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