Esempio n. 1
0
    def __minimax_helper(game_state: GameState, maximizing_player, depth):
        if game_state.is_game_over:
            if game_state.winner.name == maximizing_player.name:
                return 100, None
            elif game_state.winner is SingletonDrawPlayer:
                return 0, None
            elif game_state.is_game_over:
                return -100, None

        scores = np.array([])
        valid_moves = game_state.get_valid_moves()

        if game_state.current_player == maximizing_player:
            for move in valid_moves:
                new_game_state = game_state.copy().make_move(move)
                score = Minimax.__minimax_helper(new_game_state,
                                                 maximizing_player, depth + 1)
                scores = np.append(scores, score[0])

            max_eval = max(scores)
            arg_max_move = valid_moves[np.argmax(scores)]
            Minimax.__print_debugging_info(depth, scores, valid_moves,
                                           max_eval, arg_max_move)

            return max_eval, arg_max_move

        else:
            for move in valid_moves:
                new_game_state = game_state.copy().make_move(move)
                score = Minimax.__minimax_helper(new_game_state,
                                                 maximizing_player, depth + 1)
                scores = np.append(scores, score[0])

            return min(scores), None
Esempio n. 2
0
    def test_full_game(self):
        """ Test that I can run a game all the way to the end without an error."""
        # Random, but fixed, opening hands.
        hand_0 = ['EA_', 'EO_', 'S10', 'G8_', 'S7_', 'SA_', 'GU_', 'E7_']
        hand_1 = ['S8_', 'E10', 'SU_', 'GA_', 'HO_', 'H9_', 'H7_', 'SO_']
        hand_2 = ['EU_', 'H8_', 'SK_', 'G7_', 'G9_', 'EK_', 'HU_', 'GO_']
        hand_3 = ['HK_', 'HA_', 'GK_', 'H10', 'E9_', 'G10', 'E8_', 'S9_']
        player_dict = {0: hand_0, 1: hand_1, 2: hand_2, 3: hand_3}

        # Player 1 calls a eichel partner play, (with player 0.)
        state = GameState(game_mode="Partner Eichel",
                          offensive_player=1,
                          active=0)
        for i in range(8):
            for j in range(4):
                hand = player_dict[state.active]
                possible = state.actions(hand)
                chosen = possible[0]
                # pick the first of the possible moves, don't want randomness in unittests.
                state = state.result(chosen)
                hand.remove(chosen)
            state.calculate_round_winner(state.history[-16:])
            state.utilities()
        self.assertTrue(state.terminal_test())
        self.assertEqual(state.played_the_ace(),
                         0)  # correctly identifies who the partner is.
Esempio n. 3
0
    def __init__(self, manager):
        """manager is required to be a child of GameManager with these functions:
        -kill_player()
        -next_level()
        -add_score(amount)
        -give_energy(amount)
        -spend_energy(amount)
        -give_life()
        """

        GameState.__init__(self, manager)

        self.player = Ship(*opt.player_args)
        self.enemy = EnemyBase(opt.mover_args, opt.spinner_args,
                               opt.shooter_args, self.player)
        self.shield = EnemyShield(self.enemy, opt.shield_filename, formation,
                                  formation_center)
        self.hbullet = HomingBullet(opt.homer_filename, self.player,
                                    opt.homer_speed)
        self.cannon = Cannon(opt.deactivated_cannon_args,
                             opt.standby_cannon_args, opt.firing_cannon_args,
                             self.player)
        self.ion_field = IonField(*opt.ion_field_args)
        self.player_bullets = Group()

        self.reset_positions()
Esempio n. 4
0
    def __init__(self):
        '''
            Constructor -- creates a new instance of Board
            Parameter:
            self -- The current Board object
        '''
        self.state = GameState()

        turtle.setup(c.WIDTH + c.SQUARE_SIZE, c.HEIGHT + c.SQUARE_SIZE)
        turtle.screensize(c.WIDTH, c.HEIGHT)
        turtle.bgcolor("white")
        turtle.tracer(0, 0)

        # Create the Turtle to draw the board
        self.pen = turtle.Turtle()
        self.pen.penup()
        self.pen.hideturtle()

        # Draw the board and pieces
        self.draw_state()

        # "Convenience attributes" used for drawing
        self.high_bound = 0 - c.CORNER
        self.low_bound = c.CORNER

        self.screen = turtle.Screen()
        self.screen.onclick(self.clickhandler)
        turtle.done()  # Stops the window from closing.
	def test_unmortgage(self):
		state = GameState(1)
		player = state.players[0]

		# Set up player to own a mortgaged utility
		state.apply(GroupOfChanges([
			GameStateChange.buy_property(state.squares[INDEX[ELECTRIC_COMPANY]],
				player, state.bank, mortgaged=True)
		]))

		# Test unmortgage
		str_before = str(state)
		state.apply(GroupOfChanges([
			GameStateChange.unmortgage(state.squares[INDEX[ELECTRIC_COMPANY]], state)
		]))
		str_after = str(state)
		expected_diff = [
			# Player cash
			('Cash: 1425', 'Cash: 1342'),

			# Bank cash
			('Cash: 75', 'Cash: 158'),

			# Electric Company stats
			('Mortgaged: True', 'Mortgaged: False')
		]
		self.assertDiffGameStates(str_before, str_after, expected_diff,
			msg='Electric Company was not unmortgaged properly')	
	def test_change_position_landing_on_go(self):
		state = GameState(1)
		player = state.players[0]

		# Set up player's initial position at Short Line Railroad
		state.apply(GroupOfChanges([
			GameStateChange.change_position(player, INDEX[SHORT_LINE_RAILROAD], state.bank,
				state.squares)
		]))

		# Test player changing position to Go
		str_before = str(state)
		state.apply(GroupOfChanges([
			GameStateChange.change_position(player, INDEX[GO], state.bank, state.squares)
		]))
		str_after = str(state)
		expected_diff = [
			# Player stats
			('Position: %d' % INDEX[SHORT_LINE_RAILROAD],
			 'Position: %d' % INDEX[GO]),
			('Cash: 1500', 'Cash: 1700'),

			# Bank stats
			('Cash: 0', 'Cash: -200')
		]
		self.assertDiffGameStates(str_before, str_after, expected_diff,
			msg='Player did not pass Go properly')
	def test_mortgage(self):
		state = GameState(1)
		player = state.players[0]

		# Set up player to own a railroad
		state.apply(GroupOfChanges([
			GameStateChange.buy_property(state.squares[INDEX[PENNSYLVANIA_RAILROAD]],
				player, state.bank)
		]))

		# Test mortgage
		str_before = str(state)
		state.apply(GroupOfChanges([
			GameStateChange.mortgage(state.squares[INDEX[PENNSYLVANIA_RAILROAD]], state)
		]))
		str_after = str(state)
		expected_diff = [
			# Player cash
			('Cash: 1300', 'Cash: 1400'),

			# Bank cash
			('Cash: 200', 'Cash: 100'),

			# Pennsylvania Railroad stats
			('Mortgaged: False', 'Mortgaged: True')
		]
		self.assertDiffGameStates(str_before, str_after, expected_diff,
			msg='Pennsylvania Railroad was not mortgaged properly')
	def test_buy_property_from_something(self):
		state = GameState(1)
		player = state.players[0]

		# Set up player with some properties (two of the three greens)
		changes = []
		for prop_name in [PACIFIC_AVENUE, PENNSYLVANIA_AVENUE]:
			changes.append(GameStateChange.buy_property(state.squares[INDEX[prop_name]],
				player, state.bank))

		state.apply(GroupOfChanges(changes))

		# Test buying North Carolina Avenue
		str_before = str(state)
		state.apply(GroupOfChanges([
			GameStateChange.buy_property(state.squares[INDEX[NORTH_CAROLINA_AVENUE]],
				player, state.bank)
		]))
		str_after = str(state)
		expected_diff = [
			# Player 1 stats
			('Cash: 880', 'Cash: 580'), 
			('Pacific Avenue, Pennsylvania Avenue, ', 'Pacific Avenue, Pennsylvania Avenue, North Carolina Avenue, '),
			('6: 2', '6: 3'),

			# Bank stats
			('Cash: 620', 'Cash: 920'),
			('Mediterranean Avenue, Baltic Avenue, Reading Railroad, Oriental Avenue, Vermont Avenue, Connecticut Avenue, St. Charles Place, Electric Company, States Avenue, Virginia Avenue, Pennsylvania Railroad, St. James Place, Tennessee Avenue, New York Avenue, Kentucky Avenue, Indiana Avenue, Illinois Avenue, B. & O. Railroad, Atlantic Avenue, Ventnor Avenue, Water Works, Marvin Gardens, North Carolina Avenue, Short Line Railroad, Park Place, Boardwalk, ',
			 'Mediterranean Avenue, Baltic Avenue, Reading Railroad, Oriental Avenue, Vermont Avenue, Connecticut Avenue, St. Charles Place, Electric Company, States Avenue, Virginia Avenue, Pennsylvania Railroad, St. James Place, Tennessee Avenue, New York Avenue, Kentucky Avenue, Indiana Avenue, Illinois Avenue, B. & O. Railroad, Atlantic Avenue, Ventnor Avenue, Water Works, Marvin Gardens, Short Line Railroad, Park Place, Boardwalk, '),
			('6: 1', '6: 0')
		]
		self.assertDiffGameStates(str_before, str_after, expected_diff,
			msg='North Carolina Avenue was not purchased properly')
	def test_buy_property_mortgaged(self):
		state = GameState(1)
		player = state.players[0]

		# Test buying Pennsylvania Avenue mortgaged
		str_before = str(state)
		state.apply(GroupOfChanges([
			GameStateChange.buy_property(state.squares[INDEX[PENNSYLVANIA_AVENUE]],
				player, state.bank, mortgaged=True)
		]))
		str_after = str(state)
		expected_diff = [
			# Player stats
			('Cash: 1500', 'Cash: 1340'),
			('', 'Pennsylvania Avenue, '),
			('6: 0', '6: 1'),

			# Bank stats
			('Cash: 0', 'Cash: 160'),
			('Mediterranean Avenue, Baltic Avenue, Reading Railroad, Oriental Avenue, Vermont Avenue, Connecticut Avenue, St. Charles Place, Electric Company, States Avenue, Virginia Avenue, Pennsylvania Railroad, St. James Place, Tennessee Avenue, New York Avenue, Kentucky Avenue, Indiana Avenue, Illinois Avenue, B. & O. Railroad, Atlantic Avenue, Ventnor Avenue, Water Works, Marvin Gardens, Pacific Avenue, North Carolina Avenue, Pennsylvania Avenue, Short Line Railroad, Park Place, Boardwalk, ',
				'Mediterranean Avenue, Baltic Avenue, Reading Railroad, Oriental Avenue, Vermont Avenue, Connecticut Avenue, St. Charles Place, Electric Company, States Avenue, Virginia Avenue, Pennsylvania Railroad, St. James Place, Tennessee Avenue, New York Avenue, Kentucky Avenue, Indiana Avenue, Illinois Avenue, B. & O. Railroad, Atlantic Avenue, Ventnor Avenue, Water Works, Marvin Gardens, Pacific Avenue, North Carolina Avenue, Short Line Railroad, Park Place, Boardwalk, '),
			('6: 3', '6: 2'),

			# Pennsylvania Avenue stats
			('Mortgaged: False', 'Mortgaged: True')
		]
		self.assertDiffGameStates(str_before, str_after, expected_diff,
			msg='Pennsylvania Avenue was not mortgaged properly')
Esempio n. 10
0
    def check_partner(self):
        state = GameState(game_mode="Partner Eichel",
                          offensive_player=0,
                          active=0)
        fixed_history = [
            "E7_",
            "E10",
            "EK_",
            "EA_",  #player 0 starts, player 3 wins 25 pts
            "EO_",
            "HA_",
            "H10_",
            "HK_",  # player 3 opens, player 3 wins 28 pts
            "SA_",
            "S10",
            "SK_",
            "S9_"
        ]  # player 3 opens, player 3 wins 25 pts.

        for card in fixed_history:
            state = state.result(card)
        self.assertTrue(state.is_decided())

        utilities = state.utilities(bools=False, intermediate=True)
        expected = (78, 0, 0, 78)
        self.assertEqual(expected, utilities)
Esempio n. 11
0
 def test_Copy(self):
     s = GameState()
     u = GameState()
     u.ball.pos_x = 100
     u.ball.pos_y = 200
     u.ball.vel_x = 300
     u.ball.vel_y = 400
     u.paddle_left.pos_y = -100
     u.paddle_left.vel_y = -200
     u.paddle_right.pos_y = -300
     u.paddle_right.vel_y = -400
     u.frame = 30
     u.key_flags = 300
     u.Copy(s)
     self.assertTrue(s.ball.pos_x == u.ball.pos_x)
     self.assertTrue(s.ball.pos_y == u.ball.pos_y)
     self.assertTrue(s.ball.vel_x == u.ball.vel_x)
     self.assertTrue(s.ball.vel_y == u.ball.vel_y)
     self.assertTrue(s.paddle_left.pos_y == u.paddle_left.pos_y)
     self.assertTrue(s.paddle_left.vel_y == u.paddle_left.vel_y)
     self.assertTrue(s.paddle_right.vel_y == u.paddle_right.vel_y)
     self.assertTrue(s.paddle_right.pos_y == u.paddle_right.pos_y)
     self.assertTrue(s.frame == u.frame)
     self.assertTrue(s.key_flags == u.key_flags)
     pass
Esempio n. 12
0
 def test_Serialize_and_Deserialize(self):
     s = GameState()
     s.ball.pos_x = 100
     s.ball.pos_y = -50
     s.ball.vel_x = -43
     s.ball.vel_y = 6
     s.paddle_left.pos_y = 90
     s.paddle_left.vel_y = 4
     s.paddle_right.pos_y = 2
     s.paddle_right.vel_y = 87
     s.key_flags = 3
     s.frame = 112734590
     s.keybits = 1 << 63
     # Ignore the EventType header.
     b = s.Serialize()[4:]
     t = GameState()
     t.Deserialize(b)
     self.assertTrue(t.ball.pos_x == s.ball.pos_x)
     self.assertTrue(t.ball.pos_y == s.ball.pos_y)
     self.assertTrue(t.ball.vel_x == s.ball.vel_x)
     self.assertTrue(t.ball.vel_y == s.ball.vel_y)
     self.assertTrue(t.paddle_left.pos_y == s.paddle_left.pos_y)
     self.assertTrue(t.paddle_left.vel_y == s.paddle_left.vel_y)
     self.assertTrue(t.paddle_right.pos_y == s.paddle_right.pos_y)
     self.assertTrue(t.paddle_right.vel_y == s.paddle_right.vel_y)
     self.assertTrue(t.key_flags == s.key_flags)
     self.assertTrue(t.frame == s.frame)
     pass
	def test_build_house(self):
		state = GameState(1)

		# Set up a player to own oranges with no houses
		player = state.players[0]
		oranges = [ST_JAMES_PLACE, TENNESSEE_AVENUE, NEW_YORK_AVENUE]
		
		changes = []
		for prop_name in oranges:
			changes.append(GameStateChange.buy_property(state.squares[INDEX[prop_name]],
				player, state.bank))

		state.apply(GroupOfChanges(changes))

		# Test house build
		str_before = str(state)
		state.apply(GroupOfChanges([
			GameStateChange.build(state.squares[INDEX[NEW_YORK_AVENUE]], state)
		]))
		str_after = str(state)
		expected_diff = [
			('Cash: 940', 'Cash: 840'),          # player cash
			('Cash: 560', 'Cash: 660'),          # bank cash
			('Num houses: 0', 'Num houses: 1'),  # new york avenue
			('Houses remaining: 32', 'Houses remaining: 31')
		]
		self.assertDiffGameStates(str_before, str_after, expected_diff,
			msg='House build was not applied properly')
Esempio n. 14
0
class Agent(object):
    
    def __init__(self, name="Marty"):
       self.name = name
       self.gameState = None
       
    def ingestState(self, data):
        """ Ingests the given gamestate from the network.
        """
        # ignorant agents might not do anything with the state
        if not data:
            return

        args = struct.unpack('!ffffffB',data)
        
        self.gameState = GameState(args[0],args[1],args[2],args[3],args[4],args[5])
        self.gameState.parseFlags(args[6])


    def chooseAction(self):
        """ Chooses an action, based off of a given game state.
            Returned is the bitwise or'ed set of actions.  
        """
        print "nothing"
        pass
Esempio n. 15
0
    def test_makes_suggested_move(self, mocked):
        """Should make move suggested by api."""
        g = GameState()
        g.board = {
            'a': {'1': 'R', '2': 'P', '3': ' ', '4': ' ', '5': ' ', '6': ' ', '7': 'p', '8': 'r'},  # noqa
            'b': {'1': 'N', '2': 'P', '3': ' ', '4': ' ', '5': ' ', '6': ' ', '7': 'p', '8': 'n'},  # noqa
            'c': {'1': 'B', '2': 'P', '3': ' ', '4': ' ', '5': 'p', '6': ' ', '7': ' ', '8': 'b'},  # noqa
            'd': {'1': 'Q', '2': 'P', '3': ' ', '4': ' ', '5': ' ', '6': ' ', '7': 'p', '8': 'q'},  # noqa
            'e': {'1': 'K', '2': ' ', '3': ' ', '4': 'P', '5': ' ', '6': ' ', '7': 'p', '8': 'k'},  # noqa
            'f': {'1': 'B', '2': 'P', '3': 'N', '4': ' ', '5': ' ', '6': ' ', '7': 'p', '8': 'b'},  # noqa
            'g': {'1': ' ', '2': 'P', '3': ' ', '4': ' ', '5': ' ', '6': ' ', '7': 'p', '8': 'n'},  # noqa
            'h': {'1': 'R', '2': 'P', '3': ' ', '4': ' ', '5': ' ', '6': ' ', '7': 'p', '8': 'r'},  # noqa
        }
        g.take_turn()
        expected = """
  ---------------------------------
8 | r | n | b | q | k | b | n | r |
  |-------------------------------|
7 | p | p |   | p | p | p | p | p |
  |-------------------------------|
6 |   |   |   |   |   |   |   |   |
  |-------------------------------|
5 |   |   | p |   |   |   |   |   |
  |-------------------------------|
4 | P |   |   |   | P |   |   |   |
  |-------------------------------|
3 |   |   |   |   |   | N |   |   |
  |-------------------------------|
2 |   | P | P | P |   | P | P | P |
  |-------------------------------|
1 | R | N | B | Q | K | B |   | R |
  ---------------------------------
    a   b   c   d   e   f   g   h
""".strip('\n')  # the outer newlines are only there to make this code readable
        self.assertEqual(g.board_text, expected)
Esempio n. 16
0
    def test_full_game(self):
        """ Test to see if during the course of a full game, we can correctly
        deduce which cards the other player has. I'm undecided as to whether
        we want this test to have a random element or not."""
        # Random but fixed hands.
        hands = {
            0: {'SK_', 'S7_', 'H10', 'H7_', 'HK_', 'E8_', 'HU_', 'GU_'},
            1: {'G9_', 'HO_', 'S10', 'H9_', 'EO_', 'E10', 'GO_', 'GK_'},
            2: {'G10', 'SU_', 'G8_', 'E9_', 'G7_', 'SO_', 'S9_', 'S8_'},
            3: {'GA_', 'EU_', 'E7_', 'H8_', 'SA_', 'EA_', 'EK_', 'HA_'}
        }

        state = GameState(game_mode="Herz Solo", offensive_player=1, active=0)

        for _ in range(32):
            active = state.active
            action = random.choice(state.actions(hands[active]))
            hands[active].remove(action)
            state = state.result(action)

            for i in range(4):
                card_constraints, _ = inverse_legal_moves(state, hands[i], i)
                for p_num, card_set in card_constraints.items():
                    actual_hand = hands[p_num]
                    self.assertTrue(actual_hand.issubset(card_set))
Esempio n. 17
0
def main():
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Qiuyang's Tetris")
    pygame.key.set_repeat(
        150, 40
    )  # hold key will keep creating same event, set_repeat(delay, interval)
    # background color
    bg_color = BG_COLOR

    game_state = GameState(screen)

    while True:
        # if touch bottom
        if game_state.block and game_state.block.on_bottom:
            game_state.touch_bottom()

        # monitor keyboard and mouse event
        check_events(game_state)

        # fill background
        screen.fill(bg_color)
        # draw block
        if game_state.block:
            game_state.block.paint()
        # draw game window
        GameDisplay.draw_game_area(screen, game_state)

        # refresh the screen
        pygame.display.update()
Esempio n. 18
0
    def test_davonlaufen_2(self):
        """ Test if we can recognize if someone has run away, and enough cards
        of the called suit have been played such that we can conclude that the 
        person who ran away has ALL of the remaining cards of the called suit. """
        game_mode = "Partner Eichel"
        state = GameState(game_mode=game_mode, offensive_player=0, active=1)
        called_suit = "Eichel"
        suits_mapping = con.SUITS_MAPPING[game_mode]

        fixed_history = ["E7_", "EK_", "E10", "H8_"]
        hand = ["EO_", "GO_", "SO_", "HO_", "EU_", "GU_", "HU_"]
        for card in fixed_history:
            state = state.result(card)

        all_cards_except_eichel = {
            c
            for c in con.ALL_CARDS if suits_mapping[c] != called_suit
        }
        remaining_cards_except_eichel = {
            c
            for c in all_cards_except_eichel
            if not (c in hand or c in fixed_history)
        }
        expected = {
            1: remaining_cards_except_eichel | {"EA_", "E8_", "E9_"},
            2: remaining_cards_except_eichel,
            3: remaining_cards_except_eichel
        }

        card_constraints, number_constraints = inverse_legal_moves(
            state, hand, 0)
        self.assertEqual(expected, card_constraints)
	def test_transfer_money_bank_to_player(self):
		import random

		state = GameState(1)
		player = state.players[0]

		# Transfer random amounts of money, and test that GameState is correct
		for trial in range(0, 100):
			player_cash_before = player.cash
			bank_cash_before = state.bank.cash
			amount = random.randint(1, player_cash_before)

			str_before = str(state)
			state.apply(GroupOfChanges([
				GameStateChange.transfer_money(state.bank, player, amount)]))
			str_after = str(state)
			expected_diff = [
				# Player cash
				('Cash: %d' % player_cash_before,
				 'Cash: %d' % (player_cash_before + amount)),

				# Bank cash
				('Cash: %d' % bank_cash_before,
				 'Cash: %d' % (bank_cash_before - amount))
			]
			self.assertDiffGameStates(str_before, str_after, expected_diff,
				msg='$%d was not transferred to player correctly. Here is diff:' % amount)
Esempio n. 20
0
def main() -> None:
    game_state: GameState = GameState.initial()
    print(display_board(game_state.board))

    # ユーザアクションを取得
    input_action: str = input()

    # "quit"入力で修了
    while input_action != "quit":
        # 盤面記法が書かれたらゲームの状態を指定通りにリセット
        if Board.is_valid_notation(input_action):
            # 入力アクションを元にゲーム状態を生成
            board = Board.from_notation(input_action)
            game_state = GameState(board)

            # コンソールに盤面出力
            print(display_board(game_state.board))

        # 棋譜記法が書かれたらゲームの状態に適用
        elif FillAction.is_valid_notation(input_action):
            action: FillAction = FillAction.from_notation(input_action)
            game_state: GameState = action.apply_to(game_state)

            # コンソールに盤面出力
            print(display_board(game_state.board))
        else:
            print("正しい値を入力してください")

        input_action = input()
def build_table(num_rounds=NUM_ROUNDS):
    """Build a basic opening book of moves."""

    import random

    initial_moves = [
        (2, 2),
        (1, 1),
        (0, 0),
        (0, 2),
        (2, 0),
        (1, 2),
        (2, 1),
        (3, 3),
        (3, 1),
        (1, 3),
    ]
    openingbook = {}
    for i, move in enumerate(initial_moves):
        game = GameState()
        liberties = game.liberties(game._player_locations[game.player()])
        if move not in liberties:
            move = random.choice(liberties)
        game = game.result(move)
        openingbook[game.hashable] = move
    return openingbook
Esempio n. 22
0
    def test_demolish_house(self):
        state = GameState(1)

        # Set up a player to own a property with 1 house
        player = state.players[0]
        park_place = state.squares[INDEX[PARK_PLACE]]
        boardwalk = state.squares[INDEX[BOARDWALK]]
        state.apply(
            GroupOfChanges(
                [GameStateChange.buy_property(park_place, player,
                                              state.bank)]))
        state.apply(
            GroupOfChanges(
                [GameStateChange.buy_property(boardwalk, player, state.bank)]))
        state.apply(GroupOfChanges([GameStateChange.build(boardwalk, state)]))

        # Test applying the changes by comparing differences in their string
        # encodings. Ensure that no additional changes were made to the state.
        str_before = str(state)
        state.apply(
            GroupOfChanges([GameStateChange.demolish(boardwalk, state)]))
        str_after = str(state)
        expected_diff = [
            ('Cash: 550', 'Cash: 650'),  # player cash
            ('Cash: 950', 'Cash: 850'),  # bank cash
            ('Num houses: 1', 'Num houses: 0'),
            ('Houses remaining: 31', 'Houses remaining: 32')
        ]
        self.assertDiffGameStates(
            str_before,
            str_after,
            expected_diff,
            msg='House demolition was not applied correctly')
Esempio n. 23
0
 def test_init(self):
     """Tests the initialization of a GameState"""
     GameStateTest.G.add_edge(0, 1)
     state = GameState(GameStateTest.G)
     self.assertEquals(state.turn, labels.RED)
     self.assertFalse(state.is_gameover())
     self.assertFalse(state.is_terminal())
Esempio n. 24
0
    def test_buy_property_from_nothing(self):
        state = GameState(1)
        player = state.players[0]

        # Test buying Pacific Avenue
        str_before = str(state)
        state.apply(
            GroupOfChanges([
                GameStateChange.buy_property(
                    state.squares[INDEX[PACIFIC_AVENUE]], player, state.bank)
            ]))
        str_after = str(state)
        expected_diff = [
            # Player 1 stats
            ('Cash: 1500', 'Cash: 1200'),
            ('', 'Pacific Avenue, '),
            ('6: 0', '6: 1'),

            # Bank stats
            ('Cash: 0', 'Cash: 300'),
            ('Mediterranean Avenue, Baltic Avenue, Reading Railroad, Oriental Avenue, Vermont Avenue, Connecticut Avenue, St. Charles Place, Electric Company, States Avenue, Virginia Avenue, Pennsylvania Railroad, St. James Place, Tennessee Avenue, New York Avenue, Kentucky Avenue, Indiana Avenue, Illinois Avenue, B. & O. Railroad, Atlantic Avenue, Ventnor Avenue, Water Works, Marvin Gardens, Pacific Avenue, North Carolina Avenue, Pennsylvania Avenue, Short Line Railroad, Park Place, Boardwalk, ',
             'Mediterranean Avenue, Baltic Avenue, Reading Railroad, Oriental Avenue, Vermont Avenue, Connecticut Avenue, St. Charles Place, Electric Company, States Avenue, Virginia Avenue, Pennsylvania Railroad, St. James Place, Tennessee Avenue, New York Avenue, Kentucky Avenue, Indiana Avenue, Illinois Avenue, B. & O. Railroad, Atlantic Avenue, Ventnor Avenue, Water Works, Marvin Gardens, North Carolina Avenue, Pennsylvania Avenue, Short Line Railroad, Park Place, Boardwalk, '
             ),
            ('6: 3', '6: 2')
        ]
        self.assertDiffGameStates(
            str_before,
            str_after,
            expected_diff,
            msg='Pacific Avenue was not purchased properly')
Esempio n. 25
0
 def run():
     'parse input, update game state and call the bot classes do_turn method'
     gamestate = GameState()
     bot = MyBot(gamestate)
     map_data = ''
     while(True):
         try:
             current_line = sys.stdin.readline().rstrip('\r\n') # string new line char
             if current_line.lower() == 'ready':
                 gamestate.setup(map_data)
                 bot.do_setup()
                 gamestate.finish_turn()
                 map_data = ''
             elif current_line.lower() == 'go':
                 gamestate.update(map_data)
                 # call the do_turn method of the class passed in
                 bot.do_turn()
                 gamestate.finish_turn()
                 map_data = ''
             else:
                 map_data += current_line + '\n'
         except EOFError:
             break
         except KeyboardInterrupt:
             raise
         except:
             # don't raise error or return so that bot attempts to stay alive
             traceback.print_exc(file=sys.stderr)
             sys.stderr.flush()
    def backup(self, node, turn, outcome, state: GameState):
        """
        Update the node statistics on the path from the passed node to root to reflect
        the outcome of a randomly simulated playout.

        """
        # Careful: The reward is calculated for player who just played
        # at the node and not the next player to play
        pl_length = [state.get_num_played()['white'], state.get_num_played()['black']]
        self.pl_list = append(self.pl_list, [pl_length], axis=0)
        bonus = self.modify_reward(pl_length)
        reward = -1 if outcome == turn else 1

        while node is not None:
            node.N += 1
            max_moves_played = max(state.get_num_played().values())

            if turn == GameMeta.PLAYERS['black']:
                qb_reward = reward + (reward * MCTSMeta.A_CONST * bonus['black']) \
                    if max_moves_played >= MCTSMeta.WARMUP_ROLLOUTS else reward
            else:
                qb_reward = reward + (reward * MCTSMeta.A_CONST * bonus['white']) \
                    if max_moves_played >= MCTSMeta.WARMUP_ROLLOUTS else reward

            node.Q += qb_reward
            turn = 1 if turn == 0 else 0
            node = node.parent
            reward = -reward
Esempio n. 27
0
 def test_invalid_move(self):
     """Tests that invalid moves raise an exception"""
     GameStateTest.G.add_edge(0, 1)
     state = GameState(GameStateTest.G)
     state.make_move(0)
     state.make_move(1)
     self.assertRaises(InvalidMoveException)
Esempio n. 28
0
    def receive_once(self):
        """ Receives a package and interprets it.
            Calls :func:`on_new_gamestate`
            Sends an answer to the GC """
        try:
            data, peer = self.socket.recvfrom(GameState.sizeof())

            print(len(data))
            # Throws a ConstError if it doesn't work
            parsed_state = GameState.parse(data)

            # Assign the new package after it parsed successful to the state
            self.state = parsed_state
            self.time = time.time()

            # Call the handler for the package
            self.on_new_gamestate(self.state)

            # Answer the GameController
            self.answer_to_gamecontroller(peer)

        except AssertionError as ae:
            logger.error(ae.message)
        except socket.timeout:
            logger.warning("Socket timeout")
        except ConstError:
            logger.warning("Parse Error: Probably using an old protocol!")
        except Exception as e:
            logger.exception(e)
            pass
 def test_is_on_board(self):
     game = GameState()
     self.assertTrue(game.is_on_board(0, 0))
     self.assertTrue(game.is_on_board(4, 5))
     self.assertFalse(game.is_on_board(-1, 0))
     self.assertFalse(game.is_on_board(8, 0))
     self.assertFalse(game.is_on_board(0, 8))
Esempio n. 30
0
def main():
    #初始化pygame。启用Pygame必不可少的一步,在程序开始阶段执行。
    pygame.init()
    #创建屏幕对象
    screen = pygame.display.set_mode((1200, 900))  #分辨率是1200*900
    pygame.display.set_caption("俄罗斯方块")  #窗口标题
    pygame.key.set_repeat(100, 100)  # 一直按下某个键,每过100毫秒就引发一个KEYDOWN事件

    #屏幕背景色
    bg_color = (230, 230, 230)

    game_state = GameState(screen)
    game_resource = GameResource()
    game_resource.play_bg_music()
    #游戏主循环
    while True:
        #方块触底的话
        if game_state.piece and game_state.piece.is_on_bottom:
            game_state.touch_bottom()

        #监视键盘和鼠标事件
        check_events(game_state, game_resource)

        #设定屏幕背景
        screen.blit(game_resource.load_bg_img(), (0, 0))
        #绘制方块
        if game_state.piece:
            game_state.piece.paint()
        #绘制游戏区域网格线和墙体
        GameDisplay.draw_game_window(screen, game_state, game_resource)
        #让最近绘制的屏幕可见
        pygame.display.flip()
Esempio n. 31
0
    def test_transfer_money_bank_to_player(self):
        import random

        state = GameState(1)
        player = state.players[0]

        # Transfer random amounts of money, and test that GameState is correct
        for trial in range(0, 100):
            player_cash_before = player.cash
            bank_cash_before = state.bank.cash
            amount = random.randint(1, player_cash_before)

            str_before = str(state)
            state.apply(
                GroupOfChanges([
                    GameStateChange.transfer_money(state.bank, player, amount)
                ]))
            str_after = str(state)
            expected_diff = [
                # Player cash
                ('Cash: %d' % player_cash_before,
                 'Cash: %d' % (player_cash_before + amount)),

                # Bank cash
                ('Cash: %d' % bank_cash_before,
                 'Cash: %d' % (bank_cash_before - amount))
            ]
            self.assertDiffGameStates(
                str_before,
                str_after,
                expected_diff,
                msg='$%d was not transferred to player correctly. Here is diff:'
                % amount)
Esempio n. 32
0
    def __init__(self, player):

        self.digraph = nx.DiGraph()
        self.player = player
        self.num_simulations = 0
        # Constant parameter to weight exploration vs. exploitation for UCT
        self.uct_c = np.sqrt(2)

        self.node_counter = 0

        empty_board = GameState()
        self.digraph.add_node(self.node_counter, attr_dict={'w': 0,
                                                            'n': 0,
                                                            'uct': 0,
                                                            'expanded': False,
                                                            'state': empty_board})
        empty_board_node_id = self.node_counter
        self.node_counter += 1

        self.last_move = None

        if player is 'O':
            for successor in [empty_board.transition_function(*move) for move in empty_board.legal_moves()]:
                self.digraph.add_node(self.node_counter, attr_dict={'w': 0,
                                                                    'n': 0,
                                                                    'uct': 0,
                                                                    'expanded': False,
                                                                    'state': successor})
                self.digraph.add_edge(empty_board_node_id, self.node_counter)
                self.node_counter += 1
Esempio n. 33
0
def run_mcts_simulation(max_num_dice=5, player1_name="MctsBot", player2_name="player2", num_rounds=10000):
    """
    Set up and simulate many rounds using Monte Carlo Tree Search (mcts).

    Args:
        max_num_dice (int): the number of dice each player starts with.
        player1_name (string): name for player1
        player2_name (string): name for player2
    """
    player2bot = int(input("Please enter player 2 type: 1 for human, 2 for random, 3 for nextNum, 4 for nextFace, 5 for challenge, 6 for probability, 7 for savedQBot: "))
    player2 = None
    if player2bot == 1:
        player2 = Player(max_num_dice, player2_name)
    elif player2bot == 2:
        player2_name = "Random Bot"
        player2 = Random_Bot(max_num_dice, player2_name)
    elif player2bot == 3:
        player2_name = "Next Number Bot"
        player2 = Bot_NextNum(max_num_dice, player2_name)
    elif player2bot == 4:
        player2_name = "Next Face Bot"
        player2 = Bot_NextFace(max_num_dice, player2_name)
    elif player2bot == 5:
        player2_name = "Challenge Bot"
        player2 = Bot_Challenge(max_num_dice, player2_name)
    elif player2bot == 6:
        player2_name = "Probability Bot"
        player2 = ProbabilityBot(max_num_dice, player2_name)
    elif player2bot == 7:
        player2_name = "Saved Q Bot"
        player2 = SavedQBot(max_num_dice, player2_name)

    mctsbot = MctsBot(max_num_dice, player1_name)
    game = GameState(mctsbot, player2)

    wins = { player1_name : 0, player2_name: 0 }
    for i in range(num_rounds):
        winner = simulate_mcts_round(game)
        wins[winner.name] += 1

        plot_color = ""
        if winner.name == player1_name:
            plot_color = "blue"
        else:
            plot_color = "red"
        plt.scatter(i, wins[winner.name] / (i + 1), color=plot_color)

        game.reset_to_round_start()

    print("RESULTS")
    print("Wins for {}: {}\n".format(player1_name, wins[player1_name]))
    print("Wins for {}: {}\n".format(player2_name, wins[player2_name]))
    plt.title("Percentage of Wins Over Time")
    plt.xlabel("Rounds")
    plt.ylabel("Percentage of Wins")
    player1_legend = mpatches.Patch(color="blue", label=player1_name)
    player2_legend = mpatches.Patch(color="red", label=player2_name)
    plt.legend(handles=[player1_legend, player2_legend])
    plt.show()
Esempio n. 34
0
 def test_invalid_fen_string(self):
     """
     If fen string is not valid fen, should raise
     InvalidFENFileError.
     """
     g = GameState()
     with self.assertRaises(InvalidFENFileError):
         g._parse_fen_str('asdf 32ds 0-=fe')
Esempio n. 35
0
    def __init__(self, manager, score, lives, next_state):
        GameState.__init__(self, manager)

        sys_font = Font(get_default_font(), options.font_size)
        self.score_text = sys_font.render(str(score), True, options.white)
        self.lives_text = sys_font.render(str(lives), True, options.white)

        self.next_state = next_state
Esempio n. 36
0
def main(fen_file):
    game_state = GameState(fen_file)
    game_state.take_turn()
    print()
    print(game_state.board_text)
    print()
    print(game_state.fen)
    print()
 def test_get_piece_moves(self):
     game = GameState()
     move1 = game.get_piece_moves(Piece(c.PLAYER1, 2, 1))
     move2 = game.get_piece_moves(Piece(c.PLAYER2, 4, 5))
     move3 = game.get_piece_moves(Piece(c.PLAYER1, 0, 1))
     self.assertEqual(move1.sort(), [[1, -1], [1, 1]].sort())
     self.assertEqual(move2.sort(), [[-1, -1], [-1, 1]].sort())
     self.assertEqual(move3, [])
Esempio n. 38
0
    def __init__(self, manager, score, lives, next_state):
        GameState.__init__(self, manager)

        sys_font = Font(get_default_font(), options.font_size)
        self.score_text = sys_font.render(str(score), True, options.white)
        self.lives_text = sys_font.render(str(lives), True, options.white)

        self.next_state = next_state
Esempio n. 39
0
    def __init__(self, manager):
        GameState.__init__(self, manager)

        sys_font = Font(get_default_font(), options.font_size)
        self.message1 = sys_font.render("Andrew's Bitchin' Yars' Revenge Clone",
                                        True, options.white)
        self.message2 = sys_font.render("Press shoot button (space) to start.",
                                        True, options.white)
Esempio n. 40
0
 def test_en_passant_non_pawn_moves_two_squares(self):
     """
     Even if a non-pawn moves two spaces, en passant should be None.
     """
     game = GameState()
     game.board['a']['1'] = 'R'
     game._make_move('a1a3')
     self.assertEqual(game.en_passant, None)
    def __init__(self, player):
        """
        Implementation of Monte Carlo Tree Search

        Creates a root of an MCTS tree to keep track of the information
        obtained throughout the course of the game in the form of a tree
        of MCTS nodes

        The data structure of a node consists of:
          - the game state which it corresponds to
          - w, the number of wins that have occurred at or below it in the tree
          - n, the number of plays that have occurred at or below it in the tree
          - expanded, whether all the children (legal moves) of the node have
            been added to the tree

        To access the node attributes, use the following format. For example,
        to access the attribute 'n' of the root node:
          policy = MCTSPolicy()
          current_node = policy.root
          policy.tree.node[current_node]['n']
        """
        self.digraph = nx.DiGraph()
        self.player = player
        self.num_simulations = 0
        # Constant parameter to weight exploration vs. exploitation for UCT
        self.uct_c = np.sqrt(2)

        self.node_counter = 0

        empty_board = GameState()
        self.digraph.add_node(self.node_counter,
                              attr_dict={
                                  'w': 0,
                                  'n': 0,
                                  'uct': 0,
                                  'expanded': False,
                                  'state': empty_board
                              })
        empty_board_node_id = self.node_counter
        self.node_counter += 1

        self.last_move = None

        if player is 'O':
            for successor in [
                    empty_board.transition_function(*move)
                    for move in empty_board.legal_moves()
            ]:
                self.digraph.add_node(self.node_counter,
                                      attr_dict={
                                          'w': 0,
                                          'n': 0,
                                          'uct': 0,
                                          'expanded': False,
                                          'state': successor
                                      })
                self.digraph.add_edge(empty_board_node_id, self.node_counter)
                self.node_counter += 1
Esempio n. 42
0
    def run(self):
        self.game_state = GameState(self.conf_obj["initial_moves"], self.conf_obj["initial_drills"], self.conf_obj['layout']) # reset
        self.game_state.update_players_points()
        cycle = -1 # play: set cycle = -1
        update_phase_timer = 0
        phase_interval = self.conf_obj["time_per_display_phase"]

        clock = self.clock
        playtime = 0
        while self.running:
            miliseconds = clock.tick(self.FPS)
            playtime += miliseconds / 1000.0
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.running = False
                elif event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
                        self.running = False

            text = "FPS: {0:2f}   Playtime: {1:2f}".format(clock.get_fps(), playtime)
            pygame.display.set_caption(text)
            
            # update by timer
            update_phase_timer += miliseconds/1000
            if self.turn < self.end_turn and update_phase_timer > phase_interval:
                update_phase_timer = 0 
                cycle += 1
                cycle %= 5
            
                if cycle == 0:
                    # simulate write input, run program, get output, ...
                    # actually just read log file gen from self.run_player_program()
                    for plr_idx in range(2):       
                        copyfile('{}/{:03d}_output{}.log'.format(self.LOG_PATH, self.turn, plr_idx), \
                                 '{}/player{}/{}.OUT'.format(self.DATA_PATH, plr_idx, self.EXEC_NAME))
                        self.output_actions[plr_idx] = self.pim.read_output(self.game_state, plr_idx)
                    self.turn += 1
                elif cycle == 1:
                    # display intention
                    self.game_state.update_intentions(self.output_actions[0], self.output_actions[1])
                    
                elif cycle == 2:
                    # display actions
                    self.game_state.update_actions()
                    self.game_state.update_players_points()  
                    self.game_state.intentions = [None, None]
                    
                elif cycle == 3:
                    # update_zones
                    self.game_state.board.update_zones()
                    self.game_state.update_players_points()
                    
                elif cycle == 4:
                    # remove full zones
                    self.game_state.board.remove_full_zones()
                    
            self.draw()
            pygame.display.flip()
 def test_PlayFrame(self):
     '''Test frame count and key_flags in PlayFrame.
     '''
     e = UDPGameEngine()
     s = GameState()
     frame = s.frame
     s.key_flags = GameEvent.EVENT_FLAP_LEFT_PADDLE
     e.PlayFrame(s, s.key_flags, e.bitrec)
     self.assertTrue(s.frame == frame + 1)
Esempio n. 44
0
 def setUp(self):
     self.bot = MonteCarloBot()
     self.bot.hand = [
         'G7_', 'HO_', 'EO_', 'GU_', 'HU_', 'SA_', 'GK_', 'EK_'
     ]
     game_mode = "Herz Solo"
     self.state = GameState(game_mode=game_mode,
                            offensive_player=0,
                            active=0)
 def test_RotateRoles_1(self):
     e = UDPGameEngine()
     s = GameState()
     s.player_size = 1
     s.roles = [GameState.ROLE_LEFT_PADDLE]
     s.players = [-1, 0]
     e.RotateRoles(s)
     self.assertTrue(s.roles == [GameState.ROLE_LEFT_PADDLE])
     self.assertTrue(s.players == [-1, 0])
Esempio n. 46
0
    def test_draw_card(self):
        state = GameState(1)
        player = state.players[0]

        # Test every card in both decks
        dict_card_types = {
            CHANCE_CARD: 'Chance',
            COMMUNITY_CHEST_CARD: 'Community Chest'
        }
        for card_type, card_str in dict_card_types.iteritems():
            deck = state.decks[card_type]

            # Draw every card in the deck, check that cards are handled correctly
            # and that nothing else in the state is changed
            card = None
            for i in range(0, deck.size()):
                card = deck.peek()
                jail_free_count_before = player.jail_free_count
                str_before = str(state)
                expected_diff = None  # initialized in the following if-block

                state.apply(
                    GroupOfChanges([GameStateChange.draw_card(deck, player)]))
                if card == LMBDA_GET_OUT_OF_JAIL_FREE:
                    # Check that the card is not replaced on the deck, and that the
                    # player's Jail Free card count is incremented.
                    self.assertEqual(player.jail_free_count,
                                     jail_free_count_before + 1)
                    for j in range(0, deck.size()):
                        self.assertNotEqual(deck.draw(),
                                            LMBDA_GET_OUT_OF_JAIL_FREE)

                    # Initialize. Used after this if-block to ensure that nothing else
                    # in the state was changed.
                    expected_diff = [
                        ('Jail free count: %d' % jail_free_count_before,
                         'Jail free count: %d' % player.jail_free_count)
                    ]
                else:
                    # Check that the card is replaced on the bottom if it is not the
                    # Jail Free card.
                    for j in range(0, deck.size() - 1):
                        deck.draw()
                    self.assertEqual(deck.draw(),
                                     card)  # compare with last card

                    # Initialize
                    expected_diff = []

                # Check that the rest of the state is unchanged by comparing the
                # string encodings of the GameStates
                str_after = str(state)
                self.assertDiffGameStates(
                    str_before,
                    str_after,
                    expected_diff,
                    msg='The GameState was not modified correctly')
Esempio n. 47
0
 def __init__(self, gsm, view):
     """Initialisation des ressources et des modèles (une seule fois)"""
     GameState.__init__(self, gsm, view)
     self.areas = {}
     self.area = None
     self.description_hash = {}
     self.default_verb = 'look_at'
     self._action_subject = models.ActionSubject(self, self.default_verb)
     self._complement = None  # idem
     self.inventory = models.Inventory(self)
	def test_demolish_house(self):
		state = GameState(1)

		# Set up a player to own a property with 1 house
		player = state.players[0]
		park_place = state.squares[INDEX[PARK_PLACE]]
		boardwalk = state.squares[INDEX[BOARDWALK]]
		state.apply(GroupOfChanges([
			GameStateChange.buy_property(park_place, player, state.bank)]))
		state.apply(GroupOfChanges([
			GameStateChange.buy_property(boardwalk, player, state.bank)]))
		state.apply(GroupOfChanges([
			GameStateChange.build(boardwalk, state)]))

		# Test applying the changes by comparing differences in their string
		# encodings. Ensure that no additional changes were made to the state.
		str_before = str(state)
		state.apply(GroupOfChanges([
			GameStateChange.demolish(boardwalk, state)]))
		str_after = str(state)
		expected_diff = [
			('Cash: 550', 'Cash: 650'),  # player cash
			('Cash: 950', 'Cash: 850'),  # bank cash
			('Num houses: 1', 'Num houses: 0'),
			('Houses remaining: 31', 'Houses remaining: 32')
		]
		self.assertDiffGameStates(str_before, str_after, expected_diff,
			msg='House demolition was not applied correctly')
Esempio n. 49
0
def handle_input(log, END_GAME = False):
    """
    Handles all external input,such as those  keyboard and mouse.
    """
    for event in pygame.event.get():

        keys = pygame.key.get_pressed()

        # Closing
        handle_quit(event)

        if keyboard.queue_prompt(event):
            game_state.next_wave()

        # Pausing game
        if keyboard.pause_prompt(keys):
            game_state.toggle_paused()   

        # Hero's movement
        hero_dir = keyboard.movement(keys)
        game_state.hero.change_direction(hero_dir)

        #END_GAME
        global game_state
        handle_quit(event, END_GAME)
        if keyboard.restart(event, END_GAME):
            if game_state.mode == "FIXED":
                new_choice = "DYNAMIC"
            else:
                new_choice = "FIXED"
            game_state = GameState(new_choice)
            log.refresh(new_choice)
            log.first_row()
            

        # Sound Adjustment
        if keyboard.music_prompt(keys):
            dj.switch_background_music()
        if keyboard.increase_prompt(keys):
            dj.increase_volume()
        if keyboard.decrease_prompt(keys):
            dj.decrease_volume()
        
        # Shoot Laser
        if keyboard.laser_prompt(keys):
            if game_state.hero.laser_equipped:
                game_state.hero.is_firing_laser = True
                game_state.hero.fire_time = time.clock()

        # Shoot Pew
        if keyboard.pew_prompt(keys):
            if game_state.hero.ok_to_shoot():
                game_state.hero_fire()
                dj.play_pew()
Esempio n. 50
0
	def __init__(self, parent):
		GameState.__init__(self, parent)
		
		# White background
		self.g_background = GLSpriteGroup()
		background = ColorBackground(0.0, 0.0, 800.0, 600.0, (255, 255, 255))
		self.g_background.add(background)
		
		self.timer = 1500
		self.menu_added = False
		self.background_alpha = 1.0
 def test_ReadAndWriteEvent_State_2(self):
     evt = GameState()
     evt.frame = 100
     evt.ball.pos_x = 3
     evt.ball.pos_y = 6
     evt.paddle_left.pos_y = 5
     evt.paddle_left.vel_y = -9
     evt.paddle_right.pos_y = -19
     evt.paddle_right.vel_y = 54
     evt.key_flags = 4
     self.template_ReadAndWriteEvent(evt)
	def test_eliminate_to_player(self):
		state = GameState(2)
		player_eliminated = state.players[0]
		player_eliminator = state.players[1]

		# Set up players to have some clout
		self.setup_eliminated_player(state)
		self.setup_eliminator_player(state)

		# Move player_eliminated to a square where he would likely lose to the
		# other player (e.g. Marvin Gardens)
		state.apply(GroupOfChanges([
			GameStateChange.change_position(player_eliminated, INDEX[MARVIN_GARDENS],
				state.bank, state.squares)
		]))

		# Eliminate player_eliminated to player_eliminator, and test that
		# player_eliminated's belongings are properly transferred to the
		# player_eliminator and that no other changes are made to the state.
		str_before = str(state)
		state.apply(GroupOfChanges([
			GameStateChange.eliminate(player_eliminated, player_eliminator, state)]))
		str_after = str(state)
		expected_diff = [
			# Eliminated player stats
			('Position: %d' % INDEX[MARVIN_GARDENS], 'Position: -1'),
			('Cash: 560', 'Cash: 0'),
			('Oriental Avenue, Vermont Avenue, Connecticut Avenue, States Avenue, Short Line Railroad, ', ''),
			('1: 3', '1: 0'),
			('2: 1', '2: 0'),
			('100: 1', '100: 0'),
			('Jail free count: 1', 'Jail free count: 0'),
			('Is in game: True', 'Is in game: False'),

			# Eliminator player stats
			('Cash: 250', 'Cash: 1035'),
			('Atlantic Avenue, Ventnor Avenue, Marvin Gardens, Reading Railroad, Pennsylvania Railroad, B. & O. Railroad, ',
			 'Atlantic Avenue, Ventnor Avenue, Marvin Gardens, Reading Railroad, Pennsylvania Railroad, B. & O. Railroad, Oriental Avenue, Vermont Avenue, Connecticut Avenue, States Avenue, Short Line Railroad, '),
			('1: 0', '1: 3'),
			('2: 0', '2: 1'),
			('100: 3', '100: 4'),
			('Jail free count: 0', 'Jail free count: 1'),

			# Property stats
			('Num houses: 3', 'Num houses: 0'),      # Oriental Avenue
			('Num houses: 3', 'Num houses: 0'),      # Vermont Avenue
			('Num houses: 3', 'Num houses: 0'),      # Connecticut Avenue

			# Housing stats
			('Houses remaining: 14', 'Houses remaining: 23')  # 9 houses from light blues
		]
		self.assertDiffGameStates(str_before, str_after, expected_diff,
			msg='Player was not eliminated properly. The following changes were made to the GameState:')
 def test_RotateRoles_2(self):
     e = UDPGameEngine()
     s = GameState()
     s.player_size = 2
     s.roles = [GameState.ROLE_LEFT_PADDLE, GameState.ROLE_RIGHT_PADDLE]
     s.players = [-1]*(s.player_size + 1)
     s.players[GameState.ROLE_LEFT_PADDLE] = 0
     s.players[GameState.ROLE_RIGHT_PADDLE] = 1
     e.RotateRoles(s)
     self.assertTrue(s.roles == [GameState.ROLE_RIGHT_PADDLE, 
         GameState.ROLE_LEFT_PADDLE])
     self.assertTrue(s.players == [-1, 1, 0])
	def test_eliminate_to_bank(self):
		state = GameState(1)
		player = state.players[0]

		# Set up player to have some clout
		self.setup_eliminated_player(state)

		# Move player to a square where he would likely lose to the bank (e.g.
		# Luxury Tax)
		state.apply(GroupOfChanges([
			GameStateChange.change_position(player, INDEX[LUXURY_TAX], state.bank,
			state.squares)
		]))

		# Eliminate the player to the bank, and test that the player's belongings
		# are properly transferred to the bank and that no other changes are
		# made to the state.
		str_before = str(state)
		state.apply(GroupOfChanges([
			GameStateChange.eliminate(player, state.bank, state)]))
		str_after = str(state)
		expected_diff = [
			# Player stats
			('Position: %d' % INDEX[LUXURY_TAX], 'Position: -1'),
			('Cash: 560', 'Cash: 0'),
			('Oriental Avenue, Vermont Avenue, Connecticut Avenue, States Avenue, Short Line Railroad, ', ''),
			('1: 3', '1: 0'),
			('2: 1', '2: 0'),
			('100: 1', '100: 0'),
			('Jail free count: 1', 'Jail free count: 0'),
			('Is in game: True', 'Is in game: False'),

			# Bank stats
			('Cash: 940', 'Cash: 1725'),
			('Mediterranean Avenue, Baltic Avenue, Reading Railroad, St. Charles Place, Electric Company, Virginia Avenue, Pennsylvania Railroad, St. James Place, Tennessee Avenue, New York Avenue, Kentucky Avenue, Indiana Avenue, Illinois Avenue, B. & O. Railroad, Atlantic Avenue, Ventnor Avenue, Water Works, Marvin Gardens, Pacific Avenue, North Carolina Avenue, Pennsylvania Avenue, Park Place, Boardwalk, ',
			 'Mediterranean Avenue, Baltic Avenue, Reading Railroad, St. Charles Place, Electric Company, Virginia Avenue, Pennsylvania Railroad, St. James Place, Tennessee Avenue, New York Avenue, Kentucky Avenue, Indiana Avenue, Illinois Avenue, B. & O. Railroad, Atlantic Avenue, Ventnor Avenue, Water Works, Marvin Gardens, Pacific Avenue, North Carolina Avenue, Pennsylvania Avenue, Park Place, Boardwalk, Oriental Avenue, Vermont Avenue, Connecticut Avenue, States Avenue, Short Line Railroad, '),
			('1: 0', '1: 3'),
			('2: 2', '2: 3'),
			('100: 3', '100: 4'),

			# Property stats
			('Num houses: 3', 'Num houses: 0'),      # Oriental Avenue
			('Num houses: 3', 'Num houses: 0'),      # Vermont Avenue
			('Num houses: 3', 'Num houses: 0'),      # Connecticut Avenue
			('Mortgaged: True', 'Mortgaged: False'), # States Avenue
			('Mortgaged: True', 'Mortgaged: False'), # Short Line Railroad

			# Housing stats
			('Houses remaining: 23', 'Houses remaining: 32')  # 9 houses from light blues
		]
		self.assertDiffGameStates(str_before, str_after, expected_diff,
			msg='Player was not eliminated properly. The following changes were made to the GameState:')
    def __init__(self, settings, platformer_instance):
        GameState.__init__(self, settings)
        self.platformer_instance = platformer_instance

        self.keystate.update({
            'left':False, 
            'right':False, 
            'jump':False,
            'up':False,
            'down':False,
        })

        self.font = pygame.font.Font(pygame.font.match_font("consolas", bold=True), 24)
 def configure_keybindings(self):
     GameState.configure_keybindings(self)
     
     self.keydown_action_map.update({
         QUIT:           lambda: self.state_manager.set_current_state(GameStateManager.MAIN_MENU_STATE),
         PAUSE:          lambda: None,
         SHOW_GRID:      lambda: self.settings.set_show_grid(not self.settings.show_grid()),
         TOGGLE_3D:      lambda: self.settings.set_draw_3d(not self.settings.draw_3d())
     })
     
     if self.settings.dev_mode():
         self.keydown_action_map.update({
             FREEZE_MODE:    lambda: self.settings.set_frozen_mode(not self.settings.frozen_mode())
         })
Esempio n. 57
0
 def __init__(self, gc):
     """Initialisation des ressources et des modèles qui ne doivent être initialisés qu'une seule fois"""
     GameState.__init__(self, gc)
     self.areas = {}
     self.area = None
     self.description_hash = {}
     # self.default_verb = 'look_at'  # inside set_query_mode()
     self._verb = None  # may not be needed
     self._complement = None
     self.set_query_mode(False)  # ok??
     self.inventory = Inventory()
     #Affichage de l'inventaire
     self.view.fillInventoryLayer(self.inventory)
     self.set_inventory_layer()
Esempio n. 58
0
    def __init__(self, player):
        """
        Implementation of Monte Carlo Tree Search

        Creates a root of an MCTS tree to keep track of the information
        obtained throughout the course of the game in the form of a tree
        of MCTS nodes

        The data structure of a node consists of:
          - the game state which it corresponds to
          - w, the number of wins that have occurred at or below it in the tree
          - n, the number of plays that have occurred at or below it in the tree
          - expanded, whether all the children (legal moves) of the node have
            been added to the tree

        To access the node attributes, use the following format. For example,
        to access the attribute 'n' of the root node:
          policy = MCTSPolicy()
          current_node = policy.root
          policy.tree.node[current_node]['n']
        """
        self.digraph = nx.DiGraph()
        self.player = player
        self.num_simulations = 0
        # Constant parameter to weight exploration vs. exploitation for UCT
        self.uct_c = np.sqrt(2)

        self.node_counter = 0

        empty_board = GameState()
        self.digraph.add_node(self.node_counter, attr_dict={'w': 0,
                                                            'n': 0,
                                                            'uct': 0,
                                                            'expanded': False,
                                                            'state': empty_board})
        empty_board_node_id = self.node_counter
        self.node_counter += 1

        self.last_move = None

        if player is 'O':
            for successor in [empty_board.transition_function(*move) for move in empty_board.legal_moves()]:
                self.digraph.add_node(self.node_counter, attr_dict={'w': 0,
                                                                    'n': 0,
                                                                    'uct': 0,
                                                                    'expanded': False,
                                                                    'state': successor})
                self.digraph.add_edge(empty_board_node_id, self.node_counter)
                self.node_counter += 1
	def test_draw_card(self):
		state = GameState(1)
		player = state.players[0]

		# Test every card in both decks
		dict_card_types = { CHANCE_CARD: 'Chance', COMMUNITY_CHEST_CARD: 'Community Chest' }
		for card_type, card_str in dict_card_types.iteritems():
			deck = state.decks[card_type]

			# Draw every card in the deck, check that cards are handled correctly
			# and that nothing else in the state is changed
			card = None
			for i in range(0, deck.size()):
				card = deck.peek()
				jail_free_count_before = player.jail_free_count
				str_before = str(state)
				expected_diff = None  # initialized in the following if-block

				state.apply(GroupOfChanges([
					GameStateChange.draw_card(deck, player)]))
				if card == LMBDA_GET_OUT_OF_JAIL_FREE:
					# Check that the card is not replaced on the deck, and that the
					# player's Jail Free card count is incremented.
					self.assertEqual(player.jail_free_count, jail_free_count_before + 1)
					for j in range(0, deck.size()):
						self.assertNotEqual(deck.draw(), LMBDA_GET_OUT_OF_JAIL_FREE)

					# Initialize. Used after this if-block to ensure that nothing else
					# in the state was changed.
					expected_diff = [
						('Jail free count: %d' % jail_free_count_before,
						 'Jail free count: %d' % player.jail_free_count)
					]
				else:
					# Check that the card is replaced on the bottom if it is not the
					# Jail Free card.
					for j in range(0, deck.size() - 1):
						deck.draw()
					self.assertEqual(deck.draw(), card) # compare with last card

					# Initialize
					expected_diff = []

				# Check that the rest of the state is unchanged by comparing the
				# string encodings of the GameStates
				str_after = str(state)
				self.assertDiffGameStates(str_before, str_after, expected_diff,
					msg='The GameState was not modified correctly')