def tire_basStrat(etat): V = Vector2D(angle = -45, norm = 2) if not((etat.ball_position - etat.my_position).angle < -42 and (etat.ball_position - etat.my_position).angle > -48): res = etat.go(etat.ball_position - 0.1 *V) else: res = SoccerAction(etat.ball_position - etat.my_position,Vector2D(angle=-45, norm=2)) res.name = "tire_basStrat" return res
def dribleStrat(etat): V = (etat.ball_position - etat.adv_but)*1.05 if not(etat.dans_zone(zone(etat.adv_but + V - Vector2D(5,5), etat.adv_but + V + Vector2D(5,5)),etat.my_position)): res = SoccerAction((etat.adv_but + V) - etat.my_position, Vector2D(0,0)) else: res = SoccerAction(etat.ball_position - etat.my_position,0.030*(etat.adv_but - etat.my_position)) res.name = "dribleStrat" return res
def passe(me): res=SoccerAction(Vector2D(),Vector2D()) res.name="passe" if me.test_peut_shooter: res=me.shoot_vers_norm(me.pos_equi_pr_ball,3.0) return res else: res=me.courir_vers_ball2 return res
def degage_cote(a): dep=a.ball_position-a.my_position #--> bloquer le passage de la balle dep.x=0 if a.can_shoot() == 0: # Shoot ou pas if a.my_position.y >= settings.GAME_HEIGHT/2: res= SoccerAction(dep,Vector2D((3.14),4.5)) # angle a modifie res.name="degage_cote_haut" return res else: res=SoccerAction(dep,Vector2D(-(3.14),4.5)) res.name="degage_cote_bas" return res return SoccerAction(dep,Vector2D())
def degager(app): hisg = Vector2D((2-app.key[0])*settings.GAME_WIDTH,settings.GAME_HEIGHT/2.) shoot=hisg-app.ball_position s=SoccerAction(app.ball_position-app.my_position, shoot) s.shoot.norm=4 if app.key[0]==2: #miroir fail s.acceleration.x=-s.acceleration.x s.shoot.x=-s.shoot.x if app.can_shoot() == 0: s.name="degager" return s return SoccerAction(Vector2D(),Vector2D())
def compute_strategy(self, state, player, teamid): test = Outils(state, teamid, player) if (test.canshoot()): tir = Vector2D.create_polar(player.angle + 2.5, 100) else: tir = Vector2D(0, 0) return SoccerAction(Vector2D(0, 0), tir)
def shoot_intercepter_contrecarE(self): vect_input = self.state.ball.vitesse vect_output_x = -vect_input.x vect_output_y = -vect_input.y vect_output = Vector2D(vect_output_x, vect_output_y) return SoccerAction(Vector2D(), vect_output)
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 compute_strategy(self, state, player, teamid): g = state.get_goal_center(2) dis = (state.ball.position - player.position) b = state.ball.position + state.ball.speed p = player.position bp = b - p bp.x = bp.x * 1.2 bp.y = bp.y * 1.2 if teamid == 2: bp.x = bp.x + 0.5 else: bp.x = bp.x - 0.5 if (p.y > (GAME_HEIGHT / 2)): shoot = Vector2D(GAME_WIDTH, GAME_HEIGHT / 2 + GAME_GOAL_HEIGHT / 2 - 0.5) - state.ball.position - state.ball.speed else: shoot = Vector2D(GAME_WIDTH, GAME_HEIGHT / 2 - GAME_GOAL_HEIGHT / 2 + 0.5) - state.ball.position - state.ball.speed if (teamid == 2): if (p.y > (GAME_HEIGHT / 2)): shoot = Vector2D(0, GAME_HEIGHT / 2 + GAME_GOAL_HEIGHT / 2 - 0.5) - state.ball.position - state.ball.speed else: shoot = Vector2D(0, GAME_HEIGHT / 2 - GAME_GOAL_HEIGHT / 2 + 0.5) - state.ball.position - state.ball.speed if ((PLAYER_RADIUS + BALL_RADIUS) < (dis.norm)): shoot = Vector2D(0, 0) return SoccerAction(bp, shoot)
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 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 compute_strategy(self, state, id_team, id_player): # id_team is 1 or 2 # id_player starts at 0 return SoccerAction( Vector2D(random.randint(-1, 1), random.randint(-1, 1)), Vector2D(random.randint(-1, 1), random.randint(-1, 1)))
def entreballetbut(self): vecteurballbut = Vector2D( ((2 - self.id_team) * settings.GAME_WIDTH) - self.ball_positionx, settings.GAME_HEIGHT / 2. - self.ball_positiony) vecteurballjoueur = Vector2D(self.my_positionx - self.ball_positionx, self.my_positiony - self.ball_positiony) return SoccerAction(vecteurballbut - vecteurballjoueur)
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 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): label = self.tree.predict( [self.get_features(state, id_team, id_player)])[0] if label not in self.dic: self.logger.error("Erreur : strategie %s non trouve" % (label, )) return SoccerAction() return self.dic[label].compute_strategy(state, id_team, id_player)
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.closest_ennemi_behind(): if t.ennemi_in_my_small_perimeter(): 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.closest_ennemi_behind(): if t.ennemi_in_my_small_perimeter(): 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,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 compute_strategy(self, state, id_team, id_player): act = Action(state, id_team, id_player) mystate = MyState(state, id_team, id_player) qui = Qui_a_la_balle(state, id_team, id_player) distance = mystate.distance_ball_player #distance entre la balle et le but distance_but = mystate.distance_but_ball if distance > 20: if (mystate.adv() == 2): position = Vector2D( (0.5 / 5) * GAME_WIDTH, state.ball.position.y) - mystate.my_position else: position = 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) # if qui.mon_equipe_a_la_b(): # return mystate.en_attente # else: return SoccerAction(state.ball.position-state.player_state(id_team,id_player).position,\ Vector2D((2-id_team)*settings.GAME_WIDTH,settings.GAME_HEIGHT/2.)-state.ball.position)
def compute_strategy(self, state, player, teamid): p = (GAME_HEIGHT / 2 + GAME_GOAL_HEIGHT / 2) - 0.5 if teamid == 1: direct = Vector2D(0.75, p) - player.position else: direct = Vector2D(GAME_WIDTH - 1.0, p) - player.position return SoccerAction(direct, Vector2D())
def compute_strategy(self, state, player, teamid): need = Need(state, teamid, player) gp = state.get_goal_center(need.get()) - player.position padv = need.posPlayeradv() gpadv = state.get_goal_center(need.get()) - padv if need.CanIshoot(): if need.Playeradv(): if (gp.norm < gpadv.norm): shoot = Vector2D(3, 3) return SoccerAction(Vector2D(), shoot) else: return SoccerAction(Vector2D(), gp) else: #shoot = state.get_goal_center(need.get(teamid)) return SoccerAction(Vector2D(), gp) return SoccerAction(Vector2D(), Vector2D())
def compute_strategy(self, state, id_team, id_player): qui = Qui_a_la_balle(state, id_team, id_player) act = Action(state, id_team, id_player) #if qui.j_ai_la_balle()==True: #p=act.passe_test(state,id_team,id_player) return SoccerAction(state.ball.position-state.player_state(id_team,id_player).position ,\ Vector2D((2-id_team)*settings.GAME_WIDTH,settings.GAME_HEIGHT/2.)-state.ball.position)
def attaquant5(state): if state.teamatt2[0]: return gobetteratt(state) else: return SoccerAction( acceleration=Vector2D(state.teamatt2[1], (state.milieuloin).y) - state.player)
def compute_strategy(self, state, id_team, id_player): s = SuperState(state, id_team, id_player) if (s.ball.x == GAME_WIDTH / 2 and s.ball.y == GAME_HEIGHT / 2): self.engage = 0 # id_team is 1 or 2 # id_player starts at 0 if (self.engage == 0): if (s.dir_ball.norm < CAN_SHOOT + 1.784): self.engage = 1 return SoccerAction( s.dir_ball.normalize().scale(5.0), s.shoot((s.goal_e - s.player)).normalize().scale(5)) if (s.dir_ball.norm < CAN_SHOOT): return SoccerAction( s.dir_ball.normalize().scale(5.0), s.shoot((s.goal_e - s.player)).normalize().scale(5)) return SoccerAction(s.dir_ball.normalize().scale(5.0), Vector2D(0, 0))
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 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 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 revenir_posi_def(self, id_team): if (id_team == 1): return SoccerAction( self.vect_player_posi( GAME_WIDTH * self.cst_defense, (((self.posi_ball().y) - (GAME_HEIGHT / 2)) / self.posi_ball().x) * (GAME_WIDTH * self.cst_defense) + GAME_HEIGHT / 2), 0) return SoccerAction( self.vect_player_posi( GAME_WIDTH - (self.cst_defense * GAME_WIDTH), ((((self.posi_ball().y) - (GAME_HEIGHT / 2)) / ((self.posi_ball().x) - (GAME_WIDTH))) * (GAME_WIDTH - (self.cst_defense * GAME_WIDTH)) + GAME_HEIGHT / 2 - (((self.posi_ball().y) - (GAME_HEIGHT / 2)) / ((self.posi_ball().x) - (GAME_WIDTH))) * GAME_WIDTH)), 0)
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) balle = s.ball joueur = s.player if (id_team == 1): if s.can_shoot: return SoccerAction(shoot=s.goal_opponent - s.player) else: return SoccerAction(acceleration=balle - s.player) else: if s.can_shoot: return SoccerAction(shoot=s.goal_opponent - s.player) else: return SoccerAction(acceleration=balle - s.player)
def aller_defense(state, id_t, id_p, decalage): e=Etat(state) pos_def= e.poscage(id_t) if pos_def.x==0: pos_def.x+=decalage elif pos_def.x==GAME_WIDTH: pos_def.x-=decalage return SoccerAction(dirpos(e, id_t, id_p, 5, pos_def))
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 compute_strategy(self, state, id_team, id_player): t = Tools(state, id_team, id_player) c = Comportement(state, id_team, id_player) if t.test_shoot(): return c.shoot() if t.in_my_third(): return SoccerAction(Vector2D(0, 0), Vector2D(0, 0)) return c.run()
def compute_strategy(self, state, id_team, id_player): s = SuperState(state, id_team, id_player) if s.player.distance(s.ball) < PLAYER_RADIUS + BALL_RADIUS: if s.closest_opponent.distance(s.player) < (PLAYER_RADIUS * 20): return s.dribble elif s.getDistanceTo(s.goal_opponent) < ( PLAYER_RADIUS * 20 ): #Si il est dans la surface de tir : shoot, sinon avance shoot = s.goal_opponent - s.player return SoccerAction(shoot=shoot.normalize() * 115) else: shoot = s.goal_opponent - s.player return SoccerAction(shoot=shoot.normalize() * 1.2) else: deplacement = s.ball - s.player return SoccerAction(acceleration=deplacement.normalize() * 1500)
def compute_strategy(self, state, id_team, id_player): s = SuperState(state, id_team, id_player) if s.milieu: if s.can_shoot: return SoccerAction(shoot=s.goal_opponent - s.player) else: return SoccerAction(acceleration=s.balleamelioree - s.player) else: if s.can_shoot: if s.testjoueurdevant: return SoccerAction(shoot=s.coequipierprochedevant - s.player) else: return SoccerAction(shoot=s.goal_opponent - s.player) else: return SoccerAction(acceleration=s.balleamelioree - s.player)
def attend(etat): res = SoccerAction(Vector2D(0,0),Vector2D(0,0)) res.name = "attend" return res