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.))