Question

To use a SurfaceView for drawing a 2D game in Android, I use this in the main activity’s onCreate():

setContentView(new GameView(this));

Which is a reference to this class:

public class GameView extends SurfaceView implements SurfaceHolder.Callback

Additionally, I have a thread with its run() function:

public void run() {
    Canvas c;
    while (_run) {
        c = null;
        try {
            c = _surfaceHolder.lockCanvas(null);
            synchronized (_surfaceHolder) {
                _panel.updatePhysics();
                _panel.onDraw(c);
            }
        }
        finally { // when exception is thrown above we may not leave the surface in an inconsistent state
            if (c != null) {
                _surfaceHolder.unlockCanvasAndPost(c);
            }
        }
    }
}

In updatePhysics() I do some calculations. They are more complex than this simple example, of course, but work the same way:

public void updatePhysics() {
    GraphicObject.Coordinates coord;
    GraphicObject.Speed speed;
    for (GraphicObject graphic : _allElements) {
        coord = graphic.getCoordinates();
        speed = graphic.getSpeed();
        coord.setX(coord.getX() + speed.getX());
        coord.setY(coord.getY() + speed.getY());
        ...
    }
}

And in onDraw(), I draw everything to the canvas:

@Override
public void onDraw(Canvas canvas) {
    canvas.drawBitmap(BITMAP, xPos, yPos, null);
    ...
}

This works fine – everything. And when I tested it on my device, it looked pretty good. But when I gave it to someone else and he did a test game, the objects were moving much faster! Why is this so? Because the thread calls updatePhysics() as often as possible which means that fast devices call this function more often?

How can I prevent this and make the game equally fast on all devices? Something like this?

private long lastRun = System.currentTimeMillis();

public void updatePhysics() {
    long millisPassed = System.currentTimeMillis()-lastRun;
    ...
    float newCoord = (coord.getX() + speed.getX()) * millisPassed / 33;
    coord.setX(newCoord);
    ...
}

Thanks for your help!

Answer 1

If you can, use the time directly to calculate all your physics. That would usually work best.

If you have no way to calculate based on time because what you are doing that is just step based and you know that generating the next step does not take much time then you have another option.

You create two threads. The first one advances the state at a fixed rate (and you have to be sure that this works on slow devices at that rate too). The second one takes the current state is sees and draws that. Now the second thread can be as slow as it wants because it simply skips some states (or draws the same state several times if it is faster).

Small example below has one thread that advances some state object and replaces the reference each time so the consuming thread does not need to worry that it’s state object gets modified

class GameState {
    private int state = 0;

    public GameState advanceState() {
        GameState result = new GameState();
        result.state = this.state + 1;
        return result;
    }
}

class SurfaceViewImplementation extends SurfaceView {

    // the current state
    volatile GameState mState = new GameState();

    void somewhere() {
        Thread fastProducer = new Thread(new Runnable() {
            private static final long MAX_WAIT = 1000 / 60; 
            @Override
            public void run() {
                while (!Thread.interrupted()) {
                    long timeBefore = SystemClock.currentThreadTimeMillis();
                    GameState newState = mState.advanceState();
                    mState = newState;
                    long timeAfter = SystemClock.currentThreadTimeMillis();
                    long timeSpent = timeAfter - timeBefore;
                    SystemClock.sleep(Math.max(0, MAX_WAIT - timeSpent));
                }
            }
        });
        fastProducer.start();
        Thread slowConsumer = new Thread(new Runnable() {
            @Override
            public void run() {
                while (!Thread.interrupted()) {
                    GameState currentState = mState;
                    longRunningDraw(currentState);
                }
            }
        });
        slowConsumer.start();
    }
}

That will still fail to give you a speed independant result if the producing thread can’t run at the desired rate.