mypanel.java

JAVA编写的俄罗斯方块游戏

package MiniGame;

import java.awt.*;
import java.io.*;

import javax.swing.*;

public class MyPanel extends JPanel implements Runnable {
    int myBlockSize = 30;
    int cols = 360 / myBlockSize;
    int rows = 480 / myBlockSize;
    int mid = cols / 2;
    int level = 1;
    int level_add = 0;
    int grade_add = 300;
    static int grade = 0;
    boolean reachTop = false;



    private boolean isPaused = false;
    private boolean isStoped = true;
    private boolean isStarted = false;
   public  Thread th = null;
    public Block[] preview = new Block[4];
    public Block[] current = new Block[4];
    public int[][] grid = new int[cols][rows];
    static  public  int[][] pregrid = new int[4][4];
    public static Color[] colors = {Color.WHITE, Color.red,
                                   Color.CYAN, Color.GREEN, Color.pink,
                                   Color.YELLOW,
                                   Color.darkGray, Color.blue};

    private static final int NoBlock = 0;



    public MyPanel() {
        InitPanel();

    }

    public void InitPanel()
    {
        if(MyFrame.isLarge)
        {
            myBlockSize = 30;
        }
        else
        {
            myBlockSize = 20;
        }
        level_add = level;
        cols = 360 / myBlockSize;
        rows = 480 / myBlockSize;
        mid = cols / 2;
        grade = 0;

        grid = new int[cols + 3][rows + 3];
        pregrid = new int[4][4];

        for (int i = 0; i < 4; i++)
        {
            current[i] = new Block(0, 0, 0);
            preview[i] = new Block(0, 0, 0);
        }
        repaint();

    }

    public void startGame()
    {
        if(isPaused)
        {
            th.resume();
            isPaused = false;
            return;
        }
        InitPanel();
        newShape();
        for (int i = 0; i < 4; i++)
            current[i] = preview[i];
        pregrid = new int[4][4];
        newShape();
        repaint();

        th = new Thread(MyPanel.this);
        isStarted = true;
        isStoped = false;
        th.start();

    }

    public void pauseGame()
    {
        th.suspend();
        isPaused = true;
        isStarted = false;
        isStoped = false;
    }

    public void stopGame()
    {
        MyFrame.setMenu();

        Recording rec = new Recording();
        System.out.println("recording");
        th.stop();
        InitPanel();
        repaint();
        isStarted = false;
        isPaused = false;
        isStoped = true;
    }

    public void paint(Graphics g) {

        super.paintComponent(g);
        GameApp.frame.jLabel_grade.setText(Integer.toString(grade));

        for (int i = 0; i < cols; i++) {
            for (int j = 0; j < rows; j++) {
                g.setColor(colors[grid[i][j]]);
                g.fill3DRect(i * myBlockSize, j * myBlockSize, myBlockSize,
                             myBlockSize, true);
            }
        }

        g.setColor(colors[current[0].color]);
        for (int m = 0; m < 4; m++) {

            int prex = current[m].x;
            int prey = current[m].y;
            g.fill3DRect(prex * myBlockSize, prey * myBlockSize, myBlockSize,
                         myBlockSize, true);
        }

    }

    public void changetop() {

    }


    public synchronized void run() {

        while (true) {

            try {
                Thread.sleep(800 / level);

            } catch (InterruptedException ex) {
            }
            if(!MyFrame.isDownPressed)
            {
                nextHowTo();
                repaint();
            }
        }

    }

    public void nextHowTo() {
        boolean canDown = true; //是否可以继续下落 为真时可以
        for (int p = 0; p < 4; p++) {
            if (!(current[p].isInRange(cols, rows))) {
                canDown = false;
                break;
            }
            if (grid[current[p].x][(current[p].y) + 1] != this.NoBlock) {
                canDown = false;
                break;
            }
        }
        if (!canDown)
        {
            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    pregrid[i][j] = 0;
                }
            }

            for (int k = 0; k < 4; k++)
            {
                if (current[k].y == 0)
                {
                    reachTop = true;
                    break;
                }
            }

            if (reachTop)
            {
                System.out.println("stop");
                stopGame();
            }
            if (!reachTop) {
                for (int j = 0; j < 4; j++)
                {
                    grid[current[j].x][current[j].y] = current[j].color;
                }

                for (int aa = 0; aa < rows; aa++) {
                    boolean cutRow = true;
                    for (int bb = 0; bb < cols; bb++) {
                        if (grid[bb][aa] == 0) {
                            cutRow = false;
                            break;
                        }
                    }

                    if (cutRow) {
                        grade += 100;
                        for (int h2 = aa; h2 > 0; h2--) {
                            for (int g2 = 0; g2 < cols; g2++) {
                                grid[g2][h2] = grid[g2][h2 - 1];
                            }
                        }
                    }
                    level = grade / grade_add + level_add; //每300分level增加当前的level
                     GameApp.frame.jLabel_level.setText(Integer.toString(level));
                }
                GameApp.frame.jPanel_next.repaint();
            }
            reachTop = false;
            clear();

        }
        for (int t = 0; t < 4; t++)
        {
                    current[t].y++;
         }

    }
//新的一局
    public void clear() {
            for (int k = 0; k < 4; k++)
            {
                current[k] = preview[k];
            }
            pregrid = new int[4][4];
            newShape();
            repaint();
        }

//旋转事件响应的实现
        public void changeShape() {
            //田字形 特殊处理
            if (current[0].color == 1) {

                return;
            }

            boolean rol = true;
            Block newPos[] = new Block[4];
            for (int i = 0; i < 4; i++) {

                int dx = current[i].x - this.current[0].x;
                int dy = this.current[i].y - this.current[0].y;
                if ((current[0].x - dy) > cols - 1 || (current[0].x - dy) < 0
                    || (current[0].y + dx) > rows - 1
                    || grid[current[0].x - dy + 1][current[0].y + dx + 1] > 0) {
                    rol = false;
                    break;
                } else {
                    newPos[i] = new Block(
                            current[0].x - dy,
                            current[0].y + dx,
                            current[0].color);
                }

            }
            if (rol) {
                for (int j = 0; j < 4; j++) {
                    current[j] = newPos[j];
                }
            }
            return;

        }

        public void newShape() {
            int color = (int) (Math.random() * 7) + 1;

            switch (color) {
            case 1:
                preview[0] = new Block(mid, 0, color);
                preview[1] = new Block(mid + 1, 0, color);
                preview[2] = new Block(mid, -1, color);
                preview[3] = new Block(mid + 1, -1, color);
                pregrid[1][1] = color;
                pregrid[1][2] = color;
                pregrid[2][1] = color;
                pregrid[2][2] = color;
                break;
            case 2:
                preview[0] = new Block(mid, 0, color);
                preview[1] = new Block(mid - 1, 0, color);
                preview[2] = new Block(mid + 1, 0, color);
                preview[3] = new Block(mid + 2, 0, color);
                pregrid[0][2] = color;
                pregrid[1][2] = color;
                pregrid[2][2] = color;
                pregrid[3][2] = color;

                break;
            case 3:
                preview[0] = new Block(mid, 0, color);
                preview[1] = new Block(mid, -1, color);
                preview[2] = new Block(mid - 1, 0, color);
                preview[3] = new Block(mid + 1, 0, color);
                pregrid[2][1] = color;
                pregrid[1][2] = color;
                pregrid[2][2] = color;
                pregrid[3][2] = color;

                break;
            case 4:
                preview[0] = new Block(mid, -1, color);
                preview[1] = new Block(mid - 1, 0, color);
                preview[2] = new Block(mid - 1, -1, color);
                preview[3] = new Block(mid + 1, -1, color);
                pregrid[1][1] = color;
                pregrid[2][1] = color;
                pregrid[3][1] = color;
                pregrid[1][2] = color;

                break;
            case 5:
                preview[0] = new Block(mid, -1, color);
                preview[1] = new Block(mid - 1, -1, color);
                preview[2] = new Block(mid + 1, -1, color);
                preview[3] = new Block(mid + 1, 0, color);
                pregrid[1][1] = color;
                pregrid[2][1] = color;
                pregrid[3][1] = color;
                pregrid[3][2] = color;

                break;
            case 6:
                preview[0] = new Block(mid, 0, color);
                preview[1] = new Block(mid + 1, 0, color);
                preview[2] = new Block(mid, -1, color);
                preview[3] = new Block(mid - 1, -1, color);
                pregrid[1][1] = color;
                pregrid[2][1] = color;
                pregrid[2][2] = color;
                pregrid[3][2] = color;

                break;
            case 7:
                preview[0] = new Block(mid, 0, color);
                preview[1] = new Block(mid - 1, 0, color);
                preview[2] = new Block(mid, -1, color);
                preview[3] = new Block(mid + 1, -1, color);
                pregrid[1][2] = color;
                pregrid[2][2] = color;
                pregrid[2][1] = color;
                pregrid[3][1] = color;

                break;

            default:
                break;
            }
        }

    }