计算机博弈大赛 -- 爱因斯坦棋 (java源码)

已于 2022-07-14 15:18:31 修改
阅读量4.3k 收藏 88
点赞数 4
分类专栏： 综合实践 文章标签： java
于 2022-05-29 12:00:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_60292931/article/details/125028836
版权

目录


内容较多，需要加载一会儿

一、画棋盘

package ewn;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.util.Scanner;


public class chessBoard {
	public static final Scanner sc=new Scanner(System.in,"UTF-8");
}

class thisChessBoard{
	public static String[][] table=new String[5][5];//定义一5*5的棋盘
	private static int redc=0; //用来控制输入的棋子
	private static int bluec=0; //用来控制输入的棋子
	//初始化棋盘
	public static void initTable()
	{
		for(int i = 0; i < table.length; ++i)
			for(int j = 0; j < table[i].length; ++j)
				table[i][j] = "__";
	}

	//画棋盘
	public void drawTable() {
		System.out.println("----------------------------------------------------");
		System.out.printf("\n");
		for(int i=0;i<table.length;i++){//棋盘的高度
			System.out.print(5-i);
			for(int j=0;j<table.length;j++) {//单词高度，每格里追综数据给数组
				System.out.printf("   "+"%s"+"   ",table[i][j]);
			}
			System.out.printf("\n");
			System.out.printf("\n");
		}
		//System.out.print("  ");
		for(int i=1;i<=table.length;i++)//坐标表示
		{

			System.out.printf("    "+"%s"+"   ",change(i));
		}
		System.out.printf("\n\n");
		System.out.println("----------------------------------------------------");
	}

	//蓝方棋子布局（默认）
	public void autowriteblue() throws UnsupportedEncodingException {
		PrintStream ps=new PrintStream(System.out,true,"UTF-8");
		table[2][4]="B1";
		table[3][4]="B3";
		table[3][3]="B2";
		table[4][4]="B6";
		table[4][3]="B5";
		table[4][2]="B4";
		this.drawTable();
	}
	//红方棋子布局（默认）
	public void autowritered() throws UnsupportedEncodingException {
		PrintStream ps=new PrintStream(System.out,true,"UTF-8");
		table[0][0]="R1";
		table[0][1]="R2";
		table[0][2]="R3";
		table[1][0]="R4";
		table[1][1]="R5";
		table[2][0]="R6";
		this.drawTable();
	}
	//蓝方棋子布局（自定义定位）
	public void dewriteblue() throws UnsupportedEncodingException {
		PrintStream ps=new PrintStream(System.out,true,"UTF-8");
		table[2][4]=" 1";
		table[3][4]=" 2";
		table[3][3]=" 3";
		table[4][4]=" 4";
		table[4][3]=" 5";
		table[4][2]=" 6";
		this.drawTable();
	}
	//红方棋子布局（自定义定位）
	public void dewritered() throws UnsupportedEncodingException {
		PrintStream ps=new PrintStream(System.out,true,"UTF-8");
		table[0][0]=" 1";
		table[0][1]=" 2";
		table[0][2]=" 3";
		table[1][0]=" 4";
		table[1][1]=" 5";
		table[2][0]=" 6";
		this.drawTable();
	}
	//蓝方棋子布局
	public void writeblue() throws UnsupportedEncodingException {
		PrintStream ps=new PrintStream(System.out,true,"UTF-8");
		String str=chessBoard.sc.nextLine();
		String[] arr=str.split("\\s+");
		for(int i=1;i<=3;i++)//控制行数
		{
			int c=4;//数组的列下标
			for(int j=1;j<=i;j++)
			{
				table[i+1][c]=arr[bluec];
				c--;//数组的列下标
				bluec++;//用来控制输入的棋子
			}
		}
		this.drawTable();
	}
	//红方棋子布局
	public void writered() throws UnsupportedEncodingException {
		PrintStream ps=new PrintStream(System.out,true,"UTF-8");
		String str=chessBoard.sc.nextLine();
		String[] arr=str.split("\\s+");
		int b=2;//初始化列标限制
		for(int i=0;i<3;i++)//控制行标
		{
			for(int j=0;j<=b;j++)//控制列标
			{
				table[i][j]=arr[redc];
				redc++;
			}
			b--;//列表限制-1
		}
		this.drawTable();
	}
	//数字转字母
	public String change(int i) {
		String l = null;
		switch(i) {
			case 1:
				l = "A";
				break;
			case 2:
				l = "B";
				break;
			case 3:
				l = "C";
				break;
			case 4:
				l = "D";
				break;
			case 5:
				l = "E";
				break;
		}
		return l;

	}
}

二、棋子移动

package ewn;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.util.Scanner;

/*
 * 走棋规则
 */
public class move {
	static final Scanner sc=new Scanner(System.in,"UTF-8");
	int regret;//确定选择是否悔棋

	//记录棋谱
	int arow=0;//记录行号
	int acol=0;//记录列号
	public static int countc = 0;//用于棋谱计数
	public static String chessmanual[] = new String[50];//保存棋谱

	String Start;//保存棋子起始位置的信息，用于悔棋
	String Target ;//保存棋子目标位置的信息，用于悔棋

	seat s=new seat();//坐标位置类实例化
	thisChessBoard tcb=new thisChessBoard();//棋盘布局类实例化
	//红方走棋(电脑)
	void airedMove() throws UnsupportedEncodingException {
		if(s.seatrow!=4)//行坐标不为0
		{
			if(s.seatcol!=4)//列坐标不为0
			{
				//记录起始，目标位置
				Start = tcb.table[s.seatrow][s.seatcol];
				Target = tcb.table[s.seatrow+1][s.seatcol+1];
				//走棋
				tcb.table[s.seatrow+1][s.seatcol+1]=tcb.table[s.seatrow][s.seatcol];//将棋子移动到目标位置
				tcb.table[s.seatrow][s.seatcol]="__";	//将棋子移动前的位置赋值为空，完成棋子移动
				//记录棋谱
				arow = 4-s.seatrow;
				acol = s.seatcol+1;
				cm(arow,acol,Start);

				System.out.print("红方棋子"+tcb.table[s.seatrow+1][s.seatcol+1]+"移动到了"+change1(acol)+arow);
				System.out.print("\n");
				tcb.drawTable();//画出棋盘
				System.out.print("\n1  结束回合     2  悔棋:     ");
				//判断悔棋
				String x=sc.next();
				regret = ltn(x);
				while(!checkt(regret)) {
					System.out.println("输入错误！！！！！请重新输入:");
					System.out.println("1  结束回合     2  悔棋:     ");
					x=sc.next();
					regret = ltn(x);
				}
				if(regret ==1) {
					System.out.printf("\n红方回合结束.。。。\n");
				}
				else {
					//悔棋
					tcb.table[s.seatrow][s.seatcol]=Start;//将棋子移动到起始位置
					tcb.table[s.seatrow+1][s.seatcol+1] = Target ;//将棋子目标位置复原
					System.out.printf("悔棋成功！\n");
					//重新开始
					tcb.drawTable();//画出棋盘
					s.airedSeat();
					airedMove();
				}
			}
			else//列坐标为0
			{
				//记录起始，目标位置
				Start = tcb.table[s.seatrow][s.seatcol];
				Target = tcb.table[s.seatrow+1][s.seatcol];
				//走棋
				tcb.table[s.seatrow+1][s.seatcol]=tcb.table[s.seatrow][s.seatcol];
				tcb.table[s.seatrow][s.seatcol]="__";
				//记录棋谱
				arow = 4-s.seatrow;
				acol = s.seatcol;
				cm(arow,acol,Start);

				System.out.println("红方棋子"+tcb.table[s.seatrow+1][s.seatcol]+"移动到了"+change1(acol)+arow);
				System.out.printf("\n");
				tcb.drawTable();//画出棋盘
				System.out.print("\n1  结束回合     2  悔棋:     ");
				//判断悔棋
				String x=sc.next();
				regret = ltn(x);
				while(!checkt(regret)) {
					System.out.println("输入错误！！！！！请重新输入:");
					System.out.println("1  结束回合     2  悔棋:     ");
					x=sc.next();
					regret = ltn(x);
				}
				if(regret ==1) {
					System.out.printf("\n红方回合结束.。。。\n");
				}
				else {
					//悔棋
					tcb.table[s.seatrow][s.seatcol]=Start;
					tcb.table[s.seatrow+1][s.seatcol] = Target ;
					System.out.printf("悔棋成功！\n");

					tcb.drawTable();//画出棋盘
					s.airedSeat();
					airedMove();
				}
			}
		}
		else//行坐标为0
		{
			//记录起始，目标位置
			Start = tcb.table[s.seatrow][s.seatcol];
			Target = tcb.table[s.seatrow][s.seatcol];
			//行棋
			tcb.table[s.seatrow][s.seatcol+1]=tcb.table[s.seatrow][s.seatcol];
			tcb.table[s.seatrow][s.seatcol]="__";
			//记录棋谱
			arow = 5-s.seatrow;
			acol = s.seatcol+1;
			cm(arow,acol,Start);

			System.out.println("红方棋子"+tcb.table[s.seatrow][s.seatcol+1]+"移动到了"+change1(acol)+arow);
			System.out.printf("\n");
			tcb.drawTable();//画出棋盘
			System.out.print("\n1  结束回合     2  悔棋:     ");
			//判断悔棋
			String x=sc.next();
			regret = ltn(x);
			while(!checkt(regret)) {
				System.out.println("输入错误！！！！！请重新输入:");
				System.out.println("1  结束回合     2  悔棋:     ");
				x=sc.next();
				regret = ltn(x);
			}
			if(regret ==1) {
				System.out.printf("\n红方回合结束.。。。\n");
			}
			else {
				//悔棋
				tcb.table[s.seatrow][s.seatcol]=Start;
				tcb.table[s.seatrow+1][s.seatcol] = Target ;
				System.out.printf("悔棋成功\n");

				tcb.drawTable();//画出棋盘
				s.airedSeat();
				airedMove();
			}
		}
	}
	//蓝方走棋(电脑)
	void aiblueMove() throws UnsupportedEncodingException {
		if(s.seatrow!=0)//行坐标不为0
		{
			if(s.seatcol!=0)//列坐标不为0
			{
				//记录起始，目标位置
				Start = tcb.table[s.seatrow][s.seatcol];
				Target = tcb.table[s.seatrow-1][s.seatcol-1];
				//行棋
				tcb.table[s.seatrow-1][s.seatcol-1]=tcb.table[s.seatrow][s.seatcol];
				tcb.table[s.seatrow][s.seatcol]="__";
				//记录棋谱
				arow = 6-s.seatrow;
				acol = s.seatcol-1;
				cm(arow,acol,Start);

				System.out.println("蓝方棋子:"+tcb.table[s.seatrow-1][s.seatcol-1]+"移动到"+change1(acol)+arow);
				System.out.printf("\n");
				tcb.drawTable();//画出棋盘
				System.out.print("\n1  结束回合     2  悔棋:     ");
				//判断悔棋
				String x=sc.next();
				regret = ltn(x);
				while(!checkt(regret)) {
					System.out.println("输入错误！！！！！请重新输入:");
					System.out.println("1  结束回合     2  悔棋:     ");
					x=sc.next();
					regret = ltn(x);
				}
				if(regret ==1) {
					System.out.printf("\n蓝方回合结束.。。。\n");
				}
				else {
					//悔棋
					tcb.table[s.seatrow][s.seatcol]=Start;
					tcb.table[s.seatrow-1][s.seatcol-1] = Target ;
					System.out.printf("悔棋成功\n");

					tcb.drawTable();//画出棋盘
					s.aiblueSeat();
					aiblueMove();
				}
			}
			else//列坐标为0
			{
				//记录起始，目标位置
				Start = tcb.table[s.seatrow][s.seatcol];
				Target = tcb.table[s.seatrow-1][s.seatcol];
				//行棋
				tcb.table[s.seatrow-1][s.seatcol]=tcb.table[s.seatrow][s.seatcol];
				tcb.table[s.seatrow][s.seatcol]="__";
				//记录棋谱
				arow = 6-s.seatrow;
				acol = s.seatcol;
				cm(arow,acol,Start);

				System.out.println("蓝方棋子:"+tcb.table[s.seatrow-1][s.seatcol]+"移动到"+change1(acol)+arow);
				System.out.printf("\n");
				tcb.drawTable();//画出棋盘
				System.out.print("\n1  结束回合     2  悔棋:     ");
				String x=sc.next();
				regret = ltn(x);
				while(!checkt(regret)) {
					System.out.println("输入错误！！！！！请重新输入:");
					System.out.println("1  结束回合     2  悔棋:     ");
					x=sc.next();
					regret = ltn(x);
				}
				//判断悔棋
				if(regret ==1) {
					System.out.printf("\n蓝方回合结束.。。。\n");
				}
				else {
					//悔棋
					tcb.table[s.seatrow][s.seatcol]=Start;
					tcb.table[s.seatrow-1][s.seatcol-1] = Target ;
					System.out.printf("悔棋成功\n");

					tcb.drawTable();
					s.aiblueSeat();
					aiblueMove();
				}
			}
		}
		else//行坐标为0
		{
			//记录起始，目标位置
			Start = tcb.table[s.seatrow][s.seatcol];
			Target = tcb.table[s.seatrow][s.seatcol-1];
			//行棋
			tcb.table[s.seatrow][s.seatcol-1]=tcb.table[s.seatrow][s.seatcol];
			tcb.table[s.seatrow][s.seatcol]="__";
			//记录棋谱
			arow = 5-s.seatrow;
			acol = s.seatcol-1;
			cm(arow,acol,Start);

			System.out.println("蓝方棋子:"+tcb.table[s.seatrow][s.seatcol-1]+"移动到"+change1(acol)+arow);
			System.out.printf("\n");
			tcb.drawTable();//画出棋盘
			System.out.print("\n1  结束回合     2  悔棋:     ");
			//判断悔棋
			String x=sc.next();
			regret = ltn(x);
			while(!checkt(regret)) {
				System.out.println("输入错误！！！！！请重新输入:");
				System.out.println("1  结束回合     2  悔棋:     ");
				x=sc.next();
				regret = ltn(x);
			}
			if(regret ==1) {
				System.out.printf("\n蓝方回合结束.。。。\n");
			}
			else {
				//悔棋
				tcb.table[s.seatrow][s.seatcol]=Start;
				tcb.table[s.seatrow-1][s.seatcol-1] = Target ;
				System.out.printf("悔棋成功\n");

				tcb.drawTable();
				s.aiblueSeat();
				aiblueMove();
			}
		}

	}
	//蓝方走棋(玩家)
	void blueMove() throws UnsupportedEncodingException {
		PrintStream ps=new PrintStream(System.out,true,"UTF-8");
		Scanner sc=new Scanner(System.in,"UTF-8");
		int num=0;
		//记录骰子数
		System.out.print("\n蓝方回合！    请输入 骰子数(1~6)： \n");
		String x=sc.next();
		num = ltn(x);
		while(!checkt(num)) {
			System.out.println(num+"   骰子输入错误！！！！！请重新输入(1~6):");
			x=sc.next();
			num = ltn(x);
		}
		s.countg[s.g] = num;
		s.g++;
		System.out.println(" 骰子数: "+num+"  蓝方棋子代号(1=B1,2=B2,3=B3,4=B4,5=B5,6=B6)");
		System.out.println(" 请输入要移动的棋子代号！(1-6):");
		x=sc.next();
		num = ltn(x);
		while(!checkt(num)) {
			System.out.println("棋子代号输入错误！！！！！请重新输入(1~6):");
			x=sc.next();
			num = ltn(x);
		}
		s.blueSeat(num);//调用坐标方法，获得蓝方移动前棋子的列号行·号
		System.out.println("请输入蓝方移动后棋子的x坐标(A~E):");
		String str=sc.next();
		while(!checkx(str)) {
			System.out.println("x坐标输入错误！！！！！请重新输入(A~E):");
			str=sc.next();
		}
		System.out.println("请输入蓝方移动后棋子的y坐标(1~5):");
		int str1=0;
		x=sc.next();
		str1 = ltn(x);
		while(!checky(str1)) {
			System.out.println("y坐标输入错误！！！！！请重新输入(1~5):");
			x=sc.next();
			str1 = ltn(x);
		}
		//获得移动后棋子的行列号
		int row=5-str1;
		int col=change2(str);
		//记录起始，目标位置
		Start = tcb.table[s.seatrow][s.seatcol];
		Target = tcb.table[row][col];
		//行棋
		tcb.table[row][col]=tcb.table[s.seatrow][s.seatcol];
		tcb.table[s.seatrow][s.seatcol]="__";
		System.out.println("蓝方棋子:"+Start+"移动到"+str+str1);
		System.out.printf("\n");
		tcb.drawTable();//画出棋盘
		//记录棋谱
		arow = 5-row;
		acol = col;
		cm(arow,acol,Start);

		System.out.println("\n1  结束回合     2  悔棋:     ");
		//判断悔棋
		x=sc.next();
		regret = ltn(x);
		while(!checkt(regret)) {
			System.out.println("输入错误！！！！！请重新输入:");
			System.out.println("1  结束回合     2  悔棋:     ");
			x=sc.next();
			regret = ltn(x);
		}
		if(regret ==1) {
			System.out.printf("\n蓝方回合结束.。。。\n");
		}
		else {
			//悔棋
			tcb.table[s.seatrow][s.seatcol]=Start;
			tcb.table[row][col] = Target ;
			System.out.printf("悔棋成功\n");

			tcb.drawTable();
			blueMove();
		}
	}
	//红方走棋(玩家)
	void redMove() throws UnsupportedEncodingException {
		PrintStream ps=new PrintStream(System.out,true,"UTF-8");
		Scanner sc=new Scanner(System.in,"UTF-8");
		int num=0;
		//记录骰子数
		System.out.print("\n红方回合！    请输入 骰子数(1~6)： \n");
		String x=sc.next();
		num = ltn(x);
		while(!checkt(num)) {
			System.out.println("骰子输入错误！！！！！请重新输入(1~6):");
			x=sc.next();
			num = ltn(x);
		}
		s.countg[s.g] = num;
		s.g++;
		System.out.println(" 骰子数: "+num+"  红方棋子代号(1=R1,2=R2,3=R3,4=R4,5=R5,6=R6)");
		System.out.println(" 请输入要移动的棋子代号！(1-6):");
		x=sc.next();
		num = ltn(x);
		while(!checkt(num)) {
			System.out.println("棋子代号输入错误！！！！！请重新输入(1~6):");
			x=sc.next();
			num = ltn(x);
		}
		s.redSeat(num);//调用坐标方法，获得红方移动前棋子的列号行号

		System.out.println("请输入红方移动后棋子的x坐标(A~E):");
		String str=sc.next();
		while(!checkx(str)) {
			System.out.println("x坐标输入错误！！！！！请重新输入(A~E):");
			str=sc.next();
		}
		System.out.println("请输入红方移动后棋子的y坐标(1~5):");
		int str1=0;
		x=sc.next();
		str1 = ltn(x);
		while(!checky(str1)) {
			System.out.println("y坐标输入错误！！！！！请重新输入(1~5):");
			x=sc.next();
			str1 = ltn(x);
		}

		//获得移动后棋子的行列号
		int row=5-str1;
		int col=change2(str);
		//记录起始，目标位置
		Start = tcb.table[s.seatrow][s.seatcol];
		Target = tcb.table[row][col];
		//行棋
		tcb.table[row][col]=tcb.table[s.seatrow][s.seatcol];
		tcb.table[s.seatrow][s.seatcol]="__";

		System.out.println("红方棋子"+Start+"移动到"+str+str1);
		System.out.printf("\n");
		tcb.drawTable();//画出棋盘
		//记录棋谱
		arow = 5-row;
		acol = col;
		cm(arow,acol,Start);

		System.out.println("\n1  结束回合     2  悔棋:     ");
		//判断悔棋
		x=sc.next();
		regret = ltn(x);
		while(!checkt(regret)) {
			System.out.println("输入错误！！！！！请重新输入:");
			System.out.println("1  结束回合     2  悔棋:     ");
			x=sc.next();
			regret = ltn(x);
		}
		if(regret ==1) {
			System.out.printf("\n红方回合结束.。。。\n");
		}
		else {
			//悔棋
			tcb.table[s.seatrow][s.seatcol]=Start;
			tcb.table[row][col] = Target ;
			System.out.printf("悔棋成功！\n");

			tcb.drawTable();
			redMove();
		}
	}
	//将输入的字母转为数字防止崩盘
	int ltn(String input) {
		int B = 0;
		for(byte b:input.getBytes()) {
			B = b;
		}
		int []c = new int[6];
		c[0]=49;
		c[1]=50;
		c[2]=51;
		c[3]=52;
		c[4]=53;
		c[5]=54;
		for(int i=0;i<6;i++) {
			if(B ==c[i]) {
				B = c[i]-48;
				break;
			}
		}
		return B;
	}
	//记录棋谱
	void  cm(int Row,int Col,String start){
		String Null = "__";
		if(!start.equals(Null)) {
			chessmanual[countc] =(countc+1)+":"+s.countg[s.g-1]+";("+start+","+change1(Col)+Row+")";
			countc++;
		}
	}
	//检查输入x坐标是否正确
	boolean checkx(String Str) {
		Boolean b=false;
		String []c = new String[5];
		c[0]="A";
		c[1]="B";
		c[2]="C";
		c[3]="D";
		c[4]="E";
		for(int i=0;i<5;i++) {
			b=c[i].equals(Str);
			if(b) {
				break;
			}
		}
		if(b) {
			return true;
		}
		else {
			return false;
		}
	}
	//检查输入y坐标是否正确
	boolean checky(int Str1) {
		Boolean b=false;
		int []c = new int[5];
		c[0]=1;
		c[1]=2;
		c[2]=3;
		c[3]=4;
		c[4]=5;
		for(int i=0;i<5;i++) {
			if(Str1==c[i])	 {
				b=true;
				break;
			}
		}
		if(b) {
			return true;
		}
		else {
			return false;
		}
	}
	//判断骰子输入是否正确
	boolean checkt(int Num) {
		Boolean b=false;
		int []c = new int[6];
		c[0]=1;
		c[1]=2;
		c[2]=3;
		c[3]=4;
		c[4]=5;
		c[5]=6;
		for(int i=0;i<6;i++) {
			if(Num==c[i])	 {
				b=true;
				break;
			}
		}
		if(b) {
			return true;
		}
		else {
			return false;
		}
	}
	//将数字变成字母
	String change1(int i) {
		String l = null;
		switch(i) {
			case 0:
				l = "A";
				break;
			case 1:
				l = "B";
				break;
			case 2:
				l = "C";
				break;
			case 3:
				l = "D";
				break;
			case 4:
				l = "E";
				break;
		}
		return l;
	}
	//将字母变成数字
	int change2(String l) {
		int i = 0;
		switch(l) {
			case "A":
				i = 0;
				break;
			case "B":
				i = 1;
				break;
			case "C":
				i = 2;
				break;
			case "D":
				i = 3;
				break;
			case "E":
				i = 4;
				break;
		}
		return i;
	}
}

三、棋子选择

package ewn;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.util.Scanner;

public class seat {
	static final Scanner sc=new Scanner(System.in,"UTF-8");
	public static int seatrow;
	public static int seatcol;
	//记录游戏数和骰子
	public static int countg[] = new int[50];
	public static int g=0;
	thisChessBoard tcb=new thisChessBoard();
	strategy stra=new strategy();
	//判断骰子输入是否正确
	boolean check(int Num) {
		Boolean b=false;
		int []c = new int[6];
		c[0]=1;
		c[1]=2;
		c[2]=3;
		c[3]=4;
		c[4]=5;
		c[5]=6;
		for(int i=0;i<6;i++) {
			if(Num==c[i])	 {
				b=true;
				break;
			}
		}
		if(b) {
			return true;
		}
		else {
			return false;
		}
	}

	//（电脑）红方获取棋子坐标
	void airedSeat() throws UnsupportedEncodingException {
		PrintStream ps=new PrintStream(System.out,true,"UTF-8");
		String dict = null ;//骰子数用来遍历棋盘上棋子的位置
		int num;
		System.out.print("\n");
		System.out.print("红方回合！    请输入 骰子数(1~6)： ");
		String x=sc.next();
		num = itn(x);
		while(!check(num)) {
			System.out.println("骰子输入错误！！！！！请重新输入(1~6):");
			x=sc.next();
			num = itn(x);
		}
		countg[g] = num;
		g++;
		System.out.print("\n");
		int flag2=0;//标记，用来查找棋盘上棋子标记，如果找到为1，否则为0,也是循环标记，如果找到flag2=1退出循环，flag2=0
		while(flag2==0)
		{
			switch(num)
			{
				case 1:
					dict="R1";
					//如果找打棋子
					for(int i=0;i<5;i++) {
						for(int j=0;j<5;j++)
						{
							if(tcb.table[i][j].compareTo(dict)==0)
							{
								seatrow=i;
								seatcol=j;
								flag2=1;
								break;
							}
						}
					}
					//如果没有找到
					if(flag2==0)
					{
						num++;
					}
					break;
				case 2:
					dict="R2";
					//如果找打棋子
					for(int i=0;i<5;i++) {
						for(int j=0;j<5;j++)
						{
							if(tcb.table[i][j].compareTo(dict)==0)
							{
								seatrow=i;
								seatcol=j;
								flag2=1;
								break;
							}
						}
					}
					//如果没有找到
					if(flag2==0)
					{
						num=this.airedselect(num);
					}
					break;
				case 3:
					dict="R3";
					//如果找打棋子
					for(int i=0;i<5;i++) {
						for(int j=0;j<5;j++)
						{
							if(tcb.table[i][j].compareTo(dict)==0)
							{
								seatrow=i;
								seatcol=j;
								flag2=1;
								break;
							}
						}
					}
					//如果没有找到
					if(flag2==0)
					{
						num=this.airedselect(num);
						break;
					}
					break;
				case 4:
					dict="R4";
					//如果找打棋子
					for(int i=0;i<5;i++) {
						for(int j=0;j<5;j++)
						{
							if(tcb.table[i][j].compareTo(dict)==0)
							{
								seatrow=i;
								seatcol=j;
								flag2=1;
								break;
							}
						}
					}
					//如果没有找到
					if(flag2==0)
					{
						num=this.airedselect(num);
						break;
					}
					break;
				case 5:
					dict="R5";
					//如果找打棋子
					for(int i=0;i<5;i++) {
						for(int j=0;j<5;j++)
						{
							if(tcb.table[i][j].compareTo(dict)==0)
							{
								seatrow=i;
								seatcol=j;
								flag2=1;
								break;
							}
						}
					}
					//如果没有找到
					if(flag2==0)
					{
						num=this.airedselect(num);
						break;
					}
					break;
				case 6:
					dict="R6";
					//如果找打棋子
					for(int i=0;i<5;i++) {
						for(int j=0;j<5;j++)
						{
							if(tcb.table[i][j].compareTo(dict)==0)
							{
								seatrow=i;
								seatcol=j;
								flag2=1;
								break;
							}
						}
					}
					//如果没有找到
					if(flag2==0)
					{
						num--;
					}
					break;
			}
		}
	}


	//（电脑）红方找相邻位置
	int airedselect(int num)
	{
		int choose=0;
		int flag=0;
		int num1=0;
		int num2=0;
		int num3=num;
		boolean tof = false;
		String dict;
		do {
			if(choose==0)//找大于当前数的
			{
				num1=num+1;
				switch(num1)
				{
					case 1:
						dict="R1";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num1;
								}
								else {
									tof = false;
								}
							}
						}
						if(!tof)
						{
							num++;
						}
						break;
					case 2:
						dict="R2";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num1;
								}
								else {
									tof = false;
								}
							}
						}
						if(!tof)
						{
							num++;
						}
						break;
					case 3:
						dict="R3";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num1;
								}
								else {
									tof = false;
								}
							}
						}
						if(!tof)
						{
							num++;
						}
						break;
					case 4:
						dict="R4";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num1;
								}
								else {
									tof = false;
								}
							}
						}
						if(!tof)
						{
							num++;
						}
						break;
					case 5:
						dict="R5";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num1;
								}
								else {
									tof = false;
								}
							}
						}
						if(!tof)
						{
							num++;
						}
						break;
					case 6:
						dict="R6";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									flag=1;
									return num1;
								}
								else {
									choose=1;
								}
							}
						}
						break;
					default:
						choose=1;
						break;
				}
			}
			else {//找当前数小于的
				num2=num3--;
				switch(num2)
				{
					case 1:
						dict="R1";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									flag=1;
									return num2;
								}
								else {
									choose=0;
								}
							}
						}
						break;
					case 2:
						dict="R2";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num2;
								}
								else {
									tof=false;
								}
							}
						}
						if(!tof)
						{
							num3--;
						}
						break;
					case 3:
						dict="R3";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num2;
								}
								else {
									tof=false;
								}
							}
						}
						if(!tof)
						{
							num3--;
						}
						break;
					case 4:
						dict="R4";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num2;
								}
								else {
									tof=false;
								}
							}
						}
						if(!tof)
						{
							num3--;
						}
						break;
					case 5:
						dict="R5";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num2;
								}
								else {
									tof=false;
								}
							}
						}
						if(!tof)
						{
							num3--;
						}
						break;

					default:
						choose=1;
						break;
				}
			}
		}while(flag==0);
		return 0;
	}

	//（电脑）蓝方获取棋子坐标
	void aiblueSeat() throws UnsupportedEncodingException {
		PrintStream ps=new PrintStream(System.out,true,"UTF-8");
		String dict = null ;//骰子数用来遍历棋盘上棋子的位置
		int num;
		System.out.print("\n");
		System.out.print("蓝方回合！    请输入 骰子数(1~6)： ");
		String x=sc.next();
		num = itn(x);
		while(!check(num)) {
			System.out.println("骰子输入错误！！！！！请重新输入(1~6):");
			x=sc.next();
			num = itn(x);
		}
		countg[g] = num;
		g++;
		System.out.print("\n");
		int flag2=0;//标记，用来查找棋盘上棋子标记，如果找到为1，否则为0,也是循环标记，如果找到flag2=1退出循环，flag2=0
		do{
			int count=0;
			switch(num)
			{
				case 1:
					dict="B1";
					//如果找打棋子
					for(int i=0;i<5;i++) {
						for(int j=0;j<5;j++)
						{
							if(tcb.table[i][j].compareTo(dict)==0)
							{
								seatrow=i;
								seatcol=j;
								flag2=1;
								break;
							}
						}
					}
					//如果没有找到
					if(flag2==0)
					{
						num++;
					}
					break;
				case 2:
					dict="B2";
					//如果找打棋子
					for(int i=0;i<5;i++) {
						for(int j=0;j<5;j++)
						{
							if(tcb.table[i][j].compareTo(dict)==0)
							{
								seatrow=i;
								seatcol=j;
								flag2=1;
								break;
							}
						}
					}
					//如果没有找到
					if(flag2==0)
					{
						num=this.aiblueselect(num);
					}
					break;
				case 3:
					dict="B3";
					//如果找打棋子
					for(int i=0;i<5;i++) {
						for(int j=0;j<5;j++)
						{
							if(tcb.table[i][j].compareTo(dict)==0)
							{
								seatrow=i;
								seatcol=j;
								flag2=1;
								break;
							}
						}
					}
					//如果没有找到
					if(flag2==0)
					{
						num=this.aiblueselect(num);
						break;
					}
					break;
				case 4:
					dict="B4";
					//如果找打棋子
					for(int i=0;i<5;i++) {
						for(int j=0;j<5;j++)
						{
							if(tcb.table[i][j].compareTo(dict)==0)
							{
								seatrow=i;
								seatcol=j;
								flag2=1;
								break;
							}
						}
					}
					//如果没有找到
					if(flag2==0)
					{
						num=this.aiblueselect(num);
						break;
					}
					break;
				case 5:
					dict="B5";
					//如果找打棋子
					for(int i=0;i<5;i++) {
						for(int j=0;j<5;j++)
						{
							if(tcb.table[i][j].compareTo(dict)==0)
							{
								seatrow=i;
								seatcol=j;
								flag2=1;
								break;
							}
						}
					}
					//如果没有找到
					if(flag2==0)
					{
						num=this.aiblueselect(num);
						break;
					}
					break;
				case 6:
					dict="B6";
					//如果找打棋子
					for(int i=0;i<5;i++) {
						for(int j=0;j<5;j++)
						{
							if(tcb.table[i][j].compareTo(dict)==0)
							{
								seatrow=i;
								seatcol=j;
								flag2=1;
								break;
							}
						}
					}
					//如果没有找到
					if(flag2==0)
					{
						num--;
					}
					break;
			}
		}while(flag2==0);
	}


	//（电脑）蓝方找相邻位置
	int aiblueselect(int num)
	{
		int choose=0;
		int flag=0;
		int num1=0;
		int num2=0;
		int num3=num;
		boolean tof = false;
		String dict;
		do {
			if(choose==0)//找大于当前数的
			{
				num1=num+1;
				switch(num1)
				{
					case 1:
						dict="B1";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num1;
								}
								else {
									tof = false;
								}
							}
						}
						if(!tof)
						{
							num++;
						}
						break;
					case 2:
						dict="B2";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num1;
								}
								else {
									tof = false;
								}
							}
						}
						if(!tof)
						{
							num++;
						}
						break;
					case 3:
						dict="B3";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num1;
								}
								else {
									tof = false;
								}
							}
						}
						if(!tof)
						{
							num++;
						}
						break;
					case 4:
						dict="B4";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num1;
								}
								else {
									tof = false;
								}
							}
						}
						if(!tof)
						{
							num++;
						}
						break;
					case 5:
						dict="B5";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num1;
								}
								else {
									tof = false;
								}
							}
						}
						if(!tof)
						{
							num++;
						}
						break;
					case 6:
						dict="B6";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									flag=1;
									return num1;
								}
								else {
									choose=1;
								}
							}
						}
						break;
					default:
						choose=1;
						break;
				}
			}
			else {//找当前数小于的
				num2=num3--;
				switch(num2)
				{
					case 1:
						dict="B1";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									flag=1;
									return num2;
								}
								else {
									choose=0;
								}
							}
						}
						break;
					case 2:
						dict="B2";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num2;
								}
								else {
									tof=false;
								}
							}
						}
						if(!tof)
						{
							num3--;
						}
						break;
					case 3:
						dict="B3";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num2;
								}
								else {
									tof=false;
								}
							}
						}
						if(!tof)
						{
							num3--;
						}
						break;
					case 4:
						dict="B4";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num2;
								}
								else {
									tof=false;
								}
							}
						}
						if(!tof)
						{
							num3--;
						}
						break;
					case 5:
						dict="B5";
						for(int i=0;i<5;i++) {
							for(int j=0;j<5;j++)
							{
								if(tcb.table[i][j].compareTo(dict)==0)
								{
									tof = true;
									flag=1;
									return num2;
								}
								else {
									tof=false;
								}
							}
						}
						if(!tof)
						{
							num3--;
						}
						break;
					default:
						choose=1;
						break;
				}
			}
		}while(flag==0);
		return 0;
	}
	//获得蓝方棋子坐标(玩家)
	int blueSeat(int num) throws UnsupportedEncodingException {
		PrintStream ps=new PrintStream(System.out,true,"UTF-8");
		String dict = null ;//骰子数用来遍历棋盘上棋子的位置
		switch(num) {
			case 1:
				dict="B1";
				break;
			case 2:
				dict="B2";
				break;
			case 3:
				dict="B3";
				break;
			case 4:
				dict="B4";
				break;
			case 5:
				dict="B5";
				break;
			case 6:
				dict="B6";
				break;
			default:
				break;
		}
		for(int i=0;i<5;i++) {
			for(int j=0;j<5;j++)
			{
				if(tcb.table[i][j].compareTo(dict)==0)
				{
					seatrow=i;
					seatcol=j;
					break;
				}
			}
		}
		return 0;
	}

	//获得红方棋子坐标(玩家)
	int redSeat(int num) throws UnsupportedEncodingException {
		PrintStream ps=new PrintStream(System.out,true,"UTF-8");
		String dict = null ;//骰子数用来遍历棋盘上棋子的位置
		switch(num) {
			case 1:
				dict="R1";
				break;
			case 2:
				dict="R2";
				break;
			case 3:
				dict="R3";
				break;
			case 4:
				dict="R4";
				break;
			case 5:
				dict="R5";
				break;
			case 6:
				dict="R6";
				break;
			default:
				break;
		}
		for(int i=0;i<5;i++) {
			for(int j=0;j<5;j++)
			{
				if(tcb.table[i][j].compareTo(dict)==0)
				{
					seatrow=i;
					seatcol=j;
					break;
				}
			}
		}
		return 0;
	}
	//	//将输入的字母转为数字防止崩盘
	int itn(String input) {
		int B = 0;
		for(byte b:input.getBytes()) {
			B = b;
		}
		int []c = new int[6];
		c[0]=49;
		c[1]=50;
		c[2]=51;
		c[3]=52;
		c[4]=53;
		c[5]=54;
		for(int i=0;i<6;i++) {
			if(B ==c[i]) {
				B = c[i]-48;
				break;
			}
		}
		return B;
	}
}

四、胜利判断

package ewn;
import java.io.UnsupportedEncodingException;

public class strategy {
	thisChessBoard tcb=new thisChessBoard();

	int win(int flag) throws UnsupportedEncodingException {
		//胜利条件1 占领对角
		String []r = new String[6];//判断红方
		r[0]="R1";
		r[1]="R2";
		r[2]="R3";
		r[3]="R4";
		r[4]="R5";
		r[5]="R6";
		String []b = new String[6];//判断蓝方
		b[0]="B1";
		b[1]="B2";
		b[2]="B3";
		b[3]="B4";
		b[4]="B5";
		b[5]="B6";
		for(int i=0;i<6;i++)//红方到达对角
		{
			Boolean b1=r[i].equals(tcb.table[4][4]);
			if(b1)
			{
				System.out.println("红方棋子占领蓝方区角点，红方胜利！\n");

				return flag=1;
			}
		}
		for(int i=0;i<6;i++)//蓝方到达对角
		{
			Boolean b2=b[i].equals(tcb.table[0][0]);
			if(b2)
			{
				System.out.println("蓝方棋子占领红方区角点，蓝方胜利！\n");

				return flag=1;
			}
		}
		//胜利条件2 消灭对方
		int countr=0;//红方棋子不存在
		int countb=0;//蓝方棋子不存在
		String p;
		//红方被吃完
		for(int i=0;i<5;i++)
		{
			for(int j=0;j<5;j++)
			{
				for(int m=0;m<6;m++) {

					Boolean b1=r[m].equals(tcb.table[i][j]);//匹配红方棋子

					if(b1)
					{
						countr=1;
						break;
					}
				}
			}
		}
		if(countr==0) {
			System.out.println("红方棋子被消灭，蓝方胜利！！\n");

			return flag=1;
		}
		for(int i=0;i<5;i++)
		{
			for(int j=0;j<5;j++)
			{
				for(int m =0;m<6;m++) {
					Boolean b2=b[m].equals(tcb.table[i][j]);//匹配红方棋子
					if(b2)
					{
						countb=1;
						break;
					}
				}
			}
		}
		if(countb==0) {
			System.out.println("蓝方棋子被消灭，红方胜利！！\n");

			return flag=1;
		}
		return 0;
	}
}

五、main函数

package ewn;

import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.util.Scanner;

class main {
	public static int mode;//下棋模式
	public static int mode1;//布局模式
	public static void main(String[] args)throws UnsupportedEncodingException {
		PrintStream ps=new PrintStream(System.out,true,"UTF-8");
		Scanner sc=new Scanner(System.in,"UTF-8");
		thisChessBoard tcb=new thisChessBoard();//棋盘实例化
		seat s=new seat(); //骰子位置实例化
		move m=new move(); //移动实例化
		strategy stra=new strategy();//胜利类实例化

		//下棋开始
		System.out.println("我方棋子为：");
		System.out.println("1 红方");
		System.out.println("2 蓝方");
		mode=sc.nextInt();
		if(mode ==1) {
			tcb.initTable();//棋盘初始化
			//红方布局
			System.out.println("\n我方为红方！请选择布局 ：1默认  2自定义");
			mode1=sc.nextInt();
			if(mode1==1)
			{
				tcb.autowritered();
				System.out.println("红方布局已经完成.");
			}
			else {
				tcb.dewritered();
				System.out.println("请输入红方棋子(对应1~6的顺序，空格隔开,示例R1 R2)");
				tcb.writered();
				System.out.println("红方布局已经完成.");
			}
			//蓝方布局
			System.out.println("请选择蓝方布局 ：1默认  2自定义");
			mode1=sc.nextInt();
			if(mode1==1)
			{
				tcb.autowriteblue();
				System.out.println("蓝方布局已经完成.");
			}
			else {
				tcb.dewriteblue();
				System.out.println("请输入蓝方棋子(对应1~6的顺序，空格隔开,示例B1 B2)");
				tcb.writeblue();
				System.out.println("蓝方布局已经完成.");
			}

			System.out.println("请选择先手(红方1，蓝方2): ");
			int choose=sc.nextInt();
			int flag=0;
			do {
				if(choose==1)
				{
					s.airedSeat();//红方获得骰子随机数
					m.airedMove();//红方走棋
					flag=stra.win(flag);//判断获胜
					choose=2;
				}
				else {
					m.blueMove();//蓝方走棋
					flag=stra.win(flag);//判断获胜
					choose=1;
				}
			}while(flag==0);
			System.out.print("\n对局结束,本局棋谱为:\n");
			System.out.print(" 记录骰子次数："+s.g+"       记录棋谱次数："+m.countc+"\n\n");
			for(int i = 0;i<m.countc;i++) {
				System.out.println(m.chessmanual[i]);
			}
			sc.nextLine();
		}
		else {
			tcb.initTable();//棋盘初始化
			//蓝方布局
			System.out.println("\n我方为蓝方！请选择布局 ：1默认  2自定义");
			mode1=sc.nextInt();
			if(mode1==1)
			{
				tcb.autowriteblue();
				System.out.println("蓝方布局已经完成.");
			}
			else {
				tcb.dewriteblue();
				System.out.println("请输入蓝方棋子(对应1~6的顺序，空格隔开,示例B1 B2)");
				tcb.writeblue();
				System.out.println("蓝方布局已经完成.");
			}
			//红方布局
			System.out.println("请选择红方布局 ：1默认  2自定义");
			mode1=sc.nextInt();
			if(mode1==1)
			{
				tcb.autowritered();
				System.out.println("红方布局已经完成.");
			}
			else {
				tcb.dewritered();
				System.out.println("请输入红方棋子(对应1~6的顺序，空格隔开,示例R1 R2)");
				tcb.writered();
				System.out.println("红方布局已经完成.");
			}
			System.out.println("请选择先手(红方1，蓝方2): ");
			int choose=sc.nextInt();
			int flag=0;
			do {
				if(choose==1)
				{
					m.redMove();//红方走棋
					flag=stra.win(flag);//判断获胜
					choose=2;
				}
				else {
					s.aiblueSeat();//蓝方获得骰子随机数
					m.aiblueMove();//蓝方走棋
					flag=stra.win(flag);//判断获胜
					choose=1;

				}
			}while(flag==0);
			System.out.print("\n对局结束,本局棋谱为:\n");
			System.out.print(" 记录骰子次数："+s.g+"       记录棋谱次数："+m.countc+"\n\n");
			for(int i = 0;i<m.countc;i++) {
				System.out.println(m.chessmanual[i]);
			}
			sc.nextLine();
		}
	}
}

六、 部分测试截图

  • 默认布局：
    在这里插入图片描述

  • 我方行棋：
    在这里插入图片描述

  • 对手行棋：
    在这里插入图片描述

  • 胜利判断，棋盘打印：
    在这里插入图片描述

七、说明

  • 只能用来水比赛，没有用那些厉害算法，写的也比较乱
  • 核心代码参考：关于计算机博弈大赛，爱恩斯坦棋Java面向过程实现
  • 只是重构了上面链接的代码，增加和修改了一些地方，使其符合参赛要求
  • 重新设计了棋盘，新增先手下棋、自定义棋盘、输入合法性检测、悔棋、棋盘打印
  • 在特定棋盘布局下会出现bug，一天的比赛中好像出现过1次
计算机博弈大赛源代码,2020计算机博弈大赛幻影围棋分组第一天 信息交互模块...
weixin_36092871的博客
07-14 1507
2020计算机博弈大赛幻影围棋分组第一天从学长那拿到了2018，2019年参加幻影围棋比赛的代码，咸鱼了几天之后，我组三人正式开始准备2020年的比赛，这篇博客主要记录我参与的部分。在看到源码的时候，不禁感叹，源码之混乱(毕竟祖传代码传了不止一代)，所以下决心对源码进行重构，并且加深对源码的理解。首先来看学长给的程序结构图，这张结构图清晰易懂，重构的大体框架还是按他这个来。首先从最简单也是最基础的...
爱因斯坦棋
qq_62049014的博客
06-09 585
0:last_x = xlast_y = yprev_x = xprev_y = yelse:return -1else:return 1return 0return 0.5。
计算机博弈大赛（斗地主）AI.py
02-09
1、使用简单的逻辑判断，进行斗地主的出牌策略编写 2、程序符合计算机博弈大赛的规则 3、使用的是python编写的程序 4、代码中有相关的注释供下载者进行阅读 5、程序实现很简单主要是思路
爱恩斯坦棋 α-β剪枝 纯C++ 计算机博弈
05-12
大二的时候用纯C++写的一个爱恩斯坦棋，主要使用EGE库与α-β剪枝完成。
计算机毕设设计项目源码 ssm大学生计算机博弈比赛报名系统
最新发布
2401_89210028的博客
03-20 402
在设计一个SSM（Spring + Spring MVC + MyBatis）框架的大学生计算机博弈比赛报名系统时，可以将系统的基本框架分为几个主要模块。
关于计算机博弈大赛，爱恩斯坦棋Java面向过程实现
KuQI滴滴滴的博客
11-21 4609
一、爱恩斯坦棋规则 棋盘为5×5的方格形棋盘，方格为棋位，左上角为红方出发区；右下角为蓝方出发区 (如图1)； 红蓝方各有6枚棋子，分别标有数字1~6。开局时双方棋子在出发区的棋位可以随意摆放； 双方轮流掷骰子，然后 移动与骰子显示数字相 对应的棋子。如果相对 应的棋子已从棋盘上移 出，便可走动大于或者 小于此数字，并与此数 字最接近的棋子；（如 图2，红棋掷4，4已被吃， 可移动1或5）； 红方棋子走动方向为向右、 向下、向右下，每次走动一 格；蓝方棋子走动方向为向 左、向上、向左上，每
计算机爱恩斯坦棋游戏,爱恩斯坦棋计算机博弈系统的研究与实现
weixin_39615956的博客
07-04 702
爱恩斯坦棋计算机博弈系统的研究与实现【摘要】：计算机博弈,也称机器博弈,是一个极具挑战与发展前景的计算机研究领域,其作为人工智能领域一个极其重要的课题,素有人工智能领域“果蝇”之称。而对于棋类游戏的研究又是计算机博弈研究过程中的一个标准且极为重要的问题。现有的很多重要理论和技术方法诸如各类搜索算法及智能方法,最初的提出都是为了解决存在于棋类博弈中的某些问题。对于计算机博弈的研究最早可以追溯到半个世...
计算机博弈大赛六子棋源代码
01-01
计算机博弈大赛六子棋
java开发爱恩斯坦棋,爱恩斯坦棋计算机博弈关键技术研究
weixin_39831705的博客
03-12 649
爱恩斯坦棋计算机博弈关键技术研究【摘要】：计算机博弈是人工智能领域的重要研究方向之一,被誉为人工智能学科的“果蝇”。爱恩斯坦棋属于完备信息博弈棋种,是一种棋局信息完全透明的博弈类型,即博弈双方在任何时候都能完全掌握当前的棋局信息。然而,它不同于其它的完备信息博弈棋种,在双方行棋过程中需通过投掷骰子来确定可走的棋子,具有随机性,这使博弈系统对棋盘局势的分析和决策带来一定的挑战。自2012年爱恩斯坦棋...
python爱因斯坦棋
09-06
- *1* *2* [计算机博弈大赛 -- 爱因斯坦棋 (java源码)](https://blog.youkuaiyun.com/m0_60292931/article/details/125028836)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...
C++下爱因斯坦棋策略的实现
04-18
对于爱因斯坦棋游戏的评估策略及走子的实现，内附有pdf版的评估策略思路，可供学习使用
六子棋 计算机博弈大赛
08-18
今天计算机博弈大赛开始了，艰苦奋斗好多天，几乎全是通宵。现在却是放弃
军棋博弈比赛源程序
07-15
军棋博弈比赛源程序 比较试用于刚开始接触博弈的人
爱恩斯坦棋.exe
10-06
计算机博弈中的爱恩斯坦棋的python实现，使用tkinter与graphics开发出的界面。
计算机博弈的代码java,Java 速成
weixin_35705874的博客
07-26 443
Java 速成关于 JavaJava 是一种广泛使用的计算机编程语言，拥有 跨平台、面向对象、泛型编程 的特性，广泛应用于企业级 Web 应用开发和移动应用开发。环境安装¶Windows¶可以在 Oracle 官网 下载 Oracle JDK(需要登录 Oracle 账号)。推荐下载 EXE 安装包来自动配置环境变量。如果需要使用 OpenJDK，可以使用 AdoptOpenJDK 提供的预编...
爱因斯坦棋代码
m0_56896669的博客
03-31 1198
软件是根据开源软件修改而成，添加了一些额外的功能，修改了原来的图标，字体和布局，可以用来作为毕设或者课设，或者作为计算机博弈大赛程序。资源在链接可以到我主页上传资源中去查找。
html+css+JavaScript实现爱恩斯坦棋游戏
qq_52537838的博客
01-02 4016
title: “html+css+JavaScript实现爱恩斯坦棋游戏” author: Sun-Wind date: December 30, 2021 背景：本贴将基于前端的语言实现爱恩斯坦棋游戏的实现。 小声BB：查了一下，这应该是全网第一个基于前端语言实现爱恩斯坦棋的贴，应该是开端了。 #效果图 考虑到大家可能还不了解爱恩斯坦棋（其实点进来或多或少应该已经有了解过了吧） 理论上还是应该要介绍一下才对 规则如下： 棋盘为5×5的方格形棋盘，方格为棋位，左上角为红方出发区；右下角为蓝方出发.
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值