public class Main extends Activity {
       public void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);

           // если хотим, чтобы приложение постоянно имело портретную ориентацию
           setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);

           // если хотим, чтобы приложение было полноэкранным
           getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);

           // и без заголовка
           requestWindowFeature(Window.FEATURE_NO_TITLE);
              
           setContentView(new GameView(this));
       }
}

setContentView(new GameView(this));

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

import towe.def.GameView.GameThread;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

public class GameView extends SurfaceView
{
       /**Объект класса GameLoopThread*/
       private GameThread mThread;
          
       public int shotX;
       public int shotY;    
          
       /**Переменная запускающая поток рисования*/
       private boolean running = false;
          
     //-------------Start of GameThread--------------------------------------------------\\
          
       public class GameThread extends Thread
       {
           /**Объект класса*/
           private GameView view;     
              
           /**Конструктор класса*/
           public GameThread(GameView view)    
           {
                 this.view = view;
           }

           /**Задание состояния потока*/
           public void setRunning(boolean run)    
           {
                 running = run;
           }

           /** Действия, выполняемые в потоке */
           public void run()
           {
               while (running)
               {
                   Canvas canvas = null;
                   try
                   {
                       // подготовка Canvas-а
                       canvas = view.getHolder().lockCanvas();
                       synchronized (view.getHolder())
                       {
                           // собственно рисование
                           onDraw(canvas);
                       }
                   }
                   catch (Exception e) { }
                   finally
                   {
                       if (canvas != null)
                       {
                        view.getHolder().unlockCanvasAndPost(canvas);
                       }
                   }
               }
           }
}

       //-------------End of GameThread--------------------------------------------------\\
          
       public GameView(Context context)    
       {
           super(context);
              
           mThread = new GameThread(this);
              
           /*Рисуем все наши объекты и все все все*/
           getHolder().addCallback(new SurfaceHolder.Callback()    
           {
              /*** Уничтожение области рисования */
                  public void surfaceDestroyed(SurfaceHolder holder)    
                  {
                   boolean retry = true;
                    mThread.setRunning(false);
                    while (retry)
                    {
                        try
                        {
                            // ожидание завершение потока
                            mThread.join();
                            retry = false;
                        }
                        catch (InterruptedException e) { }
                    }
                  }

                  /** Создание области рисования */
                  public void surfaceCreated(SurfaceHolder holder)    
                  {
                   mThread.setRunning(true);
                   mThread.start();
                  }

                  /** Изменение области рисования */
                  public void surfaceChanged(SurfaceHolder holder, int format, int width, int height)    
                  {
                  }
           });
       }
          
        /**Функция рисующая все спрайты и фон*/
       protected void onDraw(Canvas canvas) {         
             canvas.drawColor(Color.WHITE);
       }
}

import android.graphics.Bitmap;
import android.graphics.Canvas;

public class Player
{
           /**Объект главного класса*/
       GameView gameView;
               
           //спрайт
       Bitmap bmp;

       //х и у координаты рисунка
       int x;
       int y;

           //конструктор    
       public Player(GameView gameView, Bitmap bmp)
       {
           this.gameView = gameView;
           this.bmp = bmp;                    //возвращаем рисунок
              
           this.x = 0;                        //отступ по х нет
           this.y = gameView.getHeight() / 2; //делаем по центру
       }

       //рисуем наш спрайт
       public void onDraw(Canvas c)
       {
           c.drawBitmap(bmp, x, y, null);
       }
}

import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Rect;

public class Bullet
{
       /**Картинка*/
       private Bitmap bmp;
          
       /**Позиция*/
       public int x;
       public int y;
          
       /**Скорость по Х=15*/
       private int mSpeed=25;
          
       public double angle;
          
       /**Ширина*/
       public int width;
          
       /**Ввыоста*/
       public  int height;
          
       public GameView gameView;
            
          /**Конструктор*/
          public Bullet(GameView gameView, Bitmap bmp) {
                this.gameView=gameView;
                this.bmp=bmp;
                   
                this.x = 0;            //позиция по Х
                this.y = 120;          //позиция по У
                this.width = 27;       //ширина снаряда
                this.height = 40;      //высота снаряда
                   
                //угол полета пули в зависипости от координаты косания к экрану
                angle = Math.atan((double)(y - gameView.shotY) / (x - gameView.shotX));    
          }
       
          /**Перемещение объекта, его направление*/
          private void update() {              
           x += mSpeed * Math.cos(angle);         //движение по Х со скоростью mSpeed и углу заданном координатой angle
           y += mSpeed * Math.sin(angle);         // движение по У -//-
          }

         /**Рисуем наши спрайты*/
          public void onDraw(Canvas canvas) {
               update();                    //говорим что эту функцию нам нужно вызывать для работы класса
               canvas.drawBitmap(bmp, x, y, null);
          }
}

private List<Bullet> ball = new ArrayList<Bullet>();   
private Player player;

Bitmap players;

players= BitmapFactory.decodeResource(getResources(), R.drawable.player2);
player= new Player(this, guns);

   /**Функция рисующая все спрайты и фон*/
      protected void onDraw(Canvas canvas) {        
            canvas.drawColor(Color.WHITE);
              
            Iterator<Bullet> j = ball.iterator();
            while(j.hasNext()) {
             Bullet b = j.next();
             if(b.x >= 1000 || b.x <= 1000) {
              b.onDraw(canvas);
             } else {
              j.remove();
             }
            }
            canvas.drawBitmap(guns, 5, 120, null);
      }

public Bullet createSprite(int resouce) {
        Bitmap bmp = BitmapFactory.decodeResource(getResources(), resouce);
        return new Bullet(this, bmp);
      }

public boolean onTouchEvent(MotionEvent e)   
      {
       shotX = (int) e.getX();
       shotY = (int) e.getY();
         
       if(e.getAction() == MotionEvent.ACTION_DOWN)
       ball.add(createSprite(R.drawable.bullet));
         
          return true;
      }

import java.util.Random;

import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Rect;

public class Enemy   
{
      /**Х и У коорданаты*/
      public int x;   
      public int y;   
        
      /**Скорость*/
      public int speed;
        
      /**Выосота и ширина спрайта*/
      public int width;
      public int height;
        
      public GameView gameView;
      public Bitmap bmp;
        
      /**Конструктор класса*/
      public Enemy(GameView gameView, Bitmap bmp){
          this.gameView = gameView;
          this.bmp = bmp;
            
          Random rnd = new Random();
          this.x = 900;
          this.y = rnd.nextInt(300);
          this.speed = rnd.nextInt(10);
            
          this.width = 9;
          this.height = 8;
      }
        
      public void update(){
          x -= speed;
      }
        
      public void onDraw(Canvas c){
          update();
          c.drawBitmap(bmp, x, y, null);
      }
}

private List<Enemy> enemy = new ArrayList<Enemy>();

Bitmap enemies;

private Thread thred = new Thread(this);

public class GameView extends SurfaceView implements Runnable

public void run() {
          while(true) {
              Random rnd = new Random();
              try {
                  Thread.sleep(rnd.nextInt(2000));    
                  enemy.add(new Enemy(this, enemies));
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      }

enemies = BitmapFactory.decodeResource(getResources(), R.drawable.target);         
enemy.add(new Enemy(this, enemies));

Iterator<Enemy> i = enemy.iterator();
            while(i.hasNext()) {
             Enemy e = i.next();
             if(e.x >= 1000 || e.x <= 1000) {
              e.onDraw(canvas);
             } else {
              i.remove();
             }
            }

/*Проверка на столкновения*/
      private void testCollision() {
          Iterator<Bullet> b = ball.iterator();
          while(b.hasNext()) {
              Bullet balls = b.next();
              Iterator<Enemy> i = enemy.iterator();
              while(i.hasNext()) {
                 Enemy enemies = i.next();
                   
                if ((Math.abs(balls.x - enemies.x) <= (balls.width + enemies.width) / 2f)
                  && (Math.abs(balls.y - enemies.y) <= (balls.height + enemies.height) / 2f)) {
                    i.remove();
                    b.remove();
                }
              }
          }
      }