1. Download our Official Android App: Forums for Android!

Apps FPS - 2D graphics game.

Discussion in 'Android Development' started by retro8, Jun 28, 2010.

  1. retro8

    retro8 Lurker
    Thread Starter
    Rank:
    None
    Points:
    5
    Posts:
    8
    Joined:
    Jun 28, 2010

    Jun 28, 2010
    8
    0
    5
    Hi guys,

    I have started making the classic game Snake, currently got the bog standard version of the game working using the 2d graphics library.

    The problem i'm having is that the game gets very laggy as the snake begins to grow. to the point where it is unplayable.


    My code is based on the work of Danuubz
    anddev.org • View topic - 2D tutorial
    Code (Text):
    1. public class gamescreen extends Activity
    2.  
    3. {      
    4.         public  int left =0, right =0, up =0, down =0;
    5.  
    6.         private Game g;
    7.         private Panel main;
    8.         private Bitmap bmap;
    9.         private Canvas offscreen;
    10.         public boolean start = true;
    11.  
    12.         private volatile boolean running = true;
    13.  
    14.     @Override
    15.     public void onCreate(Bundle savedInstanceState)
    16.  
    17.     {
    18.         super.onCreate(savedInstanceState);  
    19.         setOffscreenBitmap();
    20.         requestWindowFeature(Window.FEATURE_NO_TITLE);
    21.         main = new Panel(this);        
    22.         setContentView(main,new ViewGroup.LayoutParams(320,480));
    23.         g = new Game();
    24.         (new Thread(new AnimationLoop())).start();
    25.  
    26.     }
    27.    
    28.     private void setOffscreenBitmap()
    29.  
    30.     {
    31.          bmap = Bitmap.createBitmap(30,30,Bitmap.Config.ARGB_8888);
    32.          offscreen = new Canvas();
    33.          offscreen.setBitmap(bmap);
    34.          offscreen.drawColor(Color.RED);
    35.     }
    36.    
    37.     private synchronized void updatePhysics()
    38.     {
    39.             if(left==1)
    40.             {
    41.                 g.s.grow(0);
    42.             }
    43.             else if(right ==1)
    44.             {
    45.                 g.s.grow(1);
    46.                 left =0;
    47.                 down =0;
    48.                 up =0;
    49.             }
    50.             else if(up == 1)
    51.             {
    52.                 g.s.grow(2);
    53.                 left =0;
    54.                 right =0;
    55.                 down =0;
    56.             }
    57.             else if(down == 1)
    58.             {
    59.                 g.s.grow(3);
    60.                 up =0;
    61.                 left =0;
    62.                 right =0;
    63.             }  
    64.     }
    65.  
    66.  
    67.     private synchronized void doDraw(Canvas canvas, Paint paint)
    68.     {
    69.         if(start)
    70.                 {
    71.                         canvas.drawColor(Color.BLACK);
    72.                         canvas.drawBitmap(bmap,10,10,paint);
    73.                         start = false;
    74.                 }
    75.                 else
    76.  
    77.                 {              
    78.                     g.start();
    79.                     canvas.restore();
    80.                     Paint p = new Paint();
    81.                     p.setColor(Color.rgb(0, 255, 0));
    82.                     p.setShadowLayer(5, 10, 10, Color.rgb(0, 200,0));
    83.                     Paint p1 = new Paint();
    84.                     p1.setColor(Color.GRAY);
    85.                     for(int i =0; i <32; i++)
    86.                     {
    87.                         for(int j =0; j <44;j++)
    88.                         {
    89.                             if(g.b[i][j].p instanceof Food)
    90.                             {
    91.                                 canvas.drawRect(i*10,(j*10)+40,(i*10)+10,(j*10)+50,p1);
    92.                             }
    93.                             Segment seg;
    94.                             int size = g.s.l.size();
    95.                            
    96.                             for(int a =0; a < size; a++)
    97.                             {
    98.                                 seg=g.s.l.get(a);
    99.                                
    100.                                 if(seg.getx()==i && seg.gety() ==j)
    101.                                 {
    102.                                     canvas.drawRect(i*10,(j*10)+40,(i*10)+10,(j*10)+50,p);
    103.                                     break;
    104.                                 }
    105.                             }
    106.                         }
    107.                     }
    108.                 }
    109.     }
    110.    
    111.  
    112.    
    113.  
    114.     @Override
    115.  
    116.     public boolean onKeyDown(int keyCode, KeyEvent event)
    117.     {
    118.         if(keyCode == KeyEvent.KEYCODE_DPAD_CENTER)
    119.         {
    120.                 if(running)
    121.                 {
    122.                         running = false;
    123.                 }
    124.                 else
    125.                 {
    126.                         running = true;
    127.                 }
    128.         }
    129.         else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT)
    130.         {
    131.                 left=1;
    132.                 right =0;
    133.                 up =0;
    134.                 down =0;
    135.         }
    136.         else if (keyCode == KeyEvent.KEYCODE_DPAD_UP)    
    137.         {
    138.             left=0;
    139.             right =0;
    140.             up =1;
    141.             down =0;
    142.         }
    143.         else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT)     
    144.         {
    145.  
    146.             left=0;
    147.             right =1;
    148.             up =0;
    149.             down =0;
    150.         }
    151.         else if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN)  
    152.         {
    153.             left=0;
    154.             right =0;
    155.             up =0;
    156.             down =1;
    157.         }
    158.         return true;
    159.     }
    160.    
    161.     class Panel extends View
    162.     {
    163.         Paint paint;
    164.        
    165.         public Panel(Context context)
    166.         {
    167.                 super(context);
    168.  
    169.                 paint = new Paint();
    170.                 paint.setColor(Color.WHITE);
    171.         }
    172.  
    173.         @Override
    174.         protected void onDraw(Canvas canvas)
    175.         {
    176.                 doDraw(canvas,paint);
    177.         }
    178.     }
    179.     class AnimationLoop implements Runnable
    180.     {
    181.         public void run()
    182.         {
    183.                 while(true)
    184.                 {
    185.                         while(running)
    186.                         {                                      
    187.                                 try
    188.                                 {
    189.                                       Thread.sleep(90);
    190.                                 }
    191.                                 catch(InterruptedException ex) {}
    192.                                 updatePhysics();
    193.                                 main.postInvalidate();
    194.                         }
    195.                 }
    196.         }
    197.     }    
    198. }

    This is the code I am using.

    It currently draws a Green Square for A snake body part and a grey square for a powerup (food).

    I have done this game before on C# and I had the same problem until I started using Offscreen Bitmaps like here. But it isnt working here.
    Is their a better way of doing this, as I am hitting some serious Lag.

    Cheers
     

    Advertisement

Share This Page

Loading...