def play(self):
print 'New game'
p1, p2 = self.assignXO()
usr = UserPlayer(p1, p2, self.size)
ai = AIPlayer(p2, p1, self.size)
if usr.xo == self.first():
print 'User starts the game with \'{}\''.format(self.first())
self.s.show()
usr.makeMove(self.s)
else:
print 'AI starts the game with \'{}\''.format(self.first())
while not self.isGameOver():
ai.makeMove(self.s)
if self.isGameOver():
break
usr.makeMove(self.s)
if self.s.isWinning(usr.xo):
print 'You\'ve won, impressive!'
elif self.s.isWinning(ai.xo):
print 'You lose, sorry...'
else:
print 'It\'s a draw.'
def run_game(self, game_mode):
# Initialize Basic State
pygame.init()
self.clock = pygame.time.Clock()
# Initialize Objects
self.display = pygame.display.set_mode((self.width, self.height))
pygame.display.set_caption("Breakout Game")
paddle = Paddle(self.width, self.height)
ball = Ball(self.width, self.height)
bricks = []
brick_width = self.width / 10
brick_height = self.height / 25
for x in range(10):
for y in range(5):
brick_x = x * (self.width / 10)
brick_y = y * (self.height / 25) + 20
brick = Brick(self.width, self.height, brick_x, brick_y)
bricks.append(brick)
ai_player = AIPlayer()
# Draw Objects
self.draw_bg()
paddle.draw_paddle(self.display)
ball.draw_ball(self.display)
for brick in bricks:
brick.draw_brick(self.display)
# Update Objects Every Tick
while ball.alive:
# Handle events
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
# Handle Object Movements
if game_mode < 2:
move = ai_player.generate_move(ball, paddle, bricks, game_mode)
if move == 1:
paddle.move_left()
elif move == 2:
paddle.move_right()
elif game_mode == 2:
keys = pygame.key.get_pressed()
if keys[K_LEFT]:
paddle.move_left()
if keys[K_RIGHT]:
paddle.move_right()
bricks = ball.move_ball(paddle, bricks)
# Redraw
self.draw_bg()
paddle.draw_paddle(self.display)
ball.draw_ball(self.display)
for brick in bricks:
brick.draw_brick(self.display)
# Update Display
pygame.display.update()
self.clock.tick(self.fps)
def main():
model = buildModel()
if 'play' in sys.argv:
players = [
AIPlayer(color=chess.BLACK, model=model),
HumanPlayer(chess.WHITE)
]
elif 'debug' in sys.argv:
players = [HumanPlayer(chess.BLACK), HumanPlayer(chess.WHITE)]
elif 'train' in sys.argv or 'watch' in sys.argv:
players = [
AIPlayer(color=chess.BLACK, model=model),
AIPlayer(color=chess.WHITE, model=model)
]
else:
print("No command")
quit(1)
game = Game(*players)
def onBtn(n):
p = players[game.turn]
if isinstance(p, HumanPlayer):
p.moveOrder(game, n)
def updateGame():
running = game.run()
if not running:
print("Game ended", game.result(claim_draw=True))
game.reset()
updateGame.count += 1
if win: win.update(game.toArrays()[0])
if updateGame.count >= SAVE_INTERVAL:
saveModel(model)
updateGame.count = 0
updateGame.count = 0
win = None
try:
if 'train' in sys.argv:
while (True):
updateGame()
else:
win = Window(onButton=onBtn)
win.loop(cb=updateGame)
except KeyboardInterrupt:
pass
finally:
saveModel(model)
class EnemyPlayer(Player):
name = "Enemy Player"
shortcut = "EP"
register = True
size_ratio = 0.5
cls_texture = textures.player2_up
def setup(self):
self.textures = textures.player2
self.images = game_objects.player2
def start(self):
self.move_duration = 0.35
self.ai = AIPlayer(self)
self.on_every_move()
def on_move_finish(self):
pass
def on_every_move(self):
destination = self.ai.get_move()
if destination is None:
self.aitimer = Timer(0.1, self.on_every_move)
self.aitimer.start()
return
self.move(destination)
def freeze(self):
self.frozen = True
self.aitimer.cancel()
class EnemyPlayer(Player):
name = "Enemy Player"
shortcut = "EP"
register = True
size_ratio = 0.5
cls_texture = textures.player2_up
def setup(self):
self.textures = textures.player2
self.images = game_objects.player2
def start(self):
self.move_duration = 0.35
self.ai = AIPlayer(self)
self.on_every_move()
def on_move_finish(self):
pass
def on_every_move(self):
destination = self.ai.get_move()
if destination is None:
self.aitimer = Timer(0.1, self.on_every_move)
self.aitimer.start()
return
self.move(destination)
def freeze(self):
self.frozen = True
self.aitimer.cancel()
def start(self):
self.move_duration = 0.35
self.ai = AIPlayer(self)
self.on_every_move()
def __init__(self, name='MinMax AI (depth 4)', tag='&', color=colors['BLUE'], setup='NO_SETUP', maxDepth=4): AIPlayer.__init__(self, name, tag, color, setup) self.maxDepth = maxDepth random.seed()
def __init__(self, name='Simple AI', tag='*', color=colors['MAGENTA'], setup='NO_SETUP'): AIPlayer.__init__(self, name, tag, color, setup) random.seed()
def __init__(self, name='Easy AI', tag='!', color=colors['GREEN'], setup='NO_SETUP'): AIPlayer.__init__(self, name, tag, color, setup) random.seed()
'''
(／‵Д′)／~ ╧╧
'''
def __init__(self, players, initial_state):
raise NotImplementedError("To be implemented ?!")
def run(self, n_turns=200):
for t in range(n_turns):
p = self.state.now_player
act = p.action(self.state)
self.state = self.state.next_turn(p, act)
class Player:
@property
def name(self):
raise NotImplementedError("To be implemented 好神")
def h(self, state, action_taken=None):
raise NotImplementedError("To be implemented duckingod")
def action(self, state):
raise NotImplementedError("To be implemented QAQ")
if __name__=='__main__':
from ai import AIPlayer, Beam
players = [
AIPlayer('Alpha', Beam()),
AIPlayer('Beta', Beam())
]
initial_state = State()
game = Game(players, initial_state)
game.run()
if __name__ == '__main__':
if args.game == 'ttt':
#model = TicTacToeNet(pass_through_states=args.pass_through,
# sideways_net=args.sideways_net)
modeltype = TicTacToeNet
gametype = TicTacToeGame
humantype = HumanTicTacToePlayer
elif args.game == 'C4':
#model = ConnectFourNet(pass_through_states=args.pass_through,
# sideways_net=args.sideways_net)
modeltype = ConnectFourNet
gametype = ConnectFourGame
humantype = HumanConnectFourPlayer
ref_model = torch.load(args.reference)
ref_ai = AIPlayer(model=ref_model, max_states=args.max_states)
files = os.listdir(args.dir)
eps = []
for fn in files:
_, fn = fn.split('_')
fn, _ = fn.split('.')
eps += [int(fn)]
eps.sort()
winrates = []
for ep in eps:
model = torch.load(os.path.join(args.dir, 'model_{}.dat'.format(ep)))
test_ai = AIPlayer(model=model, max_states=args.max_states)
nwins = 0.
ngames = args.sample_games
for sample in range(ngames):
def ai_player(self, ai_difficulty=8): bot = AIPlayer(ai_difficulty=ai_difficulty) return bot
def start(self):
self.players = [AIPlayer(), Player()]
self.deal()
print("game started")
action = np.random.randint(0, 4)
else: # choose best action from Q(s,a) values
action = np.argmax(qval)
# Take action, observe new state S'
score = game.play_move(state, action, randomState)
# Observe reward
reward = game.get_reward(state, score)
# Get max_Q(S',a)
newQ = model.predict(state.reshape(1, 16), batch_size=1)
maxQ = np.max(newQ)
y = np.zeros((1, 4))
y[:] = qval[:]
if score == 0:
update = np.exp(c)
else:
update = score + gamma * maxQ
y[0][action] = update # target output
model.fit(state.reshape(1, 16), y, batch_size=1, nb_epoch=1, verbose=0)
if score == 0:
status = 0
if i % 10 == 0:
print("Game #: %s Score: %s" % (i, c))
epsilon -= 1 / epochs
randomState = np.random.RandomState(0)
GameHandler(size=4, player=AIPlayer(model), state=randomState)
def start(self):
self.move_duration = 0.35
self.ai = AIPlayer(self)
self.on_every_move()
if __name__ == '__main__':
if args.game == 'ttt':
model = TicTacToeNet(pass_through_states=args.pass_through,
sideways_net=args.sideways_net)
gametype = TicTacToeGame
humantype = HumanTicTacToePlayer
elif args.game == 'C4' or args.game == 'c4':
model = ConnectFourNet(pass_through_states=args.pass_through,
sideways_net=args.sideways_net)
gametype = ConnectFourGame
humantype = HumanConnectFourPlayer
if args.load:
model = torch.load(args.load)
ai = AIPlayer(0, lambda x: x, model, max_states=args.max_states)
if args.train:
ai.train_iterations = args.nepochs
for game_num in range(args.ngames):
training_game = gametype()
training_game.registerPlayer(ai)
training_game.registerPlayer(ai)
training_game.start(display=False)
print('finished %d games' % (game_num+1))
if args.save and game_num % args.save_interval == 0:
torch.save(model, os.path.join(args.save, 'model_{}.dat'.format(game_num) ) )
else:
human = humantype()
