players.py

# Code from https://github.com/aimacode/aima-python

import math
import random
from re import A

def random_player(game, state): 
    """A game player who plays randomly"""
    return random.choice(list(game.actions(state)))

def player(search_algorithm):
    """A game player who uses the specified search algorithm"""
    return lambda game, state: search_algorithm(game, state)[1]

infinity = math.inf

def minimax_search(game, state):
    """Search game tree to determine best move; return (value, move) pair."""

    player = state.to_move

    def max_value(state):

        if game.is_terminal(state):
            return (game.utility(state, player), None)

        v_star = -infinity
        for a in game.actions(state):
            state2 = game.result(state, a)
            v, _ = min_value(state2)
            if v > v_star:
                v_star = v 
                m_star = a
        
        return (v_star, m_star)

    def min_value(state):

        if game.is_terminal(state):
            return (game.utility(state, player), None)

        v_star = infinity
        for a in game.actions(state):
            state2 = game.result(state, a)
            v, _ = max_value(state2)
            if v < v_star:
                v_star = v 
                m_star = a
        
        return (v_star, m_star)
    
    return max_value(state)

def alphabeta_search(game, state):
    """Search game to determine best action; use alpha-beta pruning.
    As in [Figure 5.7], this version searches all the way to the leaves."""

    player = state.to_move

    def max_value(state, alpha, beta):
        
        if game.is_terminal(state):
            return (game.utility(state, player), None)

        v_star = -infinity
        for a in game.actions(state):
            state2 = game.result(state, a)
            v, _ = min_value(state2, alpha, beta)
            if v > v_star:
                v_star = v 
                m_star = a
                alpha = max(alpha, v_star)
            if v_star >= beta:
                return (v_star, m_star)
        
        return (v_star, m_star)

    def min_value(state, alpha, beta):

        if game.is_terminal(state):
            return (game.utility(state, player), None)

        v_star = +infinity
        for a in game.actions(state):
            state2 = game.result(state, a)
            v, _ = max_value(state2, alpha, beta)
            if v < v_star:
                v_star = v 
                m_star = a
                beta = min(beta, v_star)
            if v_star <= alpha:
                return (v_star, m_star)
        
        return (v_star, m_star)
        

    return max_value(state, -infinity, +infinity)


def cutoff_depth(d):
    """A cutoff function that searches to depth d."""
    return lambda game, state, depth: depth > d

def h_alphabeta_search(game, state, cutoff=cutoff_depth(6), h=lambda s , p: 0):
    """Search game to determine best action; use alpha-beta pruning.
    This version searches all the way to the leaves."""

    player = state.to_move

    def max_value(state, alpha, beta, depth):
        
        if game.is_terminal(state):
            return (game.utility(state, player), None)
            
        if cutoff(game, state, depth):
            return (h(state, player), None)

        v_star = -infinity
        for a in game.actions(state):
            state2 = game.result(state, a)
            v, _ = min_value(state2, alpha, beta, depth+1)
            if v > v_star:
                v_star = v 
                m_star = a
                alpha = max(alpha, v_star)
            if v_star >= beta:
                return (v_star, m_star)

        return (v_star, m_star)

    def min_value(state, alpha, beta, depth):

        if game.is_terminal(state):
            return (game.utility(state, player), None)

        if cutoff(game, state, depth):
            return (h(state, player), None)

        v_star = +infinity
        for a in game.actions(state):
            state2 = game.result(state, a)
            v, _ = max_value(state2, alpha, beta, depth+1)
            if v < v_star:
                v_star = v 
                m_star = a
                beta = min(beta, v_star)
            if v_star <= alpha:
                return (v_star, m_star)
        
        return (v_star, m_star)

    return max_value(state, -infinity, +infinity, 0)


def your_nice_agent(game, state):
    return h_alphabeta_search(game, state, cutoff=cutoff_depth(1), h=your_nice_heuristic)

def your_nice_heuristic(state, player):
    


    
    return 0