(心得一)java俄罗斯方块小游戏编写心得

    首先,对游戏进行分析,俄罗斯方块由七种方块及游戏界面组成,再进行细分,七种方块可拆分成四个最基本小方块,而游戏界面可分为窗体上嵌入一块游戏面板。所以,首先对游戏的最基本元素最基本小方块进行构造,编写一个Cell类

对Cell类进行分析,最基本小方块所具有的属性为行row,列col,图片Image;所具有的行为为左移,右移,下落(七种方块的左移、右移、下落实质上为最基本小方块的左移、右移、下落)。

注:在编写代码时,需要遵守JavaBean规范,即程序员在定义类时,默认遵守的一种规范。

代码如下:

package com.tetris;
import java.awt.image.BufferedImage;
public class Cell {
    private int row;
    private int col;
    private BufferedImage image;
    public Cell() {}
    public Cell(int row, int col, BufferedImage image) {
        super();
        this.row = row;
        this.col = col;
        this.image = image;
    }
    public int getRow() {
        return row;
    }
    public void setRow(int row) {
        this.row = row;
    }
    public int getCol() {
        return col;
    }
    public void setCol(int col) {
        this.col = col;
    }
    public BufferedImage getImage() {
        return image;
    }
    public void setImage(BufferedImage image) {
        this.image = image;
    }
    @Override
    public String toString() {
        return "Cell [row=" + row + ", col=" + col + ", image=" + image + "]";
    }
    //向左移动
    public void left() {
        col--;
    }
    //向右移动
    public void right() {
        col++;
    }
    public void drop() {
        row++;
    }
}

游戏最基本小方块类已经写完,接下来的第二步,就是需要用最基本小方块组合出来七种方块,而七种方块统一是由四个最基本小方块组成,所以我们可以先编写一个四格方块类,即取出四个最基本小方块放入二维数组中,构成一个四格方块,但是此时方块还未组成七种基本图形,只是在定义其行为及属性,为接下来的七种图形的构造提供方便。最终的七种方块的形状,由各个类继承本类来进行构造。对该类进行分析,四格方块所具有的属性为四个最基本小方块,方法同最基本小方块方法相同,即左移、右移、下落

代码如下:

package com.tetris;
public class Tetromino {
    protected Cell[] cells=new Cell[4];
    public void moveLefr() {
        for(int i=0;i<cells.length;i++) {
            cells[i].left();
        }
    }
    public void moveRight() {
        for(int i=0;i<cells.length;i++) {
            cells[i].right();;
        }
    }
    public void softDrop() {
        for(int i=0;i<cells.length;i++) {
            cells[i].drop();
        }
    }
}

七种方块可抽象为字母I,S,T,Z,L,O,J,如图所示,若想将最基本小方块组合成七种方块,需要将最基本方块放在一个二维数组中,行列号图中已经给出,所以可编写出I,S,T,Z,L,O,J类,分别代表七种方块。

七种小方块图片为:I:  J:  L:  O:  S:  T:  Z: ,在使用图片时,需要将图片放入到同一包下。

 

代码如下:

I:

package com.tetris;
public class I extends Tetromino {
    public I() {
        cells[0]=new Cell(0,4,Tetris.I);
        cells[1]=new Cell(0,3,Tetris.I);
        cells[2]=new Cell(0,5,Tetris.I);
        cells[3]=new Cell(0,6,Tetris.I);
    }
}

J:

package com.tetris;
public class J extends Tetromino {
    public J() {
        cells[0]=new Cell(0,4,Tetris.J);
        cells[1]=new Cell(0,3,Tetris.J);
        cells[2]=new Cell(0,5,Tetris.J);
        cells[3]=new Cell(1,5,Tetris.J);
    }
}

L:

package com.tetris;
public class L extends Tetromino {
    public L() {
        cells[0]=new Cell(0,4,Tetris.L);
        cells[1]=new Cell(0,3,Tetris.L);
        cells[2]=new Cell(0,5,Tetris.L);
        cells[3]=new Cell(1,3,Tetris.L);
    }
}

O:

package com.tetris;
public class O extends Tetromino {
    public O() {
        cells[0]=new Cell(0,4,Tetris.O);
        cells[1]=new Cell(0,5,Tetris.O);
        cells[2]=new Cell(1,4,Tetris.O);
        cells[3]=new Cell(1,5,Tetris.O);
    }
}

S:

package com.tetris;
public class S extends Tetromino {
    public S() {
        cells[0]=new Cell(0,4,Tetris.S);
        cells[1]=new Cell(0,5,Tetris.S);
        cells[2]=new Cell(1,3,Tetris.S);
        cells[3]=new Cell(1,4,Tetris.S);
    }
}

T:

package com.tetris;
public class T extends Tetromino{
    //提供构造器,进行初始化T形的四格方块的位置
    public T() {
        cells[0]=new Cell(0,4,Tetris.T);
        cells[1]=new Cell(0,3,Tetris.T);
        cells[2]=new Cell(0,5,Tetris.T);
        cells[3]=new Cell(1,4,Tetris.T);
    }
}

Z:

package com.tetris;
public class Z extends Tetromino{
    public Z(){
        cells[0]=new Cell(1,4,Tetris.Z);
        cells[1]=new Cell(0,3,Tetris.Z);
        cells[2]=new Cell(0,4,Tetris.Z);
        cells[3]=new Cell(1,5,Tetris.Z);
    }
}

代码到了这,七种方块已经构造完成,但是代码到了这会出错,因为我们在使用图片时只是将图片引到了同一包下,并没有将图片读进来,如果我们在这七种方块类中加入图片读取,那么就会出现一个问题,在最终写完后,图片会是使用一次加载一次,会造成不必要的浪费,所以我们现在需要一个主类,来将图片在程序运行最初就将图片加载进来,在以后的使用中只对其进行调用即可,不需要重新加载。

代码如下:

package com.tetris; 
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
    public class Tetris{
        public static BufferedImage T;
        public static BufferedImage I;
        public static BufferedImage O;
        public static BufferedImage J;
        public static BufferedImage L;
        public static BufferedImage S;
        public static BufferedImage Z;
        public static BufferedImage background;
        static {
            try {
                    T=ImageIO.read(Tetris.class.getResource("T.png"));
                    I=ImageIO.read(Tetris.class.getResource("I.png"));
                    O=ImageIO.read(Tetris.class.getResource("O.png"));
                    J=ImageIO.read(Tetris.class.getResource("J.png"));
                    L=ImageIO.read(Tetris.class.getResource("L.png"));
                    S=ImageIO.read(Tetris.class.getResource("S.png"));
                    Z=ImageIO.read(Tetris.class.getResource("Z.png"));
                    background=ImageIO.read(Tetris.class.getResource("tetris.png"));
                }catch(Exception e) {
                    e.printStackTrace();
                }
        }
    }

代码到了这里,根据之前的分析,七种方块的构造已经完成,还需要一个游戏面板,而游戏面板是一进游戏首先出现的就是这个面板,所以也可以说它是游戏的入口,也就是整个程序的开始的地方,所以需要写在主类的main方法中,因为主类即游戏界面,所以可以使主类继承JPanel,那么在创建主类对象时,就是创建了一个游戏面板。

代码如下:

package com.tetris; 
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Tetris extends JPanel{
    public static void main(String[] args) {
        //创建一个窗口对象
        JFrame jf=new JFrame("火拼俄罗斯");
        //创建游戏界面,即面板
        Tetris panle=new Tetris();
        //将面板嵌入窗口
        jf.add(panle);
        //设置窗口可见
        jf.setVisible(true);
        //设置窗口的尺寸
        jf.setSize(535, 595);
        //设置窗口位置
        jf.setLocationRelativeTo(null);
        //设置窗口关闭,即程序终止
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

此时如果运行的话只会出现一个游戏界面,而游戏界面上什么都没有,因为并没有在面板上绘制任何东西,接下来我们需要分析一下面板上都要绘制什么,首先,有游戏背景,其次,在游戏开始时我们会有一个正在下落的方块,在右边还会有一个位置显示下一个将要下落的方块,这是面板上可见的元素,再分析,如果想要让方块显示在游戏界面上,那便需要给方块一个初始位置,而位置如何表示,我们可以衍生出一个抽象的墙的概念,即方块是在墙上的,这便是面板上可见与不可见的元素。我们需要将这些属性封装在JPanel的自动调用方法paint()方法中,但是我们需要对paint()方法进行重写。

代码如下:

package com.tetris; 
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Tetris extends JPanel{
    public void paint(Graphics g) {
        //绘制背景
        g.drawImage(background, 0, 0, null);
        //绘制墙
        paintWall(g);
        //绘制正在下落的四格方块
        paintCurrentOne(g);
        //绘制下一个将要下落的四格方块
        paintNextOne(g);
    }
}

此时我们需要对paintWall()、paintCurrentOne()、paintNextOne()方法进行定义,对paintWall()(绘制墙)方法进行分析,如果想要使方块显示在墙上,那就需要给方块位置,位置用什么来表示,我们可以将墙定义为一个10列20行的二维数组,而墙的二维数组内的元素为与最基本小方块长宽相同的小方格,如上图。

代码如下:

package com.tetris; 
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Tetris extends JPanel{
    public void paintWall(Graphics g) {
        //外层循环控制行数
        for(int i=0;i<20;i++) {
        //内层循环控制列数
            for(int j=0;j<10;j++) {
                int x=j*CELL_SIZE;
                int y=i*CELL_SIZE;
                Cell cell=wall[i][j];
                if(cell==null) {
                    //增加难度本句可加注释
                    g.drawRect(x, y, CELL_SIZE, CELL_SIZE);
                }else {
                    g.drawImage(cell.getImage(), x, y, null);
                }
            }
        }
    }
}

然后分析即将下落方块与正在下落方块,之前已经定义过七种图形方块,可以在主类中首先定义两个Tetromino类型变量currentOne和nextOne,然后给两个变量赋值,因为在游戏中方块都是随机出现,所以需要一个随机生成方块的方法,在Tetromino类中定义此方法

代码如下:

package com.tetris;
public class Tetromino {
    protected Cell[] cells=new Cell[4];
    public static Tetromino randomeOne() {
    Tetromino t=null;
    int num=(int)(Math.random()*7);
    switch(num) {
        case 0:t=new T();break;
        case 1:t=new O();break;
        case 2:t=new I();break;
        case 3:t=new J();break;
        case 4:t=new L();break;
        case 5:t=new S();break;
        case 6:t=new Z();break;
    }
        return t;
    }
}

有了随机生成方法后,就可以给currentOne与nextOne赋值,接下来就可以重新定义方法paintCurrentOne()方法

代码如下:

package com.tetris; 
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Tetris extends JPanel{
    public void paintCurrentOne(Graphics g){
        Cell[] cells=currentOne.cells;
        for(Cell c:cells) {
            int x=c.getCol()*CELL_SIZE;
            int y=c.getRow()*CELL_SIZE; 
            g.drawImage(c.getImage(), x, y, null);
        }
    }
}

接下来继续分析nextOne,即将下落方块因为要显示在右上角,所以他的横坐标至少大于260像素,纵坐标至少大于26.。

代码如下:

package com.tetris; 
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Tetris extends JPanel{
    public void paintNextOne(Graphics g) {
        //获取nextOne对象的四个元素
        Cell[] cells=nextOne.cells;
        for(Cell c:cells) {
            //获取每一个元素的行号和列号
            int row=c.getRow();
            int col=c.getCol();
            //横坐标、纵坐标
            int x=col*CELL_SIZE+260;
            int y=row*CELL_SIZE+26;
            g.drawImage(c.getImage(), x, y, null);
        }
    }
}

现在运行代码,可以看到游戏界面已经完美,游戏的第一步已经完成

展开阅读全文

没有更多推荐了,返回首页