tetrics.java

我自己做的一个小游戏

/**
 * 
 */
package tetrics;

import java.awt.*;
import javax.swing.*;
import java.awt.event.KeyListener;
import java.awt.event.KeyEvent;
/**
 * @author Administrator
 *
 */

public class Tetrics extends JPanel //implements Runnable,KeyListener
{
	final Color BAKCOLOR=new Color(80,123,166);
	
	final Color FORCOLOR=Color.black;
	
	final int XOFFSET=200;
	
	int m_nSqLength;
	
	boolean m_bJustupdating;
//	int m_tFrame;
	int m_nTheScore=0;
	
	static int m_nCols;
	
	static int m_nRows;
	
	boolean m_bGameInPlay;
	boolean m_bNeedNewPiece;
	int m_nPlayLevel;
	int m_nPieceValue=0;
	
	Color m_colors[];
	int m_nDelayMap[]={600,600,600,500,400,300,250,200,150,100};
	
	public static int NOSQUARE=0;
	Square m_curPiece[]=new Square[4];
	Square m_prePiece[]=new Square[4];
	
	int m_nField[][];
	int m_nOldField[][];
	int m_nTotalPieces;
	boolean m_bPaused=false;
	
	Thread m_theThread=null;
	
	public Tetrics()
	{
		super();
		
		try
		{
			jbInit();
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
		}
	}
	
	public Tetrics(TetricsFrame tFrame)
	{
		super();
		
//		m_tFrame=tFrame;
		
		try
		{
			jbInit();
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
		}		
	}
	
	void jbInit() throws Exception
	{
		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_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 paint(Graphics g)
	{
		g.setFont(new Font("宋体",0,18));
		
		int gx=m_nSqLength;
		
		int gy=m_nSqLength*m_nRows/4;
		
		g.clearRect(gx, gy-25, XOFFSET-gx, 25);
		
		g.drawString("Scorc:"+m_nTheScore, gx, gy);
		
		gy+=30;
		
		g.clearRect(gx, gy-25, XOFFSET-gx, 25);
		
		g.drawString("Level:"+m_nPlayLevel, gx, gy);
		
		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);
			}
		}
		
		for(int i=0;i<m_nCols;i++)
			
			for(int j=0;j<m_nRows;j++)
			{
				g.fill3DRect(XOFFSET+m_nSqLength*i,
						m_nSqLength+m_nSqLength*j, m_nSqLength	
						, m_nSqLength, true);
			}
	}
}
	/*
	public void update(Graphics g)
	{
		m_bJustupdating=true;
		paint(g);
	}
	
	private void newPrePiece()
	{
		int middle=m_nCols/2;
		int top=m_nRows;
		
		switch((int)(Math.random()*7))
		{
		case 0:
			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:
			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:
			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:
			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:
			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:
			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:
			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);
	}
	
	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 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;
	}
	
	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;
			}
	}
	
	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;
			}
			
			this.update(this.getGraphics());
		}
		
		m_theThread=null;
	}
	
	public synchronized void start()
	{
		requestFocus();
		
		if(m_theThread!=null)
		{
			m_theThread.resume();
			m_bPaused=false;
			return ;
		}
		
		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_nTheScore=0;
		m_nTotalPieces=0;
		m_bNeedNewPiece=true;
		m_bGameInPlay=true;
		
		m_theThread=new Thread(this);
		newPrePiece();
		m_theThread.start();
		this.update(this.getGraphics());
		
		
	}
	
	public synchronized void pause()
	{
		if(m_theThread!=null)
		{
			try
			{
				m_theThread.suspend();
				m_bPaused=true;
			}
			catch(Exception e)
			{
				e.printStackTrace();
			}
		}
	}
	
	public synchronized void stop()
	{
		if(m_theThread!=null)
			m_theThread.stop();
		m_theThread=null;
	}
	
	public void KeyTyped(KeyEvent e)
	{
		int nKeyCode=e.getKeyChar();
		
		switch(nKeyCode)
		{
		case 97:
			moveCurPiece(-1,0,false);
			m_bNeedNewPiece=false;
			this.update(this.getGraphics());
			break;
		case 115:
			while(moveCurPiece(0,-1,false))
			{
				;
			}
			this.update(this.getGraphics());
			break;
		case 100:
			moveCurPiece(1,0,false);
			m_bNeedNewPiece=false;
			this.update(this.getGraphics());
			break;
		case 119:
			moveCurPiece(0,0,true);
			this.update(this.getGraphics());
			break;
		}
	}
}



*/