fixed event trigger

rlux · rlux · commit 8975ced99792 · 2013-04-25T17:52:02.000+02:00
diff --git a/include/Engine.h b/include/Engine.h
@@ -6,7 +6,6 @@
 #include <tmx/TileLayer.h>
 
 #include <QList>
-#include <QHash>
 #include <QSet>
 
 class Game;
@@ -22,13 +21,11 @@ protected slots:
 	void mapChanged();
 protected:
 	Game* _game;
-	QHash<AnimatedObject*, QSet<EventTrigger*>> _currentTriggers;
 
 	void moveObjects(double delta);
 	void moveObject(AnimatedObject* object, double delta);
 
-	void checkTriggers(AnimatedObject* object);
-	QSet<EventTrigger*> triggersFor(AnimatedObject* object);
+	void checkTriggers(AnimatedObject* object, QSet<EventTrigger*>& currentTriggers);
 
 	tmx::TileLayer* walkableLayer();
 	bool canBeAt(AnimatedObject* object, const QPointF& pos);
diff --git a/include/EventTrigger.h b/include/EventTrigger.h
@@ -7,7 +7,6 @@
 #include <QSize>
 #include <QRectF>
 #include <QHash>
-#include <QSet>
 
 #include <tmx/Object.h>
 
@@ -28,10 +27,9 @@ class EventTrigger : public QObject
 	const QSize& size() const;
 	void setSize(const QSize& size);
 
-	void ignore(AnimatedObject* object);
+	bool intersects(const QRectF& rect);
 
 	void enter(AnimatedObject* object);
-	void move(AnimatedObject* object);
 	void exit(AnimatedObject* object);
 signals:
 	void triggered(MapEvent* event);
@@ -41,7 +39,6 @@ class EventTrigger : public QObject
 	QString _name;
 	QString _type;
 	QHash<QString, QString> _properties;
-	QSet<AnimatedObject*> _ignored;
 
 	void trigger(AnimatedObject* object);
 	void trigger(MapEvent* event);
diff --git a/include/Game.h b/include/Game.h
@@ -3,6 +3,7 @@
 #include <QKeyEvent>
 #include <QSet>
 #include <QHash>
+#include <QQueue>
 
 #include <GameRenderer.h>
 #include <Engine.h>
@@ -34,7 +35,7 @@ class Game : public QObject
 signals:
 	void mapChanged();
 protected slots:
-	void processMapEvent(MapEvent* event);
+	void queueMapEvent(MapEvent* event);
 protected:
 	Map* _currentMap;
 	Player _player;
@@ -43,6 +44,10 @@ protected slots:
 	QHash<QString, Map*> _maps;
 	Engine* _engine;
 	GameRenderer* _renderer;
+	QQueue<MapEvent*> _mapEvents;
+
+	void processMapEvents();
+	void handleMapEvent(MapEvent* event);
 
 	Map* obtainMap(const QString& name);
 };
diff --git a/src/Engine.cpp b/src/Engine.cpp
@@ -15,9 +15,6 @@ Engine::Engine(Game* game)
 
 void Engine::mapChanged()
 {
-	for (EventTrigger* trigger: _currentTriggers[_game->player()]) trigger->exit(_game->player());
-	_currentTriggers.clear();
-	for (EventTrigger* trigger: _game->currentMap()->triggersIn(_game->player()->rect())) trigger->ignore(_game->player());
 }
 
 void Engine::update(double delta)
@@ -48,14 +45,14 @@ void Engine::moveObject(AnimatedObject* object, double delta)
 
 	QList<QPointF> points = wayPoints(object, distance);
 
+	QSet<EventTrigger*> currentTriggers = _game->currentMap()->triggersIn(object->marginedRect());
+
 	for (const QPointF point: points)
 	{
 		if (canBeAt(object, point) || !canBeAt(object, object->position()))
 		{
 			object->setPosition(point);
-			checkTriggers(object);
-
-			if (object->position()!=point) break;
+			checkTriggers(object, currentTriggers);
 		}
 		else
 		{
@@ -65,43 +62,33 @@ void Engine::moveObject(AnimatedObject* object, double delta)
 	}
 }
 
-void Engine::checkTriggers(AnimatedObject* object)
+void Engine::checkTriggers(AnimatedObject* object, QSet<EventTrigger*>& currentTriggers)
 {
-	if (!object->isPlayer()) return;
-
-	QSet<EventTrigger*> oldTriggers = _currentTriggers[object];
-	QSet<EventTrigger*> newTriggers = _game->currentMap()->triggersIn(object->rect());
+	QSet<EventTrigger*> newTriggers = _game->currentMap()->triggersIn(object->marginedRect());
 
-	for (EventTrigger* trigger: newTriggers-oldTriggers)
+	if (object->isPlayer())
 	{
-		trigger->enter(object);
-	}
-	for (EventTrigger* trigger: newTriggers)
-	{
-		trigger->move(object);
+		newTriggers.clear();
+		for (EventTrigger* trigger: _game->currentMap()->triggersIn(object->marginedRect()))
+		{
+			if (trigger->intersects(object->marginedRect()))
+			{
+				newTriggers<<trigger;
+			}
+		}
 	}
-	for (EventTrigger* trigger: oldTriggers-newTriggers)
+
+
+	for (EventTrigger* trigger: currentTriggers-newTriggers)
 	{
 		trigger->exit(object);
 	}
-	 _currentTriggers[object] = _game->currentMap()->triggersIn(object->rect());
-}
-
-QSet<EventTrigger*> Engine::triggersFor(AnimatedObject* object)
-{
-	QSet<EventTrigger*> triggers;
-	QRectF objectRect = object->marginedRect();
-	double objectArea = objectRect.width()*objectRect.height();
-	for (EventTrigger* trigger: _game->currentMap()->triggersIn(objectRect))
+	for (EventTrigger* trigger: newTriggers-currentTriggers)
 	{
-		QRectF triggerRect = trigger->rect();
-		double triggerArea = triggerRect.width()*triggerRect.height();
-		QRectF intersected = trigger->rect().intersected(objectRect);
-		double intersectedArea = intersected.width()*intersected.height();
-		if (intersectedArea/qMin(objectArea, triggerArea)>0.5) triggers << trigger;
+		trigger->enter(object);
 	}
 
-	return triggers;
+	currentTriggers = newTriggers;
 }
 
 tmx::TileLayer* Engine::walkableLayer()
@@ -174,6 +161,13 @@ QList<QPointF> Engine::wayPoints(AnimatedObject* object, double distance)
 		}
 	}
 
+	QSize mapSize = _game->currentMap()->internalMap()->pixelSize();
+	if (horizontal) {
+		positions << 0 << mapSize.width();
+	} else {
+		positions << 0 << mapSize.height();
+	}
+
 	if (ascending)
 	{
 		qSort(positions.begin(), positions.end(), qLess<double>());
diff --git a/src/EventTrigger.cpp b/src/EventTrigger.cpp
@@ -51,16 +51,9 @@ void EventTrigger::trigger(MapEvent* event)
 	emit(triggered(event));
 }
 
-void EventTrigger::ignore(AnimatedObject* object)
-{
-	_ignored << object;
-}
-
 void EventTrigger::trigger(AnimatedObject* object)
 {
-//	qDebug() << "trigger"<<_type <<  _name;
-
-	if (_ignored.contains(object)) return;
+	qDebug() << "trigger"<<_type <<  _name;
 
 	if (_type=="changemap")
 	{
@@ -71,35 +64,28 @@ void EventTrigger::trigger(AnimatedObject* object)
 	{
 		trigger(new TeleportEvent(object, _properties["target"]));
 	}
-
-	_ignored << object;
 }
 
 void EventTrigger::enter(AnimatedObject* object)
 {
 //	qDebug() << "enter"<<_type <<  _name;
+	trigger(object);
 }
 
-void EventTrigger::move(AnimatedObject* object)
+bool EventTrigger::intersects(const QRectF& rect)
 {
-//	qDebug() << "move"<<_type <<  _name;
+	QRectF triggerRect = this->rect();
 
-	QRectF objectRect = object->marginedRect();
-	double objectArea = objectRect.width()*objectRect.height();
+	if (triggerRect.contains(rect)) return true;
 
-	QRectF triggerRect = rect();
-	double triggerArea = triggerRect.width()*triggerRect.height();
-	QRectF intersected = triggerRect.intersected(objectRect);
-	double intersectedArea = intersected.width()*intersected.height();
+	QRectF intersected = triggerRect.intersected(rect);
 
-	double ratio = intersectedArea/qMin(objectArea, triggerArea);
+	double p = qMax(intersected.width()/triggerRect.width(), intersected.height()/triggerRect.height());
 
-	if (ratio>0.5) trigger(object);
+	return p>0.5;
 }
 
 void EventTrigger::exit(AnimatedObject* object)
 {
 //	qDebug() << "exit" << _type <<  _name;
-
-	_ignored.remove(object);
 }
diff --git a/src/Game.cpp b/src/Game.cpp
@@ -22,6 +22,7 @@ Game::~Game()
 void Game::update(double delta)
 {
 	_engine->update(delta);
+	processMapEvents();
 }
 
 void Game::render(QPainter& painter)
@@ -91,18 +92,33 @@ void Game::handleKeyRelease(QKeyEvent* event)
 	}
 }
 
-void Game::processMapEvent(MapEvent* event)
+void Game::queueMapEvent(MapEvent* event)
+{
+	_mapEvents.enqueue(event);
+}
+
+void Game::processMapEvents()
+{
+	while (!_mapEvents.isEmpty())
+	{
+		MapEvent* event = _mapEvents.dequeue();
+		handleMapEvent(event);
+		delete event;
+	}
+}
+
+void Game::handleMapEvent(MapEvent* event)
 {
 	if (MapChangeEvent* e = dynamic_cast<MapChangeEvent*>(event))
 	{
 		changeMap(e->mapName(), e->target());
+		_mapEvents.clear();
 	}
 	else if (TeleportEvent* e = dynamic_cast<TeleportEvent*>(event))
 	{
 		_currentMap->moveObjectToTarget(e->trigger(), e->target());
+		_mapEvents.clear();
 	}
-
-	delete event;
 }
 
 Map* Game::currentMap()
@@ -138,7 +154,7 @@ Map* Game::obtainMap(const QString& name)
 	{
 		Map* map = new Map("data/maps/"+name+".tmx");
 		map->initialize(_npcFactory);
-		connect(map, SIGNAL(eventTriggered(MapEvent*)), this, SLOT(processMapEvent(MapEvent*)));
+		connect(map, SIGNAL(eventTriggered(MapEvent*)), this, SLOT(queueMapEvent(MapEvent*)));
 		_maps.insert(name, map);
 	}
 
diff --git a/src/Map.cpp b/src/Map.cpp
@@ -89,6 +89,7 @@ QSet<EventTrigger*> Map::triggersIn(const QRectF& rect) const
 	for (EventTrigger* trigger: _triggers)
 	{
 		if (trigger->rect().intersects(rect))
+	//	if (trigger->intersects(rect))
 		{
 			triggers << trigger;
 		}

Original file line number	Diff line number	Diff line change
`@@ -15,9 +15,6 @@ Engine::Engine(Game* game)`
`15`	`15`
`16`	`16`	`void Engine::mapChanged()`
`17`	`17`	`{`
`18`		`- for (EventTrigger* trigger: _currentTriggers[_game->player()]) trigger->exit(_game->player());`
`19`		`- _currentTriggers.clear();`
`20`		`- for (EventTrigger* trigger: _game->currentMap()->triggersIn(_game->player()->rect())) trigger->ignore(_game->player());`
`21`	`18`	`}`
`22`	`19`
`23`	`20`	`void Engine::update(double delta)`
`@@ -48,14 +45,14 @@ void Engine::moveObject(AnimatedObject* object, double delta)`
`48`	`45`
`49`	`46`	`QList<QPointF> points = wayPoints(object, distance);`
`50`	`47`
	`48`	`+ QSet<EventTrigger*> currentTriggers = _game->currentMap()->triggersIn(object->marginedRect());`
	`49`	`+`
`51`	`50`	`for (const QPointF point: points)`
`52`	`51`	`{`
`53`	`52`	`if (canBeAt(object, point) \|\| !canBeAt(object, object->position()))`
`54`	`53`	`{`
`55`	`54`	`object->setPosition(point);`
`56`		`- checkTriggers(object);`
`57`		`-`
`58`		`- if (object->position()!=point) break;`
	`55`	`+ checkTriggers(object, currentTriggers);`
`59`	`56`	`}`
`60`	`57`	`else`
`61`	`58`	`{`
`@@ -65,43 +62,33 @@ void Engine::moveObject(AnimatedObject* object, double delta)`
`65`	`62`	`}`
`66`	`63`	`}`
`67`	`64`
`68`		`-void Engine::checkTriggers(AnimatedObject* object)`
	`65`	`+void Engine::checkTriggers(AnimatedObject* object, QSet<EventTrigger*>& currentTriggers)`
`69`	`66`	`{`
`70`		`- if (!object->isPlayer()) return;`
`71`		`-`
`72`		`- QSet<EventTrigger*> oldTriggers = _currentTriggers[object];`
`73`		`- QSet<EventTrigger*> newTriggers = _game->currentMap()->triggersIn(object->rect());`
	`67`	`+ QSet<EventTrigger*> newTriggers = _game->currentMap()->triggersIn(object->marginedRect());`
`74`	`68`
`75`		`- for (EventTrigger* trigger: newTriggers-oldTriggers)`
	`69`	`+ if (object->isPlayer())`
`76`	`70`	`{`
`77`		`- trigger->enter(object);`
`78`		`- }`
`79`		`- for (EventTrigger* trigger: newTriggers)`
`80`		`- {`
`81`		`- trigger->move(object);`
	`71`	`+ newTriggers.clear();`
	`72`	`+ for (EventTrigger* trigger: _game->currentMap()->triggersIn(object->marginedRect()))`
	`73`	`+ {`
	`74`	`+ if (trigger->intersects(object->marginedRect()))`
	`75`	`+ {`
	`76`	`+ newTriggers<<trigger;`
	`77`	`+ }`
	`78`	`+ }`
`82`	`79`	`}`
`83`		`- for (EventTrigger* trigger: oldTriggers-newTriggers)`
	`80`	`+`
	`81`	`+`
	`82`	`+ for (EventTrigger* trigger: currentTriggers-newTriggers)`
`84`	`83`	`{`
`85`	`84`	`trigger->exit(object);`
`86`	`85`	`}`
`87`		`- _currentTriggers[object] = _game->currentMap()->triggersIn(object->rect());`
`88`		`-}`
`89`		`-`
`90`		`-QSet<EventTrigger> Engine::triggersFor(AnimatedObject object)`
`91`		`-{`
`92`		`- QSet<EventTrigger*> triggers;`
`93`		`- QRectF objectRect = object->marginedRect();`
`94`		`- double objectArea = objectRect.width()*objectRect.height();`
`95`		`- for (EventTrigger* trigger: _game->currentMap()->triggersIn(objectRect))`
	`86`	`+ for (EventTrigger* trigger: newTriggers-currentTriggers)`
`96`	`87`	`{`
`97`		`- QRectF triggerRect = trigger->rect();`
`98`		`- double triggerArea = triggerRect.width()*triggerRect.height();`
`99`		`- QRectF intersected = trigger->rect().intersected(objectRect);`
`100`		`- double intersectedArea = intersected.width()*intersected.height();`
`101`		`- if (intersectedArea/qMin(objectArea, triggerArea)>0.5) triggers << trigger;`
	`88`	`+ trigger->enter(object);`
`102`	`89`	`}`
`103`	`90`
`104`		`- return triggers;`
	`91`	`+ currentTriggers = newTriggers;`
`105`	`92`	`}`
`106`	`93`
`107`	`94`	`tmx::TileLayer* Engine::walkableLayer()`
`@@ -174,6 +161,13 @@ QList<QPointF> Engine::wayPoints(AnimatedObject* object, double distance)`
`174`	`161`	`}`
`175`	`162`	`}`
`176`	`163`
	`164`	`+ QSize mapSize = _game->currentMap()->internalMap()->pixelSize();`
	`165`	`+ if (horizontal) {`
	`166`	`+ positions << 0 << mapSize.width();`
	`167`	`+ } else {`
	`168`	`+ positions << 0 << mapSize.height();`
	`169`	`+ }`
	`170`	`+`
`177`	`171`	`if (ascending)`
`178`	`172`	`{`
`179`	`173`	`qSort(positions.begin(), positions.end(), qLess<double>());`
Original file line number	Diff line number	Diff line change
`@@ -51,16 +51,9 @@ void EventTrigger::trigger(MapEvent* event)`
`51`	`51`	`emit(triggered(event));`
`52`	`52`	`}`
`53`	`53`
`54`		`-void EventTrigger::ignore(AnimatedObject* object)`
`55`		`-{`
`56`		`- _ignored << object;`
`57`		`-}`
`58`		`-`
`59`	`54`	`void EventTrigger::trigger(AnimatedObject* object)`
`60`	`55`	`{`
`61`		`-// qDebug() << "trigger"<<_type << _name;`
`62`		`-`
`63`		`- if (_ignored.contains(object)) return;`
	`56`	`+ qDebug() << "trigger"<<_type << _name;`
`64`	`57`
`65`	`58`	`if (_type=="changemap")`
`66`	`59`	`{`
`@@ -71,35 +64,28 @@ void EventTrigger::trigger(AnimatedObject* object)`
`71`	`64`	`{`
`72`	`65`	`trigger(new TeleportEvent(object, _properties["target"]));`
`73`	`66`	`}`
`74`		`-`
`75`		`- _ignored << object;`
`76`	`67`	`}`
`77`	`68`
`78`	`69`	`void EventTrigger::enter(AnimatedObject* object)`
`79`	`70`	`{`
`80`	`71`	`// qDebug() << "enter"<<_type << _name;`
	`72`	`+ trigger(object);`
`81`	`73`	`}`
`82`	`74`
`83`		`-void EventTrigger::move(AnimatedObject* object)`
	`75`	`+bool EventTrigger::intersects(const QRectF& rect)`
`84`	`76`	`{`
`85`		`-// qDebug() << "move"<<_type << _name;`
	`77`	`+ QRectF triggerRect = this->rect();`
`86`	`78`
`87`		`- QRectF objectRect = object->marginedRect();`
`88`		`- double objectArea = objectRect.width()*objectRect.height();`
	`79`	`+ if (triggerRect.contains(rect)) return true;`
`89`	`80`
`90`		`- QRectF triggerRect = rect();`
`91`		`- double triggerArea = triggerRect.width()*triggerRect.height();`
`92`		`- QRectF intersected = triggerRect.intersected(objectRect);`
`93`		`- double intersectedArea = intersected.width()*intersected.height();`
	`81`	`+ QRectF intersected = triggerRect.intersected(rect);`
`94`	`82`
`95`		`- double ratio = intersectedArea/qMin(objectArea, triggerArea);`
	`83`	`+ double p = qMax(intersected.width()/triggerRect.width(), intersected.height()/triggerRect.height());`
`96`	`84`
`97`		`- if (ratio>0.5) trigger(object);`
	`85`	`+ return p>0.5;`
`98`	`86`	`}`
`99`	`87`
`100`	`88`	`void EventTrigger::exit(AnimatedObject* object)`
`101`	`89`	`{`
`102`	`90`	`// qDebug() << "exit" << _type << _name;`
`103`		`-`
`104`		`- _ignored.remove(object);`
`105`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ Game::~Game()`
`22`	`22`	`void Game::update(double delta)`
`23`	`23`	`{`
`24`	`24`	`_engine->update(delta);`
	`25`	`+ processMapEvents();`
`25`	`26`	`}`
`26`	`27`
`27`	`28`	`void Game::render(QPainter& painter)`
`@@ -91,18 +92,33 @@ void Game::handleKeyRelease(QKeyEvent* event)`
`91`	`92`	`}`
`92`	`93`	`}`
`93`	`94`
`94`		`-void Game::processMapEvent(MapEvent* event)`
	`95`	`+void Game::queueMapEvent(MapEvent* event)`
	`96`	`+{`
	`97`	`+ _mapEvents.enqueue(event);`
	`98`	`+}`
	`99`	`+`
	`100`	`+void Game::processMapEvents()`
	`101`	`+{`
	`102`	`+ while (!_mapEvents.isEmpty())`
	`103`	`+ {`
	`104`	`+ MapEvent* event = _mapEvents.dequeue();`
	`105`	`+ handleMapEvent(event);`
	`106`	`+ delete event;`
	`107`	`+ }`
	`108`	`+}`
	`109`	`+`
	`110`	`+void Game::handleMapEvent(MapEvent* event)`
`95`	`111`	`{`
`96`	`112`	`if (MapChangeEvent* e = dynamic_cast<MapChangeEvent*>(event))`
`97`	`113`	`{`
`98`	`114`	`changeMap(e->mapName(), e->target());`
	`115`	`+ _mapEvents.clear();`
`99`	`116`	`}`
`100`	`117`	`else if (TeleportEvent* e = dynamic_cast<TeleportEvent*>(event))`
`101`	`118`	`{`
`102`	`119`	`_currentMap->moveObjectToTarget(e->trigger(), e->target());`
	`120`	`+ _mapEvents.clear();`
`103`	`121`	`}`
`104`		`-`
`105`		`- delete event;`
`106`	`122`	`}`
`107`	`123`
`108`	`124`	`Map* Game::currentMap()`
`@@ -138,7 +154,7 @@ Map* Game::obtainMap(const QString& name)`
`138`	`154`	`{`
`139`	`155`	`Map* map = new Map("data/maps/"+name+".tmx");`
`140`	`156`	`map->initialize(_npcFactory);`
`141`		`- connect(map, SIGNAL(eventTriggered(MapEvent)), this, SLOT(processMapEvent(MapEvent)));`
	`157`	`+ connect(map, SIGNAL(eventTriggered(MapEvent)), this, SLOT(queueMapEvent(MapEvent)));`
`142`	`158`	`_maps.insert(name, map);`
`143`	`159`	`}`
`144`	`160`
Original file line number	Diff line number	Diff line change
`@@ -89,6 +89,7 @@ QSet<EventTrigger*> Map::triggersIn(const QRectF& rect) const`
`89`	`89`	`for (EventTrigger* trigger: _triggers)`
`90`	`90`	`{`
`91`	`91`	`if (trigger->rect().intersects(rect))`
	`92`	`+ // if (trigger->intersects(rect))`
`92`	`93`	`{`
`93`	`94`	`triggers << trigger;`
`94`	`95`	`}`