def estimation(jeu, coup, prf, joueur): game.joueCoup(jeu, coup) #L= game.getCoupsValides(jeu) if game.finJeu(jeu): g = game.getGagnant(jeu) if g == joueur: return 100000 elif g == 0: return -100 else: return -100000 elif prf >= 2: return evaluation(jeu, coup, joueur) else: L = game.getCoupsValides(jeu) m = [] for i in L: jeu2 = game.getCopieJeu(jeu) #game.joueCoup(jeu2,i) m.append(estimation(jeu2, i, prf + 1, joueur)) if game.getJoueur(jeu) == joueur: return max(m) else: return min(m)
def joueN(n): global y v1, j1 = 0, 1 """ # ============================================================================= # - v1 (nombre de victoires du joueur 1), v2 (nombre de victoires du joueur 2), mn (nombre de matchs nuls) # - sc1 et sc2 (scores moyens de chaque joueur) # - nbc (nombre de coups joues en moyenne) # ============================================================================= """ #lancer une partie, 3 coups alea au debut puis chaque joueur se met a jouer for i in range(n): game.joueur1 = awele_alea game.joueur2 = awele_alea jeu = game.initialiseJeu() while not game.finJeu(jeu): coup = game.saisieCoup(jeu) game.joueCoup(jeu, coup) if len(game.getCoupsJoues(jeu)) == 4: game.joueur1 = game.joueurinter1 game.joueur2 = game.joueurinter2 if game.getGagnant(jeu) == j1: v1 += 1 v1 = float(v1) / float(n) #ratio victoire/nbre de match y.append( v1 ) #y=liste de victoire éfféctué (ou on ajoute a la fin de la liste le nombre de victoire pour n partie faite)
def JoueN( joueur1, joueur2 ): # joue 10 partie (variable N) et compte le nombre de victoire de joueur 1 (l'eleve) global j1, j2 victoires = 0 for i in range(N): game.joueur1 = othello_alea #transforme mes joueur en joueur aleatoire game.joueur2 = othello_alea #permet de tirer des coups aleatoire au debut, sinon tjr meme partie jeu = game.initialiseJeu() while not game.finJeu(jeu): coup = game.saisieCoup( jeu) #joues different coups tant que cest pas la fin du jeu game.joueCoup(jeu, coup) if len(game.getCoupsJoues(jeu) ) == 4: #apres 4 coups aleatoire,le jeu commence vraiment game.joueur2 = joueur2 game.joueur1 = joueur1 g = game.getGagnant(jeu) if g == j1: #on compte le nbre de victoire de leleve victoires += 1 if i == N / 2: game.joueur1 = joueur2 #apres N/2 partie, on echange les joeuur , pour quon ai pas le meme joueur qui commence game.joueur2 = joueur1 j1 = game.joueur2 j1 = game.joueur1 return victoires
def estimation(jeu, coup, profondeur): copie = game.getCopieJeu(jeu) game.joueCoup(copie, coup) if game.finJeu(copie): gagnant = game.getGagnant(copie) if gagnant == moi: return 10000 elif gagnant == 0: return -100 else: return -10000 if profondeur == PMAX: return evaluation(copie) listeCoups = game.getCoupsValides(copie) if profondeur % 2 == 0: scoremax = -10000 for c in listeCoups: score_estime = estimation(copie, c, profondeur + 1) if score_estime > scoremax: scoremax = score_estime return scoremax if profondeur % 2 == 1: scoremin = 10000 for c in listeCoups: score_estime = estimation(copie, c, profondeur + 1) if score_estime < scoremin: scoremin = score_estime return scoremin
def estimation(jeu, coup, p): #retourne le score d'utilite pour un coup donne copie = game.getCopieJeu(jeu) game.joueCoup(copie, coup) if game.finJeu(copie): g = game.getGagnant(copie) if g == moi: return 100000000 else: if g == 0: return -500 else: return -100000000 if p == prof: return evaluation(copie) if p < prof: coups = game.getCoupsValides(copie) max_min = estimation(copie, coups[0], p + 1) for c in coups[1:]: s = estimation(copie, c, p + 1) if p % 2 == 0 and s > max_min: max_min = s if p % 2 != 0 and s < max_min: max_min = s return max_min
def estimation(jeu, coup, p, a, b): copie = game.getCopieJeu(jeu) game.joueCoup(copie, coup) if game.finJeu(copie): g = game.getGagnant(copie) if g == moi: return 12345 else: if g == 0: return -123 else: return -12345 if p == prof: return evaluation(copie) else: cp = game.getCoupsValides(copie) if p % 2 == 0: m = a else: m = b for c in cp: s = estimation(copie, c, p + 1, a, b) if p % 2 == 0: if s >= m: a = s m = s if s > b: return b else: if s <= m: b = s m = s if s < a: return a return m
def jouePARTIE(j1, j2): global playerONE global playerTWO #On initialise a ALEA les 4 premier Coups pr que ce soit équilibré et pr éviter même partie. for i in range(1): jeu = game.initialiseJeu() game.joueur1 = othello_alea game.joueur2 = othello_alea while not game.finJeu(jeu): #game.affiche(jeu) coup = game.saisieCoup(jeu) game.joueCoup(jeu, coup) if len(game.getCoupsJoues(jeu)) == 4: game.joueur1 = j1 game.joueur2 = j2 if i == nbRounds / 2: game.joueur1 = j2 game.joueur2 = j1 #playerONE=2 #playerTWO=1 #print ("Nombre de tours : " + str(len(game.getCoupsJoues(jeu)))) #print("Gagnant de la partie est : ",game.getGagnant(jeu)) gagnant = game.getGagnant(jeu) return gagnant
def estimation(jeu, coup, p): global nbNoeuds nbNoeuds += 1 copie = game.getCopieJeu(jeu) game.joueCoup(copie, coup) if game.finJeu(jeu): g = game.getGagnant(jeu) if g == moi: return 100000 else: if g == 0: return -100 else: return -100000 if p == prof: l = parcoursPlateau(jeu) return evaluation(copie, l) cp = game.getCoupsValides(copie) m = 0 for c in cp: s = estimation(copie, c, p + 1) if p % 2 == 0: if s >= m: m = s else: if s <= m: m = s return m
def estimation(jeu, coup, p): global nbNoeuds nbNoeuds+=1 copie = game.getCopieJeu(jeu) game.joueCoup(copie,coup) if game.finJeu(jeu): g=game.getGagnant(jeu) if g == moi:#si c'est moi le vainqueur alors estimation élevée return 12345 else: if g == 0:#si c'est nul alors estimation moyenne return -123 else:#pire cas estimation faible return -12345 if p >= prof: liste_parcoursPlat= parcoursPlateau(jeu) return evaluation(copie,liste_parcoursPlat) coupsV=game.getCoupsValides(copie) mValue=0 for c in coupsV: est =estimation(copie,c,p+1) if p%2 == 0:#MAX if est >= mValue: mValue= est else:#MIN if est <=mValue: mValue = est return mValue
def estimationMIN(jeu, p=1): Vmin = float("inf") if game.finJeu(jeu): g = game.getGagnant(jeu) if g == monJoueur: return 1000 else: return -1000 if p == Pmax: #print("VMIN:",Vmin) return evaluation(jeu) #game.changeJoueur(jeu) coups = game.getCoupsValides(jeu) for cp in coups: j = game.getCopieJeu(jeu) game.joueCoup(j, cp) v = estimationMAX(j, p + 1) #print(cp," ",v," ", p) if Vmin > v: Vmin = v # print("VMIN:",Vmin) return Vmin
def estimation(jeu, coup, p): global nombreDeNoeuds nombreDeNoeuds += 1 copie = game.getCopieJeu(jeu) game.joueCoup(copie, coup) if game.finJeu(copie): g = game.getGagnant(copie) if g == moi: #si c'est moi le vainqueur alors estimation élevée return 12345 else: if g == 0: #si c'est nul alors estimation moyenne return -123 else: #pire cas estimation faible return -12345 if p >= prof: #max profondeur donc on evalue return evaluation(jeu, copie) else: coupsV = game.getCoupsValides(copie) mValue = 0 for c in coupsV: est = estimation(copie, c, p + 1) if p % 2 == 0: #MAX if est >= mValue: mValue = est else: #MIN if est <= mValue: mValue = est return mValue
def joueplsr(): nbrepartie = 0 j1 = 0 j2 = 0 eg = 0 tj1 = 0 tj2 = 0 tt = time.time() while (nbrepartie < NBPARTIE): if (nbrepartie == (NBPARTIE / 2)): global joueur2 global joueur1 print("score mi-temps(" + str(nbrepartie) + " partie):\nj1: " + str(j1) + " \nscore j2: " + str(j2) + "\nnb d'equalite : " + str(eg) + "\n") s = joueur1 joueur1 = joueur2 joueur2 = s a = j1 j1 = j2 j2 = a a = tj1 tj1 = tj2 tj2 = a jeu = game.initialiseJeu() it = 0 while ((it < 100) and (not (game.finJeu(jeu)))): if (it < 4): coup = Random.saisieCoup(game.getCopieJeu(jeu)) game.joueCoup(jeu, coup) else: t1 = time.time() coup = saisieCoup(jeu) if game.getJoueur(jeu) == 1: tj1 += time.time() - t1 else: tj2 += time.time() - t1 game.joueCoup(jeu, coup) it += 1 g = game.getGagnant(jeu) tj1 = tj1 / it tj2 = tj2 / it if (g == 1): j1 += 1 if (g == 2): j2 += 1 if (g == 0): eg += 1 nbrepartie += 1 tt = time.time() - tt print("score final :\nj1: " + str(j2) + "temps/coup=" + str(tj2) + "\nj2: " + str(j1) + "temps/coup=" + str(tj2) + "\nnb d'equalite : " + str(eg))
def joue(): jeu = game.initialiseJeu() while (not game.finJeu(jeu)): game.affiche(jeu) c = game.saisieCoup(game.getCopieJeu(jeu)) jeu = game.joueCoup(jeu, c) g = game.getGagnant(jeu) return g
def jouePARTIE(): jeu = game.initialiseJeu() while not game.finJeu(jeu): game.affiche(jeu) coup = game.saisieCoup(jeu) game.joueCoup(jeu, coup) print( "Nombre de tours : " + str(len(game.getCoupsJoues(jeu))) ) #str permet de cast, sinon on peut pas concatener un str et un int if game.getGagnant(jeu) == 0: print("\nEgalite parfaite !") else: print("\nLe joueur " + str(game.getGagnant(jeu)) + " a gagne !") print("\nPlateau de fin de jeu: ") game.game.affiche(jeu) g = game.getGagnant(jeu) return g
def play(): jeu = game.initialiseJeu() while True: #game.affiche(jeu) valides = game.getCoupsValides(jeu) if game.finJeu(jeu): break elif valides != None: coup = game.saisieCoup(jeu) game.joueCoup(jeu, coup) print("Le gagnant est : ", game.getGagnant(jeu)) return game.getGagnant(jeu)
def joue(): jeu=game.initialiseJeu() it=0 while((it<100)and (not game.finJeu(jeu))): game.affiche(jeu) coup=saisieCoup(jeu) game.joueCoup(jeu,coup) it+=1 game.affiche(jeu) print("gagnant="+str(game.getGagnant(jeu)+":"+ str(game.getScore(jeu)))) return jeu
def joue(): """void -> nat retourne un gagnant""" jeu = game.initialiseJeu() while not game.finJeu(jeu): #game.affiche(jeu) print "joueur : {}".format(game.getJoueur(jeu)) coup = game.saisieCoup(jeu) print "coup joue : {}".format(coup) game.joueCoup(jeu, coup) print "score : {}".format(game.getScores(jeu)) #game.affiche(jeu) return game.getGagnant(jeu)
def jouentrainement(ev): global joueur2 global joueur1 nbrepartie=0 j1=0 j2=0 eg=0 switch=1 while(nbrepartie<NBPARTIE): if (nbrepartie==(NBPARTIE/2)): s=joueur1 joueur1=joueur2 joueur2=s a=j1 j1=j2 j2=a switch=2 jeu=game.initialiseJeu() it=0 while((it<100)and (not(game.finJeu(jeu)))): if (it<4): coup=joueur_alea.saisieCoup(game.getCopieJeu(jeu)) game.joueCoup(jeu,coup) else : if(game.getJoueur(jeu)==switch): coup=saisieCoupTr(jeu,ev) else: coup=saisieCoup(jeu) game.joueCoup(jeu,coup) it+=1 g=game.getGagnant(jeu) if (g==1): j1+=1 if(g==2): j2+=1 if(g==0): eg+=1 nbrepartie+=1 if (nbrepartie==NBPARTIE): s=joueur2 joueur2=joueur1 joueur1=s return j2
def play(): jeu = game.initialiseJeu() while True: #game.affiche(jeu) valides = game.getCoupsValides(jeu) if game.finJeu(jeu): break if len(valides) !=0: coup = game.saisieCoup(jeu) game.joueCoup(jeu,coup) print("Le gagnant est : " + str(game.getGagnant(jeu))) return game.getGagnant(jeu)
def fitness(jeu): joueur = 1 if game.joueur1 == Joueur1 else 2 enemi = 1 if joueur == 2 else 2 f = 0.0 n = 0 if joueur == game.getGagnant(jeu): f += min(jeu[4][joueur - 1] * 1.0 / jeu[4][enemi - 1] * 1.0, 5) if jeu[4][enemi - 1] > 0 else 5 if enemi == game.getGagnant(jeu): f -= min(jeu[4][enemi - 1] * 1.0 / jeu[4][joueur - 1] * 1.0, 5) if jeu[4][joueur - 1] > 0 else 5 f += 0 if jeu[4][enemi - 1] > 0 else 5 f += 0 if jeu[4][joueur - 1] > 0 else 5 n += 1 if jeu[0][0][0] == joueur else 0 n += 1 if jeu[0][0][7] == joueur else 0 n += 1 if jeu[0][7][0] == joueur else 0 n += 1 if jeu[0][7][7] == joueur else 0 n *= 2 f += n return f
def joue(ev1, ev2): it = 0 jeu = game.initialiseJeu() while ((it < 100) and (not (game.finJeu(jeu)))): if (it < 4): coup = Random.saisieCoup(game.getCopieJeu(jeu)) game.joueCoup(jeu, coup) else: if (game.getJoueur(jeu) == 1): coup = Alpha_Beta_Train.saisieCoup(jeu, ev1) else: coup = Alpha_Beta_Train.saisieCoup(jeu, ev2) game.joueCoup(jeu, coup) it += 1 return game.getGagnant(jeu)
def joue(): """void -> nat retourne un gagnant""" jeu = game.initialiseJeu() for i in range(4): random.seed() coup = joueur_aleatoire.saisieCoup(jeu) game.joueCoup(jeu, coup) while not game.finJeu(jeu): #game.affiche(jeu) coup = game.saisieCoup(jeu) game.joueCoup(jeu, coup) return game.getGagnant(jeu)
def play(): global W global Alpha jeu = game.initialiseJeu() print(game.joueur1) while True: #game.affiche(jeu) valides = game.getCoupsValides(jeu) print(EvalCoupHorizon1(game.getCopieJeu(jeu), valides[0])) print(oracle.scorescoups(jeu)[0]) """if jeu[2] !=None: scoresoracle= oracle.scorescoups(jeu) o=EvalCoupHorizon1(game.getCopieJeu(jeu),oracle.saisieCoup(jeu)) for i in range(len(valides)): if scoresoracle[i] < max(scoresoracle): if (o-EvalCoupHorizon1(game.getCopieJeu(jeu),valides[i]))<1: W[0]= W[0]-Alpha*(h1CoupHorizon1(game.getCopieJeu(jeu),valides[i])-h1CoupHorizon1(game.getCopieJeu(jeu),oracle.saisieCoup(jeu))) W[1]= W[1]-Alpha*(h2CoupHorizon1(game.getCopieJeu(jeu),valides[i])-h2CoupHorizon1(game.getCopieJeu(jeu),oracle.saisieCoup(jeu))) W[2]= W[2]-Alpha*(h3CoupHorizon1(game.getCopieJeu(jeu),valides[i])-h3CoupHorizon1(game.getCopieJeu(jeu),oracle.saisieCoup(jeu))) W[3]= W[3]-Alpha*(h4CoupHorizon1(game.getCopieJeu(jeu),valides[i])-h4CoupHorizon1(game.getCopieJeu(jeu),oracle.saisieCoup(jeu))) W[4]= W[4]-Alpha*(h5CoupHorizon1(game.getCopieJeu(jeu),valides[i])-h5CoupHorizon1(game.getCopieJeu(jeu),oracle.saisieCoup(jeu))) W[5]= W[5]-Alpha*(h6CoupHorizon1(game.getCopieJeu(jeu),valides[i])-h6CoupHorizon1(game.getCopieJeu(jeu),oracle.saisieCoup(jeu))) """ if game.finJeu(jeu): break elif valides != None: coup = game.saisieCoup(jeu) game.joueCoup(jeu, coup) return game.getGagnant(jeu)
def estimationMIN(jeu, p=1): if game.finJeu(jeu): g = game.getGagnant(jeu) if g == monJoueur: return 1000 else: return -1000 if p == Pmax: return evaluation(jeu) Vmin = float("inf") for cp in game.getCoupsValides(jeu): j = game.getCopieJeu(jeu) game.joueCoup(j, cp) v = estimationMAX(j, p + 1) if Vmin > v: Vmin = v return Vmin
def estimation(jeu, coup, prf, joueur, alpha, beta): global n game.joueCoup(jeu, coup) if game.finJeu(jeu): n = n + 1 g = game.getGagnant(jeu) if g == joueur: return 100000 elif g == 0: return -100 else: return -100000 elif prf >= PRONF: n = n + 1 return evaluation(jeu, coup, joueur) else: L = game.getCoupsValides(jeu) if (joueur == game.getJoueur(jeu)): val = -5000000 for i in L: n = n + 1 jeu2 = game.getCopieJeu(jeu) val = max(val, estimation(jeu2, i, prf + 1, joueur, alpha, beta)) if val >= beta: return val + 1 alpha = max(val, alpha) return val else: val = 5000000 for i in L: n = n + 1 jeu2 = game.getCopieJeu(jeu) val = min(val, estimation(jeu2, i, prf + 1, joueur, alpha, beta)) if val <= alpha: return val - 1 beta = min(val, beta) return val
def estimationBetaMin(jeu, alpha, beta, p=1): if game.finJeu(jeu): g = game.getGagnant(jeu) if g == monJoueur: return 1000 else: return -1000 if p == Pmax: return evaluation(jeu) Vmin=float("inf") coups=game.getCoupsValides(jeu) for cp in coups: j = game.getCopieJeu(jeu) game.joueCoup(j, cp) v = estimationAlphaMax(j,alpha, beta, p+1) if Vmin>v : Vmin = v if Vmin <= alpha: return Vmin beta = min(beta, Vmin) return Vmin
def estimation(jeu, coup, p, alpha, beta): global nombreDeNoeuds nombreDeNoeuds += 1 #retourne le score d'utilite pour un coup donne copie = game.getCopieJeu(jeu) game.joueCoup(copie, coup) if game.finJeu(copie): g = game.getGagnant(copie) if g == moi: return 123456 #cas gagnant = estimation élevé else: if g == 0: return -123 #cas egalité = estimation neutre-negative else: return -123456 #cas perdant = estimation NEGATIVE if p >= prof: #si profondeur trop élevé, (dernier noeud) renvoie une evaluation de la copie du jeu. liste_parcoursPlat = parcoursPlateau(jeu) return evaluation(copie, liste_parcoursPlat) mValue = 0 coupsV = game.getCoupsValides(copie) for c in coupsV: est = estimation(copie, c, p + 1, alpha, beta) if p % 2 == 0: #noeud MAX mValue = alpha if est >= beta: return beta if est > alpha: alpha = est #on donne à a l'estimation s, qui sera réincrementé dans la boucle. mValue = alpha #on donne a m la valeur de l'estimation, car c'est m qui sera retourné a la fin else: #noeud MIN mValue = beta if est <= alpha: return alpha if est < beta: beta = est mValue = beta return mValue
def estimation(jeu, coup, alpha, beta, p): #retourne le score d'utilite pour un coup donne global cpt cpt += 1 copie = game.getCopieJeu(jeu) game.joueCoup(copie, coup) m = -100000 if p % 2 == 0 else 100000 if game.finJeu(copie): g = game.getGagnant(copie) if g == moi: return 10000 else: if g == 0: return -100 else: return -10000 if p >= prof: return evaluation(copie) if p < prof: coups = game.getCoupsValides(copie) for c in coups: s = estimation(copie, c, alpha, beta, p + 1) if p % 2 == 0: if s >= beta: return beta + 1 if s > m: alpha = max(alpha, s) m = s if p % 2 != 0: if s <= alpha: return alpha - 1 if s < m: beta = min(beta, s) m = s return m
def estimation(jeu, p=1): if game.finJeu(jeu): g = game.getGagnant(jeu) if g == monJoueur: return 1000 else: return -1000 if p == Pmax: return evaluation(jeu) Vmax = float("-inf") listvaleurs = [] for cp in game.getCoupsValides(jeu): j = game.getCopieJeu(jeu) game.joueCoup(j, cp) listvaleurs.append(estimation(j, p + 1)) avgValue = sum(listvaleurs) / len(listvaleurs) closestValue = min(listvaleurs, key=lambda x: abs(x - avgValue)) return closestValue
def estimation(jeu, coup, profondeur, alpha, beta): copie = game.getCopieJeu(jeu) game.joueCoup(copie, coup) if game.finJeu(copie): gagnant = game.getGagnant(copie) if gagnant == moi: return 10000 elif gagnant == 0: return -100 else: return -10000 if profondeur == PMAX: return evaluation(copie) listeCoups = game.getCoupsValides(copie) if profondeur % 2 == 0: #noeud max scoremax = -10000000 for c in listeCoups: score_estime = estimation(copie, c, profondeur + 1, max(alpha, scoremax), beta) if score_estime >= beta: return 10000000 if score_estime > scoremax: scoremax = score_estime return scoremax if profondeur % 2 == 1: #noeud min scoremin = 10000000 for c in listeCoups: score_estime = estimation(copie, c, profondeur + 1, alpha, min(beta, scoremin)) if score_estime <= alpha: return -10000000 if score_estime < scoremin: scoremin = score_estime return scoremin