def compute_strategy(self,state,player,teamid):
shoot = Vector2D(0,0)
d = state.ball.position - player.position
if d.norm > 25 :
if (teamAdverse(teamid)==2):
pos = Vector2D((1.2/5)*GAME_WIDTH,state.ball.position.y)-player.position
else:
pos = Vector2D((3.7/5)*GAME_WIDTH,state.ball.position.y)-player.position
else:
pos= state.ball.position-player.position
shoot= (state.get_goal_center(teamAdverse(teamid))-player.position)
if (balleProche):
shoot= (state.get_goal_center(teamAdverse(teamid))-player.position)
return SoccerAction(pos,shoot)
def compute_strategy(self,state,id_team,id_player):
if id_team==1:
position_milieu_but=Vector2D(x=150.,y=45.)
if id_team==2:
position_milieu_but=Vector2D(x=0.,y=45.)
vector_acc=state.ball.position-state.player_state(id_team,id_player).position
if (state.ball.position.distance(state.player_state(id_team,id_player).position)<BALL_RADIUS+PLAYER_RADIUS):
vector_shoot=position_milieu_but-state.ball.position
else:
vector_shoot=Vector2D()
return SoccerAction(vector_acc,vector_shoot)
def compute_strategy(self, state, id_team, id_player):
result = Vector2D(0, 0)
myself = player_position(state, id_team, id_player)
result += vector_from_field(myself, ball_position(state),
self.fields.ball_field)
result += vector_from_field(myself, goal_position(state, id_team),
self.fields.goal_field)
for ally in players_exclude(state, id_team ^ 1, id_player):
result += vector_from_field(myself, ally.position,
self.fields.ally_field)
for enemy in players_exclude(state, id_team, -1):
result += vector_from_field(myself, enemy.position,
self.fields.enemy_field)
return SoccerAction(result)
def attaque_new(state, id_t,id_p) : e=Etat(state) posb=e.posballe() if e.est_centre(): return foncer_centre(e,id_t,id_p,10) elif e.balle_def(id_t%2+1,0.6) : if not(e.can_shoot()) : return fonceur_defaut(e,id_t,id_p,4) else : if e.dist(e.posballe(),e.poscage(id_t%2+1))>=40 : return dribble2(state,id_t,id_p) else : return tir_goal(e,id_t,id_p,8) else : vect = dirpos(e,id_t,id_p,1,e.pospasse(id_t, id_jd, 25)) return SoccerAction(vect)
def compute_strategy(self,state,player,teamid):
acceleration = Vector2D(0,0)
dist = distAdv(state, teamid, player)
adv = joueurAdverseProche(state, teamid, player)
moi = player.position
if (balleProche):
if (adv!=None):
if (adv.y<moi.y):
shoot= Vector2D.create_polar((dist.angle)+0.75, state.get_goal_center(teamAdverse(teamid)).norm)
else:
shoot= Vector2D.create_polar((dist.angle)-0.75, state.get_goal_center(teamAdverse(teamid)).norm)
else:
shoot = state.get_goal_center(teamAdverse(teamid)) - player.position
else:
shoot = Vector2D(0,0)
return SoccerAction(acceleration, shoot)
def compute_strategy(self, state, player, teamid):
b = state.ball.position
p = player.position
g = state.get_goal_center(teamid)
dist_gp = g - p
#dist_pp= p - state.team.player.position
shoot = state.get_goal_center(self.get(teamid)) - p
if (state.is_y_inside_goal(p.y)):
if (b - p < 10):
shoot = b + g - p
if (p.distance(b) < PLAYER_RADIUS + BALL_RADIUS):
shoot = state.get_goal_center(self.get(teamid)) - p
#if (dist_pp < 5):
#shoot = dist_pp - p
else:
shoot = state.get_goal_center(self.get(teamid)) - p
return SoccerAction(dist_gp, shoot)
def compute_strategy(self, state, id_team, id_player):
# id_team is 1 or 2
# id_player starts at 0
acceleration = state.ball.position - state.player_state(
id_team, id_player).position
shoot = Vector2D(BALL_RADIUS, BALL_RADIUS)
d = acceleration.norm
if (d < PLAYER_RADIUS + BALL_RADIUS):
shoot = ((GAME_WIDTH, GAME_HEIGHT / 2.) -
Vector2D(3.14 / 2, maxBallAcceleration)) * v
#shoot.angle+=3.14/2
#shoot.angle = 0
#shoot = Vector2D.angle
Action = SoccerAction(acceleration, shoot)
return Action
def compute_strategy(self, state, id_team, id_player):
# id_team is 1 or 2
# id_player starts at 0
d = PLAYER_RADIUS + BALL_RADIUS
mvt = state.ball.position - state.player_state(id_team,id_player).position
if id_team == 1:
tir = Vector2D(GAME_WIDTH,GAME_HEIGHT/2) - state.ball.position
else :
tir = Vector2D(0,GAME_HEIGHT/2) - state.ball.position
return SoccerAction(mvt,tir)
def compute_strategy(self, state, player, teamid):
adv = need.obstacle(state, teamid, player)
me = player.position
advD = need.obstacleD(state, teamid, player, adv)
move = state.ball.position - player.position
a = state.get_goal_center(need.teamAdverse(teamid)) - player.position
shoot = Vector2D(0, 0)
if adv:
if adv.y < me.y:
shoot = Vector2D.create_polar(a.angle + 0.45, 1)
else:
shoot = Vector2D.create_polar(a.angle - 0.5, 1)
if advD == True:
shoot = (state.get_goal_center(need.teamAdverse(teamid)) -
player.position)
return SoccerAction(move, shoot)
def compute_strategy(self, state, player, teamid):
shoot = Vector2D(0, 0)
d = state.ball.position - player.position # diff entre ball et joueur
if d.norm > 25:
if (teamAdverse(teamid) == 2):
pos = Vector2D((1.3 / 5) * GAME_WIDTH,
state.ball.position.y) - player.position
else:
pos = Vector2D((3.7 / 5) * GAME_WIDTH,
state.ball.position.y) - player.position
else:
pos = state.ball.position - player.position
shoot = (state.get_goal_center(teamAdverse(teamid)) -
player.position)
if (PLAYER_RADIUS + BALL_RADIUS) >= (state.ball.position.distance(
player.position)):
return self.vasy.compute_strategy(state, player, teamid)
return SoccerAction(pos, shoot)
def compute_strategy(self, state, id_team, id_player):
ball = state.ball.position
sup = SupState(state, id_team, id_player)
if self.i == 0:
if sup.dist_my_but() < settings.GAME_WIDTH // 6 and sup.can_shoot(
):
return SoccerAction(shoot=Vector2D(500 * sup.sens, 0))
if sup.my_position.y > 3 * settings.GAME_HEIGHT / 4 or sup.my_position.y < settings.GAME_HEIGHT / 4: #JE SUIS DANS LES DEUX QUARTS
if sup.can_shoot(): #je peux tirer vu que proche de la balle
if (sup.dist_but_adv() <
settings.GAME_WIDTH / 5): #autorisation pour tirer
return sup.shoot_goal() #tirer vers les bois
if (sup.my_position.x < settings.GAME_WIDTH / 5
and sup.sens == -1) or (
4 * settings.GAME_WIDTH / 5 < sup.my_position.x
and sup.sens == 1):
return sup.shoot_goal()
elif sup.adv_closer_dist(
) < 2 * sup.dist_my_wall() and sup.can_shoot_lonely():
shoot = Shoot2(sup).to_goal2()
self.i = int(sup.dist_my_wall())
return shoot + SoccerAction(acceleration=Vector2D(
sup.dist_my_wall() * sup.sens,
0)) #faire un rebond
else:
return sup.shoot_goal()
else:
return SoccerAction(
acceleration=(ball - sup.my_position) * 300
) #je peux pas tirer trop loin de la balle donc je vais vers la balle
else:
if sup.can_shoot(): #si je suis dans les deux quarts du milieu
if (sup.dist_but_adv() < settings.GAME_WIDTH /
6): #j'ai l'autorisation pour tirer
return sup.shoot_goal() #je tire
else:
return sup.shoot_goal() #je drible ac la balle
else:
return SoccerAction(
acceleration=(ball - sup.my_position) * 300
) #je vais vers la balle vu que j'ai pas d'autorisation pour tirer
elif self.i > 0: #a utiliser pour aller tout droit dans le cas du rebon
self.i -= 1
qte = (2 * math.sqrt(2 * ((sup.dist_my_wall())**2)))
qte2 = math.sqrt(qte)
return SoccerAction(acceleration=Vector2D(
sup.sens * qte2, 0)) #aller tout droit aprés le rebond
else:
self.i += 1
return SoccerAction(acceleration=Vector2D(
0, 0)) #on reste immobile au début
def compute_strategy(self,state,id_team,id_player):
d=state.ball.position-state.player(id_team,id_player).position
#print state.ball.position-state.player(2,0).position
if d.norm>5 and state.ball.vitesse._x<0.001:
d+=Vector2D(-50,20)
elif state.ball.vitesse._x!=0 or state.ball.vitesse._y!=0 :
v=state.ball.vitesse.norm
p=0
while(v>=0.00001):
p+=v
v-=v*0.06-(v**2)*0.01
#print v
v=state.ball.vitesse.norm
vb=state.ball.vitesse
vb.scale(p/v)
d+=vb
elif d.norm<1:
d.scale(0.09)
return SoccerAction(d,
Vector2D(0,45)-state.ball.position)
def QuickFollow(mystate):
d = mystate.state.ball.position - mystate.state.player(
mystate.id_team, mystate.id_player).position
#print state.ball.position-state.player(2,0).position
if d.norm > 5 and mystate.state.ball.vitesse._x < 0.001:
d += Vector2D(-50, 20)
elif mystate.state.ball.vitesse._x != 0 or mystate.state.ball.vitesse._y != 0:
v = mystate.state.ball.vitesse.norm
p = 0
while (v >= 0.00001):
p += v
v -= v * 0.06 - (v**2) * 0.01
#print v
v = mystate.state.ball.vitesse.norm
vb = mystate.state.ball.vitesse
vb.scale(p / v)
d += vb
elif d.norm < 1:
d.scale(0.09)
return SoccerAction(d, Vector2D(0, 45) - mystate.state.ball.position)
def compute_strategy(self, state, player, teamid):
shoot = Vector2D(0, 0)
d = state.ball.position - player.position # diff entre ball et joueur
if need.jai_la_balle(state, player) == False:
if (teamAdverse(teamid) == 2):
pos = Vector2D((0.2 / 5) * GAME_WIDTH,
state.ball.position.y) - player.position
else:
pos = Vector2D((4.8 / 5) * GAME_WIDTH,
state.ball.position.y) - player.position
else:
pos = state.ball.position - player.position
shoot = (state.get_goal_center(teamAdverse(teamid)) -
player.position)
if need.jai_la_balle(state, player):
shoot = (state.get_goal_center(teamAdverse(teamid)) -
player.position)
return SoccerAction(pos, shoot)
def compute_strategy(self, state, id_team, id_player):
# id_team is 1 or 2
# id_player starts at 0
s = SuperState(state, id_team, id_player)
# print(s.state.strategies)
# print(s.state.strategies)
action1 = SoccerAction(acceleration=(s.court_vers_balle_anticipation))
action2 = SoccerAction(shoot=s.shoot_vers_cages)
# action3=SoccerAction(shoot=s.position_coequipier_lePlusProche-s.player)#shoot vers coequipier le + proche
# print(s.state.strategies.keys())
#print(s.state.strategies[(s.id_team,s.id_player)])
#si la balle est au 1/3 du terrain proche des cages, zone pour laquelle le defenseur doit reagir
if ((s.ball.x < s.get_limite and s.id_team == 1)
or (s.ball.x > s.get_limite and s.id_team == 2)):
if ((s.dist_coequipier_lePlusProche < s.op_lePlusProche
and s.ball.distance(s.player) < s.ball.distance(
s.position_opposant_lePlusProche))
and s.state.strategies[(s.coequipier_lePlusProche[0] - 1,
s.coequipier_lePlusProche[1])] !=
"defenseur1"):
# defenseur + proche de son coequipier que l'opposant ET la balle + proche du defenseur que l'opposant
#if(s.id_player!=2) #if le coequipier est un defenseur1 on fait pas de passes
# print(s.coequipier_lePlusProche)
return action1 + SoccerAction(
shoot=s.position_coequipier_lePlusProche - s.player
) # defenseur court vers la balle et ensuite shout vers le coequipier + proche
elif (
(s.coequipier_seul != -10 and
s.state.strategies[(s.coequipier_seul[0] - 1,
s.coequipier_seul[1])] != "defenseur1")
and s.position_coequipier_seul.distance(s.player) < 50
): # s.state.strategie: dico qui contient toutes les strategies
return action1 + SoccerAction(
shoot=s.position_coequipier_seul - s.player)
else:
return action1 + action2 # sinon il court et et shoot vers la cage de l'autre côté du terrain
# sinon le defenseur revient a sa position dans la cage
else:
return SoccerAction(
acceleration=s.pos_defenseur - s.player
) #s.pos: la position ou doit se placer le player != de s.player qui est la position ou il est deja
return SoccerAction()
def compute_strategy(self,state,player,teamid):
pos = Vector2D(0,0)
teamadv = teamAdverse(teamid)
adv = joueurAdverseProche(state, teamid, player)
print adv
moi = player.position
goalhaut= state.get_goal_center(teamAdverse(teamid))+Vector2D(0,((GAME_GOAL_HEIGHT/2)*(3.8/5)))
goalbas= state.get_goal_center(teamAdverse(teamid))-Vector2D(0, ((GAME_GOAL_HEIGHT/2)*(3.8/5)))
danscages = estDansCages(state, player, teamid)
if (balleProche(state, player)):
if (danscages) and (adv!=None):
if (adv.y<=state.get_goal_center(teamadv).y):
shoot = goalhaut - moi
else:
shoot = goalbas - moi
else :
shoot = state.get_goal_center(teamadv)- moi
else:
shoot = Vector2D(0,0)
return SoccerAction(pos, shoot)
def compute_strategy(self, state, id_team, id_player):
t = Tools(state, id_team, id_player)
c = Comportement(state, id_team, id_player)
if state.get_score_team(1) + state.get_score_team(2) > self.cpt2:
self.cpt2 = state.get_score_team(1) + state.get_score_team(2)
self.cpt = 0
if self.cpt > 100:
if t.test_shoot():
if not t.all_ennemi_behind():
if t.ennemi_in_my_small_perimeter():
if not t.ennemi_in_my_closest_friend_small_perimeter():
if t.player().distance(t.closest_friend()) < 50.:
return c.passe(3.)
return c.dribble(5.)
return c.dribble(1.5)
if t.ball_in_his_goal_perimeter():
return c.shoot()
return c.shoot3(2.)
else:
return c.run_anticipe()
else:
self.cpt += 1
if t.ball_in_my_half():
if t.test_shoot():
if not t.all_ennemi_behind():
if t.ennemi_in_my_small_perimeter():
if not t.ennemi_in_my_closest_friend_small_perimeter(
):
if t.player().distance(
t.closest_friend()) < 50.:
return c.passe(3.)
return c.dribble(5.)
return c.dribble(1.5)
if t.ball_in_his_goal_perimeter():
return c.shoot()
return c.petit_shoot2(2.)
else:
return c.run_anticipe()
else:
return SoccerAction(Vector2D(0, 0), Vector2D(0, 0))
def compute_strategy(self, state, player, teamid):
dis = (state.ball.position - player.position)
p = player.position
if (state.ball.position.y < (GAME_HEIGHT * 0.5)):
shoot = Vector2D(10, 10)
else:
shoot = Vector2D(10, -10)
if (teamid == 1):
a = (state.ball.position + state.ball.speed +
state.get_goal_center(1))
a.x = a.x / 2.0
else:
shoot.x = -10
a = (state.ball.position + state.ball.speed +
state.get_goal_center(2))
a.x = a.x / 2.0
a.y = a.y / 2 + 0.48 * (state.ball.position.y + state.ball.speed.y -
45)
a = a - p
if ((PLAYER_RADIUS + BALL_RADIUS) > ((dis + state.ball.speed).norm)):
a = Vector2D(0, 0)
return SoccerAction(a, shoot)
def compute_strategy(self, state, id_team, id_player):
mystate = MyState(state, id_team, id_player)
act = Action(state, id_team, id_player)
pos = Position(state, id_team, id_player)
angle = versOu(state, id_team, id_player)
#distance avec la balle
distance = mystate.distance_ball_player
#distance entre la balle et le but
distance_but = mystate.distance_but_ball
V = angle.vers_les_but_adv
if distance > 20:
if (mystate.adv() == 2):
position = V + Vector2D(
(0.5 / 5) * GAME_WIDTH,
state.ball.position.y) - mystate.my_position
else:
position = V + Vector2D(
(3.5 / 5) * GAME_WIDTH,
state.ball.position.y) - mystate.my_position
else:
position = state.ball.position - mystate.my_position
return SoccerAction(position, V - mystate.my_position)
def gobetteratt1 (state):
if state.teamatt[0] :
if state.player.y < GAME_HEIGHT/2 :
if state.player.distance(state.ball)<PLAYER_RADIUS + BALL_RADIUS :
return SoccerAction(shoot=Vector2D(state.teamatt[1], 0)-state.player)
else :
return SoccerAction (acceleration=state.ballameliorer-state.player)
else :
if state.player.distance(state.ball)<PLAYER_RADIUS + BALL_RADIUS :
return SoccerAction(shoot=Vector2D(state.teamatt[1], GAME_HEIGHT)-state.player)
else :
return SoccerAction (acceleration=state.ballameliorer-state.player)
else :
if state.player.distance(state.ball)<PLAYER_RADIUS + BALL_RADIUS :
return SoccerAction(shoot=state.goal-state.player)
else :
return SoccerAction (acceleration=state.ballameliorer-state.player)
def player_team1(self):
"""Joueur de la team1"""
if (self.position_ball.x == MEDIUM_WIDTH) and (self.position_ball.y == MEDIUM_HEIGHT):
if self.distance_player_ball < self.rayon_player_ball:
return SoccerAction(Vector2D(), (Vector2D(x = THREE_QUARTER_WIDTH, y = MEDIUM_HEIGHT + 4)))
return self.fonce_ball
elif (self.position_ball.x > MEDIUM_WIDTH) and (self.position_ball.x < THREE_QUARTER_WIDTH):
if self.distance_player_ball < self.rayon_player_ball:
return self.run_ball_avant_normalize
return self.fonce_ball
elif (self.position_ball.x < MEDIUM_WIDTH) and (self.position_ball.x > QUARTER_WIDTH):
if (self.position_ball.y > MEDIUM_HEIGHT):
return self.passe_g
elif (self.position_ball.y < MEDIUM_HEIGHT):
return self.passe_d
return self.shoot_ball_smart
elif (self.position_ball.x < QUARTER_WIDTH):
if (self.position_ball.y > MEDIUM_HEIGHT):
return self.defense_shoot_d
elif (self.position_ball.y < MEDIUM_HEIGHT):
return self.defense_shoot_g
return self.shoot_ball
return self.shoot_ball
def compute_strategy(self,state,player,teamid):
shoot = Vector2D(0,0)
d = state.get_goal_center(teamid) - state.ball.position
if (dansSurface(state, teamid)==False):
acceleration = state.get_goal_center(teamid) - player.position
if (d.norm)<(GAME_WIDTH*0.3):
acceleration = state.ball.position-player.position
else:
acceleration = state.get_goal_center(teamid) - player.position
if (d.norm)<(GAME_WIDTH*0.3):
acceleration = state.ball.position-player.position
if balleProche(state, player):
p = state.get_goal_center(teamAdverse(teamid)) - state.ball.position
shoot = Vector2D.create_polar((p.angle)+3.14/8, p.norm)
acceleration = Vector2D(0,0)
return SoccerAction(acceleration,shoot)
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 compute_strategy(self, state, id_team, id_player):
# id_team is 1 or 2
# id_player starts at 0
action = SoccerAction()
action_1 = SoccerAction()
s = SuperState(state, id_team, id_player)
if (s.player.distance(s.ball) >
settings.PLAYER_RADIUS + settings.BALL_RADIUS):
action_1 = SoccerAction(acceleration=s.ball - s.player)
elif (s.ball.x > 4 * settings.GAME_WIDTH / 5 and s.id_team == 1):
action = SoccerAction(shoot=s.shoot_doucement_vers_cages)
#shoot moins fort
elif (s.ball.x < settings.GAME_WIDTH / 5 and s.id_team == 2):
action = SoccerAction(shoot=s.shoot_doucement_vers_cages)
else:
action = SoccerAction(shoot=s.shoot_vers_cages)
return action_1 + action
def compute_strategy(self, state, id_team, id_player):
# id_team is 1 or 2
# id_player starts at 0
s = SuperState(state, id_team, id_player)
action1 = SoccerAction()
action2 = SoccerAction()
action3 = SoccerAction()
if (s.player.distance(s.ball) > settings.PLAYER_RADIUS +
settings.BALL_RADIUS): #court car ne peut pas shouter
if (s.position_coequipier_lePlusProche.distance(s.ball) <=
s.dist_pb): # coequip + proche de la balle que le joueur
action2 = SoccerAction(
acceleration=((s.ball - s.player).normalize()) *
0.09) # court moins vite vers la balle
else: # joueur + proche de la balle que le joueurdistance
action3 = SoccerAction(
acceleration=((s.ball - s.player).normalize()) *
1) # court vite
elif (s.fait_la_passe != Vector2D(0, 0)): #
action1 = SoccerAction(shoot=(s.fait_la_passe2))
return action1 + action2 + action3
def compute_strategy(self, state, id_team, id_player):
# id_team is 1 or 2
# id_player starts at 0
action = SoccerAction()
action_1 = SoccerAction()
#strat = Attaquant_Strategy()# on ne fait pas de passe si on est proche des cages
#return strat.compute_strategy(state, id_team, id_player)
s = SuperState(state, id_team, id_player)
if (s.player.distance(s.ball) >
settings.PLAYER_RADIUS + settings.BALL_RADIUS):
action_1 = SoccerAction(acceleration=s.ball -
s.player) #loin de la balle que courrir
elif (s.ball.x > 4 * settings.GAME_WIDTH / 5 and s.id_team
== 1): #shoot doucement quand pres des cages de l'adversaire
action = SoccerAction(shoot=s.shoot_doucement_vers_cages)
#shoot moins fort
elif (s.ball.x < settings.GAME_WIDTH / 5 and s.id_team == 2):
action = SoccerAction(shoot=s.shoot_doucement_vers_cages)
else:
action = SoccerAction(shoot=s.shoot_vers_cages)
return action_1 + action
def run_anticipe(self):
t = Tools(self.state, self.id_team, self.id_player)
"""if t.ball_in_my_perimeter():
return SoccerAction(((0.6*self.state.ball.vitesse+t.ball())-t.player()).normalize()*0.2, Vector2D(0,0))"""
return SoccerAction(((5 * self.state.ball.vitesse + t.ball()) -
t.player()).normalize() * 0.2, Vector2D(0, 0))
def follow_ball_down(self):
t = Tools(self.state, self.id_team, self.id_player)
return SoccerAction(t.down_ball_x(), Vector2D(0, 0))
def return_attaquant_defense(self):
t = Tools(self.state, self.id_team, self.id_player)
return SoccerAction(t.attaquant_my_defense(), Vector2D(0, 0))
def return_defense_milieu(self):
t = Tools(self.state, self.id_team, self.id_player)
return SoccerAction(t.player_my_defense_milieu(), Vector2D(0, 0))
