FPS - 2D graphics game.


Last Updated:

  1. retro8

    retro8 Member This Topic's Starter

    Joined:
    Jun 28, 2010
    Messages:
    8
    Likes Received:
    0
    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...