AI 与 Python – 游戏

---

游戏是有策略的。每个玩家或团队在开始游戏之前都会制定策略，并且他们必须根据游戏中当前的情况改变或建立新的策略。

搜索算法

您还必须考虑采用与上述相同策略的电脑游戏。请注意，搜索算法是计算计算机游戏策略的算法。

怎么运行的

搜索算法的目标是找到最佳的动作集，以便他们能够到达最终目的地并获胜。这些算法使用每场比赛不同的获胜条件集来找到最佳动作。

将电脑游戏想象成一棵树。我们知道树有节点。从根开始，我们可以到达最终获胜节点，但具有最佳动作。这就是搜索算法的工作。该树中的每个节点都代表一个未来状态。搜索算法搜索该树以在游戏的每个步骤或节点做出决策。

组合搜索

使用搜索算法的主要缺点是它们本质上是详尽的，这就是为什么它们探索整个搜索空间以找到导致资源浪费的解决方案。如果这些算法需要搜索整个搜索空间来找到最终的解决方案，那就更加麻烦了。

为了消除此类问题，我们可以使用组合搜索，它使用启发式来探索搜索空间，并通过消除可能的错误动作来减小搜索空间的大小。因此，此类算法可以节省资源。这里讨论一些使用启发式搜索空间并节省资源的算法 -

极小极大算法

它是组合搜索所使用的策略，利用启发式来加速搜索的策略。极小极大策略的概念可以通过两个玩家博弈的例子来理解，其中每个玩家都试图预测对手的下一步行动并试图最小化该函数。而且，为了获胜，玩家总是会根据当前情况尝试最大化自己的功能。

启发式在极小极大等策略中发挥着重要作用。树的每个节点都有一个与其关联的启发式函数。基于该启发式，它将决定转向对他们最有利的节点。

Alpha-Beta 修剪

Minimax算法的一个主要问题是它会探索树中那些不相关的部分，导致资源浪费。因此，必须有一种策略来决定树的哪一部分是相关的，哪一部分是不相关的，并且不探索不相关的部分。Alpha-Beta 修剪就是这样一种策略。

Alpha-Beta剪枝算法的主要目标是避免搜索树中没有任何解的部分。Alpha-Beta 剪枝的主要概念是使用两个边界：Alpha（最大下界）和Beta（最小上界）。这两个参数是限制可能的解决方案集的值。它将当前节点的值与 alpha 和 beta 参数的值进行比较，以便它可以移动到树中具有解决方案的部分并丢弃其余部分。

负最大算法

该算法与Minimax算法没有什么不同，但它有更优雅的实现。使用 Minimax 算法的主要缺点是我们需要定义两个不同的启发式函数。这些启发式之间的联系是，游戏状态对于一个玩家来说越好，对于另一个玩家来说就越差。在 Negamax 算法中，两个启发式函数的相同工作是在单个启发式函数的帮助下完成的。

构建玩游戏的机器人

为了构建在 AI 中玩两人游戏的机器人，我们需要安装easyAI库。它是一个人工智能框架，提供构建两人游戏的所有功能。您可以借助以下命令下载它 -

pip install easyAI

一个玩最后硬币的机器人

在这个游戏中，会有一堆硬币。每个玩家必须从该堆中取出一定数量的硬币。游戏的目标是避免拿走堆中的最后一枚硬币。我们将使用继承自easyAI库的TwoPlayersGame类的LastCoinStanding类。以下代码显示了该游戏的 Python 代码 -

导入所需的包，如图所示 -

from easyAI import TwoPlayersGame, id_solve, Human_Player, AI_Player
from easyAI.AI import TT

现在，从TwoPlayerGame类继承该类来处理游戏的所有操作 -

class LastCoin_game(TwoPlayersGame):
   def __init__(self, players):

现在，定义玩家和将开始游戏的玩家。

self.players = players
self.nplayer = 1

现在，定义游戏中的金币数量，这里我们使用 15 个金币进行游戏。

self.num_coins = 15

定义玩家在一次移动中可以获取的最大金币数量。

self.max_coins = 4

现在需要定义一些特定的内容，如以下代码所示。定义可能的动作。

def possible_moves(self):
   return [str(a) for a in range(1, self.max_coins + 1)]

定义硬币的移除

def make_move(self, move):
   self.num_coins -= int(move)

定义谁拿走了最后一枚硬币。

def win_game(self):
   return self.num_coins <= 0

定义何时停止游戏，即有人获胜的时候。

def is_over(self):
   return self.win()

定义如何计算分数。

def score(self):
   return 100 if self.win_game() else 0

定义堆中剩余的硬币数量。

def show(self):
   print(self.num_coins, 'coins left in the pile')
if __name__ == "__main__":
   tt = TT()
   LastCoin_game.ttentry = lambda self: self.num_coins

使用以下代码块解决游戏 -

r, d, m = id_solve(LastCoin_game,
   range(2, 20), win_score=100, tt=tt)
print(r, d, m)

决定谁将开始比赛

game = LastCoin_game([AI_Player(tt), Human_Player()])
game.play()

您可以找到以下输出和该游戏的简单玩法 -

d:2, a:0, m:1
d:3, a:0, m:1
d:4, a:0, m:1
d:5, a:0, m:1
d:6, a:100, m:4
1 6 4
15 coins left in the pile
Move #1: player 1 plays 4 :
11 coins left in the pile
Player 2 what do you play ? 2
Move #2: player 2 plays 2 :
9 coins left in the pile
Move #3: player 1 plays 3 :
6 coins left in the pile
Player 2 what do you play ? 1
Move #4: player 2 plays 1 :
5 coins left in the pile
Move #5: player 1 plays 4 :
1 coins left in the pile
Player 2 what do you play ? 1
Move #6: player 2 plays 1 :
0 coins left in the pile

玩井字棋的机器人

Tic-Tac-Toe 是非常熟悉的，也是最受欢迎的游戏之一。让我们使用Python 中的easyAI库来创建这个游戏。以下代码是该游戏的Python代码 -

导入包，如图所示 -

from easyAI import TwoPlayersGame, AI_Player, Negamax
from easyAI.Player import Human_Player

从TwoPlayerGame类继承该类来处理游戏的所有操作 -

class TicTacToe_game(TwoPlayersGame):
   def __init__(self, players):

现在，定义玩家和将要开始游戏的玩家 -

self.players = players
self.nplayer = 1

定义板的类型 -

self.board = [0] * 9

现在有一些特定的事情需要定义如下 -

定义可能的动作

def possible_moves(self):
   return [x + 1 for x, y in enumerate(self.board) if y == 0]

定义玩家的移动 -

def make_move(self, move):
   self.board[int(move) - 1] = self.nplayer

为了增强人工智能，定义玩家何时采取行动 -

def umake_move(self, move):
   self.board[int(move) - 1] = 0

定义对手三人成一排的失败条件

def condition_for_lose(self):
   possible_combinations = [[1,2,3], [4,5,6], [7,8,9],
      [1,4,7], [2,5,8], [3,6,9], [1,5,9], [3,5,7]]
   return any([all([(self.board[z-1] == self.nopponent)
      for z in combination]) for combination in possible_combinations])

定义游戏结束的检查

def is_over(self):
   return (self.possible_moves() == []) or self.condition_for_lose()

显示玩家当前在游戏中的位置

def show(self):
   print('\n'+'\n'.join([' '.join([['.', 'O', 'X'][self.board[3*j + i]]
      for i in range(3)]) for j in range(3)]))

计算分数。

def scoring(self):
   return -100 if self.condition_for_lose() else 0

定义主要方法来定义算法并开始游戏 -

if __name__ == "__main__":
   algo = Negamax(7)
   TicTacToe_game([Human_Player(), AI_Player(algo)]).play()

您可以看到以下输出和该游戏的简单玩法 -

. . .
. . .
. . .
Player 1 what do you play ? 1
Move #1: player 1 plays 1 :
O . .
. . .
. . .
Move #2: player 2 plays 5 :
O . .
. X .
121
. . .
Player 1 what do you play ? 3
Move #3: player 1 plays 3 :
O . O
. X .
. . .
Move #4: player 2 plays 2 :
O X O
. X .
. . .
Player 1 what do you play ? 4
Move #5: player 1 plays 4 :
O X O
O X .
. . .
Move #6: player 2 plays 8 :
O X O
O X .
. X .