paintthread.java

这是一个俄罗斯方块的JAVA实现

package com.sunfruit.draw.thread;

import com.sunfruit.draw.framework.JSFCanvasface;
import com.sunfruit.draw.framework.JSFComponentface;
import com.sunfruit.draw.swing.JSFTComponent;
import java.util.ArrayList;
import com.sunfruit.draw.swing.JSFLComponent;
import com.sunfruit.draw.util.ToolsUtil;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Color;
import javax.swing.JPanel;
import java.awt.Rectangle;
import java.awt.Graphics2D;

/**
 * <p>Title: </p>
 *
 * <p>Description: </p>
 *
 * <p>Copyright: Copyright (c) 2007</p>
 *
 * <p>Company: </p>
 *
 * @author not attributable
 * @version 1.0
 */
public class PaintThread
    extends Thread {

  private JSFCanvasface jsfCanvasface;

  private boolean iswait=false;

  private boolean isstart=false;

  private boolean isover=false;

  private JPanel jPanel2;

  public PaintThread(JSFCanvasface jsfCanvasface,JPanel jPanel2) {
    this.jsfCanvasface=jsfCanvasface;
    this.jPanel2=jPanel2;
  }

  public void run()
  {
    synchronized(this)
    {
      while (true && isstart && !isover) {
        JSFComponentface jsfComponentface = ToolsUtil.getJSFComponentface(jsfCanvasface);
        //显示预览组件
        viewBuffCom();

        jsfCanvasface.setJSFComponentface_(jsfComponentface);
        if(jsfComponentface.isBottom())
        {
          jsfCanvasface.paint(jsfCanvasface.getGraphics());
          isover=true;
          break;
        }
        while (true && isstart && !isover) {
          if (iswait) {
            try {
              this.wait();
            }
            catch (InterruptedException ex1) {
              ex1.printStackTrace();
            }
          }
          jsfCanvasface.requestFocus();
          jsfCanvasface.paint(jsfCanvasface.getGraphics());
          try {
            Thread.sleep(500);
          }
          catch (InterruptedException ex) {
            ex.printStackTrace();
          }
          if(jsfCanvasface.getJSFComponentface_()==null) break;
          boolean b = jsfCanvasface.getJSFComponentface_().falling();
          if (!b) {
            //添加到绘制面板缓冲器中
            jsfCanvasface.addShape(jsfComponentface);

            //将面板中占用的方块设置为true
            int[][] rects = jsfComponentface.getRects();
            boolean reseau[][] = jsfCanvasface.getReseau();
            for (int i = 0; i < rects.length; i++) {
              int x1 = rects[i][0];
              int y1 = rects[i][1];
              if(x1<reseau[y1].length)
                reseau[y1][x1] = true;
            }

            //判断是否有可以清除的行
            for (int i = 0; i < reseau.length; i++) {
              boolean b1 = true;
              for (int j = 0; j < reseau[i].length; j++) {
                if (reseau[i][j] == false) {
                  b1 = false;
                  break;
                }
              }
              //整行为可删除行
              if (b1) {
                //遍历所有的已经添加到绘制器缓冲中的组件
                JSFComponentface[] jsfComponentfaces = jsfCanvasface.
                    getComponents();
                for (int k = 0; k < jsfComponentfaces.length; k++) {
                  int[][] rects1 = jsfComponentfaces[k].getRects();
                  boolean b2 = true;
                  //遍历一个组件的每个占用的方块
                  for (int q = 0; q < rects1.length; q++) {

                    //将可以清除行上的方块置为空
                    if (rects1[q] != null && rects1[q][1] == i) {
                      rects1[q] = null;
                    }

                    //这个IF可以判断出来是否一个组件的所有占用方块都为null,如果是,那么这个组件就会彻底清除
                    if (rects1[q] != null) {
                      b2 = false;
                    }

                    //在这行上面的组件都要Y值+1
                    if (rects1[q] != null && rects1[q][1] < i) {
                      rects1[q][1]++;
                    }
                  }

                  //清除一个都为null的组件
                  if (b2) {
                    jsfComponentfaces[k] = null;
                  }
                }

                //将新的结果集写入绘制缓冲器中
                ArrayList arrayList = new ArrayList();
                for (int k = 0; k < jsfComponentfaces.length; k++) {
                  if (jsfComponentfaces[k] != null)
                    arrayList.add(jsfComponentfaces[k]);
                }
                jsfCanvasface.setArrayList(arrayList);
                jsfCanvasface.repaint();

              } //删除整行结束

            } //遍历所有的行，判断是否有可以清除的行，结束

            //重新设置绘制器的boolean值
            JSFComponentface[] jsfComponentfaces = jsfCanvasface.getComponents();
            for (int q = 0; q < reseau.length; q++) {
              for (int j = 0; j < reseau[q].length; j++) {
                reseau[q][j] = false;
              }
            }
            for (int q1 = 0; q1 < jsfComponentfaces.length; q1++) {
              rects = jsfComponentfaces[q1].getRects();
              for (int i = 0; i < rects.length; i++) {
                if (rects[i] != null) {
                  int x1 = rects[i][0];
                  int y1 = rects[i][1];
                  if(x1<reseau[y1].length)
                    reseau[y1][x1] = true;
                }
              }
            }
            break;
          }
        }
      }//
      //游戏结束
      if(isover)
      {
        Graphics g = jsfCanvasface.getGraphics();
        g.setXORMode(Color.white);
        g.setFont(new Font("Dialog", Font.BOLD, 48));
        g.drawString("Game", 20, 120);
        g.setFont(new Font("Dialog", Font.BOLD, 36));
        g.drawString("Over", 50, 180);
      }
    }//同步块
  }

  public void stopGame()
  {
    if(isstart)
    {
      isstart=false;
      jsfCanvasface.removeAll();
      jsfCanvasface.repaint();
    }
  }

  public void startGame()
  {
    if(!isstart)
    {
      this.start();
      isstart = true;
    }
  }

  public void setWait(boolean iswait)
  {
    this.iswait=iswait;
  }

  public synchronized void setNotify()
  {
    this.iswait=false;
    this.notify();
  }

  public boolean getWait()
  {
    return iswait;
  }


  private void viewBuffCom()
  {
    Graphics2D g2d=(Graphics2D)jPanel2.getGraphics();
    JSFComponentface jsfComponentface_=ToolsUtil.jsfComponentfaceBuff;
    if(jsfComponentface_!=null)
    {
      g2d.clearRect(0,0,jPanel2.getWidth(),jPanel2.getHeight());
      g2d.setColor(Color.white);
      g2d.fillRect(0,0,jPanel2.getWidth(),jPanel2.getHeight());
      g2d.setColor(Color.gray);
      g2d.drawRect(0,0,jPanel2.getWidth()-1,jPanel2.getHeight()-1);
      int x=jsfComponentface_.getX();
      int[][] rects=jsfComponentface_.getRects();
      for(int j=0;j<rects.length;j++)
      {
        if(rects[j]!=null)
        {
          int x1 = rects[j][0]-x+1;
          int y1 = rects[j][1]+1;
          Rectangle rectangle = new Rectangle(x1 * jsfCanvasface.getSpace(), y1 * jsfCanvasface.getSpace(), jsfCanvasface.getSpace(),
                                              jsfCanvasface.getSpace());
          g2d.setColor(jsfComponentface_.getFillColor());
          g2d.fill(rectangle);
          g2d.setColor(jsfComponentface_.getFrameColor());
          g2d.draw(rectangle);
        }
      }
    }

  }
}