Esempio n. 1
0
def main():
    
    board = ExtremeBoard() #set up boards, players
    players = [Player(1), Player(2)]
    
    while board.extreme_board_playable: #play until someone has won
        print('building board...')
        board.RenderExtremeBoard()
        print('player 1 turn...')
        board.ChooseBoard(players[0])
        print('checking for winner...')
        if board.CheckIfXBWon():
            break
        board.RenderExtremeBoard()
        board.ChooseBoard(players[1])
        if board.CheckIfXBWon():
            break
        
    #TODO: just make this a little more spiffy, maybe an if statement for alt. message if there's no winner...and set up the asterisks to adjust??? idk
    if board.extreme_board_won_by == '[X]':
        winner = '1'
    else:
        winner = '2'
    print('*******************************')
    print('\tPlayer ' + winner + ' won!')
    print('*******************************')
Esempio n. 2
0
def test_check_win_a():
    p1 = Player("X")
    p2 = Player("O")
    board = Board(p1, p2)

    board.add_move(3, p2)
    board.add_move(3, p1)
    board.add_move(2, p2)
    board.add_move(4, p1)
    assert board.check_winner()[0] == False
Esempio n. 3
0
def test_check_win_b():
    p1 = Player("X")
    p2 = Player("O")
    board = Board(p1, p2)

    board.board = [['X', ' ', ' ', ' ', ' ', ' ', ' '],
                   ['X', ' ', ' ', ' ', ' ', ' ', ' '],
                   ['X', ' ', ' ', ' ', ' ', ' ', ' '],
                   ['O', ' ', ' ', 'O', ' ', ' ', ' '],
                   ['X', ' ', ' ', 'O', ' ', ' ', ' '],
                   ['X', 'O', ' ', 'O', ' ', ' ', ' ']]

    assert board.check_winner()[0] == False
Esempio n. 4
0
File: blah.py Progetto: izzycecil/72
def gameFrame(window, stack):
    # b = Board(None, filename='media/maps/test')
    
    b = Board((20,20))

    for x in range(0,20):
        for y in range(0,20):
            b.spaces[x][y] = Tile('media/tileproto1.png', [])

    p = Player(20, 10, None, None, None, 4)
    p.makeRenderable(window)
    b.placeEntity(p, 3, 4)
    b.placeEntity(Clerk(20, 10, None, 'redneck'), 5,5)

    return GameplayFrame(stack, window, b, p)
Esempio n. 5
0
def gameFrame(window, stack):
    # b = Board(None, filename='media/maps/test')

    b = Board((20, 20))

    for x in range(0, 20):
        for y in range(0, 20):
            b.spaces[x][y] = Tile('media/tileproto1.png', [])

    p = Player(20, 10, None, None, None, 4)
    p.makeRenderable(window)
    b.placeEntity(p, 3, 4)
    b.placeEntity(Clerk(20, 10, None, 'redneck'), 5, 5)

    return GameplayFrame(stack, window, b, p)
Esempio n. 6
0
def gameFrame(window, stack):
    clerkDialogManager = DialogManager('redneck')
    diag = DialogFrame(stack, window, clerkDialogManager, playerImage='media/avatars/protag.png', npcImage='media/avatars/notnigel.png')
    b = Board((20,20))

    for x in range(0,20):
        for y in range(0,20):
            b.spaces[x][y] = Tile('media/tiles/basic.png', [])

    p = Player(20, 10, None, None, None, 4)
    p.enableRender()
    b.placeEntity(p, 3, 4)
    b.placeEntity(Clerk(20, 10, None, diag), 5,5)

    return GameplayFrame(stack, window, b, p)
Esempio n. 7
0
    def __init__(self, main, parent, level="division_of_labor"):
        super(GameUI, self).__init__(main, parent)
        self.level_name = level

        self.chatbox = Chatbox()

        player2 = parent.player2
        loc, self.board = LevelLoad.load_level(level)
        self.board.add_client(self.main.client)

        self.player1 = Player(self.board, loc, not player2)
        self.player2 = Player(self.board, loc, player2, self.player1)
        self.which_player = player2
        self.view_player = player2

        self.mode = GameUI.PLAY_MODE
    def second_move(self):
        board = Board()
        player1 = Player("Player 1", board)
        player2 = Player("player 2", board)

        player1.place_piece(player1.pieces[2], "b6")
        assert player2.place_piece(player2.pieces[2], "f6")
    def first_move(self):
        board = Board()
        player1 = Player("Player 1", board)
        player2 = Player("player 2", board)

        player1.place_piece(player1.pieces[2], "a7")
        assert player2.place_piece(player2.pieces[2], "g7")
    def third_move(self):
        board = Board()
        player1 = Player("Player 1", board)
        player2 = Player("player 2", board)

        player1.place_piece(player1.pieces[2], "c5")
        assert player2.place_piece(player2.pieces[2], "e5")
Esempio n. 11
0
    def __init__(self, count_of_players):
        self.game_board = Board()
        self.count_of_players = count_of_players
        self.player_list = []
        self.player_color_list = [RED, GREEN, BLUE]

        for i in range(self.count_of_players):
            name = input("Enter Name for Player 1 : ")
            self.player_list.append(Player(name, self.player_color_list[i]))
Esempio n. 12
0
    def _on_move(self, ws, data):
        try:
            x, y, player, ai = data['x'], data['y'], data['player'], data['ai']
        except KeyError:
            IO.write_error('error in the incoming request')
            return

        if ai:
            self.game.board.move_player(Player.OPPONENT, x, y)
            self.game.brain.turn()
        else:
            self.game.board.move_player(Player(player), x, y)
Esempio n. 13
0
def main(word, board, hint, type):
    pygame.display.set_caption("Word Cluttered")
    background = pygame.Surface(screen1.get_size())
    screen1.blit(background, (0, 0))

    pygame.display.flip()

    global guess
    guess = []
    circle = Letters("", board, 0, 0, 0, 0, "letters", type, True)
    Letters.__init__(circle, word, board, 0, 0, 0, 0, "letters", type, True)
    allSprites = pygame.sprite.Group(circle)
    keepGoing = True
    print(str(circle))

    screen1.fill((206, 185, 177))

    allSprites.clear(screen1, background)

    tempX = 0
    tempY = 0

    used = [True for x in range(len(board)**2)]
    affected = []
    circleList = colorboard(board, word, affected, type, True)

    clock = pygame.time.Clock()

    soloCount = 0
    totalCount = len(word)
    popWords = []
    msg = ""

    while keepGoing:
        global score
        if type == "multi":
            global milliseconds
            global seconds
            global minutes

            if milliseconds > 1000:
                seconds += 1
                milliseconds -= 1000
            if seconds > 60:
                minutes += 1
                seconds -= 60

            if minutes > 1:
                screen.Multi.timesUp(score)

            timer(minutes, seconds)
            milliseconds += clock.tick_busy_loop(60)
        totalScore()
        theme(hint)

        image = pygame.image.load("images/mm.png").convert_alpha()
        rect = image.get_rect()
        image = pygame.transform.scale(image, (175, 50))
        rect.center = [180, 50]
        screen1.blit(image, rect)
        pygame.display.update()

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                keepGoing = False
            pressed1, pressed2, pressed3 = pygame.mouse.get_pressed()
            currentLetters = -1

            if pressed1:
                x = pygame.mouse.get_pos()[0]
                y = pygame.mouse.get_pos()[1]
                #  inspired from https://stackoverflow.com/questions/43641282/how-would-i-go-about-making-clickable-
                # text-in-pygame
                tx = width//2 - (len(hint)//2 * 20)
                if x in range(tx, tx+100) and y in range(30, 60):
                    define(hint)
                    pass
                if x < 175 and y < 37:
                    screen.Multi.mainMenu((175, 50), 180, 50)

                for circle in circleList:
                    currentLetters += 1
                    circleX, circleY = circle.position()
                    x = pygame.mouse.get_pos()[0]
                    y = pygame.mouse.get_pos()[1]
                    r = 40

                    if circleX + r >= x >= circleX - r and circleY + r >= y >= circleY - r and used[currentLetters]:
                        if len(guess) == 0 and circle.letter != 0:
                            guess.append(circle.letter)
                            prevX = circle.index()[0]
                            prevY = circle.index()[1]
                            used[currentLetters] = False
                            affected.append(currentLetters)

                        elif len(guess) > 0 and legal(circle.index()[0], circle.index()[1], prevX, prevY) and circle.letter != 0:
                            tempX = prevX  # for when the user deletes their answer choice
                            tempY = prevY
                            guess.append(circle.letter)
                            prevX = circle.index()[0]
                            prevY = circle.index()[1]
                            used[currentLetters] = False

                            affected.append(currentLetters)
                        if type == "solo":
                            soloAnswer(guess, word, popWords)
                        else:
                            answer(guess, word)
                        colorboard(board, word, affected, type)
            global numHints
            if event.type == pygame.KEYDOWN and pygame.key.name(event.key) == 'space':
                print("space")
                numHints = 0
                guess = []
                used = [True for x in range(len(board)**2)]

                for i in range(len(popWords)):
                    word.insert(0, popWords[i])
                    score -= 1

                popWords = []
                affected = []
                soloCount = 0
                colorboard(board, word, affected, type)
                soloAnswer(guess, word, popWords)

            if event.type == pygame.KEYDOWN and pygame.key.name(event.key) == 'h' and numHints < 5:
                i = 0
                next = ""
                size = 30
                for j in range(len(word[i])):
                    if j < len(guess) and guess[j] == (word[i])[j]:
                        next = (word[i])[j+1]
                    elif j < len(guess) and guess[j] != (word[i])[j]:
                        next = "Wrong Guess"

                if next == "":
                    next = word[i][0]

                myfont = pygame.font.SysFont("serif", 30)
                pygame.draw.rect(screen1, (206, 185, 177), (500, 40, 140, 80))
                label = myfont.render("Hint: ", 1, (0, 0, 0))
                screen1.blit(label, (520, 40))

                if next == "Wrong Guess":
                    myfont = pygame.font.SysFont("serif", 25)
                    label2 = myfont.render("Wrong", 1, (0, 0, 0))
                    label3 = myfont.render("Guess", 1, (0, 0, 0))
                    screen1.blit(label2, (520, 60))
                    screen1.blit(label3, (520, 80))
                else:
                    myfont = pygame.font.SysFont("serif", 40)
                    label2 = myfont.render(next.upper(), 1, (0, 0, 0))
                    screen1.blit(label2, (530, 65))
                    numHints += 1

            if len(guess) > 0 and event.type == pygame.KEYDOWN and pygame.key.name(event.key) == 'backspace':
                prevX = tempX
                prevY = tempY

                index = affected.pop()
                used[index] = True
                guess.pop()
                if type == "solo":
                    soloAnswer(guess, word, popWords)
                else:
                    answer(guess, word)
                colorboard(board, word, affected, type)

            if type == "solo":
                for i in range(len(word)):
                    if yesWon(guess, word[i]):
                        popWords.append(word.pop(0))
                        guess = []
                        soloCount += 1
                        score += 1
                        break
            if soloCount == totalCount:
                screen1.fill((0, 0, 0))
                pygame.display.update()
                print("winner! Score: ", score)
                sologame()

            elif won(guess, word, type):
                print("winner! Score: ", score)

                screen1.fill((0, 0, 0))
                pygame.display.update()
                guess = []
                score += 1
                msg = "point"

                from board import Player
                Player(word, hint, msg)

                if type == "multi":
                    import board
                    board.start(False)
                else:
                    sologame()

        pygame.display.flip()
        clock.tick(200)
    pygame.mouse.set_visible(True)
    pygame.quit()
Esempio n. 14
0
from board import Board
from board import Player
import ai_player

computer_player = Player("X")
human_player = Player("O")

current_board = Board(computer_player, human_player)
print(current_board)

while True:
    current_board.add_move(input("Select move"), human_player)
    print(current_board)
    if current_board.check_winner()[0]:
        print(f"Player {current_board.check_winner()[1]} is the winner")
        break
    if len(current_board.get_moves()) == 0:
        print("Game is a draw")
    current_board.add_move(
        ai_player.get_best_move(current_board, computer_player, human_player),
        computer_player)
    print(current_board)
    if current_board.check_winner()[0]:
        print(f"Player {current_board.check_winner()[1]} is the winner")
        break
    if len(current_board.get_moves()) == 0:
        print("Game is a draw")
Esempio n. 15
0
    def paint(self):
        self.updateCam()
        self.window.blit(self.buffer, (self.cameraX, self.cameraY))


if __name__ == '__main__':
    pygame.init()
    fpsClock = pygame.time.Clock()
    window = pygame.display.set_mode((600, 600))
    pygame.display.set_caption('72 --- gameTest')

    b = Board((20, 20))

    for x in range(0, 20):
        for y in range(0, 20):
            b.spaces[x][y] = Tile('media/tileproto1.png', [])

    p = Player(20, 10, None, None, None, 4)
    b.placeEntity(p, 3, 4)
    b.placeEntity(Enemy(20, 10, None, None, None, 10), 5, 5)

    g = GameplayFrame(None, window, b, p)

    while True:
        window.fill(pygame.Color(255, 255, 255))
        if not runStack([g]):
            break
        pygame.display.update()
        fpsClock.tick(30)
Esempio n. 16
0
def phase2_remove_test():
    board = Board()
    player1 = Player("Player 1", board)
    player2 = Player("player 2", board)

    player1.place_piece(player1.pieces[1], "a7")
    player2.place_piece(player2.pieces[1], "g7")
    player1.place_piece(player1.pieces[2], "a4")
    player2.place_piece(player2.pieces[2], "g4")
    player1.place_piece(player1.pieces[3], "d1")
    player2.place_piece(player2.pieces[3], "d5")

    player1.place_piece(player1.pieces[4], "b6")
    player2.place_piece(player2.pieces[4], "f6 ")
    player1.place_piece(player1.pieces[5], "c5")
    player2.place_piece(player2.pieces[5], "b4")
    player1.place_piece(player1.pieces[6], "f4")
    player2.place_piece(player2.pieces[6], "e3")

    player1.place_piece(player1.pieces[7], "d6")
    player2.place_piece(player2.pieces[7], "c4")
    player1.place_piece(player1.pieces[8], "e4")
    player2.place_piece(player2.pieces[8], "d2")
    player1.place_piece(player1.pieces[0], "d3")
    player2.place_piece(player2.pieces[0], "d6")

    player1.move_piece(player1.pieces[3], "a1")

    player2.remove_piece(player2, player1.pieces[3])

    assert player2.get_phase() == 2
    def second_node(self):
        board = Board()
        player1 = Player("Player 1", board)

        assert player1.place_piece(player1.pieces[0], "f4")
    def third_node(self):
        board = Board()
        player1 = Player("Player 1", board)

        assert player1.place_piece(player1.pieces[1], "c5")
Esempio n. 19
0
    #Oceania
    earth["westaustralia"].add_conns("newguinea", "eastaustralia",
                                     "madagascar", "indonesia")
    earth["newguinea"].add_conns("indonesia", "eastaustralia")

    #Africa
    earth["madagascar"].add_conns("southafrica", "eastafrica")
    earth["congo"].add_conns("southafrica", "eastafrica", "northafrica")
    earth["egypt"].add_conns("eastafrica", "northafrica", "south")
    earth["northafrica"].add_conns("west", "brasil", "eastafrica")
    earth["southafrica"].add_conns("eastafrica")

    #South America
    earth["brasil"].add_conns("venezuela", "argentina", "peru")
    earth["peru"].add_conns("venezuela", "argentina")

    #global
    earth.purify_transitions()
    earth.activate_transitions()
    earth.setmap("worldmap")
    earth.name = "earth"
    return earth


## Players & Countries
earth = create_earth()
blue = Country("blue", (10, 0, 150))
red = Country("red", (150, 10, 0))
players = [Player("Bluka", [blue]), Player("Redna", [red])]
Esempio n. 20
0
class GameUI(UI):
    PLAY_MODE = 1
    TYPE_MODE = 2

    def __init__(self, main, parent, level="division_of_labor"):
        super(GameUI, self).__init__(main, parent)
        self.level_name = level

        self.chatbox = Chatbox()

        player2 = parent.player2
        loc, self.board = LevelLoad.load_level(level)
        self.board.add_client(self.main.client)

        self.player1 = Player(self.board, loc, not player2)
        self.player2 = Player(self.board, loc, player2, self.player1)
        self.which_player = player2
        self.view_player = player2

        self.mode = GameUI.PLAY_MODE

    def reload_level(self):
        return GameUI(self.main, self.parent, self.level_name)

    def reblit(self, screen):
        center = (self.player1.x, self.player1.y)
        if self.view_player:
            center = (self.player2.x, self.player2.y)
        self.board.reblit(screen, center)
        self.player1.reblit(screen, center)
        self.player2.reblit(screen, center)

        self.chatbox.reblit(screen)

    def set_mode(self, mode):
        if self.mode == GameUI.TYPE_MODE:
            self.chatbox.hide_time = None
        self.mode = mode
        if self.mode == GameUI.TYPE_MODE:
            self.chatbox.hide_time = True

    def handle_key(self, event):
        if self.mode == GameUI.PLAY_MODE:
            if event.key in (pygame.K_RETURN, pygame.K_KP_ENTER):
                self.set_mode(GameUI.TYPE_MODE)
            if event.key == pygame.K_DOWN:
                self.main.send_msg("MOVED 0 1")
            if event.key == pygame.K_UP:
                self.main.send_msg("MOVED 0 -1")
            if event.key == pygame.K_LEFT:
                self.main.send_msg("MOVED -1 0")
            if event.key == pygame.K_RIGHT:
                self.main.send_msg("MOVED 1 0")
            if event.key == pygame.K_TAB:
                self.view_player = not self.which_player
        elif self.mode == GameUI.TYPE_MODE:
            if event.key in (pygame.K_RETURN, pygame.K_KP_ENTER):
                self.set_mode(GameUI.PLAY_MODE)
                self.chatbox.input_box.submit(self.main.client)
            elif event.key == pygame.K_BACKSPACE:
                self.chatbox.remove_chars()
            elif event.unicode != "":
                self.chatbox.add_string(event.unicode)

    def handle_key_up(self, event):
        if event.key == pygame.K_TAB:
            self.view_player = self.which_player
Esempio n. 21
0
def phase1_remove_test():
    board = Board()
    player1 = Player("Player 1", board)
    player2 = Player("player 2", board)

    player1.place_piece(player1.pieces[1], "a7")
    player2.place_piece(player2.pieces[1], "g7")
    player1.place_piece(player1.pieces[2], "a4")
    player2.place_piece(player2.pieces[2], "g4")
    player1.place_piece(player1.pieces[3], "a1")
    player2.place_piece(player2.pieces[3], "d1")

    player2.remove_piece(player2, player1.pieces[3])

    assert player2.get_phase() == 1
def start_game():
    clock = pygame.time.Clock()
    board = Board()
    turns = 0
    MAX_TURNS = 500

    play_ai = None
    choice = Choice("Human", "Computer")
    choice.fade_in_sec = 6.5
    screen = pygame.display.set_mode(WIN_SIZE)
    while play_ai is None:
        events = pygame.event.get()
        mouse_pos = pygame.Vector2(pygame.mouse.get_pos()) 
        
        for e in events:
            if e.type == pygame.QUIT:
                return 0
            if e.type == pygame.MOUSEBUTTONDOWN:
                if play_ai is None:
                    picked = choice.is_clicked(mouse_pos)
                    if picked == 1:
                        play_ai = False
                        player1 = Player("Player 1", 1, board)
                        player2 = Player("Player 2", 2, board)
                    elif picked == 2:
                        play_ai = True
                        player1 = Player("Player 1", 1, board)
                        player2 = AI_Player("Computer", 2, board, player1)
                    elif pygame.Rect(0,0,10,10).collidepoint(mouse_pos):
                        play_ai = "yes"
                        player1 = AI_Player("C3PO", 1, board, None)
                        player2 = AI_Player("R2D2", 2, board, player1)
                        player1.opponent = player2
        choice.draw(screen)

        pygame.display.flip()
        clock.tick(60)

    gui = Gui(board, player1, player2)
    player_toggle = itertools.cycle([player1, player2])   
    current_player = next(player_toggle)

    selected_piece = None
    prev_selected_piece = None
    prev_selected_piece_pos = None
    can_remove_piece = False

    game_won_by = None
    while True:
        if isinstance(current_player, AI_Player) and not game_won_by:
            if current_player.get_phase() == Phase.FLYING:
                AI_Player.DEPTH = 2

            move = current_player.get_best_move()
            log.info("Move score: %d", move.score)
            if move.phase == Phase.PLACING:
                piece = list(current_player.pieces.values())[0] 
                if current_player.place_piece(piece, move.dest):
                    node = gui.find_node(board.board[move.dest])
                    gui.find_piece(piece).move(*node.xy)
                    log.info("Placed %s", piece)
                else:
                    log.critical("AI BROKE. COULD NOT PLACE.")
            else:
                piece = board.board[move.src].piece
                if current_player.move_piece(piece, move.dest):
                    node = gui.find_node(board.board[move.dest])
                    gui.find_piece(piece).move(*node.xy)
                    log.info("Moved %s piece from %s", piece, move.src)
                else:
                    log.critical("AI BROKE. COULD NOT MOVE.")

            if move.remove:
                other_player = next(player_toggle)
                piece = board.board[move.remove].piece
                if other_player.remove_piece(piece):
                    for player in gui.players.values():
                        if player.player is piece.player:
                            player.remove_piece(piece.id)
                    log.info("Computer removed %s piece", piece)
                else:
                    log.critical("AI BROKE. COULD NOT REMOVE.")
                next(player_toggle) # skip the next cycle to return to normal
            turns += 1
            current_player = next(player_toggle)

        events = pygame.event.get()
        mouse_pos = pygame.Vector2(pygame.mouse.get_pos()) 
        mouse_btns = pygame.mouse.get_pressed()
        
        for e in events:
            if e.type == pygame.QUIT:
                return 0
            if e.type == pygame.MOUSEBUTTONDOWN and mouse_btns == (1,0,0):
                selected_piece = gui.get_piece(mouse_pos)
                if selected_piece:
                    log.info("%s piece picked up", selected_piece)
                    prev_selected_piece_pos = selected_piece.xy
            if e.type == pygame.MOUSEBUTTONUP and (mouse_btns == (0,0,0) or mouse_btns == (0,0,1)):
                log.info("%s piece dropped", selected_piece)
                prev_selected_piece = selected_piece
                selected_piece = None

        if game_won_by:
            pass
        elif selected_piece and not can_remove_piece:
            selected_piece.move(*mouse_pos)
        elif prev_selected_piece:
            action_succesful = False
            node = gui.get_node(mouse_pos)

            if can_remove_piece:
                other_player = next(player_toggle)
                if other_player.remove_piece(prev_selected_piece.piece):
                    for player in gui.players.values():
                        if player.player is prev_selected_piece.piece.player:
                            player.remove_piece(prev_selected_piece.piece.id)
                    log.info("Remove %s piece", prev_selected_piece.piece)
                    action_succesful = True
                    can_remove_piece = False
                next(player_toggle) # skip the next cycle to return to normal
            elif node:
                log.info("Over %s node", node)
                
                if current_player.get_phase() == Phase.PLACING:
                    if current_player.place_piece(prev_selected_piece.piece, node.node.name):
                        prev_selected_piece.move(*node.xy)
                        action_succesful = True
                else:
                    if node.node in prev_selected_piece.piece.node.neighbors() or current_player.can_fly():
                        if current_player.move_piece(prev_selected_piece.piece, node.node.name):
                            prev_selected_piece.move(*node.xy)
                            action_succesful = True
                    else:
                        log.info("Could move %s piece to %s node. Not a neighbor", prev_selected_piece, node)


            if not action_succesful:
                prev_selected_piece.move(*prev_selected_piece_pos)
            else:
                if prev_selected_piece.piece in current_player.get_mills():
                    can_remove_piece = True
                else:
                    current_player = next(player_toggle)
            prev_selected_piece = None
        
        
        if turns >= MAX_TURNS or \
           not player1.can_move() and not player2.can_move() and \
           not player1.pieces and len(player1.get_placed_pieces()) < MIN_NUM_PIECES and \
           not player2.pieces and len(player2.get_placed_pieces()) < MIN_NUM_PIECES:
            game_won_by = "TIE! Everyone"
        elif not player1.can_move() or not player1.pieces and len(player1.get_placed_pieces()) < MIN_NUM_PIECES:
            game_won_by = player2
        elif not player2.can_move() or not player2.pieces and len(player2.get_placed_pieces()) < MIN_NUM_PIECES:
            game_won_by = player1

        gui.draw_board()
        if game_won_by:
            gui.game_message("%s WON!" % (game_won_by))
        elif not can_remove_piece:
            gui.game_message("%s turn" % (current_player))
        else:
            gui.game_message("%s remove piece from other player." % (current_player))

        choice = Choice("Quit", "Play new game")
        while game_won_by is not None:
            events = pygame.event.get()
            mouse_pos = pygame.Vector2(pygame.mouse.get_pos()) 
            
            for e in events:
                if e.type == pygame.QUIT:
                    return 0
                if e.type == pygame.MOUSEBUTTONDOWN:
                    picked = choice.is_clicked(mouse_pos)
                    if picked == 1:
                        return 0
                    elif picked == 2:
                        return 1
            gui.draw_board()
            gui.game_message("%s WON!" % (game_won_by))
            gui.draw_pieces()
            choice.draw(screen)
            pygame.display.flip()
            clock.tick(60)

        gui.draw_pieces()
        gui.debug_message(str(mouse_pos), gui.tell(mouse_pos))
        pygame.display.flip()
        clock.tick(60)
    def first_node(self):
        board = Board()
        player1 = Player("Player 1", board)

        assert player1.place_piece(player1.pieces[2], "a7")
Esempio n. 24
0
def main() :
    myBoard = Board()
    myBoard.draw()
    humanPlayer = input( "Pick your token: " ).upper()
    while humanPlayer not in availableTokens :
        print( "Please enter a valid token." )
        humanPlayer = input( "Pick your token: " ).upper()

    human = Player( humanPlayer )
    computer = Player( "O" ) if humanPlayer != "O" else Player( "X" )

    while myBoard.availableMoves() :
        humanMove = int( input( "Enter your move: " ) )
        while not myBoard.isValidMove( humanMove ) :
            print( "Please enter a valid move." )
            humanMove = int( input( "Enter your move: " ) )

        myBoard.makeMove( human.getToken(), humanMove )
        myBoard.draw()

        if myBoard.isWinner( human.getToken(), humanMove ) :
            print( "{} wins!!!".format( human.getToken() ) )
            break

        if myBoard.availableMoves() :
            computerMove = myBoard.findBestMove( computer.getToken() )
            myBoard.makeMove( computer.getToken(), computerMove )
            myBoard.draw()

            if myBoard.isWinner(computer.getToken(), computerMove) :
                print("{} wins!!!".format(computer.getToken()))
                break
Esempio n. 25
0
def pieces_display():
    board = Board()
    player1 = Player("Player 1", board)
    player2 = Player("player 2", board)

    assert player1.pieces
Esempio n. 26
0
def place_all_pieces():
        board = Board()
        player1 = Player("Player 1", board)
        player2 = Player("player 2", board)

        player1.place_piece(player1.pieces[1], "a7")
        player2.place_piece(player2.pieces[1], "g7")
        player1.place_piece(player1.pieces[2], "a4")
        player2.place_piece(player2.pieces[2], "g4")
        player1.place_piece(player1.pieces[3], "d1")
        player2.place_piece(player2.pieces[3], "d5")

        player1.place_piece(player1.pieces[4], "b6")
        player2.place_piece(player2.pieces[4], "f6 ")
        player1.place_piece(player1.pieces[5], "c5")
        player2.place_piece(player2.pieces[5], "b4")
        player1.place_piece(player1.pieces[6], "f4")
        player2.place_piece(player2.pieces[6], "e3")

        player1.place_piece(player1.pieces[7], "d6")
        player2.place_piece(player2.pieces[7], "c4")
        player1.place_piece(player1.pieces[8], "e4")
        player2.place_piece(player2.pieces[8], "d2")
        player1.place_piece(player1.pieces[0], "d3")
        player2.place_piece(player2.pieces[0], "d6")

        assert True
Esempio n. 27
0
def piece_gone():
    board = Board()
    player1 = Player("Player 1", board)
    player2 = Player("player 2", board)

    player1.place_piece(player1.pieces[1], "a7")
    player2.place_piece(player2.pieces[1], "g7")
    player1.place_piece(player1.pieces[2], "a4")
    player2.place_piece(player2.pieces[2], "g4")
    player1.place_piece(player1.pieces[3], "a1")
    player2.place_piece(player2.pieces[3], "d1")

    player2.remove_piece(player2, player1.pieces[3])

    piece_removed = True
    for item in player2.get_placed_pieces():
        if item == player2.pieces[3]:
            piece_removed = False

    assert piece_removed