tetrics.java~76~

JBuilder实现的具有单机

package mymatrix;
import java.awt.*;
//import java.awt.event.*;
//import java.awt.Image;


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

   public static int WIDTH=800;
   public static int HEIGHT=450;

   int m_nField[][];   //descripe the status of the game now
   int m_nOldField[][];
   //当前移动的方块
   Square m_curPiece[]=new Square[4];  //the group of square that are playing now
   Square m_prePiece[]=new Square[4];
   boolean m_bGameInPlay;    //whether the game is playing now
   boolean m_bNeedNewPiece;  //whether need a new piece now
   boolean m_bPaused=false;

   boolean m_drawback=true;

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

   Thread m_theThread=null;
   Color m_colors[];
   int m_nPieceValue,m_nTheScore=0;//the score of the piece and the score of
                                   //the game
   int m_nPlayLevel;               //the level of the game
   int m_nTotalPieces;             //the number of the pieces that have come about
   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;

   Image img;

   //Sound m;
   //Sound d;

   public char key[]={'a','d','w','s'};


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

    public Tetrics(TFrame tFrame)
    {
        super();
        m_tFrame=tFrame;
        setBackground(BAKCOLOR);
        initParam();
       // drawbackgroud();
    }
   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);





   }

   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 void drawbackgroud(Graphics g){
     //Graphics g=this.getGraphics();

     Image cimg=this.createImage(800,450);
     try{
          Toolkit toolkit = Toolkit.getDefaultToolkit();
          img = toolkit.getImage("back1.jpg");

        }
        catch(Exception e){
          System.out.print("不能显示背景图片!");
        }

     try{
       Graphics mg = cimg.getGraphics();
       mg.drawImage(img,0,0,800,450,this);
     }
     catch(Exception ce){
       ce.printStackTrace();
     }


     if(img!=null)
       g.drawImage(cimg,0,0,800,450,this);

 }

   public synchronized void paint(Graphics g)
   {
            //if(m_drawback)
            //drawbackgroud(g);
            //m_drawback=false;
            System.out.print("draw");
            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代表没有刚刚开始

               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);
   }

   private synchronized boolean moveCurPiece(int nDx,int nDy,boolean bRotate)
   {//nDx:move left(-1) ior right; nDy:move up or down(-1)


        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);