fife-parpg: engine/core/model/structures/instance.cpp comparison

comparison engine/core/model/structures/instance.cpp @ 181:56ac89189bc4

fixed time handling in fife: - the time scaling method was unreliable when changing the time factors (jumping in the moment of the change) - replaced much calls to SDL_GetTicks with TimerManager::instance()->getTime() - some other time related cleanup

author	spq@33b003aa-7bff-0310-803a-e67f0ece8222
date	Sat, 31 Jan 2009 04:15:43 +0000
parents	64e7fe3d4288
children	3d0cc4545938

comparison

equal deleted inserted replaced

-:66bd7f8c541e
+:56ac89189bc4
 // First block: files included from the FIFE root src directory
 // Second block: files included from the same folder
 #include "util/log/logger.h"
 #include "util/base/exception.h"
 #include "util/math/fife_math.h"
+#include "util/time/timemanager.h"
 #include "model/metamodel/grids/cellgrid.h"
 #include "model/metamodel/abstractpather.h"
 #include "model/metamodel/action.h"
 #include "model/metamodel/timeprovider.h"
 #include "model/structures/layer.h"
 		ActionInfo(AbstractPather* pather, const Location& curloc):
 			m_action(NULL),
 			m_target(NULL),
 			m_speed(0),
 			m_repeating(false),
-			m_action_start_time(SDL_GetTicks()),
+			m_action_start_time(0),
-			m_prev_call_time(m_action_start_time),
+			m_prev_call_time(0),
 			m_pather_session_id(-1),
 			m_pather(pather),
 			m_leader(NULL) {}
 		~ActionInfo() {
 		bool m_repeating;
 		// action start time (ticks)
 		unsigned int m_action_start_time;
 		// ticks since last call
 		unsigned int m_prev_call_time;
-		// current time for action processing (set by Instance::update), optimized to avoid multiple calls to GetTicks
-		unsigned int m_cur_time;
 		// session id for pather
 		int m_pather_session_id;
 		// pather
 		AbstractPather* m_pather;
 		// leader for follow activity
 	class SayInfo {
 	public:
 		SayInfo(const std::string& txt, unsigned int duration):
 			m_txt(txt),
 			m_duration(duration),
-			m_start_time(SDL_GetTicks()) {
+			m_start_time(0) {}
-		}
 		std::string m_txt;
 		unsigned int m_duration;
 		unsigned int m_start_time;
 	};
 		if (!m_activity->m_actioninfo->m_action) {
 			delete m_activity->m_actioninfo;
 			m_activity->m_actioninfo = NULL;
 			throw NotFound(std::string("action ") + action_name + " not found");
 		}
+		m_activity->m_actioninfo->m_prev_call_time = m_activity->m_actioninfo->m_action_start_time = getRuntime();
 	}
 	void Instance::move(const std::string& action_name, const Location& target, const double speed) {
 		initializeChanges();
 		initalizeAction(action_name);
 		delete m_activity->m_sayinfo;
 		m_activity->m_sayinfo = NULL;
 		if (text != "") {
 			m_activity->m_sayinfo = new SayInfo(text, duration);
+			m_activity->m_sayinfo->m_start_time = getRuntime();
 		}
 	}
 	const std::string* Instance::getSayText() const {
 		if (m_activity && m_activity->m_sayinfo) {
 	bool Instance::process_movement() {
 		FL_DBG(_log, "Moving...");
 		ActionInfo* info = m_activity->m_actioninfo;
 		// timeslice for this movement
-		unsigned int timedelta = scaleTime(getTotalTimeMultiplier(), info->m_cur_time - info->m_prev_call_time);
+		unsigned int timedelta = m_activity->m_timeprovider->getGameTime() - info->m_prev_call_time;
 		FL_DBG(_log, LMsg("timedelta ") <<  timedelta << " prevcalltime " << info->m_prev_call_time);
 		// how far we can travel
 		double distance_to_travel = (static_cast<double>(timedelta) / 1000.0) * info->m_speed;
 		FL_DBG(_log, LMsg("dist ") <<  distance_to_travel);
 			return true;
 		}
 		return false;
 	}
-	InstanceChangeInfo Instance::update(unsigned int curticks) {
+	InstanceChangeInfo Instance::update() {
 		if (!m_activity) {
 			return ICHANGE_NO_CHANGES;
 		}
 		m_activity->update(*this);
 		if (!m_activity->m_timeprovider) {
 			bindTimeProvider();
 		}
-		if (curticks == 0) {
-			curticks = SDL_GetTicks();
-		}
 		ActionInfo* info = m_activity->m_actioninfo;
 		if (info) {
-			info->m_cur_time = curticks;
+			FL_DBG(_log, "updating instance");
-			FL_DBG(_log, LMsg("updating instance, ticks = ") << curticks);
 			if (info->m_target) {
 				FL_DBG(_log, "action contains target for movement");
 				// update target if needed
 				if (info->m_leader && (info->m_leader->getLocationRef() != *info->m_target)) {
 					FL_DBG(_log, "movement finished");
 					finalizeAction();
 				}
 			} else {
 				FL_DBG(_log, "action does not contain target for movement");
-				if (scaleTime(getTotalTimeMultiplier(), curticks - info->m_action_start_time) >= info->m_action->getDuration()) {
+				if (m_activity->m_timeprovider->getGameTime() - info->m_action_start_time >= info->m_action->getDuration()) {
 					if (info->m_repeating) {
-						info->m_action_start_time = curticks;
+						info->m_action_start_time = m_activity->m_timeprovider->getGameTime();
 					} else {
 						finalizeAction();
 					}
 				}
 			}
-			m_activity->m_actioninfo->m_prev_call_time = curticks;
+			m_activity->m_actioninfo->m_prev_call_time = m_activity->m_timeprovider->getGameTime();
 		}
 		if (m_activity->m_sayinfo) {
 			if (m_activity->m_sayinfo->m_duration > 0) {
-				if (scaleTime(getTotalTimeMultiplier(), curticks - m_activity->m_sayinfo->m_start_time) > m_activity->m_sayinfo->m_duration) {
+				if (m_activity->m_timeprovider->getGameTime() >= m_activity->m_sayinfo->m_start_time + m_activity->m_sayinfo->m_duration) {
 					say("");
 				}
 			}
 		}
 		return m_changeinfo;
 			//m_facinglocation->setLayerCoordinates(ModelCoordinate(1,0));
 		}
 		return *m_facinglocation;
 	}
-	int Instance::getActionRuntime() const {
+	unsigned int Instance::getActionRuntime() {
 		if (m_activity && m_activity->m_actioninfo) {
-			return SDL_GetTicks() - m_activity->m_actioninfo->m_action_start_time;
+			if(!m_activity->m_timeprovider)
-		}
+				bindTimeProvider();
-		return -1;
+			return m_activity->m_timeprovider->getGameTime() - m_activity->m_actioninfo->m_action_start_time;
-	}
+		}
+		return getRuntime();
+	}
 	void Instance::bindTimeProvider() {
 		float multiplier = 1.0;
 		if (m_activity->m_timeprovider) {
 			multiplier = m_activity->m_timeprovider->getMultiplier();
 		}
 		if (!m_activity->m_timeprovider) {
 			m_activity->m_timeprovider = new TimeProvider(NULL);
 		}
 		m_activity->m_timeprovider->setMultiplier(multiplier);
 	}
 	void Instance::refresh() {
 		initializeChanges();
 		bindTimeProvider();
 	}
 	void Instance::setTimeMultiplier(float multip) {
 		initializeChanges();
 		if (!m_activity->m_timeprovider) {
 			bindTimeProvider();
 		}
 		m_activity->m_timeprovider->setMultiplier(multip);
 	}
 	float Instance::getTimeMultiplier() {
 		if (m_activity && m_activity->m_timeprovider) {
 			return m_activity->m_timeprovider->getMultiplier();
 		}
 		return 1.0;
 	}
 	float Instance::getTotalTimeMultiplier() {
 		if (m_activity && m_activity->m_timeprovider) {
 			return m_activity->m_timeprovider->getTotalMultiplier();
 		}
+		if (m_location.getLayer()) {
+			Map* map = m_location.getLayer()->getMap();
+			if (map && map->getTimeProvider()) {
+				return map->getTimeProvider()->getTotalMultiplier();
+			}
+		}
 		return 1.0;
 	}
+	unsigned int Instance::getRuntime() {
+		if (m_activity) {
+			if(!m_activity->m_timeprovider)
+				bindTimeProvider();
+			return m_activity->m_timeprovider->getGameTime();
+		}
+		if (m_location.getLayer()) {
+			Map* map = m_location.getLayer()->getMap();
+			if (map && map->getTimeProvider()) {
+				return map->getTimeProvider()->getGameTime();
+			}
+		}
+		return TimeManager::instance()->getTime();
+	}
 }

Mercurial > fife-parpg

comparison engine/core/model/structures/instance.cpp @ 181:56ac89189bc4