def entrainer1v1_main(self, fname, ia):
if self.nb_players != 1:
raise Exception(
"Not the good number of players for this function.")
#Creation d'une partie
kb_strat = KeyboardStrategy()
kb_strat.add("a", m.strategy.ShootStrat())
kb_strat.add("z", m.strategy.DefStrat())
kb_strat.add("e", m.strategy.GardienStrat())
kb_strat.add("q", m.strategy.DribleStrat())
kb_strat.add("s", m.strategy.PassStrat())
kb_strat.add("d", m.strategy.AtkStrat())
team1 = SoccerTeam(name="Control Team")
#team2 = SoccerTeam(name="Sparing")
team1.add("ControlPlayer", kb_strat)
#team2.add("Player",m.strategy.ShootStrat())
team2 = ia.get_team(1)
simu = Simulation(team1, team2)
#Jouer, afficher et controler la partie
show_simu(simu)
print("Nombre d'exemples : " + str(len(kb_strat.states)))
# Sauvegarde des etats dans un fichier
if simu.get_score_team(1) > simu.get_score_team(2):
try:
temp = load_jsonz(fname)
temp += kb_strat.states
dump_jsonz(temp, fname)
except FileNotFoundError:
dump_jsonz(kb_strat.states, fname)
def start(self, show=False, verbose=True):
self.results = np.empty((self.trials, 2), dtype=int)
for i in range(self.trials):
if verbose:
print(" Match", i)
brasil = SoccerTeam("Brasil")
brasil.add(
"self.strategy",
self.strategy(accShoot=self.list_param[0],
accDrible=self.list_param[1],
vit=self.list_param[2],
n=self.list_param[3],
maxAngle=self.list_param[4],
tooFar=self.list_param[5],
rSurfBut=self.list_param[6],
AngleHyst=self.list_param[7],
alpha=self.list_param[8]))
desafiante = self.ia.get_team(1)
simu = Simulation(brasil, desafiante, max_steps=self.max_steps)
if show:
show_simu(simu)
else:
simu.start()
self.results[i, 0] = simu.get_score_team(1)
self.results[i, 1] = simu.get_score_team(2)
if verbose:
print(" Score : {} x {}".format(self.results[i, 0],
self.results[i, 1]))
def check_team(team):
teamDefault = SoccerTeam()
for nb in range(team.nb_players):
teamDefault.add(str(nb), Strategy())
if Simulation(team,teamDefault,max_steps=MAX_TEST_STEPS).start().error or \
Simulation(teamDefault,team,max_steps=MAX_TEST_STEPS).start().error:
return False
return True
def start(self, show=True):
team1 = SoccerTeam("Team 1")
team1.add("Test tire", self.strategy)
self.simu = Simulation(team1, max_steps=100000)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def __init__(self):
self.strat = ShootExpe()
team1 = SoccerTeam("test")
team1.add("Expe", self.strat)
team2 = SoccerTeam("test2")
team2.add("Nothing", Strategy())
self.simu = Simulation(team1, team2, max_steps=40000)
self.simu.listeners += self
self.discr_step = 20
self.nb_essais = 20
def start(self , show=True , fps=None):
if not self.simu:
team1 = SoccerTeam("Team␣1")
team2 = SoccerTeam("Team␣2")
team1.add(self.strategy.name , self.strategy)
team2.add(StrategyAttaquant().name , StrategyAttaquant())
self.simu = Simulation(team1 , team2 , max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu , fps=fps)
else:
self.simu.start ()
def start(self, show=True):
if not self.simu:
team1 = SoccerTeam("Team 1")
team2 = SoccerTeam("Team 2")
team1.add("Defenseur_2v2_opti.name", self.strategy)
team2.add("Fonceur_brain.name", Fonceur())
self.simu = Simulation(team1, team2, max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def start(self, show=True):
if not self.simu:
team1 = SoccerTeam("Team 1")
team2 = SoccerTeam("Team 2")
team1.add(self.strategy1.name, self.strategy1)
team2.add(self.strategy2.name, self.strategy2)
self.simu = Simulation(team1, team2, max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def start(self, show=True):
if not self.simu:
team1 = SoccerTeam("Team Goal")
team2 = SoccerTeam("Team Shooter")
team1.add(self.strategy.name, self.strategy)
team2.add(FSF().name, FSF())
self.simu = Simulation(team1, team2, max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def start(self, show=True):
if not self.simu:
team1 = SoccerTeam("Chelsea")
team2 = SoccerTeam("Arsenal")
team1.add(self.strategy.name, self.strategy)
#team2.add(Strategy().name, Strategy())
self.simu = Simulation(team1, team2, max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def start(self, show=True):
if not self.simu:
team1 = SoccerTeam("Team Passeurs")
team2 = SoccerTeam("Team Vide")
team1.add(self.strategy.name, self.strategy)
team1.add(PasseTestStrategy().name, PasseTestStrategy())
team2.add(Strategy().name, Strategy())
self.simu = Simulation(team1, team2, max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def start(self, show=True):
if not self.simu:
team1 = SoccerTeam("Team Fonceur")
team2 = SoccerTeam("Team Dribbler")
#team1.add(FonceurChallenge1Strategy().name, FonceurChallenge1Strategy())
team1.add(FonceurStrategy().name, FonceurStrategy())
team2.add(self.strategy.name, self.strategy)
self.simu = Simulation(team1, team2, max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def entrainer(fname):
#Creation d'une partie
kb_strat_def = KeyboardStrategy()
kb_strat_def.add("a", posdefStrategy())
kb_strat_def.add("z", passeStrategy())
kb_strat_atk = KeyboardStrategy()
kb_strat_atk.add("q", pospasseStrategy())
kb_strat_atk.add("s", dribbleStrategy())
kb_strat_atk.add("d", tirStrategy())
team1 = SoccerTeam(name="Control Team")
team2 = SoccerTeam(name="Sparing")
team1.add("Defenseur", kb_strat_def)
team1.add("Attaquant", kb_strat_atk)
team2.add("Player1", AttaqueStrategy())
team2.add("Player2", DefenseStrategy())
simu = Simulation(team1, team2)
#Jouer, afficher et controler la partie
show_simu(simu)
print("Nombre d'exemples : " + str(len(kb_strat_atk.states)))
print("Nombre d'exemples : " + str(len(kb_strat_def.states)))
# Sauvegarde des etats dans un fichier
dump_jsonz(kb_strat_atk.states, fname)
dump_jsonz(kb_strat_def.states, fname)
def __init__(self,visu = False): # Visu permet la visualisation de la simu. Si on en veut pas, on met false. Cela est permis par la fonction start en bas.
team1 = SoccerTeam("expe1")
team2 = SoccerTeam("expe2")
self.strat = shoot() # On donne la strat qu'on va utiliser.
team1.add("jexp1", self.strat )
team2.add("jplot",Strategy()) # Si besoin d'un joueur de team adverse
self.simu = Simulation(team1,team2,max_steps=10000000) # On def la simu avec un enorme max_steps car on veut test x round et on veut pas devoir recommencer un match
self.visu = visu
self.simu.listeners+=self #ajout de l observer
list_a = np.linspace(0.1,20,30) # Creation de la matrice pour la parametre a. De param1 a param2 avec param2 valeurs
list_b = np.linspace(0.1,20,30)
self.list_params = [(a,b) for a in list_a for b in list_b] # Creation de tout les couples possible
self.cpt_params = 0 # Va permettre de tester toute la liste de couple de params
self.nb_expe = 20 # Nb de round que l on fera par postion
self.res = dict() # Ini de notre dico
self.pos = dict()
def entrainement(fn):
simu = Simulation(team1, team2)
show_simu(simu)
# recuperation de tous les etats
training_states = strat_j1.states
# sauvegarde dans un fichier
dump_jsonz(training_states, fn)
def jouer_arbre(dt):
####
# Utilisation de l'arbre
###
dic = {"Fonce": FonceStrategy(), "Static": StaticStrategy()}
treeStrat1 = DTreeStrategy(dt, dic, my_get_features)
treeStrat2 = DTreeStrategy(dt, dic, my_get_features)
team3 = SoccerTeam("Arbre Team")
team3.add("Joueur 1", treeStrat1)
team3.add("Joueur 2", treeStrat2)
simu = Simulation(team2, team3)
show_simu(simu)
class ParamSearch(object):
def __init__(self, strategy, params, simu=None, trials=20, max_steps=1000000, max_round_step=40):
self.strategy = strategy
self.params = params.copy()
self.simu = simu
self.trials = trials
self.max_steps = max_steps
self.max_round_step = max_round_step
def start(self, show=True):
if not self.simu:
team1 = SoccerTeam("Team 1")
team2 = SoccerTeam("Team 2")
team1.add(self.strategy.name, self.strategy)
team2.add(Strategy().name, Strategy())
self.simu = Simulation(team1, team2, max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def jouer_arbre(dt):
####
# Utilisation de l'arbre
###
dic = dict([(f.__name__, GenStrat(f)) for f in [
dribble, se_positionner_haut, se_positionner_bas, donothing,
ralentir_moyen, shoot_but, up, down, left, right
]])
treeStrat1 = DTreeStrategy(dt, dic, my_get_features)
team3 = SoccerTeam("Arbre Team")
team3.add("Joueur 1", treeStrat1)
team3.add("Joueur 2", ElDefenseur())
simu = Simulation(team2, team3)
show_simu(simu)
def entrainer(fname):
#Creation d'une partie
kb_strat = KeyboardStrategy()
kb_strat.add("a", FonceurStrategy())
kb_strat.add("z", Milieu())
kb_strat.add("e", Gardien())
team1 = SoccerTeam(name="Contol Team")
team2 = SoccerTeam(name="Sparing")
team1.add("ControlPlayer", kb_strat)
team2.add("Player", FonceurStrategy())
simu = Simulation(team1, team2)
#Jouer, afficher et controler la partie
show_simu(simu)
print("Nombre d'exemples : " + str(len(kb_strat.states)))
# Sauvegarde des etats dans un fichier
dump_jsonz(kb_strat.states, fname)
def jouer_arbre(dt):
####
# Utilisation de l'arbre
###
dic = {
"Ma Strategie d'attaque": MyAttackStrategy(),
"Strategie Intelligente": IntelligentStrategy(),
"Ma Strategie de defense": MyDefenseStrategy(),
"Ma Strategie de dribble": DribblerStrategy()
}
treeStrat1 = DTreeStrategy(dt, dic, my_get_features)
treeStrat2 = DTreeStrategy(dt, dic, my_get_features)
team3 = SoccerTeam("Arbre Team")
team3.add("Giroud", treeStrat1)
team3.add("Pogba", treeStrat2)
simu = Simulation(team2, team3)
show_simu(simu)
class Observer(object):
MAX_STEP=40
def __init__(self,visu = False): # Visu permet la visualisation de la simu. Si on en veut pas, on met false. Cela est permis par la fonction start en bas.
team1 = SoccerTeam("expe1")
team2 = SoccerTeam("expe2")
self.strat = shoot() # On donne la strat qu'on va utiliser.
team1.add("jexp1", self.strat )
team2.add("jplot",Strategy()) # Si besoin d'un joueur de team adverse
self.simu = Simulation(team1,team2,max_steps=10000000) # On def la simu avec un enorme max_steps car on veut test x round et on veut pas devoir recommencer un match
self.visu = visu
self.simu.listeners+=self #ajout de l observer
list_a = np.linspace(0.1,20,30) # Creation de la matrice pour la parametre a. De param1 a param2 avec param2 valeurs
list_b = np.linspace(0.1,20,30)
self.list_params = [(a,b) for a in list_a for b in list_b] # Creation de tout les couples possible
self.cpt_params = 0 # Va permettre de tester toute la liste de couple de params
self.nb_expe = 20 # Nb de round que l on fera par postion
self.res = dict() # Ini de notre dico
self.pos = dict()
def begin_match(self,team1,team2,state):
#initialisation des parametres ...
self.last, self.but, self.expe = 0, 0, 0
def begin_round(self,team1,team2,state):
self.x,self.y = 4*GAME_WIDTH/7+random.uniform(0,1)*GAME_WIDTH/7,GAME_HEIGHT/4+random.uniform(0,1)*GAME_HEIGHT/4 # Ini des postions qu on voudra en depart, dans un secteur donne
self.simu.state.states[(1,0)].position = Vector2D(self.x,self.y)
self.simu.state.ball.position = Vector2D(self.x,self.y)
#ou self.simu.set_state(state)
self.strat.a,self.strat.b = self.list_params[self.cpt_params] # On met les vals de a et b dans shoot que l on veut pour les couples dans list_params
self.last = self.simu.step # Pas a la fin du round precedant
def update_round(self,team1,team2,state):
if state.step>self.last+self.MAX_STEP:
self.simu.end_round()
def end_round(self,team1,team2,state):
if state.goal>0: # Si but marque, on incremente but
self.but+=1
self.expe+=1 # On increment pour chaque round
if self.expe > self.nb_expe:
if self.cpt_params <len(self.list_params)-1: # Si on a pas traite tout les couples
if self.but*1./self.expe > 0.5 :
self.res[self.list_params[self.cpt_params]]= self.but*1./self.expe # On met dans res la proba
self.pos[self.list_params[self.cpt_params]]= self.x,self.y
self.cpt_params+=1 # On change les params qu on va tester
self.last, self.but, self.expe = 0, 0, 0 # On reinitialise
else:
self.simu.end_match() # Sinon on end
def start(self):
if self.visu :
show_simu(self.simu)
else:
self.simu.start()
# Trouver parametre
def entrainer(fname):
#Creation d'une partie
kb_strat = KeyboardStrategy()
kb_strat.add("q", GoToMyGoalStrategy())
kb_strat.add("z", PushUpStrategy())
kb_strat.add("p", PassStrategy())
kb_strat.add("m", ReceivePassStrategy())
kb_strat.add("d", CutDownAngleStrategy())
kb_strat.add("s", MarkStrategy())
team1 = SoccerTeam(name="Contol Team")
team2 = ia.get_team(2)
team1.add("ControlPlayer", kb_strat)
team1.add(" ST", AttaquantStrategy(fn_st="st_dico_TME8.pkl"))
simu = Simulation(team1, team2)
#Jouer, afficher et controler la partie
show_simu(simu)
print("Nombre d'exemples : " + str(len(kb_strat.states)))
# Sauvegarde des etats dans un fichier
dump_jsonz(kb_strat.states, fname)
def entrainer(fichier):
"""
Simule un match dans lequel on doit intervenir pour générer un fichier d'apprentissage.
Contrôles : a pour Fonceur, d pour Défenseur.
"""
#Création des équipes
kb_strat = KeyboardStrategy()
kb_strat.add("a", Fonceur())
kb_strat.add("d", Defenseur())
team1 = SoccerTeam(name="Moi")
team2 = SoccerTeam(name="Idiots")
team1.add("ControlPlayer", kb_strat)
team2.add("Player", Fonceur())
#Jouer, afficher et controler la partie
simu = Simulation(team1, team2)
show_simu(simu)
print("Nombre d'exemples : " + str(len(kb_strat.states)))
# Sauvegarde des états dans un fichier
dump_jsonz(kb_strat.states, fichier)
"""
Created on Mon Feb 4 16:51:52 2019
@author: 3700049
"""
#from Strategy_f import SuperState, StrategySolo, StrategyAttaquant, StrategyDefenseur, StrategyDefenseur_duo, RandomStrategy
#from soccersimulator import SoccerTeam
#
#def get_team(nb_players): +++++
# team = SoccerTeam(name="Unknown")
# if nb_players == 1:
# team.add("StrikeBack",StrategySolo())
# if nb_players == 2:
# team.add("Footix", RandomStr++ategy())
# team.add("Billy", StrategyDefenseur_duo())
# if nb_players == 3:
# team.add("Footix", StrategyAttaquant())----
# team.add( a"Footix", StrategyAttaquant())
# team.add("Billy", StrategyDefenseur_duo())
# return team
#if __name__ =='__main__':
from soccersimulator import Simulation, show_simu
from Strategy_f import get_team
team1 = get_team(4)
team2 = get_team(5)
simu = Simulation (team1,team2)
show_simu(simu)
class ShootSearch(object):
""" nombre d'iterations maximales jusqu'a l'arret d'un round
discr_step : pas de discretisation du parametre
nb_essais : nombre d'essais par parametre
"""
MAX_STEP = 40
def __init__(self):
self.strat = ShootExpe()
team1 = SoccerTeam("test")
team1.add("Expe", self.strat)
team2 = SoccerTeam("test2")
team2.add("Nothing", Strategy())
self.simu = Simulation(team1, team2, max_steps=40000)
self.simu.listeners += self
self.discr_step = 20
self.nb_essais = 20
def start(self, visu=True):
""" demarre la visualisation avec ou sans affichage"""
if visu:
show_simu(self.simu)
else:
self.simu.start()
def begin_match(self, team1, team2, state):
""" initialise le debut d'une simulation
res : dictionnaire des Resultats
last : step du dernier round pour calculer le round de fin avec MAX_STEP
but : nombre de but pour ce parametre
cpt : nombre d'essais pour ce parametre
params : liste des parametres a tester
idx : identifiant du parametre courant
"""
self.res = dict()
self.last = 0
self.but = 0
self.cpt = 0
self.params = [
x for x in np.linspace(1, settings.maxPlayerShoot, self.discr_step)
]
self.idx = 0
def begin_round(self, team1, team2, state):
""" engagement : position random du joueur et de la balle """
position = Vector2D(
np.random.random() * settings.GAME_WIDTH / 2. +
settings.GAME_WIDTH / 2.,
np.random.random() * settings.GAME_HEIGHT)
self.simu.state.states[(1, 0)].position = position.copy()
self.simu.state.states[(1, 0)].vitesse = Vector2D()
self.simu.state.ball.position = position.copy()
self.strat.norm = self.params[self.idx]
self.last = self.simu.step
def update_round(self, team1, team2, state):
""" si pas maximal atteint, fin du tour"""
if state.step > self.last + self.MAX_STEP:
self.simu.end_round()
def end_round(self, team1, team2, state):
if state.goal > 0:
self.but += 1
self.cpt += 1
if self.cpt >= self.nb_essais:
self.res[self.params[self.idx]] = self.but * 1. / self.cpt
logger.debug("parametre %s : %f" % (
(str(self.params[self.idx]), self.res[self.params[self.idx]])))
self.idx += 1
self.but = 0
self.cpt = 0
""" si plus de parametre, fin du match"""
if self.idx >= len(self.params):
self.simu.end_match()
# -*- coding: utf-8 -*- from soccersimulator import SoccerTeam, Simulation, Strategy from soccersimulator import show_simu from ia.strategies import * import ia import module3 as module import module2 as module2 import module as module3 left = module.get_team(4) #left = module3.get_team(4) #right = module3.get_team(4) right = ia.get_team(4) simu = Simulation(right, left) #simu = Simulation(left,right) show_simu(simu)
from salsa import Attaquant, Defense
from soccersimulator import Player, SoccerTeam, Simulation, show_simu
joueura1 = Player("Attaquant A", Attaquant())
joueura2 = Player("Defenseur A", Defense())
team1 = SoccerTeam("Equipe A", [joueura1, joueura2])
# nombre de joueurs de l equipe
joueurb1 = Player("Attaquant B", Attaquant())
joueurb2 = Player("Defenseur B", Defense())
team2 = SoccerTeam("Equipe B", [joueurb1, joueurb2])
# Creer un match entre 2 equipes et de duree 10 pas
match = Simulation(team1, team2, 1000)
# Jouer le match ( sans le visualiser )
match.start()
# Jouer le match en le visualisant
show_simu(match)
# Attention !! une fois le match joue , la fonction start () permet de faire jouer le replay
# mais pas de relancer le match !!!
# Pour regarder le replay d un match
from footIA.strats import GoalStrategy, DribleStrategy, FonceurStrategy, MultipurposeStrategy, RandomStrategy
from soccersimulator import SoccerTeam, Simulation, show_simu,KeyboardStrategy,DTreeStrategy,load_jsonz,dump_jsonz
from soccersimulator import apprend_arbre, build_apprentissage, genere_dot
from footIA import MultipurposeStrategy,GoalStrategy,ToolBox,DribleStrategy,DefenseurStrategy
import sklearn
import numpy as np
import pickle
from arbre import my_get_features
dic_strategy = {MultipurposeStrategy().name:MultipurposeStrategy(),GoalStrategy().name:GoalStrategy(),DribleStrategy().name:DribleStrategy(),DefenseurStrategy().name:DefenseurStrategy()}
with open("tree_test.pkl","rb") as f:
dt = pickle.load(f)
treeStrat1 = DTreeStrategy(dt,dic_strategy,my_get_features)
## Creation d'une equipe
pyteam = SoccerTeam(name="PyTeam")
control = SoccerTeam(name="controlStratTeam")
pyteam.add("verstile", MultipurposeStrategy())
control.add("control", treeStrat1)
#pyteam.add("dVersatile2", MultipurposeStrategy())
#Creation d'une partie
simu = Simulation(pyteam,control)
#Jouer et afficher la partie
show_simu(simu)
nVect = 5
gk_st_team = GKStrikerTeam(size=size)
gk_st_team.start()
gk_cf_team = GKStrikerTeam(size=size) #GKCForwardTeam(size)
gk_cf_team.start()
for n in range(nbIter):
gk_st_team.restart()
gk_cf_team.restart()
for i in range(size):
gk_st = gk_st_team.getTeam(i)
gk_st_p = gk_st_team.getVector(i)
for j in range(size):
gk_cf = gk_cf_team.getTeam(j)
gk_cf_p = gk_cf_team.getVector(j)
team = {1: (gk_st, gk_st_p), 2: (gk_cf, gk_cf_p)}
if random.random() < 0.5:
team[1], team[2] = team[2], team[1]
simu = Simulation(team[1][0], team[2][0])
simu.start()
#print(j)
setCounters(simu, team[1][1], team[2][1])
print(n)
gk_st_team.update()
gk_cf_team.update()
gk_st_team.printVectors(nVect)
gk_cf_team.printVectors(nVect)
gk_st_team.save()
simu = Simulation(gk_st_team.getBestTeam(), gk_cf_team.getBestTeam())
show_simu(simu)
class ParamSearch(object):
def __init__(self, strategy, params, simu=None, trials=20, max_steps=1000000,
max_round_step=40):
self.strategy = strategy
self.params = params.copy()
self.simu = simu
self.trials = trials
self.max_steps = max_steps
self.max_round_step = max_round_step
def start(self, show=True):
if not self.simu:
team1 = SoccerTeam("Team 1")
team2 = SoccerTeam("Team 2")
team1.add(self.strategy.name, self.strategy)
team2.add(Strategy().name, Strategy())
self.simu = Simulation(team1, team2, max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def begin_match(self, team1, team2, state):
self.last = 0 # Step of the last round
self.crit = 0 # Criterion to maximize (here, number of goals)
self.cpt = 0 # Counter for trials
if len(self.params) > 2:
raise ValueError('Max two parameters')
self.param_keys = list(self.params.keys()) # Name of all parameters
self.param_id = [0] * len(self.param_keys) # Index of the parameter values
self.res = dict() # Dictionary of results
def begin_round(self, team1, team2, state):
ball = Vector2D.create_random(low=0, high=1)
ball.x *= GAME_WIDTH / 2
ball.x += GAME_WIDTH / 2
ball.y *= GAME_HEIGHT
# Player and ball postion (random)
self.simu.state.states[(1, 0)].position = ball.copy() # Player position
self.simu.state.states[(1, 0)].vitesse = Vector2D() # Player acceleration
self.simu.state.ball.position = ball.copy() # Ball position
# Last step of the game
self.last = self.simu.step
# Set the current value for the current parameter
for i, (key, values) in zip(self.param_id, self.params.items()):
setattr(self.strategy, key, values[i])
def update_round(self, team1, team2, state):
# Stop the round if it is too long
if state.step > self.last + self.max_round_step:
self.simu.end_round()
def end_round(self, team1, team2, state):
# A round ends when there is a goal
if state.goal > 0:
self.crit += 1 # Increment criterion
self.cpt += 1 # Increment number of trials
for i, (key, values) in zip(self.param_id, self.params.items()):
print("{}: {}".format(key, values[i]), end=" ")
print("Crit: {} Cpt: {}".format(self.crit, self.cpt))
if self.cpt >= self.trials:
# Save the result
res_key = tuple()
for i, values in zip(self.param_id, self.params.values()):
res_key += values[i],
self.res[res_key] = self.crit * 1. / self.trials
# Reset parameters
self.crit = 0
self.cpt = 0
# Go to the next parameter value to try
key0 = self.param_keys[0]
if self.param_id[0] < len(self.params[key0]) - 1:
self.param_id[0] += 1
elif len(self.params) > 1:
key1 = self.param_keys[1]
if self.param_id[1] < len(self.params[key1]) - 1:
self.param_id[0] = 0
self.param_id[1] += 1
else:
self.simu.end_match()
else:
self.simu.end_match()
def get_res(self):
return self.res
