java.java

java russiaframe 俄罗斯方块的实现

import java.awt.*;//导入java中的图形用户界面awt包
import java.awt.event.*;//导入java中的awt中的event类包
import javax.swing.*;//导入java中的awt升级包中javax.swing包

class XFK   //新建类小方块类XFK
{
    int m;   //定义整型变量m为小方块的横坐标
    int n;   //定义整型变量n为小方块的纵坐标
}
abstract class AbsFK//建立方块类的抽象类AbsFK
{  
    XFK [] xfk = new XFK[4];   //声明并初始化长度为4的数组表明每个方块图形是由4小方块XFK组成
    int state;     //声明整型变量state表示方块的状态
    int [] [] map;      //声明int型二维数组map，用来表示方块所在的区域
    AbsFK (){          //AbsFK类的构造函数
        for (int i = 0; i<4 ; i++){//for循环语句
            xfk[i] = new XFK();//为组成方块的每个小方块分配空间初始化
        }
    }
    public void setMap(int [][] map){//建立public型返回傎为空的setmap方法并将二维数组map作为参数
        this.map = map;//将map赋为傎给当前对象的map
    }
    abstract public void reset();   //声明抽象方法reset（）表示重设方法 
    abstract public void turn();    //声明方法turn（）表示方块转动的方法 
   abstract public boolean canTurn(); //声明抽象方法canTurn()用来判断方块是否能转

    public boolean canMoveLeft()//canMoveLeft()方法判断方块是否能向左移

        {
        for (int i =0; i<4; i++){  //for语句循环条件
            int m = xfk[i].m - 1;//方块的每个小方块的横坐标减去1后赋给m（每个小方块左移一位的横坐标）
            int n = xfk[i].n;//方块的每个小方块的纵坐标赋给n
            if ( m<0 || m>11 || n<0 || n>17 || map [m][n] == 1 )//判断条件m和n超过了map区域或方块已停止
                {
                return false;//如果上述条件成立则返回false
            }
        }
        return true;//如果for语句不成立返回true
    }
    public boolean canMoveRight(){//方块能否右移的方法
        for (int i =0; i<4; i++){//for语句循环条件
            int m = xfk[i].m + 1;//方块的每个小方块的横坐标加上1（每个小方块右移一位的横坐标）
            int n = xfk[i].n;//方块的每个小方块的纵坐标
            if (m < 0 || m > 11 || n < 0 || n > 17 || map[m][n] == 1)//判断条件m和n超过了边框或方块已停止
                 {
                return false;//如果上有述条件成立返回false
            }
        }
        return true;//如果不成立返回true
    }
    public boolean canMoveDown(){//方块能否下移的方法
        for (int i = 0; i < 4; i++) {//for循环条件
            int m = xfk[i].m ;//获取小方块的横坐标赋给m
            int n = xfk[i].n + 1;//小方块的纵坐标加一（每个小方块下移一位后的
            if (m < 0 || m > 11 || n < 0 || n > 17 || map[m][n] == 1)//if条件语句判断m和民是否超过了map或方块已停止
                 {
                return false;//条件成立返回false
            }
        }
        return true;//不成立函数返回傎为true
    }
    public void moveLeft(){           //方块左移方法
        for (int i = 0; i<4; i++)//for循环条件语句
                {
            xfk[i].m--;  //每一小块的横坐标减一（向左移一位）
        }
    }
    public void moveRight(){           //方块右移方法函数
        for (int i = 0; i<4; i++)//for循环每一小块
                {
            xfk[i].m++;//每一小块的横坐标加一（向右移一位）
        }
    }
    public void moveDown()//建立方块下移方法moveDown()
        {
        for (int i = 0; i<4; i++) //for语句循环每一小块
                {
            xfk[i].n++;//每一小块的纵坐标加一（向下移一位）
        }
    }
}
class FK1 extends AbsFK{       //从方块类AbsFK中派生出方块类的子类FK1
    public void reset(){              //方块FK1的reset()方法 
        state = (int)(Math.random()*2);//产生0，1两个随机整数
        if (state == 0){                //if条件语句
            for (int i = 0; i<4; i++)//for循环每一小块
                {
                xfk[i].m = 4+i;  //小方块的横坐标是由第4个位置开始的
                xfk[i].n = 0;//每一小方块的初始纵坐标是0 这两行说明此时是一长条形横放的方块
            }
        }
        else {                          //如果state等于1
            for (int i = 0; i<4; i++) //循环每一小块
                {
                xfk[i].m = 5;  //每一小方块的横坐标都是5
                xfk[i].n = i;//每一小方块的纵坐标从0开始向下排  这里是一长条形竖放的方块
            }
        }
    }
    public void turn(){       //方块的转动方法 
        if (state == 0)  {   //表示如果长条形方块横放
            int m = xfk[0].m + 1;//第一个小方块的横坐标加一后赋给m
            int n = xfk[0].n - 1;//第一个小方块的纵坐标减一后赋给n
            for (int i = 0; i<4; i++){//循环每一小方块
                xfk[i].m = m;      //将每个小方块的横坐标设为m   
                xfk[i].n = n+i;//小方块的纵侍标从n开始向下排
            }
            state = 1;//长条形方块从横放变成了竖放

        }else {              //如果方块是竖放的
            int m = xfk[0].m - 1; //将第一个小方块的横坐标减一赋给m
            int n = xfk[0].n + 1;//将第一个小方块的纵坐标加一赋给n
            for (int i = 0; i<4; i++){//循环每一小块
                xfk[i].m = m + i;//小方块的横坐标从m依次往下排
                xfk[i].n = n;//每个小方块的纵坐标都为n
            }
            state = 0;//长条形方块从竖放变成了横放
        }
    }
    public boolean canTurn() {//判断方块是否可以转
        turn();     //调用方块旋转方法使方块转动
        for(int i=0;i<4;i++)//循环方块的每一小块
        {int m=xfk[i].m;    //将旋转后的每一小块的横坐标赋给m
        int n=xfk[i].n;     //将旋转后的每一小块的纵坐标赋给n
        if ( m<0 || m>11 || n<0 || n>17 || map [m][n] == 1 )//if条件旋转后方块坐标超过map或是与有方块的地方冲突 
                {
                return true;   //如果滿足if条件则返回true再旋转一次，相当于没有转，不能旋转
            }
        }
        return false;  //如果旋转后坐标在map内且没有和有方块的地方冲突，则返回false不再旋转，相当于能旋转

        }

        }
class FK2 extends AbsFK  //T字型的方块
{   
    public void reset(){
        state = (int)(Math.random()*4);
        switch(state){
             case 0:
                 for (int i = 0; i < 3; i++) {
                     xfk[i].m = 4+i;
                     xfk[i].n = 1;
                 }
                 xfk[3].m = 5;
                 xfk[3].n = 0;
                 break;
             case 1:
                 for (int i = 0; i < 3; i++) {
                    xfk[i].m = 5;
                    xfk[i].n = i;
                }
                xfk[3].m = 6;
                xfk[3].n = 1;
                 break;
             case 2:
                 for (int i = 0; i < 3; i++) {
                    xfk[i].m = 4+i;
                    xfk[i].n = 0;
                }
                xfk[3].m = 5;
                xfk[3].n = 1;
                 break;
             case 3:
                 for (int i = 0; i < 3; i++) {
                    xfk[i].m = 5;
                    xfk[i].n = i;
                }
                xfk[3].m = 4;
                xfk[3].n = 1;
                 break;
              default:
                  break;
        }

    }
    public void turn(){
        int m,n;
        switch(state){
           case 0:
               m = xfk[0].m + 1;
               n = xfk[0].n -1;
               for (int i = 0; i<3; i++){
                   xfk[i].m = m;
                   xfk[i].n = n+i;
               }
               xfk[3].m = m+1;
               xfk[3].n = n+1;
               break;
            case 1:
                m = xfk[0].m - 1;
                n = xfk[0].n + 1;
                for (int i = 0; i<3; i++){
                    xfk[i].m = m+i;
                    xfk[i].n = n;
                }
                xfk[3].m = m+1;
                xfk[3].n = n+1;
                break;
            case 2:
                m = xfk[0].m + 1;
                n = xfk[0].n - 1;
                for (int i = 0; i < 3; i++) {
                    xfk[i].m = m;
                    xfk[i].n = n + i;
                }
                xfk[3].m = m - 1;
                xfk[3].n = n + 1;
                break;
            case 3:
                m = xfk[0].m - 1;
                n = xfk[0].n + 1;
                for (int i = 0; i < 3; i++) {
                    xfk[i].m = m + i;
                    xfk[i].n = n ;
                }
                xfk[3].m = m + 1;
                xfk[3].n = n - 1;
                break;
            default:
                break;
        }
        state = (state+1)%4;
    }
     public boolean canTurn() {//判断方块是否可以转
        turn();     //调用方块旋转方法使方块转动
        for(int i=0;i<4;i++)//循环方块的每一小块
        {int m=xfk[i].m;    //将旋转后的每一小块的横坐标赋给m
        int n=xfk[i].n;     //将旋转后的每一小块的纵坐标赋给n
        if ( m<0 || m>11 || n<0 || n>17 || map [m][n] == 1 )//if条件旋转后方块坐标超过map或是与有方块的地方冲突 
                { turn();
                turn();
                return true;   //如果滿足if条件则返回true再旋转一次，相当于没有转，不能旋转
            }
        }
        return false;  //如果旋转后坐标在map内且没有和有方块的地方冲突，则返回false不再旋转，相当于能旋转

        }

}
class FK3 extends AbsFK {
    public void reset(){
        state = (int)(Math.random()*4);
        switch(state){
             case 0:
                 for (int i = 0; i < 3; i++) {
                     xfk[i].m = 6;
                     xfk[i].n = i;
                 }
                 xfk[3].m = 7;
                 xfk[3].n = 2;
                 break;
             case 1:
                 for (int i = 0; i < 3; i++) {
                    xfk[i].m = 7-i;
                    xfk[i].n = 0;
                }
                xfk[3].m = 5;
                xfk[3].n = 1;
                 break;
             case 2:
                 for (int i = 0; i < 3; i++) {
                    xfk[i].m = 6;
                    xfk[i].n =2-i;
                }
                xfk[3].m = 5;
                xfk[3].n = 0;
                 break;
             case 3:
                 for (int i = 0; i < 3; i++) {
                    xfk[i].m = 5+i;
                    xfk[i].n = 1;
                }
                xfk[3].m = 7;
                xfk[3].n = 0;
                 break;
              default:
                  break;
        }

    }
    public void turn(){
        int m,n;
        switch(state){
           case 0:
               m = xfk[0].m + 1;
               n = xfk[0].n +1;
               for (int i = 0; i<3; i++){
                   xfk[i].m = m-i;
                   xfk[i].n = n;
               }
               xfk[3].m = m-2;
               xfk[3].n = n+1;
               break;
            case 1:
                m = xfk[0].m - 1;
                n = xfk[0].n + 1;
                for (int i = 0; i<3; i++){
                    xfk[i].m = m;
                    xfk[i].n = n-i;
                }
                xfk[3].m = m-1;
                xfk[3].n = n-2;
                break;
            case 2:
                m = xfk[0].m - 1;
                n = xfk[0].n - 1;
                for (int i = 0; i < 3; i++) {
                    xfk[i].m = m+ i;
                    xfk[i].n = n ;
                }
                xfk[3].m = m +2;
                xfk[3].n = n -1;
                break;
            case 3:
                m = xfk[0].m +1;
                n = xfk[0].n - 1;
                for (int i = 0; i < 3; i++) {
                    xfk[i].m = m ;
                    xfk[i].n = n+ i ;
                }
                xfk[3].m = m +1;
                xfk[3].n = n+2 ;
                break;
            default:
                break;
        }
        state = (state+1)%4;
    }


 public boolean canTurn(){
       turn();


                for (int i = 0;i<4; i++){
                    int m = xfk[i].m ;
                    int n = xfk[i].n ;
                    if (m<0 || m>11|| n<0 || n>=18 ||map[m][n] ==1){
                        turn();
                        turn();
                        return true;
                    }
                }
                return false;
            }
        }   


   class FK4 extends AbsFK {
    public void reset(){
        state = (int)(Math.random()*4);
        switch(state){
             case 0:
                 for (int i = 0; i < 3; i++) {
                     xfk[i].m = 6;
                     xfk[i].n = i;
                 }
                 xfk[3].m = 5;
                 xfk[3].n = 2;
                 break;
             case 1:
                 for (int i = 0; i < 3; i++) {
                    xfk[i].m = 7-i;
                    xfk[i].n = 1;
                }
                xfk[3].m = 5;
                xfk[3].n = 0;
                 break;
             case 2:
                 for (int i = 0; i < 3; i++) {
                    xfk[i].m = 6;
                    xfk[i].n = 2-i;
                }
                xfk[3].m = 7;
                xfk[3].n = 0;
                 break;
             case 3:
                 for (int i = 0; i < 3; i++) {
                    xfk[i].m =5+i;
                    xfk[i].n = 0;
                }
                xfk[3].m = 7;
                xfk[3].n = 1;
                 break;
              default:
                  break;
        }

    }
    public void turn(){
        int m,n;
        switch(state){
           case 0:
               m = xfk[0].m + 1;
               n = xfk[0].n +1;
               for (int i = 0; i<3; i++){
                   xfk[i].m = m-i;
                   xfk[i].n = n;
               }
               xfk[3].m = m-2;
               xfk[3].n = n-1;
               break;
            case 1:
                m = xfk[0].m - 1;
                n = xfk[0].n + 1;
                for (int i = 0; i<3; i++){
                    xfk[i].m = m;
                    xfk[i].n = n-i;
                }
                xfk[3].m = m+1;
                xfk[3].n = n-2;
                break;
            case 2:
                m = xfk[0].m - 1;
                n = xfk[0].n - 1;
                for (int i = 0; i < 3; i++) {
                    xfk[i].m = m + i;