def compute_strategy(self,state,player,teamid):
moi = player.position
adv = joueurAdverseProche(state, teamid, player)
shoot = Vector2D(0,0)
acceleration = state.ball.position - player.position
a = state.get_goal_center(teamAdverse(teamid))-player.position
if (adv!=None):
tir= adv - moi
if (adv.y<moi.y) and balleProche(state, player):
shoot = Vector2D.create_polar((tir.angle)+0.75, 1.75)
acceleration = state.ball.position - player.position
if (joueurAdverseDerriere(state, teamid, player, adv)==True) and balleProche(state, player):
shoot= a
elif(balleProche(state,player)):
shoot = Vector2D.create_polar((tir.angle)+0.75, 1.75)
elif (balleProche(state,player)):
shoot = Vector2D.create_polar((tir.angle)-0.75, 1.75)
acceleration = state.ball.position - player.position
if (joueurAdverseDerriere(state, teamid, player, adv)==True) and balleProche(state,player):
shoot= a
elif(balleProche(state,player)):
shoot = Vector2D.create_polar((tir.angle)+0.75, 1.75)
elif(balleProche(state,player)):
shoot = Vector2D.create_polar(a.angle, 1.75)
acceleration = state.ball.position - player.position
return SoccerAction(acceleration,shoot)
def compute_strategy(self, state, player, teamid):
need = Need(state, teamid, player)
g = state.get_goal_center(need.getad())
b = state.ball.position
p = player.position
gp = g - p
d = Vector2D(0.75 * (b.x - GAME_WIDTH) + GAME_WIDTH,
0.75 * (b.y - 0.5 * GAME_HEIGHT) + 0.5 * GAME_HEIGHT)
shoot = Vector2D.create_polar(player.angle + 2.25, g.norm)
dirt = d - p
if (teamid == 1):
d.x = 0.75 * b.x
dirt = d - p
if need.CanIshoot():
if b.y < GAME_HEIGHT / 2.0:
shoot2 = Vector2D.create_polar(gp.angle + 2.505, 15)
return SoccerAction(dirt, shoot2)
else:
shoot = Vector2D.create_polar(gp.angle - 2.505, 15)
return SoccerAction(dirt, shoot)
else:
return SoccerAction(dirt, Vector2D())
else:
if need.CanIshoot():
if b.y < GAME_HEIGHT / 2.0:
shoot2 = Vector2D.create_polar(gp.angle + 2.505, 15)
return SoccerAction(dirt, shoot2)
else:
shoot = Vector2D.create_polar(gp.angle - 2.505, 15)
return SoccerAction(dirt, shoot)
else:
return SoccerAction(dirt, Vector2D())
def compute_strategy(self, state, player, teamid):
g = state.get_goal_center(self.get(teamid))
b = state.ball.position
gb = state.get_goal_center(self.get(teamid)) - player.position
de = Vector2D.create_polar(player.angle, g.norm)
dr = Vector2D.create_polar(player.angle + random.random(), g.norm)
direc = Vector2D()
return SoccerAction(direc, dr)
def compute_strategy(self, state, player, teamid):
out = Outils(state, teamid, player)
goal = state.get_goal_center(outils.IDTeamOp(teamid))
yadv = out.jpro().y
yme = player.position.y
if (yadv > yme):
dire = goal - player.position
go = Vector2D.create_polar(dire.angle - 0.35, 2)
else:
dire = goal - player.position
go = Vector2D.create_polar(dire.angle + 0.35, 2)
if (out.canshoot()):
return SoccerAction(Vector2D(0, 0), go)
else:
return SoccerAction(Vector2D(0, 0), Vector2D(0, 0))
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 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):
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 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):
move = state.get_goal_center(
need.teamAdverse(teamid)) - (player.position)
if need.jai_la_balle(state, player):
shoot = Vector2D.create_polar(move.angle + random.random() * 2 - 1,
1)
return SoccerAction(Vector2D(0, 0), shoot)
return SoccerAction(Vector2D(0, 0), Vector2D())
def compute_strategy(self, state, player, teamid):
need = Need(state, teamid, player)
gb = state.get_goal_center(need.get()) - player.position
shoot = Vector2D.create_polar(gb.angle + pi / 4.0, 5)
if need.CanIshoot():
return SoccerAction(Vector2D(), shoot)
else:
return SoccerAction(Vector2D(), Vector2D())
def compute_strategy(self, state, player, teamid):
a = (state.ball.position + state.get_goal_center((teamid)))
a.x = a.x / 2.2
a.y = a.y / 2.2
a = a - player.position
shoot = Vector2D.create_polar(6, (teamid - 1.5) * 20)
return SoccerAction(
a, shoot) #Soit il tir a 10 soit a -10 en fonction de son équipe
def compute_strategy(self,state,player,teamid):
acceleration = Vector2D(0,0)
goaladv = state.get_goal_center(teamAdverse(teamid))
dist = goaladv - state.ball.position
if (balleProche(state, player)):
shoot= Vector2D.create_polar((dist.angle)+math.pi, 1)
else:
shoot = Vector2D(0,0)
return SoccerAction(acceleration, shoot)
def compute_strategy(self, state, player, teamid):
dri = state.get_goal_center(outils.IDTeamOp(teamid)) - player.position
test = Outils(state, teamid, player)
if (test.canshoot()):
drib = Vector2D.create_polar(dri.angle + random.random() * 2 - 1,
1)
else:
drib = Vector2D(0, 0)
return SoccerAction(Vector2D(0, 0), drib)
def compute_strategy(self, state, player, teamid):
need = Need(state, teamid, player)
b = state.ball.position
gp = state.get_goal_center(need.get()) - player.position
#gb = state.get_goal_center(need.get(teamid)) - b
padv = need.posPlayeradv()
gpadv = state.get_goal_center(need.get()) - padv
direct = Vector2D(0, 0)
b = state.ball.position
padvp = padv - player.position
if need.CanIshoot():
if need.posp():
shoot = Vector2D.create_polar(gp.angle - pi / 4.0, 40.0)
return SoccerAction(direct, shoot)
else:
shoot = Vector2D.create_polar(gp.angle + pi / 4.0, 40.0)
return SoccerAction(direct, shoot)
else:
return SoccerAction(direct, direct)
def compute_strategy(self, state, player, teamid):
need = Need(state, teamid, player)
g = state.get_goal_center(need.getad())
b = state.ball.position
p = player.position
gb = g - b
dist = b + g
d = Vector2D((dist.x) / 2.0,
(GAME_HEIGHT * 0.5) + 0.80 * (b.y - (GAME_HEIGHT * 0.5)))
dirt = d - p
shoot = Vector2D.create_polar(gb.angle + (pi / 2.0), 100)
if need.CanIshoot():
if (b.y > 0.5 * GAME_HEIGHT):
shoot = Vector2D.create_polar(gb.angle + (pi / 2.0), 100)
return SoccerAction(dirt, shoot)
else:
shoot = Vector2D.create_polar(gb.angle - (pi / 2.0), 100)
return SoccerAction(dirt, shoot)
return SoccerAction(dirt, Vector2D())
def compute_strategy(self, state, player, teamid):
g = state.get_goal_center(need.TeamMy(teamid))
b = state.ball.position
p = player.position
gp = g - p
bp = state.ball.position - player.position
dist = b + g
d = Vector2D((dist.x) / 2.00, (dist.y) / 2.00)
dirt = d - p
dirt.product(10)
if need.jai_la_balle(state, player):
if b.y < GAME_HEIGHT / 2.0:
shoot2 = Vector2D.create_polar(gp.angle + 2.505, 15)
return SoccerAction(dirt, shoot2)
else:
shoot = Vector2D.create_polar(gp.angle - 2.505, 15)
return SoccerAction(dirt, shoot)
return SoccerAction(dirt, Vector2D())
def compute_strategy(self, state, player, teamid):
need = Need(state, teamid, player)
g = state.get_goal_center(need.getad())
b = state.ball.position
p = player.position
gb = g - p
dist = b + g
d = Vector2D((dist.x) / 2.0,
(GAME_HEIGHT * 0.5) + 0.70 * (b.y - (GAME_HEIGHT * 0.5)))
dirt = d - p
shoot = Vector2D.create_polar(gb.angle + (pi / 2.0), 100)
bp = state.ball.position - player.position
if ((p.distance(b) <=
(PLAYER_RADIUS + BALL_RADIUS))) or (bp.norm <= GAME_WIDTH -
(GAME_WIDTH * 0.90)):
if (b.y > 0.5 * GAME_HEIGHT):
shoot = Vector2D.create_polar(gb.angle + (pi / 2.0), 100)
return SoccerAction(dirt, shoot)
else:
shoot = Vector2D.create_polar(gb.angle - (pi / 2.0), 100)
return SoccerAction(dirt, shoot)
def compute_strategy(self, state, player, teamid):
need = Need(state, teamid, player)
g = state.get_goal_center(self.getad(teamid))
b = state.ball.position
p = player.position
gp = g - p
bp = state.ball.position - player.position
dist = b + g
d = Vector2D((dist.x) / 2.00, (dist.y) / 2.00)
dirt = d - p
shoot = Vector2D.create_polar(gp.angle + 2.505, 15)
dirt.product(10)
if (b.y < GAME_HEIGHT * 0.5) or (gp.norm <= 20.0):
shoot2 = Vector2D.create_polar(gp.angle - 2.505, 15)
return SoccerAction(dirt, shoot2)
elif ((p.distance(b) <=
(PLAYER_RADIUS + BALL_RADIUS))) or (bp.norm <= GAME_WIDTH -
(GAME_WIDTH * 0.90)):
return SoccerAction(dirt, shoot)
shoot1 = Vector2D(-10, 10)
return SoccerAction(dirt, shoot1)
def compute_strategy(self, state, player, teamid):
need = Need(state, teamid, player)
g = state.get_goal_center(need.getad())
b = state.ball.position
p = player.position
d = Vector2D(0.75 * (b.x - GAME_WIDTH) + GAME_WIDTH,
0.75 * (b.y - 0.5 * GAME_HEIGHT) + 0.5 * GAME_HEIGHT)
if (teamid == 1):
d.x = 0.75 * b.x
dirt = d - p
shoot = Vector2D.create_polar(player.angle + 2.25, g.norm)
return SoccerAction(dirt, shoot)
def compute_strategy(self, state, player, teamid):
need = Need(state, teamid, player)
g = state.get_goal_center(self.get(teamid))
#b = state.ball.position
##gb = state.get_goal_center(self.get(teamid)) - player.position
#de=Vector2D.create_polar(player.angle, g.norm)
dr = Vector2D.create_polar(player.angle + random.random(), g.norm)
direc = Vector2D()
if need.CanIshoot():
return SoccerAction(direc, dr)
else:
return SoccerAction(direc, direc)
def compute_strategy(self, state, player, teamid):
r = random.randint(1, 10)
r = r % 2
vitesse = state.ball.position - player.position
tir = state.get_goal_center(self.get_op(teamid)) - player.position
angle = tir.angle
if r == 0:
angle = angle + 0.9
if r == 1:
angle == angle - 0.9
frappe = Vector2D.create_polar(angle, 1000)
return SoccerAction(vitesse, frappe)
def compute_strategy(self, state, player, teamid):
need = Need(state, teamid, player)
g = state.get_goal_center(need.getad())
b = state.ball.position
p = player.position
gb = state.get_goal_center(need.getad()) - p
dist = b + g
d = Vector2D((dist.x / 2.00) - (0.25 * gb.norm), b.y)
dirt = d - p
shoot = Vector2D.create_polar(player.angle + 2.25, g.norm)
if teamid == 1:
d = Vector2D((dist.x / 2.00) + (0.25 * gb.norm), b.y)
dirt = d - p
return SoccerAction(dirt, shoot)
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, player, teamid):
tir = state.get_goal_center(
self.team_adverse(teamid)) - player.position
dri = Vector2D.create_polar(tir.angle + random.random(), 1)
return SoccerAction(Vector2D(0, 0), dri)
def compute_strategy_utilitaire (self, u) :
shoot = Vector2D.create_polar(u.player.angle + 3.5, 100)
return u.tirer(shoot)
