tetrics.java

java 版的俄罗斯方块在原来的基础上的网络版

import java.awt.*;
import java.awt.event.*;
/**
 * Title:
 * Description:
 * Copyright:    Copyright (c) 2001
 * Company:
 * @author
 * @version 1.0
 */

public class Tetrics extends Panel implements Runnable
{
    //每个小方块的大小：宽，高
   int m_nSqLength;
   //信息区大小
   final int XOFFSET=200;
   final int RIVAL_XOFFSET=500;
   static int m_nCols;
   static int m_nRows;

   public static int WIDTH=800;
   public static int HEIGHT=450;
   //当前的界面情况
   int m_nField[][];
   int m_nOldField[][];
   //当前移动的方块
   Square m_curPiece[]=new Square[4];
   Square m_prePiece[]=new Square[4];
   boolean m_bGameInPlay;
   boolean m_bNeedNewPiece;
   boolean m_bPaused=false;

   //对手的情况
   int m_nRivalField[][];

   Thread m_theThread=null;
   Color m_colors[];
   int m_nPieceValue,m_nTheScore=0;
   int m_nPlayLevel;
   int m_nTotalPieces;
   boolean m_bJustupdating=false;
   int m_nDelayMap[]={600,600,600,600,500,400,300,250,200,150,100};

   final Color BAKCOLOR=new Color(80,123,166);
   final Color FORCOLOR=Color.black;

   public static int NOSQUARE=0;

   Graphics m_gOffGraph;

   TFrame m_tFrame;

    public Tetrics()
    {
        super();
        setBackground(BAKCOLOR);
        initParam();
    }

    public Tetrics(TFrame tFrame)
    {
        super();
        m_tFrame=tFrame;
        setBackground(BAKCOLOR);
        initParam();
    }
   public void initParam()
   {
   //设置初始参数
        m_nSqLength=20;
        m_nCols=10;
        m_nRows=20;
        m_nField=new int [m_nCols][m_nRows+4];
        m_nOldField=new int[m_nCols][m_nRows+4];
        //对手的状态
        m_nRivalField=new int [m_nCols][m_nRows+4];

        m_nPlayLevel=5;
    //定义八种颜色
        m_colors=new Color[8];
        m_colors[0]=new Color(40,40,40);
        m_colors[1]=new Color(255,0,0);
        m_colors[2]=new Color(0,200,0);
        m_colors[3]=new Color(0,200,255);

        m_colors[4]=new Color(255,255,0);
        m_colors[5]=new Color(255,150,0);
        m_colors[6]=new Color(210,0,240);
        m_colors[7]=new Color(40,0,240);
    //to initialize the m_prePiece;

   }

   public synchronized void start()
   {
        if(m_theThread!=null)
        //游戏是被暂停，而不是重新开始
        {
            m_bPaused=false;
            m_theThread.resume();
            return;
        }
        repaint();
        //重新开始赋上游戏的状态
        for(int i=0;i<m_nCols;i++)
        {
	          for(int j=0;j<m_nRows+4;j++)
              {
                  m_nField[i][j]=0;
                  m_nOldField[i][j]=-1;

                  m_nRivalField[i][j]=0;
        	  }
    	}
        m_nTheScore=0;
        m_nTotalPieces=0;
        m_bNeedNewPiece=true;
        m_bGameInPlay=true;

        m_theThread=new Thread(this);
        newPrePiece();
        m_theThread.start();
        requestFocus();
   }

   public void update(Graphics g)
   {
	    m_bJustupdating=true;
    	paint(g);
   }

   public synchronized void paint(Graphics g)
   {
    	g.setFont(new Font("宋体",0,18));
    	int gx=m_nSqLength;
    	int gy=m_nSqLength*m_nRows/4;
        //打印Score和level的位置

	    g.clearRect(gx,gy-25,XOFFSET-gx,25);
    	g.drawString("Score:"+m_nTheScore,gx,gy);
    	gy+=30;
    	g.clearRect(gx,gy-25,XOFFSET-gx,25);
	    g.drawString("Level:"+m_nPlayLevel,gx,gy);
//        System.out.println("paint m_nPlayLevel="+m_nPlayLevel);

        //画预览的方块
        int middle=m_nCols/2;
        int top=m_nRows;
        gy+=30;
        g.setColor(Color.black);
        g.fillRect(gx,gy,m_nSqLength*4,m_nSqLength*4);
        if(m_bGameInPlay)
        {
            for(int i=0;i<4;i++)
            {
                g.setColor(m_colors[m_prePiece[i].m_nColor]);
                g.fill3DRect((m_prePiece[i].m_nColumn-middle+2)*m_nSqLength+gx,
                    gy-(m_prePiece[i].m_nRow-top)*m_nSqLength,m_nSqLength,m_nSqLength,true);
            }
        }

       Image img1=createImage(m_nSqLength*10,m_nSqLength*20);
       //用来画自己的游戏区域
       Image img2=createImage(m_nSqLength*10,m_nSqLength*20);
       //用来画对手的游戏区域
       Graphics g1=img1.getGraphics();
       Graphics g2=img2.getGraphics();

        for(int i=0;i<m_nCols;i++)
            for(int j=0;j<m_nRows;j++)
            {
                //-1代表没有刚刚开始
/*             if(!m_bJustupdating ||m_nOldField[i][m_nRows-1-j]==-1 || m_nOldField[i][m_nRows-1-j]!=m_nField[i][m_nRows-1-j])
               {
                	g.setColor(m_colors[m_nField[i][m_nRows-1-j]]);
        	        g.fill3DRect(XOFFSET+m_nSqLength*i,m_nSqLength+m_nSqLength*j,m_nSqLength,m_nSqLength,true);
               }
               m_nOldField[i][m_nRows-1-j]=m_nField[i][m_nRows-1-j];*/
               g1.setColor(m_colors[m_nField[i][m_nRows-1-j]]);
        	   g1.fill3DRect(m_nSqLength*i,m_nSqLength*j,m_nSqLength,m_nSqLength,true);


                //来画对手的情况
               g2.setColor(m_colors[m_nRivalField[i][m_nRows-1-j]]);
      	       g2.fill3DRect(m_nSqLength*i,m_nSqLength*j,m_nSqLength,m_nSqLength,true);


            }
           g.drawImage(img1,XOFFSET,m_nSqLength,this);
           g.drawImage(img2,RIVAL_XOFFSET,m_nSqLength,this);
           m_bJustupdating=false;
   }
   public void run()
   {
      while(m_bGameInPlay){
         try
         {
        	int t;
        	if(m_nPlayLevel>10) t=75;
        	else t=m_nDelayMap[m_nPlayLevel];
        	Thread.sleep(t);
         }catch(InterruptedException e){e.printStackTrace();}
         if(m_bNeedNewPiece)
         {
        	 if(m_nPieceValue>0)
             {
                 m_nTheScore+=m_nPieceValue;
                 m_nTotalPieces+=1;
                 if(m_nTotalPieces%30==0)m_nPlayLevel++;
             }
             removelines();
        	 transferPreToCur();
             newPrePiece();
        	 m_bNeedNewPiece=false;
         }
         else
         {
        	 m_bNeedNewPiece=!moveCurPiece(0,-1,false);
        	 if(!m_bNeedNewPiece) m_nPieceValue-=5;
         }
        repaint();
        sendStatus();
     }
     m_theThread=null;
   }
   private void sendStatus()
   {
        if(m_tFrame.m_nNetStatus==TFrame.NOCONNECT)return;
        String str="Status:";
        for(int nCol=0;nCol<m_nCols;nCol++)
            for(int nRow=0;nRow<m_nRows;nRow++)
            {
                str+=m_nField[nCol][nRow]+"|";
            }
        m_tFrame.sendStr(str);
   }
   /**
    *移动方块
    *@param nDx 左右移动，向左为-1
    *@param nDy 上下移动，向下为-1
    *@param bRotate 是否转动
    */
   private synchronized boolean moveCurPiece(int nDx,int nDy,boolean bRotate)
   {
	Square newpos[]=new Square[4];
	for(int i=0;i<4;i++){
	  if(bRotate)
	  {
	    int dx=m_curPiece[i].m_nColumn-m_curPiece[0].m_nColumn;
	    int dy=m_curPiece[i].m_nRow-m_curPiece[0].m_nRow;
	    newpos[i]=new Square(m_curPiece[0].m_nColumn-dy,m_curPiece[0].m_nRow+dx,m_curPiece[i].m_nColor);
	  }
	  else
	  {
	    newpos[i]=new Square(m_curPiece[i].m_nColumn+nDx,m_curPiece[i].m_nRow+nDy,m_curPiece[i].m_nColor);
	  }
	}
	if(moveSquares(m_curPiece,newpos)==false) return false;
	m_curPiece=newpos;
	return true;
   }
   /**
    * 移动方块，如果不能移动，则返回假
    */
   boolean moveSquares(Square from[],Square to[])
   {
 	//判断是否能移动
    outerlable:
	    for (int i=0;i<to.length;i++)
        {
    	  if(to[i].InBounds()==false) return false;
          //如果不在可玩区域，则返回假
	      if(m_nField[to[i].m_nColumn][to[i].m_nRow]!=0)
          {
                for(int j=0;j<from.length;j++)
        	      if(to[i].IsEqual(from[j]))
        	         continue outerlable;
                return false;
    	  }
        }
    //移动
    	for(int i=0;i<from.length;i++)
    	  if(from[i].InBounds())
    	     m_nField[from[i].m_nColumn][from[i].m_nRow]=0;

	    for(int i=0;i<to.length;i++)
    	  m_nField[to[i].m_nColumn][to[i].m_nRow]=to[i].m_nColor;
        	return true;
   }
   /**
    * 用来产生一个新的方块用来做预览
    */
   private void newPrePiece()
   {
        int middle=m_nCols/2;
        int top=m_nRows;

        switch((int)(Math.random()*7))
        {
            case 0:
                //XXXX  red;
            m_nPieceValue=100;
            m_prePiece[0]=new Square(middle-1,top-1,1);
            m_prePiece[1]=new Square(middle-2,top-1,1);
            m_prePiece[2]=new Square(middle,top-1,1);
            m_prePiece[3]=new Square(middle+1,top-1,1);
            break;

            case 1:
            //  X orange;
                //XXX
            m_nPieceValue=200;
            m_prePiece[0]=new Square(middle,top-2,5);
            m_prePiece[1]=new Square(middle,top-1,5);
            m_prePiece[2]=new Square(middle-1,top-2,5);
            m_prePiece[3]=new Square(middle+1,top-2,5);
            break;

            case 2:
                //XX  green;
            m_nPieceValue=180;
            m_prePiece[0]=new Square(middle,top-2,2);
            m_prePiece[1]=new Square(middle-1,top-1,2);
            m_prePiece[2]=new Square(middle,top-1,2);
            m_prePiece[3]=new Square(middle+1,top-2,2);
            break;

            case 3:
                //XX  blue;
            m_nPieceValue=180;
            m_prePiece[0]=new Square(middle,top-2,7);
            m_prePiece[1]=new Square(middle+1,top-1,7);
            m_prePiece[2]=new Square(middle,top-1,7);
            m_prePiece[3]=new Square(middle-1,top-2,7);
            break;

            case 4:
                //XX  light blue;
            m_nPieceValue=100;
            m_prePiece[0]=new Square(middle-1,top-1,3);
            m_prePiece[1]=new Square(middle,top-1,3);
            m_prePiece[2]=new Square(middle-1,top-2,3);
            m_prePiece[3]=new Square(middle,top-2,3);
            break;

            case 5:
                //XXX  purle;
            m_nPieceValue=120;
            m_prePiece[0]=new Square(middle,top-1,6);
            m_prePiece[1]=new Square(middle-1,top-1,6);
            m_prePiece[2]=new Square(middle+1,top-1,6);
            m_prePiece[3]=new Square(middle+1,top-2,6);
            break;

            case 6:
                //XXX  yellow;
            m_nPieceValue=120;
            m_prePiece[0]=new Square(middle,top-1,4);
            m_prePiece[1]=new Square(middle+1,top-1,4);
            m_prePiece[2]=new Square(middle-1,top-1,4);
            m_prePiece[3]=new Square(middle-1,top-2,4);
            break;
        }

   }
   /**
    * 将预览的方块转变成正在动的方块
    */
   private void transferPreToCur()
   {
        Square old[]=new Square[4];
        old[0]=old[1]=old[2]=old[3]=new Square(-1,-1,0);

        for(int i=0;i<4;i++)
        {
            m_curPiece[i]=m_prePiece[i];
        }

        m_bGameInPlay=moveSquares(old,m_curPiece);
        if(!m_bGameInPlay && m_tFrame.m_nNetStatus!=TFrame.NOCONNECT)m_tFrame.sendStr("GameOver:"+m_nTheScore);
        else if(!m_bGameInPlay && m_tFrame!=null)m_tFrame.insertScoreReport(m_nTheScore);
   }
   //去掉可以消去的行
   private void removelines()
   {
	outerlabel:
        for(int j=0;j<m_nRows;j++)
        {
        	for(int i=0;i<m_nCols;i++)
        	  if(m_nField[i][j]==0)
            	  continue outerlabel;
    	    for(int k=j;k<m_nRows-1;k++)
	            for(int i=0;i<m_nCols;i++)
        	        m_nField[i][k]=m_nField[i][k+1];
            j-=1;
            m_tFrame.sendStr("RemoveLine");
      }
   }

   public boolean keyDown(Event evt,int nKey)
   {
   if(!m_bGameInPlay)return true;
   if(m_bPaused)return true;
   switch(nKey){
        case 'a':
        case Event.LEFT	:
            moveCurPiece(-1,0,false);
            m_bNeedNewPiece=false;
            repaint();
            break;

        case 'd':
        case Event.RIGHT:
            moveCurPiece(1,0,false);
            m_bNeedNewPiece=false;
            repaint();
            break;

        case 'w':
        case Event.UP:
            moveCurPiece(0,0,true);
            repaint();
            break;

        case 's':
        case Event.DOWN:
            while(moveCurPiece(0,-1,false));
            repaint();
            break;
       }
       return true;
   }

   public synchronized void stop()
   {
        if(m_theThread!=null)
                m_theThread.stop();
        m_theThread=null;
   }

   public synchronized void pause()
   {
        if(m_theThread!=null)
        {
            try
            {
                m_theThread.suspend();
                m_bPaused=true;
            }
            catch(Exception e){e.printStackTrace();}
        }

   }

   public void setPlayLevel(int nLevel)
   {
        m_nPlayLevel=nLevel;
//        System.out.println("m_nPlayLevel="+m_nPlayLevel);

        Graphics g=getGraphics();
       	g.setFont(new Font("宋体",0,18));
        int gx=m_nSqLength;
    	int gy=m_nSqLength*m_nRows/4+30;
        g.clearRect(gx,gy-25,XOFFSET-gx,25);
	    g.drawString("Level:"+m_nPlayLevel,gx,gy);
//        System.out.println("paint m_nPlayLevel="+m_nPlayLevel);

   }

   public int getPlayLevel()
   {
        return m_nPlayLevel;
   }
   public synchronized void addRandomLine()
   {
        int nRandom[]=new int[m_nCols];
        boolean bAllZero=true;
        boolean bNoZero=true;
        for(int i=0;i<m_nCols;i++)
        {
            nRandom[i]=(int)(7*Math.random());
            if(nRandom[i]!=0)bAllZero=false;
            else bNoZero=false;
        }
        if(bAllZero)
        {
            nRandom[(int)(m_nCols*Math.random())]=(int)(Math.random()*6+1);
        }
        else if(bNoZero)
        {
            nRandom[(int)(m_nCols*Math.random())]=0;
        }
        for(int nCol=0;nCol<m_nCols;nCol++)
            for(int nRow=m_nRows+3;nRow>0;nRow--)
            {
                m_nField[nCol][nRow]=m_nField[nCol][nRow-1];
            }
        for(int nCol=0;nCol<m_nCols;nCol++)m_nField[nCol][0]=nRandom[nCol];
        for(int i=0;i<4;i++)
        {
            m_curPiece[i].m_nRow++;
        }
   }
}