aithread.java

J2ME的游戏原代码!希望能帮助有需要帮助的师兄弟们！..

/*机器人思考算法来自网络  仅做稍许修改*/
package fivegame;

import java.util.Random;
import java.util.Vector;


public class AIThread extends Thread {

	MainGamePlayWithAI boardCanvas;
	static Random rand = new Random();
	static byte computerSide = 1;
	static byte userSide = 2;
	static final int dValuesWhen2SidesSelf[] = { 0, 1, 8, 16, 1024, 32767,
			-32767 };
	static final int dValuesWhen1SideSelf[] = { 0, 0, 4, 8, 16, 32767, -32767 };
	static final int dValuesWhen0SideSelf[] = { 0, 0, 0, 0, 0, 32767, -32767 };
	static final int dValuesSelf[][] = { dValuesWhen0SideSelf,
			dValuesWhen1SideSelf, dValuesWhen2SidesSelf };
	static final int dValuesWhen2SidesEnemy[] = { 0, 0, -4, -8, -512, -32767,
			32767 };
	static final int dValuesWhen1SideEnemy[] = { 0, 0, -2, -4, -6, -32767,
			32767 };
	static final int dValuesWhen0SideEnemy[] = { 0, 0, 0, 0, 0, -32767, 32767 };
	static final int dValuesEnemy[][] = { dValuesWhen0SideEnemy,
			dValuesWhen1SideEnemy, dValuesWhen2SidesEnemy };
	static Pattern patterns[] = { new Pattern("WOM.", 1),
			new Pattern("WMO.", 1), new Pattern("WOMM.", 2),
			new Pattern("WMOM.", 2), new Pattern("WMMO.", 2),
			new Pattern("WOMMM.", 8), new Pattern("WMOMM.", 8),
			new Pattern("WMMOM.", 8), new Pattern("WMMMO.", 8),
			new Pattern("WOMMMM.", 16384), new Pattern("WMOMMM.", 16384),
			new Pattern("WMMOMM.", 16384), new Pattern("WMMMOM.", 16384),
			new Pattern("WMMMMO.", 16384), new Pattern("XOM.", 1),
			new Pattern("XMO.", 1), new Pattern("XOMM.", 2),
			new Pattern("XMOM.", 2), new Pattern("XMMO.", 2),
			new Pattern("XOMMM.", 8), new Pattern("XMOMM.", 8),
			new Pattern("XMMOM.", 8), new Pattern("XMMMO.", 8),
			new Pattern("OMMMM", 16384), new Pattern("MOMMM", 16384),
			new Pattern("MMOMM", 16384), new Pattern("MMMOM", 16384),
			new Pattern("MMMMO", 16384), new Pattern(".OM.", 1),
			new Pattern(".MO.", 1), new Pattern(".OMM.", 2),
			new Pattern(".MOM.", 2), new Pattern(".MMO.", 2),
			new Pattern(".OMMM.", 8), new Pattern(".MOMM.", 8),
			new Pattern(".MMOM.", 8), new Pattern(".MMMO.", 8),
			new Pattern("OMMMMM", -16384), new Pattern("MOMMMM", -16384),
			new Pattern("MMOMMM", -16384), new Pattern("MMMOMM", -16384),
			new Pattern("MMMMOM", -16384), new Pattern("MMMMMO", -16384),
			new Pattern(".OMMMM.", 16384), new Pattern(".MOMMM.", 16384),
			new Pattern(".MMOMM.", 16384), new Pattern(".MMMOM.", 16384),
			new Pattern(".MMMMO.", 16384), new Pattern("MWO.", 1),
			new Pattern("MWWO.", 1), new Pattern("MWWWO.", 2),
			new Pattern("MWOW.", 1), new Pattern("MWWOW.", 2),
			new Pattern("MWOWW.", 2), new Pattern("WOWWW", 256),
			new Pattern("WWOWW", 256), new Pattern("WWWOW", 256),
			new Pattern("WWWWO", 256), new Pattern("WWOWWW.", 256),
			new Pattern("WWWOWW.", 256), new Pattern("WWWWOW.", 256),
			new Pattern(".WWO.", 4), new Pattern(".WOW.", 4),
			new Pattern(".WWOW.", 32), new Pattern(".WWWO.", 32) };
	static final int dxs[] = { 1, 1, 0, -1, -1, -1, 0, 1 };
	static final int dys[] = { 0, 1, 1, 1, 0, -1, -1, -1 };

	public AIThread(MainGamePlayWithAI boardcanvas) {
		boardCanvas = boardcanvas;
	}

	static boolean nearToExistedStones(int i, int j, byte abyte0[][]) {
		for (int k = Math.max(0, i - 1); k <= Math.min(14, i + 1); k++) {
			for (int l = Math.max(0, j - 1); l <= Math.min(14, j + 1); l++)
				if (abyte0[k][l] != 0)
					return true;

		}

		return false;
	}

	public void run() {
		if (boardCanvas.side != computerSide)
			return;
		byte abyte0[][] = new byte[15][];
		byte abyte1[][] = new byte[15][];
		byte abyte2[][] = new byte[15][];
		for (int i1 = 0; i1 < 15; i1++) {
			abyte0[i1] = new byte[15];
			abyte1[i1] = new byte[15];
			abyte2[i1] = new byte[15];
		}

		for (int i = 0; i < 15; i++) {
			for (int k = 0; k < 15; k++) {
				abyte0[i][k] = MainGamePlayWithAI.Board[i][k];
				abyte1[i][k] = 0;
				abyte2[i][k] = 0;
			}

		}

		Vector vector = new Vector();
		for (int j = 0; j < 15; j++) {
			for (int l = 0; l < 15; l++)
				if (nearToExistedStones(j, l, MainGamePlayWithAI.Board)
						&& MainGamePlayWithAI.Board[j][l] == 0) {
					OneStep onestep = new OneStep();
					onestep.x = j;
					onestep.y = l;
					abyte0[j][l] = computerSide;
					onestep.value = -dynamicEval(abyte0, userSide, j, l, 0);
					abyte0[j][l] = 0;
					vector.addElement(onestep);
				}

		}

		sortFirstGroup(vector);
		int j1 = ((OneStep) vector.elementAt(0)).value;
		int k1 = 0;
		k1 = 0;
		do {
			if (k1 >= vector.size())
				break;
			OneStep onestep1 = (OneStep) vector.elementAt(k1);
			if (j1 != onestep1.value)
				break;
			k1++;
		} while (true);
		OneStep onestep2 = (OneStep) vector.elementAt(Math.abs(rand.nextInt())
				% k1);
		MainGamePlayWithAI.Board[onestep2.x][onestep2.y] = computerSide;
		MainGamePlayWithAI.cursorX = onestep2.x;
		MainGamePlayWithAI.cursorY = onestep2.y;
		boardCanvas.StepRecord[MainGamePlayWithAI.StepIndex][1] = onestep2.x
				* 15 + onestep2.y;
		boardCanvas.repaint();
		boardCanvas.checkWin(MainGamePlayWithAI.Board, onestep2.x, onestep2.y);
		boardCanvas.side = userSide;
	}

	int dynamicEval(byte abyte0[][], int i, int j, int k, int l) {
		byte abyte1[][] = abyte0;
		if (l == 0)
			return staticEval(abyte0, (byte) i, j, k);
		Vector vector = new Vector();
		for (int i1 = 0; i1 < 15; i1++) {
			for (int k1 = 0; k1 < 15; k1++)
				if (nearToExistedStones(i1, k1, abyte0) && abyte0[i1][k1] == 0) {
					OneStep onestep = new OneStep();
					onestep.x = i1;
					onestep.y = k1;
					abyte1[i1][k1] = (byte) i;
					onestep.value = -staticEval(abyte1, (byte) (3 - i), i1, k1);
					abyte1[i1][k1] = 0;
					vector.addElement(onestep);
				}

		}

		int j1 = vector.size();
		j1 = Math.min(j1, 2);
		sort(vector, j1);
		int i2 = -65535;
		for (int l1 = 0; l1 < j1; l1++) {
			OneStep onestep1 = (OneStep) vector.elementAt(l1);
			int j2 = onestep1.x;
			int k2 = onestep1.y;
			abyte1[j2][k2] = (byte) i;
			int l2 = -dynamicEval(abyte0, 3 - i, j2, k2, l - 1);
			abyte1[j2][k2] = 0;
			onestep1.value = l2;
			if (i2 < l2)
				i2 = l2;
		}

		return i2;
	}

	int staticEval(byte abyte0[][], byte byte0, int i, int j) {
		return staticEval1(abyte0, byte0, i, j);
	}

	int staticEval0(byte abyte0[][], byte byte0) {
		int i = 0;
		for (int j = 0; j < 15; j++) {
			int l1 = 1;
			int j3 = 0;
			for (int l4 = 0; l4 < 15; l4++) {
				byte byte1 = abyte0[j][l4];
				if (byte1 != 0 && byte1 == j3)
					l1++;
				else if (byte1 != j3 && j3 != 0) {
					if (l1 > 6)
						l1 = 6;
					int j7 = 0;
					if (l4 - (l1 + 1) >= 0 && abyte0[j][l4 - (l1 + 1)] == 0)
						j7++;
					if (abyte0[j][l4] == 0)
						j7++;
					if (j3 == byte0)
						i += dValuesSelf[j7][l1];
					else
						i += dValuesEnemy[j7][l1];
					l1 = 1;
				}
				j3 = byte1;
			}

		}

		for (int k = 0; k < 15; k++) {
			int i2 = 1;
			int k3 = 0;
			for (int i5 = 0; i5 < 15; i5++) {
				byte byte2 = abyte0[i5][k];
				if (byte2 != 0 && byte2 == k3)
					i2++;
				else if (byte2 != k3 && k3 != 0) {
					if (i2 > 6)
						i2 = 6;
					int k7 = 0;
					if (i5 - (i2 + 1) >= 0 && abyte0[i5 - (i2 + 1)][k] == 0)
						k7++;
					if (abyte0[i5][k] == 0)
						k7++;
					if (k3 == byte0)
						i += dValuesSelf[k7][i2];
					else
						i += dValuesEnemy[k7][i2];
					i2 = 1;
				}
				k3 = byte2;
			}

		}

		for (int l = 0; l < 15; l++) {
			int j2 = 1;
			int l3 = 0;
			int j5 = 0;
			for (int j6 = l; j5 < 15 && j6 < 15; j6++) {
				byte byte3 = abyte0[j6][j5];
				if (byte3 != 0 && byte3 == l3)
					j2++;
				else if (byte3 != l3 && l3 != 0) {
					if (j2 > 6)
						j2 = 6;
					int l7 = 0;
					if (j5 - (j2 + 1) >= 0 && j6 - (j2 + 1) >= 0
							&& abyte0[j6 - (j2 + 1)][j5 - (j2 + 1)] == 0)
						l7++;
					if (abyte0[j6][j5] == 0)
						l7++;
					if (l3 == byte0)
						i += dValuesSelf[l7][j2];
					else
						i += dValuesEnemy[l7][j2];
					j2 = 1;
				}
				l3 = byte3;
				j5++;
			}

		}

		for (int i1 = 0; i1 < 15; i1++) {
			int k2 = 1;
			int i4 = 0;
			int k5 = i1;
			for (int k6 = 0; k5 < 15 && k6 < 15; k6++) {
				byte byte4 = abyte0[k6][k5];
				if (byte4 != 0 && byte4 == i4)
					k2++;
				else if (byte4 != i4 && i4 != 0) {
					if (k2 > 6)
						k2 = 6;
					int i8 = 0;
					if (k5 - (k2 + 1) >= 0 && k6 - (k2 + 1) >= 0
							&& abyte0[k6 - (k2 + 1)][k5 - (k2 + 1)] == 0)
						i8++;
					if (abyte0[k6][k5] == 0)
						i8++;
					if (i4 == byte0)
						i += dValuesSelf[i8][k2];
					else
						i += dValuesEnemy[i8][k2];
					k2 = 1;
				}
				i4 = byte4;
				k5++;
			}

		}

		for (int j1 = 0; j1 < 15; j1++) {
			int l2 = 1;
			int j4 = 0;
			int l5 = 14;
			for (int l6 = j1; l5 >= 0 && l6 < 15; l6++) {
				byte byte5 = abyte0[l6][l5];
				if (byte5 != 0 && byte5 == j4)
					l2++;
				else if (byte5 != j4 && j4 != 0) {
					if (l2 > 6)
						l2 = 6;
					int j8 = 0;
					if (l5 + (l2 + 1) >= 0 && l6 - (l2 + 1) >= 0
							&& abyte0[l6 - (l2 + 1)][l5 + (l2 + 1)] == 0)
						j8++;
					if (abyte0[l6][l5] == 0)
						j8++;
					if (j4 == byte0)
						i += dValuesSelf[j8][l2];
					else
						i += dValuesEnemy[j8][l2];
					l2 = 1;
				}
				j4 = byte5;
				l5--;
			}

		}

		for (int k1 = 14; k1 >= 0; k1--) {
			int i3 = 1;
			int k4 = 0;
			int i6 = 0;
			for (int i7 = k1; i7 >= 0 && i6 < 15; i6++) {
				byte byte6 = abyte0[i6][i7];
				if (byte6 != 0 && byte6 == k4)
					i3++;
				else if (byte6 != k4 && k4 != 0) {
					if (i3 > 6)
						i3 = 6;
					int k8 = 0;
					if (i7 + (i3 + 1) >= 0 && i6 - (i3 + 1) >= 0
							&& abyte0[i6 - (i3 + 1)][i7 + (i3 + 1)] == 0)
						k8++;
					if (abyte0[i6][i7] == 0)
						k8++;
					if (k4 == byte0)
						i += dValuesSelf[k8][i3];
					else
						i += dValuesEnemy[k8][i3];
					i3 = 1;
				}
				k4 = byte6;
				i7--;
			}

		}

		return i;
	}

	int staticEval1(byte abyte0[][], byte byte0, int i, int j) {
		byte0 = (byte) (3 - byte0);
		int k = 0;
		for (int l = 0; l < dxs.length; l++) {
			int i1 = dxs[l];
			int j1 = dys[l];
			StringBuffer stringbuffer = new StringBuffer();
			int k1 = i - i1 * 6;
			int l1 = j - j1 * 6;
			for (int j2 = 0; j2 < 12; j2++) {
				char c = 'X';
				if (k1 >= 0 && k1 < 15 && l1 >= 0 && l1 < 15)
					if (abyte0[k1][l1] == 0)
						c = '.';
					else if (abyte0[k1][l1] == byte0)
						c = 'M';
					else if (abyte0[k1][l1] == 3 - byte0)
						c = 'W';
				if (k1 == i && l1 == j)
					c = 'O';
				stringbuffer.append(c);
				k1 += i1;
				l1 += j1;
			}

			String s = stringbuffer.toString();
			for (int i2 = 0; i2 < patterns.length; i2++)
				if (s.indexOf(patterns[i2].pattern) >= 0)
					k += patterns[i2].value;

		}

		return -k;
	}

	void sort(Vector vector, int i) {
		for (int j = 0; j < Math.min(i, vector.size() - 1); j++) {
			int k = ((OneStep) vector.elementAt(j)).value;
			int l = j;
			for (int i1 = j + 1; i1 < vector.size(); i1++) {
				int j1 = ((OneStep) vector.elementAt(i1)).value;
				if (j1 > k) {
					l = i1;
					k = j1;
				}
			}

			Object obj = vector.elementAt(j);
			vector.setElementAt(vector.elementAt(l), j);
			vector.setElementAt(obj, l);
		}

	}

	void sortFirstGroup(Vector vector) {
		for (int i = 0; i < vector.size() - 1; i++) {
			int j = ((OneStep) vector.elementAt(i)).value;
			int k = i;
			for (int l = i + 1; l < vector.size(); l++) {
				int i1 = ((OneStep) vector.elementAt(l)).value;
				if (i1 > j) {
					k = l;
					j = i1;
				}
			}

			Object obj = vector.elementAt(i);
			vector.setElementAt(vector.elementAt(k), i);
			vector.setElementAt(obj, k);
			if (i > 0
					&& ((OneStep) vector.elementAt(i)).value != ((OneStep) vector
							.elementAt(i - 1)).value)
				return;
		}

	}

}