chesscanvas.java

这是一个Java编写的手机象棋游戏

			//画河
			g.setColor(riverColorR,riverColorG,riverColorB);
			g.fillRect(vx, hy + height * 4, width * 8 + 1, height + 1);
			g.setColor(timeColorR,timeColorG,timeColorB);
			//画出时间
			timePassed = timePassed + sleepTime;
			if(timePassed >= 60000)
			{
				stop = true;
			}
			String	s = new Integer(timePassed / 1000).toString();
			//System.out.println("现在的时间是:"+timePassed / 10);
			if(canDo == 0)
			{
				//在红方画出字符
				g.drawString(s,vLocation,HEIGHT,Graphics.HCENTER|Graphics.BOTTOM);
			}
			else
			{
				//在绿方画出字符
				g.drawString(s,vLocation,0,Graphics.HCENTER|Graphics.TOP);
			}
			//画出棋子初始摆放位置
			for(int i=0;i<10;i++)
			{
				for(int j=0;j<9;j++)
				{
					if(chess[i][j]!=32)
					{
						k=chess[i][j];
						if(k>15)
							g.setColor(myColorR,myColorG,myColorB);
						else
							g.setColor(yourColorR,yourColorG,yourColorB);
						if(isMoved && k == moveChess)
						{
							if(moveTimer == 0)
								isMoved = false;
							else
							{
								moveTimer--;
								g.setColor(selectedColorR,selectedColorG,selectedColorB);
							}
						}
						g.fillArc(width*j+vx-width/2,height*i+hy-height/2,width,width,0,360);
						g.setColor(fontColorR,fontColorG,fontColorB);
						//与画字符有关的，各种差值固定，不随机型改变
						g.drawString(str[k],width*j+vx,height*i+hy - charHeight/2,Graphics.TOP|Graphics.HCENTER);
					}
	
				}
			}
			
			//*******************画出绿方棋子动作
			if(acceptState)
			{
				//System.out.println("ChessCanvas开始绘制一个传来的棋子变化");
				a1=accept[0];
				a2=accept[1];
				a3=accept[2];
				a4=accept[3];
				//绿方棋子动作之前，先将前一步状态保存下来，以便悔棋
				gm=a1;gn=a2;gy=a3;gx=a4;
				gg=chess[a3][a4];
				//若是红将被吃，则此局结束
				if(gg == 16 || gg == 0)
					stop = true;
				//绿方动作
				chess[a3][a4]=chess[a1][a2];
				chess[a1][a2]=32;
				//动棋标记开始
				moveChess = chess[a3][a4];
				isMoved = true;
				moveTimer = 6;
				//动棋标记结束
				acceptState=false;
				//绘制完对方的棋子变化后，打开锁，我方可以动棋子
				canDo=0;
				//计时恢复为0
				timePassed = 0;
				//播放音乐
				if(isMoving)
					musicMoving.moving();
			}
			//*******************画出红方棋子选择色彩
			if(state==true)
			{	
				g.setColor(selectedColorR,selectedColorG,selectedColorB);
				g.fillArc(width*n+vx-width/2,height*m+hy-height/2,width,width,0,360);
				k=chess[m][n];
				g.setColor(fontColorR,fontColorG,fontColorB);
				g.drawString(str[k],width*n+vx,height*m+hy - charHeight/2,Graphics.TOP|Graphics.HCENTER);
			}
			//画选择框
			g.setColor(selectColorR,selectColorG,selectColorB);
			g.drawRect(vx+x*width-(bandLength+1)/2,hy+y*height-(bandLength+1)/2,bandLength,bandLength);
			
			long endTime = System.currentTimeMillis();
			int duration = (int)(endTime - startTime);
			//画时间
			if(duration<(sleepTime - 10))
			{
				try
				{
					Thread.sleep(sleepTime-duration);
				}
				catch(InterruptedException ie)
				{
					
				}
			}
			//在真机上运行时,此处的休眠时间可减少到100
			flushGraphics();
		}
		//显示一个Alert,然后转到主菜单界面
		//errorDeal.push("等待超时，退出", mainSelect);
		closeChessCanvas();
		Chess.dis.setCurrent(mainSelect);
	}
	
	//***********************自定义方法调用
	
	private void closeChessCanvas()
	{
		//终止绘图循环
		stop=true;
		if(ifTelent)
		{
			telentThreadStop = true;
		}
	}
	//擂主获取棋盘状态，观战者提供
	public int[][] getChessState()
	{
		int[][] tempchess = new int[10][9];
		for(int i = 0; i < 10; i++)
		{
			for(int j = 0; j < 9; j++)
			{
				tempchess[i][j] = chess[i][j];
			}
		}
		return tempchess;
	}
	//关闭监听器,发送棋盘变化,启动监听器
	private void sendChance()
	{//先取消看擂服务监听器，再发送棋盘走步变化
		try
		{
			//System.out.println("关闭看擂服务监听器");
			if(!ifHaveViewer)
				serverChess.stop();
			//System.out.println("看擂服务监听器关闭成功");
		}
		catch (IOException e)
		{
			//System.out.println("关闭监听器失败,无法发送数据");
			//给出提示，重试或者退出程序
			//Alert alert=new Alert("Message","关闭监听器失败,无法发送数据",null,AlertType.WARNING);
			//Chess.dis.setCurrent(alert,mainSelect);
			Chess.quitApp();
		}
		Thread sendThread=new Thread()
		{
			public void run()
			{//唯一的问题是能不能保证第一个执行完第二个再执行
				//System.out.println("开始向对方发送数据");
				//发送完毕数据后将启动监听器
				//创建类后立即执行下面的语句输出
				new ClientChess(content, chessCanvas, serverOrClient);
				//System.out.println("棋盘走步变化发送成功");
			}
		};
		sendThread.start();
	}
	public void setChance(int[] accept, boolean b)
	{
		this.accept = accept;
		if(b)
		{//收到对方已经接收到看擂客户的信号
			ifHaveViewer = true;
		}
		if(accept[0]!=10)
		{
			acceptState=true;
			//设置标记,该我方动棋了，不能再悔棋
			if(ifSaveRecord)
			{
				chessRecord.addContent(accept);
			}
		}
		else
		{
			chess[gm][gn]=chess[gy][gx];
			chess[gy][gx]=gg;
			//收到对方的悔棋后，关锁
			canDo=1;
			//计时恢复为0
			timePassed = 0;
			//删除记录
			if(ifSaveRecord)
				chessRecord.delTail();
		}
		//接收完棋盘走步变化后，打开看擂服务监听器
		if(!ifHaveViewer)
			initViewerThread();
	}
	//自定义看擂服务线程
	private void initViewerThread()
	{
		//System.out.println("看擂服务提供者打开监听器");
		//连接上一个看擂者后，调用haveViewer()方法将标记变量ifHaveViewer置true
		serverChess = new ServerChess(chess, chessCanvas);
	}
	public void setServerOrClient(boolean b)
	{
		serverOrClient = b;
	}
	public void haveViewer()
	{
		ifHaveViewer = true;
	}
	public boolean ifHaveViewer()
	{
		return ifHaveViewer;
	}
	//自定义数据接收线程
	public void initAcceptThread()
	{
		//System.out.println("打开监听器，接收对方棋盘走步");
		new ServerChess(this);
	}

	//自定义内部绿方智能走步线程
	private void initTelentThread()
	{
		telentThread=new Thread()
		{
			public void run()
			{
				while(!telentThreadStop)
				{
					if(telentState)
					{
						//System.out.println("CPU开始计算走步");
						accept = telent.go();
						//System.out.println("CPU计算走步完成m:"+accept[0]+",n:"+accept[1]+",y:"+accept[2]+",x:"+accept[3]);
						acceptState = true;
						telentState = false;
					}
					try
					{
						Thread.sleep(500);
					}
					catch(InterruptedException ie)
					{
						
					}
				}
			}
		};
		telentThread.start();
	}

	//************************走步算法
	public boolean check(int c,int d,int f,int e,boolean flag)
	{
		//车的检查算法
		if(chess[c][d]==24||chess[c][d]==25)
		{
			if(c==f)
			{
				if(d>e)
				{
					for(int i=e+1;i<d;i++)
					{
						if(chess[c][i]!=32)
							return false;
					}
					return true;
				}
				if(d<e)
				{
					for(int i=d+1;i<e;i++)
					{
						if(chess[c][i]!=32)
							return false;
					}
					return true;
				}
				if(d==e)
				{
					state=false;
					return false;
				}
			}
			if(d==e)
			{
				if(c>f)
				{
					for(int i=f+1;i<c;i++)
					{
						if(chess[i][d]!=32)
							return false;
					}
					return true;
				}
				if(c<f)
				{
					for(int i=c+1;i<f;i++)
					{
						if(chess[i][d]!=32)
							return false;
					}
					return true;
				}
				if(c==f)
				{
					state=false;
					return false;
				}
				return true;
			}
		}
		//马的检查算法
		if(chess[c][d]==26||chess[c][d]==27)
		{
			if((Math.abs(c-f)==2&&Math.abs(d-e)==1&&chess[(c+f)/2][d]==32)||(Math.abs(c-f)==1&&Math.abs(d-e)==2&&chess[c][(d+e)/2]==32))
				return true;
			else
				return false;
		}
		//相的检查算法
		if(chess[c][d]==28||chess[c][d]==29)
		{
			if(c>4&&f>4&Math.abs(c-f)==2&&Math.abs(d-e)==2&&chess[(c+f)/2][(d+e)/2]==32)
				return true;
			else
				return false;
		}
		//士的检查算法
		if(chess[c][d]==30||chess[c][d]==31)
		{
			if(c>6&&c<10&&f>6&&f<10&&d<6&&d>2&&e<6&&e>2&&Math.abs(c-f)==1&&Math.abs(d-e)==1)
				return true;
			else
				return false;
		}
		//将的检查算法
		if(chess[c][d]==16)
		{
			if(c>6&&c<10&&f>6&&f<10&&d<6&&d>2&&e<6&&e>2&&((Math.abs(c-f)==1&&Math.abs(d-e)==0)||(Math.abs(c-f)==0&&Math.abs(d-e)==1)))
			{
				for(int j = 0; j < 3; j++)
				{
					if(chess[j][e] == 0)
					{
						for(int s = j + 1; s < c; s++)
						{
							if(chess[s][e] != 32)
								return true;
						}
						return false;
					}
				}
				return true;
			}
			else
				return false;
		}
		//炮的检查算法
		if(chess[c][d]==22||chess[c][d]==23)
		{
			if(!flag)
			{//在炮不吃东西的情况下，同车的算法相同
				if(c==f&&d!=e)
				{
					if(d>e)
					{
						for(int i=e+1;i<d;i++)
						{
							if(chess[c][i]!=32)
								return false;
						}
						return true;
					}
					else
					{
						for(int i=d+1;i<e;i++)
						{
							if(chess[c][i]!=32)
								return false;
						}
						return true;
					}
				}
				if(d==e&&c!=f)
				{
					if(c>f)
					{
						for(int i=f+1;i<c;i++)
						{
							if(chess[i][d]!=32)
								return false;
						}
						return true;
					}
					else
					{
						for(int i=c+1;i<f;i++)
						{
							if(chess[i][d]!=32)
								return false;
						}
						return true;
					}
				}
				else
					return false;
			}
			if(flag)
			{
				if(c==f)
				{
					if(d>e)
					{
						int noNullNumber=0;
						for(int i=e+1;i<d;i++)
						{
							if(chess[c][i]!=32)
								noNullNumber=noNullNumber+1;
						}
						if(noNullNumber==1)
							return true;
						else
							return false;
					}
					if(d<e)
					{
						int noNullNumber=0;
						for(int i=d+1;i<e;i++)
						{
							if(chess[c][i]!=32)
								noNullNumber=noNullNumber+1;
						}
						if(noNullNumber==1)
							return true;
						else
							return false;
					}
					else
					{
						state=false;
						return false;
					}
				}
				if(d==e)
				{
					if(c>f)
					{
						int noNullNumber=0;
						for(int i=f+1;i<c;i++)
						{
							if(chess[i][d]!=32)
								noNullNumber=noNullNumber+1;
						}
						if(noNullNumber==1)
							return true;
						else
							return false;
					}
					if(c<f)
					{
						int noNullNumber=0;
						for(int i=c+1;i<f;i++)
						{
							if(chess[i][d]!=32)
								noNullNumber=noNullNumber+1;
						}
						if(noNullNumber==1)
							return true;
						else
							return false;
					}
					else
					{
						state=false;
						return false;
					}
				}
				else
				{
					return false;
				}
			}
		}
		//卒的检查算法
		if(chess[c][d]>16&&chess[c][d]<22)
		{
			//System.out.println("卒走步判断");
			if(c>4&&c<10)
			{
				if((c-f)==1&&d==e)
					return true;
				else
					return false;
			}
			if(c<5&&c>=0)
			{
				if(((c-f)==1&&d==e)||(c==f&&Math.abs(d-e)==1))
					return true;
				else
					return false;
			}
			else
				return false;
		}
		else
			return false;
	}
};