gobang.java

单机五子棋java源码

					if(warnningBlack[i].warnningLevel==max)
						temp[++index]=warnningBlack[i];							
				
				for(int i=0;i<=index;i++)
				{
					System.out.println("temp["+i+"]="+temp[i].warnningLevel);
					System.out.println("flag="+temp[i].flag);
					System.out.println("可填充坐标:");
					System.out.println("x1="+temp[i].x1+"\ty1="+temp[i].y1);					
					if(temp[i].flag==true)
					System.out.println("x2="+temp[i].x2+"\ty2="+temp[i].y2);												
				}
				//在4个方向上仅存在一个方向有唯一的最大值
				//且这个方向上具有此相同最大值的空位仅有一个
				if(index==0&&temp[0].flag==false)		
					return b[temp[0].x1][temp[0].y1];
				//在两个威胁级别相同的空位中找出一个最优的
				else
				{	//a[][]存储所有状态为空且对于PLAYER
					//有利级别相同的棋子坐标	
					int [][] a=new int [(index+1)*2+1][2];
					int t=-1;
					System.out.println("*******************");
					System.out.println("所有具有相同级别的空位");
					for(int i=0;i<=index;i++)
					{
						a[++t][0]=temp[i].x1;
						a[t][1]=temp[i].y1;
						System.out.println("("+a[t][0]+","
						+a[t][1]+")");
						if(temp[i].flag==true)
						{
							a[++t][0]=temp[i].x2;
							a[t][1]=temp[i].y2;
							System.out.println("("+a[t][0]+","
							+a[t][1]+")");
						}
					}
					//最后一个存储最大威胁级别
					a[++t][0]=temp[0].warnningLevel;
					
					System.out.println("相同级别为:"+a[t][0]);
					System.out.println("*******************");
					
					return compare(a,t+1,PLAYER);
				
				}				
				
			}
			else
				return null;	
		//危险未达到指定级别则调用computerPlayChess()使白方下棋			
		}
		//在坐标数组a(这些坐标都是空位)
		//中找出一个若填充则对状态为state
		//一方最有利的空位返回,
		//这些空位目前的威胁级别都为maxWarnning
		private Chessman compare(int [][] a,int lengthOfa,int state)
		{
			System.out.println("***** Chessman compare(int [][] a,int lengthOfa,int state) ****");
			//分别对两个空位进行考虑
			int [] x=new int [lengthOfa];
			int [] y=new int [lengthOfa];
					
			int sameLevel=a[lengthOfa-1][0];
			//标示威胁级别大于等于samweLevel的方向数
			int [] c=new int [lengthOfa];
			int [] level=new int [lengthOfa];
			for(int i=0;i<lengthOfa;i++)
			{
				x[i]=a[i][0];
				y[i]=a[i][1];
				c[i]=0;
				level[i]=sameLevel;
			}
		 	int l=0;
			//对每个点的4个方向，若某一方向的威胁级别
			//与sameLevel相同则对应的威胁方向计数器c自增
			//若在某一方向上的级别大于sameLevel则c=1,level1更新
			boolean flag;//仅扫描4个方向
			for(int r=0;r<lengthOfa;r++)
			{
				flag=false;
				for(int i=x[r]-1;i<=x[r]+1&&flag==false;i++)
				for(int j=y[r]-1;j<=y[r]+1&&flag==false;j++)
				{
					if(i==x[r]&&j==y[r]){flag=true;break;}
					l=0;
					int dr1=x[r]-i,dc1=y[r]-j;
					int m=i,n=j;
		
					while(m>=0&&m<rows&&n>=0&&n<cols
					&&b[m][n].getStatus()==state)
					{
				//		System.out.println(b[m][n]);	
				//		try{
				//			System.in.read();
				//		}catch(IOException e){}
						l++;
						m-=dr1;n-=dc1;		
					}													
					m=x[r]+dr1;n=y[r]+dc1;
					while(m>=0&&m<rows&&n>=0&&n<cols
					&&b[m][n].getStatus()==state)
					{
				//		System.out.println(b[m][n]);	
				//		try{
				//			System.in.read();
				//		}catch(IOException e){}
						l++;
						m+=dr1;n+=dc1;
					}					
					if(l>level[r])
					{c[r]=1;level[r]=l;}
					else if(l==level[r])					
							c[r]++;
					
				}								
			}
		
		
			
			//找出对状态为state的一方最有利的一个空子的有利值
			int maxLevel=level[0];		
			int k=0;
			for(int i=1;i<lengthOfa;i++)
				if(level[i]>maxLevel)				
				{
					maxLevel=level[i];
					k=i;
				}
			System.out.println("*********************");
			System.out.println("对"+state+"方最大可连通棋子数="+maxLevel);
			int count=c[k];
			for(int i=0;i<lengthOfa;i++)
				if(level[i]==maxLevel&&c[i]>count)
				{
					k=i;
					count=c[i];
				}
			System.out.println("找到"+b[x[k]][y[k]]
			+"威胁最大连通棋子方向数="+count);	
			System.out.println("*********************");
			return b[x[k]][y[k]];			
		}
		//对一个棋子对象ches的警告数组array初始化 
		private void initWarnningArray(warnning [] array,Chessman ches)
		{
			
			if(array==null)return;
			int x=ches.getPX(),y=ches.getPY();
			int state=ches.getStatus();
			int i,j;
			int index=-1;
			
	//		System.out.println("*******************initWarnningArray() start***************");
	//		System.out.println("考虑棋子"+ches+"的危险级别");
		
		
			for(i=x-1;i<=x+1&&index<3;i++)
				for(j=y-1;j<=y+1&&index<3;j++)
				{
			//		if(index>=3)return;
			//		if(i==x&&j==y)continue;//跳过
	//				System.out.println("************************");
	//				System.out.println("当前直线的第一个棋子:b["+i+"]["+j+"]");
	//				System.out.println("************************");
	//				try{
	//					System.in.read();
	//				}catch(IOException e){}	
					
					int dr1=x-i,dc1=y-j;
					int m=i,n=j;
					int x1=-1,x2=-1,y1=-1,y2=-1;
					
					//分别找出一条线上在当前棋子两头的两个空位
	//				System.out.println("1st while()寻找第一个空位:");
					while(m>=0&&m<rows&&n>=0&&n<cols
					&&(b[m][n].getStatus()==state||b[m][n].getStatus()==NULL))
					{
	//					System.out.println(b[m][n]);	
	//					try{
	//						System.in.read();
	//					}catch(IOException e){}
						if(b[m][n].getStatus()==NULL)
							{x1=m;y1=n;break;}
						m-=dr1;n-=dc1;		
					}
	//				System.out.println("第1个空位\nx1="+x1+"\ty1="+y1);
	//				System.out.println("************************");
	//				System.out.println("2nd while()寻找第2个空位");
					m+=dr1;n+=dc1;
					while(m>=0&&m<rows&&n>=0&&n<cols
					&&(b[m][n].getStatus()==state||b[m][n].getStatus()==NULL))
					{
	//					System.out.println(b[m][n]);	
	//					try{
	//						System.in.read();
	//					}catch(IOException e){}
						if(b[m][n].getStatus()==NULL)
							{x2=m;y2=n;break;}
						m+=dr1;n+=dc1;
					}					
	//				System.out.println("第2个空位\nx2="+x2+"\ty2="+y2);
	//				System.out.println("************************");
					//根据找到的空位找出两个相反方向中威胁最大的空位
					//并将这条直线上的威胁级别和允许填充的空位存入数组
					index++;
					//这个必须new，否则元素没有空间(之前new出的是数组的空间)
					array[index]=new warnning();
					//没有可填充位置，则在这个方向上的危险级别为0
					if(x1==-1&&x2==-1)
					{
	//					System.out.println("在方向   "+index+" 上");
	//					System.out.println("array["+index+"].warnningLevel=");
	//					System.out.println(array[index].warnningLevel);
	//					System.out.print("x1="+array[index].x1);
	//					System.out.println("y1="+array[index].y1);
	//					System.out.print("x2="+array[index].x2);
	//					System.out.println("y2="+array[index].y2);
	//					System.out.println("flag="+array[index].flag);
	//					System.out.println("************************");
						continue;									
					}
					else
					{										
						/*干才的操作则至少取到了一个状态为空的点*/
						/*以下分别对取到的两个点考虑*/
						
						int level_1=0;
						int level_2=0;
						if(x1!=-1)
						{
							m=x1;n=y1;
							m=m-dr1;n=n-dc1;						
							while(m>=0&&m<rows&&n>=0&&n<cols&&(b[m][n].getStatus()==state))
							{
								level_1++;
								m-=dr1;
								n-=dc1;
							}
							m=x1;n=y1;
							m=m+dr1;n=n+dc1;
							while(m>=0&&m<rows&&n>=0&&n<cols&&(b[m][n].getStatus()==state))
							{
								level_1++;
								m+=dr1;
								n+=dc1;
							}
						}
						if(x2!=-1)
						{
							m=x2;n=y2;
							m=m-dr1;n=n-dc1;						
							while(m>=0&&m<rows&&n>=0&&n<cols&&(b[m][n].getStatus()==state))
							{
								level_2++;
								m-=dr1;
								n-=dc1;
							}
							m=x2;n=y2;
							m=m+dr1;n=n+dc1;
							while(m>=0&&m<rows&&n>=0&&n<cols&&(b[m][n].getStatus()==state))
							{
								level_2++;
								m+=dr1;
								n+=dc1;
							}
						}
									
						//找出这条直线两个方向上的最危险位置并存入数组
						if(level_1>level_2)
						{
							array[index].warnningLevel=level_1;
							array[index].x1=x1;
							array[index].y1=y1;
							//array[index].(x2,y2)未赋值则为初始值(-1,-1)
							
	//						System.out.println("array["+index+"].level="+array[index].warnningLevel);	
	//						System.out.println("允许填充点:");
	//						System.out.println("x1="+array[index].x1+"\ty1="+array[index].y1);
						}
						else if(level_1<level_2)
						{
							array[index].warnningLevel=level_2;
							array[index].x1=x2;
							array[index].y1=y2;
							//array[index].(x2,y2)未赋值则为初始值(-1,-1)	
							
	//						System.out.println("array["+index+"].level="+array[index].warnningLevel);	
	//						System.out.println("允许填充点:");
	//						System.out.println("x1="+array[index].x1+"\ty1="+array[index].y1);
						}
						else if(level_1==level_2)
						{
							array[index].warnningLevel=level_1;
							array[index].x1=x1;
							array[index].y1=y1;							
							array[index].x2=x2;
							array[index].y2=y2;
							array[index].flag=true;
	//						System.out.println("array["+index+"].level="+array[index].warnningLevel);	
	//						System.out.println("允许填充点:");
	//						System.out.println("x1="+array[index].x1+"\ty1="+array[index].y1);
	//						System.out.println("x2="+array[index].x2+"\ty2="+array[index].y2);	
						}		
					}						
		 		}		 					
	//		System.out.println("*******************initWarnningArray() End***************");			
		}
	
		//以下为白方下棋方法
		class stack 
		{
			int top=-1;
			Chessman [] s=new Chessman[cols*rows];
			void push(Chessman c)
			{
				if(c.getStatus()!=COMPUTER
				||StackWhite.top==StackWhite.s.length-1)							
					return; 
				StackWhite.s[++StackWhite.top]=c;
				System.out.print("("+
				StackWhite.s[StackWhite.top].getPX()+
				","+StackWhite.s[StackWhite.top].getPY()+")已进站");
			}
			void pop()
			{StackWhite.top--;}
		}
	
		stack StackWhite=new stack(); //白方所走的步骤堆栈
	/*	private void computerPlayChess()//电脑下棋
		{
			//对每一个白棋的有利值数组
			warnning [] a=new warnning[4];
			
			//对每个白棋的4条直线中存在一个或几个最易取胜的空位
			//将与所有白棋相关联的最
			//大胜算值相同的空位加入到Danger数组
			warnning [] danger=new warnning[rows*cols];
			int index=-1;//danger数组的下标域
			int maxDanger=0;//最大胜算空位的值
			for(int i=StackWhite.top;i>-1;i--)
			{
				//对每一个堆栈中的棋子求出警告数组
				initWarnningArray(a,StackWhite.s[i]);
				int maxLevel=a[0].warnningLevel;
				int k=0;
				//找出最大值
				for(int j=1;j<a.length;j++)
					if(a[j].warnningLevel>maxLevel)					
					{
						maxLevel=a[j].warnningLevel;
						k=j;
					}	
				//找出具有相同最大值的空位
				for(int j=0;j<a.length;j++)
					if(a[j].warnningLevel==maxLevel)
						danger[++index]=a[j];
				
				System.out.println("**************************");
				System.out.println("考虑白棋("
				+StackWhite.s[i].getPX()
				+","+StackWhite.s[i].getPY()
				+")  Status="
				+StackWhite.s[i].getStatus()
				+"\n的最大有利空位("+
				a[k].x+","+a[k].y+")"+"\n有利值为:"
				+a[k].warnningLevel);		
				
					
				if(i==StackWhite.top)
				{	//第一个白棋求出的对黑方的最大威胁空位
					System.out.println("index="+index);
					maxDanger=a[k].warnningLevel;
					danger[++index]=a[k];					
					System.out.println("index="+index);
				}
				else if(maxDanger<a[k].warnningLevel)
				{
					//找到新的最大值，更新整个数组
					index=-1;
					maxDanger=a[k].warnningLevel;
					danger[++index]=a[k];
				}
				else if(maxDanger==a[k].warnningLevel)
					danger[++index]=a[k];														
			}
			//没有任何空位与任何一个白棋相连
			if(maxDanger==0)
			{mode_1();return;}
			//flag用来对相同的实列计数
			int [] flag=new int[index+1];
			int maxCount=flag[0];
			int num=0;
			for(int i=0;i<=index;i++)
			{
				flag[i]=0;
				for(int j=0;j<=index;j++)
					if(j==i)continue;
					else if(danger[i]==danger[j])
							flag[i]++;
				if(flag[i]>maxCount)
				{
					maxCount=flag[i];
					num=i;
				}
			}
			b[a[num].x][a[num].y].setCurrStatus(COMPUTER);		
		}	*/
		
	} 
	//判断对当前棋子的操作是否出现胜负或平局
	
	//返回当前胜负状态,-1为挕么都不是
	int GetGameOver()
	{
		return winFlag;
	}
}