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 entrainer(fname):
#Creation d'une partie
kb_strat = KeyboardStrategy()
kb_strat.add("a", FonceurTestStrategy())
kb_strat.add("z", FonceurStrategy())
kb_strat.add("e", AttaqueStrategy())
team1 = SoccerTeam(name="Contol Team")
team2 = SoccerTeam(name="Sparing")
team1.add("ControlPlayer1", kb_strat)
team2.add("Player", MultipurposeStrategy())
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)
""" 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)
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)
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)
# recuperation de tous les etats sur les 2 joueurs
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
Strat_protect= SousStrat(protect_cage)
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")
team2.add("PPTI-14-303-10", ElStrategy())
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)
keytest1.add("q", defense_Strategy)
keytest1.add("s", attaque_Strategy)
keytest1.add("x", milieu)
keytest1.add("w", goal_strat)
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)
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)
T2_All = Strat(player_go , "tout")
attaquant_gauche = Strat(attaque_gauche , "7")
att_def_droit = Strat(marcelo , "att_def_droit")
def_gauche = Strat(deff_gauche , "3")
foncer = Strat(foncer , "9")
tire_alea = Strat(tire_aleatoire,"tire_alea")
PasseStrategy = Strat(Passe , "passe")
#BASIC
att_droit_basic = Strat(attaquant_droit_basic , "att_droit")
att_gauche_basic = Strat(attaquant_gauche_basic , "att_gauche")
deffa_droit_basic = Strat(deff_droit_basic , "def_droit")
deffa_gauche_basic = Strat(deff_gauche_basic , "def_gauche")
# ATT DEF GAUCHE
keyatt.add("d" , P1_fonceur )
keyatt.add("s" , att_gauche_basic )
keyatt.add("z" , att_droit_basic )
keyatt.add("q" , deffa_gauche_basic )
keyatt.add("a" , deffa_droit_basic )
# Goal Strategie
keygoal.add("g" , goal_strat)
keygoal.add("f" , defense_Strategy)
keygoal.add("h" , tire_alea)
#DEF STRATEGIE
keydef.add("d" , P1_fonceur )
keydef.add("s" , att_gauche_basic )
keydef.add("z" , att_droit_basic )
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(
Vector2D((2 - idt) * settings.GAME_WIDTH, settings.GAME_HEIGHT / 2.))
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))
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())])
team = SoccerTeam("team",[Player("Aam",tree2Strat), Player("Alex",RandomStrategy())])
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)
""" 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)
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)
#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")
#match=SoccerMatch(team1,team2)
#soccersimulator.show(match)
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)
class RandomStrategy(BaseStrategy):
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 )
keytest1.add("q" , defense_Strategy )
keytest1.add("s" , attaque_Strategy )
keytest1.add("x" , milieu )
keytest1.add("w" , goal_strat )
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())])
######## strategies standards #############
conserver = Strat(conserver,"conserver")
tirer = Strat(tirer,"tirer")
dribbler = Strat(dribbler,"dribbler")
passer = Strat(passer,"passer")
finition = Strat(finition,"finition")
position = Strat(position,"position")
posG= Strat(posG,"position")
posGH = Strat(posGH,"position")
posGB = Strat(posGB,"position")
degG = Strat(degG,"position")
############## stratregies associés au clavier ##########
keytest.add("d",defenseG)
keytest.add("a",attaqueG)
keytest.add("z",millieu)
#keytest.add("c",central)
keytest.add("t",tirer)
keytest.add("c",conserver)
keytest.add("g",dribbler)
keytest.add("q",passer)
keytest.add("f",finition)
keytest.add("x",position)
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])
""" 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)
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)
""" 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)
#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)
player1 = Player("j1",strat)
player2 = Player("j2",strat)
team1=SoccerTeam("team1",[Player("t1j2",StateLessStrategy(Smart2v2)),Player("t1j2",StateLessStrategy(Smart2v2))])
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])
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)
keytest.add("d",posGH)
keytest.add("c",posGB)
keytest.add("x",degG)
#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)
player1 = Player("j1", st)
player2 = Player("j2", st)
team1 = SoccerTeam("team1", [Player("t1j1", StateLessStrategy(Smart1v1ver2))])
team2 = SoccerTeam(
"team1", [player1, Player("t1j2", StateLessStrategy(Smart2v2))])
team4 = SoccerTeam("team1", [
Player("t1j1", StateLessStrategy(Smart1v1ver2)),
Player("t1j2", StateLessStrategy(Smart1v1ver2)),
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)
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__":
show(match_dogomet1)
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)
team2= SoccerTeam("T1",[player1,Player("1", StateLessStrategy(random))])
#team4= SoccerTeam("T1",[Player("1", PasseStrategy()),Player("2",PasseStrategy()),Player("3",PasseStrategy()), Player("4",PasseStrategy())])
team1 = SoccerTeam("T2",[Player("1", FonceurStrategy())])
#team3 = SoccerTeam("T2",[Player("1", FonceurStrategy()),Player("2", FonceurStrategy()), Player("3",FonceurStrategy())])
match = SoccerMatch(team2,team1,init_state=PADState.create_initial_state(2,1))
show(match)
# -*- 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.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())
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")
#match=SoccerMatch(team1,team2)
#soccersimulator.show(match)
#tournoi = SoccerTournament(1)
#tournoi.add_team(team1)
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)
