def fonceur(m):
v=m.b_v.norm
#vitesse ball norme
p_fin=0
#condition initiale position en norme
b=m.state.ball
n=0
if (m.goal-m.b_p).norm<30:
s=m.goal-m.b_p
else:
s=m.goal-m.b_p
s.scale(1.0/(m.goal-m.b_p).norm)
a=calculdepos(b,m.p)-m.p
if (m.goal-m.b_p).norm<30:
s=m.goal-m.b_p
else:
s=m.goal-m.b_p
s.scale(1.2/(m.goal-m.b_p).norm)
if m.d>2:
return SoccerAction(a, Vector2D(0,0))
return SoccerAction(a, s)
def compute_strategy(self, state, player, teamid):
g = state.get_goal_center(need.get(teamid))
b = state.ball.position
dist = b - player.position
gb = state.get_goal_center(need.get(teamid)) - player.position
shoot = Vector2D.create_polar(gb.angle + random.uniform(-1, 1), g.norm)
return SoccerAction(dist, shoot)
def begin_round(self, team1, team2, state):
ball = Vector2D.create_random(low=0, high=1)
ball.x *= GAME_WIDTH
ball.y *= GAME_HEIGHT
# Player and ball postion ( random )
self.simu.state.states[(1,
0)].position = ball.copy() # Player position
self.simu.state.states[(1,
0)].vitesse = Vector2D() # Player accelerati
self.simu.state.ball.position = ball.copy() # Ball position
# Last step of the game
self.last_step = self.simu.step
self.last_state = None
self.last_score = self.simu.score[1] # Score of Team 1
self.cur_state = self.strategy.get_state(state, id_team=1, id_player=0)
self.rewards = []
def QuickCatch(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 mystate.state.ball.vitesse._x==0 and d.norm<2:
d.scale(0.009)
return SoccerAction(d,
Vector2D(0,45)-mystate.state.ball.position)
def defenseur3(state):
if state.v4v4[0]:
return defenseur2(state)
else:
return SoccerAction(
Vector2D(state.coequipier1.x, state.coequipier22.y) - state.player,
state.coequipier22 - state.player)
def begin_round (self, team1, team2, state):
ball = Vector2D.create_random(low=0,high=1)
ball.y = ball.y*GAME_HEIGHT
ball.x = ball.x*GAME_WIDTH*(3/5) + GAME_WIDTH*(3/5)
# Player and ball postion ( random )
self.simu.state.states[(1,0)].position = ball.copy() # Player position
self.simu.state.states[(1,0)].vitesse = Vector2D() # Player acceleration
self.simu.state.ball.position = ball.copy() # Ball position
self.last_step = self.simu.step # Last step of the game
# Set the current value for the current parameters
for key, value in self.cur_param.items():
setattr(self.strategy, key, value)
def gen_features(state, idteam, idplayer):
mystate = SoccerStateDecorator(state, idteam, idplayer, None)
e_t = 3 - mystate.id_team
#enemy team (int)
b_p = mystate.state.ball.position
#ball position (vector)
b_v = mystate.state.ball.vitesse
#ball vitesse (vector)
p = mystate.p
#position player (vector)
d = mystate.d
#distance player to ball (float)
d_vec = mystate.d_vec
#distance player to ball (vector)
goal = mystate.goal
#position goal (vector)
e_p = mystate.state.player(e_t, mystate.id_player).position
#position enemie (vector)
e_d = (b_p - e_p).norm
#distance enemie player to ball (float)
e_d_vec = b_p - e_p
#distance enemie player to ball (vector)
e_goal = Vector2D(150 - (e_t - 1) * 150, 45)
#goal enemie (vector)
return [
d, e_d, b_v.norm, (goal - p).norm, (goal - e_p).norm,
(e_goal - p).norm, (e_goal - e_p).norm,
abs(p.y - 45), (e_p - p).norm
]
def passe(etat, id_t, id_p, norme, k):
posb = etat.posballe()
posp = etat.posjoueur(id_t, id_p)
vitp = etat.spjoueur(id_t, id_p)
vect = Vector2D(posp.x - posb.x + k * vitp.x, posp.y - posb.y + k * vitp.y)
vect.norm = norme
return vect
def dribble_prec(state, opp, angleDribble, powerDribble, coeffAD):
"""
Fait un dribble avec une direction aleatoire
soit vers l'axe, soit vers l'un des deux cotes
"""
coeffAD = 1.305
destDribble = Vector2D()
oPos = opp.position
angle = atan2(oPos.y - state.my_pos.y, oPos.x - state.my_pos.x)
try:
theta = atan((abs(oPos.y - state.my_pos.y) /
abs(oPos.x - state.my_pos.x))) / acos(0.)
except ZeroDivisionError:
theta = 1.
rand = exp(-coeffAD * theta) / 2.
quad = state.quadrant
if random.random() < rand: # mauvais angle (vers l'adversaire)
if quad == "II" or quad == "IV":
angleDribble = -angleDribble
else: # bon angle (vers la cage adverse)
if quad == "I" or quad == "III":
angleDribble = -angleDribble
angle += angleDribble
destDribble.x = cos(angle)
destDribble.y = sin(angle)
return kickAt(state, state.ball_pos + destDribble, powerDribble)
def kickAt(state, dest, powerShoot=maxPlayerShoot):
"""
Frappe la balle en direction de dest avec
une puissance de powerShoot
"""
return SoccerAction(Vector2D(),
normalise_diff(state.ball_pos, dest, powerShoot))
def aBallon(self, choix):
pos = Vector2D()
if self.teamid == 1:
if choix == 0:
for p in self.state.team1.players:
if (self.state.ball.position -
p.position).norm <= (PLAYER_RADIUS + BALL_RADIUS):
pos = p.position
return pos
else:
for p in self.state.team2.players:
if (self.state.ball.position -
p.position).norm <= (PLAYER_RADIUS + BALL_RADIUS):
pos = p.position
return pos
else:
if choix == 0:
for p in self.state.team2.players:
if (self.state.ball.position -
p.position).norm <= (PLAYER_RADIUS + BALL_RADIUS):
pos = p.position
return pos
else:
for p in self.state.team1.players:
if (self.state.ball.position -
p.position).norm <= (PLAYER_RADIUS + BALL_RADIUS):
pos = p.position
return pos
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 defenseur4(state):
if state.v4v4[1]:
return defenseur2(state)
else:
return SoccerAction(
Vector2D(state.coequipier0.x, state.coequipier3.y) - state.player,
state.coequipier3 - state.player)
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 state.ball.vitesse._x==0 and d.norm<1:
d.scale(0)
return SoccerAction(d,
Vector2D(0,45)-state.ball.position)
def division_verticale(self):
#zone droite
c1 = Vector2D(0, -1)
c2 = Vector2D(1, 1)
c1 = self.denormalisation(c1)
c2 = self.denormalisation(c2)
#zonegauche
c3 = Vector2D(-1, -1)
c4 = Vector2D(0, 1)
c3 = self.denormalisation(c3)
c4 = self.denormalisation(c4)
L = []
L.append(zone(c3, c4))
L.append(zone(c1, c2))
return L
def dirgoal(etat, id_t, norme, h):
posg = etat.poscage(id_t)
hg = (GAME_HEIGHT - GAME_GOAL_HEIGHT) / 2
posb = etat.posballe()
vect = Vector2D(posg.x - posb.x, (hg + h * GAME_GOAL_HEIGHT) - posb.y)
vect.norm = norme
return vect
def division_horizontale(self):
#zone haut
c1 = Vector2D(-1, -0)
c2 = Vector2D(1, 1)
c1 = self.denormalisation(c1)
c2 = self.denormalisation(c2)
#zone bas
c3 = Vector2D(-1, -1)
c4 = Vector2D(1, 0)
c3 = self.denormalisation(c3)
c4 = self.denormalisation(c4)
L = []
L.append(zone(c3, c4))
L.append(zone(c1, c2))
return L
def begin_round(self, team1, team2, state):
ball = Vector2D(GAME_WIDTH/2., GAME_HEIGHT/2.)
# Player and ball postion (random)
self.simu.state.states[(1, 0)].position = ball.copy() # Passeur position
self.simu.state.states[(1, 1)].position = Vector2D(110, 20) # Recepteur position
self.simu.state.states[(1, 0)].vitesse = Vector2D() # Passeur acceleration
self.simu.state.states[(1, 1)].vitesse = Vector2D() # Recepteur acceleration
self.simu.state.ball.position = ball.copy() # Ball position
# Last step of the game
self.last = self.simu.step
# Set the current value for the current parameter
for i, (key, values) in zip(self.param_id, self.params.items()):
setattr(self.strategy, key, values[i])
def attaquant5(state):
if state.teamatt2[0]:
return gobetteratt(state)
else:
return SoccerAction(
acceleration=Vector2D(state.teamatt2[1], (state.milieuloin).y) -
state.player)
def passedef(etat, id_t, id_p, norme, k) : t_adv = id_t%2+1 posjadv=etat.state.player_state(t_adv, etat.proche_balle(t_adv)).position posj=etat.state.player_state(id_t,id_p).position pos=Vector2D(posj.x + k*(posj.x-posjadv.x), posj.y + k*(posj.y-posjadv.y)) vect= pos-etat.posballe() vect.norm = norme return vect
def __init__(self, name=None):
if not name:
self.name = "Overpowered"
else:
self.name = name
self.moves = [runnerMove, runnerMove]
self.shots = [directShot, directShot]
self._pos = Vector2D()
def attaquant(state):
if state.teamatt[1]:
return SoccerAction(
Vector2D(GAME_WIDTH * (state.teamatt[0]),
(state.ballameliorer.y + state.goal.y) / 2) -
state.player, state.goal - state.player)
else:
return gobettervolley(state)
def defenseur(state):
if state.teamdef[1]:
return SoccerAction(
Vector2D(GAME_WIDTH * (state.teamdef[0]),
(state.ballameliorer.y + state.goal.y) / 2) -
state.player, state.goal - state.player)
else:
return gobetterdef(state)
def compute_strategy(self, state, id_team, id_player):
p = state.player_state(id_team, id_player)
MyState = PlayerDecorator(state, id_team, id_player)
if (MyState.distanceAll() < 10):
return SoccerAction(
Vector2D(settings.GAME_WIDTH - 70, state.ball.position.y) -
p.position, Vector2D(0, 0))
if (MyState.position_balle() > 75):
return SoccerAction((state.ball.position - p.position),
Vector2D(-(settings.GAME_HEIGHT), 0))
else:
return SoccerAction(
Vector2D(settings.GAME_WIDTH - 70, state.ball.position.y) -
p.position, Vector2D(0, 0))
def begin_round(self, team1, team2, state):
ball = Vector2D(GAME_WIDTH/2,GAME_HEIGHT/2)
# Player and ball postion (random)
self.simu.state.states[(1, 0)].position = Vector2D(15,45) # Player position
self.simu.state.states[(2, 0)].position = Vector2D(135,45) # Player position
self.simu.state.ball.position = ball.copy() # Ball position
# Last step of the game
self.last = self.simu.step
# Set the current value for the current parameter
for i, (key, values) in zip(self.param_id, self.params.items()):
setattr(self.strategy1, key, values[i])
def goal(self):
if (self.id_team == 1):
back = Vector2D(5, GAME_HEIGHT / 2.) - self.pos()
if ((self.ball_pos.x < GAME_WIDTH / 10)
and (self.dist_ball() < 8)):
return self.suivre_balle() + self.shoot_def()
else:
return SoccerAction(back, Vector2D())
else:
back = Vector2D(GAME_WIDTH - 5, GAME_HEIGHT / 2.) - self.pos()
if ((self.ball_pos.x > 9 * GAME_WIDTH / 10)
and (self.dist_ball() < 8)):
return self.suivre_balle() + self.shoot_def()
else:
return SoccerAction(back, Vector2D())
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 choix_mouv(self, argument, state, id_team, id_player):
s = SuperState(state, id_team, id_player)
dir_balle = s.ball - s.player
pos_cible = ((s.ball - s.goal_a) * 0.6 +
(s.goal_a - s.player)).scale(5)
switcher = {
0:
SoccerAction(Vector2D(0, 0), Vector2D(0, 0)),
1:
SoccerAction(dir_balle, Vector2D(0, 0)),
2:
SoccerAction(dir_balle,
(s.goal_e - s.player).normalize().scale(3.8)),
3:
SoccerAction(pos_cible, Vector2D(0, 0))
}
return switcher.get(argument, "nothing")
def compute_strategy(self,state,player,teamid):
pos=Vector2D(0,0)
if(teamid==1):
shoot = state.get_goal_center(2)-player.position
return SoccerAction(pos,shoot)
else:
shoot = state.get_goal_center(1)-player.position
return SoccerAction(pos,shoot)
def begin_round(self, team1, team2, state):
ball = Vector2D.create_random(low=0, high=1)
ball.x *= GAME_WIDTH / 2
ball.x += GAME_WIDTH / 2
ball.y *= GAME_HEIGHT
# Player and ball postion (random)
self.simu.state.states[(1, 0)].position = ball.copy() # Player position
self.simu.state.states[(1, 0)].vitesse = Vector2D() # Player acceleration
self.simu.state.ball.position = ball.copy() # Ball position
# Last step of the game
self.last = self.simu.step
# Set the current value for the current parameter
for i, (key, values) in zip(self.param_id, self.params.items()):
setattr(self.strategy, key, values[i])
def campeur(a):
rayon=22
if a.key[0]==2 and a.my_position.x >= settings.GAME_WIDTH/2.5:
return SoccerAction(Vector2D(settings.GAME_WIDTH/2.5,settings.GAME_HEIGHT/3)-a.my_position,Vector2D())
else:
if a.key[0]==2:
a=App(miroir(a.state),a.key[0],a.key[1])
if a.my_position.distance(a.ball_position) <= (settings.BALL_RADIUS+settings.PLAYER_RADIUS)*rayon:
return miroir_action(fonceur(a))
else:
return SoccerAction(Vector2D.create_random(-1,1),Vector2D())
else:
if a.my_position.x <= settings.GAME_WIDTH-settings.GAME_WIDTH/2.5:
return SoccerAction(Vector2D(settings.GAME_WIDTH-settings.GAME_WIDTH/2.5,settings.GAME_HEIGHT/3)-a.my_position,Vector2D())
else:
if a.my_position.distance(a.ball_position) <= (settings.BALL_RADIUS+settings.PLAYER_RADIUS)*rayon:
return fonceur(a)
else:
return SoccerAction(Vector2D.create_random(-1,1),Vector2D())
def compute_strategy(self, state, id_team, id_player):
mystate = PlayerStateDecorator( state, id_team, id_player)
if (mystate.danger(state)):
return SoccerAction(acceleration = Vector2D.create_random(low=-1.,high=1.), shoot = Vector2D.create_random(low=-1.,high=1.))
else :
return suivre_ball (state, id_team, id_player)
def compute_strategy(self, state, id_team, id_player):
return SoccerAction(acceleration = Vector2D.create_random(low=-1.,high=1.), shoot = Vector2D.create_random(low=-1.,high=1.))
def random (self):
return SoccerAction(Vector2D.create_random(-1.,1.), Vector2D.create_random(-1.,1.))
def random(mystate):
return SoccerAction(Vector2D.create_random()-0.5,
Vector2D.create_random())
def compute_strategy(self, state, id_team, id_player):
return SoccerAction(Vector2D.create_random(-1,1),Vector2D.create_random(-1,1))
def compute_strategy(self,state,player,teamid): return SoccerAction(Vector2D.create_random(-0.1,0.1),Vector2D.create_random(-0.1,0.1))
def compute_strategy(self, state, teamid, player):
return SoccerAction(Vector2D.create_random(low=-1.,high=1.), Vector2D.create_random(low=-1.,high=1.))
