def genMoves(state, chain=[]):
"""
List possible moves. Moves are a list of moves, because some moves
result in the player getting to move again.
>>> genMoves([1, 2, 4, 4, 5, 6, 0, 12, 11, 10, 9, 8, 7, 0, 0])
([[0], [1], [2, 0], [2, 1], [2, 3], [2, 4], [2, 5], [3], [4], [5]], 11)
>>> genMoves([0, 2, 0, 0, 1, 5, 17, 0, 0, 0, 0, 0, 1, 20, 1])
([[12]], 1)
"""
movecount = 0
player = s.getCurrentPlayer(state)
new = s.getLegalMoves(state)
if len(new) == 0:
# no legal moves, so game is over: return move chain so far
result = [chain] if len(chain) > 0 else []
else:
result = []
for m in new:
movecount += 1
newstate = s.doMove(state, m)
currentChain = chain + [m]
if player == s.getCurrentPlayer(newstate):
# still our move after move m, so recurse and grow the chain
r, moves = genMoves(newstate, currentChain)
movecount = movecount + moves
# r is list of move chains we generated, so merge lists
result = result + r
else:
# no more moves in this chain, add it to result list
result = result + [currentChain]
return (result, movecount)
def getMove(self, state):
# rotate the board for current player
player = s.getCurrentPlayer(state)
if player != 0:
flip = True
board = s.flipBoard(state)
else:
flip = False
board = state
# get output of neural network
fd = {self.x: [self.makeInputVector(board[:14])], self.keep_prob: 1.0}
y = self.sess.run(self.y, fd)
# y is a list containing a single output vector
# y == [[0.0108906 0.1377293 0.370027 0.2287382 0.0950692 0.1575449]]
scores = list(y[0])
# we only want to pick from legal moves (the nn will learn these
# eventually, but we're helping him with this constraint)
legalMoves = s.getLegalMoves(board)
move = self.chooseMoveRandomly(scores, legalMoves)
if len([x for x in scores if math.isnan(x)]) > 0:
logger.error(self.name + " returned NaN!")
# if we rotated the board before, rotate it back
if flip:
move = s.flipMove(move, player)
return move
def play_game(players):
game = s.init()
done = False
moves = []
while not done:
# do move for someone
player = s.getCurrentPlayer(game)
move = players[player]['ai'].move(game)
if move is None:
print("null move! ", game)
mt = {
"move": s.flipMove(move, player),
"board": s.flipBoardCurrentPlayer(game),
"player": player,
"name": players[player]['module'].__name__
}
moves.append(mt)
game = s.doMove(game, move)
done = s.isGameOver(game)
winner = s.getWinner(game)
# make training set with move, gamestate, and 1 for win, 0 for lose
trainingset = [dict(d, winner=int(winner == d['player'])) for d in moves]
i = 0
for p in players:
p['ai'].gameOver(i == winner)
i += 1
return (winner, trainingset)
def play_one_game(players, lucky):
game = s.init()
done = False
moves = []
while not done:
# do move for someone
player = s.getCurrentPlayer(game)
if needRandomMove(len(moves)):
move = lucky.move(game)
else:
move = players[player]['ai'].move(game)
if move is None:
logger.error("null move! ", game)
mt = [s.flipBoardCurrentPlayer(game), s.flipMove(move, player), player]
moves.append(mt)
game = s.doMove(game, move)
done = s.isGameOver(game)
winner = s.getWinner(game)
score = s.getScore(game)
# make training set with move, gamestate, and 1 for win, 0 for lose
trainingset = [
d[0:2] + [int(winner == d[2])] + list(score)[::1 - d[2] * 2]
for d in moves
]
for move in trainingset:
results.info(move)
i = 0
for p in players:
isWinner = (1 if i == winner else 0)
p['ai'].gameOver(isWinner)
p['wins'] += isWinner
i += 1
return (winner, trainingset)
def setPrompt(self):
names = ["Player 1", "Player 2"]
promptlines = [
d.getStateDrawing(self.game.gamestate, self.game.priorstate),
d.getCommandOptionsLine(),
names[s.getCurrentPlayer(self.game.gamestate)] + ': '
]
self.prompt = "\n".join(promptlines)
def play_game(*players):
game = s.init()
done = False
while not done:
player = s.getCurrentPlayer(game)
move = players[player].move(game)
game = s.doMove(game, move)
done = s.isGameOver(game)
return s.getWinner(game)
def oldmain(name="nn", inputfile='trainingmoves.csv'):
ai = importlib.import_module('ai.' + name)
player = ai.AI()
player.train(datafile=inputfile)
state = s.randomState()
move = player.move(state)
draw_game.drawState(state)
print("player: {}".format(s.getCurrentPlayer(state)))
print("move: {}".format(move))
def move(self, state):
player = s.getCurrentPlayer(state)
if player != 0:
flip = True
board = s.flipBoard(state)
else:
flip = False
board = state
move = self.nn.getMove(board)
if flip:
move = s.flipMove(move, player)
return move
def makeVector(state, m=None, isWinner=None, myscore=None, oppscore=None):
"""
Create a vector of scores for winning moves and losing moves. Treat any
illegal move as a losing move.
>>> state = [1, 2, 3, 4, 5, 6, 0, 12, 11, 10, 9, 8, 7, 0, 0]
>>> makeVector(state, 0, 1)
[101, 1, 1, 2, 2, 2]
>>> state = [1, 2, 3, 0, 5, 6, 0, 12, 11, 7, 9, 8, 7, 0, 0]
>>> makeVector(state, 2, 0)
[1, 9, 0, 0, 2, 2]
>>> state = [1, 2, 3, 0, 5, 6, 0, 12, 11, 7, 9, 8, 7, 0, 0]
>>> makeVector(state)
[1, 9, 1, 0, 2, 2]
"""
score_now = s.getScore(state)
vector = ([0] * 6)[:]
for move in range(6):
if s.isLegalMove(state, move):
# legal, so start at 1
vector[move] = 1
newstate = s.doMove(state, move)
score_new = s.getScore(newstate)
if s.getCurrentPlayer(newstate) == s.getCurrentPlayer(state):
vector[move] += SCORE_MOVE_AGAIN
vector[move] += SCORE_CAPTURE * (score_new[0] - score_now[0])
if move == m:
if isWinner:
vector[move] += SCORE_WINNER_MOVE
else:
vector[move] -= SCORE_LOSER_MOVE
else:
# illegal, always zero
vector[move] = 0
vector[move] = max(0, vector[move])
return vector[:6]
def betweenMoves(self):
current = s.getCurrentPlayer(self.gamestate)
module = self.player_algorithm.get(current)
isHumanNext = True if module is None else False
while not isHumanNext:
if s.isGameOver(self.gamestate):
raise EndGame(self.gamestate)
current = s.getCurrentPlayer(self.gamestate)
module = self.player_algorithm.get(current)
isHumanNext = True if module is None else False
if not isHumanNext:
try:
d.drawState(self.gamestate, self.priorstate)
cprint("My move!", PLAYER_COLORS[current])
move = module.move(self.gamestate)
self.priorstate = self.gamestate[:]
self.gamestate = s.doMove(self.gamestate, move)
cprint(module.taunt(), PLAYER_COLORS[current])
except s.NoMoves as n:
cprint("Oops! I have no moves!", PLAYER_COLORS[current])
raise EndGame(self.gamestate)
except Exception:
raise NoAI(current)
pass
def computeScore(state):
"""
Return a numeric score for a board position.
>>> computeScore([1, 2, 4, 4, 5, 6, 0, 12, 11, 10, 9, 8, 7, 0, 0])
35
"""
score = 0
for p in range(s.NUM_PLAYERS):
row = s.getRow(state, p)
rcnt = 0
for b in row:
rcnt += b
cnt = s.getBowlCount(state, s.getMancalaIndex(p))
if p == s.getCurrentPlayer(state):
score -= cnt * 2
score -= rcnt
else:
score += cnt * 2
score += rcnt
return score
def move(self, state):
# rotate the board for current player
player = s.getCurrentPlayer(state)
if player != 0:
flip = True
board = s.flipBoard(state)
else:
flip = False
board = state
# pick best move
vector = moveToVector(board)
bestmove = None
bestscore = 0
for i in range(6):
move = 5 - i
if vector[move] > bestscore:
bestmove = move
bestscore = vector[move]
# flip move
if flip:
bestmove = s.flipMove(bestmove, player)
return bestmove
