/// <summary>
/// 初始化所有委托
/// </summary>
public void InitHandle()
{
//如果两项委托为空
if (GeneticAlgorithm.fitnessCalculator == null || Genome.genomeCreater == null)
{
//适应度度量函数
GeneticAlgorithm.fitnessCalculator = delegate(Genome gene)
{
//打开人工智能探路标记
Conf.AIRouterState = true;
//当前串中最大的威力
double maxPower = double.MinValue;
//当前串中最小的威力
double minPower = double.MaxValue;
//当前串中最大的威力棋子的位置
int maxPowerIndex = 0;
//当前串中最小的威力棋子的位置
int minPowerIndex = 0;
//设定当前添加的棋子类型
ChessType currentType = AIType;
for (int i = 0; i < gene.Genes.Length; i++)
{
//模拟更新棋盘中的棋子类型
Chess.UpdateChessTypeForAI(gene.Genes[i], currentType);
//计算单子威力*位权
double tempPower = SinglePower(gene.Genes[i], currentType) * 1 * Math.Pow(0.96, i);
if (tempPower > maxPower)
{
maxPowerIndex = i;
maxPower = tempPower;
}
if (tempPower < minPower)
{
minPowerIndex = i;
minPower = tempPower;
}
//当前的最大威力值>权值*100 退出循环
if (maxPower > (100 * Math.Pow(0.96, i)))
{
break;
}
//转换下棋方,currentTpye变换
if (currentType == ChessType.BLACK)
{
currentType = ChessType.WHITE;
}
else
{
currentType = ChessType.BLACK;
}
}
//赋值适应度
if (Math.Abs(minPower) > Math.Abs(maxPower))
{
gene.BestGenIndex = minPowerIndex;
gene.Fitness = minPower;
}
else
{
gene.Fitness = maxPower;
gene.BestGenIndex = maxPowerIndex;
}
//恢复对棋盘的改变
for (int i = 0; i < gene.Genes.Length; i++)
{
Chess.UpdateChessTypeForAI(gene.Genes[i], ChessType.NULL);
}
//关闭人工智能探路标记
Conf.AIRouterState = false;
};
//创建随机基因组的函数
Genome.genomeCreater = createGensHandle;
}
}
private bool IsWinLeftOblique(ChessType chessType)
{
return(GetConnectCount(chessType, 1, 1) + GetConnectCount(chessType, -1, -1) - 1 == GameDef.win_count);
}
private static int CtDrctnlFlips(ChessType[] board, int boardIndex, int inc, ChessType color, ChessType oppcolor)
{
int count;
int pt = boardIndex + inc;
if (board[pt] == oppcolor)
{
count = 1;
pt += inc;
if (board[pt] == oppcolor) /*2*/
{
count = 2;
pt += inc;
if (board[pt] == oppcolor) /*3*/
{
count = 3;
pt += inc;
if (board[pt] == oppcolor)/*4*/
{
count = 4;
pt += inc;
if (board[pt] == oppcolor) /*5*/
{
count = 5;
pt += inc;
if (board[pt] == oppcolor)/*6*/
{
count = 6;
pt += inc;
}
}
}
}
}
if (board[pt] == color)
{
return(count);
}
}
return(0);
}
public static ChessCharacterAttribute GetChessProperties(ChessType chessType)
{
return((ChessCharacterAttribute)typeof(ChessType)
.GetField(chessType.ToString(), BindingFlags.Public | BindingFlags.Static)
.GetCustomAttributes(false)[0]);
}
private bool IsWinHorizontal(ChessType chessType)
{
return(GetConnectCount(chessType, 1, 0) + GetConnectCount(chessType, -1, 0) - 1 == GameDef.win_count);
}
// Use this for initialization
void Start()
{
chessPath = new Stack <GameObject>();
grid = new int[15, 15];
turn = ChessType.black;
}
private int FastestFirstSolve(ChessType[] board, int alpha, int beta, ChessType color, int depth, int empties, int discdiff, int prevmove)
{
lock (this)
{
int i, j;
int score = -Constants.HighestScore - 1;
ChessType oppcolor = 2 - color;
int sqnum;
int eval;
int flipped;
int moves, mobility;
int best_value, best_index;
Empties em, old_em;
Empties[] move_ptr = new Empties[Constants.MaxEmpties];
int holepar;
int[] goodness = new int[Constants.MaxEmpties];
bool fFoundPv = false;
//
// nodes++;
if (depth == 0)
{
nodes++;
//return evalation.StaEval2(board, color, oppcolor, empties,EmHead);
return(QuiescenceSolve(board, alpha, beta, color, 2, empties, discdiff, prevmove));
}
moves = 0;
for (old_em = EmHead, em = old_em.Succ; em != null; old_em = em, em = em.Succ)
{
sqnum = em.Square;
flipped = RuleUtils.DoFlips(board, sqnum, color, oppcolor);
if (flipped > 0)
{
//
board[sqnum] = color;
old_em.Succ = em.Succ;
//
mobility = count_mobility(board, oppcolor);
//
RuleUtils.UndoFlips(board, flipped, oppcolor);
old_em.Succ = em;
board[sqnum] = ChessType.EMPTY;
move_ptr[moves] = em;
goodness[moves] = -mobility;
moves++;
}
}
if (moves != 0)
{
for (i = 0; i < moves; i++)
{
//
best_value = goodness[i];
best_index = i;
for (j = i + 1; j < moves; j++)
{
if (goodness[j] > best_value)
{
best_value = goodness[j];
best_index = j;
}
}
em = move_ptr[best_index];
move_ptr[best_index] = move_ptr[i];
goodness[best_index] = goodness[i];
//
sqnum = em.Square;
holepar = em.HoleId;
j = RuleUtils.DoFlips(board, sqnum, color, oppcolor);
board[sqnum] = color;
em.Pred.Succ = em.Succ;
if (em.Succ != null)
{
em.Succ.Pred = em.Pred;
}
nodes++;
//
if (fFoundPv)
{
//
eval = -FastestFirstSolve(board, -alpha - 1, -alpha, oppcolor, depth - 1, empties - 1, -discdiff - 2 * j - 1, sqnum);
if ((eval > alpha) && (eval < beta))
{
eval = -FastestFirstSolve(board, -beta, -eval, oppcolor, depth - 1, empties - 1, -discdiff - 2 * j - 1, sqnum);
//eval = -FastestFirstMidSolve(board, -beta, -alpha, oppcolor, depth - 1, empties - 1, -discdiff - 2 * j - 1, sqnum);
}
}
else
{
eval = -FastestFirstSolve(board, -beta, -alpha, oppcolor, depth - 1, empties - 1, -discdiff - 2 * j - 1, sqnum);
}
//
RuleUtils.UndoFlips(board, j, oppcolor);
board[sqnum] = ChessType.EMPTY;
em.Pred.Succ = em;
if (em.Succ != null)
{
em.Succ.Pred = em;
}
if (eval > score)
{
score = eval;
if (eval > alpha)
{
if (eval >= beta)
{
//
return(score);
}
alpha = eval;
fFoundPv = true;
}
}
}
}
else
{
if (prevmove == 0) //
{
if (discdiff > 0) //
{
return(Constants.HighestScore);
}
if (discdiff < 0)//
{
return(-Constants.HighestScore);
}
return(0);//
}
else /* I pass: */
{
score = -FastestFirstSolve(board, -beta, -alpha, oppcolor, depth, empties, -discdiff, 0);
}
}
return(score);
}
}
public static ChessType GetOppositeChessType(ChessType chessType)
{
ChessType retChess = chessType == ChessType.Black ? ChessType.White : ChessType.Black;
return(retChess);
}
// 检查斜边情况
int CheckBiasLink(int px, int py, ChessType type)
{
int ret = 0;
int linkCount = 1;
// 左下
for (int x = px - 1, y = py - 1; x >= 0 && y >= 0; x--, y--)
{
if (Get(x, y) == type)
{
linkCount++;
if (linkCount >= WinChessCount)
{
return(linkCount);
}
}
else
{
break;
}
}
// 右上
for (int x = px + 1, y = py + 1; x < Board.CrossCount && y < Board.CrossCount; x++, y++)
{
if (Get(x, y) == type)
{
linkCount++;
if (linkCount >= WinChessCount)
{
return(linkCount);
}
}
else
{
break;
}
}
ret = linkCount;
linkCount = 1;
// 左上
for (int x = px - 1, y = py + 1; x >= 0 && y < Board.CrossCount; x--, y++)
{
if (Get(x, y) == type)
{
linkCount++;
if (linkCount >= WinChessCount)
{
return(linkCount);
}
}
else
{
break;
}
}
// 右下
for (int x = px + 1, y = py - 1; x < Board.CrossCount && y >= 0; x++, y--)
{
if (Get(x, y) == type)
{
linkCount++;
if (linkCount >= WinChessCount)
{
return(linkCount);
}
}
else
{
break;
}
}
return(Mathf.Max(ret, linkCount));
}
public int FastestFirstEndSolve(ChessType[] board, int alpha, int beta, ChessType color, int empties, int discdiff, int prevmove)
{
int i, j;
int score = -highestScore;
ChessType oppcolor = 2 - color;
int sqnum = -1;
int ev;
int flipped;
int moves, mobility;
int best_value, best_index;
Empties em, old_em;
Empties[] move_ptr = new Empties[64];
int holepar;
int[] goodness = new int[64];
moves = 0;
nodes++;
for (old_em = EmHead, em = old_em.Succ; em != null; old_em = em, em = em.Succ)
{
sqnum = em.Square;
flipped = RuleUtils.DoFlips(board, sqnum, color, oppcolor);
if (flipped > 0)
{
board[sqnum] = color;
old_em.Succ = em.Succ;
mobility = count_mobility(board, oppcolor);
RuleUtils.UndoFlips(board, flipped, oppcolor);
old_em.Succ = em;
board[sqnum] = ChessType.EMPTY;
move_ptr[moves] = em;
goodness[moves] = -mobility;
moves++;
}
}
if (moves != 0)
{
for (i = 0; i < moves; i++)
{
best_value = goodness[i];
best_index = i;
for (j = i + 1; j < moves; j++)
{
if (goodness[j] > best_value)
{
best_value = goodness[j];
best_index = j;
}
}
em = move_ptr[best_index];
move_ptr[best_index] = move_ptr[i];
goodness[best_index] = goodness[i];
sqnum = em.Square;
holepar = em.HoleId;
j = RuleUtils.DoFlips(board, sqnum, color, oppcolor);
board[sqnum] = color;
RegionParity ^= (uint)holepar;
em.Pred.Succ = em.Succ;
if (em.Succ != null)
{
em.Succ.Pred = em.Pred;
}
if (empties <= Constants.Fastest_First + 1)
{
ev = -ParEndSolve(board, -beta, -alpha, oppcolor, empties - 1,
-discdiff - 2 * j - 1, sqnum);
}
else
{
ev = -FastestFirstEndSolve(board, -beta, -alpha, oppcolor,
empties - 1, -discdiff - 2 * j - 1, sqnum);
}
RuleUtils.UndoFlips(board, j, oppcolor);
RegionParity ^= (uint)holepar;
board[sqnum] = ChessType.EMPTY;
em.Pred.Succ = em;
if (em.Succ != null)
{
em.Succ.Pred = em;
}
if (ev > score)
{
score = ev;
if (empties == searchDepth)
{
bestMove = sqnum;
}
if (ev > alpha)
{
if (ev >= beta)
{
return(score);
}
alpha = ev;
}
}
}
}
else
{
if (prevmove == 0)
{
if (discdiff > 0)
{
return(discdiff + empties);
}
if (discdiff < 0)
{
return(discdiff - empties);
}
return(0);
}
else /* I pass: */
{
score = -FastestFirstEndSolve(board, -beta, -alpha, oppcolor, empties, -discdiff, 0);
}
if (empties == searchDepth)
{
bestMove = MVPASS;
}
}
return(score);
}
public int NoParEndSolve(ChessType[] board, int alpha, int beta, ChessType color, int empties, int discdiff, int prevmove)
{
int score = -highestScore;
ChessType oppcolor = 2 - color;
int sqnum = -1, j, j1;
int eval;
Empties em, old_em;
nodes++;
for (old_em = EmHead, em = old_em.Succ; em != null; old_em = em, em = em.Succ)
{
sqnum = em.Square;
j = RuleUtils.DoFlips(board, sqnum, color, oppcolor);
if (j > 0)
{
board[sqnum] = color;
old_em.Succ = em.Succ;
if (empties == 2)
{
j1 = RuleUtils.CountFlips(board, EmHead.Succ.Square, oppcolor, color);
if (j1 > 0)//
{
eval = discdiff + 2 * (j - j1);
}
else //pass
{
j1 = RuleUtils.CountFlips(board, EmHead.Succ.Square, color, oppcolor);
eval = discdiff + 2 * j;
if (j1 > 0)//
{
eval += 2 * (j1 + 1);
}
else
{//both pass
if (eval >= 0)
{
eval += 2;
}
}
}
}
else
{
eval = -NoParEndSolve(board, -beta, -alpha,
oppcolor, empties - 1, -discdiff - 2 * j - 1, sqnum);
}
RuleUtils.UndoFlips(board, j, oppcolor);
board[sqnum] = ChessType.EMPTY;
old_em.Succ = em;
//purning
if (eval > score)
{
score = eval;
if (empties == searchDepth)
{
bestMove = sqnum;
}
if (eval > alpha)
{
if (eval >= beta)
{ // purning
return(score);
}
alpha = eval;
}
}
}
}
if (score == -highestScore)
{
if (empties == searchDepth)
{
bestMove = MVPASS;
}
if (prevmove == 0)
{
if (discdiff > 0)
{
return(discdiff + empties);
}
if (discdiff < 0)
{
return(discdiff - empties);
}
return(0);
}
else
{
return(-NoParEndSolve(board, -beta, -alpha, oppcolor, empties, -discdiff, 0));
}
}
return(score);
}
public int ParEndSolve(ChessType[] board, int alpha, int beta, ChessType color, int empties, int discdiff, int prevmove)
{
int score = -highestScore;
ChessType oppcolor = 2 - color;
int sqnum = -1;
int j;
int eval;
Empties em, old_em;
int holepar;
//
nodes++;
for (old_em = EmHead, em = old_em.Succ; em != null; old_em = em, em = em.Succ)
{
holepar = em.HoleId;
holepar = em.Square;
holepar = em.HoleId;
sqnum = em.Square;
j = RuleUtils.DoFlips(board, sqnum, color, oppcolor);
if (j > 0)
{
//
board[sqnum] = color;
//
RegionParity ^= (uint)holepar;
//
old_em.Succ = em.Succ;
if (empties <= 1 + Constants.Use_Parity)
{
eval = -NoParEndSolve(board, -beta, -alpha, oppcolor, empties - 1, -discdiff - 2 * j - 1, sqnum);
}
else
{
eval = -ParEndSolve(board, -beta, -alpha, oppcolor, empties - 1, -discdiff - 2 * j - 1, sqnum);
}
//
RuleUtils.UndoFlips(board, j, oppcolor);
RegionParity ^= (uint)holepar;
board[sqnum] = ChessType.EMPTY;
old_em.Succ = em;
if (eval > score)
{
score = eval;
//=========================================
if (empties == searchDepth)
{
bestMove = sqnum;
//StaticMethod.UpdateMessage(score, nodes,sqnum);
// StaticMethod.UpdateThinkingMove(sqnum);
}
if (eval > alpha)
{
if (eval >= beta)
{
return(score);
}
alpha = eval;
}
}
}
}
if (score == -highestScore)
{
if (empties == searchDepth)
{
bestMove = MVPASS;
}
if (prevmove == 0)
{
if (discdiff > 0)
{
return(discdiff + empties);
}
if (discdiff < 0)
{
return(discdiff - empties);
}
return(0);
}
else
{
return(-ParEndSolve(board, -beta, -alpha, oppcolor, empties, -discdiff, 0));
}
}
return(score);
}
private static int getUnStab(ChessType[] board, ChessType color)
{
int num = 0;
int half = 0;
//if (board[10] != color && board[11] == color && (board[17] != color || !(board[12] == color && board[13] == color && board[14] == color && board[15] == color && board[16] == color)))
// num++;
//if (board[17] != color && board[16] == color && (board[10] != color || !(board[11] == color && board[12] == color && board[13] == color && board[14] == color && board[15] == color)))
// num++;
//if (board[10] != color && board[19] == color && (board[73] != color || !(board[28] == color && board[37] == color && board[46] == color && board[55] == color && board[64] == color)))
// num++;
//if (board[20] == color)
// num++;
//if (board[25] == color)
// num++;
//if (board[65] == color)
// num++;
//if (board[70] == color)
// num++;
//return num;
if (board[10] != color && board[20] == color)
{
if ((board[80] == color) && (board[30] == color && board[40] == color && board[50] == color && board[60] == color && board[70] == color))
{
half++;
}
else
{
num++;
}
}
if (board[17] != color && board[25] == color)
{
if ((board[73] == color) && (board[33] == color && board[41] == color && board[49] == color && board[57] == color && board[65] == color))
{
half++;
}
else
{
num++;
}
}
//if (board[17] != color && board[26] == color && (board[80] != color || !(board[35] == color && board[44] == color && board[53] == color && board[62] == color && board[71] == color)))
// num++;
//if (board[73] != color && board[64] == color && (board[10] != color || !(board[19] == color && board[28] == color && board[37] == color && board[46] == color && board[55] == color)))
// num++;
if (board[73] != color && board[65] == color)
{
if ((board[17] == color) && (board[25] == color && board[33] == color && board[41] == color && board[49] == color && board[57] == color))
{
half++;
}
else
{
num++;
}
}
if (board[80] != color && board[70] == color)
{
if ((board[10] == color) && (board[20] == color && board[30] == color && board[40] == color && board[50] == color && board[60] == color))
{
half++;
}
else
{
num++;
}
}
//if (board[80] != color && board[71] == color && (board[17] != color || !(board[26] == color && board[35] == color && board[44] == color && board[53] == color && board[62] == color)))
// num++;
//if (board[73] != color && board[74] == color && (board[80] != color || !(board[75] == color && board[76] == color && board[77] == color && board[78] == color && board[79] == color)))
// num++;
//if (board[80] != color && board[79] == color && (board[73] != color || !(board[74] == color && board[75] == color && board[76] == color && board[77] == color && board[78] == color)))
// num++;
return(num + num + num + half);
}
public int MidEval2(ChessType[] board, ChessType color, ChessType oppcolor, int empties, Empties EmHead)
{
int eval = 0;
//
int mydisc = 0;
int opdisc = 0;
//
int mymob = 0;
int opmob = 0;
//
int mypotmob = 0;
int oppotmob = 0;
//
int mystab = 0;
int opstab = 0;
//
int deltakeyano = 0;
//
int unstab = 0;
int sqnum;
int index = empties - 10;
Empties em = EmHead.Succ;
for (; em != null; em = em.Succ)
{
sqnum = em.Square;
if (RuleUtils.AnyFlips(board, sqnum, color, oppcolor))
{
mymob++;
}
else if (RuleUtils.AnyPotMobility(board, sqnum, oppcolor))
{
mypotmob++;
}
if (RuleUtils.AnyFlips(board, sqnum, oppcolor, color))
{
opmob++;
}
else if (RuleUtils.AnyPotMobility(board, sqnum, color))
{
oppotmob++;
}
}
for (int i = 0; i < midBoardLength; i++)
{
sqnum = midBoard[i];
if (board[sqnum] == color)
{
mydisc++;
if (RuleUtils.AnyStab(board, sqnum, color))
{
mystab++;
}
}
else if (board[sqnum] == oppcolor)
{
opdisc++;
if (RuleUtils.AnyStab(board, sqnum, oppcolor))
{
opstab++;
}
}
}
deltakeyano = getDeltaKeyano(board, color, oppcolor);
unstab = getUnStab(board, color) - getUnStab(board, oppcolor);
eval = mydisc * weight_train[index, 0] + opdisc * weight_train[index, 1] +
mymob * weight_train[index, 2] + opmob * weight_train[index, 3] +
mypotmob * weight_train[index, 4] + oppotmob * weight_train[index, 5] +
mystab * weight_train[index, 6] + opstab * weight_train[index, 7] +
unstab * weight_train[index, 8] + deltakeyano * weight_train[index, 9];
eval += get_score_edge_all(board, color, index) / 3;
return(eval);
}
private MinMaxSearchInfo MinMaxSearch(Model pModel, ChessType chessType, bool isMaxLayer, int depth, int alpha, int beta)
{
MinMaxSearchCount++;
int bestScore = isMaxLayer ? -999 : 999;
MinMaxSearchInfo bestPosInfo = new MinMaxSearchInfo(-1, -1, bestScore);
Console.WriteLine($"depth: {depth} isMaxLayer: {isMaxLayer} MinMaxSearchCount: {MinMaxSearchCount.ToString()} alpha: {alpha.ToString()} beta: {beta}");
for (int y = 0; y < GameDef.board_cell_length; y++)
{
for (int x = 0; x < GameDef.board_cell_length; x++)
{
var board = pModel.GetBoardByCopy();
if (board[y][x] == ChessType.None)
{
Model cloneModel = pModel.Clone() as Model;
cloneModel.PutChessToBoard(x, y, chessType);
int score = 0;
BoradStatus boradStatus = GetBoardStatus(cloneModel, chessType);
if (boradStatus == BoradStatus.Nothing) //沒有勝負 繼續往下找
{
ChessType nextChessType = Utility.GetOppositeChessType(chessType);
MinMaxSearchInfo info = MinMaxSearch(cloneModel, nextChessType, !isMaxLayer, depth + 1, alpha, beta);
//--------- alpha-beta pruning ---------
if (isMaxLayer)
{
alpha = Math.Max(alpha, info.Score);
}
else
{
beta = Math.Min(beta, info.Score);
}
if (alpha >= beta)
{
return(info);
}
//--------------------------------------
score = info.Score;
}
else if (boradStatus == BoradStatus.Winlose)
{
SearchHasResultCount++;
score = MyChessType == chessType ? 1 : -1;//If chess is mychessType get 1 point else get -1 point
}
else if (boradStatus == BoradStatus.Tie)
{
SearchHasResultCount++;
score = 0;
}
if (isMaxLayer)
{
if (score > bestPosInfo.Score)
{
bestPosInfo.Score = score;
bestPosInfo.X = x;
bestPosInfo.Y = y;
}
}
else
{
if (score < bestPosInfo.Score)
{
bestPosInfo.Score = score;
bestPosInfo.X = x;
bestPosInfo.Y = y;
}
}
}
}
}
return(bestPosInfo);
}
public virtual int SetCheckScore(int x, int y, ChessType chessType)
{
Vector2Int inputPos = new Vector2Int(x, y);
int score = 0;
for (int md = 0; md < 4; md++)
{
ChessBoardManager.MoveDir _moveDir = (ChessBoardManager.MoveDir)md;
string str = "1";
int xDir = 0, yDir = 0;
switch (_moveDir)
{
case ChessBoardManager.MoveDir.TransverseLine:
xDir = 1; yDir = 0;
break;
case ChessBoardManager.MoveDir.VerticalLine:
xDir = 0; yDir = 1;
break;
case ChessBoardManager.MoveDir.LeftSlantLine:
xDir = 1; yDir = -1;
break;
case ChessBoardManager.MoveDir.RightSlantLine:
xDir = 1; yDir = 1;
break;
default:
break;
}
for (int dir = -1; dir <= 1; dir += 2)
{
for (int i = 1; i < chessMaxBoard; i++)
{
Vector2Int newPoint = new Vector2Int(inputPos.x + dir * xDir * i, inputPos.y + dir * yDir * i);
if (chessBoardManager.CheckBorder(newPoint))
{
string ch;
if (chessBoardManager.GridArray[newPoint.x, newPoint.y] == chessType)
{
ch = "1";
}
else if (chessBoardManager.GridArray[newPoint.x, newPoint.y] == ChessType.None)
{
ch = "0";
}
else
{
break;
}
if (dir < 0)
{
str = ch + str;
}
else if (dir > 0)
{
str = str + ch;
}
if (ch == "0")
{
break;
}
}
else
{
break;
}
}
}
int _s;
if (scoreDic.TryGetValue(str, out _s))
{
score += _s;
}
}
return(score);
}
public TournamentTypeCondition(ChessType value) => _value = value;
/// <summary>
/// 计算一个棋子的通用威力
/// </summary>
/// <param name="point"></param>
/// <param name="type"></param>
/// <returns></returns>
public static int CommonPower(Point point, ChessType type)
{
List <int> powerContainer = new List <int>();
//计算棋子通用威力
//单二
if (checkDirectOnChessForSingle(point, Direction.UP, type) + 1 == 2)
{
powerContainer.Add(5);
}
if (checkDirectOnChessForSingle(point, Direction.UpLeft, type) + 1 == 2)
{
powerContainer.Add(5);
}
if (checkDirectOnChessForSingle(point, Direction.Left, type) + 1 == 2)
{
powerContainer.Add(5);
}
if (checkDirectOnChessForSingle(point, Direction.DownLeft, type) + 1 == 2)
{
powerContainer.Add(5);
}
if (checkDirectOnChessForSingle(point, Direction.Down, type) + 1 == 2)
{
powerContainer.Add(5);
}
if (checkDirectOnChessForSingle(point, Direction.DownRight, type) + 1 == 2)
{
powerContainer.Add(5);
}
if (checkDirectOnChessForSingle(point, Direction.Right, type) + 1 == 2)
{
powerContainer.Add(5);
}
if (checkDirectOnChessForSingle(point, Direction.UpRight, type) + 1 == 2)
{
powerContainer.Add(5);
}
//单一
if (checkDirectOnChessForSingle(point, Direction.UP, type) + 1 == 1)
{
powerContainer.Add(1);
}
if (checkDirectOnChessForSingle(point, Direction.UpLeft, type) + 1 == 1)
{
powerContainer.Add(1);
}
if (checkDirectOnChessForSingle(point, Direction.Left, type) + 1 == 1)
{
powerContainer.Add(1);
}
if (checkDirectOnChessForSingle(point, Direction.DownLeft, type) + 1 == 1)
{
powerContainer.Add(1);
}
if (checkDirectOnChessForSingle(point, Direction.Down, type) + 1 == 1)
{
powerContainer.Add(1);
}
if (checkDirectOnChessForSingle(point, Direction.DownRight, type) + 1 == 1)
{
powerContainer.Add(1);
}
if (checkDirectOnChessForSingle(point, Direction.Right, type) + 1 == 1)
{
powerContainer.Add(1);
}
if (checkDirectOnChessForSingle(point, Direction.UpRight, type) + 1 == 1)
{
powerContainer.Add(1);
}
//活二
if (ChessRule.checkDirectOnChessForActive(point, Direction.Down, type) + ChessRule.checkDirectOnChessForActive(point, Direction.UP, type) + 1 == 2)
{
powerContainer.Add(7);
}
if (ChessRule.checkDirectOnChessForActive(point, Direction.DownLeft, type) + ChessRule.checkDirectOnChessForActive(point, Direction.UpRight, type) + 1 == 2)
{
powerContainer.Add(7);
}
if (ChessRule.checkDirectOnChessForActive(point, Direction.DownRight, type) + ChessRule.checkDirectOnChessForActive(point, Direction.UpLeft, type) + 1 == 2)
{
powerContainer.Add(7);
}
if (ChessRule.checkDirectOnChessForActive(point, Direction.Left, type) + ChessRule.checkDirectOnChessForActive(point, Direction.Right, type) + 1 == 2)
{
powerContainer.Add(7);
}
//活一
if (ChessRule.checkDirectOnChessForActive(point, Direction.Down, type) + ChessRule.checkDirectOnChessForActive(point, Direction.UP, type) + 1 == 1)
{
powerContainer.Add(3);
}
if (ChessRule.checkDirectOnChessForActive(point, Direction.DownLeft, type) + ChessRule.checkDirectOnChessForActive(point, Direction.UpRight, type) + 1 == 1)
{
powerContainer.Add(3);
}
if (ChessRule.checkDirectOnChessForActive(point, Direction.DownRight, type) + ChessRule.checkDirectOnChessForActive(point, Direction.UpLeft, type) + 1 == 1)
{
powerContainer.Add(3);
}
if (ChessRule.checkDirectOnChessForActive(point, Direction.Left, type) + ChessRule.checkDirectOnChessForActive(point, Direction.Right, type) + 1 == 1)
{
powerContainer.Add(3);
}
//排序
powerContainer.Sort();
//返回最大的两个值和
return(powerContainer[powerContainer.Count - 2] + powerContainer[powerContainer.Count - 1]);
}
private int QuiescenceSolve(ChessType[] board, int alpha, int beta, ChessType color, int depth, int empties, int discdiff, int prevmove)
{
lock (this)
{
int i, j;
int score1;
int score2 = -Constants.HighestScore;
ChessType oppcolor = 2 - color;
int sqnum;
int eval;
int flipped;
int moves, mobility;
int best_value, best_index;
Empties em, old_em;
Empties[] move_ptr = new Empties[Constants.MaxEmpties];
int holepar;
int[] goodness = new int[Constants.MaxEmpties];
////
//nodes++;
score1 = evalation.StaEval2(board, color, oppcolor, empties, EmHead);
if (score1 >= beta || score1 >= 4000 || depth == 0)
{
return(score1);
}
else if (score1 > alpha)
{
alpha = score1;
}
moves = 0;
for (old_em = EmHead, em = old_em.Succ; em != null; old_em = em, em = em.Succ)
{
sqnum = em.Square;
flipped = RuleUtils.DoFlips(board, sqnum, color, oppcolor);
if (flipped > 0)
{
//
board[sqnum] = color;
old_em.Succ = em.Succ;
//
mobility = count_mobility(board, oppcolor);
//
RuleUtils.UndoFlips(board, flipped, oppcolor);
old_em.Succ = em;
board[sqnum] = ChessType.EMPTY;
move_ptr[moves] = em;
goodness[moves] = -mobility;
moves++;
}
}
if (moves != 0)
{
for (i = 0; i < moves; i++)
{
best_value = goodness[i];
best_index = i;
for (j = i + 1; j < moves; j++)
{
if (goodness[j] > best_value)
{
best_value = goodness[j];
best_index = j;
}
}
em = move_ptr[best_index];
move_ptr[best_index] = move_ptr[i];
goodness[best_index] = goodness[i];
sqnum = em.Square;
holepar = em.HoleId;
j = RuleUtils.DoFlips(board, sqnum, color, oppcolor);
board[sqnum] = color;
em.Pred.Succ = em.Succ;
if (em.Succ != null)
{
em.Succ.Pred = em.Pred;
}
//
nodes++;
//
eval = -evalation.StaEval2(board, oppcolor, color, empties - 1, EmHead);
// -QuiescenceSolve(board, -beta, -alpha, oppcolor, depth - 1, empties - 1, -discdiff - j - j - 1, sqnum);
RuleUtils.UndoFlips(board, j, oppcolor);
board[sqnum] = ChessType.EMPTY;
em.Pred.Succ = em;
if (em.Succ != null)
{
em.Succ.Pred = em;
}
if (eval > score2)
{
score2 = eval;
if (eval > alpha)
{
if (eval >= beta)
{
//
return(score2);
}
alpha = eval;
}
}
}
}
else
{
if (prevmove == 0)//
{
if (discdiff > 0)
{
return(Constants.HighestScore);
}
if (discdiff < 0)
{
return(-Constants.HighestScore);
}
return(0);
}
else /* I pass: */
{
nodes++;
score2 = -QuiescenceSolve(board, -beta, -alpha, oppcolor, depth, empties, -discdiff, 0);
return(score2);
}
}
return((2 * score1 + score2) / 3);
}
}
void ShowResult(ChessType winside)
{
rst.gameObject.SetActive(true);
rst.Show(winside);
}
void ShowResult(ChessType winside)
{
ResultWindow.gameObject.SetActive(true);
ResultWindow.Show(winside);
}
public ChessInfo(Vector2Int _pos, ChessType _chessType, GameObject _go)
{
pos = _pos;
chessType = _chessType;
go = _go;
}
public bool IsWin(ChessType chessType)
{
//Model.printBoard();
return(IsWinHorizontal(chessType) || IsWinVertical(chessType) || IsWinRightOblique(chessType) || IsWinLeftOblique(chessType));
}
public void setData(int index, ChessType type)
{
this.index = index;
this.type = type;
}
private bool IsWinVertical(ChessType chessType)
{
return(GetConnectCount(chessType, 0, 1) + GetConnectCount(chessType, 0, -1) - 1 == GameDef.win_count);
}
public void setData(int x, int y, ChessType type)
{
this.index++;
this.grid[x, y].setData(index, type);
}
public ChessType CheckVictoryCondition(ChessInfo[,] b)
{
// check each coloum
for (int i = 0; i < 4; i++)
{
if (b[i, 0] == null)
{
continue;
}
var baseShape = b[i, 0].baseShape;
var height = b[i, 0].height;
var isConcave = b[i, 0].IsConcave;
var chessType = b[i, 0].chessType;
for (int j = 1; j < 4; j++)
{
if (b[i, j] == null)
{
break;
}
if (b[i, j].baseShape != baseShape)
{
break;
}
if (b[i, j].chessType != chessType)
{
break;
}
if (j == b.GetLength(1) - 1)
{
print("return " + chessType);
return(chessType);
}
}
for (int j = 1; j < 4; j++)
{
if (b[i, j] == null || b[i, j].height != height || b[i, j].chessType != chessType)
{
break;
}
if (j == b.GetLength(1) - 1)
{
print("return " + chessType);
return(chessType);
}
}
for (int j = 0; j < 4; j++)
{
if (b[i, j] == null || b[i, j].IsConcave != isConcave || b[i, j].chessType != chessType)
{
break;
}
if (j == b.GetLength(1) - 1)
{
print("return " + chessType);
return(chessType);
}
}
}
for (int i = 0; i < 4; i++)
{
if (b[0, i] == null)
{
continue;
}
var baseShape = b[0, i].baseShape;
var height = b[0, i].height;
var hasCircleOnTop = b[0, i].IsConcave;
var chessType = b[0, i].chessType;
for (int j = 1; j < 4; j++)
{
if (b[j, i] == null || b[j, i].baseShape != baseShape || b[j, i].chessType != chessType)
{
break;
}
if (j == b.GetLength(1) - 1)
{
print("return " + chessType);
return(chessType);
}
}
for (int j = 1; j < 4; j++)
{
if (b[j, i] == null || b[j, i].height != height || b[j, i].chessType != chessType)
{
break;
}
if (j == b.GetLength(1) - 1)
{
print("return " + chessType);
return(chessType);
}
}
for (int j = 1; j < 4; j++)
{
if (b[j, i] == null || b[j, i].IsConcave != hasCircleOnTop || b[j, i].chessType != chessType)
{
break;
}
if (j == b.GetLength(1) - 1)
{
print("return " + chessType);
return(chessType);
}
}
}
// 正对角线
if (b[0, 0] != null)
{
var baseShape = b[0, 0].baseShape;
var height = b[0, 0].height;
var hasCircleOnTop = b[0, 0].IsConcave;
var chessType = b[0, 0].chessType;
for (int j = 1; j < 4; j++)
{
if (b[j, j] == null || b[j, j].baseShape != baseShape || b[j, j].chessType != chessType)
{
break;
}
if (j == b.GetLength(1) - 1)
{
print("return " + chessType);
return(chessType);
}
}
for (int j = 1; j < 4; j++)
{
if (b[j, j] == null || b[j, j].height != height || b[j, j].chessType != chessType)
{
break;
}
if (j == b.GetLength(1) - 1)
{
print("return " + chessType);
return(chessType);
}
}
for (int j = 1; j < 4; j++)
{
if (b[j, j] == null || b[j, j].IsConcave != hasCircleOnTop || b[j, j].chessType != chessType)
{
break;
}
if (j == b.GetLength(1) - 1)
{
print("return " + chessType);
return(chessType);
}
}
}
// 反对角线
if (b[0, b.GetLength(0) - 1] != null)
{
var baseShape = b[0, b.GetLength(0) - 1].baseShape;
var height = b[0, b.GetLength(0) - 1].height;
var isConcave = b[0, b.GetLength(0) - 1].IsConcave;
ChessType chessType = b[0, b.GetLength(0) - 1].chessType;
for (int j = 1; j < b.GetLength(0); j++)
{
if (b[j, b.GetLength(0) - 1 - j] == null || b[j, b.GetLength(0) - 1 - j].baseShape != baseShape || b[j, b.GetLength(0) - 1 - j].chessType != chessType)
{
break;
}
if (j == b.GetLength(1) - 1)
{
print("return " + chessType);
return(chessType);
}
}
for (int j = 0; j < b.GetLength(0); j++)
{
if (b[j, b.GetLength(0) - 1 - j] == null || b[j, b.GetLength(0) - 1 - j].height != height || b[j, b.GetLength(0) - 1 - j].chessType != chessType)
{
break;
}
if (j == b.GetLength(1) - 1)
{
print("return " + chessType);
return(chessType);
}
}
for (int j = 0; j < b.GetLength(0); j++)
{
if (b[j, b.GetLength(0) - 1 - j] == null ||
b[j, b.GetLength(0) - 1 - j].IsConcave != isConcave || b[j, b.GetLength(0) - 1 - j].chessType != chessType)
{
break;
}
if (j == b.GetLength(1) - 1)
{
print("return " + chessType);
return(chessType);
}
}
}
return(ChessType.Null);
}
public AIComputer3X3Player(String name, Form1 view, Model model, RoleMgr roleMgr, ChessType chessType) : base(name, view, model, roleMgr, chessType)
{
}
private static bool AnyDrctnlFlips(ChessType[] board, int boardIndex, int inc, ChessType color, ChessType oppcolor)
{
int pt = boardIndex + inc;
if (board[pt] == oppcolor)
{
pt += inc;
if (board[pt] == oppcolor) /*2*/
{
pt += inc;
if (board[pt] == oppcolor) /*3*/
{
pt += inc;
if (board[pt] == oppcolor)/*4*/
{
pt += inc;
if (board[pt] == oppcolor) /*5*/
{
pt += inc;
if (board[pt] == oppcolor)/*6*/
{
pt += inc;
}
}
}
}
}
return(board[pt] == color);
}
return(false);
}
public static Player CreatePlayer(GameDef.PlayerType type, Form1 view, Model model, RoleMgr roleMgr, ChessType chessType)
{
Console.WriteLine($"Create a {type.ToString()} Player. ChessType is {chessType}");
switch (type)
{
case GameDef.PlayerType.Human1:
return(new HumanPlayer("Human1 " + chessType, view, model, roleMgr, chessType));
break;
case GameDef.PlayerType.Human2:
return(new HumanPlayer("Human2 " + chessType, view, model, roleMgr, chessType));
break;
case GameDef.PlayerType.EasyAI:
return(new EasyComputerPlayer("EasyAI " + chessType, view, model, roleMgr, chessType));
break;
case GameDef.PlayerType.MediumAI:
return(new MinMaxComputerPlayer("MediumAI " + chessType, view, model, roleMgr, chessType, 1));
break;
case GameDef.PlayerType.HardAI:
return(new MinMaxComputerPlayer("HardAI " + chessType, view, model, roleMgr, chessType, 3));
break;
case GameDef.PlayerType.AI3X3:
return(new AIComputer3X3Player("AI3X3 " + chessType, view, model, roleMgr, chessType));
break;
case GameDef.PlayerType.RandomAI:
return(new RandomComputerPlayer("RandomAI " + chessType, view, model, roleMgr, chessType));
break;
default:
return(null);
break;
}
}
