python-game-with-interface.py

#Rsup300 Ryan Supardi


import tkinter as tk
from tkinter import messagebox

GRID_SIZE = 6
CELL_SIZE = 100
RADIUS = CELL_SIZE // 2 - 5

class GameBoard:
    def __init__(self, size):
        self.size = size
        self.num_disks = [0] * size
        self.items = [[0] * size for _ in range(size)]
        self.points = [0] * 2

    def num_free_positions_in_column(self, column):
        return self.size - self.num_disks[column]

    def game_over(self):
        return sum(self.num_disks) == self.size ** 2

    def num_new_points(self, column, row, player):
        new_points = 0
        vertical = 0
        for r in range(row, -1, -1):
            if self.items[column][r] == player:
                vertical += 1
            else:
                if vertical >= 1:
                    vertical = 0
            if vertical == 4:
                new_points += 1

        horizontal = 0
        for c in range(max(0, column - 3), min(self.size, column + 4)):
            if self.items[c][row] == player:
                horizontal += 1
            else:
                if horizontal >= 1:
                    horizontal = 0
            if horizontal >= 4:
                new_points += 1 
        
        top_left_count = self.diagonal(column - 1, row + 1, -1, 1, column, row, player)
        bottom_right_count = self.diagonal(column + 1, row - 1, 1, -1, column, row, player)
        if top_left_count + bottom_right_count + 1 == 4:
            new_points += 1
        elif top_left_count + bottom_right_count + 1 > 4:
            new_points += 2
            
        top_right_count = self.diagonal(column + 1, row + 1, 1, 1, column, row, player)
        bottom_left_count = self.diagonal(column - 1, row - 1, -1, -1, column, row, player)
        if top_right_count + bottom_left_count + 1 == 4:
            new_points += 1
        elif top_right_count + bottom_left_count + 1 > 4:
            new_points += 2

        return new_points

    def diagonal(self, start_col, start_row, delta_col, delta_row, col, row, player):
        count = 0
        c, r = start_col, start_row
        while max(0, col - 3) <= c < min(self.size, col + 4) and 0 <= r < self.size and self.items[c][r] == player:
            count += 1
            c += delta_col
            r += delta_row
        return count

    def add(self, column, player):
        if self.num_disks[column] >= self.size or column < 0 or column >= self.size:
            return False

        row = self.num_disks[column]
        self.items[column][row] = player
        self.num_disks[column] += 1
        
        points_gained = self.num_new_points(column, row, player)
        self.points[player - 1] += points_gained
        return True

    def free_slots_as_close_to_middle_as_possible(self):
        middle = (0 + self.size - 1) / 2
        free_slots = [
            col for col in range(self.size) if self.num_free_positions_in_column(col) > 0
        ]
        free_slots.sort(key=lambda col: (abs(col - middle), col))
        return free_slots

    def column_resulting_in_max_points(self, player):
        max_points = 0
        best_column = -1

        for col in range(self.size):
            if self.num_free_positions_in_column(col) > 0:
                row = self.num_disks[col]
                points = self.num_new_points(col, row, player)
                if points > max_points:
                    max_points = points
                    best_column = col

        if max_points == 0:
            best_column = self.free_slots_as_close_to_middle_as_possible()[0]

        return best_column, max_points


class FourInARow:
    def __init__(self, size):
        self.board = GameBoard(size)
        self.window = tk.Tk()
        self.window.title("Four in a Row")

        self.canvas = tk.Canvas(self.window, width=GRID_SIZE * CELL_SIZE, height=GRID_SIZE * CELL_SIZE)
        self.canvas.pack()

        self.symbols = ["X", "O"] 
        self.player_names = []
        self.player_turn = 0

        self.setup_players()

        # Restart button (you keep losing this code ryan)
        self.restart_button = tk.Button(self.window, text="Restart", command=self.restart_game)
        self.restart_button.pack()

        self.update_board()

    def setup_players(self):
        self.player_names = [
            input("Player 1, please enter your name: "),
            input("Player 2, please enter your name: ")
        ]

    def draw_disk(self, column, row, player):
        x = column * CELL_SIZE + CELL_SIZE // 2
        y = (GRID_SIZE - row - 1) * CELL_SIZE + CELL_SIZE // 2
        if player == 1:
            color = "red"
        else:
            color = "yellow"
        self.canvas.create_oval(x - RADIUS, y - RADIUS, x + RADIUS, y + RADIUS, fill=color, outline="black")

    def update_board(self):
        self.canvas.delete("all")
        for col in range(self.board.size):
            for row in range(self.board.size):
                self.canvas.create_rectangle(
                    col * CELL_SIZE, row * CELL_SIZE, 
                    (col + 1) * CELL_SIZE, (row + 1) * CELL_SIZE, 
                    outline="blue", width=2
                )
                if self.board.items[col][row] != 0:
                    self.draw_disk(col, row, self.board.items[col][row])

        self.update_points()

    def update_points(self):
        self.canvas.create_text(GRID_SIZE * CELL_SIZE // 2, GRID_SIZE * CELL_SIZE + 20, 
                                text=f"{self.player_names[0]}: {self.board.points[0]}   {self.player_names[1]}: {self.board.points[1]}",
                                font=("Arial", 16))

    def game_over(self):
        return self.board.game_over()

    def show_winner(self, winner_message):
        messagebox.showinfo("Game Over", winner_message)

    def restart_game(self):
        self.board = GameBoard(GRID_SIZE)
        self.player_turn = 0
        self.update_board()

    def on_column_click(self, event):
        col = event.x // CELL_SIZE
        if self.board.add(col, self.player_turn + 1):
            self.update_board()
            if self.game_over():
                if self.board.points[0] > self.board.points[1]:
                    winner_message = f"{self.player_names[0]} wins!"
                elif self.board.points[0] < self.board.points[1]:
                    winner_message = f"{self.player_names[1]} wins!"
                else:
                    winner_message = "It's a draw!"
                self.show_winner(winner_message)
            else:
                self.player_turn = (self.player_turn + 1) % 2
                if self.player_turn == 1:
                    self.ai_move()

    def ai_move(self):
        (best_column, max_points) = self.board.column_resulting_in_max_points(2)
        if max_points > 0:
            column = best_column
        else:
            (best_column, max_points) = self.board.column_resulting_in_max_points(1)
            if max_points > 0:
                column = best_column
            else:
                column = self.board.free_slots_as_close_to_middle_as_possible()[0]
        self.board.add(column, 2)
        self.update_board()

        if self.game_over():
            if self.board.points[0] > self.board.points[1]:
                winner_message = f"{self.player_names[0]} wins!"
            elif self.board.points[0] < self.board.points[1]:
                winner_message = f"{self.player_names[1]} wins!"
            else:
                winner_message = "It's a draw!"
            self.show_winner(winner_message)
        else:
            self.player_turn = 0

    def play(self):
        self.canvas.bind("<Button-1>", self.on_column_click)
        self.window.mainloop()


game = FourInARow(6)
game.play()