def gardien2(self):
s = SuperState(self.state, self.id_team, self.id_player)
a = Actions(self.state, self.id_team, self.id_player)
id_team = self.id_team
state = self.state
id_player = self.id_player
if id_team == 1:
if s.ball.x >= GAME_WIDTH / 2:
if s.player.distance(s.ball) < PLAYER_RADIUS + BALL_RADIUS:
shoot = (s.goaladverse - s.player)
#return SoccerAction(shoot = shoot.normalize()*1500)
return a.shootbut
elif s.player.distance(
s.ball
) < PLAYER_RADIUS * 3: #Ne se déplace que si la balle est proche de lui
return a.deplacement(s.ball)
else:
return a.deplacement(s.goalequipe)
elif s.ball.x < GAME_WIDTH / 2:
if s.player.distance(s.ball) < PLAYER_RADIUS + BALL_RADIUS:
shoot = (s.goaladverse - s.player)
#return SoccerAction(shoot = shoot.normalize()*1500)
else:
deplacement = state.ball.position - state.player_state(
id_team, id_player).position
tir = Vector2D(150, 45) - state.ball.position
return SoccerAction(deplacement, tir)
else:
if s.ball.x <= GAME_WIDTH / 2:
if s.player.distance(s.ball) < PLAYER_RADIUS + BALL_RADIUS:
shoot = (s.goaladverse - s.player)
return SoccerAction(shoot=shoot.normalize() * 1500)
elif s.player.distance(
s.ball
) < PLAYER_RADIUS * 3: #Ne se déplace que si la balle est proche de lui
return SoccerAction(acceleration=s.deplacement(s.ball))
else:
return a.deplacement(s.goalequipe)
elif s.ball.x > GAME_WIDTH / 2:
deplacement = state.ball.position - state.player_state(
id_team, id_player).position
tir = Vector2D(0, 45) - state.ball.position
return SoccerAction(deplacement, tir)
def compute_strategy(self, state, id_team, id_player):
s = Strategies(state, id_team, id_player)
v = SuperState(state, id_team, id_player)
a = Actions(state, id_team, id_player)
if v.player.distance(v.ball) < PLAYER_RADIUS + BALL_RADIUS:
if id_team == 1:
tir = (Vector2D(GAME_WIDTH * 3 / 8,
GAME_HEIGHT / 2)) - v.player
return SoccerAction(shoot=tir.normalize() * 3)
else:
tir = (Vector2D(GAME_WIDTH * 5 / 8,
GAME_HEIGHT / 2)) - v.player
return SoccerAction(shoot=tir.normalize() * 3)
else:
if v.ballecampadverse == 0:
if id_team == 1:
return a.deplacement(
Vector2D((GAME_WIDTH / 2) - 5, v.ball.y))
else:
return a.deplacement(
Vector2D((GAME_WIDTH / 2) + 5, v.ball.y))
elif v.player.distance(v.ball) < PLAYER_RADIUS * 10:
return a.deplacement(v.ball)
def attaque1(self):
s = SuperState(self.state, self.id_team, self.id_player)
a = Actions(self.state, self.id_team, self.id_player)
if s.poscoequippier.distance(
s.ball
) < PLAYER_RADIUS + BALL_RADIUS: #SI le coequippier a la balle
return a.deplacement(s.pointcampeurgauche)
elif s.player.distance(s.ball) < PLAYER_RADIUS + BALL_RADIUS:
if s.player.distance(s.poscoequippier) < PLAYER_RADIUS * 25:
if s.coepdevant == 1:
return a.tircoequippier
elif s.player.distance(s.goaladverse) < (
PLAYER_RADIUS *
15): #Si il est dans la surface de tir : shoot
return a.shootbut
elif s.playeradverse.distance(s.player) < (PLAYER_RADIUS * 8):
return a.dr2
else:
return a.avanceravecballe
else:
return a.deplacement(s.ball)
def attaquedroit(self): #essai
s = SuperState(self.state, self.id_team, self.id_player)
a = Actions(self.state, self.id_team, self.id_player)
if s.poscoequippier.distance(
a.directionball
) < PLAYER_RADIUS + BALL_RADIUS: #SI le coequippier a la balle
return a.deplacement(s.pointcampeurdroit)
elif s.player.distance(s.ball) < PLAYER_RADIUS + BALL_RADIUS:
if s.opposantsplusproche[1].distance(
s.player) < PLAYER_RADIUS * 10:
#if s.player.distance(s.poscoequippier) < PLAYER_RADIUS*25 :
if s.coepdevant == 1:
print("DDDDD")
return a.tircoequippier + a.deplacement(
s.pointattaquantdroit)
elif s.playeradverse.distance(s.player) < (PLAYER_RADIUS * 15):
return a.tircoequippier
elif s.player.distance(s.goaladverse) < (
PLAYER_RADIUS *
20): #Si il est dans la surface de tir : shoot
return a.shootbut
else:
return a.avanceravecballe
else:
return a.deplacement(a.directionball)
def avancertoutdroit(self):
s = SuperState(self.state, self.id_team, self.id_player)
if self.id_team == 1 :
shoot = Vector2D(GAME_WIDTH, s.player.y) - s.player
else :
shoot = Vector2D(0, s.player.y) - s.player
return SoccerAction(shoot = shoot.normalize()*1)
def compute_strategy(self, state, id_team, id_player):
s = Strategies(state, id_team, id_player)
v = SuperState(state, id_team, id_player)
a = Actions(state, id_team, id_player)
if v.player.distance(v.ball) < PLAYER_RADIUS + BALL_RADIUS:
shoot = v.playeradverse - v.player
return SoccerAction(shoot=shoot.normalize() * 3)
else:
return a.deplacement(v.ball)
def defensesolo2(self):
s = SuperState(self.state, self.id_team, self.id_player)
a = Actions(self.state, self.id_team, self.id_player)
if self.id_team == 1:
if s.position(s.ball) == 1 or s.position(
s.ball) == 2 or s.position(s.ball) == 7 or s.position(
s.ball) == 8:
return a.deplacement(s.ball) + a.shootbut
else:
return a.deplacement(s.pointdefensesolo)
if self.id_team == 2:
if s.position(s.ball) == 5 or s.position(
s.ball) == 6 or s.position(s.ball) == 11 or s.position(
s.ball) == 12:
return a.deplacement(s.ball) + a.shootbut
else:
return a.deplacement(s.pointdefensesolo)
def milieu(self):
s = SuperState(self.state, self.id_team, self.id_player)
a = Actions(self.state, self.id_team, self.id_player)
if s.player.distance(s.ball) < PLAYER_RADIUS * 10:
return a.deplacement(s.ball)
elif s.player.distance(s.ball) < PLAYER_RADIUS + BALL_RADIUS:
return a.shoot(s.pointattaquantgauche)
else:
return a.deplacementlateralmilieu
def fonceur(self):
s = SuperState(self.state, self.id_team, self.id_player)
a = Actions(self.state, self.id_team, self.id_player)
# id_team is 1 or 2
# id_player starts at 0
#SI C'EST DANS SON CAMP : FONCEUR. SINON : POSDÉFENSEDUO
if s.player.distance(s.ball) < PLAYER_RADIUS + BALL_RADIUS:
return a.tircoequippier
else:
return a.deplacement(s.ball)
def gardien(self):
s = SuperState(self.state, self.id_team, self.id_player)
a = Actions(self.state, self.id_team, self.id_player)
if s.player.distance(s.ball) < PLAYER_RADIUS + BALL_RADIUS:
return a.shootdefenseduo
elif s.player.distance(s.ball) < PLAYER_RADIUS * 10:
return a.deplacement(a.directionball)
else:
return a.deplacementlateral
def compute_strategy(self, state, id_team, id_player):
s = Strategies(state, id_team, id_player)
v = SuperState(state, id_team, id_player)
a = Actions(state, id_team, id_player)
if v.player.distance(v.ball) < PLAYER_RADIUS + BALL_RADIUS:
return a.tircoequippier
else :
if v.ballecampadverse == 0:
if id_team == 1 :
return a.deplacement(Vector2D((GAME_WIDTH/2)-5, v.ball.y))
else :
return a.deplacement(Vector2D((GAME_WIDTH/2)+5, v.ball.y))
else :
return a.deplacement(v.ball)
def attaque2(self):
s = SuperState(self.state, self.id_team, self.id_player)
a = Actions(self.state, self.id_team, self.id_player)
if s.player.distance(s.ball) < PLAYER_RADIUS * 10:
return a.deplacement(a.directionball)
elif s.player.distance(s.ball) < PLAYER_RADIUS + BALL_RADIUS:
if s.player.distance(s.goaladverse) < (PLAYER_RADIUS * 15):
return a.shootbut
elif s.coepdevant == 1:
return a.tircoequippier
else:
return a.avanceravecballe
else:
return a.deplacement(s.pointattaquant2)
def attaquesolo(self, force, distance, forcedr, angledr, distadverse):
s = SuperState(self.state, self.id_team, self.id_player)
a = Actions(self.state, self.id_team, self.id_player)
if s.player.distance(s.ball) < PLAYER_RADIUS + BALL_RADIUS:
if s.opposantsplusproche[1].distance(
s.player) < (PLAYER_RADIUS * distadverse):
return a.dr2(forcedr, angledr)
elif s.player.distance(s.goaladverse) < (
PLAYER_RADIUS * distance
): #Si il est dans la surface de tir : shoot, sinon avance
print("Surface de tir")
return a.shootbut(force)
else:
return a.avanceravecballe
else:
return a.deplacement(a.directionball)
def compute_strategy(self, state, id_team, id_player):
s = Strategies(state, id_team, id_player)
v = SuperState(state, id_team, id_player)
a = Actions(state, id_team, id_player)
if v.player.distance(v.ball) < PLAYER_RADIUS + BALL_RADIUS:
if id_team == 1:
if v.player.x < GAME_WIDTH * 2 / 8:
shoot = Vector2D(GAME_WIDTH * 4 / 8, GAME_HEIGHT / 2)
return SoccerAction(shoot=shoot.normalize() * 3)
else:
if v.playeradverse.y < GAME_HEIGHT / 2:
shoot = Vector2D(GAME_WIDTH * 7.5 / 8,
GAME_HEIGHT * 3.5 / 4) - v.player
return SoccerAction(shoot=shoot.normalize() * 100)
else:
shoot = Vector2D(GAME_WIDTH * 7.5 / 8,
GAME_HEIGHT * 0.5 / 4) - v.player
return SoccerAction(shoot=shoot.normalize() * 100)
else:
if v.player.x > GAME_WIDTH * 6 / 8:
shoot = Vector2D(GAME_WIDTH * 4 / 8, GAME_HEIGHT / 2)
return SoccerAction(shoot=shoot.normalize() * 3)
else:
if v.playeradverse.y > GAME_HEIGHT / 2:
shoot = Vector2D(GAME_WIDTH * 0.5 / 8,
GAME_HEIGHT * 0.5 / 4) - v.player
return SoccerAction(shoot=shoot.normalize() * 100)
else:
shoot = Vector2D(GAME_WIDTH * 0.5 / 8,
GAME_HEIGHT * 3.5 / 4) - v.player
return SoccerAction(shoot=shoot.normalize() * 100)
else:
if v.ballecampadverse == 0:
if id_team == 1:
return a.deplacement(
Vector2D(GAME_WIDTH * 2 / 8, GAME_HEIGHT / 2))
else:
return a.deplacement(
Vector2D(GAME_WIDTH * 6 / 8, GAME_HEIGHT / 2))
else:
return a.deplacement(v.ball)
def dr2(self, forcedr, angledr) :
s = SuperState(self.state, self.id_team, self.id_player)
if s.estderriere == 0 : #ssi l'&dversaire est derrière on dribble
if s.opposantsplusproche[1].y > s.player.y or s.opposantsplusproche[1].y == s.player.y : #Si le joueur vient par la droite
dir = (s.goaladverse - s.player).normalize() * forcedr
dir.angle -= angledr #3.14/6
return SoccerAction(shoot = dir)
#return SoccerAction(shoot = Vector2D(s.goaladverse.x - s.player.x, s.opposantsplusproche[1].y-15 - s.player.y).normalize()*1.1) #+ self.avanceravecballe #On avance par la gauche
else :
dir = (s.goaladverse - s.player).normalize() * forcedr
dir.angle += angledr #3.14/6
return SoccerAction(shoot = dir)
#return SoccerAction(shoot = Vector2D(s.goaladverse.x - s.player.x, s.opposantsplusproche[1].y+15 - s.player.y).normalize()*1.1) #+ self.avanceravecballe #On avance par la gauche
else :
return self.avanceravecballe
def tircampeur(self):
s = SuperState(self.state, self.id_team, self.id_player)
tir = s.pointcampeur - s.player
return SoccerAction(shoot = tir.normalize()*25 )
def deplacementlateralmilieu(self):
s = SuperState(self.state, self.id_team, self.id_player)
return SoccerAction(acceleration = Vector2D(s.pointmilieu.x - s.player.x, s.ball.y - s.player.y))
def directionball(self) :
s = SuperState(self.state, self.id_team, self.id_player)
#return Vector2D(s.ball + self.state.ball.vitesse*1.5*s.player.distance(s.ball))
return s.ball + self.state.ball.vitesse*2
def defenseduo(self):
s = SuperState(self.state, self.id_team, self.id_player)
return SoccerAction(acceleration=s.pointdefenseduo - s.player)
def avanceravecballe(self):
s = SuperState(self.state, self.id_team, self.id_player)
shoot = s.goaladverse - s.player
return SoccerAction(shoot = shoot.normalize()*1)
def shootbut(self, force = 5) :
s = SuperState(self.state, self.id_team, self.id_player)
shoot = s.goaladverse - s.player
print(force)
return SoccerAction(shoot = shoot.normalize()*force)
def shoot(self, obj) :
s = SuperState(self.state, self.id_team, self.id_player)
shoot = obj - s.player
return SoccerAction(shoot = shoot.normalize()*10)
def dribble(self) :
s = SuperState(self.state, self.id_team, self.id_player)
if s.playeradverse.y > s.player.y : #Si le joueur vient par la droite
return SoccerAction(shoot = Vector2D(s.goaladverse.x, 0).normalize()*0.5) #On avance par la gauche
else :
return SoccerAction(shoot = Vector2D(s.goaladverse.x, 0).normalize()*0.5)#On avance par la droite
def shootdefenseduo(self) :
s = SuperState(self.state, self.id_team, self.id_player)
shoot = s.pointdefenseduo - s.player
return SoccerAction(shoot = shoot.normalize()*155)
def campgauche(self):
s = SuperState(self.state, self.id_team, self.id_player)
a = Actions(self.state, self.id_team, self.id_player)
return a.deplacement(s.pointattaquantgauche)
def allerdefensesolo(self) :
s = SuperState(self.state, self.id_team, self.id_player)
return self.deplacement(s.pointdefensesolo)
def allergoalequipe(self):
s = SuperState(self.state, self.id_team, self.id_player)
dep = s.goalequipe - s.player
de = dep.normalize()* 1500
return SoccerAction(acceleration = de)
def defensesolo(self):
s = SuperState(self.state, self.id_team, self.id_player)
a = Actions(self.state, self.id_team, self.id_player)
return a.deplacement(s.pointdefensesolo)
def deplacement(self, obj):
s = SuperState(self.state, self.id_team, self.id_player)
dep = obj - s.player
de = dep.normalize()* 1500
return SoccerAction(acceleration = de)
def allerpositiongardien(self):
s = SuperState(self.state, self.id_team, self.id_player)
dep = s.pointdefensesolo - s.player
de = dep.normalize()* 150
return SoccerAction(acceleration = de)
