@@ -334,11 +334,11 @@ BattlescapeState::BattlescapeState(Game *game) : State(game), _popups()
 	// Set music
 	_game->getResourcePack()->getRandomMusic("GMTACTIC")->play();
 
-	_animTimer = new Timer(DEFAULT_ANIM_SPEED);
+	_animTimer = new Timer(DEFAULT_ANIM_SPEED, true);
 	_animTimer->onTimer((StateHandler)&BattlescapeState::animate);
 	_animTimer->start();
 
-	_gameTimer = new Timer(DEFAULT_ANIM_SPEED);
+	_gameTimer = new Timer(DEFAULT_ANIM_SPEED, true);
 	_gameTimer->onTimer((StateHandler)&BattlescapeState::handleState);
 	_gameTimer->start();
 
 
@@ -549,4 +549,17 @@ bool Game::getShiftKeyDown()
 {
 	return _shiftKeyDown;
 }
+
+
+/**
+ * @brief Returns whether current state is *state
+ * @param state The state to test against the stack state
+ */
+ const bool Game::isState(State *state) const
+{
+	return _states.size() > 0 && _states.back() == state;
+}
+
+
+
 }
@@ -111,6 +111,8 @@ class Game
 	static void setShiftKeyDown(bool shiftKey);
 	/// Returns whether the Shift key is down
 	static bool getShiftKeyDown();
+	/// Returns whether current state is the param state
+	const bool isState(State *state) const;
 };
 
 }
 
@@ -66,6 +66,7 @@ void createDefault()
 	setBool("asyncBlit", true);
 	setInt("keyboardMode", KEYBOARD_ON);
 #endif
+	setInt("maxFrameSkip", 8);
 	setBool("traceAI", false);
 	setBool("sneakyAI", false);
 	setInt("baseXResolution", 320);
 
@@ -76,6 +76,8 @@ class State
 	const LocalizedText &tr(const std::string &id) const;
 	/// Get the localized text.
 	LocalizedText tr(const std::string &id, unsigned n) const;
+	
+	friend class Timer;
 };
 
 }
 
@@ -17,28 +17,35 @@
  * along with OpenXcom.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include "Timer.h"
+#include "Game.h"
+#include "Options.h"
+#include <assert.h>
 
 namespace OpenXcom
 {
 
 const Uint32 accurate = 4;
-Uint32 slownes = 1;
+Uint32 slowness = 1;
 Uint32 slowTick()
 {
 	static Uint32 old_time = SDL_GetTicks();
 	static Uint64 false_time = old_time << accurate;
-	Uint32 new_time = SDL_GetTicks() << accurate;
-	false_time += (new_time - old_time) / slownes;
+	Uint64 new_time = ((Uint64)SDL_GetTicks()) << accurate;
+	false_time += (new_time - old_time) / slowness;
 	old_time = new_time;
 	return false_time >> accurate;
 }
+
+int Timer::maxFrameSkip = 8; // this is a pretty good default at 60FPS. 
+	
 
 /**
  * Initializes a new timer with a set interval.
  * @param interval Time interval in milliseconds.
  */
-Timer::Timer(Uint32 interval) : _start(0), _interval(interval), _running(false), _state(0), _surface(0)
+Timer::Timer(Uint32 interval, bool frameSkipping) : _start(0), _interval(interval), _running(false), _state(0), _surface(0), _frameSkipping(frameSkipping)
 {
+	Timer::maxFrameSkip = Options::getInt("maxFrameSkip");
 }
 
 /**
@@ -53,7 +60,7 @@ Timer::~Timer()
  */
 void Timer::start()
 {
-	_start = slowTick();
+	_frameSkipStart = _start = slowTick();
 	_running = true;
 }
 
@@ -96,19 +103,31 @@ bool Timer::isRunning() const
  */
 void Timer::think(State* state, Surface* surface)
 {
+	Sint64 now = slowTick(); // must be signed to permit negative numbers
+	Game *game = state ? state->_game : 0; // this is used to make sure we stop calling *_state on *state in the loop once *state has been popped and deallocated
+	//assert(!game || game->isState(state));
+
 	if (_running)
 	{
-		if (getTime() >= _interval)
+		if ((now - _frameSkipStart) >= _interval)
 		{
-			if (state != 0 && _state != 0)
+			for (int i = 0; i < maxFrameSkip && isRunning() && (now - _frameSkipStart) >= _interval; ++i)
 			{
-				(state->*_state)();
+				if (state != 0 && _state != 0)
+				{
+					(state->*_state)();
+				}
+				_frameSkipStart += _interval;
+				// breaking here after one iteration effectively returns this function to its old functionality:
+				if (!game || !_frameSkipping || !game->isState(state)) break; // if game isn't set, we can't verify *state
 			}
-			if (surface != 0 && _surface != 0)
+			
+			if (_running && surface != 0 && _surface != 0)
 			{
 				(surface->*_surface)();
 			}
 			_start = slowTick();
+			if (_start > _frameSkipStart) _frameSkipStart = _start; // don't play animations in ffwd to catch up :P
 		}
 	}
 }
@@ -140,4 +159,11 @@ void Timer::onTimer(SurfaceHandler handler)
 	_surface = handler;
 }
 
+
+/// Sets frame skipping on or off
+void Timer::setFrameSkipping(bool skip)
+{
+	_frameSkipping = skip;
+}
+
 }
@@ -36,14 +36,20 @@ typedef void (Surface::* SurfaceHandler)();
  */
 class Timer
 {
+public:
+	static int maxFrameSkip;
+	
 private:
-	Uint32 _start, _interval;
+	Uint32 _start;
+	Uint32 _frameSkipStart;
+	int _interval;
 	bool _running;
+	bool _frameSkipping;
 	StateHandler _state;
 	SurfaceHandler _surface;
 public:
 	/// Creates a stopped timer.
-	Timer(Uint32 interval);
+	Timer(Uint32 interval, bool frameSkipping = false);
 	/// Cleans up the timer.
 	~Timer();
 	/// Starts the timer.
@@ -62,6 +68,8 @@ class Timer
 	void onTimer(StateHandler handler);
 	/// Hooks a surface action handler to the timer interval.
 	void onTimer(SurfaceHandler handler);
+	/// Turns frame skipping on or off
+	void setFrameSkipping(bool skip);
 };
 
 }
Original file line number	Diff line number	Diff line change
`@@ -549,4 +549,17 @@ bool Game::getShiftKeyDown()`
`549`	`549`	`{`
`550`	`550`	`return _shiftKeyDown;`
`551`	`551`	`}`
	`552`	`+`
	`553`	`+`
	`554`	`+/**`
	`555`	`+ * @brief Returns whether current state is *state`
	`556`	`+ * @param state The state to test against the stack state`
	`557`	`+ */`
	`558`	`+ const bool Game::isState(State *state) const`
	`559`	`+{`
	`560`	`+ return _states.size() > 0 && _states.back() == state;`
	`561`	`+}`
	`562`	`+`
	`563`	`+`
	`564`	`+`
`552`	`565`	`}`
Original file line number	Diff line number	Diff line change
`@@ -111,6 +111,8 @@ class Game`
`111`	`111`	`static void setShiftKeyDown(bool shiftKey);`
`112`	`112`	`/// Returns whether the Shift key is down`
`113`	`113`	`static bool getShiftKeyDown();`
	`114`	`+ /// Returns whether current state is the param state`
	`115`	`+ const bool isState(State *state) const;`
`114`	`116`	`};`
`115`	`117`
`116`	`118`	`}`
Original file line number	Diff line number	Diff line change
`@@ -76,6 +76,8 @@ class State`
`76`	`76`	`const LocalizedText &tr(const std::string &id) const;`
`77`	`77`	`/// Get the localized text.`
`78`	`78`	`LocalizedText tr(const std::string &id, unsigned n) const;`
	`79`	`+`
	`80`	`+ friend class Timer;`
`79`	`81`	`};`
`80`	`82`
`81`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,28 +17,35 @@`
`17`	`17`	`* along with OpenXcom. If not, see <http://www.gnu.org/licenses/>.`
`18`	`18`	`*/`
`19`	`19`	`#include "Timer.h"`
	`20`	`+#include "Game.h"`
	`21`	`+#include "Options.h"`
	`22`	`+#include <assert.h>`
`20`	`23`
`21`	`24`	`namespace OpenXcom`
`22`	`25`	`{`
`23`	`26`
`24`	`27`	`const Uint32 accurate = 4;`
`25`		`-Uint32 slownes = 1;`
	`28`	`+Uint32 slowness = 1;`
`26`	`29`	`Uint32 slowTick()`
`27`	`30`	`{`
`28`	`31`	`static Uint32 old_time = SDL_GetTicks();`
`29`	`32`	`static Uint64 false_time = old_time << accurate;`
`30`		`- Uint32 new_time = SDL_GetTicks() << accurate;`
`31`		`- false_time += (new_time - old_time) / slownes;`
	`33`	`+ Uint64 new_time = ((Uint64)SDL_GetTicks()) << accurate;`
	`34`	`+ false_time += (new_time - old_time) / slowness;`
`32`	`35`	`old_time = new_time;`
`33`	`36`	`return false_time >> accurate;`
`34`	`37`	`}`
	`38`	`+`
	`39`	`+int Timer::maxFrameSkip = 8; // this is a pretty good default at 60FPS.`
	`40`	`+`
`35`	`41`
`36`	`42`	`/**`
`37`	`43`	`* Initializes a new timer with a set interval.`
`38`	`44`	`* @param interval Time interval in milliseconds.`
`39`	`45`	`*/`
`40`		`-Timer::Timer(Uint32 interval) : _start(0), _interval(interval), _running(false), _state(0), _surface(0)`
	`46`	`+Timer::Timer(Uint32 interval, bool frameSkipping) : _start(0), _interval(interval), _running(false), _state(0), _surface(0), _frameSkipping(frameSkipping)`
`41`	`47`	`{`
	`48`	`+ Timer::maxFrameSkip = Options::getInt("maxFrameSkip");`
`42`	`49`	`}`
`43`	`50`
`44`	`51`	`/**`
`@@ -53,7 +60,7 @@ Timer::~Timer()`
`53`	`60`	`*/`
`54`	`61`	`void Timer::start()`
`55`	`62`	`{`
`56`		`- _start = slowTick();`
	`63`	`+ _frameSkipStart = _start = slowTick();`
`57`	`64`	`_running = true;`
`58`	`65`	`}`
`59`	`66`
`@@ -96,19 +103,31 @@ bool Timer::isRunning() const`
`96`	`103`	`*/`
`97`	`104`	`void Timer::think(State* state, Surface* surface)`
`98`	`105`	`{`
	`106`	`+ Sint64 now = slowTick(); // must be signed to permit negative numbers`
	`107`	`+ Game game = state ? state->_game : 0; // this is used to make sure we stop calling _state on state in the loop once state has been popped and deallocated`
	`108`	`+ //assert(!game \|\| game->isState(state));`
	`109`	`+`
`99`	`110`	`if (_running)`
`100`	`111`	`{`
`101`		`- if (getTime() >= _interval)`
	`112`	`+ if ((now - _frameSkipStart) >= _interval)`
`102`	`113`	`{`
`103`		`- if (state != 0 && _state != 0)`
	`114`	`+ for (int i = 0; i < maxFrameSkip && isRunning() && (now - _frameSkipStart) >= _interval; ++i)`
`104`	`115`	`{`
`105`		`- (state->*_state)();`
	`116`	`+ if (state != 0 && _state != 0)`
	`117`	`+ {`
	`118`	`+ (state->*_state)();`
	`119`	`+ }`
	`120`	`+ _frameSkipStart += _interval;`
	`121`	`+ // breaking here after one iteration effectively returns this function to its old functionality:`
	`122`	`+ if (!game \|\| !_frameSkipping \|\| !game->isState(state)) break; // if game isn't set, we can't verify *state`
`106`	`123`	`}`
`107`		`- if (surface != 0 && _surface != 0)`
	`124`	`+`
	`125`	`+ if (_running && surface != 0 && _surface != 0)`
`108`	`126`	`{`
`109`	`127`	`(surface->*_surface)();`
`110`	`128`	`}`
`111`	`129`	`_start = slowTick();`
	`130`	`+ if (_start > _frameSkipStart) _frameSkipStart = _start; // don't play animations in ffwd to catch up :P`
`112`	`131`	`}`
`113`	`132`	`}`
`114`	`133`	`}`
`@@ -140,4 +159,11 @@ void Timer::onTimer(SurfaceHandler handler)`
`140`	`159`	`_surface = handler;`
`141`	`160`	`}`
`142`	`161`
	`162`	`+`
	`163`	`+/// Sets frame skipping on or off`
	`164`	`+void Timer::setFrameSkipping(bool skip)`
	`165`	`+{`
	`166`	`+ _frameSkipping = skip;`
	`167`	`+}`
	`168`	`+`
`143`	`169`	`}`