Quoridor/project/Fonctions_d_evaluation.py

from Outils import Arbre
from Outils.Arbre import *
from Outils.Moteur_de_jeu import Joueur
from Outils.Moteur_de_jeu.Joueur import *
import math


def distance_bord (position) :
    return (min (position[0], 9-position[0]))

def lin_tout (plateau, num, cdistance, cbarrieres, cbord) :
    """on considère les coefficients associés à l'importance des barrières/...
    et on les affecte 'linéairement'"""
    b_num = plateau.barrieres_restantes[num]
    b_opp = plateau.barrieres_restantes[1-num]
    distance_num = plateau.longueur_chemin(num)
    distance_opp = plateau.longueur_chemin(1-num)
    dist_bord_num = distance_bord (plateau.pions[num])
    dist_bord_opp = distance_bord (plateau.pions[1-num])
    valeur_dist = cdistance*(distance_opp-distance_num)
    valeur_b = cbarrieres*(b_opp - b_num)
    valeur_bord = cbord*(dist_bord_opp-dist_bord_num)
    v = valeur_dist + valeur_b + valeur_bord
    return (v)


def lineaire_basique (cdistance, cbarrieres, cbord) :
    return (lambda bn, bo, dn, do, dbn, dbo : cdistance*(do-dn) + cbarrieres*(bo - bn) + cbord*(dbo-dbn))

def lineaires () :
    fonctions_lineaires = numpy.zeros (1000)
    for i in range (0, 10) :                #associé à cdistance = i ici
        for j in range (0, 10) :            #associé à cbarrieres = j*j ici
            for k in range (0, 10) :        #associé à cbord = sqrt k ici
                l = 100*i + 10*j + k
                fonctions_lineaires[l] = lineaire_basique (i+1, (j+1)*(j+1), math.sqrt(k+1))
    return (fonctions_lineaires)


"""on a 1000 fonctions"""

                
def expo_basique_coefs_internes (cdistance, cbarrieres, cbord) :
    return (lambda bn, bo, dn, do, dbn, dbo : math.exp(cdistance*do) - math.exp(cdistance*dn) + math.exp(cbarrieres*bo) - math.exp(cbarrieres*bn) + math.exp(cbord*dbo) - math.exp(cbord*dbn))

def exponentielles_coefs_dans_lexpo () :
    fonctions_expo1 = numpy.zeros (125)
    for i in range (0, 5) :                
        for j in range (0, 5) :            
            for k in range (0, 5) :        
                l = 25*i + 5*j + k
                fonctions_expo1[l] = expo_basique_coefs_internes ((i+1)/2, (j+1), 0.2*(k+1))
    return (fonctions_expo1)

"""on a 125 fonctions"""

def expo_basique_coefs_doubles (cdistance, cbarrieres, cbord) :
    return (lambda bn, bo, dn, do, dbn, dbo : cdistance*math.exp(cdistance*do) - cdistance*math.exp(cdistance*dn) + cbarrieres*math.exp(cbarrieres*bo) - cbarrieres*math.exp(cbarrieres*bn) + cbord*math.exp(cbord*dbo) - cbord*math.exp(cbord*dbn))


def exponentielles_coefs_doubles () :
    fonctions_expo2 = numpy.zeros (125)
    for i in range (0, 5) :                
        for j in range (0, 5) :            
            for k in range (0, 5) :        
                l = 25*i + 5*j + k
                fonctions_expo2[l] = expo_basique_coefs_doubles ((i+1)/3, (j+1), 0.15*(k+1))
    return (fonctions_expo2)

"""on a 125 fonctions"""

#test = lambda x : x*5

#test2 = lambda x,y : x*5 + y

#print (test2 (1, 2))

def lois_en_puissance (cdistance, cbarrieres, cbord) :
    return (lambda bn, bo, dn, do, dbn, dbo : do**cdistance - dn**cdistance + bo**cbarrieres - bn**cbarrieres + dbo**cbord - dbn**cbord)


def puissances () :
    fonction_puissance1 = numpy.zeros (1000)
    for i in range (0, 10) :                
        for j in range (0, 10) :            
            for k in range (0, 10) :        
                l = 100*i + 10*j + k
                fonctions_puissance1[l] = lois_en_puissance (i, j, k)
    return (fonctions_puissance1)


"""1000 fonctions"""