极客学院Android12案例---案例3--神经猫游戏

1.目录结构

Dot类
Palygroud类
MainActivity类

2.源码

Dot类

package com.fengray.ex040;

public class Dot extends Object {
    //点的坐标
    int x,y;
    //点的状态，3个状态，可进入，不可动，当前状态
    int status;
    public static final int STAUS_ON=1;//当前站立状态
    public static final int STAUS_OFF=0;//关闭，不可进入
    public static final int STAUS_IN=9;//站立中

    public Dot(int x, int y) {
        this.x = x;
        this.y = y;
        status=STAUS_OFF;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public void setXY(int x,int y){
        this.x = x;
        this.y = y;
    }
}

Palygroud类

package com.fengray.ex040;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.RectF;
import android.util.Log;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.widget.Toast;

import java.util.HashMap;
import java.util.Vector;

public class Playground extends SurfaceView  implements View.OnTouchListener {
    //设定绘制的园的半径
    private static  int Width;
    //创建数组每个维度的数量
    private static final int Col=10;
    private static final int Row=10;
    //设置默认路障的数量
    private static  final int BLOCKS=10;

    //创建二维数组来存放表盘
    private  Dot matrix[][];
    //创建一个猫对象，市值也是有Dot对象
    private Dot cat;

    boolean justInit;

    public Playground(Context context) {
        super(context);
        //对holder添加addCallback方法
        getHolder().addCallback(callback);

        matrix=new Dot[Row][Col];
        //设置所有的点
        for (int i=0; i<Row;i++){
            for (int j=0; j<Col;j++){
                matrix[i][j]=new Dot(j, i);
            }
        }
        setOnTouchListener(this);
        //初始化游戏
        initGame();


    }

    //封装一个从数组中取对象的函数
    private  Dot getDot(int x,int y){
        return matrix[y][x];
    }
    //  判断当前的点是否是游戏边界
    private boolean isAtEdge(Dot dot){
        if (dot.getX()*dot.getY()==0||dot.getX()+1==Col||dot.getY()+1==Row){
            return true;//到达游戏界面边界
        }
        return false;
    }

    //判断是否相邻点
    private Dot getNeighbour(Dot onedot,int direction){
        //每个点有6个邻居
        switch (direction) {
            case 1:
                return getDot(onedot.getX() - 1, onedot.getY());

            case 2:
                if (onedot.getY() % 2 == 0) {
                    return getDot(onedot.getX() - 1, onedot.getY() - 1);
                } else {
                    return getDot(onedot.getX(), onedot.getY() - 1);
                }

            case 3:
                if (onedot.getY() % 2 == 0) {
                    return getDot(onedot.getX(), onedot.getY() - 1);
                } else {
                    return getDot(onedot.getX() + 1, onedot.getY() - 1);
                }
            case 4:
                return getDot(onedot.getX() + 1, onedot.getY());
            case 5:
                if (onedot.getY() % 2 == 0) {
                    return  getDot(onedot.getX(), onedot.getY() + 1);
                } else {
                    return getDot(onedot.getX() + 1, onedot.getY() + 1);
                }
            case 6:
                if (onedot.getY() % 2 == 0) {
                    return getDot(onedot.getX() - 1, onedot.getY() + 1);
                } else {
                    return getDot(onedot.getX(), onedot.getY() + 1);
                }
            default:
                break;

        }
        return null;
    }

    //获取两点的距离
    private  int getDistance(Dot one,int direction){
        int distance=0;
        if (isAtEdge(one)){
            return distance;
        }
        Dot orignial=one,next;
        while (true){
            next=getNeighbour(orignial,direction);
            if (next.getStatus()==Dot.STAUS_ON){
                return distance*-1;
            }
            if (isAtEdge(next)){
                return distance;
            }
            distance++;
            orignial=next;
        }
    }

    //实现猫的 移动
    private  void Moveto(Dot one){
        one.setStatus((Dot.STAUS_IN));
        getDot(cat.getX(), cat.getY()).setStatus(Dot.STAUS_OFF);
        cat.setXY(one.getX(), one.getY());
    }
   //重绘
    private void redraw(){
        //锁定画布
        Canvas canvas= getHolder().lockCanvas();
        canvas.drawColor(Color.LTGRAY);//使用青色绘图
        //创建画笔
        Paint paint=new Paint();
        //设置画笔抗锯齿
        paint.setFlags(paint.ANTI_ALIAS_FLAG);
        for (int i=0; i<Row;i++){
            //设置奇偶行偏移
            int offset=0;
            if (i%2==1){
                offset=Width/2;
            }
            for (int j=0; j<Col;j++){
                //依次获取数组中的dot
                Dot one=getDot(j, i);
                switch (one.getStatus()){
                    case Dot.STAUS_OFF:
                        paint.setColor(0xFFEEEEEE);
                        break;
                    case Dot.STAUS_ON:
                        paint.setColor(0xFFFFAA00);
                        break;
                    case Dot.STAUS_IN:
                        paint.setColor(0xFFFF0000);
                        break;
                    default:
                        break;
                }
                //在画布上绘制出所有的点出来
                canvas.drawOval(new RectF(one.getX()*Width+offset,one.getY()*Width,(one.getX()+1)*Width+offset,(one.getY()+1)*Width),paint);

            }
        }

        getHolder().unlockCanvasAndPost(canvas);
    }

    //创建回调对象
    SurfaceHolder.Callback callback = new SurfaceHolder.Callback() {
        @Override
        public void surfaceCreated(SurfaceHolder holder) {
            redraw();
        }

        @Override
        public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
            //根据surface的宽度设定宽度
            Width=width/(Col+1);
            //重绘一下界面
            redraw();
        }

        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {

        }
    };

    //游戏初始化
    public void initGame(){
        for (int i=0; i<Row;i++){
            for (int j=0; j<Col;j++){
                matrix[i][j].setStatus(Dot.STAUS_OFF);
            }
        }
        //直接让神经猫就在4,5象限上
        cat=new Dot(4,5);
        getDot(4, 5).setStatus(Dot.STAUS_IN);

        //随意指定10个路障的位置
        for (int i=0; i<BLOCKS;){
            //获得随机的点的x，y坐标
            int x=(int)(Math.random()*1000)%Col;
            int y=(int)(Math.random()*1000)%Row;
            if (getDot(x, y).getStatus()==Dot.STAUS_OFF){//如果点的状态为off
                //将该点设置为路障
                getDot(x, y).setStatus(Dot.STAUS_ON);
                i++;
                Log.d("FR", "Block: "+i);
            }
        }

        justInit=true;
    }

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        if (event.getAction()==MotionEvent.ACTION_UP){//手指离开触摸的一瞬间
            //获取园的游戏中的坐标
            int x,y;
            y=(int)event.getY()/Width;
            if (y%2==0){
                x=(int)event.getX()/Width;
            }else{
                x=(int)((event.getX()-Width/2)/Width);
            }
            if (x+1>Col|| y+1>Row) {
                initGame();
            }else if (getDot(x,y).getStatus()==Dot.STAUS_OFF){
                //点击之后这个点被开启了路障模式，getDot（）就是获取到了点
                getDot(x,y).setStatus(Dot.STAUS_ON);
                move();
            }
            //重绘确认改动
            redraw();

        }

        return true;
    }

    private void move() {
        //先判断场景边界
        if (isAtEdge(cat)){
            losegame();
            return;
        }
        //不在边界时
        //判断可用点个数集合
        Vector<Dot>avaliable=new Vector<>();
        //判断路径选择
        Vector<Dot>postive=new Vector<>();
        //用hashmap来记录点
        HashMap<Dot,Integer> al=new HashMap<>();

        for(int i=1;i<7;i++){
            Dot n=getNeighbour(cat,i);
            if (n.getStatus()==Dot.STAUS_OFF){
                avaliable.add(n);
                al.put(n,i);
                if (getDistance(n,i)>0){
                    postive.add(n);
                }
            }
        }

        if (avaliable.size()==0){//猫周边没有空位
            wingame();
        }else if (avaliable.size()==1){
            Moveto(avaliable.get(0));
        }else if (justInit){
            int s=(int)((Math.random()*1000)%avaliable.size());
            Moveto(avaliable.get(s));
        }else{
            Dot best=null;
            if (postive.size()!=0){//存在可以直接到达屏幕边缘的走向
                int min=99;
                for (int i=0;i<postive.size();i++){
                   int a=getDistance(postive.get(i),al.get(postive.get(i))) ;
                   if (a<min){
                       min=a;//获取一个距离的最短值
                       best=postive.get(i);//获取一个距离的最短值的点
                   }
                }

            }else{//所有方向上都存在路障
                int max=0;
                for (int i=0;i<avaliable.size(); i++){
                    int k=getDistance(avaliable.get(i),al.get(avaliable.get(i)));
                    if (k<max){
                        max=k;
                        best=avaliable.get(i);

                    }
                }
            }
            Moveto(best);
        }
    }

    private void losegame(){
        Toast.makeText(getContext(), "lose game!", Toast.LENGTH_SHORT).show();
    }
    private void wingame(){
        Toast.makeText(getContext(), "win the game!", Toast.LENGTH_SHORT).show();

    }
}

MainActivity类

import androidx.appcompat.app.AppCompatActivity;

import android.graphics.Canvas;
import android.graphics.Color;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //setContentView(R.layout.activity_main);
        //指定一个自定义的界面
        setContentView(new Playground(this));
    }


}

效果