CODEWITHSUNDEEP
androidbackgrounddrawing2d
Stevanicus
Stevanicus

Reputation: 7761

Android game scrolling background

I'm just trying to figure out the best approach for running a scolling background on an android device. The method I have so far.... its pretty laggy. I use threads, which I believe is not the best bet for android platforms

@Override
    public void run() {
        // Game Loop
        while(runningThread){
            //Scroll background down
            bgY += 1;

            try {
                this.postInvalidate();
                t.sleep(10);
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

where postinvalidate in the onDraw function simply pushings the background image down

canvas.drawBitmap(backgroundImage, bgX, bgY, null);

Thanks in advance

UPDATE

I've identified the problem. And it is the fact that my player updates the same rate as the background scrolls (making it look choppy). from top to bottom. This is because both get drawn in the same function. I'm not really sure how to tackle this and would be grateful for any help. i.e so that player movement is handled separately from the map scrolling

Also how can I control the speed at which onDraw(canvas) get called?

Thanks in advance.

However, I have patched together a different run loop for anyone having the same problem. This is partially from the jetboy example on google.

Below is my inner class in my surfaceview

class MapThread extends Thread{
    private Map map;
    private SurfaceHolder holder;
    private boolean run = false;

    public MapThread(Map map, SurfaceHolder holder){
        this.holder = holder;
        this.map = map;
        setRunning(true);
    }

    public void setRunning(boolean run){
        this.run = run;
    }

    @Override
    public void run(){
        while(run){
            try{
                Canvas c = null;

                 try {
                       c = holder.lockCanvas(null);
                       synchronized (holder) {
                            map.onDraw(c);
                     }
                 } finally {

                     if (c != null) {
                         holder.unlockCanvasAndPost(c);
                     }
                 }
        }
    }
}

SOLUTION

https://gamedev.stackexchange.com/questions/8127/android-game-scrolling-background

Upvotes: 4

Views: 7921

Answers (3)

a54studio
a54studio

Reputation: 975

I am using this method on the second level of my SpaceQuestAlpha game. This makes a seemless scroll.

I used the 2 lines below to set original position.

              moony=0;
              moon2y=-(heighty);

Then these lines increment both versions of the background image. One starts at 0 and one starts at negative screen height. Every time one of the images goes below the bottom of the screen it is moved up twice the height to move it back into position. I am using surface view with no latency issues. 

              moony+=5;
              moon2y+=5;


                 if(moon2y>=heighty) {moon2y=moon2y-(heighty*2);}
                     canvas.drawBitmap(lavabackground, 0, moon2y, null); 
                 if(moony>=heighty){moony=moony-(heighty*2);}
                     canvas.drawBitmap(lavabackground, 0, moony, null);

Upvotes: 0

f20k
f20k

Reputation: 3106

Use the SurfaceView implementation draw on the screen. It allows you more control of what to draw and when.

The SurfaceView is a special subclass of View that offers a dedicated drawing surface within the View hierarchy. The aim is to offer this drawing surface to an application's secondary thread, so that the application isn't required to wait until the system's View hierarchy is ready to draw.

The basic design is to have a surfaceview that draws continuously in a while loop. Then add an if-statement whose condition is to be true if a timer thread tells you its time to draw. Say, every 30ms, draw the bitmap. This will give you about 33 fps.

Now you may also have another timer thread that tells you when to update the the bgX or bgY values. Say at every 60ms, it will set a boolean updateFlag = true; Then in your main thread, you have an if-statement check this flag, set it to false, and update your bgX and bgY values. By accurately controlling the timer and the bgX/bgY increments, you should be able to produce smooth animations.

It would be a good idea to look at the LunarLander source code provided by Google.

Upvotes: 3

Cheryl Simon
Cheryl Simon

Reputation: 46844

One thing to keep in mind is that sleep is very inaccurate. To work around this, you can keep track of exactly how much time passed during the sleep and update how much you move things accordingly.

Its not clear from you code, but you need to make sure that all of your UI updates happen in the UI thread.

You do need to do your timing outside of the UI thread, because otherwise the UI will never update. There are other methods of timing, like using a Handler that can be a little bit cleaner, but I think the overhead on them might be a bit much for what you are trying to do. I think a simple thread has the least amount of overhead.

Upvotes: 0

Related Questions