def onGameStarted(self, goingFirst=True):
self.isFirstPlayer = goingFirst
# Set up game state information
if goingFirst:
self.game = Game(self.faction, self.enemyFaction)
self.player, self.enemy = self.game.players
else:
self.game = Game(self.enemyFaction, self.faction)
self.enemy, self.player = self.game.players
self.hasMulliganed = False
self.bothPlayersMulliganed = False
self.toMulligan = []
# Set up the game UI
if isinstance(self.player, templars.Templar):
self.guiScene = templarHud.TemplarHud()
elif isinstance(self.player, mariners.Mariner):
self.guiScene = marinerHud.MarinerHud()
elif isinstance(self.player, thieves.Thief):
self.guiScene = thiefHud.ThiefHud()
elif isinstance(self.player, fae.Faerie):
self.guiScene = faerieHud.FaerieHud()
else:
self.guiScene = hud.GameHud()
self.zoneMaker = ZoneMaker()
self.hasFirstPlayerPenalty = goingFirst
def test_policy2(self):
game = Game()
game.make_move((6, 2), (4, 2))
move = ((1, 2), (3, 2))
self.assertEqual(
NNet._get_policy(NNet._to_policy_vector(move, 'black'),
game.state)[move], 1)
def play_games(black: AI, white: AI):
players = {"B": black, "W": white}
engines = {"B": black.get_engine(), "W": white.get_engine()}
tag = f"{black.name} vs {white.name}"
try:
game = Game(Logger(), engines, {"init_size": BOARDSIZE})
game.root.add_list_property("PW", [white.name])
game.root.add_list_property("PB", [black.name])
start_time = time.time()
while not game.ended:
p = game.current_node.next_player
move = ai_move(game, players[p].strategy, players[p].ai_settings)
while not game.current_node.analysis_ready:
time.sleep(0.001)
game.game_id += f"_{game.current_node.format_score()}"
print(
f"{tag}\tGame finished in {time.time()-start_time:.1f}s {game.current_node.format_score()} -> {game.write_sgf('sgf_selfplay/')}",
file=sys.stderr)
score = game.current_node.score
if score > 0.3:
black.elo_comp.beat(white.elo_comp)
elif score > -0.3:
black.elo_comp.tied(white.elo_comp)
results[tag].append(score)
all_results.append((black.name, white.name, score))
except Exception as e:
print(f"Exception in playing {tag}: {e}")
print(f"Exception in playing {tag}: {e}", file=sys.stderr)
traceback.print_exc()
traceback.print_exc(file=sys.stderr)
def main():
game = Game("Game", 320, 240, 3)
game.assets_manager.load_images({
"bg": "assets/background.png",
"player": "assets/player.png",
"wall": "assets/wall.png"
})
level = Level("wall", GRID_SIZE)
player = Player(game, "player", 150, 50)
player.keyboard = game.keyboard
player.level_colliders = level.get_colliders()
def update(delta_time):
player.update(delta_time)
draw()
def draw():
for bg_x in range(int(game.width / GRID_SIZE)):
for bg_y in range(int(game.height / GRID_SIZE)):
game.display.draw("bg", bg_x * GRID_SIZE, bg_y * GRID_SIZE)
game.draw(level)
game.draw(player)
game.update = update
game.run()
def test_game_result(self):
'''
This test will simulate n games between a computer and a human where
n is determing by the NUMBER_OF_GAMES settings and make sure that the computer never loses
'''
for i in xrange(NUMBER_OF_GAMES):
board = [0] * 9
game = Game(board)
while True:
available_moves = game.get_blank_boxes()
# Make a random player move
box = choice(available_moves)
game.make_move(box, PLAYER)
result, winning_combination = game.check_game_over()
if result:
break
# Make computer's move
box = game.best_next_move(COMPUTER)
game.make_move(box, COMPUTER)
result, winning_combination = game.check_game_over()
if result:
break
self.assertIsNot(result, PLAYER)
def main():
"""
Entry part of game
"""
game = Game()
game.start()
def main():
juego = Game(WIN)
clock = pygame.time.Clock()
run = True
WIN.blit(OPENING, (0, 0))
print(OPENING.get_width())
pygame.display.flip()
sleep(5)
while run:
clock.tick(FPS)
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
col, row = piece_position(event.pos)
juego.select(col, row)
if event.type == pygame.MOUSEBUTTONDOWN and event.button == 3:
juego.restart()
if event.type == pygame.QUIT:
run = False
juego.draw()
def test_ko(self):
b = Game(MockKaTrain(), MockEngine(), {}, board_size=9)
for move in ["A2", "B1"]:
b.play(Move.from_gtp(move, player="B"))
for move in ["B2", "C1"]:
b.play(Move.from_gtp(move, player="W"))
b.play(Move.from_gtp("A1", player="W"))
assert 4 == len(self.nonempty_chains(b))
assert 4 == len(b.stones)
assert 1 == len(b.prisoners)
with pytest.raises(IllegalMoveException) as exc:
b.play(Move.from_gtp("B1", player="B"))
assert "Ko" in str(exc.value)
b.play(Move.from_gtp("B1", player="B"), ignore_ko=True)
assert 2 == len(b.prisoners)
with pytest.raises(IllegalMoveException) as exc:
b.play(Move.from_gtp("A1", player="W"))
b.play(Move.from_gtp("F1", player="W"))
b.play(Move(coords=None, player="B"))
b.play(Move.from_gtp("A1", player="W"))
assert 3 == len(b.prisoners)
def test_too_many_players(self):
player_names = [
"Watson", "Walace", "Profet", "Grant", "Buss", "Lenski",
"Dobzhansky"
]
self.assertRaises(ValueError, lambda: Game(player_names))
def test_collide(self):
b = Game(MockKaTrain(), MockEngine(), {}, board_size=9)
b.play(Move.from_gtp("B9", player="B"))
with pytest.raises(IllegalMoveException):
b.play(Move.from_gtp("B9", player="W"))
assert 1 == len(self.nonempty_chains(b))
assert 1 == len(b.stones)
assert 0 == len(b.prisoners)
def test_merge(self):
b = Game(MockKaTrain(), MockEngine(), {}, board_size=9)
b.play(Move.from_gtp("B9", player="B"))
b.play(Move.from_gtp("A3", player="B"))
b.play(Move.from_gtp("A9", player="B"))
assert 2 == len(self.nonempty_chains(b))
assert 3 == len(b.stones)
assert 0 == len(b.prisoners)
def start_game(self, player, first_turn, **kwargs):
""" starts a new game """
self.game = Game(human=player)
if first_turn:
self.status = self.GAME_STATUS_HUMAN_MOVE_REQUIRED
return self.check_status(self.game.human, {'status': True, 'info': ''})
else:
self.status = self.GAME_STATUS_COMP_MOVE_REQUIRED
return self._play_comp_move()
def main():
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.DEBUG,
datefmt='%Y/%m/%d %H:%M:%S')
#filename=... # logging.config.fileConfig(fname, defaults=None, disable_existing_loggers=True)
# https://docs.python.org/3/library/logging.config.html#module-logging.config
log.info("Game started")
Game().run()
log.info("Game finished")
def main():
logging.basicConfig()
client1 = c.Client(g.MUSTARD, 'www.mocky.io/v2', '')
client2 = c.Client(g.SCARLET, 'www.mocky.io/v2', '')
client3 = c.Client(g.WHITE, 'www.mocky.io/v2', '')
game = Game([client1, client2, client3])
game.take_turn()
game.take_turn()
game.take_turn()
print('Done!')
def _do_new_game(self, move_tree=None, analyze_fast=False):
self.engine.on_new_game() # clear queries
self.game = Game(self,
self.engine,
self.config("game"),
move_tree=move_tree,
analyze_fast=analyze_fast)
self.controls.select_mode("analyze" if move_tree and
len(move_tree.nodes_in_tree) > 1 else "play")
self.controls.graph.initialize_from_game(self.game.root)
self.update_state(redraw_board=True)
def __init__(self, m):
self.screen = pygame.display.set_mode((width, height),
pygame.DOUBLEBUF)
self.manager = m
self.bg = Base().isurf(pygame.Surface(self.screen.get_size()),
(0, 0)).render((0, 0, 0))
self.ms = [
Game(),
]
self.fps = fps
self.clock = pygame.time.Clock()
self.stat = Stat(self.clock, (0, 255, 0))
def setUp(self):
self.game = Game()
self.state = State(c.EMPTY_BOARD)
self.state.board[1][2] = 'white_knight'
self.state.board[5][7] = 'black_knight'
self.state.board[3][3] = 'white_pawn'
self.state.board[3][4] = 'black_king'
self.state.pieces['white_knight'].add((1, 2))
self.state.pieces['black_knight'].add((5, 7))
self.state.pieces['white_pawn'].add((3, 3))
self.state.pieces['black_king'].add((3, 4))
def _onCreateButtonClicked(self):
if self.state == MainWindow.STATE_GAME_HALL_GAME_LIST or \
self.state == MainWindow.STATE_GAME_HALL_GAME_SELECTED:
self._setState(MainWindow.STATE_GAME_HALL_MAP_LIST)
elif self.state == MainWindow.STATE_GAME_HALL_MAP_SELECTED:
self.selectedGame = Game(
-1, Game.randomGameName(), self.selectedMap,
self.leftPanel.gameHallPanel.playerName.text())
self.selectedGame.addPlayer(
Player(-1, self.leftPanel.gameHallPanel.playerName.text()))
self.selectedGame.createGame()
self._setState(MainWindow.STATE_GAME_ROOM_WAITING)
else:
qFatal('Invalid state %d when create button clicked' % self.state)
def start():
pygame.init()
pygame.display.set_caption('PyDungeon')
size = width, height = (640, 480)
game = Game()
game.setup_default_components(size)
scene = game.scene
tilemap = Entity()
scene.add_entity(tilemap)
tilemap.add_component(NameComponent("tilemap"))
tilemap.add_component(TransformComponent(Vector2(0, 0)))
ts = TileSet()
ts.load("assets/tileset.png", "assets/tileinfo.info")
tm = TileMap(ts, size)
mp = [[["floor_" + str(random.randrange(1, 8))] for _ in range(24)]
for _ in range(24)]
PyDungeons.build_wall_rect(mp, pygame.Rect(2, 2, 10, 10))
tm.load_letters(mp)
tilemap.add_component(tm)
tilemap.add_component(
TileMapCollider(
tm, ["wall_mid", "wall_side_mid_right", "wall_side_mid_left"]))
tilemap.add_component(RendererComponent(TileMapRenderer(), size))
player = Entity()
scene.add_entity(player)
player.add_component(NameComponent("player"))
key_bindings = [[pygame.K_a], [pygame.K_d], [pygame.K_w], [pygame.K_s]]
player.add_component(MoveComponent(1, 2))
player.add_component(KeyControlComponent(key_bindings))
#player.add_component(ScreenBoundsCollisionHandler(pygame.Rect(0, 0, width, height)))
player.add_component(TransformComponent(Vector2(100, 100)))
player.add_component(BoxCollider((16 * 2, 22 * 2), Vector2(0, 12)))
player.add_component(
RendererComponent(TileRenderer(ts.tiles["knight_f_idle_anim"], ts),
(16 * 2, 28 * 2)))
#player.add_component(RendererComponent(ImageRenderer("assets/tileset.png"), (1000, 1000)))
game.add_component(ExitOnEscape())
game.run()
def test_snapback(self):
b = Game(MockKaTrain(), MockEngine(), {}, board_size=9)
for move in ["C1", "D1", "E1", "C2", "D3", "E4", "F2", "F3", "F4"]:
b.play(Move.from_gtp(move, player="B"))
for move in ["D2", "E2", "C3", "D4", "C4"]:
b.play(Move.from_gtp(move, player="W"))
assert 5 == len(self.nonempty_chains(b))
assert 14 == len(b.stones)
assert 0 == len(b.prisoners)
b.play(Move.from_gtp("E3", player="W"))
assert 4 == len(self.nonempty_chains(b))
assert 14 == len(b.stones)
assert 1 == len(b.prisoners)
b.play(Move.from_gtp("D3", player="B"))
assert 4 == len(self.nonempty_chains(b))
assert 12 == len(b.stones)
assert 4 == len(b.prisoners)
def drawMainMenu(self):
x = self.win.getXSize()
y = self.win.getYSize()
self.background = OnscreenImage(image='textures/main_menu.png')
self.background.setSx(x / y)
clickNewGameButton = lambda: self.push(Game())
clickOptionsButton = lambda: self.push('Options')
clickExitButton = lambda: sys.exit()
def setButtonAttributes(button):
button.setSx(.60)
button.setSz(.26)
button.setTransparency(TransparencyAttrib.MAlpha)
maps = loader.loadModel('textures/continue_maps.egg')
geom = (maps.find('**/continue'),
maps.find('**/continue_click'),
maps.find('**/continue_hover'))
self.newGameButton = DirectButton(geom=geom, relief=None,
command=clickNewGameButton)
setButtonAttributes(self.newGameButton)
self.newGameButton.setPos(0, 0, .6)
maps = loader.loadModel('textures/options_maps.egg')
geom = (maps.find('**/options'),
maps.find('**/options_click'),
maps.find('**/options_hover'))
self.optionsButton = DirectButton(geom=geom, relief=None,
command=clickOptionsButton)
setButtonAttributes(self.optionsButton)
self.optionsButton.setPos(0, 0, .36)
maps = loader.loadModel('textures/exit_maps.egg')
geom = (maps.find('**/exit'),
maps.find('**/exit_click'),
maps.find('**/exit_hover'))
self.exitButton = DirectButton(geom=geom, relief=None,
command=clickExitButton)
setButtonAttributes(self.exitButton)
self.exitButton.setPos(0, 0, .12)
self.hasDrawnMainMenu = True
def test_play_runs_the_correct_methods(self):
board_state = [[None]]
board_state_after_ship_placed = [['AC', 'AC', 'AC', 'AC', 'AC']]
user_shot_choice = 'A1'
ship_orientation = 'row'
shot_result = 'Hit'
current_ship = {
'name': 'Aircraft Carrier',
'size': 5,
'hit_locations': [[0, 0]]
}
self.comp_board = MagicMock()
self.comp_board.state = MagicMock(return_value=board_state)
self.comp_board.add_to_board = MagicMock(
return_value=board_state_after_ship_placed)
self.comp_board.update = MagicMock()
self.comp_board.all_ships = MagicMock(
return_value=self.board_helper.all_ships)
self.validate = MagicMock()
self.validate.shot_result = MagicMock(return_value=('Hit',
current_ship))
self.validate.all_ships_sunk = MagicMock(side_effect=[False, True])
self.ai.shoot_at_board = MagicMock(return_value=('Hit', current_ship))
self.ui.get_input = MagicMock(return_value=user_shot_choice)
self.ui.display = MagicMock()
self.ui.game_board = MagicMock()
self.ui.ship_messages = MagicMock()
new_game = Game(self.comp_board, self.human_board, self.ai, self.ui,
self.validate, self.place)
new_game.play()
self.comp_board.add_to_board.assert_called_with(
self.place, ship_orientation)
self.ui.display.assert_called()
self.comp_board.update.assert_called_with(user_shot_choice,
shot_result)
self.validate.all_ships_sunk.assert_called()
self.ai.shoot_at_board.assert_called_with(self.human_board)
self.ui.game_board.assert_called()
self.ui.ship_messages.assert_called()
def test_capture(self):
b = Game(MockKaTrain(), MockEngine(), {}, board_size=9)
b.play(Move.from_gtp("A2", player="B"))
b.play(Move.from_gtp("B1", player="W"))
b.play(Move.from_gtp("A1", player="W"))
b.play(Move.from_gtp("C1", player="B"))
assert 3 == len(self.nonempty_chains(b))
assert 4 == len(b.stones)
assert 0 == len(b.prisoners)
b.play(Move.from_gtp("B2", player="B"))
assert 2 == len(self.nonempty_chains(b))
assert 3 == len(b.stones)
assert 2 == len(b.prisoners)
b.play(Move.from_gtp("B1", player="B"))
with pytest.raises(IllegalMoveException) as exc:
b.play(Move.from_gtp("A1", player="W"))
assert "Suicide" in str(exc.value)
assert 1 == len(self.nonempty_chains(b))
assert 4 == len(b.stones)
assert 2 == len(b.prisoners)
def request_game():
start_request = StartGameRequest.from_dict(dict(request.args))
player_count = len(APP.waiting_clients)
if player_count < MIN_PLAYERS:
response = StartGameResponse(client_id=start_request.client_id,
game_id='')
return jsonify(response.to_dict())
if player_count > MAX_PLAYERS:
game_clients = APP.waiting_clients[:MAX_PLAYERS - 2]
game_clients.append(APP.get_client(start_request.client_id))
else:
game_clients = APP.waiting_clients
game = Game(game_clients)
APP.games.append(game)
APP.start_game(game.game_id)
response = StartGameResponse(client_id=start_request.client_id,
game_id=game.game_id)
return jsonify(response.to_dict())
def setUp(self):
self.game = Game()
self.state = State(c.EMPTY_BOARD)
self.state.castle_rights = {
'white_king_side': True,
'white_queen_side': True,
'black_king_side': True,
'black_queen_side': True
}
self.state.board[1][3] = 'white_pawn'
self.state.board[7][6] = 'white_pawn'
self.state.board[2][3] = 'black_queen'
self.state.board[7][7] = 'white_rook'
self.state.board[1][2] = 'black_pawn'
self.state.board[7][4] = 'white_king'
self.state.pieces['white_pawn'].add((1, 3))
self.state.pieces['white_pawn'].add((7, 6))
self.state.pieces['black_queen'].add((2, 3))
self.state.pieces['white_rook'].add((7, 7))
self.state.pieces['black_pawn'].add((1, 2))
self.state.pieces['white_king'].add((7, 4))
def testTemplarAbility():
game = Game(templars.Templar, templars.Templar)
p0 = game.players[0]
p1 = game.players[1]
game.start()
# empty mulligans
p0.mulligan()
p1.mulligan()
p0.endTurn(p0.hand[0])
assert len(p0.hand) == 4 # First player penalty
assert p0.manaCap == 3
p1.endTurn(None)
assert len(p1.hand) == 6
assert p1.manaCap == 2
# Try discarding something not in your hand
p0.endTurn(p1.hand[0])
assert len(p1.hand) == 6
assert p0.manaCap == 4
def make_move(request):
"""
Make the human player's move and then calculate and make computer's move
"""
# Load board and move information
board = json.loads(request.GET['board'])
box = int(request.GET['box'].replace("box_", ""))
game_history_id = request.GET['game_history_id']
# Make player's move and check game result
game = Game(board)
game.make_move(box, PLAYER)
game_over, winning_combination = game.check_game_over()
computer_played = False
# If game is still on calculate computer's move and make it
if not game_over:
box = game.best_next_move(COMPUTER)
game.make_move(box, COMPUTER)
computer_played = True
game_over, winning_combination = game.check_game_over()
# If game is over save game history
if game_over:
game_history = GameHistory.objects.get(pk=game_history_id)
game_history.finish_game(game_over)
result = {}
result['computer_played'] = computer_played
result['box'] = str(box)
result['game_over'] = game_over
result['board'] = json.dumps(game.get_board())
# set winning combinations for highlighting
result['winning_combination'] = winning_combination
return HttpResponse(json.dumps(result), mimetype='application/json')
def main():
game = Game()
while True:
winner = game.winner
draw = (len(game.moves()) == 0)
display(game, winner=winner, draw=draw)
if winner or draw:
break
if game.turn % 2 == 0:
# person move
col = wait_key(tuple(map(str, game.moves() + 1)))
game = game.move(int(col) - 1)
# move = tree.get_move(game, tree.position_heuristic, depth=4)
# game = game.move(move)
else:
# calvin move
move = tree.get_move(game, tree.lines_heuristic, depth=4)
game = game.move(move)
def start(size_div=1.0):
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.init()
size = width, height = (25 * 50, 25 * 25)
speed = [2, 2]
black = 0, 0, 0
screen = pygame.display.set_mode(size)
pygame.display.set_caption('Square Jumper')
running = True
game = Game(screen, size)
# Program loop
while running:
game.default_run()
if game.get_level_runner() is not None:
player = game.get_level_runner().player
if not game.key.get(
pygame.K_SPACE
) and not player.is_auto_down and player.get_jump_core(
).is_charged_():
y = player.get_position_y()
player.jump(power=player.get_jump_core().get_jump_power(),
last_y=y)
for event in pygame.event.get():
listen = eventlistener.listener(event=event, game=game)
if isinstance(listen, eventlistener.MouseListener
) and game.get_current_screen() is not None:
if listen.get_type() == pygame.MOUSEBUTTONUP:
game.get_current_screen().on_click(
game=game, where=listen.get_position())
elif listen.get_type() == pygame.MOUSEMOTION:
game.get_current_screen().on_move_mouse(
listen.get_position())
def run_game(self):
"""
Run the game.
Will run the game this program is all about. After the game it will
collect results and possibly list the player in the Highscores list.
"""
g = Game(self.args.level, self.args.questions)
start_time = time()
try:
g.run()
except StopGame:
print '\nbye!'
exit()
endtime = time() - start_time
r = Results(self.args.level, self.args.questions, g.mistakes, endtime)
r.print_results()
Highscores().new(r)
