• 俄罗斯方块

    一.准备工作

    先创建一个新的Java项目命名为“俄罗斯方块”。再在该项目中创建一个文件夹命名为”images”，并将所需的图片素材拖入该文件夹。

    二.代码呈现 

    编写小方块类：

    1. import java.awt.image.BufferedImage;
    2.  
    3.  
    4. /**
    5.  * 描述:小方块类
    6.  * 属性：行，列以及单元格的图片
    7.  * 方法: 左移一格，右移一格，下移一格
    8.  */
    9.  
    10. public class Cell {
    11.     private int row;
    12.     private int col;
    13.     private BufferedImage image;
    14.  
    15.     public Cell() {
    16.     }
    17.  
    18.     public Cell(int row, int col, BufferedImage image) {
    19.         this.row = row;
    20.         this.col = col;
    21.         this.image = image;
    22.     }
    23.  
    24.     public int getRow() {
    25.         return row;
    26.     }
    27.  
    28.     public void setRow(int row) {
    29.         this.row = row;
    30.     }
    31.  
    32.     public int getCol() {
    33.         return col;
    34.     }
    35.  
    36.     public void setCol(int col) {
    37.         this.col = col;
    38.     }
    39.  
    40.     public BufferedImage getImage() {
    41.         return image;
    42.     }
    43.  
    44.     public void setImage(BufferedImage image) {
    45.         this.image = image;
    46.     }
    47.     //左移
    48.     public void left() {
    49.         col--;
    50.     }
    51.     //右移
    52.     public void right() {
    53.         col++;
    54.     }
    55.     //下移
    56.     public void soft() {
    57.         row++;
    58.     }
    59. }

    编写四方格父类：

    1. /**
    2.  * 描述：四方格父类
    3.  * 属性：Cell[]数组用于创建4个小方块
    4.  * 方法：左移一格，右移一格，下移一格，变形
    5.  */
    6. public class Tetromino {
    7.     protected Cell[] cells = new Cell[4];
    8.  
    9.     //左移
    10.     public void moveLeft() {
    11.         for (Cell cell : cells) {
    12.             cell.left();
    13.         }
    14.     }
    15.     //右移
    16.     public void moveRight() {
    17.         for (Cell cell : cells) {
    18.             cell.right();
    19.         }
    20.     }
    21.     //下移
    22.     public void sftDrop() {
    23.         for (Cell cell : cells) {
    24.             cell.drop();
    25.         }
    26.     }
    27.     //随机生成四方格
    28.     public static Tetromino randomOne() {
    29.         int num = (int)(Math.random() * 7);
    30.         Tetromino tetromino = null;
    31.         switch (num) {
    32.             case 0 :
    33.                 tetromino = new I();
    34.                 break;
    35.             case 1 :
    36.                 tetromino = new J();
    37.                 break;
    38.             case 2 :
    39.                 tetromino = new L();
    40.                 break;
    41.             case 3 :
    42.                 tetromino = new O();
    43.                 break;
    44.             case 4 :
    45.                 tetromino = new S();
    46.                 break;
    47.             case 5 :
    48.                 tetromino = new T();
    49.                 break;
    50.             case 6 :
    51.                 tetromino = new Z();
    52.                 break;
    53.         }
    54.         return tetromino;
    55.     }
    56.     //编写旋转状态
    57.     protected State[] states;
    58.     //声明旋转次数
    59.     protected int count = 10000;
    60.     /**描述：四方格旋转状态的内部类
    61.      * 属性：记录四方格的相对位置
    62.      */
    63.     class State {
    64.         int row0,col0,row1,col1,row2,col2,row3,col3;
    65.  
    66.         public State(){
    67.  
    68.         }
    69.  
    70.         public State(int row0, int col0, int row1, int col1, int row2, int col2, int row3, int col3) {
    71.             this.row0 = row0;
    72.             this.col0 = col0;
    73.             this.row1 = row1;
    74.             this.col1 = col1;
    75.             this.row2 = row2;
    76.             this.col2 = col2;
    77.             this.row3 = row3;
    78.             this.col3 = col3;
    79.         }
    80.  
    81.         public int getRow0() {
    82.             return row0;
    83.         }
    84.  
    85.         public void setRow0(int row0) {
    86.             this.row0 = row0;
    87.         }
    88.  
    89.         public int getRow1() {
    90.             return row1;
    91.         }
    92.  
    93.         public void setRow1(int row1) {
    94.             this.row1 = row1;
    95.         }
    96.  
    97.         public int getRow2() {
    98.             return row2;
    99.         }
    100.  
    101.         public void setRow2(int row2) {
    102.             this.row2 = row2;
    103.         }
    104.  
    105.         public int getRow3() {
    106.             return row3;
    107.         }
    108.  
    109.         public void setRow3(int row3) {
    110.             this.row3 = row3;
    111.         }
    112.  
    113.         public int getCol0() {
    114.             return col0;
    115.         }
    116.  
    117.         public void setCol0(int col0) {
    118.             this.col0 = col0;
    119.         }
    120.  
    121.         public int getCol1() {
    122.             return col1;
    123.         }
    124.  
    125.         public void setCol1(int col1) {
    126.             this.col1 = col1;
    127.         }
    128.  
    129.         public int getCol2() {
    130.             return col2;
    131.         }
    132.  
    133.         public void setCol2(int col2) {
    134.             this.col2 = col2;
    135.         }
    136.  
    137.         public int getCol3() {
    138.             return col3;
    139.         }
    140.  
    141.         public void setCol3(int col3) {
    142.             this.col3 = col3;
    143.         }
    144.     }
    145.     //编写顺时针旋转四方格方法
    146.     public void rotateRight() {
    147.         if (states.length == 0) {
    148.             return;
    149.         }
    150.         //旋转次数加1
    151.         count++;
    152.         //获取当前状态
    153.         State s = states[count % states.length];
    154.         Cell cell = cells[0];
    155.         int row = cell.getRow();
    156.         int col = cell.getCol();
    157.         //变形
    158.         cells[1].setRow(row + s.row1);
    159.         cells[1].setCol(col + s.col1);
    160.         cells[2].setRow(row + s.row2);
    161.         cells[2].setCol(col + s.col2);
    162.         cells[3].setRow(row + s.row3);
    163.         cells[3].setCol(col + s.col3);
    164.     }
    165.     //逆时针旋转四方格方法
    166.     public void rotateLeft() {
    167.         //旋转次数加1
    168.         count--;
    169.         //获取当前状态
    170.         State s = states[count % states.length];
    171.         Cell cell = cells[0];
    172.         int row = cell.getRow();
    173.         int col = cell.getCol();
    174.         //变形
    175.         cells[1].setRow(row + s.row1);
    176.         cells[1].setCol(col + s.col1);
    177.         cells[2].setRow(row + s.row2);
    178.         cells[2].setCol(col + s.col2);
    179.         cells[3].setRow(row + s.row3);
    180.         cells[3].setCol(col + s.col3);
    181.     }
    182.     //顺时针旋转
    183.     public void rotateRightAction() {
    184.         Tetromino currentOne = null;
    185. 		currentOne.rotateRight();
    186.         //判断是否越界或者重合，否则恢复原来的状态
    187.         if (outOfBounds() || coincide()) {
    188.             currentOne.rotateLeft();
    189.         }
    190.     }
    191.     private boolean coincide() {
    192. 		// TODO Auto-generated method stub
    193. 		return false;
    194. 	}
    195. 	private boolean outOfBounds() {
    196. 		// TODO Auto-generated method stub
    197. 		return false;
    198. 	}
    199. 	//判断游戏是否结束,结束返回true，继续返回false
    200.     public boolean isGameOver() {
    201.         Cell[] cells = nextOne.cells;
    202.         for (Cell cell : cells) {
    203.             int row = cell.getRow();
    204.             int col = cell.getCol();
    205.             if (wall[row][col] != null) {
    206.                 return true;
    207.             }
    208.         }
    209.         return false;
    210.     }
    211.     //判断当前行是否满,满返回true，没有满返回false
    212.     public boolean isFullLine(int row) {
    213.         Cell[] cells = wall[row];
    214.         for (Cell cell : cells) {
    215.             if (cell == null) {
    216.                 return false;
    217.             }
    218.         }
    219.         return true;
    220.     }
    221.     //创建销行方法
    222.     public void  destroyLine() {
    223.         //统计当前形参行数
    224.         int line = 0;
    225.         Cell[] cells = currentOne.cells;
    226.         for (Cell cell : cells) {
    227.             int row = cell.getRow();
    228.             //判断当前行是否满
    229.             if (isFullLine(row)) {
    230.                 line++;
    231.                 //将消除行以上的方块下落到对应行数
    232.                 for (int i = row; i > 0; i--) {
    233.                     System.arraycopy(wall[i - 1],0,wall[i],0,wall[0].length);
    234.                 }
    235.                 //重新创造第一行
    236.                 wall[0] = new Cell[9];
    237.             }
    238.         }
    239.         //更新分数
    240.         totalScore += scores_pool[line];
    241.         //更新消除行数
    242.         totalLine += line;
    243.     }
    244.     //判断四方格能否下落
    245.     public boolean canDrop() {
    246.         Cell[] cells = currentOne.cells;
    247.         for (Cell cell : cells) {
    248.             int row = cell.getRow();
    249.             int col = cell.getCol();
    250.             //判断能否全部到达底部
    251.             if (row == wall.length - 1) {
    252.                 return false;
    253.             } else if(wall[row + 1][col] != null) { //判断该位置是否有方块
    254.                 return false;
    255.             }
    256.         }
    257.         return true;
    258.     }
    259.     //按键一次四方格下落一个
    260.     public void sortDropAction() {
    261.         //判断能否下落
    262.         if (canDrop()) {
    263.             //当前四方格下落一格
    264.             currentOne.softDrop();
    265.         } else {
    266.             //把四方格嵌入墙中
    267.             landToWall();
    268.             //判断能否销行
    269.             destroyLine();
    270.             //判断游戏是否结束
    271.             if (isGameOver()) {
    272.                 game_state = GAMEOVER;
    273.             } else {
    274.                 //继续生成四方格
    275.                 currentOne = nextOne;
    276.                 nextOne = Tetromino.randomOne();
    277.             }
    278.         }
    279.  
    280.     }
    281.     //把四方格嵌入墙中
    282.     private void landToWall() {
    283.         Cell[] cells = currentOne.cells;
    284.         for (Cell cell : cells) {
    285.             int row = cell.getRow();
    286.             int col = cell.getCol();
    287.             wall[row][col] = cell;
    288.         }
    289.     }
    290.     //瞬间下落
    291.     public void handDropAction() {
    292.         while (canDrop()) {
    293.             currentOne.softDrop();
    294.         }
    295.         //把四方格嵌入墙中
    296.         landToWall();
    297.         //判断能否销行
    298.         destroyLine();
    299.         //判断游戏是否结束
    300.         if (isGameOver()) {
    301.             game_state = GAMEOVER;
    302.         } else {
    303.             //继续生成四方格
    304.             currentOne = nextOne;
    305.             nextOne = Tetromino.randomOne();
    306.         }
    307.     }
    308.     public void start() {
    309.         game_state = PLAYING;
    310.         KeyListener listener = new KeyAdapter() {
    311.             @Override
    312.             public void keyPressed(KeyEvent e) {
    313.                 int code = e.getKeyCode();
    314.                 switch (code) {
    315.                     case KeyEvent.VK_DOWN: //↓
    316.                         sortDropAction(); //下落一格
    317.                         break;
    318.                     case KeyEvent.VK_LEFT://←
    319.                         moveLeftAction(); //左移一格
    320.                         break;
    321.                     case KeyEvent.VK_RIGHT: //→
    322.                         moveRightAction(); //右移一格
    323.                         break;
    324.                     case KeyEvent.VK_UP://↑
    325.                         rotateRightAction();//顺时针旋转
    326.                         break;
    327.                     case KeyEvent.VK_SPACE://空格
    328.                         handDropAction();//瞬间下落
    329.                         break;
    330.                     case KeyEvent.VK_P: //p
    331.                         //判断游戏是否在运行,没有才能暂停
    332.                         if (game_state == PLAYING) {
    333.                             game_state = PAUSE;
    334.                         }
    335.                         break;
    336.                     case KeyEvent.VK_C:
    337.                         //游戏暂停后，才能继续
    338.                         if (game_state == PAUSE) {
    339.                             game_state = PLAYING;
    340.                         }
    341.                         break;
    342.                     case KeyEvent.VK_R:
    343.                         //重新开始游戏，把游戏状态变为正在游戏
    344.                         game_state = PLAYING;
    345.                         //界面清空
    346.                         wall = new Cell[ROW][COL];
    347.                         currentOne = Tetromino.randomOne();
    348.                         nextOne = Tetromino.randomOne();
    349.                         //数据清空
    350.                         totalLine = 0;
    351.                         totalScore = 0;
    352.                         break;
    353.  
    354.                 }
    355.             }
    356.         };
    357.         //把俄罗斯方块窗口设置为焦点
    358.         this.addKeyListener(listener);
    359.         this.requestFocus();
    360.  
    361.         while(true){
    362.             //判断，当前游戏状态在游戏中时，每隔0.5秒下落
    363.             if(game_state == PLAYING){
    364.                 try {
    365.                     Thread.sleep(700);
    366.                 } catch (InterruptedException e) {
    367.                     e.printStackTrace();
    368.                 }
    369.                 //判断能否下落
    370.                 if(canDrop()){
    371.                     currentOne.softDrop();
    372.                 }else{
    373.                     //嵌入到墙中
    374.                     landToWall();
    375.                     //判断能否消行
    376.                     destroyLine();
    377.                     //判断游戏是否结束
    378.                     if(isGameOver()){
    379.                         game_state = GAMEOVER;
    380.                     }else{
    381.                         currentOne = nextOne;
    382.                         nextOne = Tetromino.randomOne();
    383.                     }
    384.                 }
    385.             }
    386.             //重新绘制
    387.             repaint();
    388.         }
    389.     }
    390.  
    391.  
    392. }

    编写俄罗斯方块主类：

    1. import javax.imageio.ImageIO;
    2. import javax.swing.*;
    3. import java.awt.*;
    4. import java.awt.image.BufferedImage;
    5. import java.io.File;
    6. import java.io.IOException;
    7.  
    8. //俄罗斯方块主类
    9. public class Tetris extends JPanel {
    10. 	static int ROW=18;
    11. 	static int COL=9;
    12. 	//声明正在下落的方块
    13.     private Tetromino currentOne = Tetromino.randomOne();
    14.     //声明将要下落的方块
    15.     private Tetromino nextOne = Tetromino.randomOne();
    16.     //声明游戏主区域
    17.     private Cell[][] wall = new Cell[ROW][COL];
    18.     //声明单元格像素为48像素
    19.     private static final int CELL_SIZE=48;
    20.     //游戏分数池
    21.     int[] scores_pool = {0, 1, 2, 5, 10};
    22.     //游戏总分
    23.     private int totalScore = 0;
    24.     //游戏消除总行数
    25.     private int totalLine = 0;
    26.     //游戏的状态：游戏中，游戏暂停，游戏结束
    27.     private static final int PLAYING=0;
    28.     private static final int PAUSE=1;
    29.     private static final int GAMEOVER=2;
    30.     //声明变量来存放当前游戏状态
    31.     private int game_state;
    32.     //数组显示当前游戏状态
    33.     String[] show_state= {"P[暂停]","C[继续]","R[重开]"};
    34.     //静态载入图片
    35.     public static BufferedImage I;
    36.     public static BufferedImage J;
    37.     public static BufferedImage L;
    38.     public static BufferedImage O;
    39.     public static BufferedImage S;
    40.     public static BufferedImage T;
    41.     public static BufferedImage Z;
    42.     public static BufferedImage backImage;
    43.  
    44.     static {
    45.         try {
    46.             I = ImageIO.read(new File(pathname:"images/I.png"));
    47.             J = ImageIO.read(new File(pathname:"images/J.png"));
    48.             L = ImageIO.read(new File(pathname:"images/L.png"));
    49.             O = ImageIO.read(new File(pathname:"images/O.png"));
    50.             S = ImageIO.read(new File(pathname:"images/S.png"));
    51.             T = ImageIO.read(new File(pathname:"images/T.png"));
    52.             Z = ImageIO.read(new File(pathname:"images/Z.png"));
    53.             backImage=ImageIO.read(new File(pathname:"images/background.png"));
    54.         } catch (IOException e) {
    55.             e.printStackTrace();
    56.         }
    57.         
    58.     }
    59.     public static void main(String[] args) {
    60.         //创建窗口对象
    61.         JFrame frame = new JFrame(title:"俄罗斯方块");
    62.         //创建游戏窗口(即面板)
    63.         Tetris panel = new Tetris();
    64.         //把面板嵌入到窗口中
    65.         frame.add(panel);
    66.         //设置可见
    67.         frame.setVisible(true);
    68.         //设置窗口尺寸
    69.         frame.setSize(width:810,height:940);
    70.         //设置窗口居中
    71.         frame.setLocationRelativeTo(null);
    72.         //设置窗口关闭时程序中止
    73.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    74.         //游戏逻辑封装在方法中
    75.         panel.start();
    76.     }
    77.     @Override
    78.     public void paint(Graphics g) {
    79.     	g.drawImage(backImage,x:0,y:0,observer:null);
    80.     	
    81.     	//平移坐标轴
    82.     	g.translate(x:22, y:15);
    83.     	
    84.     	//绘制游戏主区域
    85.     	paintWall(g);
    86.     	
    87.     	//绘制正在下落的四方格
    88.     	paintCurrentOne(g);
    89.     	
    90.     	//绘制下一个下落的四方格
    91.     	paintNextOne(g);
    92.     	
    93.     	//绘制游戏得分
    94.     	paintScore(g);
    95.     	
    96.     	//绘制游戏当前状态
    97.     	paintState(g);
    98.     }
    99.     //绘制游戏当前状态
    100.     private void paintState(Graphics g) {
    101.     	if(game_state==PLAYING) {
    102.     		g.drawString(show_state[0],x:500,y:660);
    103.     	}else if(game_state==PAUSE) {
    104.     		g.drawString(show_state[1],x:500,y:660);
    105.     	}else if(game_state==GAMEOVER) {
    106.     		g.drawString(show_state[2],x:500,y:660);
    107.     		g.setColor(Color.red);
    108.     		g.setFont(new Font(Font.SANS_SERIF,Font.BOLD,size:60));
    109.     		g.drawString(str:"GAMEOVER!",x:30,y:400);
    110.     	}
    111.     }
    112.     
    113.     private void paintNextOne(Graphics g) {
    114.     	Cell[] cells=nextOne.cells;
    115.     	for(Cell cell:cells) {
    116.     		int x=cell.getCol()*CELL_SIZE+370;
    117.     		int y=cell.getRow()*CELL_SIZE+25;
    118.     		g.drawImage(cell.getImage(),x,y,observer:null);
    119.     	}
    120.     }
    121.     private void paintCurrentOne(Graphics g) {
    122.     	Cell[] cells=currentOne.cells;
    123.     	for(Cell cell:cells) {
    124.     		int x=cell.getCol()*CELL_SIZE;
    125.     		int y=cell.getRow()*CELL_SIZE;
    126.     		g.drawImage(cell.getImage(),x,y,observer:null);
    127.     	}
    128.     }
    129.     
    130.     private void paintWall(Graphics g) {
    131.     	for(int i=0;i
    132.     		for(int j=0;j
    133.     			int x=j*CELL_SIZE;
    134.     			int y=i*CELL_SIZE;
    135.     			Cell cell=wall[i][j];
    136.     			//判断当前单元格是否有小方格，如果无则绘制矩形，否则将小方块嵌到墙中
    137.     			if(cell==null) {
    138.     				g.drawRect(x,y,CELL_SIZE,CELL_SIZE);
    139.     			}else {
    140.     				g.drawImage(cell.getImage(), x, y, observer.null);
    141.     			}
    142.     		}
    143.     	}
    144.     }
    145.     //判断方块是否出界,出界返回true，没有则返回false
    146.     public boolean outOfBounds() {
    147.         Cell[] cells = currentOne.cells;
    148.         for (Cell cell : cells) {
    149.             int col = cell.getCol();
    150.             int row = cell.getRow();
    151.             if (col < 0 || col > COL - 1 || row < 0 || row > ROW - 1) {
    152.                 return true;
    153.             }
    154.         }
    155.         return false;
    156.     }
    157.     //判断方块是否重合,重合返回true，没有返回false
    158.     public boolean coincide() {
    159.         Cell[] cells = currentOne.cells;
    160.         for (Cell cell : cells) {
    161.             int col = cell.getCol();
    162.             int row = cell.getRow();
    163.             if (wall[row][col] != null) {
    164.                 return true;
    165.             }
    166.         }
    167.         return false;
    168.     }
    169.     //按键←触发左移
    170.     public void moveLeftAction() {
    171.         currentOne.moveLeft();
    172.         //判断是否越界或者重合，如果是则右移恢复原来的状态，不是则左移
    173.         if (outOfBounds() || coincide()) {
    174.             currentOne.moveRight();
    175.         }
    176.     }
    177.     //按键→触发右移
    178.     public void moveRightAction() {
    179.         currentOne.moveRight();
    180.         //判断是否越界或者重合，如果是则左移恢复原来的状态，不是则右移
    181.         if (outOfBounds() || coincide()) {
    182.             currentOne.moveLeft();
    183.         }
    184.     }
    185.  
    186. }

    分别创建并初始化7种形状：

    1. public class I extends Tetromino{
    2.     public I() {
    3.         cells[0] = new Cell(0,4,Tetris.I);
    4.         cells[1] = new Cell(0,3,Tetris.I);
    5.         cells[2] = new Cell(0,5,Tetris.I);
    6.         cells[3] = new Cell(0,6,Tetris.I);
    7.         //两种状态
    8.         states = new State[2];
    9.         //相对坐标
    10.         states[0] = new State(0,0,0,-1,0,1,0,2);
    11.         states[1] = new State(0,0,-1,0,1,0,2,0);
    12.     }
    13. }
    1. public class J extends Tetromino{
    2.     public J() {
    3.         cells[0] = new Cell(0,4,Tetris.J);
    4.         cells[1] = new Cell(0,3,Tetris.J);
    5.         cells[2] = new Cell(0,5,Tetris.J);
    6.         cells[3] = new Cell(1,5,Tetris.J);
    7.         //4种状态
    8.         states = new State[4];
    9.         states[0] = new State(0,0,0,1,0,1,1,1);
    10.         states[1] = new State(0,0,-1,0,1,0,1,-1);
    11.         states[2] = new State(0,0,0,1,0,-1,-1,-1);
    12.         states[3] = new State(0,0,1,0,-1,0,-1,1);
    13.     }
    14. }
    1. public class L extends Tetromino{
    2.     public L() {
    3.         cells[0] = new Cell(0,4,Tetris.L);
    4.         cells[1] = new Cell(0,3,Tetris.L);
    5.         cells[2] = new Cell(0,5,Tetris.L);
    6.         cells[3] = new Cell(1,3,Tetris.L);
    7.         //4种状态
    8.         states = new State[4];
    9.         //初始化
    10.         states[0] = new State(0,0,0,-1,0,1,1,-1);
    11.         states[1] = new State(0,0,-1,0,1,0,-1,-1);
    12.         states[2] = new State(0,0,0,1,0,-1,-1,1);
    13.         states[3] = new State(0,0,1,0,-1,0,1,1);
    14.     }
    15. }
    1. public class O extends Tetromino{
    2.     public O() {
    3.         cells[0] = new Cell(0,4,Tetris.O);
    4.         cells[1] = new Cell(0,5,Tetris.O);
    5.         cells[2] = new Cell(1,4,Tetris.O);
    6.         cells[3] = new Cell(1,5,Tetris.O);
    7.         //0种状态
    8.         states = new State[0];
    9.     }
    10. }
    1. public class S extends Tetromino{
    2.     public S() {
    3.         cells[0] = new Cell(0,4,Tetris.S);
    4.         cells[1] = new Cell(0,5,Tetris.S);
    5.         cells[2] = new Cell(1,3,Tetris.S);
    6.         cells[3] = new Cell(1,4,Tetris.S);
    7.         //2种状态
    8.         states = new State[2];
    9.         //初始化相对位置
    10.         states[0] = new State(0,0,0,1,1,-1,1,0);
    11.         states[1] = new State(0,0,1,0,-1,-1,0,-1);
    12.     }
    13. }
    1. public class T extends Tetromino{
    2.     public T() {
    3.         cells[0] = new Cell(0,4,Tetris.T);
    4.         cells[1] = new Cell(0,3,Tetris.T);
    5.         cells[2] = new Cell(0,5,Tetris.T);
    6.         cells[3] = new Cell(1,4,Tetris.T);
    7.  
    8.         //4种状态
    9.         states = new State[4];
    10.         //初始化相对坐标
    11.         states[0] = new State(0,0,0,-1,0,1,1,0);
    12.         states[1] = new State(0,0,-1,0,1,0,0,-1);
    13.         states[2] = new State(0,0,0,1,0,-1,-1,0);
    14.         states[3] = new State(0,0,1,0,-1,0,0,1);
    15.     }
    16. }
    1. public class Z extends Tetromino{
    2.     public Z() {
    3.         cells[0] = new Cell(1,4,Tetris.Z);
    4.         cells[1] = new Cell(0,3,Tetris.Z);
    5.         cells[2] = new Cell(0,4,Tetris.Z);
    6.         cells[3] = new Cell(1,5,Tetris.Z);
    7.         //两种状态
    8.         states = new State[2];
    9.         //初始化相对位置
    10.         states[0] = new State(0,0,-1,-1,-1,0,0,1);
    11.         states[1] = new State(0,0,-1,1,0,1,1,0);
    12.     }
    13. }

    三.结果呈现

  • 相关阅读:
    【stm32】大一上学期笔记复制
    22年建模经验交流
    spark on hive
    微信小程序如何在切换页面后原页面状态不变
    【踩坑系列】uniapp之h5 跨域的问题
    IIS通过ARR实现负载均衡
    【JavaScript】运算符与表达式、控制语句、常用API
    【Ansible自动化运维工具 1】Ansible常用模块详解（附各模块应用实例和Ansible环境安装部署）
    Mysql应用日志时间与系统时间相差八小时
    【数学】旋转后仍为函数图像问题
  • 原文地址：https://blog.csdn.net/m0_73900459/article/details/134483257