connect4.py

import numpy as np
import pygame
import sys
import math
import ai_file as ai
import brain
import random
import time


BLUE = (0, 0, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 255, 0)

ROW_COUNT = 6
COLUMN_COUNT = 7

def create_board():
    board = np.zeros((ROW_COUNT, COLUMN_COUNT))
    return board

# def drop_piece(board, row, col, piece):
#     board[row][col] = piece

def drop_piece(board, col, player):
    # print("what is going on", board[ROW_COUNT-1], ROW_COUNT) why is it in reverse
    for row1 in range(ROW_COUNT):
        if board[row1][col] == 0:
            board[row1][col] = player
            break


def is_valid_location(board, col):
    return board[ROW_COUNT - 1][col] == 0

# def get_next_open_row(board, col):
#     for r in range(ROW_COUNT):
#         if board[r][col] == 0:
#             return r

def print_board(board):
    print(np.flip(board, 0))

def winning_move(board, piece):
    # Check horizontal locations for win
    for c in range(COLUMN_COUNT - 3):
        for r in range(ROW_COUNT):
            if (board[r][c] == piece and board[r][c + 1] == piece and
                board[r][c + 2] == piece and board[r][c + 3] == piece):
                return True

    # Check vertical locations for win
    for c in range(COLUMN_COUNT):
        for r in range(ROW_COUNT - 3):
            if (board[r][c] == piece and board[r + 1][c] == piece and
                board[r + 2][c] == piece and board[r + 3][c] == piece):
                return True

    # Check positively sloped diagonals
    for c in range(COLUMN_COUNT - 3):
        for r in range(ROW_COUNT - 3):
            if (board[r][c] == piece and board[r + 1][c + 1] == piece and
                board[r + 2][c + 2] == piece and board[r + 3][c + 3] == piece):
                return True

    # Check negatively sloped diagonals
    for c in range(COLUMN_COUNT - 3):
        for r in range(3, ROW_COUNT):
            if (board[r][c] == piece and board[r - 1][c + 1] == piece and
                board[r - 2][c + 2] == piece and board[r - 3][c + 3] == piece):
                return True

def draw_board(board):
    for c in range(COLUMN_COUNT):
        for r in range(ROW_COUNT):
            pygame.draw.rect(screen, BLUE, (c * SQUARESIZE, r * SQUARESIZE + SQUARESIZE, SQUARESIZE, SQUARESIZE))
            pygame.draw.circle(screen, BLACK, (int(c * SQUARESIZE + SQUARESIZE / 2), int(r * SQUARESIZE + SQUARESIZE + SQUARESIZE / 2)), RADIUS)

    for c in range(COLUMN_COUNT):
        for r in range(ROW_COUNT):
            if board[r][c] == 1:
                pygame.draw.circle(screen, RED, (int(c * SQUARESIZE + SQUARESIZE / 2), height - int(r * SQUARESIZE + SQUARESIZE / 2)), RADIUS)
            elif board[r][c] == 2:
                pygame.draw.circle(screen, YELLOW, (int(c * SQUARESIZE + SQUARESIZE / 2), height - int(r * SQUARESIZE + SQUARESIZE / 2)), RADIUS)
    pygame.display.update()

board = create_board()
print_board(board)
game_over = False
turn = 0

pygame.init()

SQUARESIZE = 100
width = COLUMN_COUNT * SQUARESIZE
height = (ROW_COUNT + 1) * SQUARESIZE
size = (width, height)
RADIUS = int(SQUARESIZE / 2 - 5)

screen = pygame.display.set_mode(size)
draw_board(board)
pygame.display.update()

myfont = pygame.font.SysFont("monospace", 75)

while not game_over:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()

        if event.type == pygame.MOUSEMOTION:
            pygame.draw.rect(screen, BLACK, (0, 0, width, SQUARESIZE))
            posx = event.pos[0]
            if turn == 0:
                pygame.draw.circle(screen, RED, (posx, int(SQUARESIZE / 2)), RADIUS)
            # else:
            #     pygame.draw.circle(screen, YELLOW, (posx, int(SQUARESIZE / 2)), RADIUS)
            pygame.display.update()

        if event.type == pygame.MOUSEBUTTONDOWN:
            pygame.draw.rect(screen, BLACK, (0, 0, width, SQUARESIZE))
            if turn == 0:
                posx = event.pos[0]
                col = int(math.floor(posx / SQUARESIZE))

                if is_valid_location(board, col):
                    # row = get_next_open_row(board, col)
                    # drop_piece(board, row, col, 1)
                    drop_piece(board, col, 1)


                    if winning_move(board, 1):
                        label = myfont.render("Player 1 wins!!", 1, RED)
                        screen.blit(label, (40, 10))
                        game_over = True

                turn += 1
                turn = turn % 2

                print_board(board)
                draw_board(board)

            if turn == 1:
                # delay for calculating effect
                # time.sleep(round(random.uniform(0.5, 1), 1))


                second_matrix = np.copy(board)
                second_matrix = np.flip(second_matrix, 0)

                flag_dumb_algo = False
                # check for instant wins
                valid_moves = brain.get_valid_moves(second_matrix)
                third_matrix = np.copy(second_matrix)

                for col_tmp in valid_moves:
                    drop_piece(third_matrix, col_tmp, 2)
                    if winning_move(third_matrix, 2):
                        col = col_tmp
                        flag_dumb_algo = True
                        break
                    third_matrix = np.copy(second_matrix)

                if not flag_dumb_algo:
                    for col_tmp in valid_moves:
                        drop_piece(third_matrix, col_tmp, 1)
                        if winning_move(third_matrix, 1):
                            col = col_tmp
                            flag_dumb_algo = True
                            break
                        third_matrix = np.copy(second_matrix)



                if not flag_dumb_algo: col = brain.use_your_brain(board, True)
                # col = brain.use_your_brain(board, True)




                print("ai moves: ", col)
                if is_valid_location(board, col):
                    # row = get_next_open_row(board, col)
                    # drop_piece(board, row, col, 2)
                    drop_piece(board, col, 2)

                    if winning_move(board, 2):
                        label = myfont.render("Player 2 wins!!", 1, YELLOW)
                        screen.blit(label, (40, 10))
                        game_over = True
                else:
                    print("NOOOOOOOOOOOOOOOT VALID DO SOMETHING!!!!!")

            print_board(board)
            draw_board(board)

            turn += 1
            turn = turn % 2


            if game_over:
                pygame.time.wait(5000)