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)
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)
#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)
