Python GameState.GameState类代码示例

    def test_interrogate_for_the_same_two_cards_asks_for_rank_or_suit(self):
        try:
            old_raw_input = raw_input
            Interactive.raw_input = mock_raw_input('1', '3L', '3L', 'suit')  # opponent id, low card, high card

            player = HumanPlayer('joe')
            tom = AIPlayer('Tom')
            tom._hand = [(1, 'L'), (3, 'L'), (6, 'L'), (2, 'H'), (8, '$'), (9, '$')]

            state = GameState()
            state.turn = 10
            state.current_player = player
            state.players = [player, tom]
            state.question_cards = [(1, '$'), (3, 'L'), (3, 'L')]

            with captured_output() as (out, err):
                turn_ended = interrogate_command(state)

            self.assertEqual('Interrogate\n'
                             'Question cards: 1$ 3L 3L\n'
                             'Cards in this range: 3', output(out))
            turn = state.history.pop()
            self.assertEqual(10, turn['turn'])
            self.assertEqual('joe', turn['player'].name)
            self.assertEqual('Tom', turn['opponent'].name)
            self.assertEqual('interrogate', turn['action'])
            self.assertEqual('3L->3L [suit]', str(turn['range']))
            self.assertEqual(3, turn['result'])
            self.assertTrue(turn_ended)
        finally:
            Interactive.raw_input = old_raw_input

 def test_discard_question_cards(self):
     state = GameState()
     state.question_cards = [(2, 'H'), (7, 'H'), (5, '$')]
     state.discard_deck = []
     discard_question_cards(state.question_cards, state.discard_deck)
     self.assertEqual([(2, 'H'), (7, 'H'), (5, '$')], state.discard_deck)
     self.assertEqual([], state.question_cards)

    def test_secret_asks_for_two_cards_puts_the_range_in_history_and_display_the_result(self):
        try:
            old_raw_input = raw_input
            Interactive.raw_input = mock_raw_input('1', '9$', '1H')  # opponent id, low card, high card

            player = HumanPlayer('joe')
            donna = AIPlayer('donna')
            donna._hand = [(1, 'L'), (3, 'L'), (6, 'L'), (2, 'H'), (8, '$'), (9, '$')]

            state = GameState()
            state.turn = 1
            state.current_player = player
            state.players = [player, donna]
            state.question_cards = [(1, 'L'), (3, 'L'), (7, 'L')]

            with captured_output() as (out, err):
                turn_ended = secret_command(state)

            self.assertEqual('Secret\n'
                             'Cards in this range: 2', output(out))
            turn = state.history.pop()
            self.assertEqual(1, turn['turn'])
            self.assertEqual('joe', turn['player'].name)
            self.assertEqual('donna', turn['opponent'].name)
            self.assertEqual('secret', turn['action'])
            self.assertEqual(['L', 'H', '$'], turn['range'].suits)
            self.assertEqual([9, 1], turn['range'].ranks)
            self.assertEqual(2, turn['result'])
            self.assertTrue(turn_ended)
            self.assertEqual(0, state.current_player.secret)
        finally:
            Interactive.raw_input = old_raw_input

    def test_draw_question_cards(self):
        state = GameState()
        state.interrogation_deck = [(8, 'H'), (3, '$'), (1, '$'), (1, 'L')]

        draw_question_cards(state)
        self.assertItemsEqual([(1, 'L'), (1, '$'), (3, '$')], state.question_cards)
        self.assertEqual([(8, 'H')], state.interrogation_deck)

    def test_accuse_bad_guess_of_cards(self):
        try:
            old_raw_input = raw_input
            Interactive.raw_input = mock_raw_input('1', '1L', '2L')  # opponent id, first card, second card

            joe = HumanPlayer('joe')
            joe._hand = [(4, 'L'), (8, 'L'), (5, 'H'), (8, 'H')]
            ai = AIPlayer('ai')
            ai._hand = [(1, 'L'), (3, 'L'), (1, 'H'), (9, '$')]

            state = GameState()
            state.turn = 23
            state.current_player = joe
            state.players = [joe, ai]
            state.evidence_cards = [(5, '$'), (5, 'L')]

            with captured_output() as (out, err):
                self.assertTrue(accuse_command(state))

            self.assertEqual('Accuse\n\n'
                             'Your guess is: Incorrect', output(out))
            accusation = state.accusations.pop()
            self.assertEqual('joe', accusation['player'].name)
            self.assertEqual('ai', accusation['accused'].name)
            self.assertEqual([(1, 'L'), (2, 'L')], accusation['cards'])
            self.assertEqual('incorrect', accusation['outcome'])
            self.assertEqual('ended', state.status)
        finally:
            Interactive.raw_input = old_raw_input

    def test_accuse_bad_guess_of_murderer(self):
        try:
            old_raw_input = raw_input
            Interactive.raw_input = mock_raw_input('1', '3L', '5L')  # opponent id, first card, second card

            joe = HumanPlayer('joe')
            joe._hand = [(4, 'L'), (7, 'L'), (5, 'H'), (8, 'H')]
            ai1 = AIPlayer('ai1')
            ai1._hand = [(1, 'L'), (3, 'L'), (1, 'H'), (9, '$')]
            ai2 = AIPlayer('ai2')
            ai2._hand = [(8, 'L'), (3, 'H'), (2, '$'), (3, '$')]

            state = GameState()
            state.turn = 23
            state.current_player = joe
            state.players = [joe, ai1, ai2]
            state.evidence_cards = [(3, 'L'), (5, 'L')]

            with captured_output() as (out, err):
                self.assertTrue(accuse_command(state))

            self.assertEqual('Accuse\n\n'
                             'Your guess is: Incorrect', output(out))
            self.assertEqual('ended', state.status)
        finally:
            Interactive.raw_input = old_raw_input

    def test_interrogate_asks_for_two_cards_puts_the_range_in_history_and_display_the_result(self):
        try:
            old_raw_input = raw_input
            Interactive.raw_input = mock_raw_input('1', '3L', '7L')  # opponent id, low card, high card

            player = HumanPlayer('joe')
            tom = AIPlayer('tom')
            tom._hand = [(1, 'L'), (3, 'L'), (6, 'L'), (2, 'H'), (8, '$'), (9, '$')]

            state = GameState()
            state.turn = 10
            state.current_player = player
            state.players = [player, tom]
            state.question_cards = [(1, 'L'), (3, 'L'), (7, 'L')]

            with captured_output() as (out, err):
                turn_ended = interrogate_command(state)

            self.assertEqual('Interrogate\n'
                             'Question cards: 1L 3L 7L\n'
                             'Cards in this range: 2', output(out))
            turn = state.history.pop()
            self.assertEqual(10, turn['turn'])
            self.assertEqual('joe', turn['player'].name)
            self.assertEqual('tom', turn['opponent'].name)
            self.assertEqual('interrogate', turn['action'])
            self.assertEqual(['L'], turn['range'].suits)
            self.assertEqual([3, 4, 5, 6, 7], turn['range'].ranks)
            self.assertEqual(2, turn['result'])
            self.assertTrue(turn_ended)
        finally:
            Interactive.raw_input = old_raw_input

 def getNextStep(self,state):
     listState=[]
     st=time.time()
     if state.player==SELF_PLAYER:
         tmpPlayer=ENEMS_PLAYER
     else:
         tmpPlayer=SELF_PLAYER
     loc,dirs=self.getMoveCombinationAll(tmpPlayer, state)
  
     for i in range(len(loc)):
         tempLoc=loc[i]
         tempDirs=dirs[i]
         colisionMove=False
         for e in tempLoc:
             if tempLoc.count(e)>1:
                 colisionMove=True
         if colisionMove:
             continue
         cMap=self.getClearMap(state,tmpPlayer)
         for (r,c) in tempLoc:
             cMap[r][c]=tmpPlayer
         s=GameState(cMap, tmpPlayer)
         s.dirs=tempDirs
         listKill=self.preKill(s)
         for (r,c,p) in listKill:
             s.map[r][c]=LAND
         s.reward=(len(self.getAnts(s,SELF_PLAYER)),len(self.getAnts(s, ENEMS_PLAYER)))
         listState.append(s)
     
     return listState

    def test_draw_question_cards_when_there_are_not_enough_cards_in_the_interrogation_deck(self):
        state = GameState()
        state.interrogation_deck = [(4, 'L')]
        state.discard_deck = [(3, '$'), (6, 'H'), (7, 'L')]

        draw_question_cards(state)
        self.assertEqual(3, len(state.question_cards))
        self.assertIn((4, 'L'), state.question_cards)
        self.assertEqual(0, len(state.discard_deck))
        self.assertEqual(1, len(state.interrogation_deck))

def search(state, level):
    if level % 100 == 0:
        print(str(level))
    if level == TEST_DEPTH:
        pass

    newState = GameState()
    newState.setBoard(state.copyArr())
    search(newState, level + 1)
    pass

    def test_players_except(self):
        state = GameState()
        tom = HumanPlayer('tom')
        tim = AIPlayer('tim')
        tam = AIPlayer('tam')
        ari = AIPlayer('ari')

        state.players = [tom, tim, tam, ari]

        self.assertEqual([tom, tam], state.players_except(tim, ari))

    def test_players_except_should_return_gracefully_if_player_not_in_players(self):
        state = GameState()
        tom = HumanPlayer('tom')
        tim = AIPlayer('tim')

        state.players = [tom]

        try:
            self.assertEqual([tom], state.players_except(tim))
        except ValueError:
            self.fail("GameState.players_except(person) should not fail if person is not in players")

    def test_secret_is_refused_if_no_secrets_left(self):
        player = HumanPlayer('joe')
        player._secret = 0

        state = GameState()
        state.turn = 1
        state.current_player = player

        with captured_output() as (out, err):
            turn_ended = secret_command(state)

        self.assertEqual('Secret already used!', output(out))
        self.assertFalse(turn_ended)

    def test_print_summary_at_start(self):
        human = HumanPlayer('john')
        human._hand = [(3, 'L'), (5, 'H'), (9, '$')]

        state = GameState()
        state.human_player = human
        state.players = [human]

        with captured_output() as (out, err):
            print_summary(state)

        self.assertEqual('Game Summary\n'
                         'Your hand: 3L 5H 9$\n'
                         'Secret to play: [john: 1]', output(out))

 def __init__(self):
     GameState.__init__(self)
     self.time = 0.0
     self.playerSprites = pygame.sprite.Group()
     self.playerSprites.add(BorderPlayer(
         Globals.WIDTH, Globals.HEIGHT, 0, 0, Player.INDEX_DOWN))
     self.playerSprites.add(BorderPlayer(
         Globals.WIDTH, Globals.HEIGHT,
         Globals.WIDTH, 0, Player.INDEX_LEFT))
     self.playerSprites.add(
         BorderPlayer(Globals.WIDTH, Globals.HEIGHT,
                      0, Globals.HEIGHT, Player.INDEX_RIGHT))
     self.playerSprites.add(
         BorderPlayer(Globals.WIDTH, Globals.HEIGHT,
                      Globals.WIDTH, Globals.HEIGHT, Player.INDEX_UP))