def entrainer1v1_main(self, fname, ia):
if self.nb_players != 1:
raise Exception(
"Not the good number of players for this function.")
#Creation d'une partie
kb_strat = KeyboardStrategy()
kb_strat.add("a", m.strategy.ShootStrat())
kb_strat.add("z", m.strategy.DefStrat())
kb_strat.add("e", m.strategy.GardienStrat())
kb_strat.add("q", m.strategy.DribleStrat())
kb_strat.add("s", m.strategy.PassStrat())
kb_strat.add("d", m.strategy.AtkStrat())
team1 = SoccerTeam(name="Control Team")
#team2 = SoccerTeam(name="Sparing")
team1.add("ControlPlayer", kb_strat)
#team2.add("Player",m.strategy.ShootStrat())
team2 = ia.get_team(1)
simu = Simulation(team1, team2)
#Jouer, afficher et controler la partie
show_simu(simu)
print("Nombre d'exemples : " + str(len(kb_strat.states)))
# Sauvegarde des etats dans un fichier
if simu.get_score_team(1) > simu.get_score_team(2):
try:
temp = load_jsonz(fname)
temp += kb_strat.states
dump_jsonz(temp, fname)
except FileNotFoundError:
dump_jsonz(kb_strat.states, fname)
def start(self, show=False, verbose=True):
self.results = np.empty((self.trials, 2), dtype=int)
for i in range(self.trials):
if verbose:
print(" Match", i)
brasil = SoccerTeam("Brasil")
brasil.add(
"self.strategy",
self.strategy(accShoot=self.list_param[0],
accDrible=self.list_param[1],
vit=self.list_param[2],
n=self.list_param[3],
maxAngle=self.list_param[4],
tooFar=self.list_param[5],
rSurfBut=self.list_param[6],
AngleHyst=self.list_param[7],
alpha=self.list_param[8]))
desafiante = self.ia.get_team(1)
simu = Simulation(brasil, desafiante, max_steps=self.max_steps)
if show:
show_simu(simu)
else:
simu.start()
self.results[i, 0] = simu.get_score_team(1)
self.results[i, 1] = simu.get_score_team(2)
if verbose:
print(" Score : {} x {}".format(self.results[i, 0],
self.results[i, 1]))
def check_team(team):
teamDefault = SoccerTeam()
for nb in range(team.nb_players):
teamDefault.add(str(nb), Strategy())
if Simulation(team,teamDefault,max_steps=MAX_TEST_STEPS).start().error or \
Simulation(teamDefault,team,max_steps=MAX_TEST_STEPS).start().error:
return False
return True
def start(self, show=True):
team1 = SoccerTeam("Team 1")
team1.add("Test tire", self.strategy)
self.simu = Simulation(team1, max_steps=100000)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def __init__(self):
self.strat = ShootExpe()
team1 = SoccerTeam("test")
team1.add("Expe", PasseStrategy())
team1.add("Exp", AttaqueStrategy_2v2())
team2 = SoccerTeam("test2")
team2.add("Nothing", Strategy())
self.simu = Simulation(team1, team2, max_steps=1000000)
self.simu.listeners += self
self.discr_step = 20
self.nb_essais = 20
def getTeam(self, i):
"""
Doc a modifier
"""
self.team = SoccerTeam(self.name)
params = self.vectors[i].params
for i in range(2):
for p in self.playerParams[i]:
self.playerStrats[0].dico[p] = params[p] # params du st
self.team.add(self.playerStrats[0].name, self.playerStrats[0])
return self.team
def jouer_arbre(dt):
####
# Utilisation de l'arbre
###
dic = {"Fonce": FonceStrategy(), "Static": StaticStrategy()}
treeStrat1 = DTreeStrategy(dt, dic, my_get_features)
treeStrat2 = DTreeStrategy(dt, dic, my_get_features)
team3 = SoccerTeam("Arbre Team")
team3.add("Joueur 1", treeStrat1)
team3.add("Joueur 2", treeStrat2)
simu = Simulation(team2, team3)
show_simu(simu)
def get_team(nb_players):
myteam = SoccerTeam(name="Started from the bottom")
if nb_players == 1:
myteam.add("Joueur", AttaqueStrategy())
if nb_players == 2:
myteam.add("Defenseur", DefenseStrategy())
myteam.add("Attaquant", AttaqueStrategy())
if nb_players == 4:
myteam.add("Joueur 1", RandomStrategy())
myteam.add("Joueur 2", RandomStrategy())
myteam.add("Joueur 3", RandomStrategy())
myteam.add("Joueur 4", RandomStrategy())
return myteam
def start(self, show=True):
if not self.simu:
team1 = SoccerTeam("Chelsea")
team2 = SoccerTeam("Arsenal")
team1.add(self.strategy.name, self.strategy)
#team2.add(Strategy().name, Strategy())
self.simu = Simulation(team1, team2, max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def getTeam(self, i):
"""
Renvoie l'equipe composee des strategies contenues
dans l'instance avec l'i-ieme vecteur de parametres,
i.e. une SoccerTeam
"""
self.team = SoccerTeam(self.name)
params = self.vectors[i].params
for i in range(len(self.playerStrats)):
if self.playerStrats[i] is None: continue
for p in self.playerParams[i]:
self.playerStrats[i].dico[p] = params[p]
self.team.add(self.playerStrats[i].name, self.playerStrats[i])
return self.team
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 start(self, show=True):
if not self.simu:
team1 = SoccerTeam("Team Passeurs")
team2 = SoccerTeam("Team Vide")
team1.add(self.strategy.name, self.strategy)
team1.add(PasseTestStrategy().name, PasseTestStrategy())
team2.add(Strategy().name, Strategy())
self.simu = Simulation(team1, team2, max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def get_team(nb_players):
team = SoccerTeam(name="Salsa team")
if nb_players == 1:
team.add("Striker", Attaquant())
if nb_players == 2:
team.add("Striker", Attaquant())
team.add("Defense", Defense())
return team
def get_team(nb_players, nb):
team = SoccerTeam(name="Alex’s Team")
if (nb_players == 1 and nb == 0):
team.add("Echauffement", SimpleStrategy(echauffement, 'One'))
if (nb_players == 1 and nb == 2):
team.add("attaquant", SimpleStrategy(echauffement, 'att'))
if (nb_players == 2 and nb == 0):
team.add("Defenseur", SimpleStrategy(defenseur, 'One'))
team.add("attaquant", SimpleStrategy(attaquant, 'One'))
if (nb_players == 2 and nb == 2):
team.add("Defenseur", SimpleStrategy(defenseur, 'One'))
team.add("attaquant", SimpleStrategy(attaquant, 'One'))
return team
class GKStrikerModifTeam(GKStrikerTeam):
def __init__(self, size=20, keep=0.5, coProb=0.7, mProb=0.01):
super(GKStrikerModifTeam, self).__init__(size=size, keep=keep, \
coProb=coProb, mProb=mProb)
def getTeam(self, i):
"""
Doc a modifier
"""
self.team = SoccerTeam(self.name)
params = self.vectors[i].params
for i in range(2):
for p in self.playerParams[i]:
self.playerStrats[0].dico[p] = params[p] # params du gk
self.playerStrats[1].dico[p] = params[p] # params du st
self.team.add(self.playerStrats[0].name, self.playerStrats[0])
self.team.add(self.playerStrats[1].name, self.playerStrats[1])
return self.team
def start(self , show=True , fps=None):
if not self.simu:
team1 = SoccerTeam("Team␣1")
team2 = SoccerTeam("Team␣2")
team1.add(self.strategy.name , self.strategy)
team2.add(StrategyAttaquant().name , StrategyAttaquant())
self.simu = Simulation(team1 , team2 , max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu , fps=fps)
else:
self.simu.start ()
def start(self, show=True):
if not self.simu:
team1 = SoccerTeam("Team Goal")
team2 = SoccerTeam("Team Shooter")
team1.add(self.strategy.name, self.strategy)
team2.add(FSF().name, FSF())
self.simu = Simulation(team1, team2, max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def start(self, show=True):
if not self.simu:
team1 = SoccerTeam("Team 1")
team2 = SoccerTeam("Team 2")
team1.add(self.strategy1.name, self.strategy1)
team2.add(self.strategy2.name, self.strategy2)
self.simu = Simulation(team1, team2, max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def start(self, show=True):
if not self.simu:
team1 = SoccerTeam("Team 1")
team2 = SoccerTeam("Team 2")
team1.add("Defenseur_2v2_opti.name", self.strategy)
team2.add("Fonceur_brain.name", Fonceur())
self.simu = Simulation(team1, team2, max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def start(self, show=True):
if not self.simu:
team1 = SoccerTeam("Team Fonceur")
team2 = SoccerTeam("Team Dribbler")
#team1.add(FonceurChallenge1Strategy().name, FonceurChallenge1Strategy())
team1.add(FonceurStrategy().name, FonceurStrategy())
team2.add(self.strategy.name, self.strategy)
self.simu = Simulation(team1, team2, max_steps=self.max_steps)
self.simu.listeners += self
if show:
show_simu(self.simu)
else:
self.simu.start()
def __init__(self,visu = False): # Visu permet la visualisation de la simu. Si on en veut pas, on met false. Cela est permis par la fonction start en bas.
team1 = SoccerTeam("expe1")
team2 = SoccerTeam("expe2")
self.strat = shoot() # On donne la strat qu'on va utiliser.
team1.add("jexp1", self.strat )
team2.add("jplot",Strategy()) # Si besoin d'un joueur de team adverse
self.simu = Simulation(team1,team2,max_steps=10000000) # On def la simu avec un enorme max_steps car on veut test x round et on veut pas devoir recommencer un match
self.visu = visu
self.simu.listeners+=self #ajout de l observer
list_a = np.linspace(0.1,20,30) # Creation de la matrice pour la parametre a. De param1 a param2 avec param2 valeurs
list_b = np.linspace(0.1,20,30)
self.list_params = [(a,b) for a in list_a for b in list_b] # Creation de tout les couples possible
self.cpt_params = 0 # Va permettre de tester toute la liste de couple de params
self.nb_expe = 20 # Nb de round que l on fera par postion
self.res = dict() # Ini de notre dico
self.pos = dict()
class STTeam(GeneTeam):
def __init__(self, size=20, keep=0.5, coProb=0.7, mProb=0.01):
super(STTeam, self).__init__(name="STTeam", \
playerStrats=[FonceurModifStrategy(), None, None, None], \
playerParams=[GKStrikerTeam.gk_params(), GKStrikerTeam.st_params(), [], []], \
size=size, keep=keep, coProb=coProb, mProb=mProb)
def stDict(self):
"""
Renvoie le sous-dictionnaire du meilleur vecteur de
parametres compose uniquement de ceux concernant
l'attaquant
Hypothese : sortVectors() doit avoir ete appele
auparavant
"""
return super(STTeam, self).playerDict(0)
def getTeam(self, i):
"""
Doc a modifier
"""
self.team = SoccerTeam(self.name)
params = self.vectors[i].params
for i in range(2):
for p in self.playerParams[i]:
self.playerStrats[0].dico[p] = params[p] # params du st
self.team.add(self.playerStrats[0].name, self.playerStrats[0])
return self.team
def save(self, fn_gk="fonceur_gk_dico.pkl", fn_st="fonceur_st_dico.pkl"):
"""
Sauvegarde le dictionnaire de parametres du gardien
et de l'attaquant dans des fichiers dans le repertoire
'parameters'
"""
return super(STTeam, self).save([fn_gk, fn_st, None, None])
def entrainer(fname):
#Creation d'une partie
kb_strat = KeyboardStrategy()
kb_strat.add("a", FonceurStrategy())
kb_strat.add("z", Milieu())
kb_strat.add("e", Gardien())
team1 = SoccerTeam(name="Contol Team")
team2 = SoccerTeam(name="Sparing")
team1.add("ControlPlayer", kb_strat)
team2.add("Player", FonceurStrategy())
simu = Simulation(team1, team2)
#Jouer, afficher et controler la partie
show_simu(simu)
print("Nombre d'exemples : " + str(len(kb_strat.states)))
# Sauvegarde des etats dans un fichier
dump_jsonz(kb_strat.states, fname)
def jouer_arbre(dt):
####
# Utilisation de l'arbre
###
dic = dict([(f.__name__, GenStrat(f)) for f in [
dribble, se_positionner_haut, se_positionner_bas, donothing,
ralentir_moyen, shoot_but, up, down, left, right
]])
treeStrat1 = DTreeStrategy(dt, dic, my_get_features)
team3 = SoccerTeam("Arbre Team")
team3.add("Joueur 1", treeStrat1)
team3.add("Joueur 2", ElDefenseur())
simu = Simulation(team2, team3)
show_simu(simu)
def entrainer(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)
def jouer_arbre(dt):
####
# Utilisation de l'arbre
###
dic = {
"Ma Strategie d'attaque": MyAttackStrategy(),
"Strategie Intelligente": IntelligentStrategy(),
"Ma Strategie de defense": MyDefenseStrategy(),
"Ma Strategie de dribble": DribblerStrategy()
}
treeStrat1 = DTreeStrategy(dt, dic, my_get_features)
treeStrat2 = DTreeStrategy(dt, dic, my_get_features)
team3 = SoccerTeam("Arbre Team")
team3.add("Giroud", treeStrat1)
team3.add("Pogba", treeStrat2)
simu = Simulation(team2, team3)
show_simu(simu)
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, decid):
BaseStrategy.__init__(self, decid.__name__)
self.decideur = decid
self.info = dict()
def compute_strategy(self, state, id_team, id_player):
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)
from soccersimulator import ChallengeFonceurButeur, SoccerTeam, show_simu
from ia.strategies import FonceurChallenge1Strategy
team = SoccerTeam("ChPerFusion")
team.add("FonceurCh1Joueur", FonceurChallenge1Strategy())
challenge = ChallengeFonceurButeur(team, max_but=20)
show_simu(challenge)
print("temps moyen : ", challenge.stats_score, "\nliste des temps",
challenge.resultats)
#-*- coding: utf-8 -*-
import pyglet
from soccersimulator import Vector2D, SoccerBattle, SoccerPlayer, SoccerTeam, SoccerStrategy, SoccerAction, GAME_WIDTH, GAME_HEIGHT
from soccersimulator import PygletObserver, ConsoleListener, LogListener, PLAYER_RADIUS, BALL_RADIUS, mdpsoccer
from classe_basique import *
from joueur_alea import *
teama = SoccerTeam("teama")
teamb = SoccerTeam("teamb")
teama.add_player(SoccerPlayer("t1j1", GoalStrategy()))
teama.add_player(SoccerPlayer("t1j2", FonceurStrategy()))
teamb.add_player(
SoccerPlayer("t2j1", ComposeStrategy(GoalStrategy(), Degager())))
teamb.add_player(SoccerPlayer("t2j2", PremSelector()))
print teama
print teamb
battle = SoccerBattle(teama, teamb)
obs = PygletObserver()
obs.set_soccer_battle(battle)
pyglet.app.run()
from monequipe import teams
from soccersimulator import Vector2D, SoccerState, SoccerAction
from soccersimulator import SoccerTournament, SoccerTeam, SoccerMatch, Player, show
from soccersimulator import BaseStrategy
from soccersimulator.settings import *
from Strategiecode1 import fonceetshoot, defenseduGoal
import math
## Creation joueur et equique (2 joueurs)
joueur1 = Player("Joueur 1", BaseStrategy("fonceetshoot"))
joueur2 = Player("Goal 1", BaseStrategy("defenseduGoal"))
print joueur1.name, joueur2.strategy, joueur2.name, joueur2.strategy
team1 = SoccerTeam("Equipe 1", [Joueur 1, Goal 1])
# nombre de joueurs de l equipe
print team1.nb_players
# renvoie la liste des noms, la liste des strategies
print team1.players_name, team1.strategies
# nom et strategie du premier joueur
print team1.player_name(0), team1.strategy(0)
joueur1 = Player("Joueur 2", BaseStrategy("fonceetshoot"))
joueur2 = Player("Goal 2", BaseStrategy("defenseduGoal"))
print joueur1.name, joueur2.strategy, joueur2.name, joueur2.strategy
team2 = SoccerTeam("Equipe 2", [Joueur 2, Goal 2])
# nombre de joueurs de l equipe
print team1.nb_players
# renvoie la liste des noms, la liste des strategies
print team1.players_name, team1.strategies
# nom et strategie du premier joueur
print team1.player_name(0), team1.strategy(0)
# -*- coding: utf-8 -*-
from soccersimulator import SoccerPlayer, SoccerTeam, InteractStrategy, TreeStrategy
from strats import RandomStrategy, FonceurStrategy
from apprentissage import *
from apprentissage import gen_feature_simple
team1=SoccerTeam("Fonceur Random")
team1.add_player(SoccerPlayer("Fonceur",FonceurStrategy()))
team1.add_player(SoccerPlayer("Random",RandomStrategy()))
team2=SoccerTeam("Random Random")
team2.add_player(SoccerPlayer("Random 1",RandomStrategy()))
team2.add_player(SoccerPlayer("Random 2",RandomStrategy()))
list_key_player1=['a','z']
list_strat_player1=[RandomStrategy(),FonceurStrategy()]
inter_strat_player1=InteractStrategy(list_key_player1,list_strat_player1,"joueur1")
team3 = SoccerTeam("Interactive")
team3.add_player(SoccerPlayer("Inter 1",inter_strat_player1))
team3.add_player(SoccerPlayer("Rand",RandomStrategy()))
team_tree = SoccerTeam("Team Tree")
treeia=TreeIA(gen_feature_simple,dict({"Random":RandomStrategy(),"Fonceur":FonceurStrategy()}))
### Apprentissage
fn=os.path.join(os.path.dirname(os.path.realpath(__file__)),"myfirsttree.pkl")
treeia.load(fn)
TreeST=TreeStrategy("tree1",treeia)
