예제 #1
0
def IA(situation, comp, player):
    """
    """
    n = -1000
    situations = Game.nextSituations({"":0},situation, comp)
    for sit in situations:
        tmp = Mini(sit[0], comp, player)
        if tmp >= n :
            n = tmp
            valueToPlay = sit[1]
    situation = Game.changeValue(situation , valueToPlay, comp)  
    return situation
예제 #2
0
def Mini(situation,comp ,player):
    """
    """
    #mini = 1000
    if Game.isFinished(situation):
        return Game.evalFunction(situation,comp)
    else:
        situations = Game.nextSituations({"":0},situation, player)
        for sit in situations:
            tmp = Maxi (sit[0] ,comp, player)
            if tmp <= mini :
                mini = tmp
    return mini
예제 #3
0
파일: minmax.py 프로젝트: Zimoune/projet-s3
def __min_max(game_name, game, situation, player, depth):
    """
    The minimax algorithm.
    
    :param game: The game
    :type game: game
    :param situation: The current situation
    :type situation: situation:
    :param player: The player
    :type player: a player
    :param depth: The recursivity depth for the minimax algorithm (Upper is the depth, better is the decision)
                  * If depth = -1 , the depth will be based on the difficulty score
    :type depth: int
    :return: A tuple with two elements: the first is the best situation score, the second is the best situation
    :rtype: tuple<int, situation>
    """
    if game_name == "nim":
        import nim_game as Game

    elif game_name == "othello":
        import othello as Game

    else:
        import tictactoe as Game

    if Game.isFinished(situation) or depth == 0:
        score = Game.evalFunction(situation, player)
        return score, situation
    else:
        nextSituations = Game.nextSituations(situation, player)

        if Game.coef(player) == 1:
            return max([(__min_max(game_name, game, nextSit, Game.get_inv_player(player), depth - 1)[0], nextSit)
                        for nextSit in nextSituations])
        else:
            return min([(__min_max(game_name, game, nextSit, Game.get_inv_player(player), depth - 1)[0], nextSit)
                        for nextSit in nextSituations])