def build_apprentissage(fn,generator): ex_raw = KeyboardStrategy.read(fn) exemples = [] labels = [] for x in ex_raw: exemples.append(generator(x[1],x[0][0],x[0][1])) labels.append(x[0][2]) return exemples,labels
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 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)
from soccersimulator import SoccerTeam, SoccerMatch from soccersimulator import Player, SoccerTournament from soccersimulator import BaseStrategy, SoccerAction from soccersimulator import Vector2D, Player, SoccerTournament from soccersimulator.settings import * from strategy import MaStrategyFonceur from strategy import MaStrategyDefensive from strategy import MaStrategyCampeur from strategy import MaStrategyGoal from strategy import MaStrategyUtilitaire import soccersimulator from tools import PlayerStateDeco from soccersimulator import KeyboardStrategy strat = KeyboardStrategy() strat.add("a",MaStrategyFonceur()) strat.add("z",MaStrategyDefensive()) strat.add("e",MaStrategyUtilitaire()) strat.add("r",MaStrategyGoal()) joueur1 = Player("Alpha", strat) joueur2 = Player("Dourou", MaStrategyCampeur()) joueur3= Player("Kiba", MaStrategyGoal()) joueur4= Player("Soro", MaStrategyFonceur()) joueur5 = Player("Dadan", MaStrategyDefensive()) joueur6 = Player("Manque d'inspi", MaStrategyUtilitaire()) team1 = SoccerTeam("Equipe 1", [joueur1,joueur3]) team2 = SoccerTeam("Equipe 2", [joueur5,joueur3]) team3 = SoccerTeam("Equipe 3", [joueur1,joueur2,joueur3,joueur5]) team4 = SoccerTeam("Equipe 4", [joueur6,joueur2,joueur3,joueur5])
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 __init__(self,comportement,name): BaseStrategy.__init__(self,name) self.comportement = comportement def compute_strategy(self, state, id_team, id_player): s_miroir = state if id_team==1 : Mystate = PlayerStateDecorator(s_miroir,id_team , id_player) return self.comportement(Mystate) else : s_miroir = miroir_st(state) Mystate = PlayerStateDecorator(s_miroir,id_team , id_player) return miroir_sa(self.comportement(Mystate)) keyatt = KeyboardStrategy() keygoal = KeyboardStrategy() keydef = KeyboardStrategy() goal_strat = Strat(goal , "1") attaque_Strategy = Strat(attaque_pointe,"attaquant") defense_Strategy = Strat(defenseur1,"def") milieu = Strat(milieu_centre , "mil") milieu_deffa = Strat(milieu_def , "milOf") test = Strat(test1, "test") P1_fonceur = Strat(attaquant1 , "foncer") T2_All = Strat(player_go , "tout") attaquant_gauche = Strat(attaque_gauche , "7")
""" team1.add("ATTAQUANT 1", MS.Attack3()) team1.add("ATTAQUANT 2 ", MS.Intercept()) team1.add("DEFENSEUR 1", MS.DefenseBase()) team1.add("DEFENSEUR 2", MS.Attack2()) team2.add("ATTAQUANT 1", MS.Attack3()) team2.add("ATTAQUANT 2 ", MS.Intercept()) team2.add("DEFENSEUR 1", MS.DefenseBase()) team2.add("DEFENSEUR 2", MS.Attack2()) simu = Simulation(team1,team2,3000) show_simu(simu) """ KBStrat=KeyboardStrategy() KBStrat.add('a',MS.Tirer()) KBStrat.add('z',MS.Degager()) KBStrat.add('e',MS.Dribbler()) KBStrat.add('r',MS.Intercepter()) KBStrat.add('h',MS.AllerAGauche()) KBStrat.add('k',MS.AllerADroite()) KBStrat.add('j',MS.AllerEnBas()) KBStrat.add('u',MS.AllerEnHaut()) team1.add("Manuel1", KBStrat) #team1.add("Manuel2", MS.DefenseBase()) team2.add("Auto1",MS.Attack2()) #team2.add("Auto2", MS.Intercept())
s_miroir = miroir_st(state) Mystate = PlayerStateDecorator(s_miroir,id_team , id_player) return miroir_sa(self.comportement(Mystate)) attaquant_fonceur = Strat(attaquant_fonceur, "A") attaquant_pointe = Strat(attaquant_pointe, "AP") defenseur_central = Strat(defenseur_central, "DC") defenseur_gauche = Strat(defenseur_gauche, "DG") defenseur_droit = Strat(defenseur_droit, "DD") milieu = Strat(milieu, "M") milieu_defensif = Strat(milieu_defensif, "MD") #### Arbres de decisions tree = cPickle.load(file("./arbre.pkl")) dic = {"A":attaquant_fonceur,"AP":attaquant_pointe,"DC":defenseur_central, "DG":defenseur_gauche, "DD":defenseur_droit, "M":milieu, "MD":milieu_defensif} treeStrat = DTreeStrategy(tree,dic,gen_features) #### Controle avec commandes keytest = KeyboardStrategy(fn="arbre") keytest.add("a", attaquant_fonceur) keytest.add("z", attaquant_pointe) keytest.add("d", defenseur_central) keytest.add("e", milieu) keytest.add("r", milieu_defensif)
from soccersimulator import show from soccersimulator import SoccerMatch from soccersimulator import KeyboardStrategy from team import lalya1, lalya2, lalya4, lalya1bis, lalya0 from coordination import * match_lalya1 = SoccerMatch(lalya1, lalya1) match_lalya2 = SoccerMatch(lalya2, lalya2) match_lalya4 = SoccerMatch(lalya4, lalya4) match_lalya5 = SoccerMatch(lalya4, lalya2) if __name__ == "__main__": strat = KeyboardStrategy(fn="monfichier.exp") #fn veut dire filename strat.add("d", defenseur) #Ensuite on ajoute les joueurs, bref... show(match_lalya5)
j10 = Player("intercepte",inter) team1 = SoccerTeam("team1",[joueur6]) toto_team = SoccerTeam("toto_team",[j7,joueur2]) test = SoccerTeam("test",[j7,joueur2,dio]) test2 = SoccerTeam("test2",[joueur1,joueur2]) test3 = SoccerTeam("test3",[joueur2]) test4 = SoccerTeam("test4",[joueur6]) team2 = SoccerTeam("team2",[joueur2,j8]) team4 = SoccerTeam("team4",[joueur2,j8,joueur5,j8]) dTeam = SoccerTeam("dTeam",[j9]) FoncTeam = SoccerTeam("FonceTeam",[joueur1]) t10 = SoccerTeam("ITeam",[j10]) #apprentissage superviseshell strat = KeyboardStrategy() strat.add("f",fonceStrat) strat.add("g",gardien) strat.add("a",attaque) strat.add("d",defense) eleve = Player("eleve",strat) team_spe = SoccerTeam("team_eleve",[eleve]) team_arbre = SoccerTeam("IA",[Player("IA",treeStrat)]) #match = SoccerMatch(team_arbre, team_arbre) #match = SoccerMatch(test3,toto_team) match = SoccerMatch(FoncTeam, t10) soccersimulator.show(match) #strat.write("mon_fichier.exp")
def entrainer2v2_snap(self, fname1, fname2, nb_snap): if self.nb_players != 2: raise Exception( "Not the good number of players for this function.") #Creation d'une partie kb_strat1 = KeyboardStrategy() kb_strat1.add("a", m.strategy.ShootStrat()) kb_strat1.add("z", m.strategy.DefStrat()) kb_strat1.add("e", m.strategy.GardienStrat()) kb_strat1.add("q", m.strategy.DribleStrat()) kb_strat1.add("s", m.strategy.PassStrat()) kb_strat1.add("d", m.strategy.AtkStrat()) kb_strat2 = KeyboardStrategy() kb_strat2.add("a", m.strategy.ShootStrat()) kb_strat2.add("z", m.strategy.DefStrat()) kb_strat2.add("e", m.strategy.GardienStrat()) kb_strat2.add("q", m.strategy.DribleStrat()) kb_strat2.add("s", m.strategy.PassStrat()) kb_strat2.add("d", m.strategy.AtkStrat()) kb_strat2.idp = 1 sortie = False i = 0 while (not sortie) and i < nb_snap: state = self.create_rd_state() kb_strat1.state = state kb_strat2.state = state self.affiche_rd_state(state, 900, 600) joueur_0 = input("Choose strategy for player red 0 : ") joueur_1 = input("Choose strategy for player red 1 : ") kb_strat1.send_strategy(joueur_0) kb_strat2.send_strategy(joueur_1) if input("wanna continue?") == "n": sortie = True i += 1 try: temp_joueur_1 = load_jsonz(fname1) temp_joueur_1 += kb_strat1.states dump_jsonz(temp_joueur_1, fname1) except FileNotFoundError: dump_jsonz(kb_strat1.states, fname1) try: temp_joueur_2 = load_jsonz(fname2) temp_joueur_2 += kb_strat2.states dump_jsonz(temp_joueur_2, fname2) except FileNotFoundError: dump_jsonz(kb_strat2.states, fname2)
from decisiontree import * import cPickle #tree = cPickle.load(file("./test.pkl")) #dic = {"Random":RandomStrategy(),"Fonceur":FoncerStrategy(),"Marquer":MarquerStrategy()} #treeStrat = DTreeStrategy(tree,dic,gen_features) tree2 = cPickle.load(file("test.pkl")) dic_exemple = {"Passe":PasseStrategy(),"Random":RandomStrategy(),"Marquer":MarquerStrategy()} tree2Strat = DTreeStrategy(tree2,dic_exemple,gen_features) tree3 = cPickle.load(file("goal.pkl")) dic_exemple = {"Goal":GoalStrategy(),"Defenseur1":Defenseur1Strategy(),"Defenseur2":Defenseur2Strategy()} tree_goal_strat = DTreeStrategy(tree3,dic_exemple,gen_features) goal_strat = KeyboardStrategy() goal_strat.add("c",GoalStrategy()) #goal_strat.add("v",DefenseStrategy()) goal_strat.add("b",PasseStrategy()) strat2 = KeyboardStrategy() strat2.add("j",GoalStrategy()) strat2.add("k",PasseStrategy()) strat2.add("b", DribleStrategy()) team1 = SoccerTeam("team1",[Player("Alexous",strat2)]) team2 = SoccerTeam("team2",[Player("Sam",tree_goal_strat), Player("Slex",RandomStrategy())]) team3 = SoccerTeam("team3",[Player("A", PasseStrategy()), Player("x",RandomStrategy())])
from strategy import MaStrategyCampeur from strategy import MaStrategyGoal from strategy import MaStrategyUtilitaire from soccersimulator import DecisionTreeClassifier, SoccerMatch, show, SoccerTeam,Player,KeyboardStrategy from strategy import DTreeStrategy #from tree_1v1 import gen_features #from tree_4v4 import gen_features from tree_2v2 import gen_features import cPickle import os f=os.path.join(os.path.dirname(os.path.realpath(__file__)),"tree.pkl") strat = KeyboardStrategy() strat.add("a",MaStrategyFonceur()) strat.add("z",MaStrategyDefensive()) strat.add("e",MaStrategyUtilitaire()) strat.add("r",MaStrategyGoal()) tree = cPickle.load(file(f)) dic = {"Campeur":MaStrategyCampeur(),"Fonceur":MaStrategyFonceur(),"Defenseur":MaStrategyDefensive(),"Utilitaire":MaStrategyUtilitaire(), "Goal":MaStrategyGoal()} treeIA = DTreeStrategy(tree,dic,gen_features) joueur1 = Player("Alpha", strat) joueur2 = Player("Dourou", MaStrategyCampeur()) joueur3= Player("Kiba", MaStrategyGoal()) joueur4= Player("Soro", MaStrategyFonceur()) joueur5 = Player("Dadan", MaStrategyDefensive()) joueur6 = Player("Manque d'inspi", MaStrategyUtilitaire())
def entrainer2v2_main(self, fname1, fname2, ia): if self.nb_players != 2: raise Exception( "Not the good number of players for this function.") #Creation d'une partie kb_strat1 = KeyboardStrategy() kb_strat1.add("a", m.strategy.ShootStrat()) kb_strat1.add("z", m.strategy.DefStrat()) kb_strat1.add("e", m.strategy.GardienStrat()) kb_strat1.add("q", m.strategy.DribleStrat()) kb_strat1.add("s", m.strategy.PassStrat()) kb_strat1.add("d", m.strategy.AtkStrat()) kb_strat2 = KeyboardStrategy() kb_strat2.add("u", m.strategy.ShootStrat()) kb_strat2.add("i", m.strategy.DefStrat()) kb_strat2.add("o", m.strategy.GardienStrat()) kb_strat2.add("j", m.strategy.DribleStrat()) kb_strat2.add("k", m.strategy.PassStrat()) kb_strat2.add("l", m.strategy.AtkStrat()) team1 = SoccerTeam(name="Control Team") #team2 = SoccerTeam(name="Sparing") team1.add("ControlPlayer", kb_strat1) team1.add("ControlPlayer", kb_strat2) #team2.add("Player",m.strategy.ShootStrat()) team2 = ia.get_team(2) simu = Simulation(team1, team2) #Jouer, afficher et controler la partie show_simu(simu) print("Nombre d'exemples : " + str(len(kb_strat1.states) + len(kb_strat2.states))) # Sauvegarde des etats dans un fichier if simu.get_score_team(1) >= simu.get_score_team(2): try: temp_joueur_1 = load_jsonz(fname1) temp_joueur_1 += kb_strat1.states dump_jsonz(temp_joueur_1, fname1) except FileNotFoundError: dump_jsonz(kb_strat1.states, fname1) try: temp_joueur_2 = load_jsonz(fname2) temp_joueur_2 += kb_strat2.states dump_jsonz(temp_joueur_2, fname2) except FileNotFoundError: dump_jsonz(kb_strat2.states, fname2)
""" Permet de jouer et d'entrainer une strategie * changer les strategies ajoutees * utilisation : python entrainer prefix_fichier_exemple par defaut ajoute au fichier d'exemples sil existe deja (extension : .exp pour le fichier exemple) """ from soccersimulator import SoccerMatch, show, SoccerTeam,Player,KeyboardStrategy from strategie import * import sys if __name__=="__main__": prefix = "tree" if len(sys.argv)>1: prefix = sys.argv[1] keytest = KeyboardStrategy(fn = "mon_fichier") keytest.add("d",defenseG) # keytest.add("a",attaqueG) keytest.add("z",millieu) keytest.add("f",finition) keytest.add("t",tirer) keytest.add("c",conserver) keytest.add("g",dribbler) keytest.add("q",passer) keytest.add("x",position) # keytest.add("c",central) # keytest.add("g",posG) # keytest.add("d",posGH) # keytest.add("c",posGB) # keytest.add("x",degG)
""" Permet de jouer et d'entrainer une strategie * changer les strategies ajoutees * utilisation : python entrainer prefix_fichier_exemple par defaut ajoute au fichier d'exemples sil existe deja (extension : .exp pour le fichier exemple) """ from soccersimulator import SoccerMatch, show, SoccerTeam, Player, KeyboardStrategy from strategies import FonceurStrategy, DefenseStrategy, RandomStrategy import sys if __name__ == "__main__": prefix = "tree" if len(sys.argv) > 1: prefix = sys.argv[1] strat_key = KeyboardStrategy() strat_key.add("a", RandomStrategy()) strat_key.add("z", FonceurStrategy()) strat_key.add("e", DefenseStrategy()) team_noob = SoccerTeam( "keyb", [Player("KBs", strat_key), Player("Defense", DefenseStrategy())]) team_bad = SoccerTeam("foncteam", [ Player("Fonceur", FonceurStrategy()), Player("Defense", DefenseStrategy()) ]) match = SoccerMatch(team_noob, team_bad, 1000) show(match) strat_key.write(prefix + ".exp", True)
return me.alligne_sur_demi_cercle else: if me.test_peut_shooter: return me.shoot_intercepter_contrecarE else: return me.aller_vers_ball + me.shoot_alea FonceurStrat = SousStrat(fonceur_pass) Gard_shoot_but = SousStrat(gardien_shoot_vers_but) Gard_shoot_alea = SousStrat(gardien_shoot_alea) DefStrat = SousStrat(def_mouvement_et_shoot) keystrat1 = KeyboardStrategy() keystrat1.add("a", Gard_shoot_alea) keystrat1.add("b", Gard_shoot_but) keystrat2= KeyboardStrategy() keystrat2.add("c", FonceurStrat) keystrat2.add("d", DefStrat) milieustrat = KeyboardStrategy() milieustrat.add("x", FonceurStrat) milieustrat.add("w", DefStrat)
aa = self.decideur(SoccerStateDecorator(state,id_team,id_player,self.info)) return aa #team1=SoccerTeam("team1",[Player("t1j1",StateLessStrategy(random))]) #team2=SoccerTeam("team2",[Player("t2j1",StateLessStrategy(Smart1v1))]) team1=SoccerTeam("team1",[Player("t1j1",StateLessStrategy(random)),Player("t1j2",StateLessStrategy(Smart1v1))]) team2=SoccerTeam("team1",[Player("t2j1",StateLessStrategy(Smart2v2)),Player("t2j2",StateLessStrategy(Smart2v2))]) #team1=SoccerTeam("team1",[Player("t1j1",StateLessStrategy(fonceur)),Player("t1j2",StateLessStrategy(fonceur)),Player("t1j3",StateLessStrategy(fonceur)),Player("t1j4",StateLessStrategy(fonceur))]) #team2=SoccerTeam("team1",[Player("t1j1",StateLessStrategy(Smart1v1)),Player("t1j2",StateLessStrategy(Smart1v1)),Player("t1j3",StateLessStrategy(Smart1v1)),Player("t1j4",StateLessStrategy(Smart1v1))]) strat = KeyboardStrategy() #ou pour une sauvegarde automatique #KeyboardStrategy(fn="monfichier.exp") FS = StateLessStrategy(fonceur) GK = StateLessStrategy(QuickFollow) strat.add("d",FS) strat.add("a",GK) player1 = Player("j1",strat) team1=SoccerTeam("team1",[player1]) team2=SoccerTeam("team2",[Player("t2j1",StateLessStrategy(Smart1v1))]) match=SoccerMatch(team1,team2) show(match) strat.write("monfichier.exp")
from decisiontree import DTreeStrategy from soccersimulator import SoccerMatch, show, SoccerTeam, Player, KeyboardStrategy from decisiontree import gen_features import cPickle #### Arbres de decisions import os fn = os.path.join(os.path.dirname(os.path.realpath(__file__)), "test.pkl") tree = cPickle.load(file(fn)) dic = { "Random": RandomStrategy(), "Fonceur": FonceurStrategy(), "Defense": DefenseStrategy() } treeStrat = DTreeStrategy(tree, dic, gen_features) ### Entrainer un arbre strat_key = KeyboardStrategy() strat_key.add("a", RandomStrategy()) strat_key.add("z", FonceurStrategy()) strat_key.add("e", DefenseStrategy()) team_noob = SoccerTeam( "keyb", [Player("KBs", strat_key), Player("Defense", DefenseStrategy())]) team_bad = SoccerTeam( "foncteam", [Player("IA", treeStrat), Player("Defense", DefenseStrategy())]) show(SoccerMatch(team_noob, team_bad))
""" Permet de jouer et d'entrainer une strategie * changer les strategies ajoutees * utilisation : python entrainer prefix_fichier_exemple par defaut ajoute au fichier d'exemples sil existe deja (extension : .exp pour le fichier exemple) """ from soccersimulator import SoccerMatch, show, SoccerTeam,Player,KeyboardStrategy from strat import * import sys if __name__=="__main__": prefix = "tree" if len(sys.argv)>1: prefix = sys.argv[1] strat_key = KeyboardStrategy() strat_key.add("a",StrategyF()) strat_key.add("g",StrategyG()) team_noob = SoccerTeam("lobIA",[Player("lobIA", strat_key)]) team_bad = SoccerTeam("teamTest",[Player("Fonceur",StrategyP())]) #match = SoccerMatch(team_noob,team_bad,1000) match = SoccerMatch(team_bad,team_noob,1000) #show(match) strat_key.write(prefix+".exp",True)
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)
""" Permet de jouer et d'entrainer une strategie * changer les strategies ajoutees * utilisation : python entrainer prefix_fichier_exemple par defaut ajoute au fichier d'exemples sil existe deja (extension : .exp pour le fichier exemple) """ from soccersimulator import SoccerMatch, show, SoccerTeam,Player,KeyboardStrategy from WalterIA import * import sys if __name__=="__main__": prefix = "tree" if len(sys.argv)>1: prefix = sys.argv[1] strat_key = KeyboardStrategy() strat_key.add("e",all2(3)) strat_key.add("a",gogole()) strat_key.add("z",all2(2)) team_noob = SoccerTeam("keyb",[Player("KBs", strat_key)]) team_bad = SoccerTeam("foncteam",[Player("Fonceur",all2(3))]) match = SoccerMatch(team_noob,team_bad,2000) show(match) strat_key.write(prefix+".exp",True)
if (my_state.distanceAuBallon() > settings.PLAYER_RADIUS + settings.BALL_RADIUS): return my_state.laisse() else: if (my_state.distanceAuButAdv() > settings.GAME_WIDTH / 3.2): return my_state.passe() + my_state.trace() else: return my_state.shoot(my_state.position_but_adv()) ####### ## Construction des equipes ####### team1 = SoccerTeam("EGY") strat_j1 = KeyboardStrategy() strat_j1.add('a', MyAttackStrategy()) strat_j1.add('z', DribblerStrategy()) team1.add("Salah", strat_j1) team1.add("Warda", MyDefenseStrategy()) team2 = SoccerTeam("ALG") team2.add("Mahrez", IntelligentStrategy()) team2.add("Slimani", IntelligentStrategy()) ### Transformation d'un etat en features : state,idt,idp -> R^d def my_get_features(state, idt, idp): """ extraction du vecteur de features d'un etat, ici distance a la balle, distance au but, distance balle but """ p_pos = state.player_state(idt, idp).position f1 = p_pos.distance(state.ball.position) f2 = p_pos.distance(
def __init__(self,tree,dic,gen_feat): BaseStrategy.__init__(self,"Tree Strategy") self.dic = dic self.tree = tree self.gen_feat= gen_feat def compute_strategy(self, state, id_team, id_player): label = self.tree.predict([self.gen_feat(state,id_team,id_player)])[0] if label not in self.dic: print("Erreur : strategie %s non trouve" %(label,)) return SoccerAction() return self.dic[label].compute_strategy(state,id_team,id_player) dic = {"fonceur":StateLessStrategy(fonceur),"reflexion":StateLessStrategy(reflexion),"defent":StateLessStrategy(defent),"defent_l":StateLessStrategy(defent_l), "shooter":StateLessStrategy(shooter)} st=DTreeStrategy(tree,dic,gen_features) strat = KeyboardStrategy() #ou pour une sauvegarde automatique #KeyboardStrategy(fn="monfichier.exp") FS = StateLessStrategy(demarque2v1) RF = StateLessStrategy(reflexion) PA = StateLessStrategy(passage2v1) RI = StateLessStrategy(rien) strat.add("d",FS) strat.add("q",RF) strat.add("a",PA) strat.add("r",RI) player1 = Player("j1",strat) player2 = Player("j2",strat)
def left(mystate): return SoccerAction(Vector2D(-1, 0).norm_max(0.1), Vector2D()) def right(mystate): return SoccerAction(Vector2D(1, 0).norm_max(0.1), Vector2D()) ####### ## Constructioon des equipes ####### team1 = SoccerTeam("Equipe Active") strat_j1 = KeyboardStrategy() strat_j1.add('a', GenStrat(shoot_but)) strat_j1.add('z', GenStrat(dribble)) strat_j1.add('q', GenStrat(se_positionner_haut)) strat_j1.add('s', GenStrat(se_positionner_bas)) strat_j1.add('d', GenStrat(ralentir_moyen)) strat_j1.add('r', GenStrat(donothing)) strat_j1.add('o', GenStrat(up)) strat_j1.add('l', GenStrat(down)) strat_j1.add('k', GenStrat(left)) strat_j1.add('m', GenStrat(right)) team1.add("Jexp 1", strat_j1) team1.add("Jexp 2", ElDefenseur()) team2 = SoccerTeam("team2")
from soccersimulator import SoccerMatch, SoccerTournament,KeyboardStrategy, Vector2D from soccersimulator import SoccerTeam, Player, show from strategy import MaStrategyFonceur from strategy import MaStrategyDefensive from strategy import MaStrategyCampeur from strategy import MaStrategyUtilitaire from strategy import MaStrategyGoal from tools import PlayerStateDeco from soccersimulator import export_graphviz from soccersimulator import settings, Vector2D,DecisionTreeClassifier import cPickle strat = KeyboardStrategy() strat.add("a",MaStrategyFonceur()) strat.add("z",MaStrategyDefensive()) strat.add("e",MaStrategyUtilitaire()) strat.add("r",MaStrategyGoal()) team_noob = SoccerTeam("myteam",[Player("Thithi", strat),Player("Defense d'acier",MaStrategyDefensive())]) team_bad = SoccerTeam("nemesis",[Player("Fonceur",MaStrategyFonceur()),Player("Defense en carton", MaStrategyDefensive())]) ## Fonction de generation de descripteurs def gen_features(state,id_team,id_player): Mystate=PlayerStateDeco(state, id_team, id_player) ball_pos = Mystate.ball_pos my_pos = Mystate.pos() my_goal = Mystate.my_goal his_goal = Mystate.his_goal #liste_copain=Mystate.get_copain_proche()
def __init__(self, comportement, name): BaseStrategy.__init__(self, name) self.comportement = comportement def compute_strategy(self, state, id_team, id_player): s_miroir = state if id_team == 1: Mystate = PlayerStateDecorator(s_miroir, id_team, id_player) return self.comportement(Mystate) else: s_miroir = miroir_st(state) Mystate = PlayerStateDecorator(s_miroir, id_team, id_player) return miroir_sa(self.comportement(Mystate)) keytest = KeyboardStrategy() keytest1 = KeyboardStrategy() goal_strat = Strat(goal, "1") attaque_Strategy = Strat(attaque_pointe, "attaquant") defense_Strategy = Strat(defenseur1, "def") milieu = Strat(milieu_centre, "mil") milieu_attaquant = Strat(milieu_att, "milOf") test = Strat(test1, "test") P1_fonceur = Strat(attaquant1, "att") T2_All = Strat(player_go, "tout") keytest.add("d", defense_Strategy) keytest.add("a", attaque_Strategy) keytest.add("z", milieu) keytest.add("g", goal_strat)
class Strat(BaseStrategy): def __init__(self,comportement,name): BaseStrategy.__init__(self,name) self.comportement = comportement def compute_strategy(self, state, id_team, id_player): s_miroir = state if id_team==1 : Mystate = PlayerStateDecorator(s_miroir,id_team , id_player) return self.comportement(Mystate) else : s_miroir = miroir_st(state) Mystate = PlayerStateDecorator(s_miroir,id_team , id_player) return miroir_sa(self.comportement(Mystate)) keytest = KeyboardStrategy() keytest1 = KeyboardStrategy() goal_strat = Strat(goal , "1") attaque_Strategy = Strat(attaque_pointe,"attaquant") defense_Strategy = Strat(defenseur1,"def") milieu = Strat(milieu_centre , "mil") milieu_attaquant = Strat(milieu_att , "milOf") test = Strat(test1, "test") P1_fonceur = Strat(attaquant1 , "att") T2_All = Strat(player_go , "tout") keytest.add("d" , defense_Strategy ) keytest.add("a" , attaque_Strategy ) keytest.add("z" , milieu ) keytest.add("g" , goal_strat )
def compute_strategy(self,state,id_team,id_player): return SoccerAction(state.ball.position-state.player_state(id_team,id_player).position,\ Vector2D((2-id_team)*settings.GAME_WIDTH,settings.GAME_HEIGHT/2.)-state.ball.position) class StaticStrategy(Strategy): def __init__(self): super(StaticStrategy,self).__init__("Static") def compute_strategy(self,state,id_team,id_player): return SoccerAction() ####### ## Constructioon des equipes ####### team1 = SoccerTeam("team1") strat_j1 = KeyboardStrategy() strat_j1.add('a',FonceStrategy()) strat_j1.add('z',StaticStrategy()) strat_j2 = KeyboardStrategy() strat_j2.add('q',FonceStrategy()) strat_j2.add('s',StaticStrategy()) team1.add("Jexp 1",strat_j1) team1.add("Jexp 2",strat_j2) team2 = SoccerTeam("team2") team2.add("rien 1", StaticStrategy()) team2.add("rien 2", StaticStrategy()) simu = Simulation(team1,team2) show_simu(simu)
def __init__(self,comportement,name): BaseStrategy.__init__(self,name) self.comportement = comportement def compute_strategy(self, state, id_team, id_player): s_miroir = state if id_team==1 : Mystate = PlayerDecorator(s_miroir,id_team , id_player) return self.comportement(Mystate) else : s_miroir = miroir_st(state) Mystate = PlayerDecorator(s_miroir,id_team , id_player) return miroir_sa(self.comportement(Mystate)) keytest = KeyboardStrategy(fn = "mon_fichier2.exp") ############## strategies principales ############ goalG = Strat(goal, "goal") attaqueG = Strat(scoreG,"attaquant") defenseG = Strat(defence,"defenseur") lateralG = Strat(lateral,"lateral") pointe = Strat(fullStrike,"pointe") millieu = Strat(millieu,"millieu") central = Strat(Dcentral,"dc") joueur1 = Strat(j1,"j1") ######## strategies standards ############# conserver = Strat(conserver,"conserver")
sepr = " " * long def aux(node, sep): if tree.tree_.children_left[node] < 0: ls = "(%s)" % (", ".join( "%s: %d" % (tree.classes_[i], int(x)) for i, x in enumerate(tree.tree_.value[node].flat))) return sep + sep1 + "%s\n" % (ls, ) return (sep+sep1+"X%d<=%0.2f\n"+"%s"+sep+sep1+"X%d>%0.2f\n"+"%s" )% \ (tree.tree_.feature[node],tree.tree_.threshold[node],aux(tree.tree_.children_left[node],sep+sepl), tree.tree_.feature[node],tree.tree_.threshold[node],aux(tree.tree_.children_right[node],sep+sepr)) return aux(0, "") exemples = KeyboardStrategy.read("./monfichier.exp") train, labels = build_apprentissage("./monfichier.exp", gen_features) tree = apprendre_arbre(train, labels) print(affiche_arbre(tree)) if __name__ == "__main__": prefix = "./test" if len(sys.argv) > 1: prefix = sys.argv[1] ## constitution de la base d'entrainement et des labels train, labels = build_apprentissage(prefix + ".exp", gen_features) ## apprentissage de l'arbre tree = apprendre_arbre(train, labels) ## sauvegarde de l'arbre cPickle.dump(tree, file(prefix + ".pkl", "w")) ## exporter l'arbre en .dot
""" Permet de jouer et d'entrainer une strategie * changer les strategies ajoutees * utilisation : python entrainer prefix_fichier_exemple par defaut ajoute au fichier d'exemples sil existe deja (extension : .exp pour le fichier exemple) """ from soccersimulator import SoccerMatch, show, SoccerTeam,Player,KeyboardStrategy from projet import * import sys if __name__=="__main__": prefix = "train" if len(sys.argv)>1: prefix = sys.argv[1] strat_key = KeyboardStrategy() strat_key.add("f",fonceStrat) strat_key.add("g",gardien) strat_key.add("a",attaque) strat_key.add("d",defense) team_noob = SoccerTeam("keyb",[Player("KBs", strat_key)]) team_bad = SoccerTeam("foncteam",[Player("toto",j_solo)]) match = SoccerMatch(team_noob,team_bad,1000) show(match) strat_key.write(prefix+".exp",True)
from soccersimulator import SoccerMatch, show, SoccerTeam,Player,KeyboardStrategy,KeyboardStrategy from strategy import MaStrategyFonceur from strategy import MaStrategyDefensive from strategy import MaStrategyCampeur from strategy import MaStrategyUtilitaire from strategy import MaStrategyGoal strat = KeyboardStrategy() strat.add("a",MaStrategyFonceur()) strat.add("z",MaStrategyDefensive()) strat.add("e",MaStrategyUtilitaire()) strat.add("r",MaStrategyGoal()) joueur1 = Player("Alpha", strat) joueur2 = Player("Dourou", MaStrategyCampeur()) joueur3= Player("Kiba", MaStrategyGoal()) joueur4= Player("Soro", MaStrategyFonceur()) joueur5 = Player("Dadan", MaStrategyDefensive()) joueur6 = Player("Manque d'inspi", MaStrategyUtilitaire()) team1 = SoccerTeam("Equipe 1", [joueur1,joueur4]) team2 = SoccerTeam("Equipe 2", [joueur4,joueur5]) match = SoccerMatch(team1,team2,2000) show(match) strat.write("training.exp",True)
""" Permet de jouer et d'entrainer une strategie * changer les strategies ajoutees * utilisation : python entrainer prefix_fichier_exemple par defaut ajoute au fichier d'exemples sil existe deja (extension : .exp pour le fichier exemple) """ from soccersimulator import SoccerMatch, show, SoccerTeam,Player,KeyboardStrategy from strategies import FonceurStrategy, DefenseStrategy, RandomStrategy import sys if __name__=="__main__": prefix = "tree" if len(sys.argv)>1: prefix = sys.argv[1] strat_key = KeyboardStrategy() strat_key.add("a",RandomStrategy()) strat_key.add("z",FonceurStrategy()) strat_key.add("e",DefenseStrategy()) team_noob = SoccerTeam("keyb",[Player("KBs", strat_key),Player("Defense",DefenseStrategy())]) team_bad = SoccerTeam("foncteam",[Player("Fonceur",FonceurStrategy()),Player("Defense", DefenseStrategy())]) match = SoccerMatch(team_noob,team_bad,1000) show(match) strat_key.write(prefix+".exp",True)
from strategies import * from decisiontree import DTreeStrategy from soccersimulator import SoccerMatch, SoccerTeam,Player,KeyboardStrategy from decisiontree import * import cPickle tree2 = cPickle.load(file("test.pkl")) dic_exemple = {"Passe":PasseStrategy(),"Random":RandomStrategy(),"Marquer":MarquerStrategy()} tree2Strat = DTreeStrategy(tree2,dic_exemple,gen_features) tree3 = cPickle.load(file("goal.pkl")) dic_exemple2 = {"Goal":GoalStrategy(),"Defenseur1":Defenseur1Strategy(),"Defenseur2":Defenseur2Strategy(),"Passe":PasseStrategy(),"Drible":DribleStrategy(),"Marquer":MarquerStrategy()} tree_goal_strat = DTreeStrategy(tree3,dic_exemple2,gen_features) strat1 = KeyboardStrategy() strat1.add("a",GoalStrategy()) strat1.add("z",PasseStrategy()) strat1.add("e", Defenseur1Strategy()) strat1.add("r", Defenseur2Strategy()) strat1.add("t", MarquerStrategy()) strat1.add("y", DribleStrategy()) strat1.add("u", FoncerStrategy()) team1 = SoccerTeam("team1",[Player("Arbre",tree_goal_strat)]) team2 = SoccerTeam("team2",[Player("Arbre",tree2Strat), Player("Passeur",PasseStrategy())]) team4 = SoccerTeam("team4",[Player("Defenseur",Defenseur1Strategy()), Player("Passeur",PasseStrategy()), Player("Goal",GoalStrategy()), Player("Attaquant",MarquerStrategy())])
import soccersimulator,soccersimulator.settings from soccersimulator import SoccerTeam, SoccerMatch from soccersimulator import Player, SoccerTournament from soccersimulator import BaseStrategy, SoccerAction from soccersimulator import Vector2D, Player, SoccerTournament from soccersimulator.settings import * from strategy import MaStrategyFonceur from strategy import MaStrategyDefensive from strategy import MaStrategyCampeur from strategy import MaStrategyGoal from strategy import MaStrategyUtilitaire from tools import PlayerStateDeco from soccersimulator import KeyboardStrategy strat = KeyboardStrategy() strat.add("a",MaStrategyFonceur()) strat.add("z",MaStrategyDefensive()) strat.add("e",MaStrategyCampeur()) strat.add("r",MaStrategyUtilitaire()) joueur1 = Player("Alpha", strat) joueur2 = Player("Dourou", MaStrategyCampeur()) joueur3= Player("Kiba", MaStrategyGoal()) joueur4= Player("Soro", MaStrategyFonceur()) joueur5 = Player("Dadan", MaStrategyDefensive()) joueur6 = Player("Manque d'inspi", MaStrategyUtilitaire()) team1 = SoccerTeam("Equipe 1", [joueur1,joueur3]) team2 = SoccerTeam("Equipe 2", [joueur4,joueur5]) team4 = SoccerTeam("Equipe 4", [joueur6,joueur2,joueur3,joueur5])
def compute_strategy(self,state,idteam,idplayer): #ou faire miroir ici self.state = state action,self.name=self.strat(MyState(self.state,idteam,idplayer)) #print action #if(idteam!=1): #action= miroir_action(action) #print action return action QDribbut= SStrat(qdribler_vers_but) QDriblerzone = SStrat(qdribler_vers_zone) QDegager = SStrat(qdegager) QShootBas = SStrat(qshooter_bas) QShootHaut= SStrat(qshooter_haut) QShooterMalin= SStrat(qshooter_malin) QShootFort= SStrat(qshooter_fort) QDegager = SStrat(qdegager) KBS=KeyboardStrategy() KBS.add("y",QShootHaut) KBS.add("h",QShootBas) KBS.add("b",QShootFort) KBS.add("d",QDribbut) KBS.add("u",QShooterMalin) KBS.add("e",QDegager)
from soccersimulator import Vector2D, Player, SoccerTournament from Strategies import * from StratsSpecialise import* from Outils import * ############################################################# ###### CREATION ET AFFECTATION DES KEYBOARD STRATEGIES ##### ############################################################# ############################################ ## Keyb Strategies a tester sur le Milieu ## ############################################ KBS_Milieu = KeyboardStrategy() KBS_Milieu.add("d",Def4vs4_Strat) KBS_Milieu.add("g",Attack4vs4_Strat) ############################################ ## Keyb Strategies a tester sur le Gardien # ############################################ #creation d'une petite strategie a utiliser def degager(me): res=me.degager res.name="degager" return res
return self.dic[label].compute_strategy(state,id_team,id_player) dic = {"fonceur":StateLessStrategy(fonceur),"reflexion":StateLessStrategy(reflexion),"defent":StateLessStrategy(defent),"defent_l":StateLessStrategy(defent_l), "shooter":StateLessStrategy(shooter)} st=DTreeStrategy(tree,dic,gen_features) tab = np.ndarray((3,3,2,2,3)) #team1=SoccerTeam("team1",[Player("t1j1",StateLessStrategy(random))]) #team2=SoccerTeam("team2",[Player("t2j1",StateLessStrategy(Smart1v1))]) #team1=SoccerTeam("team1",[Player("t1j1",StateLessStrategy(fonceur)),Player("t1j2",StateLessStrategy(fonceur)),Player("t1j3",StateLessStrategy(fonceur)),Player("t1j4",StateLessStrategy(fonceur))]) #team2=SoccerTeam("team1",[Player("t1j1",StateLessStrategy(Smart1v1)),Player("t1j2",StateLessStrategy(Smart1v1)),Player("t1j3",StateLessStrategy(Smart1v1)),Player("t1j4",StateLessStrategy(Smart1v1))]) strat = KeyboardStrategy() #ou pour une sauvegarde automatique #KeyboardStrategy(fn="monfichier.exp") FS = StateLessStrategy(fonceur) RF = StateLessStrategy(reflexion) DF = StateLessStrategy(defent) DL = StateLessStrategy(defent_l) SH = StateLessStrategy(shooter) PA = StateLessStrategy(passage) strat.add("d",FS) strat.add("q",RF) strat.add("s",DF) strat.add("z",DL) strat.add("f",SH) strat.add("a",PA)
dic = { "fonceur": StateLessStrategy(fonceur), "reflexion": StateLessStrategy(reflexion), "defent": StateLessStrategy(defent), "defent_l": StateLessStrategy(defent_l), "shooter": StateLessStrategy(shooter) } st = DTreeStrategy(tree, dic, gen_features) #team1=SoccerTeam("team1",[Player("t1j1",StateLessStrategy(random))]) #team2=SoccerTeam("team2",[Player("t2j1",StateLessStrategy(Smart1v1))]) #team1=SoccerTeam("team1",[Player("t1j1",StateLessStrategy(fonceur)),Player("t1j2",StateLessStrategy(fonceur)),Player("t1j3",StateLessStrategy(fonceur)),Player("t1j4",StateLessStrategy(fonceur))]) #team2=SoccerTeam("team1",[Player("t1j1",StateLessStrategy(Smart1v1)),Player("t1j2",StateLessStrategy(Smart1v1)),Player("t1j3",StateLessStrategy(Smart1v1)),Player("t1j4",StateLessStrategy(Smart1v1))]) strat = KeyboardStrategy() #ou pour une sauvegarde automatique #KeyboardStrategy(fn="monfichier.exp") FS = StateLessStrategy(fonceur) RF = StateLessStrategy(reflexion) DF = StateLessStrategy(defent) DL = StateLessStrategy(defent_l) SH = StateLessStrategy(shooter) PA = StateLessStrategy(passage) strat.add("d", FS) strat.add("q", RF) strat.add("s", DF) strat.add("z", DL) strat.add("f", SH) strat.add("a", PA)
""" Permet de jouer et d'entrainer une strategie * changer les strategies ajoutees * utilisation : python entrainer prefix_fichier_exemple par defaut ajoute au fichier d'exemples sil existe deja (extension : .exp pour le fichier exemple) """ from soccersimulator import SoccerMatch, show, SoccerTeam,Player,KeyboardStrategy from strategie import * import sys if __name__=="__main__": prefix = "tree" if len(sys.argv)>1: prefix = sys.argv[1] keytest = KeyboardStrategy(fn = "goal") # keytest.add("d",defenseG) # keytest.add("a",attaqueG) keytest.add("z",millieu) keytest.add("f",finition) keytest.add("t",tirer) keytest.add("c",conserver) keytest.add("g",dribbler) #keytest.add("q",passer) #keytest.add("x",position) # keytest.add("c",central) ############## pour le gardien #########""" keytest.add("g",posG)
""" from soccersimulator import SoccerMatch, show, SoccerTeam,Player,KeyboardStrategy from decisiontree import DTreeStrategy, gen_features import cPickle from coordination import * from team import * import sys ### Entrainer un arbre de la team1IA prefix = "tree" if len(sys.argv)>1: prefix = sys.argv[1] strat_key = KeyboardStrategy(fn="monfichier.exp") #fn veut dire filename strat_key.add("f", fonceur_shooteur) strat_key.add("b", buteur) strat_key.add("r", runv_goal) strat_key.add("t", runv_goal_arr) strat_key.add("d", dribleur) strat_key.add("g", gardienIA) #Joueur de la team1IA t1j1 = Player("t1j1", strat_key) dogomet1 = SoccerTeam("dogomet1", [t1j1]) match_dogomet1 = SoccerMatch(dogomet1, lalya0) if __name__=="__main__":
long = 10 sep1="|"+"-"*(long-1) sepl="|"+" "*(long-1) sepr=" "*long def aux(node,sep): if tree.tree_.children_left[node]<0: ls ="(%s)" % (", ".join( "%s: %d" %(tree.classes_[i],int(x)) for i,x in enumerate(tree.tree_.value[node].flat))) return sep+sep1+"%s\n" % (ls,) return (sep+sep1+"X%d<=%0.2f\n"+"%s"+sep+sep1+"X%d>%0.2f\n"+"%s" )% \ (tree.tree_.feature[node],tree.tree_.threshold[node],aux(tree.tree_.children_left[node],sep+sepl), tree.tree_.feature[node],tree.tree_.threshold[node],aux(tree.tree_.children_right[node],sep+sepr)) return aux(0,"") exemples = KeyboardStrategy.read("./monfichier.exp") train,labels = build_apprentissage("./monfichier.exp",gen_features) tree = apprendre_arbre(train,labels) print(affiche_arbre(tree)) if __name__=="__main__": prefix = "./test" if len(sys.argv)>1: prefix = sys.argv[1] ## constitution de la base d'entrainement et des labels train,labels = build_apprentissage(prefix+".exp",gen_features) ## apprentissage de l'arbre
# -*- coding: utf-8 -*- from soccersimulator import SoccerMatch, show, SoccerTeam, Player, KeyboardStrategy from strategies import * import sys if __name__ == "__main__": prefix = "test" if len(sys.argv) > 1: prefix = sys.argv[1] strat_g = KeyboardStrategy() strat_g.add("t", MarquerStrategy()) strat_g.add("y", DribleStrategy()) strat_g.add("z", PasseStrategy()) team45 = SoccerTeam( "team4", [Player("Al", strat_g), Player("xxx", strat_g), Player("Samounette", strat_g), Player("Sam", strat_g)] ) team46 = SoccerTeam( "team4", [ Player("S", Defenseur1Strategy()), Player("am", Defenseur2Strategy()), Player("l", GoalStrategy()), Player("As", DribleStrategy()), ], ) match = SoccerMatch(team45, team46, 10000) show(match) strat_g.write(prefix + ".exp", True)
#team1=SoccerTeam("team1",[Player("t1j1",StateLessStrategy(random))]) #team2=SoccerTeam("team2",[Player("t2j1",StateLessStrategy(Smart1v1))]) team1 = SoccerTeam("team1", [ Player("t1j1", StateLessStrategy(random)), Player("t1j2", StateLessStrategy(Smart1v1)) ]) team2 = SoccerTeam("team1", [ Player("t2j1", StateLessStrategy(Smart2v2)), Player("t2j2", StateLessStrategy(Smart2v2)) ]) #team1=SoccerTeam("team1",[Player("t1j1",StateLessStrategy(fonceur)),Player("t1j2",StateLessStrategy(fonceur)),Player("t1j3",StateLessStrategy(fonceur)),Player("t1j4",StateLessStrategy(fonceur))]) #team2=SoccerTeam("team1",[Player("t1j1",StateLessStrategy(Smart1v1)),Player("t1j2",StateLessStrategy(Smart1v1)),Player("t1j3",StateLessStrategy(Smart1v1)),Player("t1j4",StateLessStrategy(Smart1v1))]) strat = KeyboardStrategy() #ou pour une sauvegarde automatique #KeyboardStrategy(fn="monfichier.exp") FS = StateLessStrategy(fonceur) GK = StateLessStrategy(QuickFollow) strat.add("d", FS) strat.add("a", GK) player1 = Player("j1", strat) team1 = SoccerTeam("team1", [player1]) team2 = SoccerTeam("team2", [Player("t2j1", StateLessStrategy(Smart1v1))]) match = SoccerMatch(team1, team2) show(match) strat.write("monfichier.exp")
from projet import * from PlayerDecorator import * from zone import * joueur1 = Player("Joueur 1", fonceStrat) joueur2 = Player("Joueur 2", gardien) joueur3 = Player("Joueur 3", MilieuStrategy()) joueur4 = Player("Joueur 4", attaque) joueur5 = Player("Joueur 5", defense) joueur6 = Player("Joueur 6", j_solo) team1 = SoccerTeam("team1",[joueur6]) test = SoccerTeam("test",[joueur1]) team2 = SoccerTeam("team2",[joueur2,joueur4]) team4 = SoccerTeam("team4",[joueur2,joueur5,joueur4,joueur1]) #apprentissage supervise strat = KeyboardStrategy() strat.add("f",fonceStrat) strat.add("g",gardien) strat.add("a",attaque) strat.add("d",defense) eleve = Player("eleve",strat) team_spe = SoccerTeam("team_eleve",[eleve]) #match = SoccerMatch(team1, team_spe) match = SoccerMatch(team4, team4) soccersimulator.show(match)