Take the 2-minute tour ×
Game Development Stack Exchange is a question and answer site for professional and independent game developers. It's 100% free, no registration required.

How can I implement the fast forward feature for my tower defense game like in http://fieldrunners.com/ and other TD games?

I am using Unity 3D. Would there be something to manage fewer frames per second or some kind of manually set fast movement of enemies and tower firing speed, et cetera?

share|improve this question
    
have you tried to increase the update frequency ?? you may need to skip frames.. –  concept3d Dec 20 '11 at 14:20
add comment

3 Answers

up vote 2 down vote accepted

if your game doesn't have complicated or computationally expensive simulations that require separating them into independent update timelines, you can use a simple approach of basing the code in your Update() functions on Unity's Time.time value, and in your code set the value of Time.timeScale to be whatever you want. 0 == paused, 1 = normal, our testers love to set timeScale > 1 to get things done faster.

http://unity3d.com/support/documentation/ScriptReference/Time-timeScale.html

share|improve this answer
add comment

Approach: Higher simulation rate

Your timing for your user interface should be decoupled from your actual game loop, as should your rendering. Say for example your world runs at 4x speed. Lets say that at your basic (1x) speed, your game runs 30 updates per second.

You would then have something like the following, when in fast-forward mode:

  • World logic runs 4 updates for every update of UI and renderer. This means it needs to run 120 updates per second. Thus, your world model (data) is updated at this rate.
  • Renderer and UI logic both continue to poll or do whatever at 30 updates per second.

In other words, the game as a whole is not running faster. The simulation part is.

You can deduce two things from this:

  1. You need to keep your game logic simple enough that you can easily run it four times faster on your target platform, OR you need to introduce methods to extrapolate various aspects of gameplay more quickly -- this can result, though, in a model that is different from what it would have been if you had simply used a more rapidly paced simulation. So the tradeoff would be processing cost for accuracy. See approach 2, below.

  2. It is the separation of concerns that allows you to easily speed up your world simulation, that separation being model, view and controller (MVC). If your world data(M), render logic(V), and game logic(C) are all mixed up, you really won't be able to do this, at least not without a massive migraine.

Approach: Extrapolation based on time deltas

As mentioned above, you'll need to calculate motion based on how far something would have travelled in a given time. This assumes your game physics are inherently more realistic in their simulation, however, which may not be the case. This is a rather larger topic and considerably more complex. You'll need to ask more questions about if you want to know. Essentially, you'll be doing some calculus to get things right. You'll need to deal with interpenetration in collisions and a host of other issues I won't go into here.

To conclude

This gives you the general outline. Your language choice is your own, presumably you either know how to do that in Unity or you don't. Timing in any language requires you to understand the ins and outs in detail, I'd suggest starting with Gaffer's articles and checking out the Unity API docs.

share|improve this answer
    
If you are going to use the higher simulation rate approach, and you want to support slowdown, you probably need to actually have an extremely slow base simulation rate, then run that by default at like 100 simulation steps/frame. –  bobobobo Nov 18 '13 at 18:06
add comment

As a general principle, the update of game logic should be decoupled from the update of the game's graphics -- that is, simulation of your gameplay, AI, unit movement, et cetera should not be tied to the speed at which the game is rendering. Usually the main game loop computes how much real time had elapsed since the last game update, and sends that delta time step to the update routines of each individual game logic object.

In such a scenario, it becomes simple to implement time scaling (including fast-forwarding) in your game. Simply premultiply the game logic time step by some scalar value that controls how much to "fast-foward" or slow down time. By default this value would be one, and for example once the user hits the "fast forward" key you set it to 1.5, and all simulation would appear to go 50% faster. You would still render at the same rate, however.

I am not extremely familiar with Unity and thus could be wrong in the following suggestion, but Unity does have a time management component which may be useful for implementing this. It in fact already has a timescale property. The description of the component implies that the class was designed for physics objects, but it may be applicable to your scenario as well.

share|improve this answer
1  
It is definitely applicable to his scenerio. All he would need to do is set Time.timeScale to some multiplier and everything will just go faster. It's an across the board change, so if there are things like menu interactions and such they'll also go faster, though. –  Tetrad Dec 20 '11 at 17:20
    
thnx again Tetrad :) –  Syed Dec 22 '11 at 10:43
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.