Scribd
Upload
1 views

minmaxalgo

This document presents a Python implementation of the Connect Four game using the Minimax algorithm for AI decision-making. It defines a ConnectFour class that manages the game board, checks for valid moves, and determines winning conditions. The game alternates between a human player and an AI opponent, which uses the Minimax algorithm with alpha-beta pruning to select optimal moves.

Uploaded by

singh.raviprakash.ds
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
1 views

minmaxalgo

This document presents a Python implementation of the Connect Four game using the Minimax algorithm for AI decision-making. It defines a ConnectFour class that manages the game board, checks for valid moves, and determines winning conditions. The game alternates between a human player and an AI opponent, which uses the Minimax algorithm with alpha-beta pruning to select optimal moves.

Uploaded by

singh.raviprakash.ds
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 2

Connect Four with Minimax Algorithm

import numpy as np
import sys

ROWS = 6
COLUMNS = 7
PLAYER1 = 1
PLAYER2 = 2

class ConnectFour:
def __init__(self):
self.board = np.zeros((ROWS, COLUMNS), int)

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

def is_valid_location(self, col):


return self.board[ROWS - 1][col] == 0

def get_next_open_row(self, col):


for r in range(ROWS):
if self.board[r][col] == 0:
return r

def drop_piece(self, row, col, piece):


self.board[row][col] = piece

def winning_move(self, piece):


# Check horizontal locations
for c in range(COLUMNS - 3):
for r in range(ROWS):
if all(self.board[r][c + i] == piece for i in range(4)):
return True

# Check vertical locations


for c in range(COLUMNS):
for r in range(ROWS - 3):
if all(self.board[r + i][c] == piece for i in range(4)):
return True

# Check positively sloped diagonals


for c in range(COLUMNS - 3):
for r in range(ROWS - 3):
if all(self.board[r + i][c + i] == piece for i in range(4)):
return True

# Check negatively sloped diagonals


for c in range(COLUMNS - 3):
for r in range(3, ROWS):
if all(self.board[r - i][c + i] == piece for i in range(4)):
return True

return False

def minimax(self, depth, alpha, beta, maximizing_player):


valid_locations = [c for c in range(COLUMNS) if self.is_valid_location(c)]
is_terminal = self.winning_move(PLAYER1) or self.winning_move(PLAYER2) or not
valid_locations

if depth == 0 or is_terminal:
if self.winning_move(PLAYER1):
return (None, 100000000000000)
elif self.winning_move(PLAYER2):
return (None, -10000000000000)
else:
return (None, 0)

if maximizing_player:
value = -np.inf
column = np.random.choice(valid_locations)
for col in valid_locations:
row = self.get_next_open_row(col)
self.drop_piece(row, col, PLAYER1)
new_score = self.minimax(depth - 1, alpha, beta, False)[1]
self.drop_piece(row, col, 0)
if new_score > value:
value = new_score
column = col
alpha = max(alpha, value)
if alpha >= beta:
break
return column, value
else:
value = np.inf
column = np.random.choice(valid_locations)
for col in valid_locations:
row = self.get_next_open_row(col)
self.drop_piece(row, col, PLAYER2)
new_score = self.minimax(depth - 1, alpha, beta, True)[1]
self.drop_piece(row, col, 0)
if new_score < value:
value = new_score
column = col
beta = min(beta, value)
if beta <= alpha:
break
return column, value

def play_game(self):
while True:
# Player 1 Input
self.print_board()
col = int(input("Player 1 (1) - Select a column (0-6): "))
if self.is_valid_location(col):
row = self.get_next_open_row(col)
self.drop_piece(row, col, PLAYER1)

if self.winning_move(PLAYER1):
self.print_board()
print("Player 1 wins!")
break

# Player 2 (AI) Move


col, _ = self.minimax(4, -np.inf, np.inf, True)
if self.is_valid_location(col):
row = self.get_next_open_row(col)
self.drop_piece(row, col, PLAYER2)

if self.winning_move(PLAYER2):
self.print_board()
print("Player 2 (AI) wins!")
break

if __name__ == "__main__":
game = ConnectFour()
game.play_game()

You might also like