俄罗斯方块（java版）

俄罗斯方块操作简介

左右键控制方块左右移动，下键加快方块移动的速度
空白键让方块顺时针旋转

当分数超过10的倍数，则会相应的减少相应的倍数的时间，即会加快掉落的速度

该游戏只为练练手，写的比较简单，可能还有bug，望以后再改进

源代码简介(还没有学设计模式，所以整个设计可能还不那么令人如意）：

Model.java：该文件中的类Model仅存储方块的形状（将每个方块分解为一个一个的小正方形，存储在数组里面，将其旋转的图形也存储在数组里面，这样简单迅速）：每个方块由四个小正方形组成。

                  静态数组shapeBox：每四组大括号为一组表示一个方块，每五个方块是一组，总共有四组，即第一组为方块的初始形状，第二组为第一组方块顺时针旋转后的形状，第三组为第二组顺时针旋转后的形状，依次类推。将所有的形状放在一个数组里面方便随机选择方块。

                  方法drawModel仅仅是绘制方块的图像，由fIndex指定绘制那个方块（fIndex由Box.java传递过来）

Box.java:该文件中的类相当于一个中转，在Model.java与RussiaBoxClient.java中中转,其主要是判断方块是否超过边界，是否碰到其他方块，并绘制方块，与Model.java沟通，还有一个就是其属性index是随机产生，传递给fIndex（Model.java中drawModel的参数）

              私有方法isBottom判断是否碰到边框的底部

              私有方法addItem将方块的小正方形加入到RussiaBoxClient中的pDraw中（pDraw中存储的是框架里面的所有停止的没有消掉的小正方形）

              私有方法overEdge判断方块旋转时是否超过了框架的左右边框

              公共方法hit判断方块是否撞到了其他方块和底部

              公共方法bKeyPressed监听按键事件，在监听的时候注意判断方块是否会越界，然后再决定是否响应键盘事件

DrawPoint.java：该文件里面的类DrawPoint主要是为了存储每个小正方形的位置与颜色，其实这个类可以不用单独放在一个文件里面的，完全可以放在RussiaBoxClient.java里面

                        公共方法draw是为了绘制小正方形

RussiaBoxClient.java：定义了主框架，并绘图，还有利用双缓冲更新框架画面

                                私有方法decBox是为了消解已经形成一行的方块

                                私有方法ThreadMonitor：调用repaint方法，并让线程睡眠一定时间，这个睡眠时间由分数的多少决定，分数越高时间越短

                                私有方法keyMonitor监听键盘事件，调用Box里面的监听事件的方法

                                内部类cmp是为了对pDraw进行排序

整个项目还是挺简单的，但是我的大部分时间是花在调试程序上了，1)、之前运行的时候在消解一行小正方形后上面掉下来的东西总是很乱，然后用各种方法调试并检查，发现自己在pDraw.remove()时弄错了，因为pDraw.remove()后整个List变小了，如果现在在将k加一的话，则删除的不是下一个小正方形，而是下下一个小正方形，2)、改后还是有错，继续检查调试，发现数组record用的有问题，然后改成先前用的num（之前的问题还一直以为num有问题，就改成了record去记录一行方块的个数），最后调试成功，3)、还有就是remove后整个pDraw里面的元素变少了，在继续查找是否还有一行的小正方形时，不可继续在前面的基础上处理，要先减去remove的元素个数才行。。。

         

Model.java

import java.awt.*;


public class Model {
    
    //本来想找规律的，但是觉得找规律可能比直接列出来更麻烦，效率会更低，就枚举了，以后再更改吧。。。
    //初始的方块
    public static final int shapeBox[][] = {
        {0,0},{Box.UNIT_WIDTH,0},{2*Box.UNIT_WIDTH,0},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},
        {0,0},{Box.UNIT_WIDTH,0},{2*Box.UNIT_WIDTH,0},{0,Box.UNIT_WIDTH},
        {0,0},{Box.UNIT_WIDTH,0},{2*Box.UNIT_WIDTH,0},{2*Box.UNIT_WIDTH,Box.UNIT_WIDTH},
        {0,0},{0,Box.UNIT_WIDTH},{0,2*Box.UNIT_WIDTH},{0,3*Box.UNIT_WIDTH},
        {0,0},{Box.UNIT_WIDTH,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},
        {0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,0},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,2*Box.UNIT_WIDTH},
        {0,0},{Box.UNIT_WIDTH,0},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,2*Box.UNIT_WIDTH},
        {Box.UNIT_WIDTH,0},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},{0,2*Box.UNIT_WIDTH},{Box.UNIT_WIDTH,2*Box.UNIT_WIDTH},
        {0,0},{Box.UNIT_WIDTH,0},{2*Box.UNIT_WIDTH,0},{3*Box.UNIT_WIDTH,0},
        {0,0},{Box.UNIT_WIDTH,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},
        {Box.UNIT_WIDTH,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},{2*Box.UNIT_WIDTH,Box.UNIT_WIDTH},
        {2*Box.UNIT_WIDTH,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},{2*Box.UNIT_WIDTH,Box.UNIT_WIDTH},
        {0,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},{2*Box.UNIT_WIDTH,Box.UNIT_WIDTH},
        {0,0},{0,Box.UNIT_WIDTH},{0,2*Box.UNIT_WIDTH},{0,3*Box.UNIT_WIDTH},
        {0,0},{Box.UNIT_WIDTH,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},
        {0,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},{0,2*Box.UNIT_WIDTH},
        {0,0},{0,Box.UNIT_WIDTH},{0,2*Box.UNIT_WIDTH},{Box.UNIT_WIDTH,2*Box.UNIT_WIDTH},
        {0,0},{Box.UNIT_WIDTH,0},{0,Box.UNIT_WIDTH},{0,2*Box.UNIT_WIDTH},
        {0,0},{Box.UNIT_WIDTH,0},{2*Box.UNIT_WIDTH,0},{3*Box.UNIT_WIDTH,0},
        {0,0},{Box.UNIT_WIDTH,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH}
        };
    /*
    //旋转一次的方块（顺时针）
    public static final int oShapeBox[][] = {
        {0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,0},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,2*Box.UNIT_WIDTH},
        {0,0},{Box.UNIT_WIDTH,0},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,2*Box.UNIT_WIDTH},
        {Box.UNIT_WIDTH,0},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},{0,2*Box.UNIT_WIDTH},{Box.UNIT_WIDTH,2*Box.UNIT_WIDTH},
        {0,0},{Box.UNIT_WIDTH,0},{2*Box.UNIT_WIDTH,0},{3*Box.UNIT_WIDTH,0},
        {0,0},{Box.UNIT_WIDTH,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH}
    };
    
    //旋转两次后的方块（顺时针）
    public static final int tShapeBox[][] = {
        {Box.UNIT_WIDTH,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},{2*Box.UNIT_WIDTH,Box.UNIT_WIDTH},
        {2*Box.UNIT_WIDTH,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},{2*Box.UNIT_WIDTH,Box.UNIT_WIDTH},
        {0,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},{2*Box.UNIT_WIDTH,Box.UNIT_WIDTH},
        {0,0},{0,Box.UNIT_WIDTH},{0,2*Box.UNIT_WIDTH},{0,3*Box.UNIT_WIDTH},
        {0,0},{Box.UNIT_WIDTH,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH}
    };
    
    //旋转三次后的方块（顺时针）
    public static final int thShapeBox[][] = {
        {0,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH},{0,2*Box.UNIT_WIDTH},
        {0,0},{0,Box.UNIT_WIDTH},{0,2*Box.UNIT_WIDTH},{Box.UNIT_WIDTH,2*Box.UNIT_WIDTH},
        {0,0},{Box.UNIT_WIDTH,0},{0,Box.UNIT_WIDTH},{0,2*Box.UNIT_WIDTH},
        {0,0},{Box.UNIT_WIDTH,0},{2*Box.UNIT_WIDTH,0},{3*Box.UNIT_WIDTH,0},
        {0,0},{Box.UNIT_WIDTH,0},{0,Box.UNIT_WIDTH},{Box.UNIT_WIDTH,Box.UNIT_WIDTH}
    };
    */
    
    /*
     * drawModel方法是为了画出方块模型
     * fIndex的范围是[0,20)，其中[0,5)表示初始的方块（总共有五个方块），[5,10)表示第一次旋转后的方块。。。
     * sIndex是每个方块组的方块的编号
     * index是每个组的方块的起始编号，由于是每四个为一个方块的位置描述，所以要用sIndex*4
     */
    public void drawModel(Graphics g,int fIndex,int x,int y){
        Color c = g.getColor();
        int sIndex = fIndex % 5;
        
        if(fIndex >= 20){
            try {
                throw new Exception("wrong index,there is no this box...the surround of index is 0 - 19");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        switch(sIndex){
        case 0:
            g.setColor(Color.BLUE);
            break;
        case 1:
            g.setColor(Color.GREEN);
            break;
        case 2:
            g.setColor(Color.MAGENTA);
            break;
        case 3:
            g.setColor(Color.ORANGE);
            break;
        case 4:
            g.setColor(Color.RED);
            break;
        }
        
        int index = fIndex * 4;
        g.fillRect(x + shapeBox[index][0], y + shapeBox[index][1], Box.UNIT_WIDTH, Box.UNIT_WIDTH);
        g.fillRect(x + shapeBox[index+1][0], y + shapeBox[index+1][1], Box.UNIT_WIDTH, Box.UNIT_WIDTH);
        g.fillRect(x + shapeBox[index+2][0], y + shapeBox[index+2][1], Box.UNIT_WIDTH, Box.UNIT_WIDTH);
        g.fillRect(x + shapeBox[index+3][0], y + shapeBox[index+3][1], Box.UNIT_WIDTH, Box.UNIT_WIDTH);
        
        g.setColor(c);
        
    }

}

Box.java

import java.awt.*;
import java.awt.event.*;
import java.util.Random;

public class Box {
    public static final int BOX_NUM = 15;
    public static final int UNIT_WIDTH =  RussiaBoxClient.GAME_WIDTH / BOX_NUM;
    //public static final int UNIT_HEIGHT = RussiaBoxClient.GAME_HEIGHT / 15;
    private int x,y;
    RussiaBoxClient rbc ;
//    Color cBox;
    private static Random r = new Random();
    Model boxModel = new Model();
    int index;//选择方块的形状
    boolean edge = false;//检测方块是否碰到了其他东西
    //int eBottom[][] = new int[3][2];

    public Box(RussiaBoxClient rbC) {
        this.x = BOX_NUM / 2 * UNIT_WIDTH;
        this.y = 0;
        this.index = r.nextInt(20);
        this.rbc = rbC;
    }
    
    public void draw(Graphics g){
        if (!edge) {
            //y += 20;
            y += UNIT_WIDTH;
        }
        boxModel.drawModel(g, index, x, y);
    }
    
//    private boolean hitBox(){
//        for(int i = 0;i < BOX_NUM;i ++){
//            for(int j = 0;j < 3;j ++){
//                if(eBottom[j][0] == rbc.edgeBottom[i][0] && eBottom[j][1] == rbc.edgeBottom[i][1]){
//                    edge = true;
//                    rbc.boxes.add(this);
//                    for(int k = j;k < 3;k ++)
//                    {
//                        rbc.edgeBottom[i + k - j][1] -= (rbc.edgeBottom[i + k - j][1] - y);
//                    }
//                    for(int k = 0;k < j;k ++){
//                        rbc.edgeBottom[i + k - j][1] -= (rbc.edgeBottom[i + k - j][1] - y);
//                    }
//                    return true;
//                }
//            }
//        }
//        return false;
//    }
    //判断是否碰到边框的底部
    private boolean isBottom(int sIndex){
        for(int i = 0;i < 4;i ++){
            if(Model.shapeBox[sIndex+i][1]+y >= RussiaBoxClient.GAME_HEIGHT - UNIT_WIDTH)
                return true;
        }
        return false;
    }
    
    //将方块里面的一个一个得小正方形加入到RussiaBoxClient中的pDraw中去
    private void addItem(int sIndex){
        edge = true;
        
        int ii = index % 5;
        Color cc;
        if(ii == 0){
            cc = Color.BLUE;
        }else if(ii == 1)
        {
            cc = Color.GREEN;
        }else if(ii == 2)
        {
            cc = Color.MAGENTA;
        }else if(ii == 3)
        {
            cc = Color.ORANGE;
        }else
        {
            cc = Color.RED;
        }
        
        rbc.pDraw.add(new DrawPoint(Model.shapeBox[sIndex][0] + x,Model.shapeBox[sIndex][1] + y,cc));
        rbc.pDraw.add(new DrawPoint(Model.shapeBox[sIndex + 1][0] + x,Model.shapeBox[sIndex+1][1] + y,cc));
        rbc.pDraw.add(new DrawPoint(Model.shapeBox[sIndex + 2][0] + x,Model.shapeBox[sIndex+2][1] + y,cc));
        rbc.pDraw.add(new DrawPoint(Model.shapeBox[sIndex + 3][0] + x,Model.shapeBox[sIndex+3][1] + y,cc));
    }
    
    //判断是否撞到边界和其他小方块
    public boolean hit(){
        if(edge)
            return true;
        
        if(isBottom(4*index))
        {
            addItem(4*index);
            return true;
        }
        
        for(int i = 0;i < 4;i ++)
        {
            int sIndex = index * 4;
            
            //System.out.println(Model.shapeBox[sIndex+i][1]);
            
            Rectangle r1 = new Rectangle(Model.shapeBox[sIndex + i][0] + x,Model.shapeBox[sIndex+i][1] + y + UNIT_WIDTH,UNIT_WIDTH,UNIT_WIDTH);
            
            for(int j = 0;j < rbc.pDraw.size();j ++){
                Rectangle r2 = new Rectangle(rbc.pDraw.get(j).x,rbc.pDraw.get(j).y,UNIT_WIDTH,UNIT_WIDTH);
                
                if(r1.intersects(r2))
                {
                    addItem(sIndex);
                    return true;
                }
            }
        }
        
        
        return false;
    }
    
    //方块旋转时是否超过了框架的左右边框
    private boolean overEdge(int sIndex){
        for(int i = 0;i < 4;i ++){
            if(Model.shapeBox[sIndex + i][0] + x >= RussiaBoxClient.GAME_WIDTH - UNIT_WIDTH || Model.shapeBox[sIndex + i][0] + x <= 0){
                return true;
            }
        }
        return false;
    }
    
    //监听按键事件
    public void bKeyPressed(KeyEvent e){
        int key = e.getKeyCode();

        if (!edge) {
            switch (key) {
            case KeyEvent.VK_DOWN:
                if(!hit()){
                    y += UNIT_WIDTH;
                }
                break;
            case KeyEvent.VK_RIGHT:
                if(!overEdge(4*index)){
                    x += UNIT_WIDTH;
                }
                break;
            case KeyEvent.VK_LEFT:
                if(!overEdge(4*index)){
                    x -= UNIT_WIDTH;
                }
                break;
            case KeyEvent.VK_SPACE:
                index += 5;
                if (index >= 20)
                    index %= 20;
                
                break;
            }
        }
        
    }
}

DrawPoint.java

import java.awt.*;


public class DrawPoint {
    int x,y;
    private Color cBox;
    
    public DrawPoint(int x, int y, Color cBox) {
        this.x = x;
        this.y = y;
        this.cBox = cBox;
    }
    
    public void draw(Graphics g){
        Color c = g.getColor();
        g.setColor(cBox);
        
        g.fillRect(x, y, Box.UNIT_WIDTH, Box.UNIT_WIDTH);
        
        g.setColor(c);
    }

}

RussiaBoxClient.java

import java.awt.*;
import java.awt.event.*;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.ArrayList;

public class RussiaBoxClient extends Frame{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    
    public static final int GAME_HEIGHT = 400;
    public static final int GAME_WIDTH = 300;
    
    Image offScreen = null;
    Box box = null;
    int scores;
    int times;
//    public int edgeBottom[][]  = new int[Box.BOX_NUM][2];
    
//    List<Box> boxes = new ArrayList<Box>();
    List<DrawPoint> pDraw = new ArrayList<DrawPoint>();
    Cmp cmp = new Cmp();
    
    public static void main(String[] args) {
        new RussiaBoxClient().launchFrame();
    }

//    private void setEdgeBottom(){
//        for(int i = 0;i < Box.BOX_NUM;i ++){
//            edgeBottom[i][0] = i * Box.UNIT_WIDTH;
//            edgeBottom[i][1] = GAME_HEIGHT;
//        }
//    }
    
    private void launchFrame(){
        this.setLocation(500, 150);
        setSize(GAME_WIDTH,GAME_HEIGHT);
        this.setBackground(Color.cyan);

        pDraw.clear();
        scores = 0;
        times = 700;
    //    setEdgeBottom();
        
        this.addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
                System.exit(0);
            }
        });
        this.addKeyListener(new keyMonitor());
        
        this.setResizable(false);
        this.setTitle("俄罗斯方块");
        this.setVisible(true);
        
        new Thread(new ThreadMonitor()).start();
    }
    
    //绘图
    public void paint(Graphics g) {
        g.drawString("your scores are: "+scores, 10, 10);
        if(box == null)
        {
            box = new Box(this);
        }
        
        for(int i = 0;i < pDraw.size();i ++){
            pDraw.get(i).draw(g);
        }
        
        if (!box.edge) {
            if(box.hit())
            {
                Collections.sort(pDraw,cmp);
                
                decBox();
            }
            box.draw(g);
        }else
        {
            box = null;
        }
    }

    //利用双缓冲更新主框架界面
    public void update(Graphics g) {
        if(offScreen == null){
            offScreen = this.createImage(GAME_WIDTH,GAME_HEIGHT);
        }
        Graphics gOffScreen = offScreen.getGraphics();
        Color c = gOffScreen.getColor();
        gOffScreen.setColor(Color.cyan);
        gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT);
        gOffScreen.setColor(c);
        
        paint(gOffScreen);
        g.drawImage(offScreen, 0, 0, null);
        
    }

    /*private boolean dealRecord(int i,boolean record[]){
        if(i == 1){
            for(int j = 0;j < Box.BOX_NUM;j ++){
                record[j] = false;
            }
            return true;
        }else if(i == 2){
            for(int j = 0;j < Box.BOX_NUM;j ++){
                if(!record[j])
                    return false;
            }
            return true;
        }
        return true;
    }
    */
    //消解方块
    private void decBox(){
        //boolean record[] = new boolean[Box.BOX_NUM];
        //dealRecord(1,record);
        int num = 0;
        for(int i = 0;i < pDraw.size() - 1;i ++){
            if(pDraw.get(i).y == pDraw.get(i+1).y){
                //record[pDraw.get(i).x / Box.UNIT_WIDTH] = true;
                //record[pDraw.get(i + 1).x / Box.UNIT_WIDTH] = true;
                num ++;
            }else
            {
                //record[pDraw.get(i).x / Box.UNIT_WIDTH] = false;
                //record[pDraw.get(i + 1).x / Box.UNIT_WIDTH] = false;
                num = 0;
            }
            if( num == Box.BOX_NUM - 1){
                scores ++;
                /*for(int j = 0;j < pDraw.size();j ++){
                    System.out.println(pDraw.get(j).x + " " + pDraw.get(j).y);
                }
                */
                if(i + 2 < pDraw.size()){
                    for(int j = i + 2;j < pDraw.size();j ++){
//                        System.out.println("up  "+ j + ":"+pDraw.get(j).x + " " + pDraw.get(j).y);
                        pDraw.get(j).y += Box.UNIT_WIDTH;
                    }
                }
                for(int j = 0;j < Box.BOX_NUM;j ++){
                    int k = i + 2 - Box.BOX_NUM;
                    //System.out.println("delete  "+k + ":" + pDraw.get(k).x +" " + pDraw.get(k).y);
                    //if(k >= 0 && k < pDraw.size())
                        pDraw.remove(k);
                }
//                for(int j = 0;j < pDraw.size();j ++){
//                    System.out.println("Second:");
//                    System.out.println(pDraw.get(j).x + " " + pDraw.get(j).y);
//                }
                //dealRecord(1,record);
                num = 0;
                i -= num;
            }
        }
    }
    //重绘线程
    private class ThreadMonitor implements Runnable{

        public void run() {
            while(true){
                
                repaint();
                
                try {
                    Thread.sleep(times);
                    times -= (scores/10 *50);
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }
            }
        }
        
    }

    //主框架监听键盘事件
    private class keyMonitor extends KeyAdapter{

        public void keyPressed(KeyEvent e) {
            box.bKeyPressed(e);
        }
        
    }

    //写比较器类排序pDraw
    class Cmp implements Comparator<DrawPoint>{
        public int compare(DrawPoint d1,DrawPoint d2){
            if(d1.y < d2.y){
                return 1;
            }
            else if(d1.y == d2.y){
                if(d1.x > d2.x){
                    return 1;
                }else if(d1.x == d2.x){
                    return 0;
                }else
                {
                    return -1;
                }
            }else
                return -1;
        }
    }
}