java.java

java russiaframe 俄罗斯方块的实现

                    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 FK5 extends AbsFK{
        public void reset()
        { for (int i = 0;i<2; i++)
        {

                        xfk[i].m=5;
                        xfk[i].n=i;
        }
        for(int i=2;i<4;i++)
        {xfk[i].m=6;
                xfk[i].n=i-2;
        }

        }
        public void turn()
        {}
  public boolean canTurn(){return true;}
  }
  class FK6 extends AbsFK{
        public void reset()
        {	  state = (int)(Math.random()*2);
        switch(state)
                {case 0:
                for (int i = 0;i<2; i++)
        {

                        xfk[i].m=5+i;
                        xfk[i].n=0;
        }
        for(int i=2;i<4;i++)
        {xfk[i].m=4+i;
                xfk[i].n=1;
        }
        break;
       case 1:
        for(int i=0;i<2;i++)
        {xfk[i].m=6;
        xfk[i].n=i;
        }
        for(int i=2;i<4;i++)
        {xfk[i].m=5;
        xfk[i].n=i-1;
        }
        default:break;
        }
        }

                public void turn()
        {int m=xfk[2].m;
        int n=xfk[2].n;
        if(state==0)
        {
        for(int i=0;i<2;i++)
        {xfk[i].m=m+1;
        xfk[i].n=n+i-1;
        }
        for(int i=2;i<4;i++)
        {xfk[i].m=m;
        xfk[i].n=n+i-2;
        }
        state=1;
        }
        else
        {for(int i=0;i<2;i++)
        {xfk[i].m=m+i-1;
        xfk[i].n=n-1;}
        for(int i=2;i<4;i++)
        {xfk[i].m=m+i-2;
        xfk[i].n=n;
        }
        state=0;
        }
        }


 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>=12 || n<0 || n>=18 ||map[m][n] ==1){
                        return true;
                    }
                }
                return false;
            }
  }
   class FK7 extends AbsFK{
        public void reset()
        { state = (int)(Math.random()*2);
        switch(state){
        case 0:
                 for (int i = 0;i<2; i++)
        {

                        xfk[i].m=5+i;
                        xfk[i].n=1;
        }
        for(int i=2;i<4;i++)
        {xfk[i].m=4+i;
                xfk[i].n=0;
        }
        break;
        case 1:
                for(int i=0;i<2;i++)
                {xfk[i].m=5;
                xfk[i].n=i;
                }
        for(int i=2;i<4;i++)
        {xfk[i].m=6;
        xfk[i].n=i-1;
        }
        default:break;
        }
        }
        public void turn()
        {
        int m=xfk[1].m;
        int n=xfk[1].n;
        if(state==0)
        {
        for(int i=0;i<2;i++)
        {xfk[i].m=m;
        xfk[i].n=n+i-1;
        }
        for(int i=2;i<4;i++)
        {xfk[i].m=m+1;
        xfk[i].n=n+i-2;
        }
        state=1;
        }
        else
        {for(int i=0;i<2;i++)
        {xfk[i].m=m+i-1;
        xfk[i].n=n;}
        for(int i=2;i<4;i++)
        {xfk[i].m=m+i-2;
        xfk[i].n=n-1;
        }
        state=0;
        }

        }
 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>=12 || n<0 || n>=18 ||map[m][n] ==1){
                        return true;
                    }
                }
                return false;
            }
  }
class RussiaPanel extends JPanel implements Runnable,KeyListener
{//从JPanel派生并实现接口runable和监听器KeyListener的类RussiaPanel
   // AbsFK []dqfk = new FK1[3];
     AbsFK dqfk ;
    AbsFK fk[] = new AbsFK[7]  ;
      //新建FK1类的对象dqfk（长条形方块）
          Label bb=new Label();//新建标签bb
          Label ab=new Label("得分：");   //新建一个显示文本信息为"得分："的标签
          int time = 500;        //整型变量time为500
          static  int abc;     //声明静态int型变量abc，将会用在计数方法里
          int [][] map = new int[12][18];  
           //初始化map
            public void reset(){
        int r = (int)(Math.random()*7);
        dqfk = fk[r];
         dqfk.reset();


    }
    RussiaPanel(){
        fk[0] = new FK1();
        fk[1] = new FK2();
        fk[2]=new FK3();
        fk[3]=new FK4();
        fk[4]=new FK5();//RussiaPanel的构造函数
         fk[5]=new FK6();
          fk[6]=new FK7();
        setLayout(new FlowLayout(FlowLayout.RIGHT));//设置RussiaPanel为流式布局并右对齐
        add(ab);//在面板上添加标签ab
        add(bb);//在面板上添加标签bb
        this.reset();      //dqfk调用父类中的reset()方法 
         for (int i = 0; i<7; i++)  {  //7
            fk[i].setMap(map);
        }//dqfk调用父类中的setMap()方法 
    }
    public void paint(Graphics g){ //paint方法将Graphics类对象g作为参数
        super.paint(g);             //引用父类的paint()方法 
        bb.setText(abc+"");         //设置标签bb显示的文本信息为abc的傎 
        g.setColor(Color.black);     //设置对象g的颜色为blue
        g.drawLine(12*25,0,12*25,18*25);
        g.drawLine(0,18*25,12*25,18*25);
        /*for (int i = 0; i<=12; i++)//循环条件在横坐标上循环
        {
         g.drawLine(i*25,0,i*25,18*25);//在(i*25,0)和(i*15,18*25)之间画直线这样画出了竖线
        }
        for (int i = 0; i<=18; i++)//循环条件在纵坐标上循环
                {
            g.drawLine(0,i*25,12*25,i*25);//在(0,i*25)和(12*25,i*25)之间画直线这样画出了横线
        }*/
        g.setColor(new Color(79,70,40));//设置颜色r,g,b分别为79,70,40
        for (int i = 0; i<12 ; i++){  //横坐标循环
            for (int j = 0; j < 18; j++)//for的嵌套循环纵坐标的循环 
                {
                if (map[i][j] == 1) //如果map为1，表示这一位置存在小方块
                        {
                    g.fill3DRect(i * 25, j * 25, 25, 25, true);
                    //绘制矩形：坐标(i*25,j*25),宽和高分别为25,25,true表示矩形为突起的
                }
            }
        }
        g.setColor(Color.green);//设置g对象的颜色为green
        for (int i = 0; i<4; i++){  //循环每一小块
            int m = dqfk.xfk[i].m;//每小块的横坐标赋给m
            int n = dqfk.xfk[i].n;//每小块的纵坐标给n
            g.fill3DRect(m*25,n*25,25,25,true);
             //绘制矩形坐标(m*25,n*25),宽和高分别为25,25,true表示矩形为突起的
        }}
    public void keyPressed(KeyEvent e) //keyPressed方法 
        {
        int key = e.getKeyCode();//将所按键的code赋给key
        switch(key)   //开关语句将kwy作为参数
                {
             case KeyEvent.VK_UP:     //如果按下了UP键
                 if(dqfk.canTurn())
                     dqfk.turn();//判断dqfk方块是否能转，能则调用turn()方法 
                 this.repaint();         //重画方法
                 break;//跳出循环
             case KeyEvent.VK_DOWN://如果按下了DOWN键
                 time=100;//设制下落时间为100
                 break;//跳出循环
             case KeyEvent.VK_LEFT://如果按下了LEFT键
                 if (dqfk.canMoveLeft())//判断能否左移
                     dqfk.moveLeft();//调用左移方法
                 this.repaint();    //重画方法
                 break;//跳出循环
             case KeyEvent.VK_RIGHT://如果按下了RIGHT键
                 if (dqfk.canMoveRight())//判断能否右移
                     dqfk.moveRight();//调用右移方法 
                 this.repaint();    //重画方法
                 break;//跳出循环
             default://其他情况
                 break;//跳出
        }
    }
    public void keyReleased(KeyEvent e)//keyReleased方法 
         {
       int key = e.getKeyCode();  //将所释放键的code赋给key
        if (key == KeyEvent.VK_DOWN)//如果释放了DOWN键
            time = 500;//下落时间设为500
    }
    public void keyTyped(KeyEvent e)//keyTyped方法函数体为空
         {}
    public void run()//run方法 
         {
        while (true)//while语句为真
                {
            if (dqfk.canMoveDown())//判断方块是否能下移
                dqfk.moveDown();   //调用下移方法      
            else 
            {                      //如果不能下移

                for (int i = 0; i<4; i++)  //循环每一小块
                        {
                    int m = dqfk.xfk[i].m; //将小块的横坐标赋给m
                    int n = dqfk.xfk[i].n;//将小块的纵坐标赋给n
                    map[m][n] = 1;//设置不能下移时的存在小方块的位置map[m][n]的傎为1
                }
                  refresh();    //调用消行和计分方法
                  for (int i = 0; i<4; i++)  //for 语句实现游戏的停止
                  { int n = dqfk.xfk[i].n;  
                  if(n>0)               //如果小方块的纵坐标大于0
                this.reset();           //调用重设方块的方法
                }
            }
            this.repaint();//刷新重画方法
            try 
            {
                Thread.sleep(time);//线程调用sleep()方法，并将time做为参数
            } catch (InterruptedException ex)  //捕获异常 
                {
            }
        }
    }

     boolean isFullLine(int m)//判断是否滿行参数m表示某一行
        {
        for (int i = 0; i<12; i++)//循环语句
                {
            if (map[i][m] == 0)  //如果某一行上有空的位置
                {
             return false;//返回傎为false表示未滿行
            }
        }
        return true;  //如果为for语句不成立返回傎为true表示滿行了
    }
     void refresh()//不带参数的refresh()方法
        {
        for (int i = 0; i<18;i++)//循环每行
                {
            if (isFullLine(i))  //if条件i行是否滿行
                {
               refresh(i);  //调用含参数的refresh()方法
            }
        }
    }
   void refresh(int m)  //带参数的refresh(m)方法m为refresh()if条件中的i为行号
        {
        abc++;    //计数器abc加1
        for (int i = m; i>0; i--){//循环m行以上的行
            for (int j = 0; j<12; j++)//循环每一列
                {
                map [j][i] = map [j][i-1];//将上一行的map傎赋给本行，由于上一行为空这样就实现了消行
                }
        }
        }
    }    
    
class ButtonPanel extends JPanel implements ActionListener
{Button bt1=new Button("开始");

Button bt2=new Button("结束");
ButtonPanel()
{//bt1=new Button("开始");
//bt2=new Button("结束");

add(bt1);
add(bt2);
//bt1.addActionListener(this);
//bt2.addActionListener(this);
}
public void actionPerformed(ActionEvent e)
{
}

}

class FunctionPanel extends JPanel
{
ButtonPanel p1=new ButtonPanel();
FunctionPanel()
{setLayout(new GridLayout(2,2,10,5));
add(p1);
}
}
 public class RussiaFrame1 extends JFrame {//从JFrame类中派生出类RussiaFrmae类
    RussiaPanel p = new RussiaPanel();//创建RussiaPanel类的对象p
    FunctionPanel p2=new FunctionPanel();
    //ButtonPanel p1=new ButtonPanel();
    public RussiaFrame1(){ //RussiaFrame类的构造函数
      
        Container con = this.getContentPane();//获得当前对象的容器赋给con
        con.setBackground(Color.blue);
      con.setLayout(new BorderLayout(1,1));
       con.add(p,BorderLayout.CENTER);//在con容器中添加面板对象p
      //  con.add(p2,BorderLayout.EAST);
       this.addKeyListener(p);//为当前对象注册监听器KeyListener

       Thread t = new Thread(p);//创建线程对象t，将p做为参数
      t.start();//开始线程

    }
    public static void main(String[] args)//主方法 
        {
        RussiaFrame1 f = new RussiaFrame1();//新建RussiaFrame类对象f
        f.setSize(400,500);//设对象f的宽400,高500
        f.setVisible(true);//show()方法等同于此方法但总有警吿故改之，将f上组件可视化
}
}