android 贪吃蛇游戏

写了一个简单的贪吃蛇游戏、、、

主要思路

一、用一个int 数组保存蛇身坐标，snake[i*2+0]为X轴，snake[i*2+1]为Y轴，

二、定蛇头的X轴和Y轴 并赋值，snake[0]+=snakeX; snake[1]+=snakeY;
蛇身移动，从蛇头开始把坐标重新赋值到下一个。

for(int i=snakeLength-1;i>0;i--){
snake[i*2+0]=snake[(i-1)*2+0];
snake[i*2+1]=snake[(i-1)*2+1];
}

三、Random 随机等到食物坐标，没有判断 和蛇身的坐标重合会怎么样。

foodX=random_food.nextInt(screen_w-snake_w);
foodY=random_food.nextInt(screen_h-snake_h)+LINE_Y;

判断蛇头是否吃到食物

if(foodX<=snake[0]&&snake[0]<=foodX+snake_w&&foodY<=snake[1]&&snake[1] <=foodY+snake_h){

return true;
}

四、判断蛇头是否死亡，主要是判断是否吃到自身和是否越界

if(snake[0]<=screen_start_w||snake[0]>=screen_w||snake[1]<=LINE_Y||snake[1]>=screen_h){
return true;
}

for(int i=2;i<snakeLength;i++){
if(snake[i*2+0]==snake[0]&&snake[i*2+1]==snake[1]){
return true;
}
}

package com.snake.view;

import java.util.Random;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

import com.snake.main.R;
import com.snake.main.SnakeActivity;

public class SnakeView extends SurfaceView implements SurfaceHolder.Callback{
    private SurfaceHolder mHolder;
   
    private static final int SLEEP_TIME=1000;
    private static final int head=0;
   
    private boolean isflag;
    private boolean snake_state;
    private final boolean snake_runing=true;
    private final boolean snake_pause=false;
   
    private Bitmap snake_head;
    private Bitmap snake_body;
    private Bitmap snake_food;
    //蛇的坐标
    private final int snake[]=new int[60];
   
    //蛇身长
    private int snakeLength;
   
    //蛇的方向
    private int direction;
    private static final int DIR_UP=0;
    private static final int DIR_RIGHT=1;   
    private static final int DIR_DOWN=2;
    private static final int DIR_LEFT=3;
   
    //蛇大小
    private int snake_h;
    private int snake_w;
   
    //屏幕宽高
    private int screen_h;
    private int screen_w;
   
    //蛇的食物坐标
    private static int foodX=120;
    private static int foodY=140;
   
   
    private static final int screen_start_w=-1;
   
    private final int LINE_Y=15;
   
    private final Random random_food=new Random();
    private final SnakeActivity snakeActivity;
    public SnakeView(Context context,AttributeSet attributeSet){
        super(context, attributeSet);
        snakeActivity=(SnakeActivity) context;
        ini();
    }
    public SnakeView(Context context,AttributeSet attributeSet,int defStyle){
        super(context, attributeSet, defStyle);
        snakeActivity=(SnakeActivity) context;
        ini();
    }
   
    public void ini(){
        mHolder=getHolder();
        mHolder.addCallback(this);
       
        setFocusable(true);
        isflag=true;
       
        snakeLength=snakeActivity.snakeStartLength;
       
        snake_state=snake_runing;
       
        snake_head=BitmapFactory.decodeResource(getResources(), R.drawable.redstar);
        snake_body=BitmapFactory.decodeResource(getResources(), R.drawable.yellowstar);
        snake_food=BitmapFactory.decodeResource(getResources(), R.drawable.greenstar);
       
        snake_h=snake_head.getHeight();
        snake_w=snake_head.getWidth();
       
        for(int i=0;i<snakeLength;i++){
            snake[i*2+0]=101-snake_h*i;
            snake[i*2+1]=101;
        }
       
    }

    private  void ondraw(){
        Canvas canvas=mHolder.lockCanvas();
        Paint mpaint=new Paint();
   
       
        float[] line={0,LINE_Y,screen_w,LINE_Y};
        //覆盖以前视图
        canvas.drawRect(0, 0, screen_w, screen_h, mpaint);
        mpaint.setColor(Color.WHITE);
        canvas.drawLines(line, mpaint);
        for(int i=0;i<snakeLength;i++){
            drawSnake(canvas,snake[i*2+0],snake[i*2+1],i,mpaint);
        }
        canvas.drawBitmap(snake_food, foodX, foodY, mpaint);
       
   
        mHolder.unlockCanvasAndPost(canvas);
       
    }
    public void drawSnake(Canvas canvas,int x,int y,int ishead,Paint paint){
        if(ishead==head){
            canvas.drawBitmap(snake_head, x, y, paint);
        }else {
            canvas.drawBitmap(snake_body, x, y, paint);
        }
    }

   
    public void SnakeRun() {
        while(isflag){
            while(snake_state){
                try {
                   
                    Thread.sleep(SLEEP_TIME);
                } catch (InterruptedException e) {
                   
                    e.printStackTrace();
                }
               
                    snakeMain();
                       snakeActivity.SnakeNum();
                    ondraw();
                   
                    postInvalidate();
               
            }
        }
       
    }

   
    public void surfaceChanged(SurfaceHolder holder, int format, int width,
            int height) {
       
       
    }
   
    public void surfaceCreated(SurfaceHolder holder) {
        screen_h=getHeight();
        screen_w=getWidth();
       
   
   
   
    }
   


    public void surfaceDestroyed(SurfaceHolder holder) {

        isflag=false;
        snake_state=snake_pause;
    }
    //屏幕事件控制蛇
    public boolean onTouchEvent(MotionEvent event) {
       
        //按蛇头的坐标和手势得到的X/Y坐标位置的判断
        return isflag;
       
    }
    //滚轮事件控制蛇
    public boolean onTrackballEvent(MotionEvent event) {
        return isflag;
       
    }
     
    //按键事件控制蛇
   
    public boolean onKeyDown(int keyCode, KeyEvent event) {
       
        if(keyCode==KeyEvent.KEYCODE_DPAD_UP){
            direction=DIR_UP;
            return true;
        }else if(keyCode==KeyEvent.KEYCODE_DPAD_RIGHT){
            direction=DIR_RIGHT;
             return true;
        }else if(keyCode==KeyEvent.KEYCODE_DPAD_DOWN){
            direction=DIR_DOWN;
             return true;
        }else if(keyCode==KeyEvent.KEYCODE_DPAD_LEFT){
            direction=DIR_LEFT;
             return true;
        }else if(keyCode==KeyEvent.KEYCODE_DPAD_CENTER){
            if(snake_state==snake_runing){
                snake_state=snake_pause;
                   return true;
            }else {
                snake_state=snake_runing;
                   return true;
            }
   
        }
   
        return super.onKeyDown(keyCode, event);
       
    }
   //主方法
    public void snakeMain(){
        int stepX=0;
        int stepY=0;
       
        switch(direction){
        case DIR_UP:
            stepY=-snake_h;
            break;
        case DIR_RIGHT:
            stepX=snake_w;
            break;
        case DIR_DOWN:
            stepY=snake_h;
            break;
        case DIR_LEFT:
            stepX=-snake_w;
            break;
       
       
        }
        snakeMove(stepX,stepY);
        if(snakeIsDead()){
            isflag=false;
            snake_state=false;
   
        }
        if(isEatFood()){
            makeFood();
            snakeLength++;
            snakeMove(stepX,stepY);
        }
            }
    public int getSnakeLength(){

        return this.snakeLength;
       

       
    }
    public void setSnakeLength(int snakeLangth){
        this.snakeLength=snakeLangth;
    }
    //判断蛇身是否越界
    private boolean snakeIsDead(){
       
        if(snake[0]<=screen_start_w||snake[0]>=screen_w||snake[1]<=LINE_Y||snake[1]>=screen_h){
            return true;
        }
       
        for(int i=2;i<snakeLength;i++){
            if(snake[i*2+0]==snake[0]&&snake[i*2+1]==snake[1]){
                return true;
            }
        }
       
       
        return false;
    }
    //蛇的食物坐标
    public void makeFood(){
        foodX=random_food.nextInt(screen_w-snake_w);
        foodY=random_food.nextInt(screen_h-snake_h)+LINE_Y;
       
    }
    //判断蛇头是否和食物坐标相似
    public boolean isEatFood(){
       
        if(foodX<=snake[0]&&snake[0]<=foodX+snake_w&&foodY<=snake[1]&&snake[1]<=foodY+snake_h){
           
            return true;
        }
        return false;
    }
     //蛇身移动
    public void snakeMove(int snakeX,int snakeY){
   
         for(int i=snakeLength-1;i>0;i--){
             snake[i*2+0]=snake[(i-1)*2+0];
             snake[i*2+1]=snake[(i-1)*2+1];
         }
         

         //确定蛇头
        snake[0]+=snakeX;
        snake[1]+=snakeY;
    }
   
   
   

}