美国上市公司

亿元级外企IT培训企业

  • 全国服务监督电话400-827-0010
IT培训 > 学习笔记 > 和TTS有所不同的贪吃蛇 能穿墙而不是撞墙 [纯代码]
  • 和TTS有所不同的贪吃蛇 能穿墙而不是撞墙 [纯代码]

    发布:IT培训 来源:达内 时间:2014-12-29

  • 和TTS 有所不同的贪吃蛇 能穿墙而不是撞墙 [纯代码]

  • 参赛人:陈彬豪

    获得奖项:三等奖

    内容:

    第一步,就是先把单个格子的属性创建出来

    public class Cell {
        int row;
        int col;
        int color;
        
        static int indexRow = 10000;//这个参数是上下穿墙用的,为了保证不用完,要尽可能的大
        static int indexCol = 10000;//这个参数是左右穿墙用的,为了保证不用完,要尽可能的大
        
        public Cell(){//对于父类,无参数构造器不一定用到,应该习惯的写上
            
        }
        public Cell(int x, int y, int color) {
            super();
            this.row = x;
            this.col = y;
            this.color = color;
        }
    
        //各属性的get set方法
        public int getColor() {
            return color;
        }
        public void setColor(int color) {
            this.color = color;
        }
        public int getRow() {
            return row;
        }
        public void setRow(int x) {
            this.row = x;
        }
        public int getCol() {
            return col;
        }
        public void setCol(int y) {
            this.col = y;
        }
        
        /**向X轴负正向走*/
        public void left(){
            row = (indexRow+(--row))%40;/*这就是穿墙的关键,40是贪吃蛇墙的长,%40就能使蛇走不出墙,注意!!(--row)不能写成(row--) */
        }
        /**向X轴负方向走*/
        public void right(){
            row= (indexRow+(++row))%40;
        }
        /**向Y轴负方向走*/
        public void up(){
            col = (indexCol+(--col))%40;
        }
        /**向Y轴正方向走*/
        public void down(){
            col = (indexCol+(++col))%40;
        }
        public String toString(){
            return row+","+col;
        }
    }

    第二步,对蛇身的构造,以及蛇运动的方法

    import java.util.Arrays;
    
    public class Body extends Cell{
        /**蛇身的颜色*/
        public static final int BADY_COLOR = 0x66ccff;    
        /** 身体 */
        public  Cell[] bodys;
        /**头*/
        protected Cell head;
    
        public Body(){ 
            bodys = new Cell[5];
            head = new Cell(4,10,BADY_COLOR);
            bodys[0] = head;
            bodys[1] = new Cell(3,10,BADY_COLOR);
            bodys[2] = new Cell(2,10,BADY_COLOR);
            bodys[3] = new Cell(1,10,BADY_COLOR);
            bodys[4] = new Cell(0,10,BADY_COLOR); 
        
        }    
        /**绝对左移*/
        public Cell[] moveLeft() {    
            int i;
            worm Worm = new worm();
            //当前蛇身的长度
            int length = Worm.getBodyCellsLength();
            //对蛇身数组的扩容
            bodys = Arrays.copyOf(bodys, length);
            
            for(i = length-1;i>0;i--){
                if(bodys[i]==null){//如果吃了食物就会扩容,扩容的新元素为null
                    bodys[i]=new Cell();
                }
                bodys[i].col=bodys[i-1].col;
                bodys[i].row=bodys[i-1].row;            
            }
            head.left();
            return bodys;
        }
        /**绝对左移*/
        public Cell[] moveRight() {
            int i;
            worm Worm = new worm();
            int length = Worm.getBodyCellsLength();
            bodys = Arrays.copyOf(bodys, length);
            
            for(i = length-1;i>0;i--){
                if(bodys[i]==null){
                    bodys[i]=new Cell();
                }
                bodys[i].setCol(bodys[i-1].col);
                bodys[i].setRow(bodys[i-1].row);    
            }
            head.right();
            return bodys;
        }
        /**绝对上移*/
        public Cell[] goUp() {
            int i;
            worm Worm = new worm();
            int length = Worm.getBodyCellsLength();
            bodys = Arrays.copyOf(bodys, length);
    
            for(i = length-1;i>0;i--){
                if(bodys[i]==null){
                    bodys[i]=new Cell();
                }
                bodys[i].col=bodys[i-1].col;
                bodys[i].row=bodys[i-1].row;            
            }
            head.up();
            return bodys;
        }
        /**绝对下移*/
        public Cell[] goDown() {
            int i;
            worm Worm = new worm();
            int length = Worm.getBodyCellsLength();    
            bodys = Arrays.copyOf(bodys, length);
            
            for(i = length-1;i>0;i--){
                if(bodys[i]==null){
                    bodys[i]=new Cell();
                }
                bodys[i].col=bodys[i-1].col;
                bodys[i].row=bodys[i-1].row;    
            }
            head.down();
            return bodys;
        }
        
        
        public Cell[] getBody(){
            return bodys;
        }
        
        
        public String toString(){
            return Arrays.toString(bodys);
        }
    }    

    第三步 绘制动作方法和绘图

    import java.awt.Color;
    import java.awt.Font;
    import java.awt.Graphics;
    import java.awt.Image;
    import java.awt.LayoutManager;
    import java.awt.event.KeyEvent;
    import java.awt.event.KeyListener;
    import java.awt.image.ImageObserver;
    import java.util.Arrays;
    import java.util.Random;
    import java.util.Timer;
    import java.util.TimerTask;
    
    import javax.swing.ImageIcon;
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JPanel;
    
    public class worm extends JPanel {
    
        public static final int ROWS = 40;
    
        public static final int COLS = 40;
    
        private Cell[][] wall = new Cell[ROWS][COLS];
    
        /** 每一格的大小规格 */
        public static final int CELL_SIZE = 10;
    
        /** 与边框的距离 */
        public static final int ADD = 20;
        
        public static final int BG_COLOR = 0xc3d5ea;
        /** 背景色 */
        public static final int FONT_COLOR = 0xffffff;
    
        /** 边框线条颜色 */
        public static final int BORDER_COLOR = 0x667799;
    
        /** 食物的颜色 */
        public static final int FOOD_COLOR = 0xff0000;
    
        /** 蛇身的颜色 */
        public static final int BADY_COLOR = 0x66ccff;
    
        /** 是否吃到的判定 */
        public static boolean eat = false;
    
        /** 正在向绝对上走 */
        public static boolean goingUp = false;
    
        /** 正在向绝对下走 */
        public static boolean goingDwon = false;
    
        /** 正在向绝对右走 */
        public static boolean moveingRight = false;
    
        /** 正在向绝对左走 */
        public static boolean moveingLeft = false;
        /**游戏结束*/
        public static boolean gameOver = false;
        /**暂停判定*/
        public static boolean pause = false;
        /**速度*/
        public static int speed;
        /**分数*/
        public static int score;
        /** 食物 */
        public static Cell food;
    
        /** 吃到食物前一格时的最后一格 */
        public Cell tempBody;
    
        public Timer timer;
    
        public static Body body;
    
        /** 蛇身 */
        public static Cell[] bodyCells;
        
        public static JFrame frame = new JFrame("贪吃蛇");
    
        public static worm panel = new worm(null); 
        // ------------------------------------开始---------------------------------
    
        public worm(LayoutManager layout){
            super(layout);
        }
        public worm(){
        }
        public static void main(String[] args) {
            Random ra = new Random();
            /** 食物 */
            food = new Cell(ra.nextInt(ROWS), ra.nextInt(COLS), FOOD_COLOR);
    
            frame.setSize((COLS +7) * CELL_SIZE-20, (ROWS+8) * CELL_SIZE + 90);
            frame.setResizable(false);//禁止窗口缩放
            frame.setLocationRelativeTo(null);// 窗口居中//null是窗口的相对位置,没有就是居中
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置关闭窗口就关闭软件
            
            frame.add(panel);// 窗口中添加面板
            frame.setVisible(true);// 显示窗口
        
            
            panel.action();
            
            
        }
    
        /** 动作流程 */
        private void action() {
            
            startAction();
    
            this.requestFocus();// 为当前面板请求获得输入焦点,this对象就获得了输入焦点,以后任何的键盘输入目标就是这个面板
            this.addKeyListener(new KeyListener() {// 添加键盘监听,
                        public void keyPressed(KeyEvent e) {// 按键按下去
                            System.out.println("type:" + e.getKeyCode());
                            int key = e.getKeyCode();
                            if(gameOver!= true){
                            switch (key) {
                            case 'A':
                                if(goingUp||goingDwon){                            
                                    moveLeftAction();
                                    pause=false;
                                }
                                break;
                            case 'D':
                                if(goingUp || goingDwon){                            
                                    moveRightAction();
                                    pause=false;
                                }
                                break;
                            case 'W':
                                if(moveingRight || moveingLeft){    
                                    goUpAction();        
                                    pause=false;
                                }                            
                                break;
                            case 'S':
                                if(moveingLeft || moveingRight){                            
                                    goDwonAction();
                                    pause=false;
                                }
                                break;
                            case KeyEvent.VK_SPACE:
                                if(pause==false){
                                    pauseAction();
                                    pause=true;
                                }
                            }
                            repaint();
                            }
                            if(key==KeyEvent.VK_Q){
                                gameOver=true;
                                pause=false;
                                timer.cancel();
                                repaint();
                            }
                            if(gameOver){
                                if(key==KeyEvent.VK_ENTER){
                                    startAction();
                                }
                            }
                            /**ESC 退出系统*/
                            if(key==KeyEvent.VK_ESCAPE){
                                System.exit(0);
                            }
                        }
                        public void keyReleased(KeyEvent e) {
                            int key = e.getKeyCode();
                            
                        }// 按键松开
    
                        public void keyTyped(KeyEvent e) {
                            int key = e.getKeyCode();
                            if(key=='T'){
                                System.exit(0);
                            }
                        }// 按键按一下
                    });
            
        }
        
        /**开始流程*/
        public void startAction(){
            gameOver = false;
            pause = false;
            score = 0;
            level();
            body = new Body();
            bodyCells = body.bodys;
            newFood();
            moveingRight = true;
            timer = new Timer();
            timer.schedule(new TimerTask() {
                public void run() {
                    TempBody(bodyCells);
                    bodyCells = body.moveRight();
                    level();
                    gameOverAction();
                    bodyCells = grow(bodyCells, food, tempBody);
                    repaint();
                }
            }, 500, speed);
            repaint();
        }
        /**结束流程*/
        public void gameOverAction() {
            if (gameOver()) {
                System.out.println("gameOver");
                timer.cancel();
            }
        }
        
        private void pauseAction() {
            timer.cancel();
            pause = true;
        }
    
        /** 向上走流程 */
        private void goUpAction() {
            timer.cancel();
            goingUp = true;
            goingDwon = false;
            moveingRight = false;
            moveingLeft = false;
            level();
            timer = new Timer();
            timer.schedule(new TimerTask() {
                public void run() {
                    TempBody(bodyCells);
                    bodyCells = body.goUp();
                    gameOverAction();
                    bodyCells = grow(bodyCells, food, tempBody);
                    repaint();
                }
            }, 0, speed);
        }
    
        /** 向下走流程 */
        private void goDwonAction() {
            timer.cancel();
            goingUp = false;
            goingDwon = true;
            moveingRight = false;
            moveingLeft = false;
            level();
            timer = new Timer();
            timer.schedule(new TimerTask() {
                public void run() {
                    TempBody(bodyCells);
                    bodyCells = body.goDown();
                    gameOverAction();
                    bodyCells = grow(bodyCells, food, tempBody);
                    repaint();
                }
            }, 0, speed);
        }
    
        /** 向左走流程 */
        private void moveLeftAction() {
            timer.cancel();
            goingUp = false;
            goingDwon = false;
            moveingRight = false;
            moveingLeft = true;
            level();
            timer = new Timer();
            timer.schedule(new TimerTask() {
                public void run() {
                    TempBody(bodyCells);
                    bodyCells = body.moveLeft();
                    gameOverAction();
                    bodyCells = grow(bodyCells, food, tempBody);
                    repaint();
                }
            }, 0, speed);
        }
    
        /** 想右走流程 */
        private void moveRightAction() {
            timer.cancel();
            goingUp = false;
            goingDwon = false;
            moveingRight = true;
            moveingLeft = false;
            level();
            timer = new Timer();
            timer.schedule(new TimerTask() {
                public void run() {
                    TempBody(bodyCells);
                    bodyCells = body.moveRight();
                    gameOverAction();
                    bodyCells = grow(bodyCells, food, tempBody);
                    repaint();
                }
            }, 0, speed);
        }
    
        /** 吃到食物前一格时的最后一格 */
        public void TempBody(Cell[] bodyCells) {
            tempBody = new Cell(bodyCells[bodyCells.length - 1].row,
                    bodyCells[bodyCells.length - 1].col,
                    bodyCells[bodyCells.length - 1].color);
        }
    
        /** 增加1格 tempBody:吃到食物前一格时的最后一格 */
        public Cell[] grow(Cell[] bodyCells, Cell food, Cell tempBody) {
            if (eatFood(bodyCells[0], food)) {
                bodyCells = Arrays.copyOf(bodyCells, bodyCells.length + 1);
                bodyCells[bodyCells.length - 1] = tempBody;
                score = (bodyCells.length-5)*10;
                newFood();
                return bodyCells;
            }
            return bodyCells;
        }
    
        /** 判断是否吃到食物 */
        public static boolean eatFood(Cell head, Cell food) {
            eat = food.row == head.row && food.col == head.col;
            return eat;
        }
    
        /** 刷新食物 */
        public void newFood() {
            if (eat) {
                Random ra = new Random();
                /** 食物 */
                food = new Cell(ra.nextInt(20), ra.nextInt(20), FOOD_COLOR);
                for(Cell cell: bodyCells){
                    if(food.row==cell.row && food.col== cell.col){
                        newFood();
                    }
                }
                eat = false;
            }
        }
        private void level(){
            int index = 100;
            int scoreIndex = score;
            speed=200;
            if(scoreIndex>=index){
                speed-=50;
                scoreIndex-=index;            
            }
            if(scoreIndex>=index){
                speed-=50;
                scoreIndex-=index;
                index=50;
            }
            if(scoreIndex>=index){
                speed-=50;
                scoreIndex-=index;
                index=100;
            }
            if(scoreIndex>=index){
                speed-=10;
                scoreIndex-=index;
            }
        }
    
        /** 游戏结束判定 */
        private boolean gameOver() {
            for (int i = 1; i < bodyCells.length; i++) {
                gameOver = bodyCells[0].row == bodyCells[i].row
                        && bodyCells[0].col == bodyCells[i].col;
                if (gameOver == true) {
                    return gameOver;
                }
            }
            return gameOver;
        }
    
        public int getBodyCellsLength() {
            return bodyCells.length;
        }
        public worm getworm(){
            worm we = new worm();
            return we;
        }
    
        // -------------------------------------------------------------------------------------------
    
        /** JPanel 类利用paint(图画)方法绘制界面,子类重写paint方法可以修改绘图逻辑 */
        public void paint(Graphics g) {
            paintBackBorder(g);    
            //paintWall(g);//绘制墙的格子,方便蛇的运动,但玩的时候最好注释掉,这要更美观
            paintBody(g);
            paintFood(g);
            paintScore(g);
            paintTetrisBorder(g);
        }
    
        /** 填充背景 */
        private void paintBackBorder(Graphics g) {
            
            g.setColor(new Color(0x000000));
            g.fillRect(ADD, ADD+CELL_SIZE * 10, CELL_SIZE * ROWS, CELL_SIZE * COLS);
            g.setColor(new Color(0xc3d5ea));
            g.fillRect(ADD, ADD, CELL_SIZE *ROWS, CELL_SIZE * 10);
        }
    
        /** 绘制墙 */
        private void paintWall(Graphics g) {
            for (int row = 0; row < ROWS; row++) {
                for (int col = 0; col < COLS; col++) {
                    Cell cell = wall[row][col];
    
                        // 墙的格子
    //                    g.setColor(new Color(BORDER_COLOR));
    //                    g.drawRect(ADD +col * CELL_SIZE, ADD+10*CELL_SIZE+row * CELL_SIZE,
    //                            CELL_SIZE, CELL_SIZE);
    
                }
            }
    
        }
    
        /** 绘制食物 */
        private void paintFood(Graphics g) {
    
            int row = food.getRow();
            int col = food.getCol();
            g.setColor(new Color(food.getColor()));
            g.fill3DRect(ADD + row * CELL_SIZE, ADD + col * CELL_SIZE+CELL_SIZE * 10, CELL_SIZE,
                    CELL_SIZE, true);
            g.setColor(new Color(0xffffff));
            g.draw3DRect(ADD + row * CELL_SIZE, ADD + col * CELL_SIZE+CELL_SIZE * 10, CELL_SIZE,
                    CELL_SIZE, true);
        }
    
        /** 绘制蛇身 */
        private void paintBody(Graphics g) {
            for (Cell cell : bodyCells) {
                int row = cell.getRow();
                int col = cell.getCol();
                g.setColor(new Color(0x66ccff));
                g.fill3DRect(ADD + row * CELL_SIZE, ADD + col * CELL_SIZE+CELL_SIZE * 10,
                        CELL_SIZE, CELL_SIZE, true);
                g.setColor(new Color(0xffffff));
                g.draw3DRect(ADD + row * CELL_SIZE, ADD + col * CELL_SIZE+CELL_SIZE * 10,
                        CELL_SIZE, CELL_SIZE, true);
            }
        }
        /** 绘制文字 */
        private void paintScore(Graphics g) {
            Font font = new Font(getFont().getName(), Font.BOLD, 35);
            String str = "SCORE : " + score;
            g.setColor(new Color(FONT_COLOR));
            g.setFont(font);
            g.drawString(str, 13 * CELL_SIZE, 7 * CELL_SIZE);
            str = "[SPACE]PAUSE";
            font = new Font(getFont().getName(), Font.BOLD, 20);
            g.setFont(font);
            g.drawString(str, 4 * CELL_SIZE, 11 * CELL_SIZE);
            str = "[Q]QUIT";
            g.drawString(str, 25 * CELL_SIZE, 11 * CELL_SIZE);
            if(pause){
                font = new Font(getFont().getName(), Font.BOLD, 100);
                g.setFont(font);
                str = "PAUSE";
                g.drawString(str, 6 * CELL_SIZE, 35 * CELL_SIZE);
            }
            
            if(gameOver){
                font = new Font(getFont().getName(), Font.BOLD, 60);
                g.setFont(font);
                str = "GAME OVER ";
                g.drawString(str, 4 * CELL_SIZE, 25 * CELL_SIZE);
                font = new Font(getFont().getName(), Font.BOLD, 20);
                g.setFont(font);
                str = "YOUR SCORE ";
                g.drawString(str, 16 * CELL_SIZE, 30 * CELL_SIZE);
                font = new Font(getFont().getName(), Font.BOLD, 100);
                g.setFont(font);
                str = scoreString(score);
                g.drawString(str, 6 * CELL_SIZE, 40 * CELL_SIZE);
                str = "[ENTER] START ";
                font = new Font(getFont().getName(), Font.BOLD, 40);
                g.setFont(font);
                g.drawString(str, 7 * CELL_SIZE, 45* CELL_SIZE);
            }
        }
    
        /** 绘制边框 */
        private void paintTetrisBorder(Graphics g) {
            g.setColor(new Color(BORDER_COLOR));// 绘制边线
            g.drawRect(ADD, ADD+CELL_SIZE * 10, CELL_SIZE * COLS, CELL_SIZE * ROWS);
            g.drawRect(ADD, ADD, CELL_SIZE*COLS, CELL_SIZE* 10);
        }
        
        private String scoreString(int score){
            String str= ""+score;
            for(int i=0;i<3-(str.length())/2;i++){
                if(str.length()%2==0){
                    str+="  ";
                }
                if(str.length()%2!=0){
                    str="  "+str;
                }
            }
            return str;
        }
    }

    以上就是完整的代码,亲测能用,复制粘贴就用运行,基本上都有注释,看注释就能明白了,写程序加注释是很好的习惯,不然不只是用的人不知道说什么,写到后面很可能连自己都不知哪个方法是干什么的!!!

    写这篇东西纯属学习上的交流,给多少分就随意把,本人觉得征文的这个系统太坑爹了,进来了居然不打分不给走(x.x)

  • 上一篇:杂谈javaEE重点,分享交流经验

    下一篇:可以两人一起玩的坦克大战

相关资讯
2001-2016 达内国际公司(TARENA INTERNATIONAL,INC.) 版权所有 京ICP证08000853号-56