Javascript Alpha-Beta修剪Tic-Tac-Toe

我正在为我的AI类做一个项目，我们需要实现深度有界的极大极小搜索，然后在一个终极Tic-Tac-Toe或Tic-Tac-Toe的游戏中添加alpha-beta修剪。这个版本的tic tac toe是一个由3x3个游戏板组成的3x3游戏板。当你在小板上的某个位置上玩时，你刚才玩的移动对应于对手将玩的下一个小板。我已经能够找到常规井字游戏的结果，但由于游戏规则的原因，它们并不太适用

如果你在左上角棋盘的中间，下一个玩家将在大棋盘的中间棋盘上比赛。提供了这两个动作的图片。红色是第一个球员

我们的问题在于阿尔法-贝塔植入。

关于我们的深度有界极大极小搜索

我们的minimax实现似乎工作正常。当我们试图实现alpha-beta时，我们的AI代理正确地停止了工作

我们的minimax实现代码如下：

function evaluateMove(outerX2, outerY2, innerX2, innerY2, depth, isAI, tempBoard)
{
var currentBoard = JSON.parse( JSON.stringify( tempBoard ));
var score = 0;
var bestScore = 0;

var playerZZ;
if (isAI) {
    playerZZ = 2;
}
else {
    playerZZ = 1;
}
if(checkForWin(2, JSON.parse( JSON.stringify( currentBoard )), outerX2, outerY2, innerX2, innerY2))
{
    //AI wins
    return 10;
}
if(checkForWin(1, JSON.parse( JSON.stringify( currentBoard )), outerX2, outerY2, innerX2, innerY2))
{
    //Human wins
    return -10;
}
else if (depth == 2) {
    return 0;
}
if (checkForBoardWin(innerX2, innerY2, 1) || checkForBoardWin(innerX2, innerY2, 2))
{
    if (isAI)
    {
    bestScore = -100;
        for (var X = 0; X < 3; X++)
        {
            for (var Y = 0; Y < 3; Y++)
            {
                for (var x = 0; x < 3; x++)
                {
                    for (var y = 0; y < 3; y++)
                    {
                        if(currentBoard[X][Y][x][y] == 0 && !(checkForBoardWin(X, Y, 1) || checkForBoardWin(X, Y, 2)))
                        {
                            //JAKE: Broken here?
                            currentBoard[X][Y][x][y] = 2
                            score = evaluateMove(X, Y, x, y, depth + 1, false, currentBoard);
                            //var bestScore = -100;
                            if (score > bestScore)
                            {
                                console.log("Line 105: Score = ", score);
                                return score;
                            }
                            else
                            {
                                return bestScore;
                            }
                        }

                    }
                }
            }
        }
    }
    else
    {
    bestScore = 100;
        for (var X = 0; X < 3; X++)
        {
            for (var Y = 0; Y < 3; Y++)
            {
                for (var x = 0; x < 3; x++)
                {
                    for (var y = 0; y < 3; y++)
                    {
                        if(currentBoard[X][Y][x][y] == 0)
                        {
                            currentBoard[X][Y][x][y] = 1
                            score = evaluateMove(X, Y, x, y, depth + 1, false, currentBoard);
                            //bestScore = 100;
                            if (score < bestScore)
                            {
                                console.log("Line 137: Score = ", score);
                                return score;
                            }
                            else
                            {
                                return bestScore;
                            }
                        }

                    }
                }
            }
        }
    }
}
else
{
bestScore = -100;
    if (isAI)
    {
        for(var x = 0; x < 3; x++)
        {
            for (var y = 0; y < 3; y++)
            {
                if(currentBoard[innerX2][innerY2][x][y] == 0)
                {
                    //JAKE: Broken here?
                    currentBoard[innerX2][innerY2][x][y] = 2
                    score = evaluateMove(innerX2, innerY2, x, y, depth + 1, false, currentBoard);
                    //bestScore = -100;
                    if (score > bestScore)
                    {
                        console.log("Line 169: Score = ", score);
                        return score;
                    }
                    else
                    {
                        return bestScore;
                    }
                }

            }
        }
    }
    else
    {
    bestScore = 100;
        for(var x = 0; x < 3; x++)
        {
            for (var y = 0; y < 3; y++)
            {
                if(currentBoard[innerX2][innerY2][x][y] == 0)
                {
                    currentBoard[innerX2][innerY2][x][y] = 1
                    score = evaluateMove(innerX2, innerY2, x, y, depth + 1, true, currentBoard);
                    bestScore = 100;
                    if (score < bestScore)
                    {
                        console.log("Line 195: Score = ", score);
                        return score;
                    }
                    else
                    {
                        return bestScore;
                    }
                }

            }
        }
    }
}
return 0;
}

function evaluateMove（outerX2、outerY2、innerX2、innerY2、depth、isAI、tempBoard）
{
var currentBoard=JSON.parse（JSON.stringify（tempBoard））；
var得分=0；
var得分=0；
var playerZZ；
如果（国际会计准则）{
playerZZ=2；
}
否则{
playerZZ=1；
}
if（checkForWin（2，JSON.parse（JSON.stringify（currentBoard）），outerX2，outerY2，innerX2，innerY2））
{
//AI获胜
返回10；
}
if（checkForWin（1，JSON.parse（JSON.stringify（currentBoard）），outerX2，outerY2，innerX2，innerY2））
{
//人类获胜
返回-10；
}
否则如果（深度==2）{
返回0；
}
if（checkForBoardWin（innerX2，innerY2，1）| checkForBoardWin（innerX2，innerY2，2））
{
如果（国际会计准则）
{
最佳得分=-100；
对于（变量X=0；X<3；X++）
{
对于（变量Y=0；Y<3；Y++）
{
对于（变量x=0；x<3；x++）
{
对于（变量y=0；y<3；y++）
{
if（currentBoard[X][Y][X][Y]==0&&！（checkForBoardWin（X，Y，1）| checkForBoardWin（X，Y，2）））
{
//杰克：这里坏了？
电流板[X][Y][X][Y]=2
分数=评估移动（X，Y，X，Y，深度+1，错误，当前板）；
//var bestScore=-100；
如果（分数>最佳分数）
{
console.log（“第105行：Score=”，Score）；
返回分数；
}
其他的
{
返回最佳分数；
}
}
}
}
}
}
}
其他的
{
最佳得分=100分；
对于（变量X=0；X<3；X++）
{
对于（变量Y=0；Y<3；Y++）
{
对于（变量x=0；x<3；x++）
{
对于（变量y=0；y<3；y++）
{
如果（当前板[X][Y][X][Y]==0）
{
电流板[X][Y][X][Y]=1
分数=评估移动（X，Y，X，Y，深度+1，错误，当前板）；
//最佳得分=100分；
如果（分数<最佳分数）
{
console.log（“第137行：Score=”，Score）；
返回分数；
}
其他的
{
返回最佳分数；
}
}
}
}
}
}
}
}
其他的
{
最佳得分=-100；
如果（国际会计准则）
{
对于（变量x=0；x<3；x++）
{
对于（变量y=0；y<3；y++）
{
如果（当前板[innerX2][innerY2][x][y]==0）
{
//杰克：这里坏了？
电流板[innerX2][innerY2][x][y]=2
分数=评估移动（innerX2、innerY2、x、y、深度+1、false、currentBoard）；
//最佳得分=-100；
如果（分数>最佳分数）
{
console.log（“第169行：Score=”，Score）；
返回分数；
}
其他的
{
返回最佳分数；
}
}
}
}
}
其他的
{
最佳得分=100分；
对于（变量x=0；x<3；x++）
{
对于（变量y=0；y<3；y++）
{
如果（当前板[innerX2][innerY2][x][y]==0）
{
电流板[innerX2][innerY2][x][y]=1
分数=评估移动（innerX2、innerY2、x、y、深度+1、真、当前板）；
最佳得分=100分；
如果（分数<最佳分数）
{
console.log（“第195行：Score=”，Score）；
返回分数；
}
其他的
{
返回最佳分数；
}
}
}
}
}
}
返回0；
}

关于我们的Alpha-Beta修剪实现：

我们的evaluate move函数包含几个变量，X2和Y2都构成了我们现在正在评估的bigBoard中移动的四维数组坐标。我们遵循了中的伪代码。不幸的是，我们的人工智能一直在左上角播放，直到它没有更多的选择这样做，在这种情况下，它播放了左侧的董事会。我和我的团队已经为这件事大惊小怪了一段时间了

function evaluateMove(outerX2, outerY2, innerX2, innerY2, depth, isAI, tempBoard)
{
var currentBoard = JSON.parse( JSON.stringify( tempBoard ));
var score = 0;
var bestScore = 0;

var playerZZ;
if (isAI) {
    playerZZ = 2;
}
else {
    playerZZ = 1;
}
if(checkForWin(2, JSON.parse( JSON.stringify( currentBoard )), outerX2, outerY2, innerX2, innerY2))
{
    //AI wins
    return 10;
}
if(checkForWin(1, JSON.parse( JSON.stringify( currentBoard )), outerX2, outerY2, innerX2, innerY2))
{
    //Human wins
    return -10;
}
else if (depth == 2) {
    return 0;
}
if (checkForBoardWin(innerX2, innerY2, 1) || checkForBoardWin(innerX2, innerY2, 2))
{
    if (isAI)
    {
    bestScore = -100;
        for (var X = 0; X < 3; X++)
        {
            for (var Y = 0; Y < 3; Y++)
            {
                for (var x = 0; x < 3; x++)
                {
                    for (var y = 0; y < 3; y++)
                    {
                        if(currentBoard[X][Y][x][y] == 0 && !(checkForBoardWin(X, Y, 1) || checkForBoardWin(X, Y, 2)))
                        {
                            //JAKE: Broken here?
                            currentBoard[X][Y][x][y] = 2
                            score = evaluateMove(X, Y, x, y, depth + 1, false, currentBoard);
                            //var bestScore = -100;
                            if (score > bestScore)
                            {
                                console.log("Line 105: Score = ", score);
                                return score;
                            }
                            else
                            {
                                return bestScore;
                            }
                        }

                    }
                }
            }
        }
    }
    else
    {
    bestScore = 100;
        for (var X = 0; X < 3; X++)
        {
            for (var Y = 0; Y < 3; Y++)
            {
                for (var x = 0; x < 3; x++)
                {
                    for (var y = 0; y < 3; y++)
                    {
                        if(currentBoard[X][Y][x][y] == 0)
                        {
                            currentBoard[X][Y][x][y] = 1
                            score = evaluateMove(X, Y, x, y, depth + 1, false, currentBoard);
                            //bestScore = 100;
                            if (score < bestScore)
                            {
                                console.log("Line 137: Score = ", score);
                                return score;
                            }
                            else
                            {
                                return bestScore;
                            }
                        }

                    }
                }
            }
        }
    }
}
else
{
bestScore = -100;
    if (isAI)
    {
        for(var x = 0; x < 3; x++)
        {
            for (var y = 0; y < 3; y++)
            {
                if(currentBoard[innerX2][innerY2][x][y] == 0)
                {
                    //JAKE: Broken here?
                    currentBoard[innerX2][innerY2][x][y] = 2
                    score = evaluateMove(innerX2, innerY2, x, y, depth + 1, false, currentBoard);
                    //bestScore = -100;
                    if (score > bestScore)
                    {
                        console.log("Line 169: Score = ", score);
                        return score;
                    }
                    else
                    {
                        return bestScore;
                    }
                }

            }
        }
    }
    else
    {
    bestScore = 100;
        for(var x = 0; x < 3; x++)
        {
            for (var y = 0; y < 3; y++)
            {
                if(currentBoard[innerX2][innerY2][x][y] == 0)
                {
                    currentBoard[innerX2][innerY2][x][y] = 1
                    score = evaluateMove(innerX2, innerY2, x, y, depth + 1, true, currentBoard);
                    bestScore = 100;
                    if (score < bestScore)
                    {
                        console.log("Line 195: Score = ", score);
                        return score;
                    }
                    else
                    {
                        return bestScore;
                    }
                }

            }
        }
    }
}
return 0;
}