Python Board.get_winner方法代码示例

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import get_winner [as 别名]
def main(prepop_board=None):
    if prepop_board:
        board = Board(prepop_board)
    else:
        board = Board()
    p1 = Human('O')
    p2 = Human('X')
    players = [p1, p2]
    current_player = 0
    while not (board.is_full() or board.get_winner()):
        #os.system('clear')
        print board
        print
        player = players[current_player]
        while True:
            move = player.get_next_move(board)
            try:
                board.move(move, player.symbol)
                break
            except:
                pass
        current_player = (current_player + 1) % 2

    # display final state
    os.system('clear')
    print board
    print
    winner = board.get_winner()
    if winner:
        print winner + ' wins!'
    else:
        print 'A draw!'

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import get_winner [as 别名]
def main(player_first = True):
    WIDTH = 3
    HEIGHT = 3

    board = Board(WIDTH, HEIGHT)
    interaction = Interaction(WIDTH, HEIGHT)
    computer = Computer()
    turn = 'X'
    if player_first:
        computer_tile = 'O'
    else:
        computer_tile = 'X'

    while board.get_winner() is None and not board.is_cat_game():
        if turn == computer_tile:
            x, y = computer.get_move(board, computer_tile)
            board.place_tile(turn, x, y)
        else:
            x, y = interaction.get_move(turn, board)
            board.place_tile(turn, x, y)
        if turn == 'X':
            turn = 'O'
        else:
            turn = 'X'

    if board.is_cat_game():
        interaction.display_cat_game(board)
    else:
        interaction.display_winner(board, board.get_winner() != computer_tile)

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import get_winner [as 别名]
def run_test():
    board = Board()
    bot1 = Bot(1, board)
    bot2 = Bot(2, board)
    while not board.get_winner():
        print board
        if not board.can_be_played():
            break
        bot1.act()
        print board
        if not board.can_be_played():
            break
        bot2.act()

    print board
    bot1.update_strategy()
    bot2.update_strategy()
    print "bot %d wins" % board.get_winner()

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import get_winner [as 别名]
    def test_gameplay_identical_opposite_mark(self):
        """
        Test that the gameplay followed in the above test is identical when the symbols are reversed
        """
        board = Board()
        board.add_mark(0, "X")
        board.add_mark(1, "O")
        board.add_mark(6, "X")
        board.add_mark(board.find_next_move("O"), "O")
        self.assertIn(board.find_next_move("X"), [4, 8])  # 4 and 8 guarantee the win for X

        board.add_mark(4, "X")
        board.add_mark(board.find_next_move("O"), "O")
        board.add_mark(board.find_next_move("X"), "X")
        self.assertEquals(board.get_winner(), "X")  # Test that X actually wins the game

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import get_winner [as 别名]
    def test_gameplay_first_player_winning_setup(self):
        """
        Test that the first player will have a winning setup if the middle square is left unplayed.
        """
        board = Board()
        board.add_mark(0, "O")
        board.add_mark(1, "X")
        board.add_mark(6, "O")
        board.add_mark(board.find_next_move("X"), "X")
        self.assertIn(board.find_next_move("O"), [4, 8])  # 4 and 8 guarantee the win for O

        board.add_mark(4, "O")
        board.add_mark(board.find_next_move("X"), "X")
        board.add_mark(board.find_next_move("O"), "O")
        self.assertEquals(board.get_winner(), "O")  # Test that O actually wins the game

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import get_winner [as 别名]
def main():
	random_seed = int( time.time() * 1000 )
	print "seeding random with", random_seed
	random.seed( random_seed )

	player_one = Player( PlayerNumber.one, sys.argv[ 1 ] )
	player_two = Player( PlayerNumber.two, sys.argv[ 2 ] )

	board = Board( player_one, player_two )

	board_state = board.get_state()
	while board_state != BoardState.game_finished:
		for event in pygame.event.get():
			if event.type == pygame.QUIT:
				pygame.quit()
				return

		pygame.display.update()
		board.update()
		board_state = board.get_state()

		display_surface.fill( ( 10, 10, 10 ) )
		board.render( display_surface )

		time.sleep( 0.01 )

	winning_player = board.get_winner()
	if winning_player is None:
		print "Game is a tie"
	else:
		print winning_player, "has won"


	while True:
		for event in pygame.event.get():
			if event.type == pygame.QUIT:
				pygame.quit()
				return

		pygame.display.update()
		display_surface.fill( ( 10, 10, 10 ) )
		board.render( display_surface )

		time.sleep( 0.1 )

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import get_winner [as 别名]
class App(gtk.Window):
	def __init__(self):
		super(App, self).__init__()

		self.set_title('Tic-Tac-Toe')
		self.connect('destroy', gtk.main_quit)
		self.set_position(gtk.WIN_POS_CENTER)
		self.set_default_size(250,250)
		self.show()

		self.init_widgets()
		self.game_count = 0
		self.start_new_game()
	
	def init_widgets(self):
		vbox = gtk.VBox()
		self.add(vbox)
		
		self.button_position = {}
		self.buttons = {}

		for i in xrange(3):
			hbox = gtk.HBox()
			vbox.add(hbox)
			for j in xrange(3):
				button = gtk.Button()
				self.button_position[button] = (i,j)
				hbox.add(button)
				button.connect('clicked', self.game_button_clicked)
				button.show()
				self.buttons[i, j] = button
			hbox.show()

		hbox = gtk.HBox()

		restart_button = gtk.Button('restart')
		restart_button.connect('clicked', self.start_new_game)
		restart_button.show()
		hbox.add(restart_button)
		
		self.score_label= gtk.Label('0 - 0')
		self.score_label.show()
		hbox.add(self.score_label)

		vbox.add(hbox)
		hbox.show()

		vbox.show()
	
	def draw_board_state(self):
		for i in xrange(3):
			for j in xrange(3):
				button = self.buttons[i,j]
				if self.board.board[i][j] == 0:
					label = '  '
				elif self.board.board[i][j] == 1:
					label = 'X'
				else:
					label = '0'
				button.set_label(label)
				
	def start_new_game(self, widget=None):
		for button in self.button_position:
			button.set_label(' ')

		self.board = Board()

		if self.game_count % 2 == 0:
			self.bot = Bot(1, self.board)
			self.bot.act()
			self.draw_board_state()
			self.player_color = 2
		else:
			self.bot = Bot(2, self.board)
			self.player_color = 1

		self.game_count += 1

	def game_button_clicked(self, button):
		position = self.button_position[button]

		if position not in self.board.get_possible_actions():
			return

		self.board.move(self.player_color, self.button_position[button]) 
		self.draw_board_state()
		
		if not self.board.can_be_played():
			return

		self.bot.act()
		self.draw_board_state()

		if not self.board.get_winner() != 0:
			return

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import get_winner [as 别名]
if number == "1":
    print "Ok, you will start the game first! Prepare for action!"
    print
    board.player_starts(HUMAN)
    print_board(board)
elif number == "2":
    print "Super Computer starts the game. He's thinking about first his move, so"
    print "you should be patient..."
    print
    board.player_starts(COMPUTER)
    board.put(randint(0, 2), randint(0, 2), COMPUTER)
    print_board(board)
else:
    exit(0)

while board.get_winner() == None:
    print
    if board.player_turn() == HUMAN:
        x = int(raw_input("Now is your turn. Enter X coord starting from 0 to 2: "))
        y = int(raw_input("                  Enter Y coord starting from 0 to 2: "))
        print
        while x not in [0, 1, 2] or y not in [0, 1, 2] or not board.can_put(x, y):
            first = False
            if x not in [0, 1, 2] or y not in [0, 1, 2]:
                print "Oops, invalid coords. Please try again."
            else:
                print "As you can see, this is reserved place. Choose another one!"
            print
            x = int(raw_input("Enter X coord starting from 0 to 2: "))
            y = int(raw_input("Enter Y coord starting from 0 to 2: "))
            print

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import get_winner [as 别名]
class TestBoard(TestCase):
    def setUp(self):
        self.board = Board()

    def test_clear_board_on_start(self):
        self.assertTrue(self.board.is_clear())

    def test_clear_board(self):
        self.assertTrue(self.board.is_clear())
        self.board.put(0, 0, HUMAN)
        self.assertFalse(self.board.is_clear())
        self.board.clear()
        self.assertTrue(self.board.is_clear())

    def test_full_board(self):
        self.assertFalse(self.board.is_full())
        self.board.put(1, 1, HUMAN)
        self.assertFalse(self.board.is_full())
        self.board.board = [[COMPUTER, COMPUTER, COMPUTER],
                            [COMPUTER, HUMAN, COMPUTER],
                            [COMPUTER, COMPUTER, COMPUTER]]
        self.assertTrue(self.board.is_full())

    def test_can_put_on_board(self):
        self.assertTrue(self.board.can_put(0, 0))
        self.assertTrue(self.board.put(0, 0, HUMAN))

        self.assertFalse(self.board.can_put(0, 0))
        self.assertTrue(self.board.can_put(0, 1))
        self.assertTrue(self.board.can_put(1, 1))
        self.assertFalse(self.board.put(0, 0, HUMAN))

        self.assertEqual(HUMAN, self.board.owner_of(0, 0))

    def test_next_player(self):
        self.board.player_starts(COMPUTER)
        self.assertEqual(HUMAN, self.board.next_player())
        self.assertEqual(COMPUTER, self.board.next_player())
        self.assertEqual(HUMAN, self.board.next_player())

    def test_walk(self):
        self.board.player_starts(COMPUTER)
        self.board.player_starts(HUMAN)
        self.assertEqual(HUMAN, self.board.player_turn())
        self.assertTrue(self.board.put(0, 0, HUMAN))
        self.assertEqual(COMPUTER, self.board.player_turn())

    def test_game_winner(self):
        self.board.board = [[HUMAN, EMPTY, EMPTY],
                            [EMPTY, HUMAN, EMPTY],
                            [EMPTY, EMPTY, HUMAN]]
        self.assertEqual(HUMAN, self.board.get_winner())

        self.board.board = [[HUMAN, EMPTY, COMPUTER],
                            [HUMAN, HUMAN, HUMAN],
                            [COMPUTER, COMPUTER, EMPTY]]
        self.assertEqual(HUMAN, self.board.get_winner())

        self.board.board = [[COMPUTER, HUMAN, COMPUTER],
                            [COMPUTER, HUMAN, COMPUTER],
                            [HUMAN, COMPUTER, HUMAN]]
        self.assertEqual(EMPTY, self.board.get_winner())

        self.board.board = [[EMPTY, HUMAN, COMPUTER],
                            [COMPUTER, HUMAN, COMPUTER],
                            [EMPTY, COMPUTER, HUMAN]]
        self.assertEqual(None, self.board.get_winner())

        self.board.board = [[EMPTY, HUMAN, COMPUTER],
                            [HUMAN, COMPUTER, HUMAN],
                            [COMPUTER, COMPUTER, HUMAN]]
        self.assertEqual(COMPUTER, self.board.get_winner())

        self.board.board = [[EMPTY, HUMAN, HUMAN],
                            [HUMAN, COMPUTER, HUMAN],
                            [COMPUTER, COMPUTER, COMPUTER]]
        self.assertEqual(COMPUTER, self.board.get_winner())

        self.board.board = [[EMPTY, HUMAN, HUMAN],
                            [HUMAN, COMPUTER, HUMAN],
                            [COMPUTER, COMPUTER, COMPUTER]]
        self.assertEqual(COMPUTER, self.board.get_winner())

        self.board.board = [[HUMAN, COMPUTER, HUMAN],
                            [HUMAN, COMPUTER, HUMAN],
                            [HUMAN, HUMAN, COMPUTER]]
        self.assertEqual(HUMAN, self.board.get_winner())

        self.board.board = [[HUMAN, COMPUTER, HUMAN],
                            [COMPUTER, COMPUTER, HUMAN],
                            [HUMAN, EMPTY, HUMAN]]
        self.assertEqual(HUMAN, self.board.get_winner())

    def test_evaluate_move(self):
        board = [[EMPTY, EMPTY, EMPTY],
                 [COMPUTER, HUMAN, EMPTY],
                 [COMPUTER, EMPTY, HUMAN]]
        self.board.board = deepcopy(board)
        self.assertEqual(1, self.board.evaluate_move(0, 0, HUMAN))
        self.assertEqual(1, self.board.evaluate_move(0, 0, COMPUTER))
#.........这里部分代码省略.........