def comparer_coin(self, pos1, pos2):
coeff1, coeff2 = [], []
coeff1.append(
self.Nombre_coin_adjacent_pris(self.plateau, self.cote, pos1))
coeff2.append(
self.Nombre_coin_adjacent_pris(self.plateau, self.cote, pos2))
coeff1.append(
self.Augmentation_pion_stable_dans_zone(self.plateau, self.cote,
ZONE_BORD, pos1))
coeff2.append(
self.Augmentation_pion_stable_dans_zone(self.plateau, self.cote,
ZONE_BORD, pos2))
coeff1.append(
self.Augmentation_pion_dans_zone(self.plateau, self.cote,
ZONE_BORD, pos1))
coeff2.append(
self.Augmentation_pion_dans_zone(self.plateau, self.cote,
ZONE_BORD, pos2))
coeff1.append(self.Nombre_pion_retourne(self.plateau, pos1))
coeff2.append(self.Nombre_pion_retourne(self.plateau, pos2))
outils.ajouter_coeff_alea(coeff1, coeff2)
if est_superieur(coeff1, coeff2):
return pos1
else:
return pos2
def comparer_vert_noir(self, vert, noir):
if self.Augmentation_coup_possible_adv_dans_zone(
self.plateau, noir, ZONE_COIN) <= 0:
#Ok on peut envisager de jouer noir
coeff_vert, coeff_noir = [], []
coeff_vert.append(
self.Augmentation_pion_stable_dans_zone(
self.plateau, self.cote, ZONE_BORD, vert))
coeff_noir.append(
self.Augmentation_pion_stable_dans_zone(
self.plateau, self.cote, ZONE_BORD, noir))
coeff_vert.append(
self.Augmentation_pion_dans_zone(self.plateau, self.cote,
ZONE_BORD, vert))
coeff_noir.append(
self.Augmentation_pion_dans_zone(self.plateau, self.cote,
ZONE_BORD, noir))
coeff_vert.append(self.Nombre_pion_retourne(self.plateau, vert))
coeff_noir.append(self.Nombre_pion_retourne(self.plateau, noir))
outils.ajouter_coeff_alea(coeff_vert, coeff_noir)
if est_superieur(coeff_vert, coeff_noir):
return vert
else:
return noir
return vert
def comparer_blanc_noir(self, blanc,
noir): #todo faire un debug affichable
if self.Augmentation_coup_possible_adv_dans_zone(
self.plateau, noir, ZONE_COIN) <= 0:
#Ok on peut envisager de jouer noir
coeff_blanc, coeff_noir = [], []
coeff_blanc.append(
self.Augmentation_pion_stable_dans_zone(
self.plateau, self.cote, ZONE_TOUT, blanc))
coeff_noir.append(
self.Augmentation_pion_stable_dans_zone(
self.plateau, self.cote, ZONE_TOUT, noir))
coeff_blanc.append(self.Nombre_pion_retourne(self.plateau, blanc))
coeff_noir.append(self.Nombre_pion_retourne(self.plateau, noir))
outils.ajouter_coeff_alea(coeff_blanc, coeff_noir)
cfg.debug("##Cas particu noir {} est mieux que blanc {}".format(
noir, blanc))
if est_superieur(coeff_blanc, coeff_noir):
return blanc
else:
return noir
return blanc
def comparer_rouge_noir(self, rouge, noir):
coeff_rouge, coeff_noir = [], []
coeff_noir.append(int(self.plateau.possessionCoinDuQuartier(noir, self.cote)))
coeff_rouge.append(1)
coeff_noir.append(
self.plateau.est_coup_bourbier_par_cote(noir, self.cote)
* self.parite_desavantageuse
)
coeff_rouge.append(
self.plateau.est_coup_bourbier_par_cote(rouge, self.cote)
* self.parite_desavantageuse
)
coeff_rouge.append(
self.plateau.Augmentation_pion_stable_dans_zone(self.cote, ZONE_TOUT, rouge)
)
coeff_noir.append(
self.plateau.Augmentation_pion_stable_dans_zone(self.cote, ZONE_TOUT, noir)
)
coeff_rouge.append(self.plateau.Nombre_pion_retourne(rouge, self.cote))
coeff_noir.append(self.plateau.Nombre_pion_retourne(noir, self.cote))
if est_superieur(coeff_rouge, coeff_noir):
return rouge
else:
return noir
def comparer_blanc(self, pos1, pos2):
coeff1, coeff2 = [], []
coeff1.append(self.Nombre_pion_retourne(self.plateau, pos1))
coeff2.append(self.Nombre_pion_retourne(self.plateau, pos2))
outils.ajouter_coeff_alea(coeff1, coeff2)
if est_superieur(coeff1, coeff2):
return pos1
else:
return pos2
def comparer_vert(self, pos1, pos2):
"""On produit ci dessous est en fait une astuce :
Si self.parite_desavantageuse est True, la parite est desavantgeuse,
il faut essayer de faire passer le tour de l'adversaire, pour cela,
on cherche un "coup bourbier",
il faut donc en prendre compte dans la selection des coups proposes.
Sinon, alors self.parite_desavantageuse est False et
le produit est dans les deux cas egal à 0
il n'influe donc pas dans la selection du coup
"""
coeff1, coeff2 = [], []
coeff1.append(
self.plateau.est_coup_bourbier_par_cote(pos1, self.cote)
* self.parite_desavantageuse
)
coeff2.append(
self.plateau.est_coup_bourbier_par_cote(pos2, self.cote)
* self.parite_desavantageuse
)
coeff1.append(int(self.plateau.position_stable_pour_cote(pos1, self.cote)))
coeff2.append(int(self.plateau.position_stable_pour_cote(pos2, self.cote)))
coeff1.append(
-1
* self.plateau.Augmentation_coup_possible_adv_dans_zone(
pos1, ZONE_VERTE, self.cote
)
)
coeff2.append(
-1
* self.plateau.Augmentation_coup_possible_adv_dans_zone(
pos2, ZONE_VERTE, self.cote
)
)
coeff1.append(
-1
* self.plateau.Augmentation_coup_possible_adv_dans_zone(
pos1, ZONE_TOUT, self.cote
)
)
coeff2.append(
-1
* self.plateau.Augmentation_coup_possible_adv_dans_zone(
pos2, ZONE_TOUT, self.cote
)
)
coeff1.append(self.plateau.Nombre_pion_retourne(pos1, self.cote))
coeff2.append(self.plateau.Nombre_pion_retourne(pos2, self.cote))
if est_superieur(coeff1, coeff2):
return pos1
else:
return pos2
def comparer_rouge(self, pos1, pos2):
coeff1, coeff2 = [], []
coeff1.append(-1 * self.Augmentation_coup_possible_adv_dans_zone(
self.plateau, pos1, ZONE_BORD))
coeff2.append(-1 * self.Augmentation_coup_possible_adv_dans_zone(
self.plateau, pos2, ZONE_BORD))
coeff1.append(self.Nombre_pion_retourne(self.plateau, pos1))
coeff2.append(self.Nombre_pion_retourne(self.plateau, pos2))
outils.ajouter_coeff_alea(coeff1, coeff2)
if est_superieur(coeff1, coeff2):
return pos1
else:
return pos2
def comparer_blanc(self, pos1, pos2):
"""Comparer deux positions de couleur blanche"""
coeff1, coeff2 = [], []
# Les méthodes de comparaisons à partir des couleurs sont toutes construites de la même façon.
# A chaque position, on associe une liste.
# En fonction des critères ordonnés de l'algorithme que l'on applique sur chaque position, on ajoute un
# coefficient dans la liste correspondante : plus le coefficient est élevé, plus le coup est favorisé.
# Si le critère est qualitatif, le coefficient peut être des Booléens converti en 0 ou 1.
# Si le critère est quantitatif, le coefficient est la quantité examinée (éventuellement multiplié par -1
# si le critère demande de limiter cette quantité)
# Enfin, pour déterminer la position choisie, il suffit de comparer les deux listes termes par terme : cf la
# fonction est_superieur dans outils.py
# Le coefficeint ci dessous est un porduit astucieux :
# Si self.parite_desavantageuse est True, la parite est desavantgeuse, il faut essayer de faire passer le tour
# de l'adversaire, pour cela, on cherche un "coup bourbier", il faut donc en prendre compte dans la selection
# des coups proposes.
# Sinon, alors self.parite_desavantageuse est False et le porduit est dans les deux cas egal à 0
# il n'influe donc pas dans la selection du coup
coeff1.append(
self.plateau.est_coup_bourbier_par_cote(pos1, self.cote)
* self.parite_desavantageuse
)
coeff2.append(
self.plateau.est_coup_bourbier_par_cote(pos2, self.cote)
* self.parite_desavantageuse
)
coeff1.append(
-1
* self.plateau.Augmentation_coup_possible_adv_dans_zone(
pos1, ZONE_TOUT, self.cote
)
)
coeff2.append(
-1
* self.plateau.Augmentation_coup_possible_adv_dans_zone(
pos2, ZONE_TOUT, self.cote
)
)
coeff1.append(self.plateau.Nombre_pion_retourne(pos1, self.cote))
coeff2.append(self.plateau.Nombre_pion_retourne(pos2, self.cote))
if est_superieur(coeff1, coeff2):
return pos1
else:
return pos2
def comparer_vert_noir(self, vert, noir):
coeff_vert, coeff_noir = [], []
coeff_noir.append(int(self.plateau.possessionCoinDuQuartier(noir, self.cote)))
coeff_vert.append(1)
coeff_noir.append(1)
coeff_vert.append(0)
if est_superieur(coeff_vert, coeff_noir):
return vert
else:
return noir
def comparer_rouge(self, pos1, pos2):
"""Permet de comparer deux positions rouge"""
coeff1, coeff2 = [], []
coeff1.append(
self.plateau.est_coup_bourbier_par_cote(pos1, self.cote)
* self.parite_desavantageuse
)
coeff2.append(
self.plateau.est_coup_bourbier_par_cote(pos2, self.cote)
* self.parite_desavantageuse
)
coeff1.append(
-1
* self.plateau.Augmentation_coup_possible_adv_dans_zone(
pos1, ZONE_VERTE, self.cote
)
)
coeff2.append(
-1
* self.plateau.Augmentation_coup_possible_adv_dans_zone(
pos2, ZONE_VERTE, self.cote
)
)
coeff1.append(
-1
* self.plateau.Augmentation_coup_possible_adv_dans_zone(
pos1, ZONE_TOUT, self.cote
)
)
coeff2.append(
-1
* self.plateau.Augmentation_coup_possible_adv_dans_zone(
pos2, ZONE_TOUT, self.cote
)
)
coeff1.append(self.plateau.Nombre_pion_retourne(pos1, self.cote))
coeff2.append(self.plateau.Nombre_pion_retourne(pos2, self.cote))
if est_superieur(coeff1, coeff2):
return pos1
else:
return pos2
def comparer_rouge_noir(self, rouge,
noir): #todo revoir ca + debug affichage
if self.Augmentation_coup_possible_adv_dans_zone(
self.plateau, noir, ZONE_COIN) <= 0:
#Ok on peut envisager de jouer noir
coeff_rouge, coeff_noir = [], []
coeff_rouge.append(
self.Augmentation_pion_stable_dans_zone(
self.plateau, self.cote, ZONE_TOUT, rouge))
coeff_noir.append(
self.Augmentation_pion_stable_dans_zone(
self.plateau, self.cote, ZONE_TOUT, noir))
coeff_rouge.append(self.Nombre_pion_retourne(self.plateau, rouge))
coeff_noir.append(self.Nombre_pion_retourne(self.plateau, noir))
outils.ajouter_coeff_alea(coeff_rouge, coeff_noir)
if est_superieur(coeff_rouge, coeff_noir):
return rouge
else:
return noir
return rouge
def comparer_noir(self, pos1, pos2):
coeff1, coeff2 = [], []
coeff1.append(-1 * self.Augmentation_coup_possible_adv_dans_zone(
self.plateau, pos1, ZONE_COIN))
coeff1.append(-1 * self.Augmentation_coup_possible_adv_dans_zone(
self.plateau, pos2, ZONE_COIN))
coeff1.append(
int(self.position_stable_pour_cote(self.plateau, pos1, self.cote)))
coeff2.append(
int(self.position_stable_pour_cote(self.plateau, pos2, self.cote)))
#todo faire cas Case noir sur l'extrême bord, juste à côté d’un coin conquis
coeff1.append(self.Nombre_pion_retourne(self.plateau, pos1))
coeff2.append(self.Nombre_pion_retourne(self.plateau, pos2))
outils.ajouter_coeff_alea(coeff1, coeff2)
if est_superieur(coeff1,
coeff2): #todo utiliser le mot cle or en python
return pos1
else:
return pos2
def comparer_rouge_vert(self, rouge, vert):
coeff_rouge, coeff_vert = [], []
coeff_rouge.append(
int(not (self.plateau.position_stable_pour_cote(vert, self.cote)))
)
coeff_vert.append(1)
coeff_rouge.append(
self.plateau.est_coup_bourbier_par_cote(rouge, self.cote)
* self.parite_desavantageuse
)
coeff_vert.append(
self.plateau.est_coup_bourbier_par_cote(vert, self.cote)
* self.parite_desavantageuse
)
coeff_rouge.append(1)
coeff_vert.append(0)
if est_superieur(coeff_rouge, coeff_vert):
return rouge
else:
return vert
