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?
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
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:
In other words, the game as a whole is not running faster. The simulation part is.
You can deduce two things from this:
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.
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.
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.
