def get_free_forward_team_mates(self,
team,
side,
my_coord: Coordinate,
max_data_age,
min_distance_free,
min_dist_from_me=3):
free_team_mates: [ObservedPlayer
] = self.get_free_team_mates(team, max_data_age,
min_distance_free)
debug_msg("Free_team_mates={0}".format(free_team_mates), "OFFSIDE")
if side == "l":
free_forward_team_mates = list(
filter(
lambda p: p.coord.pos_x > my_coord.pos_x and p.coord.
euclidean_distance_from(my_coord) > min_dist_from_me,
free_team_mates))
else:
free_forward_team_mates = list(
filter(
lambda p: p.coord.pos_x < my_coord.pos_x and p.coord.
euclidean_distance_from(my_coord) > min_dist_from_me,
free_team_mates))
return free_forward_team_mates
def get_free_team_mates(self,
team,
max_data_age,
min_distance=2) -> [ObservedPlayer]:
team_mates: [ObservedPlayer
] = self.get_teammates(team, max_data_age=max_data_age)
opponents: [ObservedPlayer
] = self.get_opponents(team, max_data_age=max_data_age)
debug_msg(
"Team_mates={0} | opponents={1} | other_players:{2}".format(
team_mates, opponents, self.other_players), "OFFSIDE")
free_team_mates = []
if len(opponents) < 1:
return team_mates
for team_mate in team_mates:
for opponent in opponents:
tm: ObservedPlayer = team_mate
op: ObservedPlayer = opponent
if tm.coord.euclidean_distance_from(
op.coord) > min_distance and tm not in free_team_mates:
free_team_mates.append(tm)
return free_team_mates
def _optimal_midfielder_pos(state) -> Coordinate:
side = 1 if state.world_view.side == 'l' else -1
if not state.world_view.ball.is_value_known():
return state.get_global_play_pos()
ball: Coordinate = state.world_view.ball.get_value().coord
play_position = state.get_global_play_pos()
ball_delta_y = ball.pos_y - play_position.pos_y
ball_delta_x = ball.pos_x - play_position.pos_x
# Position player according to their starting position and the current ball position
if side * ball.pos_x > 0:
# Attacking
optimal_x = clamp(
play_position.pos_x + ball_delta_x * 0.4 + ball.pos_x * 0.6, -45,
45)
else:
# Defending
optimal_x = clamp(play_position.pos_x + ball.pos_x * 0.4, -45, 45)
# Used to make players position themselves closer to the goal on the y-axis when far up/down the field
y_goal_factor = 1 - (abs(optimal_x) -
35) * 0.05 if abs(optimal_x) > 35 else 1.0
optimal_y = clamp(
play_position.pos_y + ball_delta_y * 0.2 + ball.pos_y * 0.2, -25,
25) * y_goal_factor
if state.world_view.team_has_ball(state.team_name, max_data_age=4):
opt_coord = Coordinate(optimal_x + (10 * side), optimal_y)
free_pos = state.get_closest_free_position(opt_coord)
if state.is_test_player():
debug_msg("Free position:{0}".format(free_pos), "FREE_POSITION")
return opt_coord if free_pos is None else free_pos
return Coordinate(optimal_x, optimal_y)
def is_ball_inside_own_box(self) -> bool:
pos: Coordinate = self.world_view.ball.get_value().coord
result = True
if self.world_view.side == "l":
if pos.pos_x > -36 or (pos.pos_y < -20 or pos.pos_y > 20):
result = False
else:
if pos.pos_x < 36 or (pos.pos_y < -20 or pos.pos_y > 20):
result = False
if self.is_test_player():
debug_msg("is_inside_own_box={0}, Pos={1}".format(result, pos),
"GOALIE")
return result
def _optimal_striker_pos(state: PlayerState) -> Coordinate:
side = 1 if state.world_view.side == 'l' else -1
if not state.world_view.ball.is_value_known():
return state.get_global_play_pos()
ball: Coordinate = state.world_view.ball.get_value().coord
play_position = state.get_global_play_pos()
ball_delta_y = ball.pos_y - play_position.pos_y
if side * ball.pos_x > 0:
# Attacking
x_offset = ball.pos_x + side * 5
optimal_x = clamp(play_position.pos_x + x_offset, -45, 45)
# Used to make players position themselves closer to the goal on the y-axis when far up/down the field
y_goal_factor = 0.982888 + 0.002871167 * abs(
optimal_x) - 0.0000807057 * pow(optimal_x, 2)
optimal_y = clamp(
play_position.pos_y + ball.pos_y * 0.2 + ball_delta_y * 0.4, -30,
30) * y_goal_factor
if state.world_view.team_has_ball(state.team_name, max_data_age=4):
opt_coord = Coordinate(optimal_x + (10 * side), optimal_y)
free_pos = state.get_closest_free_position(opt_coord)
if state.is_test_player():
debug_msg("Free position:{0}".format(free_pos),
"FREE_POSITION")
return opt_coord if free_pos is None else free_pos
return Coordinate(optimal_x, optimal_y)
else:
# Defending
optimal_x = -state.get_global_play_pos().pos_x + ball.pos_x * 0.4
optimal_y = state.get_global_play_pos().pos_y + ball_delta_y * 0.2
if state.world_view.team_has_ball(state.team_name, max_data_age=4):
opt_coord = Coordinate(optimal_x + (10 * side), optimal_y)
free_pos = state.get_closest_free_position(opt_coord)
if state.is_test_player():
debug_msg("Free position:{0}".format(free_pos),
"FREE_POSITION")
return opt_coord if free_pos is None else free_pos
return Coordinate(optimal_x, optimal_y)
def get_non_offside_forward_team_mates(self,
team,
side,
my_coord: Coordinate,
max_data_age,
min_distance_free,
min_dist_from_me=1):
free_forward_team_mates: [ObservedPlayer
] = self.get_free_forward_team_mates(
team, side, my_coord, max_data_age,
min_distance_free, min_dist_from_me)
opponents: [ObservedPlayer] = self.get_opponents(team, max_data_age)
# If no opponents are seen, no one is offside
if len(opponents) < 1:
debug_msg(
"free_forward_team_mates={0}".format(free_forward_team_mates),
"OFFSIDE")
return free_forward_team_mates
reverse = True if side == "l" else False
furthest_behind_opponent: ObservedPlayer = \
list(sorted(opponents, key=lambda p: p.coord.pos_x, reverse=reverse))[0]
furthest_opp_x_pos = furthest_behind_opponent.coord.pos_x
if side == "l":
non_offside_players = list(
filter(
lambda p: (p.coord.pos_x < furthest_opp_x_pos and p.coord.
euclidean_distance_from(my_coord) >
min_dist_from_me) or p.coord.pos_x < 0,
free_forward_team_mates))
else:
non_offside_players = list(
filter(
lambda p: (p.coord.pos_x > furthest_opp_x_pos and p.coord.
euclidean_distance_from(my_coord) >
min_dist_from_me) or p.coord.pos_x > 0,
free_forward_team_mates))
debug_msg(
"Further_opp_x_pos={0} | free_forward_team_mates={1} | furthest_behind_opponent={2} | non_offisde_players={3}"
.format(furthest_opp_x_pos, free_forward_team_mates,
furthest_behind_opponent, non_offside_players), "OFFSIDE")
return non_offside_players
def team_has_ball(self, team, max_data_age, min_possession_distance=3):
if not self.ball.is_value_known():
debug_msg("{0} has ball".format("Team2"), "HAS_BALL")
return False
all_players: [ObservedPlayer
] = self.get_all_known_players(team, max_data_age)
# Sort players by distance to ball
sorted_list: [ObservedPlayer] = list(
sorted(all_players,
key=lambda p: p.coord.euclidean_distance_from(
self.ball.get_value().coord),
reverse=False))
if len(sorted_list) < 1:
return False
# If closest player to ball team is known and is our team, return True
closest_player: ObservedPlayer = sorted_list[0]
if closest_player.team is not None and closest_player.team == team and closest_player.coord.euclidean_distance_from(
self.ball.get_value().coord) < min_possession_distance:
debug_msg(
"{0} has ball | player: {1}".format(team, closest_player),
"HAS_BALL")
return True
debug_msg("{0} has ball".format("Team2"), "HAS_BALL")
return False
def needs_dribble_or_pass_strat(self):
if not (self.mode is DRIBBLING_MODE
or self.ball_incoming()) or self.intercepting or self.now(
) - self.last_dribble_pass_strat <= 4:
if self.is_test_player():
debug_msg(
str(self.now()) +
" Not dribbling or recently generated strat",
"DRIBBLE_PASS_MODEL")
return False
enough_opponents = len(
self.world_view.get_opponents(self.team_name, 10)) > 0
enough_teammates = len(
self.world_view.get_teammates(self.team_name, 10, 5)) > 0
if not enough_opponents:
if self.is_test_player():
debug_msg(
str(self.now()) + " Not enough opponents: " +
str(self.world_view.other_players), "DRIBBLE_PASS_MODEL")
return False
if not enough_teammates:
if self.is_test_player():
debug_msg(
str(self.now()) + " Not enough teammates: " +
str(self.world_view.other_players), "DRIBBLE_PASS_MODEL")
return False
return True
def ball_incoming(self):
if not self.world_view.ball.is_value_known(
self.action_history.three_see_updates_ago):
return False
ball: Ball = self.world_view.ball.get_value()
dist = ball.distance
if dist >= 15:
return False
if ball.absolute_velocity is not None:
ball_move_dir = ball.absolute_velocity.world_direction()
ball_relative_dir = math.degrees(
calculate_full_origin_angle_radians(ball.coord,
self.position.get_value()))
dif = abs(
smallest_angle_difference((ball_move_dir + 180) % 360,
ball_relative_dir))
if self.is_test_player():
debug_msg(
str(self.now()) + " Ball movement dir: " +
str(ball_move_dir) + " Direction from player: " +
str(ball_relative_dir) + " Heading this way : " +
str(dif <= 15), "DRIBBLE_PASS_MODEL")
return dif <= 15
position, projected_direction, speed = ball.approximate_position_direction_speed(
2)
if projected_direction is None or speed < 0.25:
return False
ball_angle = math.degrees(
calculate_full_origin_angle_radians(self.position.get_value(),
ball.coord))
if abs(ball_angle - projected_direction) < 15 and dist < 40:
return True
return False
def determine_objective_biptest(state: PlayerState):
# If lost orientation -> blind orient
if _lost_orientation(state):
return Objective(state, lambda: actions.blind_orient(state),
lambda: True, 1)
# If ball unknown -> locate ball
if _ball_unknown(state):
return Objective(state, lambda: actions.locate_ball(state),
lambda: True, 1)
if state.position.is_value_known():
side: int = 1 if state.world_view.side == "l" else -1
lower_goal: Coordinate = Coordinate(-25 * side, -33)
upper_goal: Coordinate = Coordinate(-25 * side, 33)
if not state.is_near(upper_goal, 2):
debug_msg("Going to left goal", "BIPTEST")
return Objective(state, lambda: actions.rush_to(state, upper_goal),
lambda: state.is_near(upper_goal, 0.5), 1000)
else:
debug_msg("Going to right goal", "BIPTEST")
return Objective(state, lambda: actions.rush_to(state, lower_goal),
lambda: state.is_near(lower_goal, 0.5), 1000)
def get_closest_free_position(self,
opt_coord: Coordinate,
max_delta_from_org_coord=5,
min_delta_from_opp=7):
init_x: int = int(opt_coord.pos_x)
init_y: int = int(opt_coord.pos_y)
free_cords: [Coordinate] = []
for x in range(init_x, init_x + max_delta_from_org_coord):
for y in range(init_y, init_y + max_delta_from_org_coord):
c: Coordinate = Coordinate(x, y)
if self.is_coord_free(c, min_delta_from_opp):
free_cords.append(c)
debug_msg(
"Opt_coord={0}, free_coords={1}".format(opt_coord, free_cords),
"FREE_POSITION")
if len(free_cords) > 0:
return sorted(free_cords,
key=lambda c: c.euclidean_distance_from(opt_coord),
reverse=False)[0]
return None
def perform_action(self):
if self.player_state.current_objective.should_recalculate(
self.player_state):
self.player_state.current_objective = determine_objective(
self.player_state)
if self.player_state.is_test_player(): # Debugging
debug_msg(
str(self.player_state.now()) + " Mode : " +
str(self.player_state.mode), "MODE")
commands = self.player_state.current_objective.get_next_commands(
self.player_state)
if self.player_state.is_test_player(): # Debugging
debug_msg(
str(self.player_state.now()) + " Sending commands : " +
str(commands), "SENT_COMMANDS")
debug_msg(
str(self.player_state.now()) +
"Position : {0} | Speed : {1} | BodyDir : {2} | NeckDir : {3} | "
"TurnInProgress : {4}".format(
self.player_state.position.get_value(),
self.player_state.body_state.speed,
self.player_state.body_angle.get_value(),
self.player_state.body_state.neck_angle,
self.player_state.action_history.turn_in_progress),
"STATUS")
if self.player_state.is_test_player(): # Debugging
debug_msg(
"{0} Commands: {1}".format(
self.player_state.world_view.sim_time, commands),
"MESSAGES")
for command in commands:
if command is not None:
self.player_conn.action_queue.put(command)
def _extract_actions(strategy: UppaalStrategy, team_members):
actions = []
debug_msg("-" * 50, "PASS_CHAIN")
for r in strategy.regressors:
if "Passing" in str(
strategy.index_to_transition[r.get_highest_val_trans()[0]]):
from_player = _get_ball_possessor(r, strategy.location_to_id,
team_members)
to_player = _get_pass_target(r, strategy.index_to_transition,
team_members)
to_player: PlayerViewCoach
actions.append("(" + str(from_player.num) + " pass " +
to_player.coord.marshal() + ")")
debug_msg(
str(from_player.num) + " passes to " + str(to_player.num),
"PASS_CHAIN")
else:
from_player = _get_ball_possessor(r, strategy.location_to_id,
team_members)
actions.append("(" + str(from_player.num) + " dribble" + ")")
debug_msg(str(from_player.num) + " dribbles ", "PASS_CHAIN")
debug_msg("-" * 50, "PASS_CHAIN")
return actions
def ball_interception(self):
wv = self.world_view
ball = wv.ball.get_value()
ball_known = wv.ball.is_value_known(self.now() - 4)
if (
not ball_known
) or ball.absolute_velocity is None or ball.absolute_velocity.magnitude(
) < 0.2:
return None, None
if wv.ball.is_value_known(self.now() - 4):
ball: Ball = wv.ball.get_value()
tick_offset = self.now() - wv.ball.last_updated_time
project_positions = ball.project_ball_position(10, tick_offset)
if project_positions is None:
return None, None
all_ticks = range(1, 11)
positions_and_ticks = list(zip(project_positions, all_ticks))
printable_list = [(pt[0], pt[1]) for pt in positions_and_ticks]
# positions_and_ticks = sorted(positions_and_ticks, key=lambda pos_and_t: pos_and_t[0].euclidean_distance_from(self.position.get_value()))
for (position, tick) in positions_and_ticks:
if self.can_player_reach(position, tick):
debug_msg(
str(self.now()) + " | Found reachable position: " +
str(ball.absolute_velocity), "INTERCEPTION")
return position, tick
if self.is_test_player():
debug_msg(
str(self.now()) + " | Based on ball velocity : " +
str(ball.absolute_velocity), "INTERCEPTION")
debug_msg(
str(self.now()) + " | Predictions : " +
str(printable_list), "INTERCEPTION")
return None, None
def map_reduce(file_path=None):
from parser import parse
from lexer import lexer
from utils import function, debug_msg, insert_in_tbl
#build hash table from file or scanning the complete source file
#check for input args
#global the_tbl
the_tbl = global_tbl()
if not file_path:
file_path = "."
print "No file_path specified for parsing the source code starting from current directory"
if os.path.isfile(file_path) and file_path.endswith(".tbl"):
#read file to create the_tbl
f = open(file_path)
entry = None
func = None
for line in f:
if line.startswith("&#?filename:"):
#acquire the global_etntry_tbl lock and add this entry
#for this file
if entry:
the_tbl.lock.qcquire()
the_tbl.tbl[entry.get_file_name()] = entry
the_tbl.lock.release()
filename_start = line.find(':')
file_name = line[filename_start+1:]
print "File name is: ", file_name
entry = global_tbl_entry()
entry.set_file_name(file_name)
elif line.startswith("\t&#?func_name:"):
# &#?func_name:func&#?func_args:int a&#?macro_name:MSG&#?message:I am Nandan&#?msg_args:
func = function()
function_name_start = line.find(':')
function_name_end = line.index("&#?func_args:")
func_name = line[function_name_start+1:function_name_end]
print "Func name: ", func_name
function_args_start = function_name_end + 13
func_args_end = line.index("&#?macro_name:")
func_args = line[function_args_start+1:func_args_end]
func.set_name(func_name)
func.set_args(func_args)
print "Func args: ", func_args
#message
dbg_msg = debug_msg()
dbg_macro_start = line.find("&#?macro_name:") + 14
dbg_msg_macro_end = line.index("&#?message:")
macro_name = line[dbg_macro_start:dbg_msg_macro_end]
print "Macro name: ", macro_name
dbg_msg.set_macro_name(macro_name)
dbg_msg_start = dbg_msg_macro_end + 11
dbg_msg_end = line.index("&#?msg_args:")
msg = line[dbg_msg_start:dbg_msg_end]
print "message: ", msg
dbg_msg.set_message(msg)
dbg_msg_args_start = dbg_msg_end + 12
args = line[dbg_msg_args_start:]
dbg_msg.set_args(args)
print "msg args: ", args
insert_in_tbl(entry,dbg_msg, func)
#insert the last entry
if entry:
the_tbl.lock.acquire()
the_tbl.tbl[entry.get_file_name()] = entry
the_tbl.lock.release()
return the_tbl.tbl
#else scan/parse directory to make the_tbl
print file_path
#create table write table
the_tbl = make_tbl(file_path)
save_tbl_in_file(the_tbl.tbl)
return the_tbl
def determine_objective_field_default(state: PlayerState):
state.intercepting = False
# If lost orientation -> blind orient
if _lost_orientation(state):
return Objective(state, lambda: actions.blind_orient(state),
lambda: True, 1)
opponent_side = "r" if state.world_view.side == "l" else "l"
# If game not started or other team starting -> Idle orientation
if state.world_view.game_state == 'before_kick_off' or state.world_view.game_state == "kick_off_{0}".format(
opponent_side) or "goal" in state.world_view.game_state:
return Objective(state, lambda: actions.idle_orientation(state),
lambda: True, 1)
# If some fault has been made by our team -> position optimally
if "fault_{0}".format(
state.world_view.side) in state.world_view.game_state:
return _position_optimally_objective(state)
# If we have a free kick, corner_kick, kick_in or kick_off
# If closest -> Go to ball and pass, else position optimally
if state.world_view.game_state == "free_kick_{0}".format(state.world_view.side) \
or state.world_view.game_state == "corner_kick_{0}".format(state.world_view.side) \
or state.world_view.game_state == "kick_in_{0}".format(state.world_view.side) \
or state.world_view.game_state == "kick_off_{0}".format(state.world_view.side) \
or state.world_view.game_state == "offside_{0}".format(opponent_side):
if _ball_unknown(state):
return _locate_ball_objective(state)
if state.is_near_ball(KICKABLE_MARGIN):
if state.world_view.sim_time - state.action_history.last_look_for_pass_targets > 2:
return Objective(state,
lambda: actions.look_for_pass_target(state),
lambda: True, 2)
if _choose_pass_target(state, must_pass=True) is not None:
return Objective(
state, lambda: actions.pass_to_player(
state, _choose_pass_target(state, must_pass=True)),
lambda: True, 1)
else:
return Objective(state,
lambda: actions.look_for_pass_target(state),
lambda: True, 2)
elif state.is_nearest_ball(1):
return _jog_to_ball_objective(state)
else:
return _position_optimally_objective(state)
# If in dribbling mode -> Dribble
if state.mode is DRIBBLING_MODE:
return _dribble_objective(state)
# If in possession mode -> Pass
if state.mode is POSSESSION_MODE:
return _pass_objective(state)
# If position known, but ball not -> Locate ball
if _ball_unknown(state):
return _locate_ball_objective(state)
# If in possession of ball -> dribble!
if state.is_near_ball() and state.is_nearest_ball(1):
state.mode = DRIBBLING_MODE
return _dribble_objective(state)
required_degree = calculate_required_degree(state)
if state.is_nearest_ball(required_degree):
intercept_actions = actions.intercept_2(state)
state.intercepting = True
if intercept_actions is not None:
return Objective(state, lambda: intercept_actions)
else:
return _rush_to_ball_objective(state)
# If ball not incoming -> Position optimally while looking at ball
if not state.ball_incoming() and not configurations.USING_PASS_CHAIN_STRAT:
if state.is_test_player():
debug_msg(str(state.now()) + " Position optimally!", "ACTIONS")
return _position_optimally_objective(state)
if state.is_test_player():
debug_msg(str(state.now()) + " Idle orientation!", "ACTIONS")
return Objective(state, lambda: actions.idle_orientation(state),
lambda: True, 1)
def determine_objective_goalie_default(state: PlayerState):
opponent_side = "r" if state.world_view.side == "l" else "l"
# If goalie and goal_kick -> Go to ball and pass
if state.world_view.game_state == "goal_kick_{0}".format(
state.world_view.side) and state.num == 1:
debug_msg(
str(state.now()) + " | goal kick -> got to ball and pass",
"GOALIE")
if state.is_near_ball(KICKABLE_MARGIN):
return _pass_objective(state, must_pass=True)
else:
return _jog_to_ball_objective(state)
# If game not started or other team starting -> Idle orientation
if state.world_view.game_state == 'before_kick_off' or state.world_view.game_state == "kick_off_{0}".format(
opponent_side) or ("goal_r" == state.world_view.game_state
or "goal_l" == state.world_view.game_state):
debug_msg(
str(state.now()) +
" | If game not started or other team starting -> Idle orientation",
"GOALIE")
return Objective(state, lambda: actions.idle_orientation(state),
lambda: True, 1)
# If lost_orientation -> blind orient
if _lost_orientation(state):
debug_msg(
str(state.now()) + " | lost orientation -> blind orient", "GOALIE")
return Objective(state, lambda: actions.blind_orient(state),
lambda: True, 1)
# If ball unknown -> locate ball
if _ball_unknown(state):
debug_msg(
str(state.now()) + " | ball unknown -> locate ball", "GOALIE")
return Objective(state, lambda: actions.locate_ball(state),
lambda: True, 1)
# If some fault has been made by our team -> Position optimally
if "fault_{0}".format(
state.world_view.side) in state.world_view.game_state:
debug_msg(
str(state.now()) + " | Team made fault -> position optimally",
"GOALIE")
return _position_optimally_objective_goalie(state)
# If we have a free kick, corner_kick, kick_in, kick_off or goal_kick
# If closest -> Go to ball and pass, else position optimally
if state.world_view.game_state == "free_kick_{0}".format(state.world_view.side) \
or state.world_view.game_state == "corner_kick_{0}".format(state.world_view.side) \
or state.world_view.game_state == "kick_in_{0}".format(state.world_view.side) \
or state.world_view.game_state == "goal_kick_{0}".format(state.world_view.side) \
or state.world_view.game_state == "offside_{0}".format(opponent_side):
debug_msg(
str(state.now()) +
" | free_kick, corner_kick, kick_in, kick_off, goal_kick, offside -> go to ball or position optimally",
"GOALIE")
if _ball_unknown(state):
return _locate_ball_objective(state)
if state.is_near_ball(KICKABLE_MARGIN):
if state.world_view.sim_time - state.action_history.last_look_for_pass_targets > 2:
return Objective(state,
lambda: actions.look_for_pass_target(state),
lambda: True, 2)
if _choose_pass_target(state, must_pass=True) is not None:
return Objective(
state, lambda: actions.pass_to_player(
state, _choose_pass_target(state, must_pass=True)),
lambda: True, 1)
else:
return Objective(state,
lambda: actions.look_for_pass_target(state),
lambda: True, 2)
elif state.is_nearest_ball(1):
return _jog_to_ball_objective(state)
else:
return _position_optimally_objective_goalie(state)
ball: Ball = state.world_view.ball.get_value()
# If in possession of the ball -> Pass to team mate
if state.is_near_ball(KICKABLE_MARGIN):
pass_target = _choose_pass_target(state)
if pass_target is not None:
debug_msg(
str(state.now()) +
" | in possession, pass target found -> pass to teammate",
"GOALIE")
return Objective(
state, lambda: actions.pass_to_player(
state, _choose_pass_target(state)), lambda: True, 1)
# No suitable pass target
debug_msg(
str(state.now()) +
" | in possession, pass target not found -> look for pass target",
"GOALIE")
return Objective(state, lambda: actions.look_for_pass_target(state),
lambda: True, 1)
# If ball coming to goalie inside box -> Catch ball
positions = ball.project_ball_position(2, 0)
if positions is not None and state.is_inside_own_box():
debug_msg(
str(state.now()) + " | Ball incoming inside box -> Catch ball",
"GOALIE")
ball_pos_1_tick: Coordinate = positions[0]
if ball_pos_1_tick.euclidean_distance_from(
state.position.get_value()) < CATCHABLE_MARGIN:
return Objective(
state, lambda: actions.catch_ball(state, ball_pos_1_tick),
lambda: True, 1)
# If ball coming towards us or ball will hit goal soon -> Intercept
if (ball.will_hit_goal_within(ticks=5)
or (state.is_nearest_ball(1) and state.is_ball_inside_own_box())):
debug_msg(
str(state.now()) +
" | ball coming towards us or ball will hit goal soon -> run to ball and catch!",
"GOALIE")
intercept_actions = actions.intercept_2(state, "catch")
if intercept_actions is not None:
return Objective(state, lambda: intercept_actions)
else:
return _rush_to_ball_objective(state)
# If position not alligned with ball y-position -> Adjust y-position
if state.position.is_value_known(
) and state.world_view.ball.is_value_known(
) and not configurations.USING_PASS_CHAIN_STRAT:
debug_msg(
str(state.now()) + " | Position not optimal -> adjust position",
"GOALIE")
return _position_optimally_objective_goalie(state)
# If nothing to do -> Face ball
debug_msg(str(state.now()) + " | Nothing to do -> Face ball", "GOALIE")
return Objective(state, lambda: actions.face_ball(state), lambda: True, 1)
def _choose_pass_target(state: PlayerState, must_pass: bool = False):
print("choose pass target")
"""
If uppaal has been generated recently -> Follow strat if applicable
If free targets forward -> Pass forward
If no free targets forward, but i am not marked -> dribble forward
If no free targets forward, but free targets behind, and i am marked -> Pass back
If no free targets and i am marked -> Try to dribble anyway
:return: Parse target or None, if dribble
"""
# For pass chain model, if an existing target is seen by player, pass ball
if len(state.passchain_targets) > 0:
print("passchain longer than 0")
for target in state.passchain_targets:
target: PrecariousData
if target.last_updated_time > state.now() - 40:
print("if target update time is later than 40 seconds ago")
target = state.find_teammate_closest_to(target.get_value(),
max_distance_delta=8.0)
if target is not None:
print("TORGET ACQUIRED : ", target)
return target
debug_msg(str(state.now()) + "Choosing pass target", "DRIBBLE_PASS_MODEL")
# Act according to Possession model
if state.dribble_or_pass_strat.is_value_known():
if state.dribble_or_pass_strat.is_value_known(state.now() - 8):
debug_msg(
"Following uppaal DribbleOrPass strategy :" +
str(state.dribble_or_pass_strat.get_value()),
"DRIBBLE_PASS_MODEL")
strat = state.dribble_or_pass_strat.get_value()
state.dribble_or_pass_strat = PrecariousData.unknown()
if DRIBBLE_INDICATOR in strat:
if not must_pass:
state.statistics.use_possession_strategy()
debug_msg(
str(state.now()) + " Dribble!", "DRIBBLE_PASS_MODEL")
return None
else:
match = re.match(r'.*\(([^,]*), ([^)]*)\)', strat)
x = float(match.group(1))
y = float(match.group(2))
target = state.find_teammate_closest_to(Coordinate(x, y),
max_distance_delta=3.0)
if target is not None:
debug_msg(
str(state.now()) +
" DRIBBLE_PASS_MODEL : Playing to :" +
str(Coordinate(x, y)), "DRIBBLE_PASS_MODEL")
# If target is outside the no no square then return target
i = -1 if state.world_view.side == "l" else 1
is_too_far_back = True if (state.world_view.side == "l" and target.coord.pos_x < -36) \
or (state.world_view.side == "r" and target.coord.pos_x > 36) else False
if (not is_too_far_back) and (not is_offside(
state, target)) and (target.coord.pos_y > -20
or target.coord.pos_y > 20):
state.statistics.use_possession_strategy()
return target
else:
debug_msg(
str(state.now()) + "No teammate matched :" +
str(Coordinate(x, y)) + " Visible: " +
str(state.world_view.get_teammates(
state.team_name, 10)), "DRIBBLE_PASS_MODEL")
# Discard strategy
state.statistics.discard_possession_strategy()
state.dribble_or_pass_strat = PrecariousData.unknown()
side = state.world_view.side
""" # TODO : TESTING ONLY ----------------------------------------------------------
teammates = state.world_view.get_teammates(state.team_name, 2)
if len(teammates) is not 0:
return choice(teammates)
# todo -------------------------------------------------------------------------- """
am_i_marked = state.world_view.is_marked(team=state.team_name,
max_data_age=4,
min_distance=4)
# If free targets forward -> Pass forward
forward_team_mates = state.world_view.get_non_offside_forward_team_mates(
state.team_name,
side,
state.position.get_value(),
max_data_age=4,
min_distance_free=2,
min_dist_from_me=2)
if len(forward_team_mates) > 0:
# If free team mates sort by closest to opposing teams goal
opposing_team_goal: Coordinate = Coordinate(
52.5, 0) if side == "l" else Coordinate(-52.5, 0)
debug_msg("forward_team_mates: " + str(forward_team_mates),
"PASS_TARGET")
good_target = list(
sorted(forward_team_mates,
key=lambda p: p.coord.euclidean_distance_from(
opposing_team_goal),
reverse=False))[0]
return good_target
# If no free targets forward, but i am not marked -> dribble forward
if len(forward_team_mates) < 1 and not am_i_marked:
debug_msg("No free targets forward -> Dribble!", "PASS_TARGET")
if must_pass:
tms = state.world_view.get_teammates(state.team_name, 5)
if len(tms) > 0:
return random.choice(tms)
return None
# If no free targets forward, but free targets behind, and i am marked -> Pass back
behind_team_mates = state.world_view.get_free_behind_team_mates(
state.team_name,
side,
state.position.get_value(),
max_data_age=3,
min_distance_free=3,
min_dist_from_me=3)
if len(behind_team_mates) > 0:
# Get the player furthest forward and free
opposing_team_goal: Coordinate = Coordinate(
52.5, 0) if side == "l" else Coordinate(-52.5, 0)
debug_msg("Behind_team_mates: " + str(behind_team_mates),
"PASS_TARGET")
good_target = list(
sorted(behind_team_mates,
key=lambda p: p.coord.euclidean_distance_from(
opposing_team_goal),
reverse=False))[0]
return good_target
# If no free targets and i am marked -> Try to dribble anyway
debug_msg("No free targets forward and i am marked -> Dribble anyway!",
"PASS_TARGET")
if must_pass:
tms = state.world_view.get_player_observations(state.team_name, 3)
if len(tms) > 0:
return random.choice(tms)
return None
def _update_dribble_or_pass_model(state: PlayerState, model: UppaalModel):
# This function edits the UPPAAL file to represent the current state of the game
# Amount of ticks to forecast game state
# This should be the expected time that it takes to generate the strategy
FORECAST_TICKS = 6
team_mates = state.world_view.get_teammates_precarious(state.team_name,
10,
min_dist=5)
opponents = state.world_view.get_opponents_precarious(state.team_name,
10,
min_dist=0)
# Forecast position of the ball possessor
if state.get_y_north_velocity_vector() is not None:
possessor_forecasted = (
state.position.get_value().vector() +
state.get_y_north_velocity_vector() * FORECAST_TICKS).coord()
else:
possessor_forecasted = state.position.get_value()
# Forecast position of other players
forecasted_team_positions = list(
map(
lambda p: p.get_value().forecasted_position(
(state.now() - p.last_updated_time) + FORECAST_TICKS),
team_mates))
forecasted_opponent_positions = list(
map(
lambda p: p.get_value().forecasted_position(
(state.now() - p.last_updated_time) + FORECAST_TICKS),
opponents))
if state.players_close_behind > 0:
forecasted_opponent_positions.append(
Coordinate(
possessor_forecasted.pos_x - 1,
possessor_forecasted.pos_y,
))
# Convert to textual format understandable by uppaal
team_pos_value = _to_3d_double_array_coordinate(forecasted_team_positions)
opponent_pos_value = _to_3d_double_array_coordinate(
forecasted_opponent_positions)
possessor_val = _to_2d_double_array_coordinate(possessor_forecasted)
model.set_global_declaration_value("TEAM_MATES",
len(forecasted_team_positions))
model.set_global_declaration_value("OPPONENTS",
len(forecasted_opponent_positions))
model.set_global_declaration_value("team_pos[TEAM_MATES][2]",
team_pos_value)
model.set_global_declaration_value("opponent_pos[OPPONENTS][2]",
opponent_pos_value)
model.set_global_declaration_value("possessor[2]", possessor_val)
if state.is_test_player(): # Debugging
all_posis = list(
map(lambda p: p.get_value().coord, state.world_view.other_players))
debug_msg(
str(state.now()) + " All positions: " + str(all_posis),
"DRIBBLE_PASS_MODEL")
debug_msg(
str(state.now()) + " Forecasted team positions: " +
str(team_pos_value), "DRIBBLE_PASS_MODEL")
debug_msg(
str(state.now()) + " Forecasted opponent positions: " +
str(opponent_pos_value), "DRIBBLE_PASS_MODEL")
debug_msg(
str(state.now()) + " Forecasted possessor position: " +
str(possessor_val), "DRIBBLE_PASS_MODEL")
return forecasted_team_positions
def parse_file(self):
from lexer import lexer, token
from parser import parser
from utils import function, debug_msg
filename = self.filename
entry = global_tbl_entry()
print "parser: Lexing on file:", self.filename
body = file(self.filename, 'rt').read()
print 'parser: rORIGINAL:', repr(body)
print
print
print 'parser: -------------TOKENS:------------------'
lexer = lexer(body)
parser = parser()
func_name = None
curly_brace = 0
small_brace = 0
args = ""
for token in lexer:
#first find a function name store id and lookahead if brace move to state
print "parser: parsing token: ", token.get_value()," of type: ", token.get_type()
if parser.get_state() == "Begin":
print "parser: parser state Begin"
if token.get_type() == "Id":
parser.set_state("FuncName")
func_name = token.get_value()
elif parser.get_state() == "FuncName":
type(token.get_value())
type(token.get_type())
if token.get_value() == "(":
parser.set_state("FuncArgs")
elif token.get_type() == "Id":
parser.set_state("FuncName")
func_name = token.get_value()
else:
parser.set_state("Begin")
elif parser.get_state() == "FuncArgs":
if token.get_value() == ")":
parser.set_state("FuncBody")
elif token.get_value() == ",":
print "parser: Comma"
elif token.get_type() == "Id":
args+=token.get_value()
else:
print "parser: found: ", token.get_value()," while parser in state Args"
#reset parser
parser.set_state("Begin")
elif parser.get_state() == "FuncBody":
if token.get_value() == "{":
#confirmed function update everything
parser.set_state("Function")
aFunction = function()
aFunction.set_name(func_name)
aFunction.set_args(args);
print "parser: ***********Found a function by name : ", func_name, " **************************"
curly_brace += 1
#insert function
elif token.get_type() == "Id":
parser.set_state("FuncName")
func_name = token.get_value()
else:
parser.set_state("Begin")
elif parser.get_state() == "Function":
if token.get_value() == "}":
curly_brace -= 1
if curly_brace == 0:
print "parser: ********* Finished function: ",func_name ,"******************"
#function ends update everything
parser.set_state("Begin")
#close messages for this func
elif token.get_value() == "{":
curly_brace += 1
elif token.get_type() == "Debug":
parser.set_state("Debug")
dbg_msg = debug_msg()
print "MAcro Name ===================================================",token.get_value()
dbg_msg.set_macro_name(token.get_value())
elif token.get_type() == "Entry/Exit":
parser.set_state("DebugEntry/Exit")
dbg_msg = debug_msg()
print "MAcro Name ==================================================",token.get_value()
dbg_msg.set_macro_name(token.get_value())
elif parser.get_state() == "Debug":
if token.get_value() == "(":
if small_brace == 0:
parser.set_state("DbgMsg")
small_brace += 1
elif parser.get_state() == "DbgMsg":
if token.get_type() == "Quotes":
dbg_msg.set_message(token.get_value())
elif token.get_value() == ")":
small_brace -= 1
if small_brace == 0:
print "parser: **** Finished one Debug message***** "
insert_in_tbl(entry, dbg_msg, aFunction);
parser.set_state("Function")
else:
parser.set_state("DbgMsgArgs")
elif parser.get_state() == "DbgMsgArgs":
if token.get_value() == ")":
small_brace -= 1
if small_brace == 0:
print "parser: **** Finished one Debug message***** "
insert_in_tbl(entry, dbg_msg,aFunction);
parser.set_state("Function")
if token.get_value() == "(":
small_brace += 1
if token.get_type() in ["Id","Quotes"]:
dbg_msg.append_args(token.get_value())
print "parser: ======TESTING: Token value: ",token.get_value()
print "parser: ======TESTING: Token type: ",token.get_type()
print "parser: ***********all tables ***********************"
print
print "parser: -----------Rest-------------------"
for val in entry.rest_in_list:
print "parser: Function: ", val.get_function().get_func_name(), " Message: ", val.get_dbg_msg().get_message()," Debug Args: ", val.get_dbg_msg().get_args()
print
print "parser: ----------cmplt_msg_tbl--------------------"
for hash_key in entry.cmplt_msg_tbl.keys():
val = entry.cmplt_msg_tbl[hash_key]
print "parser: Function: ", val.get_function().get_func_name(), " Message: ", val.get_dbg_msg().get_message()," Debug Args: ", val.get_dbg_msg().get_args()
print
print "parser: ----------partial_msg_tbl--------------------"
for hash_key in entry.partial_msg_tbl.keys():
print hash_key
val = entry.partial_msg_tbl[hash_key]
print "parser: Function: ", val.get_function().get_func_name(), " Message: ", val.get_dbg_msg().get_message()," Debug Args: ", val.get_dbg_msg().get_args()
return entry
def approximate_position_direction_speed(
self, minimum_data_points_used) -> (Coordinate, int, int):
if self.projection is not None:
return self.projection
if len(self.position_history.list) <= 1:
return None, None, None # No information can be deduced about movement of ball
history = self.position_history.list
time_1 = history[0][1]
time_2 = history[1][1]
c1: Coordinate = history[0][0]
c2: Coordinate = history[1][0]
first_coord = c1
last_coord = c2
if time_1 == time_2 or c1.euclidean_distance_from(
c2) < 0.1 or c1.euclidean_distance_from(c2) > 4.2:
return c1, 0, 0
final_speed = (c1.euclidean_distance_from(c2) /
(time_1 - time_2)) * BALL_DECAY
final_direction = degrees(calculate_full_origin_angle_radians(c1, c2))
angles = [final_direction] # Used for calculating 'average' angle
max_deviation = 50 # angle deviation
max_speed_deviation = 0.8
age = time_1 - time_2
max_age = 20
def allowed_angle_deviation(index):
return 90 if index == 0 else max_deviation
previous_dist = final_speed
data_points_used = 2
for i, pos_and_time in enumerate(islice(history, 2, len(history))):
c1 = c2
c2 = pos_and_time[0]
time_1 = time_2
time_2 = pos_and_time[1]
age += time_1 - time_2
dist = c1.euclidean_distance_from(c2)
if time_1 == time_2 or dist <= 0.05 or (
dist < 0.3 and previous_dist < 0.3) or dist > 4.2:
break
previous_dist = dist
# calculate angle from point observed 2 ticks prior
direction = degrees(
calculate_full_origin_angle_radians(history[i][0], c2))
direction_similar = is_angle_in_range(
direction,
(final_direction - allowed_angle_deviation(i)) % 360,
(final_direction + allowed_angle_deviation(i)) % 360)
speed = (dist / (time_1 - time_2)) * pow(BALL_DECAY, age)
speed_similar = (final_speed - max_speed_deviation) <= speed <= (
final_speed + max_speed_deviation)
if direction_similar and speed_similar and age < max_age:
data_points_used += 1
last_coord = c2
angles.append(
degrees(
calculate_full_origin_angle_radians(first_coord, c2)))
final_speed = (final_speed * age + speed) / (
age + 1) # calculate average with new value
final_direction = find_mean_angle(angles, 179)
else:
debug_msg(
"Previous points did not match. Speed : " + str(speed) +
"vs." + str(final_speed) + "| Direction :" +
str(direction) + "vs." + str(final_direction) + "| age: " +
str(age) + str(c1) + str(c2), "POSITIONAL")
break # This vector did not fit projection, so no more history is used in the projection
if data_points_used < minimum_data_points_used:
return None, None, None
debug_msg(
"Prediction based on {0} of these data points: {1}".format(
data_points_used, self.position_history), "INTERCEPTION")
direction = degrees(
calculate_full_origin_angle_radians(first_coord, last_coord))
self.projection = self.position_history.list[0][
0], direction, final_speed
return self.position_history.list[0][0], direction, final_speed
