def menu():
fast = False
if fast:
board = generate_board(3)
return Game([Player("p1"), Player("p2")], board)
players = []
print(
'''Entre respectivamente o tamanho da quadra que voce quer usar, um valor de 3 a 10,
e o qantidade de jogadores que vao jogar. Minimo 2, maximo 5, para sair digite sair a qualquer momento'''
)
while True:
board_size = int(input('Tamanho do tabuleiro: '))
if 2 < board_size <= 10:
break
while True:
pos = len(players)
player_name = input('Nome do jogador ' + (pos + 1).__str__() + ": ")
players.append(Player(player_name))
# verifica se o tamanho do tabuleiro é 3 e se tem 2 jogadores e continua o jogo, fica impossivel
# jogar com mais de dois jogadores no mesmo tabuleiro
if board_size.__eq__(3) and len(players).__eq__(2):
break
if board_size > 3 and len(players) >= 2:
more = input('Continuar(S/N)? ')
if more.upper().__eq__("N"):
break
board = generate_board(board_size)
return Game(players, board)
def reset_game(self):
try:
self.model = Game(int(self.size.get()), int(self.num_mines.get()))
except ValueError:
self.model = Game()
self.view.reset_view(self.model, self.reveal_field)
def test_game_fire(self, MockShip):
ship = MockShip()
ship.is_dead.return_value = False
rules = Rules(mode='standard', opponent='human')
player1 = Player('p1')
player2 = Player('p2')
player2.ships.append(ship)
g = Game(1, player1, player2, rules)
ship.is_hit.return_value = True
expected = True
actual = g.fire(Coordinates('a', 1))
self.assertEqual(expected, actual)
g = Game(1, player1, player2, rules)
ship.is_hit.return_value = False
expected = False
actual = g.fire(Coordinates('b', 3))
self.assertEqual(expected, actual)
expected = False
actual = g.fire(Coordinates('i', 10))
self.assertEqual(expected, actual)
def init_game(self, mode):
game = Game()
controller = Controller(game)
ai = AI(game)
first_player = Player(PieceColor.WHITE, controller,
ai if mode == GameMode.AI_VS_HUMAN else None)
second_player = Player(PieceColor.BLACK, controller,
ai if mode == GameMode.HUMAN_VS_AI else None)
players = [first_player, second_player]
game_board = GameBoardWidget(game)
for player in players:
if player.type == PlayerType.HUMAN:
game_board.move_receive_from_ui.append(
player.move_receive_from_ui_handler)
if first_player.type == PlayerType.AI:
first_player.move_complete_event(PieceColor.BLACK)
Clock.schedule_interval(lambda delta_time: game_board.update(), 0.03)
self.clear_widgets()
game_widget = GameWidget(game)
size = (game_board.width, game_board.height + 50)
game_widget.size = size
Window.size = size
game_widget.set_game_board(game_board)
self.add_widget(game_widget)
def test_npc_interaction():
"""
start
|
w1 <- dialog becomes available
|
end
"""
game = Game('test')
start = Waypoint(game.graph, 'start')
w1 = Waypoint(game.graph, 'w1')
end = Waypoint(game.graph, 'end')
start.add_destination(w1)
w1.add_destination(end)
game.set_start(start)
npc_dialog = Dialog()
ds = Mail(npc_dialog.graph, 'test subject', 'test body')
with pytest.raises(PlayerStateException):
NonPlayableCharacter('test', 'npc', npc_dialog)
npc_dialog.set_start(ds)
npc_dialog.start.waypoints.append(w1)
game.add_non_playable_character(NonPlayableCharacter('test', 'npc', npc_dialog))
instance = game.create_new_game()
instance.add_player(Player('test', 'player'), 'testy', 'mctestpants')
assert len(instance.npc_states) == 1
assert ds not in [k for k, _ in instance.player_states[0].inventory.values()]
interactions = instance.player_states[0].move_to(w1)
assert len(interactions.keys()) == 1 and len(interactions.values()) == 1
def test_create_and_delete_game(wait_for_api, create_clean_db, client):
# create our game
game = Game('test')
start = Waypoint(game.graph, 'start')
w1 = Waypoint(game.graph, 'w1')
w2 = Waypoint(game.graph, 'w2', items=['some item'])
end = Waypoint(game.graph, 'end')
start.add_destination(w1)
task = Task(w2, 'test description', 'test text', 'answer')
w1.add_task(task)
w2.add_destination(end)
game.set_start(start)
# create user
lg = client.post(
f"{ROOT_URL}/register", json=default_account
)
assert lg.status_code == 201
token = json.loads(lg.data)
# convert it to an API object
game_data = generate_api_game(game)
lg = client.post(
f"{ROOT_URL}/games", json=game_data, headers={'X-TOKEN': token}
)
assert lg.status_code == 201
lg = client.get(
f"{ROOT_URL}/games"
)
assert lg.status_code == 200
assert game.title in [g['title'] for g in lg.data]
def test_player_at_another_game(mocker):
ps, gs = setup()
data = copy.deepcopy(GAME_DICT)
# Game starts
data["state"] = GameState.PLAYING
gs[1].update(**data)
data["state"] = GameState.OPEN
data["uid"] = 2
data["teams"] = {1: ["Guy"]}
g2 = Game(playerset=ps, **data)
gUpd = mocker.Mock()
ps[1].newCurrentGame.connect(gUpd)
gs[2] = g2
gUpd.assert_called_with(ps[1], g2, gs[1])
gUpd.reset_mock()
# Test if closing the first game changes player state
data = copy.deepcopy(GAME_DICT)
data["state"] = GameState.CLOSED
gs[1].update(**data)
assert not gUpd.called
def create(id):
details = game_data.details(id)
game = Game(key_name=str(id), genres=[])
if details:
game.name = details['name']
game.genres = details['genres']
game.put()
def _build_hosted_game(self, main_mod, mapname=None):
if mapname is None:
mapname = util.settings.value("fa.games/gamemap", "scmp_007")
if self._me.player is not None:
host = self._me.player.login
else:
host = "Unknown"
title = util.settings.value("fa.games/gamename", host + "'s game")
friends_only = util.settings.value("friends_only", False, type=bool)
return Game(
playerset=self._playerset,
uid=0, # Mock
state=GameState.OPEN, # Mock
launched_at=None,
num_players=1,
max_players=12,
title=title,
host=host,
mapname=mapname,
map_file_path="", # Mock
teams={1: [host]},
featured_mod=main_mod,
featured_mod_versions={},
sim_mods={},
password_protected=False, # Filled in later
visibility=(GameVisibility.FRIENDS
if friends_only else GameVisibility.PUBLIC))
def test_game_at_missing_player(mocker):
ps = Playerset()
gs = Gameset(ps)
p = Player(**{"id_": 1, "login": "******"})
ps[p.id] = p
p = Player(**{"id_": 2, "login": "******"})
ps[p.id] = p
data = copy.deepcopy(GAME_DICT)
g1 = Game(playerset=ps, **data)
pAdd = mocker.Mock()
g1.connectedPlayerAdded.connect(pAdd)
gs[1] = g1
assert len(g1.players) == 3
gps = [g1.to_player(n) for n in g1.players if g1.is_connected(n)]
assert len(gps) == 2
assert ps[1] in gps
assert ps[2] in gps
assert not pAdd.called
p = Player(**{"id_": 3, "login": "******"})
ps[p.id] = p
pAdd.assert_called_with(g1, ps[3])
gps = [g1.to_player(n) for n in g1.players if g1.is_connected(n)]
assert len(gps) == 3
assert ps[3] in gps
assert g1.is_ingame(ps[3].login)
assert ps[3].currentGame is g1
def test_player_at_game_change(mocker):
ps = Playerset()
gs = Gameset(ps)
p = Player(**{"id_": 1, "login": "******"})
ps[p.id] = p
p = Player(**{"id_": 2, "login": "******"})
ps[p.id] = p
p = Player(**{"id_": 3, "login": "******"})
ps[p.id] = p
data = copy.deepcopy(GAME_DICT)
g1 = Game(playerset=ps, **data)
gUpd = mocker.Mock()
ps[1].newCurrentGame.connect(gUpd)
gs[1] = g1
gUpd.assert_called_with(ps[1], g1, None)
gUpd.reset_mock()
data["state"] = GameState.PLAYING
gs[1].update(**data)
assert not gUpd.called
data["state"] = GameState.CLOSED
gs[1].update(**data)
gUpd.assert_called_with(ps[1], None, g1)
def test_simple_graph_generation():
game = Game('test')
start = Waypoint(game.graph, 'start')
end = Waypoint(game.graph, 'end')
start.add_destination(end)
assert len(game.graph.nodes) == 2
assert len(game.graph.edges) == 1
assert not game.start_is_set()
def test_turn_board_with_lines(self):
game = Game()
board = game.gameState.board.copy()
game.gameState.board[18, 5] = 1
game.gameState.board[28, 6] = 1
board[30, 2] = 1
board[20, 1] = 1
self.assertEqual(
turn_board(game.gameState.board).tolist(), board.tolist())
def test_is_game_over(self, MockShip):
ship = MockShip()
ship.is_dead.return_value = False
player1 = Player('p1')
player2 = Player('p2')
rules = Rules(mode='standard', opponent='human')
g = Game(1, player1, player2, rules)
self.assertTrue(g.is_game_over())
player1.ships.append(ship)
g = Game(1, player1, player2, rules)
self.assertTrue(g.is_game_over())
player2.ships.append(ship)
g = Game(1, player1, player2, rules)
self.assertFalse(g.is_game_over())
def train(self, rounds: int) -> None:
for i in range(rounds):
initial_state = self._choose_initial_state()
# safe, because of acyclic Markov Process
self._pi[initial_state] = np.random.choice(list(Action))
game = Game(player_policy=self.policy)
game_info = game.play_starting_in(initial_state)
self._update_with(game_info)
def __init__(self):
self.root = tk.Tk()
self.size = tk.StringVar()
self.num_mines = tk.StringVar()
self.size.set(6)
self.num_mines.set(3)
self.model = Game(int(self.size.get()), int(self.num_mines.get()))
self.view = MainWindow(self.root, self.model, self.reveal_field, self.reset_game, self.size, self.num_mines)
def main():
args = parse_args()
field_io = FieldIO(FileSerializer())
field = field_io.load_from_file(args.field)
game = Game(field)
ui = UI(game, UISerializer())
ui.run(args.tick_time, args.confirm)
if args.save:
field_io.save_to_file(args.save, game.field)
print('Field saved.')
def test_adding_task_adds_path():
game = Game('test')
start = Waypoint(game.graph, 'start')
end = Waypoint(game.graph, 'end')
task = Task(end, 'test description', 'test text', 'answer')
start.add_task(task)
game.set_start(start)
assert len(game.graph.nodes) == 2
assert len(game.graph.edges) == 1
assert game.start_is_set()
def test_game_next_player(self):
rules = Rules(mode='standard', opponent='human')
p1 = Player('p1')
p2 = Player('p2')
g = Game(1, p1, p2, rules)
expected = p2
actual = g.next_player()
self.assertEqual(expected, actual)
def game():
"""
start (path with dialog)
/ \
w1 (m1) w2 (d1)
\ /
knot1
/ | \
w3 w4 w5 <- with task t1,t2,t3
\ |
end <- task from dialog td1
:return: game with described graph
"""
#TODO, check interaction model in waypoint
dialog = Dialog()
dialog_start = Mail(dialog.graph, 'start sub', 'start body')
m1 = Mail(dialog.graph, 'second sub', 'second body')
td1 = Task(None, 'some task 1', 'some task', 'some solution')
d1 = Speech(dialog.graph, 'content', task=td1)
game = Game('test')
start = Waypoint(game.graph, 'start')
w1 = Waypoint(game.graph, 'w1')
w2 = Waypoint(game.graph, 'w2')
knot = Waypoint(game.graph, 'knot')
w3 = Waypoint(game.graph, 'w3')
t1 = Task(w3, 'some task 1', 'some task')
w4 = Waypoint(game.graph, 'w4')
t2 = Task(w4, 'some task 2', 'some task')
w5 = Waypoint(game.graph, 'w5')
t3 = Task(w5, 'some task 3', 'some task')
end = Waypoint(game.graph, 'end')
start.add_destination(w1, 1.1)
start.add_destination(w2)
w1.add_destination(knot)
w2.add_destination(knot)
knot.add_task(t1)
knot.add_task(t2)
knot.add_task(t3)
w3.add_destination(end)
w4.add_destination(end)
game.set_start(start)
dialog_end = Speech(dialog.graph, 'next content', destination=end)
dialog.set_start(dialog_start)
dialog_start.add_follow_up(d1)
dialog_start.add_follow_up(m1)
dialog_start.waypoints.append(start)
d1.add_follow_up(dialog_end, None)
game.add_non_playable_character(NonPlayableCharacter(
'bob', 'test', dialog))
return game
def __init__(self, view):
self.__game = Game()
self.__view = view
self.__view.set_info("Next player: {}".format(self.__game.next_player))
self.__view.connect('cell-clicked', self.on_cell_clicked)
self.__view.connect('new-game', self.on_new_game)
self.__view.connect('destroy', Gtk.main_quit)
self.__view.show_all()
def get_or_create(id):
game = Game.get_by_key_name(str(id))
if game:
return game
details = game_data.details(id)
game = Game(key_name=str(id), genres=[])
if details:
game.name = details['name']
game.genres = details['genres']
game.put()
return game
def test_allowed_actions_after_by_corner(self):
game = Game()
board = game.gameState.board.copy()
board[26, 4] = 1
board[30, 5] = 1
board[33, 6] = 1
board[38, 6] = 1
board[37, 7] = 1
board[36, 7] = 1
allowed = {(39, 7), (34, 7)}
self.assertEqual(set(game.gameState.allowed_actions(board, (9, 8))),
allowed)
def test_turn_board_with_broad_lines(self):
game = Game()
board = game.gameState.board.copy()
game.gameState.board[4, 0] = 1
game.gameState.board[42, 0] = 1
game.gameState.board[6, 7] = 1
board[44, 7] = 1
board[6, 7] = 1
board[42, 0] = 1
self.assertEqual(
turn_board(game.gameState.board).tolist(), board.tolist())
def new_game():
print(request.form)
host_name = 'Host'
presentation_file = request.files['presentation_file']
host = Player(host_name)
game = Game(host)
game.load_presentation(presentation_file)
redis_client.set(f'stopwatch.{game.id}', pickle.dumps(epoch()))
save_game(game)
return jsonify(game_id=game.id, player_id=host.id)
def build_game_with_2maps_winning_picks_team1_and_team3():
game = Game(None, team1.id_team, team3.id_team, None, 2, 1, team1.id_team,
3, "Mapa 1", "Mapa 2", "", "", "Mapa 3", team1.actual_rank,
team3.actual_rank)
game.team1 = team1
game.team2 = team3
map1 = Map(game.id_game, "Mapa 1", 9, 6, 7, 6, 0, 0, 16, 12)
map2 = Map(game.id_game, "Mapa 2", 8, 7, 8, 4, 0, 0, 16, 11)
game.maps = [map1, map2]
return game
def draw_board(self, board):
lines = self.get_all_lines(board)
self.set_game_window()
self.agent = self.bot
self.env = Game()
self.board = Board(self.window)
self.board.draw_board()
self.board.color_current_point()
self.board.color_allowable_points()
self.board.canvas.pack(fill="both", expand=True)
self.board.draw_lines(lines)
self.window.mainloop()
def play_valid(p1, p2, episodes, random_moves=0):
"""
plays matches between players to analyse results
@param p1: player 1
@param p2: player 2
@param episodes: number of games
@param random_moves: number of random moves at the beginning of the match
@return: dictionary with games results
"""
env = Game()
players = {1: p1, -1: p2}
scores = {
p1.name: 0,
p2.name: 0,
'starting_player': 0,
'non-starting_player': 0,
}
for e in range(int(episodes / 2)):
log_important('First half, game ', e)
env.reset()
env.currentPlayer = 1
done, result = 0, 0
turn = 0
while done == 0:
move = players[env.currentPlayer].get_move(env, turn, random_moves)
done, result = env.make_move(move)
if done == 1:
scores[players[env.currentPlayer].name] += max(0, result)
scores[players[-env.currentPlayer].name] += max(0, -result)
env.change_player()
turn += 1
scores['starting_player'] = scores[p1.name] - scores[p2.name]
scores['non-starting_player'] = int(
episodes / 2) - scores[p1.name] + scores[p2.name]
for e in range(int(episodes / 2)):
log_important('Secound half, game ', e)
env.reset()
env.change_player()
done, result = 0, 0
turn = 0
while done == 0:
move = players[env.currentPlayer].get_move(env, turn, random_moves)
# print(move[0],' ',move[1])
done, result = env.make_move(move)
if done == 1:
scores[players[env.currentPlayer].name] += max(0, result)
scores[players[-env.currentPlayer].name] += max(0, -result)
env.change_player()
turn += 1
scores['starting_player'] += scores[p2.name]
scores['non-starting_player'] += int(episodes / 2) - scores[p2.name]
return scores
def test_pickling(self):
game = Game(PlayerId.ONE, seed=2)
self.assertEqual(Suit.DIAMONDS, game.game_state.trump)
actions = [
# Player TWO wins the first trick. Score: 0-6.
PlayCardAction(PlayerId.TWO, Card(Suit.HEARTS, CardValue.JACK)),
PlayCardAction(PlayerId.ONE, Card(Suit.CLUBS, CardValue.KING)),
# Player TWO closes the talon.
CloseTheTalonAction(PlayerId.TWO),
# Player TWO wins the second trick. Score: 0-18.
PlayCardAction(PlayerId.TWO, Card(Suit.DIAMONDS, CardValue.TEN)),
PlayCardAction(PlayerId.ONE, Card(Suit.DIAMONDS, CardValue.JACK)),
# Player TWO wins the third trick. Score: 0-31.
PlayCardAction(PlayerId.TWO, Card(Suit.HEARTS, CardValue.TEN)),
PlayCardAction(PlayerId.ONE, Card(Suit.SPADES, CardValue.QUEEN)),
# Player ONE wins the forth trick. Score: 13-31.
PlayCardAction(PlayerId.TWO, Card(Suit.CLUBS, CardValue.JACK)),
PlayCardAction(PlayerId.ONE, Card(Suit.CLUBS, CardValue.ACE)),
# Player TWO wins the fifth trick. Score: 13-52.
PlayCardAction(PlayerId.ONE, Card(Suit.SPADES, CardValue.TEN)),
PlayCardAction(PlayerId.TWO, Card(Suit.SPADES, CardValue.ACE)),
# Player TWO wins the sixth trick. Score: 13-67.
PlayCardAction(PlayerId.TWO, Card(Suit.HEARTS, CardValue.ACE)),
PlayCardAction(PlayerId.ONE, Card(Suit.SPADES, CardValue.KING))
]
for action in actions[:8]:
game.play_action(action)
self.assertFalse(game.game_state.is_game_over)
self.assertEqual(PlayerPair(0, 31), game.game_state.trick_points)
self.assertFalse(game.game_state.is_to_lead(PlayerId.ONE))
self.assertFalse(game.game_state.is_to_lead(PlayerId.TWO))
unpickled_game: Game = loads(dumps(game))
self.assertEqual(unpickled_game.game_state, game.game_state)
self.assertFalse(unpickled_game.game_state.is_game_over)
self.assertFalse(unpickled_game.game_state.is_to_lead(PlayerId.ONE))
for action in actions[8:]:
unpickled_game.play_action(action)
self.assertTrue(unpickled_game.game_state.is_game_over)
self.assertEqual(PlayerPair(13, 67),
unpickled_game.game_state.trick_points)
self.assertEqual(PlayerPair(0, 3),
unpickled_game.game_state.game_points)
def get_tags(app_id, name):
url_tags = 'http://store.steampowered.com/app/%s' % (app_id)
response_tags = urlfetch.fetch(url_tags, deadline=60).content
tags = []
glance_tags = bs(response_tags).find("div", {"class": "glance_tags"})
if glance_tags:
tag_elements = glance_tags.findAll("a", {"class": "app_tag"})
for tag_element in tag_elements:
tag = tag_element.string.strip()
tags.append(tag)
Tag(key_name=tag).put()
Game(key_name=str(app_id), name=name, tags=tags).put()
