Пример #1
0
 def test_get_label_h_pairs(self):
     game = Game(3)
     game.shuffle(333)
     clean_tiles = [[(1, 0)], [(2, 0)], [(3, 0)], [(4, 0)], [(5, 0)], [(6, 0)], [(7, 0)], [(8, 0)], [(9, 0)]]
     self.assertNotEqual(game.get_label_h_pairs(), clean_tiles)
     game.tiles = game.generate_tiles(3)
     self.assertEqual(game.get_label_h_pairs(), clean_tiles)
Пример #2
0
def test_possible_to_emerge():
    game = Game()
    game.add_lives(Life(0, 0))
    game.add_lives(Life(1, 0))
    game.add_lives(Life(2, 1))

    assert len(game.get_possible_to_emerge()) == 17
Пример #3
0
    def test_read_message_decreases_messages_count(self):
        self.game = Game(self.questions_storage)
        self.game.next_question()
        start_messages_count = self.game.get_messages_count()

        self.game.read_message()

        self.assertLess(self.game.get_messages_count(), start_messages_count)
Пример #4
0
    def test_request_help_adds_messages(self):
        self.game = Game(self.questions_storage)
        self.game.next_question()
        start_messages_count = self.game.get_messages_count()

        self.game.request_help()

        self.assertGreater(self.game.get_messages_count(),
                           start_messages_count)
Пример #5
0
 def evaluate(self, member):
     scr = pygame.display.set_mode((800, 600))
     ac = choice(self.action)
     g = Game(scr, member, None, ac)
     a = g.start()
     if g.thing.life < 0:
         g.thing.life = 0
     member.fitness = (g.thing.full - g.thing.life) / g.wave
     return member.fitness
Пример #6
0
def main(stdscr):
    with open("result.out") as f:
        game = Game(*json.loads(f.read()))
    if len(sys.argv) > 1 and sys.argv[1] == "-t":
        turn = int(sys.argv[2])-1
    else:
        turn = 0
        
    play_game(stdscr, game, turn=turn)
Пример #7
0
def run():
	args = docopt(__doc__)
	debug.log(args)
	if args['-']:
		story = sys.stdin.read()
	else:
		story = open(args['STORY-FILE'], 'r').read()
	characters = open(args['CHARACTERS-FILE'], 'r').read()
	stats = open(args['STATS-FILE'], 'r').read()
	game = Game(story, characters, stats).start()
Пример #8
0
 def test_slide_tile(self):
     game = Game(3)
     game.tiles = game.generate_tiles(3)
     print(game)
     self.assertFalse(game.slide_tile(1))
     self.assertFalse(game.slide_tile(2))
     self.assertFalse(game.slide_tile(4))
     self.assertTrue(game.slide_tile(8))
     self.assertTrue(game.slide_tile(7))
     self.assertTrue(game.slide_tile(7))
     self.assertTrue(game.slide_tile(8))
    def client_on_message(self, message):
        """
        When the client receive a message
        :param message: The message receive
        :return: None
        """
        messages = Server.Server.decode_message(message)

        for message in messages:
            message = message.split('_')

            if message[0] == MESSAGE_NEED_STATE:
                self.client_send_player_name()
                self.client_send_token()

            elif message[0] == MESSAGE_SEND_NAME_SELECTED:
                self.players_entry_string_variable[0].set(message[1])
                self.name_string_var_trace_write(False)

            elif message[0] == MESSAGE_SEND_TOKEN_SELECTED:
                try:
                    # noinspection PyTypeChecker
                    self.players_tokens[
                        self.opponent_id] = TokenStyle.TokenStyle(
                            int(message[1]))

                    self.players_tokens_images[self.opponent_id] = \
                        self.ui.image_getter.save_token_photos[self.opponent][self.players_tokens[self.opponent_id]]

                    self.players_tokens_labels[self.opponent_id].config(
                        image=self.players_tokens_images[self.opponent_id])
                except ValueError:
                    pass

            elif message[0] == MESSAGE_PLAYER_1_WANT_START:
                self.player_1_want_to_start()

            elif message[0] == MESSAGE_PLAY:
                game = Game.Game(
                    first_player=(TokenState.Player_2,
                                  TokenState.Player_1)[message[1] == "1"])

                self.export_last_game_settings()

                self.ui.change_panel(
                    ServerGamePanel.ServerGamePanel,
                    player_1=Player.Player(
                        TokenState.Player_1, self.players_tokens[0],
                        self.players_entry_string_variable[0].get()),
                    player_2=Player.Player(
                        TokenState.Player_2, self.players_tokens[1],
                        self.players_entry_string_variable[1].get()),
                    is_server=self.create_game,
                    game=game)
Пример #10
0
def test_available_moves():
    g = Game(Strategy(), Strategy())
    s = g.state

    moves = available_moves(s)
    for m in moves:
        new_state = deepcopy(g.state)

        new_state.apply(m)
        new_state.show()

    return moves
Пример #11
0
 def test_check_win_with_uncorrect_positions_0(self):
     test_mas = (
         ("O", "O", 3, 4, 5, 6, 7, 8, "O"),
         (1, "O", 3, "O", 5, "O", 7, 8, 9),
         ("O", "O", 3, "O", 5, 6, 7, 8, 9),
         (1, 2, 3, 4, 5, "O", 7, 8, "O"),
         (1, 2, 3, "O", 5, 6, 7, 8, 9),
         (1, 2, "O", 4, 5, 6, "O", 8, "O"),
         (1, "O", 3, "O", 5, 6, "O", 8, 9),
         ("O", 2, "O", 4, "O", 6, 7, "O", 9),
     )
     for it in test_mas:
         chw = Game(it).check_win()
         self.assertFalse(chw)
Пример #12
0
 def test_check_win_with_uncorrect_positions_X(self):
     test_mas = (
         (1, "X", 3, 4, 5, "X", 7, "X", 9),
         ("X", 2, 3, "X", "X", 6, 7, 8, 9),
         (1, "X", 3, "X", 5, "X", 7, 8, 9),
         ("X", "X", 3, 4, 5, 6, 7, 8, "X"),
         (1, 2, "X", 4, "X", 6, 7, "X", "X"),
         (1, 2, "X", "X", "X", 8, 7, 8, 9),
         (1, 2, "X", "X", 5, "X", "X", 8, 9),
         (1, "X", 3, 4, 5, 6, 7, "X", 9),
     )
     for gb in test_mas:
         chw = Game(gb).check_win()
         self.assertFalse(chw)
Пример #13
0
    def do_start(self, _):
        try:
            self.game = Game(
                player_1=self.player_1,
                player_2=self.player_2,
            )
        except AttributeError as exc:
            if 'player_1' in str(exc):
                self.logger.error("Game cannot start: You need to create the Player 1: p1 <name> .")

            elif 'player_2' in str(exc):
                self.logger.error("Game cannot start: You need to create the Player 2: p2 <name> .")

        except Exception as exc:
            self.logger.error("Error: {}".format(str(exc)))
Пример #14
0
def run(dimensions, turns, terminal=1):
    """ Run a game with the chosen config - accessible through terminal """

    # Run the game
    game = Game(dimensions, turns, terminal)  # debug flag = 1
    strategy1 = Castle(game)
    strategy2 = Ship(game, "~")

    # Opposing strategies
    game.add_strategy(strategy1).add_strategy(strategy2)

    # Choose the board
    print("Welcome to Game of Life Extended (codename golex) v.", game.VERSION)
    print(
        "This game takes GoL to the next level by bringing 2 players (strategies) together and making them fight each other.\n"
    )

    # Start line
    print("Initial configuration with the chosen strategies (", strategy1.SIGN,
          ",", strategy2.SIGN, "):")

    # Set up the initial configuration
    game.build()

    # Make user see what's happening
    if terminal:
        input("Press Enter to continue")

    print("\nProceeding with the simulation...")

    # Iterate through the GoL algorithm
    game.run()

    winner = game.get_winner()

    print("Resulting board:")

    game.print_state()

    print()

    # Show the winner
    print("The winning strategy is '", winner, "'")

    # End line
    print()

    return winner
Пример #15
0
 def game_loop(self):
     while self.running:
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
                 self.running = False
                 sys.exit(0)
             elif event.type == pygame.KEYDOWN:
                 if event.unicode.isalpha():
                     self.entered_name += event.unicode
                 elif event.key == pygame.K_BACKSPACE:
                     self.entered_name = self.entered_name[:-1]
                 elif event.key == pygame.K_RETURN:
                     self.running = False
                     Game(self.entered_name)
         self.display()
         pygame.display.update()
         CLOCK.tick(FPS)
Пример #16
0
def play_game(screen, game, turn=0):
    maxturn = len(game.record)-1
    turn = min(max(turn, 0), maxturn) 
    while True:
        table, score = game.record[turn]
        g = Game(table=table, score=score, size=game.size, turn=turn+1)
        render_info(g, screen)
        render_help(screen)
        action, arg = prompt_key(g, screen)
        if action == "next":
            turn += 1
        elif action == "prev":
            turn -= 1
        elif action == "skip":
            turn = int(arg)-1
            
        elif action == "add":
            turn += int(arg)
        turn = min(max(turn, 0), maxturn)
Пример #17
0
    def __init__(self,
                 master,
                 ui,
                 is_server=False,
                 player_1=Player.Player(TokenState.TokenState.Player_1,
                                        TokenStyle.TokenStyle.Blue),
                 player_2=Player.Player(TokenState.TokenState.Player_2,
                                        TokenStyle.TokenStyle.Green),
                 game=Game.Game()):
        """
        Constructor
        """
        super().__init__(master,
                         ui,
                         player_1,
                         player_2,
                         game,
                         disable_end_button=not is_server)

        self.is_server = is_server

        if self.is_server:
            self.button_main_menu.configure(
                text=self.ui.translation.get_translation("quit"))

            # Set server functions
            self.ui.server.on_message_function = self.server_on_message
            self.ui.server.on_client_connect_function = self.server_on_client_connect_function
            self.ui.server.on_client_disconnect_function = self.server_on_client_disconnect_function

        else:
            tkinter.tix.Label(self.win_text_frame,
                              text=self.ui.translation.get_translation(
                                  "server_game_wait_host")).grid(row=1,
                                                                 column=0)

            # Set client functions
            self.ui.client.on_message_function = self.client_on_message
            self.ui.client.on_connection_function = self.client_on_connection_function
            self.ui.client.on_disconnection_function = self.client_on_disconnection_function
Пример #18
0
def train():
    record = 0
    agent = Agent()
    game = Game(True)
    counter: int = 0
    game.set_game_time(1)
    while True:
        state_old = game.get_state()
        move = agent.get_action(state_old)
        if move == [1, 0, 0]:
            final_move = TriDirections.STRAIGHT
        elif move == [0, 1, 0]:
            final_move = TriDirections.RIGHT
        else:
            final_move = TriDirections.LEFT
        game.set_direction(final_move)
        reward, done, score = game.game_logic()
        if reward == 0:
            counter += 1
        else:
            counter = 0
        state_new = game.get_state()
        if counter > 100:
            done = True
            reward = -10
        if counter > 100:
            game.set_game_time(5)
        agent.train_short_memory(state_old, move, reward, state_new, done)
        agent.remember(state_old, move, reward, state_new, done)
        if done:
            counter = 0
            game.reset()
            agent.n_games += 1
            agent.train_long_memory()
            if score > record:
                record = score
                agent.model.save()
            print('Game', agent.n_games, 'Score', score, 'Record:', record)
Пример #19
0
 def test_check_win_with_wit_garbage(self):
     test_mas = (
         ("a", 2, "ty", "X", 5, 6, 7, "O", 9),
         (1, 2, "X", "X", "X", 6, 7, 8, 9),
         (1, "O", 3, "r", "67", "O", 7, 8, 9),
         ("O", "@", "X", "l", 5, "D", 7, "X", 9),
         ("*", 2, "4", "]", "|", 6, 7, 8, "X"),
         (1, "X", 3, 4, "O", 6, 7, "O", 9),
         (1, 2, 3, "X", "X", "O", 7, 0x45, 9),
         (
             1,
             "O",
             3,
             "F",
             5,
             "f",
             7,
             8,
         ),
     )
     for it in test_mas:
         chw = Game(it).check_win()
         self.assertFalse(chw)
    def button_play_command(self):
        """
        When the button play (or ready is press)
        :return: None
        """

        if self.create_game:
            if self.player_2_is_connected:
                if self.player_2_is_ready:
                    self.export_last_game_settings()

                    self.ui.change_panel(
                        ServerGamePanel.ServerGamePanel,
                        player_1=Player.Player(
                            TokenState.Player_1, self.players_tokens[0],
                            self.players_entry_string_variable[0].get()),
                        player_2=Player.Player(
                            TokenState.Player_2, self.players_tokens[1],
                            self.players_entry_string_variable[1].get()),
                        is_server=self.create_game,
                        game=Game.Game(
                            first_player=random.choice((TokenState.Player_1,
                                                        TokenState.Player_2))))

                    self.ui.server.send_message_to_all(
                        Server.Server.encode_message('_'.join(
                            (MESSAGE_PLAY,
                             str(self.ui.current_panel.game.current_turn.value)
                             ))))
                else:
                    self.player_1_want_to_start()
        else:
            self.set_player_2_ready(not self.player_2_is_ready)
            self.ui.client.send_message(
                Server.Server.encode_message('_'.join(
                    (MESSAGE_SEND_READY, str(self.player_2_is_ready)))))
Пример #21
0
from main import Game
from utility import NonBlockingInput, keyPressed, clearScreen as c
from config import *
from time import sleep, monotonic
from objects import MandoBullet, BossBullet
import sys

g = Game(100)

keys = NonBlockingInput()
keys.NBISetupTerminal()

counter = 0
bulletFlag = False

coinLocations = []
lazerLocations = []

for location in g.screen.locationsUsed:

    if counter < COINB_COUNT:

        coinLocations.append(g.screen.map[location[0] - COIN_SIZE[0] : location[0], location[1] : location[1] + COIN_SIZE[1]])

    elif counter < COINB_COUNT + HLAZER_COUNT:
            
        lazerLocations.append(g.screen.map[location[0], location[1] : location[1] + HLAZER_SIZE[1]])

    elif counter < COINB_COUNT + HLAZER_COUNT + VLAZER_COUNT:
            
        lazerLocations.append(g.screen.map[location[0] - VLAZER_SIZE[0] : location[0], location[1]])
Пример #22
0
from main import Game, select_action
import sys

states = {}

with open(sys.argv[1], "r") as f:
    line = f.readline()
    while line:
        data = line[:-1].split("#")
        states[eval(data[0])] = eval(data[1])
        line = f.readline()

game = Game()

while 1:
    state = game.get_state()
    if not state in states.keys():
        states[state] = {}
        for i in game.get_actions():
            states[state][i] = 0.0
    action = max(states[state], key=states[state].get)
    # print(states[state])
    game.do_action(action, 1)
    next_state = game.get_state()

    if game.is_end() != -1:
        game.print()
        print(f"game end {game.is_end()}")
        break

    actions = game.get_actions()
Пример #23
0
def main():
    Game().run()
Пример #24
0
def main():
    print("Starting the game")
    game = Game()
    game.play()
    print("Game Over")
Пример #25
0
def training_loop(training_model, opponent_model, verbose=False):

    winner = None

    # for tensor board logging
    log_dir = ("logs/fit/" + training_model._name +
               datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))
    tensorboard = ModifiedTensorBoard(log_dir=log_dir)

    # now execute the q learning
    y = 0.9
    eps = 0.5
    interval_size = 500
    num_episodes = interval_size * 1
    decay_factor = (1000 * eps)**(
        -1 / num_episodes
    )  # ensures that eps = 0.001 after `num_episodes` episodes

    r_avg_list = []
    sse_avg_list = []
    wins = []
    n_moves_list = []
    moves_played = [0] * BOARD_SIZE
    for i in tqdm(range(num_episodes), desc="Training"):

        as_player = random.choice([0, 1])
        eps *= decay_factor

        g = Game(verbose=verbose)

        if as_player == 1:  # Training as player 1 so opponent makes first move
            winner, board = g.move(opponent_model.move(g._board, 0))
        else:
            board = g._board

        done = False
        r_sum = 0
        sse_sum = 0
        move_num = 0
        while not done:
            random_move = False
            move_num += 1
            preds = training_model.predict(board, as_player)

            # To encourage early exploration
            if np.random.random() < eps:
                move = np.random.randint(0, BOARD_SIZE - 1)
                random_move = True
            else:
                move = training_model.move(board, as_player)
                moves_played.append(move)

            winner, new_board = g.move(move)

            if winner is None:
                opponent_move = opponent_model.move(new_board, 1 - as_player)
                winner, new_board = g.move(opponent_move)

            # Calculate reward amount
            if winner == as_player:
                done = True
                wins.append(1)
                r = 1000 - move_num**2
            elif winner == 1 - as_player:
                done = True
                wins.append(0)
                r = -(1000 - move_num**2)
            elif winner == -1:
                done = True
                wins.append(None)
                r = 1000
            else:
                r = move_num

            if winner is None:
                target = r + y * np.max(
                    training_model.predict(new_board, as_player))
            else:
                target = r

            target_vec = deepcopy(preds[0])
            target_vec[move] = target

            training_model.fit_one(
                as_player,
                board,
                np.array([target_vec]),
                epochs=1,
                verbose=0,
                callbacks=[tensorboard],
            )

            new_preds = training_model.predict(board, as_player)

            sse = sum([(x - y)**2 for x, y in zip(preds[0], target_vec)])
            new_sse = sum([(x - y)**2
                           for x, y in zip(new_preds[0], target_vec)])
            sse_sum += sse

            if verbose:
                print(f"""
                    {training_model._name} training as player: {as_player}, move: {move_num}, eps: {round(eps, 2)},
                    old preds: {[round(p, 2) for p in preds[0]]}, rand move: {random_move},
                    tgt preds: {[round(p, 2) for p in target_vec]}, reward: {r},
                    new preds: {[round(p, 2) for p in new_preds[0]]}, average last 20 games: {round(sum(r_avg_list[-20:])/20, 2)} 
                    sse: {round(sse, 4)} >> {round(new_sse, 4)}
                    """)

            board = new_board
            r_sum += r

        if verbose and ((i % interval_size == 0 and i > 0) or
                        (i == num_episodes - 1)):
            run_game(training_model, opponent_model, verbose=True)

        # Collect game level metrics
        r_avg_list.append(round(r_sum, 2))
        n_moves_list.append(move_num)

        tensorboard.update_stats(reward_sum=r_sum,
                                 wins=wins[-1],
                                 n_moves_avg=n_moves_list[-1])
        tensorboard.update_dist(moves_played=moves_played)
Пример #26
0
    assert(len(W) == 10)
    W -= (1,2,0,0,0,0)
    assert(len(W) == 7)
    assert(W[2] == 3)
    W += (4,4,1,0,0,0)
    assert(W.overmax())
    W -= (4,4,4,4,0,0)
    assert(W.negative() is False)
    
if __name__ == "__main__":
    _BLACK = 4
    C = Card(_BLACK,0,1,1,1,1,0)
    assert(C.cost() == (1,1,1,1,0))
    assert(C.color() == 'B')
    assert(C.points() == 0)
    C.set_key(0,3)
    assert(C.key() == (0, 3))

if __name__ == "__main__":
    G = Game()
    P1 = G.active_player()
    G.collect((1,1,1,0,0,0))
    P2 = G.active_player()
    assert(P2 is not P1)
    G.collect((0,1,1,1,0,0))
    G.board()

if __name__ == "__main__":
    N = Noble(3, 3, 3, 3, 0, 0)
    assert(N.cost() == (3, 3, 3, 0, 0))
Пример #27
0
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from main import Game
import json, queue

NBTHREADS = 4
MAXSIZE = -1
SCORETARGET = 600000

boundary = queue.LifoQueue(MAXSIZE)

boundary.put(Game())

maxscore = -1
nbgames = 1
bgame = None
while not boundary.empty():
    game = boundary.get()
    game.init_turn()
    moves = game.avail_moves(game.table)
    if not moves:
        if game.score > maxscore:
            print("new maxscore (%s branch): %s" % (nbgames, maxscore))
            maxscore = game.score
            bgame = game
        if maxscore > SCORETARGET:
            break
    nbgames += len(moves) - 1
    for move in moves:
        game2 = game.copy()
        game2.play(move)
Пример #28
0
 def setUp(self):
     self.game = Game()
Пример #29
0
    def __init__(self, master, ui,
                 player_1=Player.Player(TokenState.TokenState.Player_1, TokenStyle.TokenStyle.Blue),
                 player_2=Player.Player(TokenState.TokenState.Player_2, TokenStyle.TokenStyle.Green),
                 game=Game.Game(), disable_end_button=False, delay=Preferences.DEFAULT_DELAY):
        """
        Constructor
        :param player_1: the player 1
        :param player_2: the player 2
        :param game: a link to the game
        :param disable_end_button: if need to disable end buttons (for the client)
        :param delay: the delay between click in ms
        :param master: see Panel class
        :param ui: see Panel class
        """
        super().__init__(master, ui)

        self.turn_text_format = self.ui.translation.get_translation("game_panel_turn_format")
        self.win_text_format = self.ui.translation.get_translation("game_panel_win_format")

        self.grid_canvas = tkinter.tix.Canvas(self)
        self.grid_canvas.pack(expand=True, fill=tkinter.tix.BOTH)

        self.after(500, lambda: self.grid_canvas.bind("<Button>", self.grid_canvas_on_click))

        self.game = game

        self.players = {
            TokenState.TokenState.Player_1: player_1,
            TokenState.TokenState.Player_2: player_2
        }

        self.token_square_size = 0

        self.height_center = 0
        self.width_center = 0

        self.button_main_menu = tkinter.tix.Button(
            self,
            # text=self.ui.translation.get_translation("game_panel_main_menu_button"),
            command=self.button_main_menu_command, image=self.ui.image_getter.door_exit_icon)
        self.button_main_menu.place(x=0, y=0)

        self.grid_image_create = []
        self.turn_text_id = -1
        self.turn_image_id = - 1
        self.win_line_id = -1
        self.win_icon_id = -1
        self.win_icon_background_id = -1

        self.win_text_frame = tkinter.tix.Frame(self, relief=tkinter.tix.RAISED, borderwidth=2)

        self.win_text_label = tkinter.tix.Label(self.win_text_frame)
        self.win_text_label.grid(row=0, column=0)

        if not disable_end_button:
            self.end_buttons_frame = tkinter.tix.Frame(self.win_text_frame)
            self.end_buttons_frame.columnconfigure(0, weight=1)
            self.end_buttons_frame.columnconfigure(1, weight=1)
            self.end_buttons_frame.grid(row=1, column=0)

            max_width = max(len(self.ui.translation.get_translation("back")),
                            len(self.ui.translation.get_translation("restart")),
                            len(self.ui.translation.get_translation("main_menu")))

            self.button_main_menu_end = tkinter.tix.Button(
                self.end_buttons_frame,
                text=self.ui.translation.get_translation("main_menu"),
                command=self.button_main_menu_command, width=max_width
            )
            self.button_main_menu_end.grid(row=0, column=0, sticky=tkinter.tix.NSEW, padx=5)

            self.back_button = tkinter.tix.Button(
                self.end_buttons_frame,
                text=self.ui.translation.get_translation("back"),
                command=self.button_back_command, width=max_width
            )
            self.back_button.grid(row=0, column=1, sticky=tkinter.tix.NSEW, padx=5)

            self.restart_button = tkinter.tix.Button(
                self.end_buttons_frame,
                text=self.ui.translation.get_translation("restart"),
                command=self.button_restart_command, width=max_width
            )
            self.restart_button.grid(row=0, column=2, sticky=tkinter.tix.NSEW, padx=5)

        for x in range(0, self.game.grid_width):
            self.grid_image_create.append([])
            for y in range(0, self.game.grid_height):
                self.grid_image_create[x].append(-1)

        self.token_animation_list = []

        self.delay = delay / 1000.  # convert in second
        self.last_click_time = time.time()

        self.ai_turn_start_time = time.time()

        self.ai_progress_bar = tkinter.ttk.Progressbar(self.grid_canvas, orient=tkinter.tix.HORIZONTAL,
                                                       mode='determinate')
        self.ai_progress_bar_show = False
Пример #30
0
 def setUp(self):
     self.questions_storage = QuestionStorage('')
     self.game = Game(self.questions_storage)