diff --git a/base/basic_tackle.py b/base/basic_tackle.py index 886fd4ff..dff82237 100644 --- a/base/basic_tackle.py +++ b/base/basic_tackle.py @@ -24,13 +24,13 @@ def execute(self, agent: 'PlayerAgent'): wm = agent.world() use_foul = False - tackle_prob = wm.self().tackle_probability() + tackle_prob = wm.self().tackle_probability - if wm.self().card() == Card.NO_CARD \ - and (wm.ball().pos().x() > SP.our_penalty_area_line_x() + 0.5 - or wm.ball().pos().abs_y() > SP.penalty_area_half_width() + 0.5) \ - and tackle_prob < wm.self().foul_probability(): - tackle_prob = wm.self().foul_probability() + if wm.self().card == Card.NO_CARD \ + and (wm.ball().pos.x() > SP.our_penalty_area_line_x() + 0.5 + or wm.ball().pos.abs_y() > SP.penalty_area_half_width() + 0.5) \ + and tackle_prob < wm.self().foul_probability: + tackle_prob = wm.self().foul_probability use_foul = True if tackle_prob < self._min_prob: @@ -44,7 +44,7 @@ def execute(self, agent: 'PlayerAgent'): self_goal = False if self_reach_point.x() < - SP.pitch_half_length(): - ball_ray = Ray2D(wm.ball().pos(), wm.ball().vel().th()) + ball_ray = Ray2D(wm.ball().pos, wm.ball().vel.th()) goal_line = Line2D(Vector2D(-SP.pitch_half_length(), +10), Vector2D(-SP.pitch_half_length(), -10)) @@ -57,8 +57,8 @@ def execute(self, agent: 'PlayerAgent'): or self_goal or (opp_min < self_min - 3 and opp_min < mate_min - 3) or (self_min >= 5 - and wm.ball().pos().dist2(SP.their_team_goal_pos()) < 10 **2 - and ((SP.their_team_goal_pos() - wm.self().pos()).th() - wm.self().body()).abs() < 45.)): + and wm.ball().pos.dist2(SP.their_team_goal_pos()) < 10 **2 + and ((SP.their_team_goal_pos() - wm.self().pos).th() - wm.self().body).abs() < 45.)): return False @@ -69,10 +69,10 @@ def executeV14(self, agent: 'PlayerAgent', use_foul: bool): result = TackleGenerator.instance().best_result(wm) - ball_next = wm.ball().pos() + result._ball_vel + ball_next = wm.ball().pos + result._ball_vel log.debug_client().add_message(f"Basic{'Foul' if use_foul else 'Tackle'}{result._tackle_angle.degree()}") - tackle_dir = (result._tackle_angle - wm.self().body()).degree() + tackle_dir = (result._tackle_angle - wm.self().body).degree() agent.do_tackle(tackle_dir, use_foul) agent.set_neck_action(NeckTurnToPoint(ball_next)) diff --git a/base/bhv_block.py b/base/bhv_block.py index e1e1a02a..f734a431 100644 --- a/base/bhv_block.py +++ b/base/bhv_block.py @@ -26,12 +26,12 @@ def execute(self, agent: 'PlayerAgent'): tm = wm.our_player(unum) if tm is None: continue - if tm.unum() < 1: + if tm.unum < 1: continue for c in range(1, 40): dribble_pos = ball_pos + Vector2D.polar2vector(c * dribble_speed_etimate, dribble_angle_estimate) - turn_cycle = Tools.predict_player_turn_cycle(tm.player_type(), tm.body(), tm.vel().r(), tm.pos().dist(dribble_pos), (dribble_pos - tm.pos()).th(), 0.2, False) - tm_cycle = tm.player_type().cycles_to_reach_distance(tm.inertia_point(opp_min).dist(dribble_pos)) + turn_cycle + turn_cycle = Tools.predict_player_turn_cycle(tm.player_type, tm.body, tm.vel.r(), tm.pos.dist(dribble_pos), (dribble_pos - tm.pos).th(), 0.2, False) + tm_cycle = tm.player_type.cycles_to_reach_distance(tm.inertia_point(opp_min).dist(dribble_pos)) + turn_cycle if tm_cycle <= opp_min + c: if tm_cycle < block_cycle: block_cycle = tm_cycle diff --git a/base/bhv_move.py b/base/bhv_move.py index ed9e9c51..a70f0700 100644 --- a/base/bhv_move.py +++ b/base/bhv_move.py @@ -57,13 +57,13 @@ def execute(self, agent: 'PlayerAgent'): agent.set_neck_action(NeckTurnToBall()) return True st = StrategyFormation().i() - target = st.get_pos(agent.world().self().unum()) + target = st.get_pos(agent.world().self().unum) log.debug_client().set_target(target) log.debug_client().add_message('bhv_move') dash_power, self._in_recovery_mode = get_normal_dash_power(wm, self._in_recovery_mode) - dist_thr = wm.ball().dist_from_self() * 0.1 + dist_thr = wm.ball().dist_from_self * 0.1 if dist_thr < 1.0: dist_thr = 1.0 diff --git a/base/decision.py b/base/decision.py index ede8096f..c40e8425 100644 --- a/base/decision.py +++ b/base/decision.py @@ -27,7 +27,7 @@ def get_decision(agent: 'PlayerAgent'): st = StrategyFormation().i() st.update(wm) - if wm.self().goalie(): + if wm.self().goalie: if goalie_decision.decision(agent): return True @@ -35,10 +35,10 @@ def get_decision(agent: 'PlayerAgent'): if Bhv_SetPlay().execute(agent): return True - log.sw_log().team().add_text(f'is kickable? dist {wm.ball().dist_from_self()} ' - f'ka {wm.self().player_type().kickable_area()} ' - f'seen pos count {wm.ball().seen_pos_count()} ' - f'is? {wm.self()._kickable}') + log.sw_log().team().add_text(f'is kickable? dist {wm.ball().dist_from_self} ' + f'ka {wm.self().player_type.kickable_area()} ' + f'seen pos count {wm.ball().seen_pos_count} ' + f'is? {wm.self().is_kickable()}') if wm.self().is_kickable(): return BhvKick().execute(agent) if BhvMove().execute(agent): diff --git a/base/generator_action.py b/base/generator_action.py index 964aed07..a9ce9510 100644 --- a/base/generator_action.py +++ b/base/generator_action.py @@ -29,7 +29,7 @@ def __init__(self): def calculate_min_opp_dist(self, wm: 'WorldModel' = None): if wm is None: return 0.0 - return min([opp.pos().dist(self.target_ball_pos) for opp in wm.opponents() if opp is not None and opp.unum() > 0]) + return min([opp.pos.dist(self.target_ball_pos) for opp in wm.opponents() if opp is not None and opp.unum > 0]) def evaluate(self, wm: 'WorldModel' = None): self.min_opp_dist = self.calculate_min_opp_dist(wm) @@ -105,10 +105,10 @@ def __init__(self): def can_opponent_cut_ball(self, wm: 'WorldModel', ball_pos, cycle): for unum in range(1, 12): opp: 'PlayerObject' = wm.their_player(unum) - if opp.unum() == 0: + if opp.unum == 0: continue - opp_cycle = opp.pos().dist(ball_pos) - opp.player_type().kickable_area() - opp_cycle /= opp.player_type().real_speed_max() + opp_cycle = opp.pos.dist(ball_pos) - opp.player_type.kickable_area() + opp_cycle /= opp.player_type.real_speed_max() if opp_cycle < cycle: return True return False diff --git a/base/generator_clear.py b/base/generator_clear.py index 06c85e8d..6928c536 100644 --- a/base/generator_clear.py +++ b/base/generator_clear.py @@ -30,7 +30,7 @@ def generator(self, wm: 'WorldModel'): def add_to_candidate(self, wm: 'WorldModel', ball_pos: Vector2D): action = KickAction() action.target_ball_pos = ball_pos - action.start_ball_pos = wm.ball().pos() + action.start_ball_pos = wm.ball().pos.copy() action.start_ball_speed = 2.5 action.type = KickActionType.Clear action.index = self.index @@ -58,7 +58,7 @@ def generate_clear_ball(self, wm: 'WorldModel'): angle_step = 360.0 / angle_div for a in range(angle_div): - ball_pos = wm.ball().pos() + ball_pos = wm.ball().pos.copy() angle = AngleDeg(a * angle_step) speed = 2.5 log.sw_log().clear().add_text(f'========= a:{a} speed:{speed} angle:{angle} ball:{ball_pos}') @@ -76,12 +76,12 @@ def generate_clear_ball(self, wm: 'WorldModel'): for opp in wm.opponents(): if not opp: continue - if opp.unum() <= 0: + if opp.unum <= 0: continue - opp_cycle = opp.pos().dist(ball_pos) / opp.player_type().real_speed_max() - opp.player_type().kickable_area() - opp_cycle -= min(0, opp.pos_count()) + opp_cycle = opp.pos.dist(ball_pos) / opp.player_type.real_speed_max() - opp.player_type.kickable_area() + opp_cycle -= min(0, opp.pos_count) if opp_cycle <= c: - receiver_opp = opp.unum() + receiver_opp = opp.unum break if receiver_opp != 0: break diff --git a/base/generator_dribble.py b/base/generator_dribble.py index 71527811..ce90e0cc 100644 --- a/base/generator_dribble.py +++ b/base/generator_dribble.py @@ -43,19 +43,19 @@ def generate_simple_dribble(self, wm: 'WorldModel'): angle_step = 360.0 / angle_div sp = SP.i() - ptype = wm.self().player_type() + ptype = wm.self().player_type - my_first_speed = wm.self().vel().r() + my_first_speed = wm.self().vel.r() for a in range(angle_div): - dash_angle = wm.self().body() + (angle_step * a) + dash_angle = wm.self().body + (angle_step * a) - if wm.self().pos().x() < 16.0 and dash_angle.abs() > 100.0: + if wm.self().pos.x() < 16.0 and dash_angle.abs() > 100.0: if debug_dribble: log.sw_log().dribble().add_text( '#dash angle:{} cancel is not safe1'.format(dash_angle)) continue - if wm.self().pos().x() < -36.0 and wm.self().pos().abs_y() < 20.0 and dash_angle.abs() > 45.0: + if wm.self().pos.x() < -36.0 and wm.self().pos.abs_y() < 20.0 and dash_angle.abs() > 45.0: if debug_dribble: log.sw_log().dribble().add_text( '#dash angle:{} cancel is not safe2'.format(dash_angle)) continue @@ -93,7 +93,7 @@ def simulate_kick_turns_dashes(self, wm: 'WorldModel', dash_angle, n_turn): if debug_dribble: log.sw_log().dribble().add_text( '##self_cache:{}'.format(self_cache)) sp = SP.i() - ptype = wm.self().player_type() + ptype = wm.self().player_type # trap_rel = Vector2D.polar2vector(ptype.playerSize() + ptype.kickableMargin() * 0.2 + SP.ball_size(), dash_angle) trap_rel = Vector2D.polar2vector(ptype.player_size() + ptype.kickable_margin() * 0.2 + 0, dash_angle) @@ -113,9 +113,9 @@ def simulate_kick_turns_dashes(self, wm: 'WorldModel', dash_angle, n_turn): continue term = (1.0 - pow(sp.ball_decay(), 1 + n_turn + n_dash ) ) / (1.0 - sp.ball_decay()) - first_vel: Vector2D = (ball_trap_pos - wm.ball().pos()) / term - kick_accel: Vector2D = first_vel - wm.ball().vel() - kick_power = kick_accel.r() / wm.self().kick_rate() + first_vel: Vector2D = (ball_trap_pos - wm.ball().pos) / term + kick_accel: Vector2D = first_vel - wm.ball().vel + kick_power = kick_accel.r() / wm.self().kick_rate if kick_power > sp.max_power() or kick_accel.r2() > pow(sp.ball_accel_max(), 2) or first_vel.r2() > pow( sp.ball_speed_max(), 2): @@ -126,7 +126,7 @@ def simulate_kick_turns_dashes(self, wm: 'WorldModel', dash_angle, n_turn): self.debug_list.append((self.index, ball_trap_pos, False)) continue - if (wm.ball().pos() + first_vel).dist2(self_cache[0]) < pow(ptype.player_size() + sp.ball_size() + 0.1, 2): + if (wm.ball().pos + first_vel).dist2(self_cache[0]) < pow(ptype.player_size() + sp.ball_size() + 0.1, 2): if debug_dribble: log.sw_log().dribble().add_text( '#index:{} target:{} in body, power:{}, accel:{}, vel:{}'.format( @@ -137,9 +137,9 @@ def simulate_kick_turns_dashes(self, wm: 'WorldModel', dash_angle, n_turn): if self.check_opponent(wm, ball_trap_pos, 1 + n_turn + n_dash): candidate = KickAction() candidate.type = KickActionType.Dribble - candidate.start_ball_pos = wm.ball().pos() + candidate.start_ball_pos = wm.ball().pos.copy() candidate.target_ball_pos = ball_trap_pos - candidate.target_unum = wm.self().unum() + candidate.target_unum = wm.self().unum candidate.start_ball_speed = first_vel.r() candidate.index = self.index candidate.evaluate(wm) @@ -158,14 +158,14 @@ def simulate_kick_turns_dashes(self, wm: 'WorldModel', dash_angle, n_turn): def create_self_cache(self, wm: 'WorldModel', dash_angle, n_turn, n_dash, self_cache): sp = SP.i() - ptype = wm.self().player_type() + ptype = wm.self().player_type self_cache.clear() - stamina_model = wm.self().stamina_model() + stamina_model = wm.self().stamina_model.copy() - my_pos = wm.self().pos() - my_vel = wm.self().vel() + my_pos = wm.self().pos.copy() + my_vel = wm.self().vel.copy() my_pos += my_vel my_vel *= ptype.player_decay() @@ -194,31 +194,31 @@ def create_self_cache(self, wm: 'WorldModel', dash_angle, n_turn, n_dash, self_c def check_opponent(self, wm: 'WorldModel', ball_trap_pos: Vector2D, dribble_step: int): sp = SP.i() - ball_move_angle:AngleDeg = (ball_trap_pos - wm.ball().pos()).th() + ball_move_angle:AngleDeg = (ball_trap_pos - wm.ball().pos).th() for o in range(12): opp: 'PlayerObject' = wm.their_player(o) - if opp is None or opp.unum() == 0: + if opp is None or opp.unum == 0: if debug_dribble: log.sw_log().dribble().add_text( "###OPP {} is ghost".format(o)) continue - if opp.dist_from_self() > 20.0: + if opp.dist_from_self > 20.0: if debug_dribble: log.sw_log().dribble().add_text( "###OPP {} is far".format(o)) continue - ptype = opp.player_type() + ptype = opp.player_type control_area = (sp._catchable_area - if opp.goalie() + if opp.goalie and ball_trap_pos.x() > sp.their_penalty_area_line_x() and ball_trap_pos.abs_y() < sp.penalty_area_half_width() else ptype.kickable_area()) opp_pos = opp.inertia_point( dribble_step ) - ball_to_opp_rel = (opp.pos() - wm.ball().pos()).rotated_vector(-ball_move_angle) + ball_to_opp_rel = (opp.pos - wm.ball().pos).rotated_vector(-ball_move_angle) if ball_to_opp_rel.x() < -4.0: if debug_dribble: @@ -237,9 +237,9 @@ def check_opponent(self, wm: 'WorldModel', ball_trap_pos: Vector2D, dribble_step dash_dist -= 0.2 n_dash = ptype.cycles_to_reach_distance(dash_dist) - n_turn = 1 if opp.body_count() > 1 else Tools.predict_player_turn_cycle(ptype, - opp.body(), - opp.vel().r(), + n_turn = 1 if opp.body_count > 1 else Tools.predict_player_turn_cycle(ptype, + opp.body, + opp.vel.r(), target_dist, (ball_trap_pos - opp_pos).th(), control_area, @@ -258,9 +258,9 @@ def check_opponent(self, wm: 'WorldModel', ball_trap_pos: Vector2D, dribble_step bonus_step = -5 if ball_to_opp_rel.x() > 0.5: - bonus_step += smath.bound(0, opp.pos_count(), 8) + bonus_step += smath.bound(0, opp.pos_count, 8) else: - bonus_step += smath.bound(0, opp.pos_count(), 4) + bonus_step += smath.bound(0, opp.pos_count, 4) if n_step - bonus_step <= dribble_step: if debug_dribble: diff --git a/base/generator_pass.py b/base/generator_pass.py index ece617c5..f5693402 100644 --- a/base/generator_pass.py +++ b/base/generator_pass.py @@ -30,9 +30,9 @@ def generator(self, wm: 'WorldModel'): self.update_receivers(wm) for r in self.receivers: - log.sw_log().pass_().add_text(f'=============== Lead Pass to {r.unum()} pos: {r.pos()}') + log.sw_log().pass_().add_text(f'=============== Lead Pass to {r.unum} pos: {r.pos}') # if self.best_pass is not None \ - # and r.pos().x() < self.best_pass.target_ball_pos.x() - 5: + # and r.pos.x() < self.best_pass.target_ball_pos.x() - 5: # break self.generate_direct_pass(wm, r) self.generate_lead_pass(wm, r) @@ -59,61 +59,61 @@ def update_receivers(self, wm: 'WorldModel'): if tm is None: log.sw_log().pass_().add_text('-----<<< TM is none') continue - if tm.unum() <= 0: - log.sw_log().pass_().add_text(f'-----<<< TM unum is {tm.unum()}') + if tm.unum <= 0: + log.sw_log().pass_().add_text(f'-----<<< TM unum is {tm.unum}') continue - if tm.unum() == wm.self().unum(): - log.sw_log().pass_().add_text(f'-----<<< TM unum is {tm.unum()} (self)') + if tm.unum == wm.self().unum: + log.sw_log().pass_().add_text(f'-----<<< TM unum is {tm.unum} (self)') continue - if tm.pos_count() > 10: - log.sw_log().pass_().add_text(f'-----<<< TM unum pos count {tm.pos_count()}') + if tm.pos_count > 10: + log.sw_log().pass_().add_text(f'-----<<< TM unum pos count {tm.pos_count}') continue if tm.is_tackling(): log.sw_log().pass_().add_text(f'-----<<< TM is tackling') continue - if tm.pos().x() > wm.offside_line_x(): - log.sw_log().pass_().add_text(f'-----<<< TM is in offside {tm.pos().x()} > {wm.offside_line_x()}') + if tm.pos.x() > wm.offside_line_x(): + log.sw_log().pass_().add_text(f'-----<<< TM is in offside {tm.pos.x()} > {wm.offside_line_x()}') continue - if tm.goalie() and tm.pos().x() < sp.our_penalty_area_line_x() + 15: - log.sw_log().pass_().add_text(f'-----<<< TM is goalie and danger {tm.pos().x()} < {sp.our_penalty_area_line_x() + 15}') + if tm.goalie and tm.pos.x() < sp.our_penalty_area_line_x() + 15: + log.sw_log().pass_().add_text(f'-----<<< TM is goalie and danger {tm.pos.x()} < {sp.our_penalty_area_line_x() + 15}') continue - log.sw_log().pass_().add_text(f'--->>>>> TM {tm.unum()} is added') + log.sw_log().pass_().add_text(f'--->>>>> TM {tm.unum} is added') self.receivers.append(tm) - self.receivers = sorted(self.receivers, key=lambda p: p.pos().x(), reverse=True) + self.receivers = sorted(self.receivers, key=lambda p: p.pos.x(), reverse=True) def generate_direct_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): sp = SP.i() min_receive_step = 3 max_direct_pass_dist = 0.8 * smath.inertia_final_distance(sp.ball_speed_max(), sp.ball_decay()) max_receive_ball_speed = sp.ball_speed_max() * pow(sp.ball_decay(), min_receive_step) - min_direct_pass_dist = receiver.player_type().kickable_area() * 2.2 - if receiver.pos().x() > sp.pitch_half_length() - 1.5 \ - or receiver.pos().x() < -sp.pitch_half_length() + 5.0 \ - or receiver.pos().abs_y() > sp.pitch_half_width() - 1.5: + min_direct_pass_dist = receiver.player_type.kickable_area() * 2.2 + if receiver.pos.x() > sp.pitch_half_length() - 1.5 \ + or receiver.pos.x() < -sp.pitch_half_length() + 5.0 \ + or receiver.pos.abs_y() > sp.pitch_half_width() - 1.5: if debug_pass: - log.sw_log().pass_().add_text( '#DPass to {} {}, out of field'.format(receiver.unum(), receiver.pos())) + log.sw_log().pass_().add_text( '#DPass to {} {}, out of field'.format(receiver.unum, receiver.pos)) return # TODO sp.ourTeamGoalPos() - if receiver.pos().x() < wm.ball().pos().x() + 1.0 \ - and receiver.pos().dist2(Vector2D(-52.5, 0)) < pow(18.0, 2): + if receiver.pos.x() < wm.ball().pos.x() + 1.0 \ + and receiver.pos.dist2(Vector2D(-52.5, 0)) < pow(18.0, 2): if debug_pass: - log.sw_log().pass_().add_text( '#DPass to {} {}, danger near goal'.format(receiver.unum(), receiver.pos())) + log.sw_log().pass_().add_text( '#DPass to {} {}, danger near goal'.format(receiver.unum, receiver.pos)) return - ptype = receiver.player_type() - max_ball_speed = wm.self().kick_rate() * sp.max_power() + ptype = receiver.player_type + max_ball_speed = wm.self().kick_rate * sp.max_power() if wm.game_mode().type() == GameModeType.PlayOn: max_ball_speed = sp.ball_speed_max() # TODO SP.defaultRealSpeedMax() min_ball_speed = 1.0 - receive_point = ptype.inertiaFinalPoint(receiver.pos(), receiver.vel()) - ball_move_dist = wm.ball().pos().dist(receive_point) + receive_point = ptype.inertiaFinalPoint(receiver.pos, receiver.vel) + ball_move_dist = wm.ball().pos.dist(receive_point) if ball_move_dist < min_direct_pass_dist or max_direct_pass_dist < ball_move_dist: if debug_pass: - log.sw_log().pass_().add_text( '#DPass to {} {}, far or close'.format(receiver.unum(), receiver.pos())) + log.sw_log().pass_().add_text( '#DPass to {} {}, far or close'.format(receiver.unum, receiver.pos)) return if wm.game_mode().type().is_goal_kick() \ @@ -121,20 +121,20 @@ def generate_direct_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): and receive_point.abs_y() < sp.penalty_area_half_width() + 1.0: if debug_pass: log.sw_log().pass_().add_text( - '#DPass to {} {}, in penalty area in goal kick mode'.format(receiver.unum(), receiver.pos())) + '#DPass to {} {}, in penalty area in goal kick mode'.format(receiver.unum, receiver.pos)) return max_receive_ball_speed = min(max_receive_ball_speed, ptype.kickable_area() + ( sp.max_dash_power() * ptype.dash_power_rate() * ptype.effort_max()) * 1.8) min_receive_ball_speed = ptype.real_speed_max() - ball_move_angle = (receive_point - wm.ball().pos()).th() + ball_move_angle = (receive_point - wm.ball().pos).th() min_ball_step = sp.ball_move_step(sp.ball_speed_max(), ball_move_dist) # TODO Penalty step start_step = max(max(min_receive_step, min_ball_step), 0) max_step = start_step + 2 - log.sw_log().pass_().add_text( '#DPass to {} {}'.format(receiver.unum(), receiver.pos())) + log.sw_log().pass_().add_text( '#DPass to {} {}'.format(receiver.unum, receiver.pos)) self.create_pass(wm, receiver, receive_point, start_step, max_step, min_ball_speed, max_ball_speed, min_receive_ball_speed, @@ -151,9 +151,9 @@ def generate_lead_pass(self, wm: 'WorldModel', receiver): max_receive_ball_speed = sp.ball_speed_max() * pow(sp.ball_decay(), min_receive_step) max_player_distance = 35 - if receiver.pos().dist(wm.ball().pos()) > max_player_distance: + if receiver.pos.dist(wm.ball().pos) > max_player_distance: if debug_pass: - log.sw_log().pass_().add_text( '#####LPass to {} {}, player is far'.format(receiver.unum(), receiver.pos())) + log.sw_log().pass_().add_text( '#####LPass to {} {}, player is far'.format(receiver.unum, receiver.pos)) return abgle_divs = 8 @@ -161,8 +161,8 @@ def generate_lead_pass(self, wm: 'WorldModel', receiver): dist_divs = 4 dist_step = 1.1 - ptype = receiver.player_type() - max_ball_speed = wm.self().kick_rate() * sp.max_power() + ptype = receiver.player_type + max_ball_speed = wm.self().kick_rate * sp.max_power() if wm.game_mode().type() == GameModeType.PlayOn: max_ball_speed = sp.ball_speed_max() min_ball_speed = sp.default_player_speed_max() @@ -173,7 +173,7 @@ def generate_lead_pass(self, wm: 'WorldModel', receiver): our_goal = Vector2D(-52.5, 0) - angle_from_ball = (receiver.pos() - wm.ball().pos()).th() + angle_from_ball = (receiver.pos - wm.ball().pos).th() for d in range(1, dist_divs + 1): player_move_dist = dist_step * d a_step = 2 if player_move_dist * 2.0 * math.pi / abgle_divs < 0.6 else 1 @@ -182,47 +182,47 @@ def generate_lead_pass(self, wm: 'WorldModel', receiver): receive_point = receiver.inertia_point(1) + Vector2D.from_polar(player_move_dist, angle) move_dist_penalty_step = 0 - ball_move_line = Line2D(wm.ball().pos(), receive_point) - player_line_dist = ball_move_line.dist(receiver.pos()) + ball_move_line = Line2D(wm.ball().pos, receive_point) + player_line_dist = ball_move_line.dist(receiver.pos) move_dist_penalty_step = int(player_line_dist * 0.3) if receive_point.x() > sp.pitch_half_length() - 3.0 \ or receive_point.x() < -sp.pitch_half_length() + 5.0 \ or receive_point.abs_y() > sp.pitch_half_width() - 3.0: if debug_pass: - log.sw_log().pass_().add_text( '#####LPass to {} {}, out of field'.format(receiver.unum(), receive_point)) + log.sw_log().pass_().add_text( '#####LPass to {} {}, out of field'.format(receiver.unum, receive_point)) continue - if receive_point.x() < wm.ball().pos().x() \ + if receive_point.x() < wm.ball().pos.x() \ and receive_point.dist2(our_goal) < our_goal_dist_thr2: if debug_pass: - log.sw_log().pass_().add_text( '#####LPass to {} {}, pass is danger'.format(receiver.unum(), receive_point)) + log.sw_log().pass_().add_text( '#####LPass to {} {}, pass is danger'.format(receiver.unum, receive_point)) continue - if wm.game_mode().type() in [GameModeType.GoalKick_Right, GameModeType.GoalKick_Left] \ + if wm.game_mode().type().is_goal_kick() \ and receive_point.x() < sp.our_penalty_area_line_x() + 1.0 \ and receive_point.abs_y() < sp.penalty_area_half_width() + 1.0: if debug_pass: - log.sw_log().pass_().add_text( '#####LPass to {} {}, in penalty area'.format(receiver.unum(), receive_point)) + log.sw_log().pass_().add_text( '#####LPass to {} {}, in penalty area'.format(receiver.unum, receive_point)) return - ball_move_dist = wm.ball().pos().dist(receive_point) + ball_move_dist = wm.ball().pos.dist(receive_point) if ball_move_dist < min_leading_pass_dist or max_leading_pass_dist < ball_move_dist: if debug_pass: - log.sw_log().pass_().add_text( '#####LPass to {} {}, so far or so close'.format(receiver.unum(), receive_point)) + log.sw_log().pass_().add_text( '#####LPass to {} {}, so far or so close'.format(receiver.unum, receive_point)) continue nearest_receiver = Tools.get_nearest_teammate(wm, receive_point, self.receivers) - if nearest_receiver.unum() != receiver.unum(): + if nearest_receiver.unum != receiver.unum: if debug_pass: log.sw_log().pass_().add_text( - '#####LPass to {} {}, {} is closer than receiver '.format(receiver.unum(), receive_point, - nearest_receiver.unum())) + '#####LPass to {} {}, {} is closer than receiver '.format(receiver.unum, receive_point, + nearest_receiver.unum)) continue receiver_step = self.predict_receiver_reach_step(receiver, receive_point, True, 'L') + move_dist_penalty_step - ball_move_angle = (receive_point - wm.ball().pos()).th() + ball_move_angle = (receive_point - wm.ball().pos).th() min_ball_step = sp.ball_move_step(sp.ball_speed_max(), ball_move_dist) @@ -231,7 +231,7 @@ def generate_lead_pass(self, wm: 'WorldModel', receiver): # max_step = std::max(max_receive_step, start_step + 3); # else if debug_pass: - log.sw_log().pass_().add_text( '#####LPass to {} {}'.format(receiver.unum(), receive_point)) + log.sw_log().pass_().add_text( '#####LPass to {} {}'.format(receiver.unum, receive_point)) max_step = start_step + 3 self.create_pass(wm, receiver, receive_point, start_step, max_step, @@ -250,25 +250,25 @@ def generate_through_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): max_receive_ball_speed = sp.ball_speed_max() * pow(sp.ball_decay(), min_receive_step) max_player_distance = 35 - if receiver.pos().dist(wm.ball().pos()) > max_player_distance: + if receiver.pos.dist(wm.ball().pos) > max_player_distance: if debug_pass: - log.sw_log().pass_().add_text('#####TPass to {} {}, player is far'.format(receiver.unum(), receiver.pos())) + log.sw_log().pass_().add_text('#####TPass to {} {}, player is far'.format(receiver.unum, receiver.pos)) return - if receiver.pos().x() < teammate_min_x: + if receiver.pos.x() < teammate_min_x: if debug_pass: - log.sw_log().pass_().add_text('#####TPass to {} {}, player is far'.format(receiver.unum(), receiver.pos())) + log.sw_log().pass_().add_text('#####TPass to {} {}, player is far'.format(receiver.unum, receiver.pos)) return - if receiver.pos().x() < wm.offside_line_x() - 5.0: + if receiver.pos.x() < wm.offside_line_x() - 5.0: if debug_pass: - log.sw_log().pass_().add_text('#####TPass to {} {}, player is not close to offside line'.format(receiver.unum(), receiver.pos())) + log.sw_log().pass_().add_text('#####TPass to {} {}, player is not close to offside line'.format(receiver.unum, receiver.pos)) return - if receiver.pos().x() > wm.offside_line_x() - 0.5: + if receiver.pos.x() > wm.offside_line_x() - 0.5: if debug_pass: - log.sw_log().pass_().add_text('#####TPass to {} {}, player is in offside'.format(receiver.unum(), receiver.pos())) + log.sw_log().pass_().add_text('#####TPass to {} {}, player is in offside'.format(receiver.unum, receiver.pos)) return - if wm.ball().pos().x() < -10.0 or wm.ball().pos().x() > 30.0: + if wm.ball().pos.x() < -10.0 or wm.ball().pos.x() > 30.0: if debug_pass: - log.sw_log().pass_().add_text('#####TPass to {} {}, ball x is low or high'.format(receiver.unum(), receiver.pos())) + log.sw_log().pass_().add_text('#####TPass to {} {}, ball x is low or high'.format(receiver.unum, receiver.pos)) return min_angle = -30 @@ -277,8 +277,8 @@ def generate_through_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): dist_divs = 25 dist_step = 1.0 - ptype = receiver.player_type() - max_ball_speed = wm.self().kick_rate() * sp.max_power() + ptype = receiver.player_type + max_ball_speed = wm.self().kick_rate * sp.max_power() if wm.game_mode().type() == GameModeType.PlayOn: max_ball_speed = sp.ball_speed_max() min_ball_speed = sp.default_player_speed_max() @@ -289,46 +289,46 @@ def generate_through_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): our_goal = Vector2D(-52.5, 0) - angle_from_ball = (receiver.pos() - wm.ball().pos()).th() + angle_from_ball = (receiver.pos - wm.ball().pos).th() for d in range(5, dist_divs + 1): player_move_dist = dist_step * d for a in range(min_angle, max_angle + 1, angle_step): receive_point = receiver.inertia_point(1) + Vector2D.from_polar(player_move_dist, a) move_dist_penalty_step = 0 - ball_move_line = Line2D(wm.ball().pos(), receive_point) - player_line_dist = ball_move_line.dist(receiver.pos()) + ball_move_line = Line2D(wm.ball().pos, receive_point) + player_line_dist = ball_move_line.dist(receiver.pos) move_dist_penalty_step = int(player_line_dist * 0.3) if receive_point.x() > sp.pitch_half_length() - 3.0 \ or receive_point.x() < -sp.pitch_half_length() + 5.0 \ or receive_point.abs_y() > sp.pitch_half_width() - 3.0: if debug_pass: - log.sw_log().pass_().add_text('#####TPass to {} {}, out of field'.format(receiver.unum(), receive_point)) + log.sw_log().pass_().add_text('#####TPass to {} {}, out of field'.format(receiver.unum, receive_point)) continue if receive_point.x() < target_min_x: if debug_pass: - log.sw_log().pass_().add_text('#####TPass to {} {}, pass is danger'.format(receiver.unum(), receive_point)) + log.sw_log().pass_().add_text('#####TPass to {} {}, pass is danger'.format(receiver.unum, receive_point)) continue - ball_move_dist = wm.ball().pos().dist(receive_point) + ball_move_dist = wm.ball().pos.dist(receive_point) if ball_move_dist < min_pass_dist or max_pass_dist < ball_move_dist: if debug_pass: - log.sw_log().pass_().add_text('#####TPass to {} {}, so far or so close'.format(receiver.unum(), receive_point)) + log.sw_log().pass_().add_text('#####TPass to {} {}, so far or so close'.format(receiver.unum, receive_point)) continue nearest_receiver = Tools.get_nearest_teammate(wm, receive_point, self.receivers) - if nearest_receiver.unum() != receiver.unum(): + if nearest_receiver.unum != receiver.unum: if debug_pass: log.sw_log().pass_().add_text( - '#####TPass to {} {}, {} is closer than receiver '.format(receiver.unum(), receive_point, - nearest_receiver.unum())) + '#####TPass to {} {}, {} is closer than receiver '.format(receiver.unum, receive_point, + nearest_receiver.unum)) continue receiver_step = self.predict_receiver_reach_step(receiver, receive_point, True, 'T') + move_dist_penalty_step - ball_move_angle = (receive_point - wm.ball().pos()).th() + ball_move_angle = (receive_point - wm.ball().pos).th() min_ball_step = sp.ball_move_step(sp.ball_speed_max(), ball_move_dist) @@ -337,7 +337,7 @@ def generate_through_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): # max_step = std::max(max_receive_step, start_step + 3); # else if debug_pass: - log.sw_log().pass_().add_text('#####TPass to {} {}'.format(receiver.unum(), receive_point)) + log.sw_log().pass_().add_text('#####TPass to {} {}'.format(receiver.unum, receive_point)) max_step = start_step + 3 self.create_pass(wm, receiver, receive_point, start_step, max_step, @@ -347,11 +347,11 @@ def generate_through_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): 'T') def predict_receiver_reach_step(self, receiver, pos: Vector2D, use_penalty, pass_type): - ptype = receiver.player_type() + ptype = receiver.player_type target_dist = receiver.inertia_point(1).dist(pos) - n_turn = 1 if receiver.body_count() > 0 else Tools.predict_player_turn_cycle(ptype, receiver.body(), - receiver.vel().r(), target_dist, ( + n_turn = 1 if receiver.body_count > 0 else Tools.predict_player_turn_cycle(ptype, receiver.body, + receiver.vel.r(), target_dist, ( pos - receiver.inertia_point( 1)).th(), ptype.kickable_area(), False) @@ -363,9 +363,9 @@ def predict_receiver_reach_step(self, receiver, pos: Vector2D, use_penalty, pass if pass_type == 'L': dash_dist *= 1.05 - dash_angle = (pos - receiver.pos()).th() + dash_angle = (pos - receiver.pos).th() - if dash_angle.abs() > 90.0 or receiver.body_count() > 1 or (dash_angle - receiver.body()).abs() > 30.0: + if dash_angle.abs() > 90.0 or receiver.body_count > 1 or (dash_angle - receiver.body).abs() > 30.0: n_turn += 1 n_dash = ptype.cycles_to_reach_distance(dash_dist) @@ -388,8 +388,8 @@ def create_pass(self, wm: 'WorldModel', receiver, receive_point: Vector2D, log.sw_log().pass_().add_text( '##Pass {},to {} {}, step:{}, ball_speed:{}, first ball speed is low'.format( self.index, - receiver.unum(), - receiver.pos(), + receiver.unum, + receiver.pos, step, first_ball_speed)) self.debug_list.append((self.index, receive_point, False)) @@ -400,8 +400,8 @@ def create_pass(self, wm: 'WorldModel', receiver, receive_point: Vector2D, log.sw_log().pass_().add_text( '##Pass {},to {} {}, step:{}, ball_speed:{}, first ball speed is high'.format( self.index, - receiver.unum(), - receiver.pos(), + receiver.unum, + receiver.pos, step, first_ball_speed)) self.debug_list.append((self.index, receive_point, False)) @@ -414,8 +414,8 @@ def create_pass(self, wm: 'WorldModel', receiver, receive_point: Vector2D, log.sw_log().pass_().add_text( '##Pass {},to {} {}, step:{}, ball_speed:{}, rball_speed:{}, receive ball speed is low'.format( self.index, - receiver.unum(), - receiver.pos(), + receiver.unum, + receiver.pos, step, first_ball_speed, receive_ball_speed)) @@ -427,17 +427,17 @@ def create_pass(self, wm: 'WorldModel', receiver, receive_point: Vector2D, log.sw_log().pass_().add_text( '##Pass {},to {} {}, step:{}, ball_speed:{}, rball_speed:{}, receive ball speed is high'.format( self.index, - receiver.unum(), - receiver.pos(), + receiver.unum, + receiver.pos, step, first_ball_speed, receive_ball_speed)) self.debug_list.append((self.index, receive_point, False)) continue - kick_count = Tools.predict_kick_count(wm, wm.self().unum(), first_ball_speed, ball_move_angle) + kick_count = Tools.predict_kick_count(wm, wm.self().unum, first_ball_speed, ball_move_angle) - o_step, o_unum, o_intercepted_pos = self.predict_opponents_reach_step(wm, wm.ball().pos(), + o_step, o_unum, o_intercepted_pos = self.predict_opponents_reach_step(wm, wm.ball().pos, first_ball_speed, ball_move_angle, receive_point, step + (kick_count - 1) + 5, description) @@ -453,7 +453,7 @@ def create_pass(self, wm: 'WorldModel', receiver, receive_point: Vector2D, if debug_pass: log.sw_log().pass_().add_text( '------<<<<>>>> OK Pass {} to {} {}, opp {} step {} max_step {}'.format(self.index, - receiver.unum(), + receiver.unum, receive_point, o_unum, o_step, @@ -474,9 +474,9 @@ def create_pass(self, wm: 'WorldModel', receiver, receive_point: Vector2D, self.debug_list.append((self.index, receive_point, True)) candidate = KickAction() candidate.type = KickActionType.Pass - candidate.start_ball_pos = wm.ball().pos() + candidate.start_ball_pos = wm.ball().pos.copy() candidate.target_ball_pos = receive_point - candidate.target_unum = receiver.unum() + candidate.target_unum = receiver.unum candidate.start_ball_speed = first_ball_speed candidate.evaluate(wm) self.candidates.append(candidate) @@ -501,13 +501,13 @@ def predict_opponents_reach_step(self, wm: 'WorldModel', first_ball_pos: Vector2 min_opp = 0 intercepted_pos = None for opp in wm.opponents(): - if opp is None or opp.unum() == 0: + if opp is None or opp.unum == 0: continue step, intercepted_pos = self.predict_opponent_reach_step(wm, opp, first_ball_pos, first_ball_vel, ball_move_angle, receive_point, max_cycle, description) if step < min_step: min_step = step - min_opp = opp.unum() + min_opp = opp.unum return min_step, min_opp, intercepted_pos def predict_opponent_reach_step(self, wm: 'WorldModel', opp: 'PlayerObject', first_ball_pos: Vector2D, first_ball_vel: Vector2D, @@ -520,8 +520,8 @@ def predict_opponent_reach_step(self, wm: 'WorldModel', opp: 'PlayerObject', fir opponent = opp - ptype = opponent.player_type() - min_cycle = Tools.estimate_min_reach_cycle(opponent.pos(), ptype.real_speed_max(), first_ball_pos, + ptype = opponent.player_type + min_cycle = Tools.estimate_min_reach_cycle(opponent.pos, ptype.real_speed_max(), first_ball_pos, ball_move_angle) if min_cycle < 0: @@ -531,7 +531,7 @@ def predict_opponent_reach_step(self, wm: 'WorldModel', opp: 'PlayerObject', fir ball_pos = smath.inertia_n_step_point(first_ball_pos, first_ball_vel, cycle, sp.ball_decay()) control_area = sp.catchable_area() if opponent.is_goalie() and penalty_area.contains(ball_pos) else ptype.kickable_area() - inertia_pos = ptype.inertia_point(opponent.pos(), opponent.vel(), cycle) + inertia_pos = ptype.inertia_point(opponent.pos, opponent.vel, cycle) target_dist = inertia_pos.dist(ball_pos) dash_dist = target_dist @@ -556,16 +556,16 @@ def predict_opponent_reach_step(self, wm: 'WorldModel', opp: 'PlayerObject', fir else: dash_dist -= control_area + 0.2 - if dash_dist > ptype.real_speed_max() * (cycle + min(opponent.pos_count(), 5)): + if dash_dist > ptype.real_speed_max() * (cycle + min(opponent.pos_count, 5)): continue n_dash = ptype.cycles_to_reach_distance(dash_dist) - if n_dash > cycle + opponent.pos_count(): + if n_dash > cycle + opponent.pos_count: continue n_turn = 0 - if opponent.body_count() > 1: - n_turn = Tools.predict_player_turn_cycle(ptype, opponent.body(), opponent.vel().r(), target_dist, + if opponent.body_count > 1: + n_turn = Tools.predict_player_turn_cycle(ptype, opponent.body, opponent.vel.r(), target_dist, (ball_pos - inertia_pos).th(), control_area, True) n_step = n_turn + n_dash if n_turn == 0 else n_turn + n_dash + 1 diff --git a/base/generator_shoot.py b/base/generator_shoot.py index 04247981..78fbfd66 100644 --- a/base/generator_shoot.py +++ b/base/generator_shoot.py @@ -27,12 +27,12 @@ def generator(self, wm: 'WorldModel') -> ShootAction: goal_l = Vector2D(SP.i().pitch_half_length(), -SP.i().goal_half_width()) goal_r = Vector2D(SP.i().pitch_half_length(), +SP.i().goal_half_width()) - goal_l._y += min(1.5, 0.6 + goal_l.dist(wm.ball().pos()) * 0.042) - goal_r._y -= min(1.5, 0.6 + goal_r.dist(wm.ball().pos()) * 0.042) + goal_l._y += min(1.5, 0.6 + goal_l.dist(wm.ball().pos) * 0.042) + goal_r._y -= min(1.5, 0.6 + goal_r.dist(wm.ball().pos) * 0.042) - if wm.self().pos().x() > SP.i().pitch_half_length() - 1.0 and wm.self().pos().abs_y() < SP.i().goal_half_width(): - goal_l._x = wm.self().pos().x() + 1.5 - goal_r._x = wm.self().pos().x() + 1.5 + if wm.self().pos.x() > SP.i().pitch_half_length() - 1.0 and wm.self().pos.abs_y() < SP.i().goal_half_width(): + goal_l._x = wm.self().pos.x() + 1.5 + goal_r._x = wm.self().pos.x() + 1.5 DIST_DIVS = 25 dist_step = abs(goal_l.y() - goal_r.y()) / (DIST_DIVS - 1) @@ -55,9 +55,9 @@ def generator(self, wm: 'WorldModel') -> ShootAction: return self.candidates[0] def create_shoot(self, wm: 'WorldModel', target_point: Vector2D): - ball_move_angle = (target_point - wm.ball().pos()).th() + ball_move_angle = (target_point - wm.ball().pos).th() goalie = wm.get_opponent_goalie() - if goalie is None or (goalie.unum() > 0 and 5 < goalie.pos_count() < 30): + if goalie is None or (goalie.unum > 0 and 5 < goalie.pos_count < 30): # TODO and wm.dirCount( ball_move_angle ) > 3 log.sw_log().shoot().add_text( "#shoot {} didnt see goalie".format(self.total_count)) return @@ -66,11 +66,11 @@ def create_shoot(self, wm: 'WorldModel', target_point: Vector2D): ball_speed_max = sp.ball_speed_max() if wm.game_mode().type() == GameModeType.PlayOn \ or wm.game_mode().is_penalty_kick_mode() \ - else wm.self().kick_rate() * sp.max_power() + else wm.self().kick_rate * sp.max_power() - ball_move_dist = wm.ball().pos().dist(target_point) + ball_move_dist = wm.ball().pos.dist(target_point) - max_one_step_vel = calc_max_velocity(ball_move_angle, wm.self().kick_rate(), wm.ball().vel()) + max_one_step_vel = calc_max_velocity(ball_move_angle, wm.self().kick_rate, wm.ball().vel) max_one_step_speed = max_one_step_vel.r() first_ball_speed = max((ball_move_dist + 5.0) * (1.0 - sp.ball_decay()), max_one_step_speed, 1.5) @@ -117,33 +117,35 @@ def check_shoot(self, wm: 'WorldModel', target_point: Vector2D, first_ball_speed for o in range(1, 12): opp = wm.their_player(o) - if opp.unum() < 1: + if o is None: + continue + if opp.unum < 1: log.sw_log().shoot().add_text( '## opp {} can not, unum') continue if opp.is_tackling(): log.sw_log().shoot().add_text( '## opp {} can not, tackle') continue - if opp.pos().x() < opponent_x_thr: + if opp.pos.x() < opponent_x_thr: log.sw_log().shoot().add_text( '## opp {} can not, xthr') continue - if opp.pos().abs_y() > opponent_y_thr: + if opp.pos.abs_y() > opponent_y_thr: log.sw_log().shoot().add_text( '## opp {} can not, ythr') continue - if (ball_move_angle - (opp.pos() - wm.ball().pos()).th()).abs() > 90.0: + if (ball_move_angle - (opp.pos - wm.ball().pos).th()).abs() > 90.0: log.sw_log().shoot().add_text( '## opp {} can not, angle') continue - if opp.goalie(): + if opp.goalie: if self.maybe_goalie_catch(opp, course, wm): return False log.sw_log().shoot().add_text( '## opp {} can not, goalie catch') continue - if opp.pos_count() > 10: + if opp.pos_count > 10: log.sw_log().shoot().add_text( '## opp {} can not, pos count') continue - if opp.is_ghost() and opp.pos_count() > 5: + if opp.is_ghost() and opp.pos_count > 5: log.sw_log().shoot().add_text( '## opp {} can not, ghost') continue @@ -158,18 +160,18 @@ def maybe_goalie_catch(self, goalie: 'PlayerObject', course: ShootAction, wm: 'W Size2D(SP.i().penalty_area_length(), SP.i().penalty_area_width())) CONTROL_AREA_BUF = 0.15 sp = SP.i() - ptype = goalie.player_type() - min_cycle = Tools.estimate_min_reach_cycle(goalie.pos(), ptype.real_speed_max(), wm.ball().pos(), + ptype = goalie.player_type + min_cycle = Tools.estimate_min_reach_cycle(goalie.pos, ptype.real_speed_max(), wm.ball().pos, course.ball_move_angle) if min_cycle < 0: return False - goalie_speed = goalie.vel().r() - seen_dist_noise = goalie.dist_from_self() * 0.02 + goalie_speed = goalie.vel.r() + seen_dist_noise = goalie.dist_from_self * 0.02 max_cycle = course.ball_reach_step for cycle in range(min_cycle, max_cycle): - ball_pos = smath.inertia_n_step_point(wm.ball().pos(), course.first_ball_vel, cycle, sp.ball_decay()) + ball_pos = smath.inertia_n_step_point(wm.ball().pos, course.first_ball_vel, cycle, sp.ball_decay()) if ball_pos.x() > sp.pitch_half_length(): break in_penalty_area = penalty_area.contains(ball_pos) @@ -191,18 +193,18 @@ def maybe_goalie_catch(self, goalie: 'PlayerObject', course: ShootAction, wm: 'W n_dash = ptype.cycles_to_reach_distance(dash_dist) - if n_dash > cycle + goalie.pos_count(): + if n_dash > cycle + goalie.pos_count: continue n_turn = 0 - if goalie.body_count() <= 1: - Tools.predict_player_turn_cycle(ptype, goalie.body(), goalie_speed, target_dist, + if goalie.body_count <= 1: + Tools.predict_player_turn_cycle(ptype, goalie.body, goalie_speed, target_dist, (ball_pos - inertia_pos).th(), control_area + 0.1, True) n_step = n_turn + n_dash if n_turn == 0: n_step += 1 - bonus_step = smath.bound(0, goalie.pos_count(), 5) if in_penalty_area else smath.bound(0, - goalie.pos_count() - 1, + bonus_step = smath.bound(0, goalie.pos_count, 5) if in_penalty_area else smath.bound(0, + goalie.pos_count - 1, 1) if not in_penalty_area: bonus_step -= 1 @@ -210,25 +212,25 @@ def maybe_goalie_catch(self, goalie: 'PlayerObject', course: ShootAction, wm: 'W if n_step <= cycle + bonus_step: return True - if in_penalty_area and n_step <= cycle + goalie.pos_count() + 1: + if in_penalty_area and n_step <= cycle + goalie.pos_count + 1: course.goalie_never_reach_ = False return False def opponent_can_reach(self, opponent, course: ShootAction, wm: 'WorldModel'): sp = SP.i() - ptype = opponent.player_type() + ptype = opponent.player_type control_area = ptype.kickable_area() - min_cycle = Tools.estimate_min_reach_cycle(opponent.pos(), ptype.real_speed_max(), wm.ball().pos(), + min_cycle = Tools.estimate_min_reach_cycle(opponent.pos, ptype.real_speed_max(), wm.ball().pos, course.ball_move_angle) if min_cycle < 0: return False - opponent_speed = opponent.vel().r() + opponent_speed = opponent.vel.r() max_cycle = course.ball_reach_step maybe_reach = False nearest_step_diff = 1000 for cycle in range(min_cycle, max_cycle): - ball_pos = smath.inertia_n_step_point(wm.ball().pos(), course.first_ball_vel, cycle, sp.ball_decay()) + ball_pos = smath.inertia_n_step_point(wm.ball().pos, course.first_ball_vel, cycle, sp.ball_decay()) inertia_pos = opponent.inertia_point(cycle) target_dist = inertia_pos.dist(ball_pos) if target_dist - control_area < 0.001: @@ -238,17 +240,17 @@ def opponent_can_reach(self, opponent, course: ShootAction, wm: 'WorldModel'): dash_dist -= control_area * 0.8 n_dash = ptype.cycles_to_reach_distance(dash_dist) - if n_dash > cycle + opponent.pos_count(): + if n_dash > cycle + opponent.pos_count: continue n_turn = 1 - if opponent.body_count() == 0: - n_turn = Tools.predict_player_turn_cycle(ptype, opponent.body(), opponent_speed, target_dist, + if opponent.body_count == 0: + n_turn = Tools.predict_player_turn_cycle(ptype, opponent.body, opponent_speed, target_dist, (ball_pos - inertia_pos).th(), control_area, True) n_step = n_turn + n_dash if n_turn == 0: n_step += 1 - bonus_step = smath.bound(0, opponent.pos_count(), 1) + bonus_step = smath.bound(0, opponent.pos_count, 1) penalty_step = -1 if opponent.is_tackling(): @@ -257,9 +259,9 @@ def opponent_can_reach(self, opponent, course: ShootAction, wm: 'WorldModel'): if n_step <= cycle + bonus_step + penalty_step: return True - if n_step <= cycle + opponent.pos_count() + 1: + if n_step <= cycle + opponent.pos_count + 1: maybe_reach = True - diff = cycle + opponent.pos_count() - n_step + diff = cycle + opponent.pos_count - n_step if diff < nearest_step_diff: nearest_step_diff = diff if maybe_reach: @@ -272,7 +274,7 @@ def evaluate_courses(self, wm: 'WorldModel'): sp = SP.i() goalie = wm.get_opponent_goalie() - goalie_angle = (goalie.pos() - wm.ball().pos()).th() if goalie else 180.0 + goalie_angle = (goalie.pos - wm.ball().pos).th() if goalie else 180.0 for it in self.candidates: score = 1.0 @@ -287,13 +289,13 @@ def evaluate_courses(self, wm: 'WorldModel'): score += 100.0 goalie_rate = 1.0 - if goalie.unum() > 0: + if goalie.unum > 0: variance2 = 1.0 if it.goalie_never_reach else pow(10.0, 2) angle_diff = (it.ball_move_angle - goalie_angle).abs() goalie_rate = 1.0 - math.exp(-pow(angle_diff, 2) / (2.0 * variance2) ) y_rate = 1.0 - if it.target_point.dist2(wm.ball().pos()) > y_dist_thr2: + if it.target_point.dist2(wm.ball().pos) > y_dist_thr2: y_dist = max(0.0, it.target_point.abs_y() - 4.0 ) y_rate = math.exp(-pow(y_dist, 2.0) / (2.0 * pow( sp.goal_half_width() - 1.5, 2))) diff --git a/base/goalie_decision.py b/base/goalie_decision.py index 16c234a9..f2258498 100644 --- a/base/goalie_decision.py +++ b/base/goalie_decision.py @@ -43,9 +43,9 @@ def decision(agent: 'PlayerAgent'): return True return False - if (wm.time().cycle() > wm.self().catch_time().cycle() + SP.catch_ban_cycle() - and wm.ball().dist_from_self() < SP.catchable_area() - 0.05 - and our_penalty.contains(wm.ball().pos())): + if (wm.time().cycle() > wm.self().last_catch_time.cycle() + SP.catch_ban_cycle() + and wm.ball().dist_from_self < SP.catchable_area() - 0.05 + and our_penalty.contains(wm.ball().pos)): agent.do_catch() agent.set_neck_action(NeckTurnToBall()) diff --git a/base/sample_communication.py b/base/sample_communication.py index 91b6c9e0..c3269195 100644 --- a/base/sample_communication.py +++ b/base/sample_communication.py @@ -49,7 +49,7 @@ def should_say_ball(self, agent: 'PlayerAgent'): wm = agent.world() ef = agent.effector() - if wm.ball().seen_pos_count() > 0 or wm.ball().seen_vel_count() > 2: + if wm.ball().seen_pos_count > 0 or wm.ball().seen_vel_count > 2: return False if wm.game_mode().type() != GameModeType.PlayOn and ef.queued_next_ball_vel().r2() < 0.5 ** 2: return False @@ -57,15 +57,15 @@ def should_say_ball(self, agent: 'PlayerAgent'): return False ball_vel_changed = False - current_ball_speed = wm.ball().vel().r() + current_ball_speed = wm.ball().vel.r() if wm.prev_ball().vel_valid(): - prev_ball_speed = wm.prev_ball().vel().r() - angle_diff = (wm.ball().vel().th() - wm.prev_ball().vel().th()).abs() + prev_ball_speed = wm.prev_ball().vel.r() + angle_diff = (wm.ball().vel.th() - wm.prev_ball().vel.th()).abs() log.sw_log().communication().add_text(f'(sample communication)' - f'prev vel={wm.prev_ball().vel()}, r={prev_ball_speed}' - f'current_vel={wm.ball().vel()}, r={wm.ball().vel()}') + f'prev vel={wm.prev_ball().vel}, r={prev_ball_speed}' + f'current_vel={wm.ball().vel}, r={wm.ball().vel}') if current_ball_speed > prev_ball_speed + 0.1 \ or ( @@ -93,7 +93,7 @@ def should_say_ball(self, agent: 'PlayerAgent'): for p in wm.teammates_from_ball(): if p is None: continue - if p.is_ghost() or p.pos_count() >= 10: + if p.is_ghost() or p.pos_count >= 10: continue if ball_nearest_teammate is None: @@ -106,7 +106,7 @@ def should_say_ball(self, agent: 'PlayerAgent'): opp_min = wm.intercept_table().opponent_reach_cycle() if ball_nearest_teammate is None \ - or ball_nearest_teammate.dist_from_ball() > wm.ball().dist_from_self() - 3.: + or ball_nearest_teammate.dist_from_ball > wm.ball().dist_from_self - 3.: log.sw_log().communication().add_text('(sample communication) maybe nearest to ball') if ball_vel_changed or (opp_min <= 1 and current_ball_speed > 1.): @@ -114,8 +114,8 @@ def should_say_ball(self, agent: 'PlayerAgent'): return True if ball_nearest_teammate is not None \ - and wm.ball().dist_from_self() < 20. \ - and 1. < ball_nearest_teammate.dist_from_ball() < 6. \ + and wm.ball().dist_from_self < 20. \ + and 1. < ball_nearest_teammate.dist_from_ball < 6. \ and (opp_min <= our_min + 1 or ball_vel_changed): log.sw_log().communication().add_text('(sample communication) support nearset player') return True @@ -128,16 +128,16 @@ def should_say_opponent_goalie(self, agent: 'PlayerAgent'): if goalie is None: return False - if goalie.seen_pos_count() == 0 \ - and goalie.body_count() == 0 \ - and goalie.unum() != UNUM_UNKNOWN \ - and goalie.unum_count() == 0 \ - and goalie.dist_from_self() < 25. \ - and 51. - 16. < goalie.pos().x() < 52.5 \ - and goalie.pos().abs_y() < 20.: + if goalie.seen_pos_count == 0 \ + and goalie.body_count == 0 \ + and goalie.unum != UNUM_UNKNOWN \ + and goalie.unum_count == 0 \ + and goalie.dist_from_self < 25. \ + and 51. - 16. < goalie.pos.x() < 52.5 \ + and goalie.pos.abs_y() < 20.: goal_pos = ServerParam.i().their_team_goal_pos() - ball_next = wm.ball().pos() + wm.ball().vel() + ball_next = wm.ball().pos + wm.ball().vel if ball_next.dist2(goal_pos) < 18 ** 2: return True @@ -166,7 +166,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): goalie_say_situation = False # self.goalie_say_situation # TODO IMP FUNC if not should_say_ball and not should_say_goalie and not goalie_say_situation \ - and self._current_sender_unum != wm.self().unum() \ + and self._current_sender_unum != wm.self().unum \ and current_len == 0: log.sw_log().communication().add_text('(sample communication) say ball and players: no send situation') return False @@ -194,15 +194,15 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): objects[0].score = -1000 else: objects[0].score = 1000 - elif wm.ball().seen_pos_count() > 0 or wm.ball().seen_vel_count() > 1 or wm.kickable_teammate(): + elif wm.ball().seen_pos_count > 0 or wm.ball().seen_vel_count > 1 or wm.kickable_teammate(): objects[0].score = -1000 elif should_say_ball: objects[0].score = 1000 elif objects[0].score > 0: if wm.prev_ball().vel_valid(): - angle_diff = (wm.ball().vel().th() - wm.prev_ball().vel().th()).abs() - prev_speed = wm.prev_ball().vel().r() - current_speed = wm.ball().vel().r() + angle_diff = (wm.ball().vel.th() - wm.prev_ball().vel.th()).abs() + prev_speed = wm.prev_ball().vel.r() + current_speed = wm.ball().vel.r() if (current_speed > prev_speed + 0.1 or (prev_speed > 0.5 and current_speed < prev_speed * SP.ball_decay() * 0.5) @@ -221,21 +221,21 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): for i in range(1, 12): p = wm.our_player(i) - if p is None or p.unum_count() >= 2: + if p is None or p.unum_count >= 2: objects[i].score = -1000 else: - d = (((p.pos().x() - ball_pos.x()) * x_rate) ** 2 + ((p.pos().y() - ball_pos.y()) * y_rate) ** 2) ** 0.5 + d = (((p.pos.x() - ball_pos.x()) * x_rate) ** 2 + ((p.pos.y() - ball_pos.y()) * y_rate) ** 2) ** 0.5 objects[i].score *= exp(-d ** 2 / (2 * variance ** 2)) - objects[i].score *= 0.3 ** p.unum_count() + objects[i].score *= 0.3 ** p.unum_count objects[i].player = p p = wm.their_player(i) - if p is None or p.unum_count() >= 2: + if p is None or p.unum_count >= 2: objects[i + 11].score = -1000 else: - d = (((p.pos().x() - ball_pos.x()) * x_rate) ** 2 + ((p.pos().y() - ball_pos.y()) * y_rate) ** 2) ** 0.5 + d = (((p.pos.x() - ball_pos.x()) * x_rate) ** 2 + ((p.pos.y() - ball_pos.y()) * y_rate) ** 2) ** 0.5 objects[i + 11].score *= exp(-d ** 2 / (2 * variance ** 2)) - objects[i + 11].score *= 0.3 ** p.unum_count() + objects[i + 11].score *= 0.3 ** p.unum_count objects[i + 11].player = p objects = list(filter(lambda x: x.score > 0.1, objects)) @@ -276,10 +276,10 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): if available_len >= Messenger.SIZES[Messenger.Types.BALL_PLAYER]: agent.add_say_message(BallPlayerMessenger(ef.queued_next_ball_pos(), ball_vel, - wm.self().unum(), + wm.self().unum, ef.queued_next_self_pos(), ef.queued_next_self_body())) - self.update_player_send_time(wm, wm.our_side(), wm.self().unum()) + self.update_player_send_time(wm, wm.our_side(), wm.self().unum) else: agent.add_say_message(BallMessenger(ef.queued_next_ball_pos(), ball_vel)) @@ -292,110 +292,110 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): goalie = wm.get_their_goalie() agent.add_say_message(BallGoalieMessenger(ef.queued_next_ball_pos(), ball_vel, - goalie.pos() + goalie.vel(), - goalie.body())) + goalie.pos + goalie.vel, + goalie.body)) self._ball_send_time = wm.time().copy() - self.update_player_send_time(wm, goalie.side(), goalie.unum()) + self.update_player_send_time(wm, goalie.side, goalie.unum) log.sw_log().communication().add_text('(sample communication) ball and goalie') return True if available_len >= Messenger.SIZES[Messenger.Types.BALL_PLAYER]: p = send_players[0].player - if p.unum() == wm.self().unum(): + if p.unum == wm.self().unum: agent.add_say_message(BallPlayerMessenger(ef.queued_next_ball_pos(), ball_vel, - wm.self().unum(), + wm.self().unum, ef.queued_next_self_pos(), ef.queued_next_self_body())) else: agent.add_say_message(BallPlayerMessenger(ef.queued_next_ball_pos(), ball_vel, send_players[0].number, - p.pos() + p.vel(), - p.body())) + p.pos + p.vel, + p.body)) self._ball_send_time = wm.time().copy() - self.update_player_send_time(wm, p.side(), p.unum()) + self.update_player_send_time(wm, p.side, p.unum) - log.sw_log().communication().add_text(f'(sample communication) ball and player {p.side()}{p.unum()}') + log.sw_log().communication().add_text(f'(sample communication) ball and player {p.side}{p.unum}') return True - if wm.ball().pos().x() > 34 and wm.ball().pos().abs_y() < 20: + if wm.ball().pos.x() > 34 and wm.ball().pos.abs_y() < 20: goalie: PlayerObject = wm.get_their_goalie() if goalie is not None \ - and goalie.seen_pos_count() == 0 \ - and goalie.body_count() == 0 \ - and goalie.pos().x() > 53. - 16 \ - and goalie.pos().abs_y() < 20. \ - and goalie.unum() != UNUM_UNKNOWN \ - and goalie.dist_from_self() < 25: + and goalie.seen_pos_count == 0 \ + and goalie.body_count == 0 \ + and goalie.pos.x() > 53. - 16 \ + and goalie.pos.abs_y() < 20. \ + and goalie.unum != UNUM_UNKNOWN \ + and goalie.dist_from_self < 25: if available_len >= Messenger.SIZES[Messenger.Types.GOALIE_PLAYER]: player: PlayerObject = None for p in send_players: - if p.player.unum() != goalie.unum() and p.player.side() != goalie.side(): + if p.player.unum != goalie.unum and p.player.side != goalie.side: player = p.player break if player is not None: - goalie_pos = goalie.pos() + goalie.vel() + goalie_pos = goalie.pos + goalie.vel goalie_pos.assign( bound(53. - 16., goalie_pos.x(), 52.9), bound(-20, goalie_pos.y(), 20), ) - agent.add_say_message(GoaliePlayerMessenger(goalie.unum(), + agent.add_say_message(GoaliePlayerMessenger(goalie.unum, goalie_pos, - goalie.body(), + goalie.body, ( - player.unum() if player.side() == wm.our_side() else player.unum() + 11), - player.pos() + player.vel())) - self.update_player_send_time(wm, goalie.side(), goalie.unum()) - self.update_player_send_time(wm, player.side(), player.unum()) + player.unum if player.side == wm.our_side() else player.unum + 11), + player.pos + player.vel)) + self.update_player_send_time(wm, goalie.side, goalie.unum) + self.update_player_send_time(wm, player.side, player.unum) log.sw_log().communication().add_text(f'(sample communication) say goalie and player: ' - f'goalie({goalie.unum()}): p={goalie.pos()} b={goalie.body()}' - f'player({player.side()}{player.unum()}: {player.pos()})') + f'goalie({goalie.unum}): p={goalie.pos} b={goalie.body}' + f'player({player.side}{player.unum}: {player.pos})') return True if available_len >= Messenger.SIZES[Messenger.Types.GOALIE]: - goalie_pos = goalie.pos() + goalie.vel() + goalie_pos = goalie.pos + goalie.vel goalie_pos.assign( bound(53. - 16., goalie_pos.x(), 52.9), bound(-20, goalie_pos.y(), 20), ) - agent.add_say_message(GoalieMessenger(goalie.unum(), + agent.add_say_message(GoalieMessenger(goalie.unum, goalie_pos, - goalie.body())) + goalie.body)) self._ball_send_time = wm.time().copy() - self._opponent_send_time[goalie.unum()] = wm.time().copy() + self._opponent_send_time[goalie.unum] = wm.time().copy() log.sw_log().communication().add_text(f'(sample communication) say goalie info:' - f'{goalie.unum()} {goalie.pos()} {goalie.body()}') + f'{goalie.unum} {goalie.pos} {goalie.body}') return True if len(send_players) >= 3 and available_len >= Messenger.SIZES[Messenger.Types.THREE_PLAYER]: for o in send_players: log.os_log().debug(o.player) - log.os_log().debug(o.player.pos()) + log.os_log().debug(o.player.pos) p0 = send_players[0].player p1 = send_players[1].player p2 = send_players[2].player agent.add_say_message(ThreePlayerMessenger(send_players[0].number, - p0.pos() + p0.vel(), + p0.pos + p0.vel, send_players[1].number, - p1.pos() + p1.vel(), + p1.pos + p1.vel, send_players[2].number, - p2.pos() + p2.vel())) - self.update_player_send_time(wm, p0.side(), p0.unum()) - self.update_player_send_time(wm, p1.side(), p1.unum()) - self.update_player_send_time(wm, p2.side(), p2.unum()) + p2.pos + p2.vel)) + self.update_player_send_time(wm, p0.side, p0.unum) + self.update_player_send_time(wm, p1.side, p1.unum) + self.update_player_send_time(wm, p2.side, p2.unum) log.sw_log().communication().add_text(f'(sample communication) three players:' - f'{p0.side()}{p0.unum()}' - f'{p1.side()}{p1.unum()}' - f'{p2.side()}{p2.unum()}') + f'{p0.side}{p0.unum}' + f'{p1.side}{p1.unum}' + f'{p2.side}{p2.unum}') return True if len(send_players) >= 2 and available_len >= Messenger.SIZES[Messenger.Types.TWO_PLAYER]: @@ -403,49 +403,49 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): p1 = send_players[1].player agent.add_say_message(TwoPlayerMessenger(send_players[0].number, - p0.pos() + p0.vel(), + p0.pos + p0.vel, send_players[1].number, - p1.pos() + p1.vel())) - self.update_player_send_time(wm, p0.side(), p0.unum()) - self.update_player_send_time(wm, p1.side(), p1.unum()) + p1.pos + p1.vel)) + self.update_player_send_time(wm, p0.side, p0.unum) + self.update_player_send_time(wm, p1.side, p1.unum) log.sw_log().communication().add_text(f'(sample communication) two players:' - f'{p0.side()}{p0.unum()}' - f'{p1.side()}{p1.unum()}') + f'{p0.side}{p0.unum}' + f'{p1.side}{p1.unum}') return True if len(send_players) >= 1 and available_len >= Messenger.SIZES[Messenger.Types.GOALIE]: p0 = send_players[0].player - if p0.side() == wm.their_side() \ - and p0.goalie() \ - and p0.pos().x() > 53. - 16. \ - and p0.pos().abs_y() < 20 \ - and p0.dist_from_self() < 25: - goalie_pos = p0.pos() + p0.vel() + if p0.side == wm.their_side() \ + and p0.goalie \ + and p0.pos.x() > 53. - 16. \ + and p0.pos.abs_y() < 20 \ + and p0.dist_from_self < 25: + goalie_pos = p0.pos + p0.vel goalie_pos.assign( bound(53. - 16., goalie_pos.x(), 52.9), bound(-20, goalie_pos.y(), 20), ) - agent.add_say_message(GoalieMessenger(p0.unum(), + agent.add_say_message(GoalieMessenger(p0.unum, goalie_pos, - p0.body())) + p0.body)) - self.update_player_send_time(wm, p0.side(), p0.unum()) + self.update_player_send_time(wm, p0.side, p0.unum) log.sw_log().communication().add_text(f'(sample communication) goalie:' - f'{p0.side()}{p0.unum()}') + f'{p0.side}{p0.unum}') return True if len(send_players) >= 1 and available_len >= Messenger.SIZES[Messenger.Types.ONE_PLAYER]: p0 = send_players[0].player agent.add_say_message(OnePlayerMessenger(send_players[0].number, - p0.pos() + p0.vel())) + p0.pos + p0.vel)) - self.update_player_send_time(wm, p0.side(), p0.unum()) + self.update_player_send_time(wm, p0.side, p0.unum) log.sw_log().communication().add_text(f'(sample communication) one player:' - f'{p0.side()}{p0.unum()}') + f'{p0.side}{p0.unum}') return True return False @@ -453,13 +453,13 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): def update_current_sender(self, agent: 'PlayerAgent'): wm = agent.world() if agent.effector().get_say_message_length() > 0: - self._current_sender_unum = wm.self().unum() + self._current_sender_unum = wm.self().unum return self._current_sender_unum = UNUM_UNKNOWN candidate_unum: list[int] = [] - if wm.ball().pos().x() < -10. or wm.game_mode().type() != GameModeType.PlayOn: + if wm.ball().pos.x() < -10. or wm.game_mode().type() != GameModeType.PlayOn: for unum in range(1, 12): candidate_unum.append(unum) else: @@ -480,7 +480,7 @@ def say_recovery(self, agent: 'PlayerAgent'): if available_len < Messenger.SIZES[Messenger.Types.RECOVERY]: return False - agent.add_say_message(RecoveryMessenger(agent.world().self().recovery())) + agent.add_say_message(RecoveryMessenger(agent.world().self().stamina_model.recovery())) log.sw_log().communication().add_text('(sample communication) say self recovery') return True @@ -492,7 +492,7 @@ def say_stamina(self, agent: 'PlayerAgent'): available_len = ServerParam.i().player_say_msg_size() - current_len if available_len < Messenger.SIZES[Messenger.Types.STAMINA]: return False - agent.add_say_message(StaminaMessenger(agent.world().self().stamina())) + agent.add_say_message(StaminaMessenger(agent.world().self().stamina_model.stamina())) log.sw_log().communication().add_text('(sample communication) say self stamina') return True @@ -500,21 +500,21 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC wm = agent.world() ef = agent.effector() - if wm.self().pos().x() > wm.offside_line_x() - 15. \ + if wm.self().pos.x() > wm.offside_line_x() - 15. \ and wm.intercept_table().self_reach_cycle() <= 3: - if self._current_sender_unum != wm.self().unum() and self._current_sender_unum != UNUM_UNKNOWN: + if self._current_sender_unum != wm.self().unum and self._current_sender_unum != UNUM_UNKNOWN: agent.do_attentionto(wm.our_side(), self._current_sender_unum) player = wm.our_player(self._current_sender_unum) if player is not None: - log.debug_client().add_circle(player.pos(), 3., color='#000088') - log.debug_client().add_line(player.pos(), wm.self().pos(), '#000088') + log.debug_client().add_circle(player.pos, 3., color='#000088') + log.debug_client().add_line(player.pos, wm.self().pos, '#000088') log.debug_client().add_message(f'AttCurSender{self._current_sender_unum}') else: candidates: list[PlayerObject] = [] for p in wm.teammates_from_self(): - if p.goalie() or p.unum() == UNUM_UNKNOWN or p.pos().x() > wm.offside_line_x() + 1.: + if p.goalie or p.unum == UNUM_UNKNOWN or p.pos.x() > wm.offside_line_x() + 1.: continue - if p.dist_from_self() > 20.: + if p.dist_from_self > 20.: break candidates.append(p) @@ -524,7 +524,7 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC target_teammate: PlayerObject = None max_x = -100000 for p in candidates: - diff = p.pos() + p.vel() - self_next + diff = p.pos + p.vel - self_next x = diff.x() * (1. - diff.abs_y() / 40) if x > max_x: max_x = x @@ -532,13 +532,13 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC if target_teammate is not None: log.sw_log().communication().add_text(f'(attentionto someone) most front teammate') - log.debug_client().add_message(f'AttFrontMate{target_teammate.unum()}') - log.debug_client().add_circle(target_teammate.pos(), 3., color='#000088') - log.debug_client().add_line(target_teammate.pos(), wm.self().pos(), '#000088') - agent.do_attentionto(wm.our_side(), target_teammate.unum()) + log.debug_client().add_message(f'AttFrontMate{target_teammate.unum}') + log.debug_client().add_circle(target_teammate.pos, 3., color='#000088') + log.debug_client().add_line(target_teammate.pos, wm.self().pos, '#000088') + agent.do_attentionto(wm.our_side(), target_teammate.unum) return - if wm.self().attentionto_unum() > 0: + if wm.self().attentionto_unum > 0: log.sw_log().communication().add_text('(attentionto someone) attentionto off. maybe ball owner') log.debug_client().add_message('AttOffBOwner') agent.do_attentionto_off() @@ -550,58 +550,58 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC opp_min = wm.intercept_table().opponent_reach_cycle() if fastest_teammate is not None \ - and fastest_teammate.unum() != UNUM_UNKNOWN \ + and fastest_teammate.unum != UNUM_UNKNOWN \ and mate_min <= 1 \ and mate_min < self_min \ and mate_min <= opp_min + 1 \ - and mate_min <= 5 + min(4, fastest_teammate.pos_count()) \ + and mate_min <= 5 + min(4, fastest_teammate.pos_count) \ and wm.ball().inertia_point(mate_min).dist2(ef.queued_next_self_pos()) < 35.**2: - log.debug_client().add_message(f'AttBallOwner{fastest_teammate.unum()}') - log.debug_client().add_circle(fastest_teammate.pos(), 3., color='#000088') - log.debug_client().add_line(fastest_teammate.pos(), wm.self().pos(), '#000088') - agent.do_attentionto(wm.our_side(), fastest_teammate.unum()) + log.debug_client().add_message(f'AttBallOwner{fastest_teammate.unum}') + log.debug_client().add_circle(fastest_teammate.pos, 3., color='#000088') + log.debug_client().add_line(fastest_teammate.pos, wm.self().pos, '#000088') + agent.do_attentionto(wm.our_side(), fastest_teammate.unum) return nearest_teammate = wm.get_teammate_nearest_to_ball(5) if nearest_teammate is not None \ - and nearest_teammate.unum() != UNUM_UNKNOWN \ + and nearest_teammate.unum != UNUM_UNKNOWN \ and opp_min <= 3 \ and opp_min <= mate_min \ and opp_min <= self_min \ - and nearest_teammate.dist_from_self() < 45. \ - and nearest_teammate.dist_from_ball() < 20.: - log.debug_client().add_message(f'AttBallNearest(1){nearest_teammate.unum()}') - log.debug_client().add_circle(nearest_teammate.pos(), 3., color='#000088') - log.debug_client().add_line(nearest_teammate.pos(), wm.self().pos(), '#000088') - agent.do_attentionto(wm.our_side(), nearest_teammate.unum()) + and nearest_teammate.dist_from_self < 45. \ + and nearest_teammate.dist_from_ball < 20.: + log.debug_client().add_message(f'AttBallNearest(1){nearest_teammate.unum}') + log.debug_client().add_circle(nearest_teammate.pos, 3., color='#000088') + log.debug_client().add_line(nearest_teammate.pos, wm.self().pos, '#000088') + agent.do_attentionto(wm.our_side(), nearest_teammate.unum) return if nearest_teammate is not None \ - and nearest_teammate.unum() != UNUM_UNKNOWN \ - and wm.ball().pos_count() >= 3 \ - and nearest_teammate.dist_from_ball() < 20.: - log.debug_client().add_message(f'AttBallNearest(2){nearest_teammate.unum()}') - log.debug_client().add_circle(nearest_teammate.pos(), 3., color='#000088') - log.debug_client().add_line(nearest_teammate.pos(), wm.self().pos(), '#000088') - agent.do_attentionto(wm.our_side(), nearest_teammate.unum()) + and nearest_teammate.unum != UNUM_UNKNOWN \ + and wm.ball().pos_count >= 3 \ + and nearest_teammate.dist_from_ball < 20.: + log.debug_client().add_message(f'AttBallNearest(2){nearest_teammate.unum}') + log.debug_client().add_circle(nearest_teammate.pos, 3., color='#000088') + log.debug_client().add_line(nearest_teammate.pos, wm.self().pos, '#000088') + agent.do_attentionto(wm.our_side(), nearest_teammate.unum) return if nearest_teammate is not None \ - and nearest_teammate.unum() != 45. \ - and nearest_teammate.dist_from_self() < 45. \ - and nearest_teammate.dist_from_ball() < 3.5: - log.debug_client().add_message(f'AttBallNearest(3){nearest_teammate.unum()}') - log.debug_client().add_circle(nearest_teammate.pos(), 3., color='#000088') - log.debug_client().add_line(nearest_teammate.pos(), wm.self().pos(), '#000088') - agent.do_attentionto(wm.our_side(), nearest_teammate.unum()) + and nearest_teammate.unum != 45. \ + and nearest_teammate.dist_from_self < 45. \ + and nearest_teammate.dist_from_ball < 3.5: + log.debug_client().add_message(f'AttBallNearest(3){nearest_teammate.unum}') + log.debug_client().add_circle(nearest_teammate.pos, 3., color='#000088') + log.debug_client().add_line(nearest_teammate.pos, wm.self().pos, '#000088') + agent.do_attentionto(wm.our_side(), nearest_teammate.unum) return - if self._current_sender_unum != wm.self().unum() and self._current_sender_unum != UNUM_UNKNOWN: + if self._current_sender_unum != wm.self().unum and self._current_sender_unum != UNUM_UNKNOWN: log.debug_client().add_message(f'AttCurSender{self._current_sender_unum}') player = wm.our_player(self._current_sender_unum) if player is not None: - log.debug_client().add_circle(player.pos(), 3., color='#000088') - log.debug_client().add_line(player.pos(), wm.self().pos(), '#000088') + log.debug_client().add_circle(player.pos, 3., color='#000088') + log.debug_client().add_line(player.pos, wm.self().pos, '#000088') agent.do_attentionto(wm.our_side(), self._current_sender_unum) else: log.debug_client().add_message(f'AttOff') @@ -622,8 +622,8 @@ def execute(self, agent: 'PlayerAgent'): say_recovery = False if wm.game_mode().type() == GameModeType.PlayOn \ and not penalty_shootout \ - and self._current_sender_unum == wm.self().unum() \ - and wm.self().recovery() < ServerParam.i().recover_init() - 0.002: + and self._current_sender_unum == wm.self().unum \ + and wm.self().stamina_model.recovery() < ServerParam.i().recover_init() - 0.002: say_recovery = True self.say_recovery(agent) diff --git a/base/sample_player.py b/base/sample_player.py index 17657264..eb2019b3 100644 --- a/base/sample_player.py +++ b/base/sample_player.py @@ -40,8 +40,8 @@ def do_preprocess(self): ScanField().execute(self) return True - count_thr = 10 if wm.self().goalie() else 5 - if wm.ball().pos_count() > count_thr or ( wm.game_mode().type() is not GameModeType.PlayOn and wm.ball().seen_pos_count() > count_thr + 10): + count_thr = 10 if wm.self().goalie else 5 + if wm.ball().pos_count > count_thr or ( wm.game_mode().type() is not GameModeType.PlayOn and wm.ball().seen_pos_count > count_thr + 10): self.set_view_action(ViewTactical()) NeckBodyToBall().execute(self) return True @@ -58,7 +58,7 @@ def do_heard_pass_receive(self): if wm.messenger_memory().pass_time() != wm.time() \ or len(wm.messenger_memory().pass_()) == 0 \ - or wm.messenger_memory().pass_()[0]._receiver != wm.self().unum(): + or wm.messenger_memory().pass_()[0]._receiver != wm.self().unum: return False @@ -69,8 +69,8 @@ def do_heard_pass_receive(self): log.sw_log().team().add_text( f"(sample palyer do heard pass) heard_pos={heard_pos}, intercept_pos={intercept_pos}") if not wm.kickable_teammate() \ - and wm.ball().pos_count() <= 1 \ - and wm.ball().vel_count() <= 1 \ + and wm.ball().pos_count <= 1 \ + and wm.ball().vel_count <= 1 \ and self_min < 20: log.sw_log().team().add_text( f"(sample palyer do heard pass) intercepting!, self_min={self_min}") log.debug_client().add_message("Comm:Receive:Intercept") diff --git a/base/sample_trainer.py b/base/sample_trainer.py index 2eb5c3c1..c1530978 100644 --- a/base/sample_trainer.py +++ b/base/sample_trainer.py @@ -19,7 +19,7 @@ def sample_action(self): log.sw_log().block().add_text( "Sample Action") wm = self.world() - ballpos = wm.ball().pos() + ballpos = wm.ball().seen_pos if ballpos.abs_x() > 10 or ballpos.abs_y() > 10: for i in range(1, 12): self.do_move_player(wm.team_name_l(), i, Vector2D(-40, i * 5 - 30)) diff --git a/base/set_play/bhv_goalie_set_play.py b/base/set_play/bhv_goalie_set_play.py index 46afcb4f..57a901dc 100644 --- a/base/set_play/bhv_goalie_set_play.py +++ b/base/set_play/bhv_goalie_set_play.py @@ -31,9 +31,9 @@ def execute(self, agent: 'PlayerAgent'): wm = agent.world() gm = wm.game_mode() - if not gm.type().is_goalie_catch_ball() or gm.side() != wm.our_side() or not wm.self().is_kickable(): + if not gm.type().is_goalie_catch_ball() or gm.side != wm.our_side() or not wm.self().is_kickable(): log.os_log().debug(f'### goalie set play gm.catch?={gm.type().is_goalie_catch_ball()}') - log.os_log().debug(f'### goalie set play gm.side,ourside={gm.side()}, {wm.our_side()}') + log.os_log().debug(f'### goalie set play gm.side,ourside={gm.side}, {wm.our_side()}') log.os_log().debug(f'### goalie set play iskick?={wm.self().is_kickable()}') log.sw_log().team().add_text('not a goalie catch mode') return False @@ -50,7 +50,7 @@ def execute(self, agent: 'PlayerAgent'): return True if not Bhv_GoalieSetPlay._first_move: - move_point = Vector2D(SP.our_penalty_area_line_x() - 1.5, -13. if wm.ball().pos().y() < 0 else 13.) + move_point = Vector2D(SP.our_penalty_area_line_x() - 1.5, -13. if wm.ball().pos.y() < 0 else 13.) log.os_log().debug(f'### goalie set play move_point={move_point}') Bhv_GoalieSetPlay._first_move = True Bhv_GoalieSetPlay._second_move = False @@ -65,7 +65,7 @@ def execute(self, agent: 'PlayerAgent'): if time_diff < 50. \ or wm.set_play_count() < 3 \ or (time_diff < SP.drop_ball_time() - 15 - and (wm.self().stamina() < SP.stamina_max() * 0.9 + and (wm.self().stamina_model.stamina() < SP.stamina_max() * 0.9 or wm.exist_teammates_in(our_penalty_area, 20, True))): self.do_wait(agent) return True @@ -107,7 +107,7 @@ def get_kick_point(self, agent: 'PlayerAgent'): for p in points: score = 0 for o in agent.world().opponents_from_self(): - score += 1. / o.pos().dist2(p) + score += 1. / o.pos.dist2(p) candids.append((p, score)) best_pos = candids[0][0] diff --git a/base/set_play/bhv_set_play.py b/base/set_play/bhv_set_play.py index 0293171f..eb8464d3 100644 --- a/base/set_play/bhv_set_play.py +++ b/base/set_play/bhv_set_play.py @@ -31,27 +31,27 @@ def execute(self, agent: 'PlayerAgent'): log.sw_log().team().add_text( "Bhv_SetPlay") wm: WorldModel = agent.world() game_mode = wm.game_mode().type() - game_side = wm.game_mode().side() + game_side = wm.game_mode().side if game_mode is GameModeType.BeforeKickOff or game_mode.is_after_goal(): return Bhv_BeforeKickOff().execute(agent) st = StrategyFormation.i() - target = st.get_pos(wm.self().unum()) - if wm.game_mode().side() is wm.our_side(): + target = st.get_pos(wm.self().unum) + if wm.game_mode().side is wm.our_side(): nearest_tm_dist = 1000 nearest_tm = 0 for i in range(1, 12): tm: 'PlayerObject' = wm.our_player(i) if tm is None: continue - if tm.unum() == i: - dist = tm.pos().dist(wm.ball().pos()) + if tm.unum == i: + dist = tm.pos.dist(wm.ball().pos) if dist < nearest_tm_dist: nearest_tm_dist = dist nearest_tm = i - if nearest_tm is wm.self().unum(): - target = wm.ball().pos() + if nearest_tm is wm.self().unum: + target = wm.ball().pos.copy() if GoToPoint(target, 0.5, 100).execute(agent): agent.set_neck_action(NeckTurnToBallOrScan()) return True @@ -63,17 +63,17 @@ def execute(self, agent: 'PlayerAgent'): def is_kicker(agent): wm = agent.world() if wm.game_mode().mode_name() == "goalie_catch" and \ - wm.game_mode().side() == wm.our_side() and \ - not wm.self().goalie(): + wm.game_mode().side == wm.our_side() and \ + not wm.self().goalie: log.sw_log().team().add_text( "(is_kicker) goalie free kick") return False - if not wm.self().goalie() and \ + if not wm.self().goalie and \ wm.game_mode().mode_name() == "goal_kick" and \ - wm.game_mode().side() == wm.our_side(): + wm.game_mode().side == wm.our_side(): return False - if wm.self().goalie() and \ + if wm.self().goalie and \ wm.game_mode().mode_name() == "goal_kick" and \ - wm.game_mode().side() == wm.our_side(): + wm.game_mode().side == wm.our_side(): return True st = StrategyFormation().i() kicker_unum = 0 @@ -88,7 +88,7 @@ def is_kicker(agent): if not home_pos.is_valid(): continue - d2 = home_pos.dist2(wm.ball().pos()) + d2 = home_pos.dist2(wm.ball().pos) if d2 < second_min_dist2: second_kicker_unum = unum second_min_dist2 = d2 @@ -110,7 +110,7 @@ def is_kicker(agent): if kicker is None: if len(wm.teammates_from_ball()) > 0 and \ - wm.teammates_from_ball()[0].dist_from_ball() < wm.ball().dist_from_self() * 0.9: + wm.teammates_from_ball()[0].dist_from_ball < wm.ball().dist_from_self * 0.9: log.sw_log().team().add_text( "(is kicker) first kicker") return False @@ -119,25 +119,25 @@ def is_kicker(agent): if kicker is not None and \ second_kicker is not None and \ - (kicker.unum() == wm.self().unum() or \ - second_kicker.unum() == wm.self().unum()): + (kicker.unum == wm.self().unum or \ + second_kicker.unum == wm.self().unum): if min_dist2 ** 0.5 < (second_min_dist2 ** 0.5) * 0.95: - log.sw_log().team().add_text( f"(is kicker) kicker->unum={kicker.unum()} (1)") - return kicker.unum() == wm.self().unum() - elif kicker.dist_from_ball() < second_kicker.dist_from_ball() * 0.95: - log.sw_log().team().add_text( f"(is kicker) kicker->unum={kicker.unum()} (2)") - return kicker.unum() == wm.self().unum() - elif second_kicker.dist_from_ball() < kicker.dist_from_ball() * 0.95: - log.sw_log().team().add_text( f"(is kicker) kicker->unum={kicker.unum()} (3)") - return second_kicker.unum() == wm.self().unum() + log.sw_log().team().add_text( f"(is kicker) kicker->unum={kicker.unum} (1)") + return kicker.unum == wm.self().unum + elif kicker.dist_from_ball < second_kicker.dist_from_ball * 0.95: + log.sw_log().team().add_text( f"(is kicker) kicker->unum={kicker.unum} (2)") + return kicker.unum == wm.self().unum + elif second_kicker.dist_from_ball < kicker.dist_from_ball * 0.95: + log.sw_log().team().add_text( f"(is kicker) kicker->unum={kicker.unum} (3)") + return second_kicker.unum == wm.self().unum elif len(wm.teammates_from_ball()) > 0 and \ - wm.teammates_from_ball()[0].dist_from_ball() < wm.self().dist_from_ball() * 0.95: + wm.teammates_from_ball()[0].dist_from_ball < wm.self().dist_from_ball * 0.95: log.sw_log().team().add_text( "(is kicker) other kicker") return False else: log.sw_log().team().add_text( "(is kicker) self (2)") return True - return kicker.unum() == wm.self().unum() + return kicker.unum == wm.self().unum def kick(self, agent: 'PlayerAgent'): wm = agent.world() diff --git a/base/set_play/bhv_set_play_before_kick_off.py b/base/set_play/bhv_set_play_before_kick_off.py index dca191e9..69315596 100644 --- a/base/set_play/bhv_set_play_before_kick_off.py +++ b/base/set_play/bhv_set_play_before_kick_off.py @@ -12,10 +12,10 @@ def __init__(self): pass def execute(self, agent: 'PlayerAgent'): - unum = agent.world().self().unum() + unum = agent.world().self().unum st = StrategyFormation.i() target = st.get_pos(unum) - if target.dist(agent.world().self().pos()) > 1.: + if target.dist(agent.world().self().pos) > 1.: agent.do_move(target.x(), target.y()) agent.set_neck_action(NeckScanField()) return True diff --git a/base/stamina_manager.py b/base/stamina_manager.py index cd6a0360..e6736e94 100644 --- a/base/stamina_manager.py +++ b/base/stamina_manager.py @@ -7,37 +7,37 @@ def get_normal_dash_power(wm: 'WorldModel', s_recover_mode: bool): - if wm.self().stamina_model().capacity_is_empty(): - return min(SP.i().max_dash_power(), wm.self().stamina() + wm.self().player_type().extra_stamina()) + if wm.self().stamina_model.capacity_is_empty(): + return min(SP.i().max_dash_power(), wm.self().stamina_model.stamina() + wm.self().player_type.extra_stamina()) self_min = wm.intercept_table().self_reach_cycle() mate_min = wm.intercept_table().teammate_reach_cycle() opp_min = wm.intercept_table().opponent_reach_cycle() ball_min_reach_cycle = min(self_min, mate_min, opp_min) - if wm.self().stamina_model().capacity_is_empty(): + if wm.self().stamina_model.capacity_is_empty(): s_recover_mode = False - elif wm.self().stamina() < SP.i().stamina_max() * 0.5: + elif wm.self().stamina_model.stamina() < SP.i().stamina_max() * 0.5: s_recover_mode = True - elif wm.self().stamina() > SP.i().stamina_max() * 0.7: + elif wm.self().stamina_model.stamina() > SP.i().stamina_max() * 0.7: s_recover_mode = False dash_power = SP.i().max_dash_power() - my_inc = wm.self().player_type().stamina_inc_max() * wm.self().recovery() + my_inc = wm.self().player_type.stamina_inc_max() * wm.self().stamina_model.recovery() - # TODO wm.ourDefenseLineX() > wm.self().pos().x - # TODO wm.ball().pos().x() < wm.ourDefenseLineX() + 20.0 - if wm.self().unum() <= 5 and wm.ball().inertia_point(ball_min_reach_cycle).x() < -20.0: + # TODO wm.ourDefenseLineX() > wm.self().pos.x + # TODO wm.ball().pos.x() < wm.ourDefenseLineX() + 20.0 + if wm.self().unum <= 5 and wm.ball().inertia_point(ball_min_reach_cycle).x() < -20.0: dash_power = SP.i().max_dash_power() elif s_recover_mode: dash_power = my_inc - 25.0 if dash_power < 0.0: dash_power = 0.0 - elif wm.exist_kickable_teammates() and wm.ball().dist_from_self() < 20.0: + elif wm.exist_kickable_teammates() and wm.ball().dist_from_self < 20.0: dash_power = min(my_inc * 1.1, SP.i().max_dash_power()) - elif wm.self().pos().x() > wm.offside_line_x(): + elif wm.self().pos.x() > wm.offside_line_x(): dash_power = SP.i().max_dash_power() - elif wm.ball().pos().x() > 25.0 and wm.ball().pos().x() > wm.self().pos().x() + 10.0 and self_min < opp_min - 6 and mate_min < opp_min - 6: + elif wm.ball().pos.x() > 25.0 and wm.ball().pos.x() > wm.self().pos.x() + 10.0 and self_min < opp_min - 6 and mate_min < opp_min - 6: dash_power = smath.bound(SP.i().max_dash_power() * 0.1, my_inc * 0.5, SP.i().max_dash_power()) else: dash_power = min(my_inc * 1.7, SP.i().max_dash_power()) diff --git a/base/strategy.py b/base/strategy.py index 46f93c8b..b6f83a5c 100644 --- a/base/strategy.py +++ b/base/strategy.py @@ -18,7 +18,7 @@ def __init__(self): self._poses = [Vector2D(0, 0) for i in range(11)] def update(self, wm): - ball_pos = wm.ball().pos() + ball_pos = wm.ball().pos for p in range(len(self._poses)): x = ball_pos.x() / 52.5 * self._base_poses[p - 1][1] + self._base_poses[p - 1][0].x() y = ball_pos.y() / 52.5 * self._base_poses[p - 1][1] + self._base_poses[p - 1][0].y() diff --git a/base/strategy_formation.py b/base/strategy_formation.py index 2467bc4b..666bfc57 100644 --- a/base/strategy_formation.py +++ b/base/strategy_formation.py @@ -45,7 +45,7 @@ def update(self, wm: 'WorldModel'): thr = 0 if wm.ball().inertia_point(min(self_min, tm_min, opp_min)).x() > 0: thr += 1 - if wm.self().unum() > 6: + if wm.self().unum > 6: thr += 1 if min(tm_min, self_min) < opp_min + thr: self.current_situation = Situation.Offense_Situation diff --git a/base/tackle_generator.py b/base/tackle_generator.py index 71aa923b..2dda076f 100644 --- a/base/tackle_generator.py +++ b/base/tackle_generator.py @@ -53,7 +53,7 @@ def generate(self, wm: 'WorldModel'): if wm.self().is_kickable(): return - if wm.self().tackle_probability() < 0.001 and wm.self().foul_probability() < 0.001: + if wm.self().tackle_probability < 0.001 and wm.self().foul_probability() < 0.001: return if wm.time().stopped_cycle() > 0: @@ -80,7 +80,7 @@ def calculate(self, wm: 'WorldModel'): max_angle = SP.max_moment() angle_step = abs(max_angle - min_angle) / TackleGenerator.ANGLE_DIVS - ball_rel_angle = wm.ball().angle_from_self() - wm.self().body() + ball_rel_angle = wm.ball().angle_from_self - wm.self().body tackle_rate = SP.tackle_power_rate() * (1 - 0.5*ball_rel_angle.abs()/ 180.) for a in range(TackleGenerator.ANGLE_DIVS): @@ -90,10 +90,10 @@ def calculate(self, wm: 'WorldModel'): * (1. - (dir.abs() / 180.)) eff_power *= tackle_rate - angle = wm.self().body() + dir + angle = wm.self().body + dir accel = Vector2D(r=eff_power, a=angle) - vel = wm.ball().vel() + accel + vel = wm.ball().vel + accel speed = vel.r() if speed > SP.ball_speed_max(): vel.set_length(SP.ball_speed_max()) @@ -110,16 +110,16 @@ def calculate(self, wm: 'WorldModel'): def evaluate(self, wm, result: TackleAction): SP = ServerParam.i() - ball_end_point = inertia_final_point(wm.ball().pos(), + ball_end_point = inertia_final_point(wm.ball().pos, result._ball_vel, SP.ball_decay()) - ball_line = Segment2D(wm.ball().pos(), ball_end_point) + ball_line = Segment2D(wm.ball().pos, ball_end_point) ball_speed = result._ball_speed ball_move_angle = result._ball_move_angle if ball_end_point.x() > SP.pitch_half_length() \ - and wm.ball().pos().dist2(SP.their_team_goal_pos()) < 20**2: + and wm.ball().pos.dist2(SP.their_team_goal_pos()) < 20**2: goal_line = Line2D(Vector2D(SP.pitch_half_length(), 10), Vector2D(SP.pitch_half_length(), -10)) @@ -145,17 +145,17 @@ def evaluate(self, wm, result: TackleAction): shoot_score = y_penalty + speed_bonus return shoot_score - opponent_reach_step = self.predict_opponents_reach_step(wm, wm.ball().pos(), result._ball_vel, ball_move_angle) - final_point = inertia_n_step_point(wm.ball().pos(), result._ball_vel, opponent_reach_step, SP.ball_decay()) + opponent_reach_step = self.predict_opponents_reach_step(wm, wm.ball().pos, result._ball_vel, ball_move_angle) + final_point = inertia_n_step_point(wm.ball().pos, result._ball_vel, opponent_reach_step, SP.ball_decay()) - final_segment = Segment2D(wm.ball().pos(), final_point) + final_segment = Segment2D(wm.ball().pos, final_point) pitch = Rect2D.from_center(0., 0., SP.pitch_length(), SP.pitch_width()) intersections = pitch.intersection(final_segment) if len(intersections) > 0: final_point = intersections[0] - our_goal_angle = (SP.our_team_goal_pos() - wm.ball().pos()).th() + our_goal_angle = (SP.our_team_goal_pos() - wm.ball().pos).th() our_goal_angle_diff = (our_goal_angle - ball_move_angle).abs() our_goal_angle_rate = 1 - exp(-our_goal_angle_diff**2 / (2*40**2)) @@ -206,11 +206,11 @@ def predict_opponent_reach_step(self, ball_move_angle: AngleDeg, max_cycle): SP = ServerParam.i() - ptype = opponent.player_type() + ptype = opponent.player_type - opponent_speed = opponent.vel().r() + opponent_speed = opponent.vel.r() - min_cycle = Tools.estimate_min_reach_cycle(opponent.pos(), + min_cycle = Tools.estimate_min_reach_cycle(opponent.pos, ptype.real_speed_max(), first_ball_pos, ball_move_angle) @@ -245,8 +245,8 @@ def predict_opponent_reach_step(self, if n_dash > cycle: continue - n_turn = 0 if opponent.body_count() > 1 else Tools.predict_player_turn_cycle(ptype, - opponent.body(), + n_turn = 0 if opponent.body_count > 1 else Tools.predict_player_turn_cycle(ptype, + opponent.body, opponent_speed, target_dist, (ball_pos - inertia_pos).th(), @@ -257,7 +257,7 @@ def predict_opponent_reach_step(self, if opponent.is_tackling(): n_step += 5 - n_step -= min(3, opponent.pos_count()) + n_step -= min(3, opponent.pos_count) if n_step <= cycle: return cycle return 1000 diff --git a/base/tools.py b/base/tools.py index 75b268f0..79996a79 100644 --- a/base/tools.py +++ b/base/tools.py @@ -39,8 +39,8 @@ def predict_kick_count(wm: 'WorldModel', kicker, first_ball_speed, ball_move_ang if wm.game_mode().type() != GameModeType.PlayOn and not wm.game_mode().is_penalty_kick_mode(): return 1 - if kicker == wm.self().unum() and wm.self().is_kickable(): - max_vel = calc_max_velocity(ball_move_angle, wm.self().kick_rate(), wm.ball().vel()) + if kicker == wm.self().unum and wm.self().is_kickable(): + max_vel = calc_max_velocity(ball_move_angle, wm.self().kick_rate, wm.ball().vel) if max_vel.r2() >= pow( first_ball_speed, 2): return 1 if first_ball_speed > 2.5: @@ -64,7 +64,7 @@ def get_nearest_teammate(wm: 'WorldModel', position: Vector2D, players: list['Pl best_player: 'PlayerObject' = None min_dist2 = 1000 for player in players: - d2 = player.pos().dist2( position ) + d2 = player.pos.dist2( position ) if d2 < min_dist2: min_dist2 = d2 best_player = player @@ -73,8 +73,8 @@ def get_nearest_teammate(wm: 'WorldModel', position: Vector2D, players: list['Pl @staticmethod def estimate_virtual_dash_distance(player: 'PlayerObject'): - pos_count = min(10, player.pos_count(), player.seen_pos_count()) - max_speed = player.player_type().real_speed_max() * 0.8 + pos_count = min(10, player.pos_count, player.seen_pos_count) + max_speed = player.player_type.real_speed_max() * 0.8 d = 0. for i in range(pos_count): diff --git a/base/view_tactical.py b/base/view_tactical.py index 897cd590..00689a65 100644 --- a/base/view_tactical.py +++ b/base/view_tactical.py @@ -20,7 +20,7 @@ def __init__(self): def execute(self, agent: 'PlayerAgent'): ViewTactical.PREV2 = ViewTactical.PREV1 - ViewTactical.PREV1 = agent.world().self().view_width().width() + ViewTactical.PREV1 = agent.world().self().view_width.width() best_width = None gm = agent.world().game_mode().type() @@ -35,7 +35,7 @@ def execute(self, agent: 'PlayerAgent'): elif gm.is_penalty_taken(): best_width = ViewWidth.NARROW - elif gm.is_goalie_catch_ball() and gm.side() == agent.world().our_side(): + elif gm.is_goalie_catch_ball() and gm.side == agent.world().our_side(): best_width = self.get_our_goalie_free_kick_view_width(agent) else: best_width = self.get_default_view_width(agent) @@ -63,7 +63,7 @@ def get_default_view_width(self, agent: 'PlayerAgent'): ball_pos = wm.ball().inertia_point(ball_reach_cycle) ball_dist = ef.queued_next_self_pos().dist(ball_pos) - if wm.self().goalie() and not wm.self().is_kickable(): + if wm.self().goalie and not wm.self().is_kickable(): goal_pos = Vector2D(- SP.pitch_half_length(), 0) if ball_dist > 10 or ball_pos.x() > SP.our_penalty_area_line_x() or ball_pos.dist(goal_pos) > 20: ball_angle = ef.queued_next_angle_from_body(ef.queued_next_ball_pos()) # TODO IMP FUNC @@ -88,21 +88,21 @@ def get_default_view_width(self, agent: 'PlayerAgent'): opponent_ball_dist = 1000. if len(wm.teammates_from_ball()) > 0: - teammate_ball_dist = wm.teammates_from_ball()[0].dist_from_ball() + teammate_ball_dist = wm.teammates_from_ball()[0].dist_from_ball if len(wm.opponents_from_ball()) > 0: - opponent_ball_dist = wm.opponents_from_ball()[0].dist_from_ball() + opponent_ball_dist = wm.opponents_from_ball()[0].dist_from_ball - if (not wm.self().goalie() + if (not wm.self().goalie and teammate_ball_dist > 5 and opponent_ball_dist > 5 and ball_dist > 10 - and wm.ball().dist_from_self() > 10): + and wm.ball().dist_from_self > 10): return ViewWidth.NORMAL return ViewWidth.NARROW def get_our_goalie_free_kick_view_width(self, agent: 'PlayerAgent'): - if agent.world().self().goalie(): + if agent.world().self().goalie: return ViewWidth.WIDE return self.get_default_view_width(agent) diff --git a/lib/action/basic_actions.py b/lib/action/basic_actions.py index 31324ac0..cc6ea1f1 100644 --- a/lib/action/basic_actions.py +++ b/lib/action/basic_actions.py @@ -28,11 +28,11 @@ def __init__(self, point: Vector2D, cycle: int = 1): def execute(self, agent: 'PlayerAgent'): me = agent.world().self() - if not me.pos().is_valid(): + if not me.pos.is_valid(): return agent.do_turn(60) my_point = me.inertia_point(self._cycle) - target_rel_angle = (self._point - my_point).th() - me.body() + target_rel_angle = (self._point - my_point).th() - me.body agent.do_turn(target_rel_angle) if target_rel_angle.abs() < 1: @@ -58,7 +58,7 @@ def execute(self, agent: 'PlayerAgent'): # agent.do_turn(0.0) # return False - agent.do_turn(self._angle - me.body()) + agent.do_turn(self._angle - me.body) return True @@ -99,11 +99,11 @@ def execute(self, agent: 'PlayerAgent'): wm = agent.world() sp = ServerParam.i() - if wm.self().tackle_probability() < self._min_prob: + if wm.self().tackle_probability < self._min_prob: return False - target_angle = (self._point - wm.ball().pos()).th() - target_rel_angle = target_angle - wm.self().body() + target_angle = (self._point - wm.ball().pos).th() + target_rel_angle = target_angle - wm.self().body # if agent.config().version() < 12.0: # if target_rel_angle.abs() < 90.0: @@ -113,14 +113,14 @@ def execute(self, agent: 'PlayerAgent'): # return agent.do_tackle(- sp.maxBackTacklePower()) # return False - ball_rel_angle = wm.ball().rpos().th() - wm.self().body() + ball_rel_angle = wm.ball().rpos.th() - wm.self().body eff_power = sp.max_back_tackle_power() + ( (sp.max_tackle_power() - sp.max_back_tackle_power()) * (1.0 - target_rel_angle.abs() / 180.0)) eff_power *= sp.tackle_power_rate() eff_power *= 1.0 - 0.5 * (ball_rel_angle.abs() / 180.0) - vel = wm.ball().vel() + Vector2D.polar2vector(eff_power, target_angle) + vel = wm.ball().vel + Vector2D.polar2vector(eff_power, target_angle) if ((vel.th() - target_angle).abs() > 90.0 # never accelerate to the target direction or vel.r() < self._min_speed): # too small speed @@ -138,8 +138,8 @@ def execute(self, agent: 'PlayerAgent'): next_view_width = agent.effector().queued_next_view_width().width() my_next_pos = agent.effector().queued_next_self_pos() my_next_face = agent.effector().queued_next_self_face() - current_focus_point_dist = agent.world().self().focus_point_dist() - current_focus_point_dir = agent.world().self().focus_point_dir() + current_focus_point_dist = agent.world().self().focus_point_dist + current_focus_point_dir = agent.world().self().focus_point_dir current_focus_point_dir = AngleDeg(min_max(-next_view_width / 2.0, current_focus_point_dir.degree(), next_view_width / 2.0)) next_focus_point_dist = my_next_pos.dist(self.next_focus_point) if not (0.0 < next_focus_point_dist < 40.0): diff --git a/lib/action/go_to_point.py b/lib/action/go_to_point.py index f9c30b1c..5a5a922d 100644 --- a/lib/action/go_to_point.py +++ b/lib/action/go_to_point.py @@ -51,9 +51,9 @@ def do_turn(self, agent): inertia_pos: Vector2D = wm.self().inertia_point(self._cycle) target_rel: Vector2D = self._target - inertia_pos target_dist = target_rel.r() - max_turn = wm.self().player_type().effective_turn(SP.i().max_moment(), wm.self().vel().r()) - turn_moment: AngleDeg = target_rel.th() - wm.self().body() - if turn_moment.abs() > max_turn and turn_moment.abs() > 90.0 and target_dist < 2.0 and wm.self().stamina_model().stamina() > SP.i().recover_dec_thr_value() + 500.0: + max_turn = wm.self().player_type.effective_turn(SP.i().max_moment(), wm.self().vel.r()) + turn_moment: AngleDeg = target_rel.th() - wm.self().body + if turn_moment.abs() > max_turn and turn_moment.abs() > 90.0 and target_dist < 2.0 and wm.self().stamina_model.stamina() > SP.i().recover_dec_thr_value() + 500.0: effective_power = SP.i().max_dash_power() * wm.self().dash_rate() effective_back_power = SP.i().min_dash_power() * wm.self().dash_rate() if math.fabs(effective_back_power) > math.fabs(effective_power) * 0.75: @@ -75,21 +75,21 @@ def do_dash(self, agent): inertia_pos: Vector2D = wm.self().inertia_point(self._cycle) target_rel: Vector2D = self._target - inertia_pos - accel_angle: AngleDeg = wm.self().body() + accel_angle: AngleDeg = wm.self().body.copy() if self._back_mode: accel_angle += 180.0 target_rel.rotate(-accel_angle) - first_speed = smath.calc_first_term_geom_series(target_rel.x(), wm.self().player_type().player_decay(), + first_speed = smath.calc_first_term_geom_series(target_rel.x(), wm.self().player_type.player_decay(), self._cycle) - first_speed = smath.bound(- wm.self().player_type().player_speed_max(), first_speed, - wm.self().player_type().player_speed_max()) + first_speed = smath.bound(- wm.self().player_type.player_speed_max(), first_speed, + wm.self().player_type.player_speed_max()) if self._dash_speed > 0.0: if first_speed > 0.0: first_speed = min(first_speed, self._dash_speed) else: first_speed = max(first_speed, -self._dash_speed) - rel_vel = wm.self().vel() + rel_vel = wm.self().vel.copy() rel_vel.rotate(-accel_angle) required_accel = first_speed - rel_vel.x() if math.fabs(required_accel) < 0.05: @@ -105,33 +105,33 @@ def do_dash(self, agent): def check_collision(self, agent): wm: 'WorldModel' = agent.world() - collision_dist = wm.self().player_type().player_size() + SP.i().goal_post_radius() + 0.2 + collision_dist = wm.self().player_type.player_size() + SP.i().goal_post_radius() + 0.2 goal_post_l = Vector2D(-SP.i().pitch_half_length() + SP.i().goal_post_radius(), -SP.i().goal_half_width() - SP.i().goal_post_radius()) goal_post_r = Vector2D(-SP.i().pitch_half_length() + SP.i().goal_post_radius(), +SP.i().goal_half_width() + SP.i().goal_post_radius()) - dist_post_l = wm.self().pos().dist2(goal_post_l) - dist_post_r = wm.self().pos().dist2(goal_post_r) + dist_post_l = wm.self().pos.dist2(goal_post_l) + dist_post_r = wm.self().pos.dist2(goal_post_r) nearest_post = goal_post_l if dist_post_l > dist_post_r: nearest_post = goal_post_r dist_post = min(dist_post_l, dist_post_r) - if dist_post > collision_dist + wm.self().player_type().real_speed_max() + 0.5: + if dist_post > collision_dist + wm.self().player_type.real_speed_max() + 0.5: return post_circle = Circle2D(nearest_post, collision_dist) - move_line = Segment2D(wm.self().pos(), self._target) + move_line = Segment2D(wm.self().pos, self._target) if len(post_circle.intersection(move_line)) == 0: return - post_angle: AngleDeg = AngleDeg((nearest_post - wm.self().pos()).th()) + post_angle: AngleDeg = AngleDeg((nearest_post - wm.self().pos).th()) new_target: Vector2D = nearest_post - if post_angle.is_left_of(wm.self().body()): + if post_angle.is_left_of(wm.self().body): new_target += Vector2D.from_polar(collision_dist + 0.1, post_angle + 90.0) else: new_target += Vector2D.from_polar(collision_dist + 0.1, post_angle - 90.0) diff --git a/lib/action/hold_ball.py b/lib/action/hold_ball.py index 1ff1850a..c300e489 100644 --- a/lib/action/hold_ball.py +++ b/lib/action/hold_ball.py @@ -111,11 +111,11 @@ def avoidOpponent(self, agent: 'PlayerAgent'): if not point.is_valid(): log.sw_log().kick().add_text( "avoidOpponent() no candidate point") return False - ball_move = point - wm.ball().pos() - kick_accel = ball_move - wm.ball().vel() + ball_move = point - wm.ball().pos + kick_accel = ball_move - wm.ball().vel kick_accel_r = kick_accel.r() - agent.do_kick(kick_accel_r / wm.self().kick_rate(), - kick_accel.th() - wm.self().body()) + agent.do_kick(kick_accel_r / wm.self().kick_rate, + kick_accel.th() - wm.self().body) return True """ @@ -151,37 +151,37 @@ def createKeepPoints(self, wm: 'WorldModel', candidates): dir_divs = 20 dir_step = 360.0 / dir_divs - near_dist = wm.self().player_type().player_size() + param.ball_size() + wm.self().player_type().kickable_margin() * 0.4 - mid_dist = wm.self().player_type().player_size() + param.ball_size() + wm.self().player_type().kickable_margin() * 0.6 - far_dist = wm.self().player_type().player_size() + param.ball_size() + wm.self().player_type().kickable_margin() * 0.8 + near_dist = wm.self().player_type.player_size() + param.ball_size() + wm.self().player_type.kickable_margin() * 0.4 + mid_dist = wm.self().player_type.player_size() + param.ball_size() + wm.self().player_type.kickable_margin() * 0.6 + far_dist = wm.self().player_type.player_size() + param.ball_size() + wm.self().player_type.kickable_margin() * 0.8 # candidates = [] * dir_divs * 2 - my_next = wm.self().pos() + wm.self().vel() + my_next = wm.self().pos + wm.self().vel - my_noise = wm.self().vel().r() * param.player_rand() - current_dir_diff_rate = (wm.ball().angle_from_self() - wm.self().body()).abs() / 180.0 + my_noise = wm.self().vel.r() * param.player_rand() + current_dir_diff_rate = (wm.ball().angle_from_self - wm.self().body).abs() / 180.0 current_dist_rate = ( - wm.ball().dist_from_self() - wm.self().player_type().player_size() - param.ball_size()) / wm.self().player_type().kickable_margin() + wm.ball().dist_from_self - wm.self().player_type.player_size() - param.ball_size()) / wm.self().player_type.kickable_margin() current_pos_rate = 0.5 + 0.25 * (current_dir_diff_rate + current_dist_rate) - current_speed_rate = 0.5 + 0.5 * (wm.ball().vel().r() / (param.ball_speed_max() * param.ball_decay())) + current_speed_rate = 0.5 + 0.5 * (wm.ball().vel.r() / (param.ball_speed_max() * param.ball_decay())) angles = [-180 + a*dir_step for a in range(dir_divs)] for d in angles: angle = AngleDeg(d) - dir_diff = (angle - wm.self().body()).abs() + dir_diff = (angle - wm.self().body).abs() unit_pos = Vector2D.polar2vector(1.0, angle) # near side point near_pos = my_next + unit_pos.set_length_vector(near_dist) if (near_pos.abs_x() < max_pitch_x and near_pos.abs_y() < max_pitch_y): - ball_move = near_pos - wm.ball().pos() - kick_accel = ball_move - wm.ball().vel() + ball_move = near_pos - wm.ball().pos + kick_accel = ball_move - wm.ball().vel # can kick to the point by 1 step kick - if kick_accel.r() < param.max_power() * wm.self().kick_rate(): - near_krate = wm.self().player_type().kick_rate(near_dist, dir_diff) + if kick_accel.r() < param.max_power() * wm.self().kick_rate: + near_krate = wm.self().player_type.kick_rate(near_dist, dir_diff) # can stop the ball by 1 step kick if ball_move.r() * param.ball_decay() < param.max_power() * near_krate: candidates.append(KeepPoint(near_pos, @@ -191,9 +191,9 @@ def createKeepPoints(self, wm: 'WorldModel', candidates): mid_pos = my_next + unit_pos.set_length_vector(mid_dist) if (mid_pos.abs_x() < max_pitch_x and mid_pos.abs_y() < max_pitch_y): - ball_move = mid_pos - wm.ball().pos() - kick_accel = ball_move - wm.ball().vel() - kick_power = kick_accel.r() / wm.self().kick_rate() + ball_move = mid_pos - wm.ball().pos + kick_accel = ball_move - wm.ball().vel + kick_power = kick_accel.r() / wm.self().kick_rate # can kick to the point by 1 step kick if kick_power < param.max_power(): @@ -201,12 +201,12 @@ def createKeepPoints(self, wm: 'WorldModel', candidates): move_dist = ball_move.r() ball_noise = move_dist * param.ball_rand() - max_kick_rand = wm.self().player_type().kick_rand() * (kick_power / param.max_power()) * ( + max_kick_rand = wm.self().player_type.kick_rand() * (kick_power / param.max_power()) * ( current_pos_rate + current_speed_rate) # move noise is small if ((my_noise + ball_noise + max_kick_rand) * 0.95 - < wm.self().player_type().kickable_area() - mid_dist - 0.1): - mid_krate = wm.self().player_type().kick_rate(mid_dist, dir_diff) + < wm.self().player_type.kickable_area() - mid_dist - 0.1): + mid_krate = wm.self().player_type.kick_rate(mid_dist, dir_diff) # can stop the ball by 1 step kick if move_dist * param.ball_decay() < param.max_power() * mid_krate: candidates.append(KeepPoint(mid_pos, @@ -217,21 +217,21 @@ def createKeepPoints(self, wm: 'WorldModel', candidates): far_pos = my_next + unit_pos.set_length_vector(far_dist) if (far_pos.abs_x() < max_pitch_x and far_pos.abs_y() < max_pitch_y): - ball_move = far_pos - wm.ball().pos() - kick_accel = ball_move - wm.ball().vel() - kick_power = kick_accel.r() / wm.self().kick_rate() + ball_move = far_pos - wm.ball().pos + kick_accel = ball_move - wm.ball().vel + kick_power = kick_accel.r() / wm.self().kick_rate # can kick to the point by 1 step kick if kick_power < param.max_power(): # check move noise move_dist = ball_move.r() ball_noise = move_dist * param.ball_rand() - max_kick_rand = wm.self().player_type().kick_rand() * (kick_power / param.max_power()) * ( + max_kick_rand = wm.self().player_type.kick_rand() * (kick_power / param.max_power()) * ( current_pos_rate + current_speed_rate) # move noise is small if ((my_noise + ball_noise + max_kick_rand) * 0.95 - < wm.self().player_type().kickable_area() - far_dist - 0.1): - far_krate = wm.self().player_type().kick_rate(far_dist, dir_diff) + < wm.self().player_type.kickable_area() - far_dist - 0.1): + far_krate = wm.self().player_type.kick_rate(far_dist, dir_diff) # can stop the ball by 1 step kick if move_dist * param.ball_decay(): candidates.append(KeepPoint(far_pos, @@ -249,7 +249,7 @@ def evaluateKeepPoints(self, wm: 'WorldModel', keep_points): for it in keep_points: it.score_ = self.evaluateKeepPoint(wm, it.pos_) if it.score_ < DEFAULT_SCORE: - it.score_ += it.pos_.dist(wm.ball().pos()) + it.score_ += it.pos_.dist(wm.ball().pos) else: it.score_ += it.kick_rate_ * 1000.0 @@ -271,26 +271,26 @@ def evaluateKeepPoint(self, wm: 'WorldModel', param = ServerParam.i() score = DEFAULT_SCORE - my_next = wm.self().pos() + wm.self().vel() + my_next = wm.self().pos + wm.self().vel if len(wm.opponents_from_ball()) == 0: return score for o in wm.opponents_from_ball(): - if o is None or o.player_type() is None: + if o is None or o.player_type is None: continue - if o.dist_from_ball() > consider_dist: + if o.dist_from_ball > consider_dist: break - if o.pos_count() > 10: + if o.pos_count > 10: continue if o.is_ghost(): continue if o.is_tackling(): continue - player_type = o.player_type() - opp_next = o.pos() + o.vel() - control_area = o.player_type().catchable_area() if ( - o.goalie() and penalty_area.contains(o.pos()) and penalty_area.contains( - keep_point)) else o.player_type().kickable_area() + player_type = o.player_type + opp_next = o.pos + o.vel + control_area = o.player_type.catchable_area() if ( + o.goalie and penalty_area.contains(o.pos) and penalty_area.contains( + keep_point)) else o.player_type.kickable_area() opp_dist = opp_next.dist(keep_point) if opp_dist < control_area * 0.5: @@ -305,11 +305,11 @@ def evaluateKeepPoint(self, wm: 'WorldModel', score -= 25.0 - if o.body_count() == 0: - opp_body = o.body() + if o.body_count == 0: + opp_body = o.body - elif o.vel().r() > 0.2: # o.velCount() <= 1 #and - opp_body = o.vel().th() + elif o.vel.r() > 0.2: # o.velCount() <= 1 #and + opp_body = o.vel.th() else: opp_body = (my_next - opp_next).th() @@ -361,10 +361,10 @@ def evaluateKeepPoint(self, wm: 'WorldModel', and player_2_pos.x() - max_accel < param.tackle_dist() - 0.25): score -= 10.0 - ball_move_dist = (keep_point - wm.ball().pos()).r() - if ball_move_dist > wm.self().player_type().kickable_area() * 1.6: + ball_move_dist = (keep_point - wm.ball().pos).r() + if ball_move_dist > wm.self().player_type.kickable_area() * 1.6: next_ball_dist = my_next.dist(keep_point) - threshold = wm.self().player_type().kickable_area() - 0.4 + threshold = wm.self().player_type.kickable_area() - 0.4 rate = 1.0 - 0.5 * max(0.0, (next_ball_dist - threshold) / 0.4) score *= rate return score @@ -380,19 +380,19 @@ def turnToPoint(self, agent: 'PlayerAgent'): max_pitch_x = param.pitch_half_length() - 0.2 max_pitch_y = param.pitch_half_width() - 0.2 wm = agent.world() - my_next = wm.self().pos() + wm.self().vel() - ball_next = wm.ball().pos() + wm.ball().vel() + my_next = wm.self().pos + wm.self().vel + ball_next = wm.ball().pos + wm.ball().vel if (ball_next.abs_x() > max_pitch_x or ball_next.abs_y() > max_pitch_y): return False - my_noise = wm.self().vel().r() * param.player_rand() - ball_noise = wm.ball().vel().r() * param.ball_rand() + my_noise = wm.self().vel.r() * param.player_rand() + ball_noise = wm.ball().vel.r() * param.ball_rand() next_ball_dist = my_next.dist(ball_next) - if (next_ball_dist > (wm.self().player_type().kickable_area() + if (next_ball_dist > (wm.self().player_type.kickable_area() - my_noise - ball_noise - 0.15)): @@ -406,7 +406,7 @@ def turnToPoint(self, agent: 'PlayerAgent'): my_inertia = wm.self().inertia_final_point() target_angle = (face_point - my_inertia).th() - if (wm.self().body() - target_angle).abs() < 5.0: + if (wm.self().body - target_angle).abs() < 5.0: return False score = self.evaluateKeepPoint(wm, ball_next) @@ -428,19 +428,19 @@ def keepFront(self, agent: 'PlayerAgent'): max_pitch_y = param.pitch_half_width() - 0.2 wm = agent.world() - front_keep_dist = wm.self().player_type().player_size() + param.ball_size() + 0.05 + front_keep_dist = wm.self().player_type.player_size() + param.ball_size() + 0.05 - my_next = wm.self().pos() + wm.self().vel() + my_next = wm.self().pos + wm.self().vel - front_pos = my_next + Vector2D.polar2vector(front_keep_dist, wm.self().body()) + front_pos = my_next + Vector2D.polar2vector(front_keep_dist, wm.self().body) if (front_pos.abs_x() > max_pitch_x or front_pos.abs_y() > max_pitch_y): return False - ball_move = front_pos - wm.ball().pos() - kick_accel = ball_move - wm.ball().vel() - kick_power = kick_accel.r() / wm.self().kick_rate() + ball_move = front_pos - wm.ball().pos + kick_accel = ball_move - wm.ball().vel + kick_power = kick_accel.r() / wm.self().kick_rate # can kick to the point by 1 step kick if kick_power > param.max_power(): @@ -452,7 +452,7 @@ def keepFront(self, agent: 'PlayerAgent'): return False agent.do_kick(kick_power, - kick_accel.th() - wm.self().body()) + kick_accel.th() - wm.self().body) return True """ @@ -469,25 +469,25 @@ def keepReverse(self, agent: 'PlayerAgent'): max_pitch_y = param.pitch_half_width() - 0.2 wm = agent.world() - my_inertia = wm.self().pos() + wm.self().vel() + my_inertia = wm.self().pos + wm.self().vel - my_noise = wm.self().vel().r() * param.player_rand() - current_dir_diff_rate = (wm.ball().angle_from_self() - wm.self().body()).abs() / 180.0 + my_noise = wm.self().vel.r() * param.player_rand() + current_dir_diff_rate = (wm.ball().angle_from_self - wm.self().body).abs() / 180.0 - current_dist_rate = (wm.ball().dist_from_self() - - wm.self().player_type().player_size() - - param.ball_size()) / wm.self().player_type().kickable_margin() + current_dist_rate = (wm.ball().dist_from_self + - wm.self().player_type.player_size() + - param.ball_size()) / wm.self().player_type.kickable_margin() current_pos_rate = 0.5 + 0.25 * (current_dir_diff_rate + current_dist_rate) - current_speed_rate = 0.5 + 0.5 * (wm.ball().vel().r() / (param.ball_speed_max() * param.ball_decay())) + current_speed_rate = 0.5 + 0.5 * (wm.ball().vel.r() / (param.ball_speed_max() * param.ball_decay())) keep_angle = (my_inertia - self._kick_target_point).th() - dir_diff = (keep_angle - wm.self().body()).abs() - min_dist = (wm.self().player_type().player_size() + dir_diff = (keep_angle - wm.self().body).abs() + min_dist = (wm.self().player_type.player_size() + param.ball_size() + 0.2) - keep_dist = wm.self().player_type().player_size() + wm.self().player_type().kickable_margin() * 0.7 + param.ball_size() + keep_dist = wm.self().player_type.player_size() + wm.self().player_type.kickable_margin() * 0.7 + param.ball_size() while keep_dist > min_dist: @@ -498,29 +498,29 @@ def keepReverse(self, agent: 'PlayerAgent'): or keep_pos.abs_y() > max_pitch_y): continue - ball_move = keep_pos - wm.ball().pos() - kick_accel = ball_move - wm.ball().vel() - kick_power = kick_accel.r() / wm.self().kick_rate() + ball_move = keep_pos - wm.ball().pos + kick_accel = ball_move - wm.ball().vel + kick_power = kick_accel.r() / wm.self().kick_rate if kick_power > param.max_power(): continue move_dist = ball_move.r() ball_noise = move_dist * param.ball_rand() - max_kick_rand = wm.self().player_type().kick_rand() * (kick_power / param.max_power()) * ( + max_kick_rand = wm.self().player_type.kick_rand() * (kick_power / param.max_power()) * ( current_pos_rate + current_speed_rate) - if (my_noise + ball_noise + max_kick_rand) > wm.self().player_type().kickable_area() - keep_dist - 0.1: + if (my_noise + ball_noise + max_kick_rand) > wm.self().player_type.kickable_area() - keep_dist - 0.1: continue - new_krate = wm.self().player_type().kick_rate(keep_dist, dir_diff) + new_krate = wm.self().player_type.kick_rate(keep_dist, dir_diff) if move_dist * param.ball_decay() > new_krate * param.max_power(): continue score = self.evaluateKeepPoint(wm, keep_pos) if score >= DEFAULT_SCORE: agent.do_kick(kick_power, - kick_accel.th() - wm.self().body()) + kick_accel.th() - wm.self().body) return True return False diff --git a/lib/action/intercept.py b/lib/action/intercept.py index 4b79342b..2239410c 100644 --- a/lib/action/intercept.py +++ b/lib/action/intercept.py @@ -52,7 +52,7 @@ def execute(self, agent: 'PlayerAgent'): if best_intercept.dash_cycle() == 0: face_point = self._face_point.copy() if not face_point.is_valid(): - face_point.assign(50.5, wm.self().pos().y() * 0.75) + face_point.assign(50.5, wm.self().pos.y() * 0.75) log.sw_log().intercept().add_text( f"best_intercept.dash_cycle() == 0 (TurnToPoint)") @@ -72,17 +72,17 @@ def execute(self, agent: 'PlayerAgent'): log.sw_log().intercept().add_text( f"best_intercept.turn_cycle() > 0 (do_turn)") - return agent.do_turn(target_angle - wm.self().body()) + return agent.do_turn(target_angle - wm.self().body) if self.do_wait_turn(agent, target_point, best_intercept): return True - if self._save_recovery and not wm.self().stamina_model().capacity_is_empty(): + if self._save_recovery and not wm.self().stamina_model.capacity_is_empty(): consumed_stamina = best_intercept.dash_power() if best_intercept.dash_power() < 0: consumed_stamina *= -2 - if (wm.self().stamina() - consumed_stamina + if (wm.self().stamina_model.stamina() - consumed_stamina < ServerParam.i().recover_dec_thr_value() + 1): log.sw_log().intercept().add_text( f"last if (do turn)") @@ -102,12 +102,12 @@ def execute(self, agent: 'PlayerAgent'): def do_kickable_opponent_check(self, agent: 'PlayerAgent') -> bool: wm = agent.world() - if wm.ball().dist_from_self() < 2 and wm.exist_kickable_opponents(): + if wm.ball().dist_from_self < 2 and wm.exist_kickable_opponents(): opp: PlayerObject = wm.opponents_from_ball()[0] if opp is not None: goal_pos = Vector2D(-ServerParam.i().pitch_half_length(), 0) - my_next = wm.self().pos() + wm.self().vel() - attack_pos = opp.pos() + opp.vel() + my_next = wm.self().pos + wm.self().vel + attack_pos = opp.pos + opp.vel if attack_pos.dist2(goal_pos) > my_next.dist2(goal_pos): log.sw_log().intercept().add_text( @@ -140,7 +140,7 @@ def get_best_intercept(self, wm: 'WorldModel', max_pitch_y = SP.pitch_half_width() - 1 penalty_x = SP.our_penalty_area_line_x() penalty_y = SP.penalty_area_half_width() - speed_max = wm.self().player_type().real_speed_max() * 0.9 + speed_max = wm.self().player_type.real_speed_max() * 0.9 opp_min = table.opponent_reach_cycle() mate_min = table.teammate_reach_cycle() @@ -171,19 +171,19 @@ def get_best_intercept(self, wm: 'WorldModel', cycle = cache[i].reach_cycle() self_pos = wm.self().inertia_point(cycle) ball_pos = wm.ball().inertia_point(cycle) - ball_vel = wm.ball().vel() * SP.ball_decay() ** cycle + ball_vel = wm.ball().vel * SP.ball_decay() ** cycle if ball_pos.abs_x() > max_pitch_x or \ ball_pos.abs_y() > max_pitch_y: continue - if (wm.self().goalie() + if (wm.self().goalie and wm.last_kicker_side() != wm.our_side() and ball_pos.x() < penalty_x - 1 and ball_pos.abs_y() < penalty_y - 1 and cycle < opp_min - 1): if ((cache[i].turn_cycle() == 0 - and cache[i].ball_dist() < wm.self().player_type().catchable_area() * 0.5) + and cache[i].ball_dist() < wm.self().player_type.catchable_area() * 0.5) or cache[i].ball_dist() < 0.01): d = ball_pos.dist2(our_goal_pos) if d > goalie_score: @@ -252,7 +252,7 @@ def get_best_intercept(self, wm: 'WorldModel', return attacker_best if noturn_best is not None and forward_best is not None: - noturn_ball_vel = (wm.ball().vel() + noturn_ball_vel = (wm.ball().vel * SP.ball_decay() ** noturn_best.reach_cycle()) noturn_ball_speed = noturn_ball_vel.r() if (noturn_ball_vel.x() > 0.1 @@ -264,7 +264,7 @@ def get_best_intercept(self, wm: 'WorldModel', return forward_best fastest_pos = wm.ball().inertia_point(cache[0].reach_cycle()) - fastest_vel = wm.ball().vel() * SP.ball_decay() ** cache[0].reach_cycle() + fastest_vel = wm.ball().vel * SP.ball_decay() ** cache[0].reach_cycle() if ((fastest_pos.x() > -33 or fastest_pos.abs_y() > 20) @@ -282,15 +282,15 @@ def get_best_intercept(self, wm: 'WorldModel', return noturn_best if nearest_best.reach_cycle() <= noturn_best.reach_cycle() + 2: - nearest_ball_vel = (wm.ball().vel() + nearest_ball_vel = (wm.ball().vel * SP.ball_decay() ** nearest_best.reach_cycle()) nearest_ball_speed = nearest_ball_vel.r() if nearest_ball_speed < 0.7: return nearest_best - noturn_ball_vel = (wm.ball().vel() + noturn_ball_vel = (wm.ball().vel * SP.ball_decay() ** noturn_best.reach_cycle()) - if (nearest_best.ball_dist() < wm.self().player_type().kickable_area() - 0.4 + if (nearest_best.ball_dist() < wm.self().player_type.kickable_area() - 0.4 and nearest_best.ball_dist() < noturn_best.ball_dist() and noturn_ball_vel.x() < 0.5 and noturn_ball_vel.r2() > 1 ** 2 @@ -299,7 +299,7 @@ def get_best_intercept(self, wm: 'WorldModel', nearest_self_pos = wm.self().inertia_point(nearest_best.reach_cycle()) if nearest_ball_speed > 0.7 and \ - nearest_self_pos.dist2(nearest_ball_pos) < wm.self().player_type().kickable_area(): + nearest_self_pos.dist2(nearest_ball_pos) < wm.self().player_type.kickable_area(): return nearest_best return noturn_best @@ -309,9 +309,9 @@ def get_best_intercept(self, wm: 'WorldModel', if nearest_best is not None: return nearest_best - if (wm.self().pos().x() > 40 - and wm.ball().vel().r() > 1.8 - and wm.ball().vel().th().abs() < 100 + if (wm.self().pos.x() > 40 + and wm.ball().vel.r() > 1.8 + and wm.ball().vel.th().abs() < 100 and cache[0].reach_cycle() > 1): chance_best: InterceptInfo = None for i in range(MAX): @@ -330,17 +330,17 @@ def do_wait_turn(self, info: InterceptInfo): wm = agent.world() opp: PlayerObject = wm.get_opponent_nearest_to_self(5) - if opp is not None and opp.dist_from_self() < 3: + if opp is not None and opp.dist_from_self < 3: return False opp_min = wm.intercept_table().opponent_reach_cycle() if info.reach_cycle() > opp_min - 5: return False my_inertia = wm.self().inertia_point(info.reach_cycle()) - target_rel = (target_point - my_inertia).rotated_vector(-wm.self().body()) + target_rel = (target_point - my_inertia).rotated_vector(-wm.self().body) target_dist = target_rel.r() - ball_travel = inertia_n_step_distance(wm.ball().vel().r(), + ball_travel = inertia_n_step_distance(wm.ball().vel.r(), info.reach_cycle(), ServerParam.i().ball_decay()) ball_noise = ball_travel * ServerParam.i().ball_rand() @@ -348,7 +348,7 @@ def do_wait_turn(self, if info.reach_cycle() == 1 and info.turn_cycle() == 1: face_point = self._face_point if not face_point.is_valid(): - face_point.assign(50.5, wm.self().pos().y() * 0.9) + face_point.assign(50.5, wm.self().pos.y() * 0.9) log.sw_log().intercept().add_text( f"do wait turn (1) (TurnToPoint)") @@ -360,31 +360,31 @@ def do_wait_turn(self, return True extra_buf = 0.1 * bound(0, info.reach_cycle() - 1, 4) - angle_diff = (wm.ball().vel().th() - wm.self().body()).abs() + angle_diff = (wm.ball().vel.th() - wm.self().body).abs() if angle_diff < 10 or 170 < angle_diff: extra_buf = 0 - dist_buf = wm.self().player_type().kickable_area() - 0.3 + extra_buf - dist_buf -= 0.1 * wm.ball().seen_pos_count() + dist_buf = wm.self().player_type.kickable_area() - 0.3 + extra_buf + dist_buf -= 0.1 * wm.ball().seen_pos_count if target_dist > dist_buf: return False face_point = self._face_point if info.reach_cycle() > 2: - face_point = my_inertia + (wm.ball().pos() - my_inertia).rotated_vector(90) + face_point = my_inertia + (wm.ball().pos - my_inertia).rotated_vector(90) if face_point.x() < my_inertia.x(): - face_point = my_inertia + (wm.ball().pos() - my_inertia).rotated_vector(-90) + face_point = my_inertia + (wm.ball().pos - my_inertia).rotated_vector(-90) if not face_point.is_valid(): - face_point.assign(50.5, wm.self().pos().y() * 0.9) + face_point.assign(50.5, wm.self().pos.y() * 0.9) face_rel = face_point - my_inertia face_angle = face_rel.th() faced_rel = target_point - my_inertia faced_rel.rotate(face_angle) - if faced_rel.abs_y() > wm.self().player_type().kickable_area() - ball_noise - 0.2: + if faced_rel.abs_y() > wm.self().player_type.kickable_area() - ball_noise - 0.2: return False log.sw_log().intercept().add_text( @@ -401,23 +401,23 @@ def do_inertia_dash(self, target_point: Vector2D, info: InterceptInfo): wm = agent.world() - ptype = wm.self().player_type() + ptype = wm.self().player_type if info.reach_cycle() == 1: agent.do_dash(info.dash_power(), info.dash_angle()) return True - target_rel = target_point - wm.self().pos() - target_rel.rotate(-wm.self().body()) + target_rel = target_point - wm.self().pos + target_rel.rotate(-wm.self().body) - accel_angle = wm.self().body() + accel_angle = wm.self().body.copy() if info.dash_power() < 0: accel_angle += 180 - ball_vel = wm.ball().vel() * ServerParam.i().ball_decay() ** info.reach_cycle() - if ((not wm.self().goalie() + ball_vel = wm.ball().vel * ServerParam.i().ball_decay() ** info.reach_cycle() + if ((not wm.self().goalie or wm.last_kicker_side() == wm.our_side()) - and wm.self().body().abs() < 50): + and wm.self().body.abs() < 50): buf = 0.3 if info.reach_cycle() >= 8: buf = 0 @@ -447,11 +447,11 @@ def do_inertia_dash(self, target_rel -= Vector2D(buf, 0) used_power = info.dash_power() - if (wm.ball().seen_pos_count() <= 2 - and wm.ball().vel().r() * ServerParam.i().ball_decay() ** info.reach_cycle() < ptype.kickable_area() * 1.5 + if (wm.ball().seen_pos_count <= 2 + and wm.ball().vel.r() * ServerParam.i().ball_decay() ** info.reach_cycle() < ptype.kickable_area() * 1.5 and info.dash_angle().abs() < 5 and target_rel.abs_x() < (ptype.kickable_area() - + ptype.dash_rate(wm.self().effort()) + + ptype.dash_rate(wm.self().stamina_model.effort()) * ServerParam.i().max_dash_power() * 0.8)): first_speed = calc_first_term_geom_series(target_rel.x(), @@ -460,7 +460,7 @@ def do_inertia_dash(self, first_speed = min_max(-ptype.player_speed_max(), first_speed, ptype.player_speed_max()) - rel_vel = wm.self().vel().rotated_vector(-wm.self().body()) + rel_vel = wm.self().vel.rotated_vector(-wm.self().body) required_accel = first_speed - rel_vel.x() used_power = required_accel / wm.self().dash_rate() used_power /= ServerParam.i().dash_dir_rate(info.dash_angle().degree()) @@ -475,10 +475,10 @@ def do_inertia_dash(self, my_inertia = wm.self().inertia_point(info.reach_cycle()) face_point = self._face_point if not face_point.is_valid(): - face_point.assign(50.5, wm.self().pos().y() * 0.75) + face_point.assign(50.5, wm.self().pos.y() * 0.75) face_angle = (face_point - my_inertia).th() - ball_next = wm.ball().pos() + wm.ball().vel() + ball_next = wm.ball().pos + wm.ball().vel ball_angle = (ball_next - my_inertia).th() # normal_half_width = ViewWidth.width(ViewWidth.Mode.NORMAL) # TODO FIX THIS after view mode normal_half_width = ServerParam.i().visible_angle() diff --git a/lib/action/intercept_player.py b/lib/action/intercept_player.py index d52d1664..e5875c98 100644 --- a/lib/action/intercept_player.py +++ b/lib/action/intercept_player.py @@ -25,23 +25,23 @@ def predict(self, penalty_x_abs = ServerParam.i().pitch_half_length() - ServerParam.i().penalty_area_length() penalty_y_abs = ServerParam.i().penalty_area_half_width() - pos_count = min(player.seen_pos_count(), player.pos_count()) - player_pos = (player.seen_pos() - if player.seen_pos_count() <= player.pos_count() - else player.pos()) + pos_count = min(player.seen_pos_count, player.pos_count) + player_pos = (player.seen_pos + if player.seen_pos_count <= player.pos_count + else player.pos) min_cycle = 0 - ball_to_player = player_pos - wm.ball().pos() - ball_to_player.rotate(-wm.ball().vel().th()) + ball_to_player = player_pos - wm.ball().pos + ball_to_player.rotate(-wm.ball().vel.th()) min_cycle = int(floor(ball_to_player.abs_y() / player_type.real_speed_max())) if player.is_tackling(): min_cycle += max(0, - ServerParam.i().tackle_cycles() - player.tackle_count() - 2) + ServerParam.i().tackle_cycles() - player.tackle_count - 2) min_cycle = max(0, - min_cycle - min(player.seen_pos_count(), - player.pos_count())) + min_cycle - min(player.seen_pos_count, + player.pos_count)) if min_cycle > max_cycle: return self.predict_final(player, player_type) @@ -50,7 +50,7 @@ def predict(self, for cycle in range(min_cycle, MAX_LOOP): ball_pos: Vector2D = self._ball_cache[cycle] control_area = (player_type.catchable_area() - if (player.goalie() + if (player.goalie and ball_pos.abs_x() > penalty_x_abs and ball_pos.abs_y() < penalty_y_abs) else player_type.kickable_area()) @@ -73,19 +73,19 @@ def predict_final(self, player: PlayerObject, player_type: PlayerType): penalty_x_abs = ServerParam.i().pitch_half_length() - ServerParam.i().penalty_area_length() penalty_y_abs = ServerParam.i().penalty_area_half_width() - pos_count = min(player.seen_pos_count(), player.pos_count()) - ppos = (player.seen_pos() - if player.seen_pos_count() <= player.pos_count() - else player.pos()) - pvel = (player.seen_vel() - if player.seen_vel_count() <= player.vel_count() - else player.vel()) + pos_count = min(player.seen_pos_count, player.pos_count) + ppos = (player.seen_pos + if player.seen_pos_count <= player.pos_count + else player.pos) + pvel = (player.seen_vel + if player.seen_vel_count <= player.vel_count + else player.vel) ball_pos = self._ball_cache[-1] ball_step = len(self._ball_cache) control_area = (player_type.catchable_area() - if (player.goalie() + if (player.goalie and ball_pos.abs_x() > penalty_x_abs and ball_pos.abs_y() < penalty_y_abs) else player_type.kickable_area()) @@ -100,15 +100,15 @@ def predict_final(self, player: PlayerObject, player_type: PlayerType): dash_dist = inertia_pos.dist(ball_pos) dash_dist -= control_area - if player.side() != wm.our_side(): - dash_dist -= player.dist_from_self() * 0.03 + if player.side != wm.our_side(): + dash_dist -= player.dist_from_self * 0.03 if dash_dist < 0: return ball_step n_dash = player_type.cycles_to_reach_distance(dash_dist) - if player.side() != wm.our_side(): + if player.side != wm.our_side(): n_dash -= bound(0, pos_count - n_turn, 10) else: n_dash -= bound(0, pos_count - n_turn, 1) @@ -123,12 +123,12 @@ def predict_turn_cycle(self, player_type: PlayerType, control_area: float, ball_pos: Vector2D): - ppos = (player.seen_pos() - if player.seen_pos_count() <= player.pos_count() - else player.pos()) - pvel = (player.seen_vel() - if player.seen_vel_count() <= player.vel_count() - else player.vel()) + ppos = (player.seen_pos + if player.seen_pos_count <= player.pos_count + else player.pos) + pvel = (player.seen_vel + if player.seen_vel_count <= player.vel_count + else player.vel) inertia_pos = player_type.inertia_point(ppos, pvel, cycle) target_rel = ball_pos - inertia_pos @@ -138,7 +138,7 @@ def predict_turn_cycle(self, turn_margin = AngleDeg.asin_deg(control_area / target_dist) turn_margin = max(turn_margin, 12) - angle_diff = (target_rel.th() - player.body()).abs() + angle_diff = (target_rel.th() - player.body).abs() if (target_dist < 5 # XXX MAGIC NUMBER XXX :| and angle_diff > 90): @@ -146,7 +146,7 @@ def predict_turn_cycle(self, angle_diff = 180 - angle_diff n_turn = 0 - speed = player.vel().r() + speed = player.vel.r() while angle_diff > turn_margin: max_turn = player_type.effective_turn(ServerParam.i().max_moment(), speed) @@ -187,13 +187,13 @@ def can_reach_after_dash(self, control_area: float, ball_pos: Vector2D): wm = self._wm - pos_count = min(player.seen_pos_count(), player.pos_count()) - ppos = (player.seen_pos() - if player.seen_pos_count() <= player.pos_count() - else player.pos()) - pvel = (player.seen_vel() - if player.seen_vel_count() <= player.vel_count() - else player.vel()) + pos_count = min(player.seen_pos_count, player.pos_count) + ppos = (player.seen_pos + if player.seen_pos_count <= player.pos_count + else player.pos) + pvel = (player.seen_vel + if player.seen_vel_count <= player.vel_count + else player.vel) player_pos = inertia_n_step_point(ppos, pvel, n_turn + max_dash, @@ -211,14 +211,14 @@ def can_reach_after_dash(self, if player.side != wm.our_side(): n_dash -= bound(0, pos_count - n_turn, - min(6, wm.ball().seen_pos_count() + 1)) + min(6, wm.ball().seen_pos_count + 1)) else: n_dash -= bound(0, pos_count - n_turn, - min(1, wm.ball().seen_pos_count())) + min(1, wm.ball().seen_pos_count)) if player.is_tackling(): - n_dash += max(0, ServerParam.i().tackle_cycles() - player.tackle_count() - 2) + n_dash += max(0, ServerParam.i().tackle_cycles() - player.tackle_count - 2) if n_dash <= max_dash: return True diff --git a/lib/action/intercept_self.py b/lib/action/intercept_self.py index 9eaadc6a..d8cff8f0 100644 --- a/lib/action/intercept_self.py +++ b/lib/action/intercept_self.py @@ -36,7 +36,7 @@ def predict(self, max_cycle, self_cache: list): log.sw_log().intercept().add_text("no ball position cache :(") return - save_recovery: bool = self._wm.self().stamina_model().capacity() != 0 + save_recovery: bool = self._wm.self().stamina_model.capacity() != 0 self.predict_one_step(self_cache) self.predict_short_step(max_cycle, save_recovery, self_cache) @@ -49,16 +49,16 @@ def predict(self, max_cycle, self_cache: list): def predict_one_step(self, self_cache): wm = self._wm - ball_next: Vector2D = wm.ball().pos() + wm.ball().vel() + ball_next: Vector2D = wm.ball().pos + wm.ball().vel goalie_mode: bool = self.is_goalie_mode(ball_next) - control_area: float = wm.self().player_type().catchable_area() if \ + control_area: float = wm.self().player_type.catchable_area() if \ goalie_mode else \ - wm.self().player_type().kickable_area() + wm.self().player_type.kickable_area() # dist is to far never reach with one dash - if wm.ball().dist_from_self() > \ + if wm.ball().dist_from_self > \ ServerParam.i().ball_speed_max() \ - + wm.self().player_type().real_speed_max() \ + + wm.self().player_type.real_speed_max() \ + control_area: return if self.predict_no_dash(self_cache): @@ -71,14 +71,14 @@ def predict_no_dash(self, self_cache) -> bool: wm: 'WorldModel' = self._wm me: PlayerObject = wm.self() - my_next: Vector2D = me.pos() + me.vel() - ball_next: Vector2D = wm.ball().pos() + wm.ball().vel() + my_next: Vector2D = me.pos + me.vel + ball_next: Vector2D = wm.ball().pos + wm.ball().vel goalie_mode: bool = self.is_goalie_mode(ball_next) - control_area: float = me.player_type().catchable_area() if \ + control_area: float = me.player_type.catchable_area() if \ goalie_mode else \ - me.player_type().kickable_area() - next_ball_rel: Vector2D = (ball_next - my_next).rotated_vector(-me.body()) - ball_noise: float = wm.ball().vel().r() * SP.ball_rand() + me.player_type.kickable_area() + next_ball_rel: Vector2D = (ball_next - my_next).rotated_vector(-me.body) + ball_noise: float = wm.ball().vel.r() * SP.ball_rand() next_ball_dist: float = next_ball_rel.r() # out of control area @@ -88,8 +88,8 @@ def predict_no_dash(self, self_cache) -> bool: # if goalie immediately success if goalie_mode: - stamina_model: StaminaModel = me.stamina_model() - stamina_model.simulate_wait(me.player_type()) + stamina_model: StaminaModel = me.stamina_model.copy() + stamina_model.simulate_wait(me.player_type) self_cache.append(InterceptInfo(InterceptInfo.Mode.NORMAL, 1, 0, @@ -101,17 +101,17 @@ def predict_no_dash(self, self_cache) -> bool: return True # check kick effectiveness - ptype: PlayerType = me.player_type() + ptype: PlayerType = me.player_type if next_ball_dist > ptype.player_size() + SP.ball_size(): kick_rate: float = ptype.kick_rate(next_ball_dist, next_ball_rel.th().degree()) - next_ball_vel: Vector2D = wm.ball().vel() * SP.ball_decay() + next_ball_vel: Vector2D = wm.ball().vel * SP.ball_decay() if SP.max_power() * kick_rate <= next_ball_vel.r() * SP.ball_decay() * 1.1: log.sw_log().intercept().add_text("------>>>>> NO can not control the ball") return False # at least, player can stop the ball - stamina_model = me.stamina_model() + stamina_model = me.stamina_model.copy() self_cache.append(InterceptInfo(InterceptInfo.Mode.NORMAL, 1, 0, # 1 turn 0, 0, @@ -128,7 +128,7 @@ def is_goalie_mode(self, ball_next, x_limit=None, abs_y_limit=None) -> bool: if abs_y_limit is None: abs_y_limit = ServerParam.i().penalty_area_half_width() - return (wm.self().goalie() and + return (wm.self().goalie and wm.last_kicker_side() != wm.our_side() and ball_next.x() < x_limit and ball_next.abs_y() < abs_y_limit) @@ -141,9 +141,9 @@ def predict_one_dash(self, self_cache): wm: 'WorldModel' = self._wm ball: BallObject = wm.ball() me: PlayerObject = wm.self() - ptype: PlayerType = me.player_type() + ptype: PlayerType = me.player_type - ball_next: Vector2D = ball.pos() + ball.vel() + ball_next: Vector2D = ball.pos + ball.vel goalie_mode: bool = self.is_goalie_mode(ball_next) control_area: float = ptype.catchable_area() if \ goalie_mode else \ @@ -159,24 +159,24 @@ def predict_one_dash(self, self_cache): n_steps = int((max_dash_angle - min_dash_angle) / dash_angle_step) dirs = [min_dash_angle + d * dash_angle_step for d in range(n_steps)] for dash_dir in dirs: - dash_angle: AngleDeg = me.body() + SP.discretize_dash_angle(SP.normalize_dash_angle(dash_dir)) + dash_angle: AngleDeg = me.body + SP.discretize_dash_angle(SP.normalize_dash_angle(dash_dir)) dash_rate: float = me.dash_rate() * SP.dash_dir_rate(dash_dir) log.sw_log().intercept().add_text(f"----- dash dir={dash_dir}, angle={dash_angle}, dash_rate={dash_rate}") # check recovery save dash forward_dash_power = bound(0, - me.stamina() - SP.recover_dec_thr_value() - 1, + me.stamina_model.stamina() - SP.recover_dec_thr_value() - 1, SP.max_dash_power()) back_dash_power = bound(SP.min_dash_power(), - (me.stamina() - SP.recover_dec_thr_value() - 1) * -0.5, + (me.stamina_model.stamina() - SP.recover_dec_thr_value() - 1) * -0.5, 0) max_forward_accel = Vector2D.polar2vector(forward_dash_power * dash_rate, dash_angle) max_back_accel = Vector2D.polar2vector(back_dash_power * dash_rate, dash_angle) - ptype.normalize_accel(me.vel(), max_forward_accel) - ptype.normalize_accel(me.vel(), max_back_accel) + ptype.normalize_accel(me.vel, max_forward_accel) + ptype.normalize_accel(me.vel, max_back_accel) info: InterceptInfo = InterceptInfo() if self.predict_one_dash_adjust(dash_angle, @@ -198,8 +198,8 @@ def predict_one_dash(self, self_cache): dash_angle) max_back_accel = Vector2D.polar2vector(SP.min_dash_power() * dash_rate, dash_angle) - ptype.normalize_accel(me.vel(), max_forward_accel) - ptype.normalize_accel(me.vel(), max_back_accel) + ptype.normalize_accel(me.vel, max_forward_accel) + ptype.normalize_accel(me.vel, max_back_accel) info: InterceptInfo = InterceptInfo() if self.predict_one_dash_adjust(dash_angle, @@ -234,9 +234,9 @@ def predict_one_dash_adjust(self, me = wm.self() control_buf = control_area - 0.075 - dash_dir: AngleDeg = dash_angle - me.body() - ball_next = wm.ball().pos() + wm.ball().vel() - me_next = me.pos() + me.vel() + dash_dir: AngleDeg = dash_angle - me.body + ball_next = wm.ball().pos + wm.ball().vel + me_next = me.pos + me.vel ball_rel: Vector2D = (ball_next - me_next).rotated_vector(-dash_angle) forward_accel_rel: Vector2D = max_forward_accel.rotated_vector(-dash_angle) @@ -302,11 +302,11 @@ def predict_one_dash_adjust(self, mode = InterceptInfo.Mode.NORMAL accel = Vector2D.polar2vector(dash_power * dash_rate, dash_angle) - my_vel = me.vel() + accel - my_pos = me.pos() + my_vel + my_vel = me.vel + accel + my_pos = me.pos + my_vel - stamina_model = me.stamina_model() - stamina_model.simulate_dash(me.player_type(), dash_power) + stamina_model = me.stamina_model.copy() + stamina_model.simulate_dash(me.player_type, dash_power) if stamina_model.stamina() < SP.recover_dec_thr_value() and \ not stamina_model.capacity_is_empty(): @@ -334,7 +334,7 @@ def get_one_step_dash_power(self, wm = self._wm dash_rate = wm.self().dash_rate() * ServerParam.i().dash_dir_rate(dash_angle.degree()) - ptype = wm.self().player_type() + ptype = wm.self().player_type best_ctrl_dist_forward = (ptype.player_size() + ptype.kickable_margin() / 2 + ServerParam.i().ball_size()) @@ -383,12 +383,12 @@ def predict_short_step(self, max_cycle, save_recovery, self_cache): wm = self._wm ball = wm.ball() me = wm.self() - ptype = me.player_type() + ptype = me.player_type pen_area_x = SP.our_penalty_area_line_x() - 0.5 pen_area_y = SP.penalty_area_half_width() - 0.5 - ball_to_self = (me.pos() - ball.pos()).rotated_vector(-ball.vel().th()) + ball_to_self = (me.pos - ball.pos).rotated_vector(-ball.vel.th()) min_cycle = int(ceil((ball_to_self.abs_y() - ptype.kickable_area()) / ptype.real_speed_max())) @@ -398,7 +398,7 @@ def predict_short_step(self, max_cycle, save_recovery, self_cache): min_cycle = 2 ball_pos = ball.inertia_point(min_cycle - 1) - ball_vel = ball.vel() * SP.ball_decay() ** (min_cycle - 1) + ball_vel = ball.vel * SP.ball_decay() ** (min_cycle - 1) for cycle in range(min_cycle, max_loop + 1): tmp_cache = [] @@ -410,7 +410,7 @@ def predict_short_step(self, max_cycle, save_recovery, self_cache): control_area = (ptype.catchable_area() if goalie_mode else ptype.kickable_area()) - if (control_area + ptype.real_speed_max() * cycle) ** 2 < me.pos().dist2(ball_pos): + if (control_area + ptype.real_speed_max() * cycle) ** 2 < me.pos.dist2(ball_pos): log.sw_log().intercept().add_text("self pred short too far") continue @@ -441,7 +441,7 @@ def predict_short_step(self, max_cycle, save_recovery, self_cache): if len(tmp_cache) == 0: continue - safety_ball_dist = max(control_area - 0.2 - ball.pos().dist(ball_pos) * SP.ball_rand(), + safety_ball_dist = max(control_area - 0.2 - ball.pos.dist(ball_pos) * SP.ball_rand(), ptype.player_size() + SP.ball_size() + ptype.kickable_margin() * 0.4) best: InterceptInfo = tmp_cache[0] for it in tmp_cache[1:]: @@ -471,9 +471,9 @@ def predict_omni_dash_short(self, wm = self._wm me = wm.self() - ptype = me.player_type() + ptype = me.player_type - body_angle = me.body() + 180 if back_dash else me.body() + body_angle = me.body + 180 if back_dash else me.body.copy() my_inertia = me.inertia_point(cycle) target_line = Line2D(p=ball_pos, a=body_angle) @@ -502,9 +502,9 @@ def predict_omni_dash_short(self, continue first_dash_power = 0 - my_pos = me.pos() - my_vel = me.vel() - stamina_model = me.stamina_model() + my_pos = me.pos.copy() + my_vel = me.vel.copy() + stamina_model = me.stamina_model.copy() n_omni_dash, first_dash_power = self.predict_adjust_omni_dash(cycle, ball_pos, @@ -560,11 +560,11 @@ def predict_omni_dash_short(self, my_vel *= ptype.player_decay() stamina_model.simulate_dash(ptype, dash_power) - my_move = my_pos - me.pos() + my_move = my_pos - me.pos if my_pos.dist2(ball_pos) < (control_area - control_area_buf) ** 2 or \ - my_move.r() > (ball_pos - me.pos()).rotated_vector(-my_move.th()).abs_x(): + my_move.r() > (ball_pos - me.pos).rotated_vector(-my_move.th()).abs_x(): mode = (InterceptInfo.Mode.EXHAUST - if stamina_model.recovery() < me.stamina_model().recovery() + if stamina_model.recovery() < me.stamina_model.recovery() and not stamina_model.capacity_is_empty() else InterceptInfo.Mode.NORMAL) self_cache.append(InterceptInfo(mode, @@ -588,12 +588,12 @@ def predict_adjust_omni_dash(self, SP = ServerParam.i() wm = self._wm me = wm.self() - ptype = me.player_type() + ptype = me.player_type recover_dec_thr = SP.recover_dec_thr_value() + 1 max_omni_dash = min(2, cycle) - body_angle = me.body() + 180 if back_dash else me.body() + body_angle = me.body + 180 if back_dash else me.body.copy() target_line = Line2D(p=ball_pos, a=body_angle) my_inertia = me.inertia_point(cycle) @@ -654,7 +654,7 @@ def predict_turn_dash_short(self, back_dash: bool, turn_margin_control_area: float, self_cache: list): - dash_angle = self._wm.self().body() + dash_angle = self._wm.self().body.copy() n_turn = self.predict_turn_cycle_short(cycle, ball_pos, control_area, back_dash, turn_margin_control_area, dash_angle) @@ -678,16 +678,16 @@ def predict_dash_cycle_short(self, wm = self._wm me = wm.self() - ptype = me.player_type() + ptype = me.player_type recover_dec_thr = SP.recover_dec_thr_value() + 1 max_dash = cycle - n_turn my_inertia = me.inertia_point(cycle) my_pos = me.inertia_point(n_turn) - my_vel = me.vel() * ptype.player_decay() ** n_turn + my_vel = me.vel * ptype.player_decay() ** n_turn - stamina_model = me.stamina_model() + stamina_model = me.stamina_model.copy() stamina_model.simulate_waits(ptype, n_turn) if my_inertia.dist2(ball_pos) < (control_area - control_area_buf) ** 2: @@ -745,7 +745,7 @@ def predict_dash_cycle_short(self, stamina_model.simulate_dash(ptype, dash_power) if my_pos.dist2(ball_pos) < (control_area - control_area_buf) ** 2 or \ - me.pos().dist2(my_pos) > me.pos().dist2(ball_pos): + me.pos.dist2(my_pos) > me.pos.dist2(ball_pos): mode = (InterceptInfo.Mode.EXHAUST if stamina_model.stamina() < SP.recover_dec_thr_value() and not stamina_model.capacity_is_empty() @@ -769,7 +769,7 @@ def predict_turn_cycle_short(self, max_moment = SP.max_moment() me = wm.self() - ptype = me.player_type() + ptype = me.player_type dist_thr = turn_margin_control_area inertia_pos = me.inertia_point(cycle) @@ -777,7 +777,7 @@ def predict_turn_cycle_short(self, target_angle = (ball_pos - inertia_pos).th() n_turn = 0 - body_angle = me.body() + 180 if back_dash else me.body() + body_angle = me.body + 180 if back_dash else me.body.copy() angle_diff = (target_angle - body_angle).abs() turn_margin = 180 @@ -785,7 +785,7 @@ def predict_turn_cycle_short(self, turn_margin = max(self._min_turn_thr, AngleDeg.asin_deg(dist_thr / target_dist)) if angle_diff > turn_margin: - my_speed = me.vel().r() + my_speed = me.vel.r() while angle_diff > turn_margin: angle_diff -= ptype.effective_turn(max_moment, my_speed) my_speed *= ptype.player_decay() @@ -817,11 +817,11 @@ def predict_long_step(self, max_cycle: int, save_recovery: bool, self_cache: lis wm = self._wm ball = wm.ball() me = wm.self() - ptype = me.player_type() + ptype = me.player_type # calc y distance from ball line - ball_to_self = me.pos() - ball.pos() - ball_to_self.rotate(-ball.vel().th()) + ball_to_self = me.pos - ball.pos + ball_to_self.rotate(-ball.vel.th()) start_cycle = int(ceil((ball_to_self.abs_y() - ptype.kickable_area() - 0.2) @@ -830,7 +830,7 @@ def predict_long_step(self, max_cycle: int, save_recovery: bool, self_cache: lis # start_cycle = self._max_short_step + 1 ball_pos = ball.inertia_point(start_cycle - 1) - ball_vel = ball.vel() * SP.ball_decay() ** (start_cycle - 1) + ball_vel = ball.vel * SP.ball_decay() ** (start_cycle - 1) found = False max_loop = max_cycle @@ -850,7 +850,7 @@ def predict_long_step(self, max_cycle: int, save_recovery: bool, self_cache: lis control_area = ptype.catchable_area() if goalie_mode else ptype.kickable_area() # reach point is to far never reach - if control_area + ptype.real_speed_max() * cycle < me.pos().dist(ball_pos): + if control_area + ptype.real_speed_max() * cycle < me.pos.dist(ball_pos): log.sw_log().intercept().add_text('-------> to far never reach') log.sw_log().intercept().add_circle(cx=ball_pos.x(), cy=ball_pos.y(), r=0.3, color='r') continue @@ -882,7 +882,7 @@ def can_reach_after_turn_long_dash(self, control_area, save_recovery, self_cache) -> tuple: - dash_angle = self._wm.self().body() + dash_angle = self._wm.self().body.copy() result_recovery = 0 n_turn, dash_angle, back_dash = self.predict_turn_cycle(cycle, ball_pos, @@ -904,7 +904,7 @@ def predict_turn_cycle(self, cycle: int, control_area: float, dash_angle: AngleDeg) -> tuple: wm = self._wm - ptype = wm.self().player_type() + ptype = wm.self().player_type back_dash = False n_turn = 0 @@ -933,7 +933,7 @@ def predict_turn_cycle(self, cycle: int, # predict turn cycles max_moment = ServerParam.i().max_moment() * (1 - ServerParam.i().player_rand()) - player_speed = wm.self().vel().r() + player_speed = wm.self().vel.r() while angle_diff > turn_margin: max_turnable = ptype.effective_turn(max_moment, player_speed) angle_diff -= max_turnable @@ -957,11 +957,11 @@ def can_back_dash_chase(self, cycle: int, if angle_diff < self._back_dash_thr_angle: return False - if (not wm.self().goalie() + if (not wm.self().goalie or wm.last_kicker_side() == wm.our_side()) and cycle >= 5: return False - if (wm.self().goalie() + if (wm.self().goalie and wm.last_kicker_side() != wm.our_side() and cycle >= 5): if cycle >= 15: @@ -974,10 +974,10 @@ def can_back_dash_chase(self, cycle: int, # check stamina consumed by one step total_consume = -ServerParam.i().min_dash_power() * 2 * cycle - total_recover = (wm.self().player_type().stamina_inc_max() - * wm.self().recovery() + total_recover = (wm.self().player_type.stamina_inc_max() + * wm.self().stamina_model.recovery() * (cycle - 1)) - result_stamina = (wm.self().stamina() + result_stamina = (wm.self().stamina_model.stamina() - total_consume + total_recover) @@ -1001,14 +1001,14 @@ def can_reach_after_dash(self, SP = ServerParam.i() wm = self._wm - ptype = wm.self().player_type() + ptype = wm.self().player_type my_inertia = wm.self().inertia_point(n_turn + n_dash) recover_dec_thr = SP.recover_dec_thr() * SP.stamina_max() dash_angle_minus = -dash_angle - ball_rel = (ball_pos - wm.self().pos()).rotated_vector(dash_angle_minus) - ball_noise = (wm.ball().pos().dist(ball_pos) + ball_rel = (ball_pos - wm.self().pos).rotated_vector(dash_angle_minus) + ball_noise = (wm.ball().pos.dist(ball_pos) * SP.ball_rand() * 0.5) noised_ball_x = ball_rel.x() + ball_noise @@ -1016,14 +1016,14 @@ def can_reach_after_dash(self, # prepare loop variables # ORIGIN: first player pos. # X - axis: dash angle - tmp_pos = ptype.inertia_travel(wm.self().vel(), n_turn) + tmp_pos = ptype.inertia_travel(wm.self().vel, n_turn) tmp_pos.rotate(dash_angle_minus) - tmp_vel = wm.self().vel() + tmp_vel = wm.self().vel.copy() tmp_vel *= ptype.player_decay() ** n_turn tmp_vel.rotate(dash_angle_minus) - stamina_model = wm.self().stamina_model() + stamina_model = wm.self().stamina_model.copy() stamina_model.simulate_waits(ptype, n_turn) prev_effort = stamina_model.effort() @@ -1080,12 +1080,12 @@ def can_reach_after_dash(self, if tmp_pos.x() * PLAYER_NOISE_RATE + 0.1 > noised_ball_x: result_recovery = stamina_model.recovery() inertia_pos = ptype.inertia_point(tmp_pos, tmp_vel, n_dash - (i + 1)) - my_final_pos = wm.self().pos() + tmp_pos.rotate(dash_angle) + my_final_pos = wm.self().pos + tmp_pos.rotate(dash_angle) if my_inertia.dist2(my_final_pos) > 0.01: my_final_pos = Line2D(p1=my_inertia, p2=my_final_pos).projection(ball_pos) stamina_model.simulate_waits(ptype, n_dash - (i + 1)) mode = (InterceptInfo.Mode.EXHAUST - if stamina_model.recovery() < wm.self().recovery() + if stamina_model.recovery() < wm.self().stamina_model.recovery() and not stamina_model.capacity_is_empty() else InterceptInfo.Mode.NORMAL) self_cache.append(InterceptInfo(mode, @@ -1105,10 +1105,10 @@ def can_reach_after_dash(self, buf += ball_noise if last_ball_dist < max(control_area - 0.225, control_area - buf): - my_final_pos = wm.self().pos() + tmp_pos.rotate(dash_angle) + my_final_pos = wm.self().pos + tmp_pos.rotate(dash_angle) result_recovery = stamina_model.recovery() mode = (InterceptInfo.Mode.EXHAUST - if stamina_model.recovery() < wm.self().recovery() + if stamina_model.recovery() < wm.self().stamina_model.recovery() and not stamina_model.capacity_is_empty() else InterceptInfo.Mode.NORMAL) self_cache.append(InterceptInfo(mode, @@ -1122,13 +1122,13 @@ def can_reach_after_dash(self, def predict_final(self, max_cycle: int, self_cache: list): wm = self._wm me = wm.self() - ptype = me.player_type() + ptype = me.player_type my_final_pos = me.inertia_point(100) ball_final_pos = wm.ball().inertia_point(100) goalie_mode = self.is_goalie_mode(ball_final_pos) control_area = ptype.catchable_area() - 0.15 if goalie_mode else ptype.kickable_area() - dash_angle = me.body() + dash_angle = me.body.copy() n_turn, dash_angle, back_dash = self.predict_turn_cycle(100, ball_final_pos, control_area, @@ -1140,7 +1140,7 @@ def predict_final(self, max_cycle: int, self_cache: list): if max_cycle > n_turn + n_dash: n_dash = max_cycle - n_turn - stamina_model = me.stamina_model() + stamina_model = me.stamina_model.copy() stamina_model.simulate_waits(ptype, n_turn) stamina_model.simulate_dashes(ptype, n_dash, ServerParam.i().max_dash_power()) self_cache.append(InterceptInfo(InterceptInfo.Mode.NORMAL, diff --git a/lib/action/intercept_table.py b/lib/action/intercept_table.py index f8c90fa7..760f5f5c 100644 --- a/lib/action/intercept_table.py +++ b/lib/action/intercept_table.py @@ -81,7 +81,7 @@ def update(self, wm: 'WorldModel'): log.sw_log().intercept().add_text( "(intercept update) GAMEMODE RETURN") return - if not wm.self().pos().is_valid() or not wm.ball().pos().is_valid(): + if not wm.self().pos.is_valid() or not wm.ball().pos.is_valid(): log.sw_log().intercept().add_text( "(intercept update) self pos or ball pos is not valid") return @@ -93,19 +93,19 @@ def update(self, wm: 'WorldModel'): if self._fastest_teammate is not None: log.sw_log().intercept().add_text( f"Intercept Teammate, fastest reach step={self._teammate_reach_cycle}" - f"teammate {self._fastest_teammate.unum()} {self._fastest_teammate.pos()}") + f"teammate {self._fastest_teammate.unum} {self._fastest_teammate.pos}") if self._second_teammate is not None: log.sw_log().intercept().add_text( f"Intercept Teammate2nd, fastest reach step={self._second_teammate_reach_cycle}" - f"teammate {self._second_teammate.unum()} {self._second_teammate.pos()}") + f"teammate {self._second_teammate.unum} {self._second_teammate.pos}") if self._fastest_opponent is not None: log.sw_log().intercept().add_text( f"Intercept Opponent, fastest reach step={self._opponent_reach_cycle}" - f"teammate {self._fastest_opponent.unum()} {self._fastest_opponent.pos()}") + f"teammate {self._fastest_opponent.unum} {self._fastest_opponent.pos}") if self._second_opponent is not None: log.sw_log().intercept().add_text( f"Intercept Opponent2nd, fastest reach step={self._second_opponent_reach_cycle}" - f"teammate {self._second_opponent.unum()} {self._second_opponent.pos()}") + f"teammate {self._second_opponent.unum} {self._second_opponent.pos}") def clear(self): self._ball_cache = [] @@ -131,8 +131,8 @@ def create_ball_cache(self, wm): pitch_max_y = SP.pitch_half_width() + 5 ball_decay = SP.ball_decay() - ball_pos: Vector2D = wm.ball().pos() - ball_vel: Vector2D = wm.ball().vel() + ball_pos: Vector2D = wm.ball().pos.copy() + ball_vel: Vector2D = wm.ball().vel.copy() self._ball_cache.append(ball_pos) @@ -198,7 +198,7 @@ def predict_opponent(self, wm: 'WorldModel'): "Intercept Opponent. exits kickable opponent") self._opponent_reach_cycle = 0 for o in opponents: - if o.is_ghost() or o.pos_count() > wm.ball().pos_count() + 1: + if o.is_ghost() or o.pos_count > wm.ball().pos_count + 1: continue self._fastest_opponent = o log.sw_log().intercept().add_text( @@ -211,18 +211,18 @@ def predict_opponent(self, wm: 'WorldModel'): predictor = PlayerIntercept(wm, self._ball_cache) for it in opponents: - if it.pos_count() >= 15: + if it.pos_count >= 15: continue - player_type = it.player_type() + player_type = it.player_type if player_type is None: log.sw_log().intercept().add_text( - f"intercept opponents faild to get player{it.unum()} type") + f"intercept opponents faild to get player{it.unum} type") continue cycle = predictor.predict(it, player_type, second_min_cycle) log.sw_log().intercept().add_text( - f"opp{it.unum()} {it.pos()} " + f"opp{it.unum} {it.pos} " f"type={player_type.id()} cycle={cycle}") if cycle < second_min_cycle: @@ -248,7 +248,7 @@ def predict_teammate(self, wm: 'WorldModel'): "Intercept Teammates. exits kickable teammate") self._teammate_reach_cycle = 0 for t in teammates: - if t.is_ghost() or t.pos_count() > wm.ball().pos_count() + 1: + if t.is_ghost() or t.pos_count > wm.ball().pos_count + 1: continue self._fastest_teammate = t log.sw_log().intercept().add_text( @@ -261,22 +261,22 @@ def predict_teammate(self, wm: 'WorldModel'): predictor = PlayerIntercept(wm, self._ball_cache) for it in teammates: - if it.pos_count() >= 10: + if it.pos_count >= 10: continue - player_type = it.player_type() + player_type = it.player_type if player_type is None: log.sw_log().intercept().add_text( - f"intercept teammate faild to get player{it.unum()} type") + f"intercept teammate faild to get player{it.unum} type") continue cycle = predictor.predict(it, player_type, second_min_cycle) log.sw_log().intercept().add_text( - f"tm{it.unum()} {it.pos()} " + f"tm{it.unum} {it.pos} " f"type={player_type.id()} cycle={cycle}") - if it.goalie(): + if it.goalie: self._goalie_reach_cycle = cycle elif cycle < second_min_cycle: second_min_cycle = cycle diff --git a/lib/action/kick_table.py b/lib/action/kick_table.py index e7059e75..0a80ce13 100644 --- a/lib/action/kick_table.py +++ b/lib/action/kick_table.py @@ -332,18 +332,13 @@ def __init__(self): self._player_size = 0.0 self._kickable_margin = 0.0 self._ball_size = 0.0 - self._state_cache = [] - for i in range(MAX_DEPTH): - self._state_cache.append([]) - for j in range(NUM_STATE): - self._state_cache[i].append(0.0) # not static state list self._state_list = [] self._tables = [] self._current_state = State() - self._state_cache = [[State()]] * DEST_DIR_DIVS + self._state_cache = [[State()] for _ in range(DEST_DIR_DIVS)] self._candidates = [] # : list[Sequence] = [] @@ -468,13 +463,13 @@ def create_state_cache(self, world: 'WorldModel'): param = ServerParam.i() pitch = Rect2D(Vector2D(- param.pitch_half_length(), - param.pitch_half_width()), Size2D(param.pitch_length(), param.pitch_width())) - self_type = world.self().player_type() + self_type = world.self().player_type near_dist = calc_near_dist(self_type) mid_dist = calc_mid_dist(self_type) far_dist = calc_far_dist(self_type) - rpos = world.ball().rpos() - rpos.rotate(- world.self().body()) + rpos = world.ball().rpos.copy() + rpos.rotate(- world.self().body) dist = rpos.r() angle = rpos.th() @@ -488,9 +483,9 @@ def create_state_cache(self, world: 'WorldModel'): if self._current_state.index_ >= dir_div: self._current_state.index_ = 0 - # self._current_state.pos_ = world.ball().rpos() - self._current_state.pos_ = world.ball().pos() - self._current_state.kick_rate_ = world.self().kick_rate() + # self._current_state.pos_ = world.ball().rpos.copy() + self._current_state.pos_ = world.ball().pos.copy() + self._current_state.kick_rate_ = world.self().kick_rate self.check_interfere_at(world, self._current_state) # 0 @@ -498,8 +493,8 @@ def create_state_cache(self, world: 'WorldModel'): # create future state # - self_pos = world.self().pos() - self_vel = world.self().vel() + self_pos = world.self().pos.copy() + self_vel = world.self().vel.copy() for i in range(MAX_DEPTH): self._state_cache[i].clear() @@ -512,7 +507,7 @@ def create_state_cache(self, world: 'WorldModel'): pos = self._state_list[index].pos_.copy() krate = self_type.kick_rate(near_dist, pos.th().degree()) - pos.rotate(world.self().body()) + pos.rotate(world.self().body) pos.set_length(near_dist) pos += self_pos self._state_cache[i].append(State(index, near_dist, pos, krate)) @@ -526,7 +521,7 @@ def create_state_cache(self, world: 'WorldModel'): pos = self._state_list[index].pos_.copy() krate = self_type.kick_rate(mid_dist, pos.th().degree()) - pos.rotate(world.self().body()) + pos.rotate(world.self().body) pos.set_length(mid_dist) pos += self_pos @@ -541,7 +536,7 @@ def create_state_cache(self, world: 'WorldModel'): pos = self._state_list[index].pos_.copy() krate = self_type.kick_rate(far_dist, pos.th().degree()) - pos.rotate(world.self().body()) + pos.rotate(world.self().body) pos.set_length(far_dist) pos += self_pos @@ -561,12 +556,12 @@ def create_state_cache(self, world: 'WorldModel'): def check_collision_after_release(self, world: 'WorldModel', target_point: Vector2D, first_speed): - self_type = world.self().player_type() + self_type = world.self().player_type collide_dist2 = pow(self_type.player_size() + ServerParam.i().ball_size(), 2) - self_pos = world.self().pos() - self_vel = world.self().vel() + self_pos = world.self().pos.copy() + self_vel = world.self().vel.copy() # check the release kick from current state @@ -621,16 +616,16 @@ def check_interfere_at(world: 'WorldModel', state.flag_ = SAFETY return for o in OFB: - if o is None or o.player_type() is None: + if o is None or o.player_type is None: continue - if o.pos_count() >= 8: + if o.pos_count >= 8: continue if o.is_ghost(): continue - if o.dist_from_ball() > 10.0: + if o.dist_from_ball > 10.0: break - opp_next = o.pos() + o.vel() + opp_next = o.pos + o.vel opp_dist = opp_next.dist(state.pos_) if o.is_tackling(): @@ -641,19 +636,19 @@ def check_interfere_at(world: 'WorldModel', continue - control_area = o.player_type().catchable_area() if ( - o.goalie() and penalty_area.contains(o.pos()) and penalty_area.contains(state.pos_ - )) else o.player_type().kickable_area() + control_area = o.player_type.catchable_area() if ( + o.goalie and penalty_area.contains(o.pos) and penalty_area.contains(state.pos_ + )) else o.player_type.kickable_area() # # check kick possibility # - if not o.is_ghost() and o.pos_count() <= 2 and opp_dist < control_area + 0.15: + if not o.is_ghost() and o.pos_count <= 2 and opp_dist < control_area + 0.15: flag |= KICKABLE break - opp_body = o.body() if o.body_count() <= 1 else (state.pos_ - opp_next).th() - player_2_pos = Vector2D(state.pos_ - opp_next) + opp_body = o.body if o.body_count <= 1 else (state.pos_ - opp_next).th() + player_2_pos = state.pos_ - opp_next player_2_pos.rotate(- opp_body) # # check tackle possibility @@ -669,7 +664,7 @@ def check_interfere_at(world: 'WorldModel', # check kick or tackle possibility after dash - player_type = o.player_type() + player_type = o.player_type max_accel = (ServerParam.i().max_dash_power() * player_type.dash_power_rate() * player_type.effort_max()) @@ -732,25 +727,25 @@ def check_interfere_after_release(self, *args): # , **kwargs):): state.flag_ = SAFETY return for o in OFB: - if o is None or o.player_type() is None: + if o is None or o.player_type is None: continue - if o.pos_count() >= 8: + if o.pos_count >= 8: continue if o.is_ghost(): continue - if o.dist_from_ball() > 10.0: + if o.dist_from_ball > 10.0: break opp_pos = o.inertia_point(cycle) if not opp_pos.is_valid(): - opp_pos = o.pos() + o.vel() + opp_pos = o.pos + o.vel if o.is_tackling(): - if opp_pos.dist(ball_pos) < (o.player_type().player_size() + ServerParam.i().ball_size()): + if opp_pos.dist(ball_pos) < (o.player_type.player_size() + ServerParam.i().ball_size()): state.flag_ |= RELEASE_INTERFERE continue - control_area = o.player_type().catchable_area() if ( - o.goalie() and penalty_area.contains(o.pos()) and penalty_area.contains( - state.pos_)) else o.player_type().kickable_area() + control_area = o.player_type.catchable_area() if ( + o.goalie and penalty_area.contains(o.pos) and penalty_area.contains( + state.pos_)) else o.player_type.kickable_area() control_area += 0.1 control_area2 = pow(control_area, 2) @@ -762,7 +757,7 @@ def check_interfere_after_release(self, *args): # , **kwargs):): else: state.flag_ |= RELEASE_INTERFERE else: # if cycle <= 1 : - opp_body = o.body() if o.body_count() <= 1 else (ball_pos - opp_pos).th() + opp_body = o.body if o.body_count <= 1 else (ball_pos - opp_pos).th() player_2_pos = ball_pos - opp_pos player_2_pos.rotate(- opp_body) @@ -774,7 +769,7 @@ def check_interfere_after_release(self, *args): # , **kwargs):): ServerParam.i().tackle_exponent())) if tackle_prob < 1.0 and 1.0 - tackle_prob > 0.8: # success probability state.flag_ |= MAYBE_RELEASE_INTERFERE - player_type = o.player_type() + player_type = o.player_type max_accel = (ServerParam.i().max_dash_power() * player_type.dash_power_rate() * player_type.effort_max()) * 0.8 @@ -804,26 +799,26 @@ def simulate_one_step(self, world: 'WorldModel', target_point: Vector2D, first_s current_max_accel = min(self._current_state.kick_rate_ * ServerParam.i().max_power(), ServerParam.i().ball_accel_max()) - target_vel = (target_point - world.ball().pos()) + target_vel = (target_point - world.ball().pos) target_vel.set_length(first_speed) - accel = target_vel - world.ball().vel() + accel = target_vel - world.ball().vel accel_r = accel.r() if accel_r > current_max_accel: max_vel = calc_max_velocity(target_vel.th(), self._current_state.kick_rate_, - world.ball().vel()) - accel = max_vel - world.ball().vel() + world.ball().vel) + accel = max_vel - world.ball().vel self._candidates.append(Sequence()) self._candidates[-1].flag_ = self._current_state.flag_ - self._candidates[-1].pos_list_.append(world.ball().pos() + max_vel) + self._candidates[-1].pos_list_.append(world.ball().pos + max_vel) self._candidates[-1].speed_ = max_vel.r() self._candidates[-1].power_ = accel.r() / self._current_state.kick_rate_ return False self._candidates.append(Sequence()) self._candidates[-1].flag_ = self._current_state.flag_ - self._candidates[-1].pos_list_.append(world.ball().pos() + target_vel) + self._candidates[-1].pos_list_.append(world.ball().pos + target_vel) self._candidates[-1].speed_ = first_speed self._candidates[-1].power_ = accel_r / self._current_state.kick_rate_ """ @@ -851,25 +846,25 @@ def simulate_two_step(self, world: 'WorldModel', target_point: Vector2D, first_s accel_max = ServerParam.i().ball_accel_max() ball_decay = ServerParam.i().ball_decay() - self_type = world.self().player_type() + self_type = world.self().player_type current_max_accel = min(self._current_state.kick_rate_ * max_power, accel_max) param = ServerParam.i() my_kickable_area = self_type.kickable_area() - my_noise = world.self().vel().r() * param.player_rand() - current_dir_diff_rate = (world.ball().angle_from_self() - world.self().body()).abs() / 180.0 + my_noise = world.self().vel.r() * param.player_rand() + current_dir_diff_rate = (world.ball().angle_from_self - world.self().body).abs() / 180.0 - current_dist_rate = ((world.ball().dist_from_self() + current_dist_rate = ((world.ball().dist_from_self - self_type.player_size() - param.ball_size()) / self_type.kickable_margin()) current_pos_rate = 0.5 + 0.25 * (current_dir_diff_rate + current_dist_rate) - current_speed_rate = 0.5 + 0.5 * (world.ball().vel().r() / ( + current_speed_rate = 0.5 + 0.5 * (world.ball().vel.r() / ( param.ball_speed_max() * param.default_player_decay())) - # my_final_pos = world.self().pos() + world.self().vel() + world.self().vel() * self_type.player_decay() + # my_final_pos = world.self().pos + world.self().vel + world.self().vel * self_type.player_decay() success_count = 0 max_speed2 = 0.0 @@ -891,13 +886,13 @@ def simulate_two_step(self, world: 'WorldModel', target_point: Vector2D, first_s kick_miss_flag = SAFETY target_vel = (target_point - state.pos_).set_length_vector(first_speed) - vel = state.pos_ - world.ball().pos() - accel = vel - world.ball().vel() + vel = state.pos_ - world.ball().pos + accel = vel - world.ball().vel accel_r = accel.r() if accel_r > current_max_accel: continue - kick_power = accel_r / world.self().kick_rate() + kick_power = accel_r / world.self().kick_rate ball_noise = vel.r() * param.ball_rand() max_kick_rand = self_type.kick_rand() * (kick_power / param.max_power()) * ( current_pos_rate + current_speed_rate) @@ -963,21 +958,21 @@ def simulate_three_step(self, world: 'WorldModel', param = ServerParam.i() - self_type = world.self().player_type() + self_type = world.self().player_type my_kickable_area = self_type.kickable_area() - my_noise1 = world.self().vel().r() * param.player_rand() - current_dir_diff_rate = (world.ball().angle_from_self() - world.self().body()).abs() / 180.0 - current_dist_rate = ((world.ball().dist_from_self() + my_noise1 = world.self().vel.r() * param.player_rand() + current_dir_diff_rate = (world.ball().angle_from_self - world.self().body).abs() / 180.0 + current_dist_rate = ((world.ball().dist_from_self - self_type.player_size() - param.ball_size()) / self_type.kickable_margin()) current_pos_rate = 0.5 + 0.25 * (current_dir_diff_rate + current_dist_rate) - current_speed_rate = 0.5 + 0.5 * (world.ball().vel().r() + current_speed_rate = 0.5 + 0.5 * (world.ball().vel.r() / (param.ball_speed_max() * param.ball_decay())) - target_rel_angle = (target_point - world.self().pos()).th() - world.self().body() + target_rel_angle = (target_point - world.self().pos).th() - world.self().body angle_deg = target_rel_angle.degree() + 180.0 target_angle_index = round(DEST_DIR_DIVS * (angle_deg / 360.0)) if target_angle_index >= DEST_DIR_DIVS: @@ -1020,14 +1015,14 @@ def simulate_three_step(self, world: 'WorldModel', kick_miss_flag = SAFETY - vel1 = state_1st.pos_ - world.ball().pos() - accel = vel1 - world.ball().vel() + vel1 = state_1st.pos_ - world.ball().pos + accel = vel1 - world.ball().vel accel_r2 = accel.r2() if accel_r2 > current_max_accel2: continue - kick_power = math.sqrt(accel_r2) / world.self().kick_rate() + kick_power = math.sqrt(accel_r2) / world.self().kick_rate ball_noise = vel1.r() * param.ball_rand() max_kick_rand = self_type.kick_rand() * (kick_power / param.max_power()) * ( current_pos_rate + current_speed_rate) diff --git a/lib/action/neck_body_to_ball.py b/lib/action/neck_body_to_ball.py index 7b53cd3f..98dc55c7 100644 --- a/lib/action/neck_body_to_ball.py +++ b/lib/action/neck_body_to_ball.py @@ -19,7 +19,7 @@ def execute(self, agent: 'PlayerAgent'): log.debug_client().add_message('BodyToBall/') wm = agent.world() if wm.ball().pos_valid(): - ball_next = wm.ball().pos() + wm.ball().vel() + ball_next = wm.ball().pos + wm.ball().vel return NeckBodyToPoint(ball_next, self._angle_buf).execute(agent) return ScanField().execute(agent) diff --git a/lib/action/neck_body_to_point.py b/lib/action/neck_body_to_point.py index 89b26e3c..c4ae023b 100644 --- a/lib/action/neck_body_to_point.py +++ b/lib/action/neck_body_to_point.py @@ -27,15 +27,15 @@ def execute(self, agent: 'PlayerAgent'): angle_buf = bound(0., self._angle_buf, 180.) - my_next = wm.self().pos() + wm.self().vel() - target_rel_angle = (self._point - my_next).th() - wm.self().body() + my_next = wm.self().pos + wm.self().vel + target_rel_angle = (self._point - my_next).th() - wm.self().body if SP.min_neck_angle() + angle_buf < target_rel_angle.degree() < SP.max_neck_angle() - angle_buf: agent.do_turn(0.) agent.set_neck_action(NeckTurnToRelative(target_rel_angle)) return True - max_turn = wm.self().player_type().effective_turn(SP.max_moment(),wm.self().vel().r()) + max_turn = wm.self().player_type.effective_turn(SP.max_moment(),wm.self().vel.r()) if target_rel_angle.abs() < max_turn: agent.do_turn(target_rel_angle) agent.set_neck_action(NeckTurnToRelative(0.)) diff --git a/lib/action/neck_scan_field.py b/lib/action/neck_scan_field.py index 4e0b92e5..043bb18d 100644 --- a/lib/action/neck_scan_field.py +++ b/lib/action/neck_scan_field.py @@ -35,7 +35,7 @@ def execute(self, agent: 'PlayerAgent'): if (NeckScanField._last_calc_time == wm.time() and NeckScanField._last_calc_view_width != ef.queued_next_view_width()): - agent.do_turn_neck(NeckScanField._cached_target_angle - ef.queued_next_self_body() - wm.self().neck()) + agent.do_turn_neck(NeckScanField._cached_target_angle - ef.queued_next_self_body() - wm.self().neck) return True NeckScanField._last_calc_time = wm.time().copy() @@ -44,13 +44,13 @@ def execute(self, agent: 'PlayerAgent'): angle = self.calc_angle_for_wide_pitch_edge(agent) if angle != NeckScanField.INVALID_ANGLE: NeckScanField._cached_target_angle = angle - agent.do_turn_neck(AngleDeg(NeckScanField._cached_target_angle) - ef.queued_next_self_body() - wm.self().neck()) + agent.do_turn_neck(AngleDeg(NeckScanField._cached_target_angle) - ef.queued_next_self_body() - wm.self().neck) return True existed_ghost = False for p in wm.all_players(): - if p.is_ghost() and p.dist_from_self() < 30: + if p.is_ghost() and p.dist_from_self < 30: existed_ghost = True break @@ -62,7 +62,7 @@ def execute(self, agent: 'PlayerAgent'): angle = NeckScanPlayers.get_best_angle(agent) if angle != NeckScanField.INVALID_ANGLE: NeckScanField._cached_target_angle = angle - agent.do_turn_neck(AngleDeg(NeckScanField._cached_target_angle) - ef.queued_next_self_body() - wm.self().neck()) + agent.do_turn_neck(AngleDeg(NeckScanField._cached_target_angle) - ef.queued_next_self_body() - wm.self().neck) return True gt = wm.game_mode().type() @@ -71,16 +71,16 @@ def execute(self, agent: 'PlayerAgent'): or ( not gt.is_ind_free_kick() and not gt.is_back_pass() - and wm.ball().dist_from_self() < wm.self().player_type().player_size() + 0.15 + and wm.ball().dist_from_self < wm.self().player_type.player_size() + 0.15 ) ) angle = self.calc_angle_default(agent, consider_patch) - if consider_patch and (AngleDeg(angle) - wm.self().face()).abs() < 5: + if consider_patch and (AngleDeg(angle) - wm.self().face).abs() < 5: angle = self.calc_angle_default(agent, False) NeckScanField._cached_target_angle = angle - agent.do_turn_neck(AngleDeg(NeckScanField._cached_target_angle) - ef.queued_next_self_body() - wm.self().neck()) + agent.do_turn_neck(AngleDeg(NeckScanField._cached_target_angle) - ef.queued_next_self_body() - wm.self().neck) return True @@ -172,10 +172,10 @@ def calc_angle_for_wide_pitch_edge(self, agent: 'PlayerAgent'): return NeckScanField.INVALID_ANGLE gt = wm.game_mode().type() - if gt is not GameModeType.PlayOn and not gt.is_goal_kick() and wm.ball().dist_from_self() > 2: + if gt is not GameModeType.PlayOn and not gt.is_goal_kick() and wm.ball().dist_from_self > 2: return NeckScanField.INVALID_ANGLE - next_self_pos = wm.self().pos() + wm.self().vel() + next_self_pos = wm.self().pos + wm.self().vel pitch_x_thr = SP.pitch_half_length() - 15. pitch_y_thr = SP.pitch_half_length() - 10. # TODO WIDTH MAYBE(it was on librcsc tho...) diff --git a/lib/action/neck_scan_players.py b/lib/action/neck_scan_players.py index 866a6dfb..816c0a21 100644 --- a/lib/action/neck_scan_players.py +++ b/lib/action/neck_scan_players.py @@ -57,7 +57,7 @@ def execute(self, agent: 'PlayerAgent'): return NeckScanField().execute(agent) target_angle = AngleDeg(NeckScanPlayers._cached_target_angle) - agent.do_turn_neck(target_angle - ef.queued_next_self_body().degree() - wm.self().neck().degree()) + agent.do_turn_neck(target_angle - ef.queued_next_self_body().degree() - wm.self().neck.degree()) return True @staticmethod @@ -122,27 +122,27 @@ def calculate_score(wm: WorldModel, next_self_pos: Vector2D, left_angle: AngleDe if p.is_self(): continue - pos = p.pos() + p.vel() + pos = p.pos + p.vel angle = (pos - next_self_pos).th() if not angle.is_right_of(reduced_left_angle) or not angle.is_left_of(reduced_right_angle): continue - if p.ghost_count() >= 5: + if p.ghost_count >= 5: continue - pos_count= p.seen_pos_count() - if p.is_ghost() and p.ghost_count() % 2 == 1: + pos_count= p.seen_pos_count + if p.is_ghost() and p.ghost_count % 2 == 1: pos_count = min(2, pos_count) pos_count += 1 if our_ball: - if p.side() == wm.our_side() and (p.pos().x() > wm.ball().pos().x() - 10 or p.pos().x() > 30): + if p.side == wm.our_side() and (p.pos.x() > wm.ball().pos.x() - 10 or p.pos.x() > 30): pos_count *=2 base_val = pos_count**2 - rate = exp(-(p.dist_from_self() ** 2) / (2*(20**2))) + rate = exp(-(p.dist_from_self ** 2) / (2*(20**2))) score += base_val * rate buf = min((angle-left_angle).abs(), (angle-right_angle).abs()) diff --git a/lib/action/neck_turn_to_ball.py b/lib/action/neck_turn_to_ball.py index 94d188c0..5efefc98 100644 --- a/lib/action/neck_turn_to_ball.py +++ b/lib/action/neck_turn_to_ball.py @@ -40,7 +40,7 @@ def execute(self, agent: 'PlayerAgent'): return True if wm.intercept_table().opponent_reach_cycle() <= 1: - neck_moment = ball_rel_angle_next - wm.self().neck() + neck_moment = ball_rel_angle_next - wm.self().neck agent.do_turn_neck(neck_moment) return True @@ -54,20 +54,20 @@ def execute(self, agent: 'PlayerAgent'): if (SP.visible_distance() * 0.7 < ball_dist < 15 and (wm.kickable_teammate() or wm.kickable_opponent() - or (opp and opp.dist_from_ball() < opp.player_type().kickable_area()+0.3) - or (mate and mate.dist_from_ball() < mate.player_type().kickable_area() + 0.3) + or (opp and opp.dist_from_ball < opp.player_type.kickable_area()+0.3) + or (mate and mate.dist_from_ball < mate.player_type.kickable_area() + 0.3) ) ): view_half = max(0, next_view_width*0.5 - 20) if (len(wm.opponents_from_self()) >= 11 - and (wm.ball().pos().x() > 0 - or wm.ball().pos().abs_y() > SP.pitch_half_width() - 8 + and (wm.ball().pos.x() > 0 + or wm.ball().pos.abs_y() > SP.pitch_half_width() - 8 or not opp - or opp.dist_from_ball() > 3)): + or opp.dist_from_ball > 3)): best_angle = NeckScanPlayers.INVALID_ANGLE - if ball_dist > SP.visible_distance() - 0.3 or wm.ball().seen_pos_count() > 0: + if ball_dist > SP.visible_distance() - 0.3 or wm.ball().seen_pos_count > 0: min_neck_angle = bound(SP.min_neck_angle(), ball_rel_angle_next.degree() - view_half, SP.max_neck_angle()) @@ -83,7 +83,7 @@ def execute(self, agent: 'PlayerAgent'): if best_angle != NeckScanPlayers.INVALID_ANGLE: target_angle = best_angle - neck_moment = AngleDeg(target_angle - my_body_next.degree() - wm.self().neck().degree()) + neck_moment = AngleDeg(target_angle - my_body_next.degree() - wm.self().neck.degree()) agent.do_turn_neck(neck_moment) return True @@ -98,9 +98,9 @@ def execute(self, agent: 'PlayerAgent'): _, right_sum_count, _ = wm.dir_range_count(my_body_next + right_rel_angle, next_view_width) if left_sum_count > right_sum_count: - agent.do_turn_neck(left_rel_angle - wm.self().neck().degree()) + agent.do_turn_neck(left_rel_angle - wm.self().neck.degree()) else: - agent.do_turn_neck(right_rel_angle - wm.self().neck().degree()) + agent.do_turn_neck(right_rel_angle - wm.self().neck.degree()) return True diff --git a/lib/action/neck_turn_to_ball_or_scan.py b/lib/action/neck_turn_to_ball_or_scan.py index 48bb6228..b8b3db37 100644 --- a/lib/action/neck_turn_to_ball_or_scan.py +++ b/lib/action/neck_turn_to_ball_or_scan.py @@ -22,13 +22,13 @@ def execute(self, agent: 'PlayerAgent'): ef = agent.effector() SP = ServerParam.i() - if wm.ball().pos_count() <= self._count_thr: + if wm.ball().pos_count <= self._count_thr: return NeckScanField().execute(agent) ball_next = ef.queued_next_ball_pos() my_next = ef.queued_next_self_pos() - if (wm.ball().pos_count() <= 0 + if (wm.ball().pos_count <= 0 and not wm.kickable_opponent() and not wm.kickable_teammate() and my_next.dist(ball_next) < SP.visible_distance() - 0.2): diff --git a/lib/action/neck_turn_to_point.py b/lib/action/neck_turn_to_point.py index 2e3ea01b..cf48ec94 100644 --- a/lib/action/neck_turn_to_point.py +++ b/lib/action/neck_turn_to_point.py @@ -35,7 +35,7 @@ def execute(self, agent: 'PlayerAgent'): rel_angle = rel_pos.th() - next_body if rel_angle.abs() < SP.max_neck_angle() + next_view_width - 5.: - return agent.do_turn_neck(rel_angle - agent.world().self().neck()) + return agent.do_turn_neck(rel_angle - agent.world().self().neck) NeckScanField().execute(agent) return True diff --git a/lib/action/neck_turn_to_relative.py b/lib/action/neck_turn_to_relative.py index 567d9b7d..38ea6dfe 100644 --- a/lib/action/neck_turn_to_relative.py +++ b/lib/action/neck_turn_to_relative.py @@ -13,4 +13,4 @@ def __init__(self, rel_angle: Union[AngleDeg, float]): self._angle_rel_to_body: AngleDeg = AngleDeg(rel_angle) def execute(self, agent: 'PlayerAgent'): - return agent.do_turn_neck(self._angle_rel_to_body - agent.world().self().neck()) \ No newline at end of file + return agent.do_turn_neck(self._angle_rel_to_body - agent.world().self().neck) \ No newline at end of file diff --git a/lib/action/scan_field.py b/lib/action/scan_field.py index f8b286e7..def77d3b 100644 --- a/lib/action/scan_field.py +++ b/lib/action/scan_field.py @@ -38,10 +38,10 @@ def find_ball(self, agent: 'PlayerAgent'): if agent.effector().queued_next_view_width() is not ViewWidth.WIDE: agent.set_view_action(ViewWide()) - my_next = wm.self().pos() + wm.self().vel() - face_angle = (wm.ball().seen_pos() - my_next).th() if wm.ball().seen_pos().is_valid() else (my_next*-1).th() + my_next = wm.self().pos + wm.self().vel + face_angle = (wm.ball().seen_pos - my_next).th() if wm.ball().seen_pos.is_valid() else (my_next*-1).th() - search_flag = wm.ball().lost_count() //3 + search_flag = wm.ball().lost_count //3 if search_flag%2==1: face_angle += 180. @@ -53,10 +53,10 @@ def scan_all_field(self, agent: 'PlayerAgent'): if agent.effector().queued_next_view_width() is not ViewWidth.WIDE: agent.set_view_action(ViewWide()) - turn_moment=wm.self().view_width().width() + agent.effector().queued_next_view_width().width() + turn_moment=wm.self().view_width.width() + agent.effector().queued_next_view_width().width() turn_moment /= 2 agent.do_turn(turn_moment) - agent.set_neck_action(NeckTurnToRelative(wm.self().neck())) + agent.set_neck_action(NeckTurnToRelative(wm.self().neck)) diff --git a/lib/action/smart_kick.py b/lib/action/smart_kick.py index 35895ad7..ff8de788 100644 --- a/lib/action/smart_kick.py +++ b/lib/action/smart_kick.py @@ -67,17 +67,17 @@ def execute(self, agent: 'PlayerAgent'): if ans[0]: self._sequence = ans[1] if self._sequence.speed_ >= first_speed_thr: # double check - vel = self._sequence.pos_list_[0] - wm.ball().pos() - kick_accel = vel - wm.ball().vel() + vel = self._sequence.pos_list_[0] - wm.ball().pos + kick_accel = vel - wm.ball().vel if SmartKick.debug_print_DEBUG: - log.os_log().debug(f"Kick Vel : {vel}, Kick Power : {kick_accel.r() / wm.self().kick_rate()}, Kick Angle : {kick_accel.th() - wm.self().body()}") - log.sw_log().kick().add_text(f"Kick Vel : {vel}, Kick Power : {kick_accel.r() / wm.self().kick_rate()}, Kick Angle : {kick_accel.th() - wm.self().body()}") + log.os_log().debug(f"Kick Vel : {vel}, Kick Power : {kick_accel.r() / wm.self().kick_rate}, Kick Angle : {kick_accel.th() - wm.self().body}") + log.sw_log().kick().add_text(f"Kick Vel : {vel}, Kick Power : {kick_accel.r() / wm.self().kick_rate}, Kick Angle : {kick_accel.th() - wm.self().body}") - agent.do_kick(kick_accel.r() / wm.self().kick_rate(), - kick_accel.th() - wm.self().body()) + agent.do_kick(kick_accel.r() / wm.self().kick_rate, + kick_accel.th() - wm.self().body) if SmartKick.debug_print_DEBUG: - log.os_log().debug(f"----------------#### Player Number {wm.self().unum()} 'DO_KICK'ed in SmartKick at Time: {wm.time().cycle()} ####----------------") - log.sw_log().kick().add_text(f"----------------#### Player Number {wm.self().unum()} 'DO_KICK'ed in SmartKick at Time: {wm.time().cycle()} ####----------------") + log.os_log().debug(f"----------------#### Player Number {wm.self().unum} 'DO_KICK'ed in SmartKick at Time: {wm.time().cycle()} ####----------------") + log.sw_log().kick().add_text(f"----------------#### Player Number {wm.self().unum} 'DO_KICK'ed in SmartKick at Time: {wm.time().cycle()} ####----------------") return True # failed to search the kick sequence diff --git a/lib/action/stop_ball.py b/lib/action/stop_ball.py index 303a2468..42be3bce 100644 --- a/lib/action/stop_ball.py +++ b/lib/action/stop_ball.py @@ -39,11 +39,11 @@ def execute(self, agent: 'PlayerAgent'): if not wm.self().is_kickable(): return False if not wm.ball().vel_valid(): # Always true until NFS nice :) - required_accel = wm.self().vel() - (wm.self().pos() - wm.ball().pos()) - kick_power = required_accel.r() / wm.self().kick_rate() + required_accel = wm.self().vel - (wm.self().pos - wm.ball().pos) + kick_power = required_accel.r() / wm.self().kick_rate kick_power *= 0.5 agent.do_kick(min(kick_power, ServerParam.i().max_power()), - required_accel.th() - wm.self().body()) + required_accel.th() - wm.self().body) return True self._accel_radius = 0.0 @@ -59,28 +59,28 @@ def execute(self, agent: 'PlayerAgent'): # kick_power = min(kick_power, i.maxPower()) return agent.do_kick(kick_power, - self._accel_angle - wm.self().body()) + self._accel_angle - wm.self().body) def calcAccel(self, agent): wm: 'WorldModel' = agent.world() - safety_dist = wm.self().player_type().player_size() + ServerParam.i().ball_size() + 0.1 + safety_dist = wm.self().player_type.player_size() + ServerParam.i().ball_size() + 0.1 - target_dist = wm.ball().dist_from_self() + target_dist = wm.ball().dist_from_self if target_dist < safety_dist: target_dist = safety_dist - if target_dist > wm.self().player_type().kickable_area() - 0.1: - target_dist = wm.self().player_type().kickable_area() - 0.1 + if target_dist > wm.self().player_type.kickable_area() - 0.1: + target_dist = wm.self().player_type.kickable_area() - 0.1 - target_rel = wm.self().pos() - wm.ball().pos() + target_rel = wm.self().pos - wm.ball().pos target_rel.set_length(target_dist) - required_accel = wm.self().vel() + required_accel = wm.self().vel.copy() required_accel += target_rel # target relative to current - required_accel -= wm.self().pos() - wm.ball().pos() # vel = pos diff - required_accel -= wm.ball().vel() # required accel + required_accel -= wm.self().pos - wm.ball().pos # vel = pos diff + required_accel -= wm.ball().vel # required accel self._accel_radius = required_accel.r() @@ -89,7 +89,7 @@ def calcAccel(self, agent): # check max accel with player's kick rate - max_accel = ServerParam.i().max_power() * wm.self().kick_rate() + max_accel = ServerParam.i().max_power() * wm.self().kick_rate if max_accel > self._accel_radius: # can accelerate -. can stop ball successfully self._accel_angle = required_accel.th() @@ -98,11 +98,11 @@ def calcAccel(self, agent): ################################## # keep the ball as much as possible near the best point - next_ball_to_self = wm.self().vel() - next_ball_to_self -= wm.self().pos() - wm.ball().pos() - next_ball_to_self -= wm.ball().vel() + next_ball_to_self = wm.self().vel.copy() + next_ball_to_self -= wm.self().pos - wm.ball().pos + next_ball_to_self -= wm.ball().vel - keep_dist = wm.self().player_type().player_size() + wm.self().player_type().kickable_margin() * 0.4 + keep_dist = wm.self().player_type.player_size() + wm.self().player_type.kickable_margin() * 0.4 self._accel_radius = min(max_accel, next_ball_to_self.r() - keep_dist) self._accel_angle = next_ball_to_self.th() diff --git a/lib/action/turn_to_point.py b/lib/action/turn_to_point.py index 10623e57..2d7138e4 100644 --- a/lib/action/turn_to_point.py +++ b/lib/action/turn_to_point.py @@ -15,7 +15,7 @@ def execute(self, agent: 'PlayerAgent'): return agent.do_turn(60) my_point = self_player.inertia_point(self._cycle) - target_rel_angle = (self._point - my_point).th() - self_player.body() + target_rel_angle = (self._point - my_point).th() - self_player.body agent.do_turn(target_rel_angle) if target_rel_angle.abs() < 1: diff --git a/lib/coach/gloabl_world_model.py b/lib/coach/gloabl_world_model.py index cea117f2..3093ca95 100644 --- a/lib/coach/gloabl_world_model.py +++ b/lib/coach/gloabl_world_model.py @@ -93,12 +93,12 @@ def fullstate_parser(self, message): player = GlobalPlayerObject() player.init_dic(player_dic) # player.set_player_type(self._player_types[player.type()]) - if player.side().value == self._our_side: - self._our_players[player.unum() - 1] = player - elif player.side() == SideID.NEUTRAL: - self._unknown_player[player.unum() - 1] = player + if player.side.value == self._our_side: + self._our_players[player.unum - 1] = player + elif player.side == SideID.NEUTRAL: + self._unknown_player[player.unum - 1] = player else: - self._their_players[player.unum() - 1] = player + self._their_players[player.unum - 1] = player # TODO check reversion def __repr__(self): diff --git a/lib/debug/debug_client.py b/lib/debug/debug_client.py index 97534c72..467a1a5f 100644 --- a/lib/debug/debug_client.py +++ b/lib/debug/debug_client.py @@ -15,33 +15,33 @@ def player_printer(p: 'PlayerObject', our_side: SideID): s = ' (' - if p.side() is SideID.NEUTRAL: + if p.side is SideID.NEUTRAL: s += 'u' - elif p.side() == our_side: - if p.unum() != UNUM_UNKNOWN: - s += f"t {p.unum()}" - if p.player_type(): - s += f" {p.player_type().id()}" + elif p.side == our_side: + if p.unum != UNUM_UNKNOWN: + s += f"t {p.unum}" + if p.player_type: + s += f" {p.player_type.id()}" else: s += ' -1' else: s += 'ut' else: - if p.unum() != UNUM_UNKNOWN: - s += f"o {p.unum()}" - if p.player_type(): - s += f" {p.player_type().id()}" + if p.unum != UNUM_UNKNOWN: + s += f"o {p.unum}" + if p.player_type: + s += f" {p.player_type.id()}" else: s += ' -1' else: s += 'uo' - s += f" {round(p.pos().x(), 2)} {round(p.pos().y(), 2)}" + s += f" {round(p.pos.x(), 2)} {round(p.pos.y(), 2)}" if p.body_valid(): - s += f" (bd {round(p.body().degree())})" + s += f" (bd {round(p.body.degree())})" - if p.pointto_count() < 10: - s += f"(pt {round(float(p.pointto_angle()))})" + if p.pointto_count < 10: + s += f"(pt {round(float(p.pointto_angle))})" s += ")" return s @@ -131,32 +131,32 @@ def to_str(self, world: 'WorldModel', effector): ostr_player = '' ostr_ball = '' - if world.self() and world.self().pos().is_valid(): + if world.self() and world.self().pos.is_valid(): ostr_player = ' (s ' \ + ('l ' if world.our_side() == SideID.LEFT else 'r ') \ - + str(world.self().unum()) + ' ' \ - + str(world.self().player_type_id()) + ' ' \ - + str(round(world.self().pos().x(), 2)) + ' ' \ - + str(round(world.self().pos().y(), 2)) + ' ' \ - + str(round(world.self().vel().x(), 2)) + ' ' \ - + str(round(world.self().vel().y(), 2)) + ' ' \ - + str(round(world.self().body().degree(), 1)) + ' ' \ - + str(round(world.self().neck().degree(), 1)) \ - + ' (c "' + str(world.self().pos_count()) + ' ' \ - + str(world.self().vel_count()) + ' ' + str(world.self().face_count()) - if world.self().card() == Card.YELLOW: + + str(world.self().unum) + ' ' \ + + str(world.self().player_type_id) + ' ' \ + + str(round(world.self().pos.x(), 2)) + ' ' \ + + str(round(world.self().pos.y(), 2)) + ' ' \ + + str(round(world.self().vel.x(), 2)) + ' ' \ + + str(round(world.self().vel.y(), 2)) + ' ' \ + + str(round(world.self().body.degree(), 1)) + ' ' \ + + str(round(world.self().neck.degree(), 1)) \ + + ' (c "' + str(world.self().pos_count) + ' ' \ + + str(world.self().vel_count) + ' ' + str(world.self().face_count) + if world.self().card == Card.YELLOW: ostr_player += 'y' ostr_player += '"))' - if world.ball().pos().is_valid(): - ostr_ball = ' (b ' + str(round(world.ball().pos().x(), 2)) \ - + ' ' + str(round(world.ball().pos().y(), 2)) + if world.ball().pos.is_valid(): + ostr_ball = ' (b ' + str(round(world.ball().pos.x(), 2)) \ + + ' ' + str(round(world.ball().pos.y(), 2)) if world.ball().vel_valid(): - ostr_ball += (' ' + str(round(world.ball().vel().x(), 2)) - + ' ' + str(round(world.ball().vel().y(), 2))) - ostr_ball += (' (c \'g' + str(world.ball().pos_count()) + 'r' - + str(world.ball().rpos_count()) + 'v' - + str(world.ball().vel_count())) + '\'))' + ostr_ball += (' ' + str(round(world.ball().vel.x(), 2)) + + ' ' + str(round(world.ball().vel.y(), 2))) + ostr_ball += (' (c \'g' + str(world.ball().pos_count) + 'r' + + str(world.ball().rpos_count) + 'v' + + str(world.ball().vel_count)) + '\'))' ostr += ostr_player ostr += ostr_ball diff --git a/lib/messenger/ball_pos_vel_messenger.py b/lib/messenger/ball_pos_vel_messenger.py index b43f4b7d..06e45409 100644 --- a/lib/messenger/ball_pos_vel_messenger.py +++ b/lib/messenger/ball_pos_vel_messenger.py @@ -27,8 +27,8 @@ def encode(self) -> str: return SP = ServerParam.i() - pos = wm.ball().pos().copy() - vel = wm.ball().vel().copy() + pos = wm.ball().pos.copy() + vel = wm.ball().vel.copy() x:float = min_max(-SP.pitch_half_length(), pos.x(), SP.pitch_half_length()) + SP.pitch_half_length() y:float = min_max(-SP.pitch_half_width(), pos.y(), SP.pitch_half_width()) + SP.pitch_half_width() diff --git a/lib/messenger/player_pos_unum_messenger.py b/lib/messenger/player_pos_unum_messenger.py index 9b3c2c09..019b5a4a 100644 --- a/lib/messenger/player_pos_unum_messenger.py +++ b/lib/messenger/player_pos_unum_messenger.py @@ -41,7 +41,7 @@ def encode(self) -> str: SP = ServerParam.i() - pos = player.pos() + pos = player.pos x:float = min_max(-SP.pitch_half_length(), pos.x(), SP.pitch_half_length()) + SP.pitch_half_length() y:float = min_max(-SP.pitch_half_width(), pos.y(), SP.pitch_half_width()) + SP.pitch_half_width() diff --git a/lib/player/action_effector.py b/lib/player/action_effector.py index 3a493592..46923508 100644 --- a/lib/player/action_effector.py +++ b/lib/player/action_effector.py @@ -91,9 +91,9 @@ def inc_command_type(self, type: CommandType): def check_command_count_with_fullstate_parser(self, full_sensor: FullStateWorldMessageParser): # TODO CALL it wm = self._agent.world() if full_sensor.kick_count() != self._command_counter[CommandType.KICK.value]: - log.os_log().error(f"player({wm.self().unum()} lost kick at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()} lost kick at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()} lost kick at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum} lost kick at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum} lost kick at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum} lost kick at cycle {wm.time()}") self._last_body_commands[0] = CommandType.ILLEGAL self._kick_accel = Vector2D(0, 0) @@ -101,9 +101,9 @@ def check_command_count_with_fullstate_parser(self, full_sensor: FullStateWorldM self._command_counter[CommandType.KICK.value] = full_sensor.kick_count() if full_sensor.turn_count() != self._command_counter[CommandType.TURN.value]: - log.os_log().error(f"player({wm.self().unum()}) lost TURN at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost TURN at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost TURN at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost TURN at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost TURN at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost TURN at cycle {wm.time()}") self._last_body_commands[0] = CommandType.ILLEGAL self._turn_actual = 0 @@ -111,9 +111,9 @@ def check_command_count_with_fullstate_parser(self, full_sensor: FullStateWorldM self._command_counter[CommandType.TURN.value] = full_sensor.turn_count() if full_sensor.dash_count() != self._command_counter[CommandType.DASH.value]: - log.os_log().error(f"player({wm.self().unum()}) lost DASH at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost DASH at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost DASH at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost DASH at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost DASH at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost DASH at cycle {wm.time()}") self._last_body_commands[0] = CommandType.ILLEGAL self._dash_accel = Vector2D(0, 0) @@ -122,72 +122,72 @@ def check_command_count_with_fullstate_parser(self, full_sensor: FullStateWorldM self._command_counter[CommandType.DASH.value] = full_sensor.dash_count() if full_sensor.move_count() != self._command_counter[CommandType.MOVE.value]: - log.os_log().error(f"player({wm.self().unum()}) lost MOVE at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost MOVE at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost MOVE at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost MOVE at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost MOVE at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost MOVE at cycle {wm.time()}") self._last_body_commands[0] = CommandType.ILLEGAL self._move_pos = Vector2D(0, 0) self._command_counter[CommandType.MOVE.value] = full_sensor.move_count() if full_sensor.catch_count() != self._command_counter[CommandType.CATCH.value]: - log.os_log().error(f"player({wm.self().unum()}) lost CATCH at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost CATCH at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost CATCH at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost CATCH at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost CATCH at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost CATCH at cycle {wm.time()}") self._last_body_commands[0] = CommandType.ILLEGAL # self._catch_time = GameTime() self._command_counter[CommandType.CATCH.value] = full_sensor.catch_count() - # if full_sensor.tackle_count() != self._command_counter[CommandType.TACKLE.value]: - # log.os_log().error(f"player({wm.self().unum()}) lost TACKLE at cycle {wm.time()}") - # log.sw_log().action().add_text(f"player({wm.self().unum()}) lost TACKLE at cycle {wm.time()}") - # log.debug_client().add_message(f"player({wm.self().unum()}) lost TACKLE at cycle {wm.time()}") + # if full_sensor.tackle_count != self._command_counter[CommandType.TACKLE.value]: + # log.os_log().error(f"player({wm.self().unum}) lost TACKLE at cycle {wm.time()}") + # log.sw_log().action().add_text(f"player({wm.self().unum}) lost TACKLE at cycle {wm.time()}") + # log.debug_client().add_message(f"player({wm.self().unum}) lost TACKLE at cycle {wm.time()}") # # self._last_body_commands[0] = CommandType.ILLEGAL # self._tackle_power = 0 # self._tackle_dir = 0 # self._tackle_foul = False - # self._command_counter[CommandType.TACKLE.value] = full_sensor.tackle_count() + # self._command_counter[CommandType.TACKLE.value] = full_sensor.tackle_count if full_sensor.turn_neck_count() != self._command_counter[CommandType.TURN_NECK.value]: - log.os_log().error(f"player({wm.self().unum()}) lost command TURN_NECK at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost command TURN_NECK at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost command TURN_NECK at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost command TURN_NECK at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost command TURN_NECK at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost command TURN_NECK at cycle {wm.time()}") self._command_counter[CommandType.TURN_NECK.value] = full_sensor.turn_neck_count() self._done_turn_neck = False self._turn_neck_moment = 0 # if full_sensor.change_focus_count() != self._command_counter[CommandType.CHANGE_FOCUS.value]: - # log.os_log().error(f"player({wm.self().unum()}) lost command CHANGE_FOCUS at cycle {wm.time()}") - # log.sw_log().action().add_text(f"player({wm.self().unum()}) lost command CHANGE_FOCUS at cycle {wm.time()}") - # log.debug_client().add_message(f"player({wm.self().unum()}) lost command CHANGE_FOCUS at cycle {wm.time()}") + # log.os_log().error(f"player({wm.self().unum}) lost command CHANGE_FOCUS at cycle {wm.time()}") + # log.sw_log().action().add_text(f"player({wm.self().unum}) lost command CHANGE_FOCUS at cycle {wm.time()}") + # log.debug_client().add_message(f"player({wm.self().unum}) lost command CHANGE_FOCUS at cycle {wm.time()}") # self._command_counter[CommandType.CHANGE_FOCUS.value] = body_sensor.change_focus_count() # self._done_change_focus = False # self._change_focus_moment_dist = 0 # self._change_focus_moment_dir = AngleDeg(0) if full_sensor.change_view_count() != self._command_counter[CommandType.CHANGE_VIEW.value]: - log.os_log().error(f"player({wm.self().unum()}) lost command CHANGE_VIEW at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost command CHANGE_VIEW at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost command CHANGE_VIEW at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost command CHANGE_VIEW at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost command CHANGE_VIEW at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost command CHANGE_VIEW at cycle {wm.time()}") self._command_counter[CommandType.CHANGE_VIEW.value] = full_sensor.change_view_count() if full_sensor.say_count() != self._command_counter[CommandType.SAY.value]: - log.os_log().error(f"player({wm.self().unum()}) lost command SAY at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost command SAY at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost command SAY at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost command SAY at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost command SAY at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost command SAY at cycle {wm.time()}") self._command_counter[CommandType.SAY.value] = full_sensor.say_count() - # if body_sensor.pointto_count() != self._command_counter[CommandType.POINTTO.value]: - # log.os_log().error(f"player({wm.self().unum()}) lost command POINTTO at cycle {wm.time()}") - # log.sw_log().action().add_text(f"player({wm.self().unum()}) lost command POINTTO at cycle {wm.time()}") - # log.debug_client().add_message(f"player({wm.self().unum()}) lost command POINTTO at cycle {wm.time()}") - # self._command_counter[CommandType.POINTTO.value] = full_sensor.pointto_count() + # if body_sensor.pointto_count != self._command_counter[CommandType.POINTTO.value]: + # log.os_log().error(f"player({wm.self().unum}) lost command POINTTO at cycle {wm.time()}") + # log.sw_log().action().add_text(f"player({wm.self().unum}) lost command POINTTO at cycle {wm.time()}") + # log.debug_client().add_message(f"player({wm.self().unum}) lost command POINTTO at cycle {wm.time()}") + # self._command_counter[CommandType.POINTTO.value] = full_sensor.pointto_count # if full_sensor.attentionto_count() != self._command_counter[CommandType.ATTENTIONTO.value]: - # log.os_log().error(f"player({wm.self().unum()}) lost command ATTENTIONTO at cycle {wm.time()}") - # log.sw_log().action().add_text(f"player({wm.self().unum()}) lost command ATTENTIONTO at cycle {wm.time()}") - # log.debug_client().add_message(f"player({wm.self().unum()}) lost command ATTENTIONTO at cycle {wm.time()}") + # log.os_log().error(f"player({wm.self().unum}) lost command ATTENTIONTO at cycle {wm.time()}") + # log.sw_log().action().add_text(f"player({wm.self().unum}) lost command ATTENTIONTO at cycle {wm.time()}") + # log.debug_client().add_message(f"player({wm.self().unum}) lost command ATTENTIONTO at cycle {wm.time()}") # self._command_counter[CommandType.ATTENTIONTO.value] = full_sensor.attentionto_count() @@ -195,9 +195,9 @@ def check_command_count(self, body_sensor: SenseBodyParser): wm = self._agent.world() if body_sensor.kick_count() != self._command_counter[CommandType.KICK.value]: if body_sensor.charged_expires() == 0: - log.os_log().error(f"player({wm.self().unum()} lost kick at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()} lost kick at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()} lost kick at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum} lost kick at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum} lost kick at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum} lost kick at cycle {wm.time()}") self._last_body_commands[0] = CommandType.ILLEGAL self._kick_accel = Vector2D(0, 0) @@ -206,9 +206,9 @@ def check_command_count(self, body_sensor: SenseBodyParser): if body_sensor.turn_count() != self._command_counter[CommandType.TURN.value]: if body_sensor.charged_expires() == 0: - log.os_log().error(f"player({wm.self().unum()}) lost TURN at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost TURN at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost TURN at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost TURN at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost TURN at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost TURN at cycle {wm.time()}") self._last_body_commands[0] = CommandType.ILLEGAL self._turn_actual = 0 @@ -217,9 +217,9 @@ def check_command_count(self, body_sensor: SenseBodyParser): if body_sensor.dash_count() != self._command_counter[CommandType.DASH.value]: if body_sensor.charged_expires() == 0: - log.os_log().error(f"player({wm.self().unum()}) lost DASH at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost DASH at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost DASH at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost DASH at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost DASH at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost DASH at cycle {wm.time()}") self._last_body_commands[0] = CommandType.ILLEGAL self._dash_accel = Vector2D(0, 0) @@ -228,27 +228,27 @@ def check_command_count(self, body_sensor: SenseBodyParser): self._command_counter[CommandType.DASH.value] = body_sensor.dash_count() if body_sensor.move_count() != self._command_counter[CommandType.MOVE.value]: if body_sensor.charged_expires() == 0: - log.os_log().error(f"player({wm.self().unum()}) lost MOVE at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost MOVE at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost MOVE at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost MOVE at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost MOVE at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost MOVE at cycle {wm.time()}") self._last_body_commands[0] = CommandType.ILLEGAL self._move_pos = Vector2D(0, 0) self._command_counter[CommandType.MOVE.value] = body_sensor.move_count() if body_sensor.catch_count() != self._command_counter[CommandType.CATCH.value]: if body_sensor.charged_expires() == 0: - log.os_log().error(f"player({wm.self().unum()}) lost CATCH at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost CATCH at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost CATCH at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost CATCH at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost CATCH at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost CATCH at cycle {wm.time()}") self._last_body_commands[0] = CommandType.ILLEGAL # self._catch_time = GameTime() self._command_counter[CommandType.CATCH.value] = body_sensor.catch_count() if body_sensor.tackle_count() != self._command_counter[CommandType.TACKLE.value]: if body_sensor.charged_expires() == 0: - log.os_log().error(f"player({wm.self().unum()}) lost TACKLE at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost TACKLE at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost TACKLE at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost TACKLE at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost TACKLE at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost TACKLE at cycle {wm.time()}") self._last_body_commands[0] = CommandType.ILLEGAL self._tackle_power = 0 @@ -257,44 +257,44 @@ def check_command_count(self, body_sensor: SenseBodyParser): self._command_counter[CommandType.TACKLE.value] = body_sensor.tackle_count() if body_sensor.turn_neck_count() != self._command_counter[CommandType.TURN_NECK.value]: - log.os_log().error(f"player({wm.self().unum()}) lost command TURN_NECK at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost command TURN_NECK at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost command TURN_NECK at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost command TURN_NECK at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost command TURN_NECK at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost command TURN_NECK at cycle {wm.time()}") self._command_counter[CommandType.TURN_NECK.value] = body_sensor.turn_neck_count() self._done_turn_neck = False self._turn_neck_moment = 0 if body_sensor.change_focus_count() != self._command_counter[CommandType.CHANGE_FOCUS.value]: - log.os_log().error(f"player({wm.self().unum()}) lost command CHANGE_FOCUS at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost command CHANGE_FOCUS at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost command CHANGE_FOCUS at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost command CHANGE_FOCUS at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost command CHANGE_FOCUS at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost command CHANGE_FOCUS at cycle {wm.time()}") self._command_counter[CommandType.CHANGE_FOCUS.value] = body_sensor.change_focus_count() self._done_change_focus = False self._change_focus_moment_dist = 0 self._change_focus_moment_dir = AngleDeg(0) if body_sensor.change_view_count() != self._command_counter[CommandType.CHANGE_VIEW.value]: - log.os_log().error(f"player({wm.self().unum()}) lost command CHANGE_VIEW at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost command CHANGE_VIEW at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost command CHANGE_VIEW at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost command CHANGE_VIEW at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost command CHANGE_VIEW at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost command CHANGE_VIEW at cycle {wm.time()}") self._command_counter[CommandType.CHANGE_VIEW.value] = body_sensor.change_view_count() if body_sensor.say_count() != self._command_counter[CommandType.SAY.value]: - log.os_log().error(f"player({wm.self().unum()}) lost command SAY at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost command SAY at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost command SAY at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost command SAY at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost command SAY at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost command SAY at cycle {wm.time()}") self._command_counter[CommandType.SAY.value] = body_sensor.say_count() - if body_sensor.pointto_count() != self._command_counter[CommandType.POINTTO.value]: - log.os_log().error(f"player({wm.self().unum()}) lost command POINTTO at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost command POINTTO at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost command POINTTO at cycle {wm.time()}") - self._command_counter[CommandType.POINTTO.value] = body_sensor.pointto_count() + if body_sensor.pointto_count != self._command_counter[CommandType.POINTTO.value]: + log.os_log().error(f"player({wm.self().unum}) lost command POINTTO at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost command POINTTO at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost command POINTTO at cycle {wm.time()}") + self._command_counter[CommandType.POINTTO.value] = body_sensor.pointto_count if body_sensor.attentionto_count() != self._command_counter[CommandType.ATTENTIONTO.value]: - log.os_log().error(f"player({wm.self().unum()}) lost command ATTENTIONTO at cycle {wm.time()}") - log.sw_log().action().add_text(f"player({wm.self().unum()}) lost command ATTENTIONTO at cycle {wm.time()}") - log.debug_client().add_message(f"player({wm.self().unum()}) lost command ATTENTIONTO at cycle {wm.time()}") + log.os_log().error(f"player({wm.self().unum}) lost command ATTENTIONTO at cycle {wm.time()}") + log.sw_log().action().add_text(f"player({wm.self().unum}) lost command ATTENTIONTO at cycle {wm.time()}") + log.debug_client().add_message(f"player({wm.self().unum}) lost command ATTENTIONTO at cycle {wm.time()}") self._command_counter[CommandType.ATTENTIONTO.value] = body_sensor.attentionto_count() @staticmethod @@ -303,7 +303,7 @@ def conserve_dash_power(wm: 'WorldModel', power, rel_dir): SP = ServerParam.i() required_stamina = power - available_stamina = wm.self().stamina() + wm.self().player_type().extra_stamina() + available_stamina = wm.self().stamina_model.stamina() + wm.self().player_type.extra_stamina() if available_stamina < required_stamina: log.sw_log().action().add_text( f"(conserve dash power) not enough stamina. power={power} stamina={available_stamina}") @@ -311,8 +311,8 @@ def conserve_dash_power(wm: 'WorldModel', power, rel_dir): dir_rate = SP.dash_dir_rate(rel_dir) accel_mag = abs(power*dir_rate*wm.self().dash_rate()) - accel_angle = wm.self().body() + rel_dir - _, accel_mag = wm.self().player_type().normalize_accel(wm.self().vel(), + accel_angle = wm.self().body + rel_dir + _, accel_mag = wm.self().player_type.normalize_accel(wm.self().vel, accel_angle=accel_angle, accel_mag=accel_mag) @@ -329,13 +329,13 @@ def set_kick(self, power: float, rel_dir: Union[AngleDeg, float]): rel_dir = float(rel_dir) if power < ServerParam.i().min_power() or power > ServerParam.i().max_power(): - log.os_log().error(f"(set kick) player({wm.self().unum()}) power is out of boundary at cycle {wm.time()}. power={power}") + log.os_log().error(f"(set kick) player({wm.self().unum}) power is out of boundary at cycle {wm.time()}. power={power}") power = ServerParam.i().max_power() if power > 100 else ServerParam.i().min_power() log.sw_log().action().add_text( f"(set kick) power={power}, rel_dir={rel_dir}") - self._kick_accel = Vector2D.polar2vector(power * wm.self().kick_rate(), - wm.self().body() + rel_dir) - max_rand = wm.self().player_type().kick_rand()*power/ServerParam.i().max_power() + self._kick_accel = Vector2D.polar2vector(power * wm.self().kick_rate, + wm.self().body + rel_dir) + max_rand = wm.self().player_type.kick_rand()*power/ServerParam.i().max_power() self._kick_accel_error = Vector2D(max_rand, max_rand) self._body_command = PlayerKickCommand(power, rel_dir) @@ -348,11 +348,11 @@ def set_dash(self, power: float, rel_dir: Union[AngleDeg, float] = 0): rel_dir = float(rel_dir) if power > SP.max_dash_power() or power < SP.min_dash_power(): - log.os_log().error(f"(set dash) player({wm.self().unum()}) power is out of boundary at cycle {wm.time()}. power={power}") + log.os_log().error(f"(set dash) player({wm.self().unum}) power is out of boundary at cycle {wm.time()}. power={power}") SP.normalize_dash_power(power) if rel_dir > SP.max_dash_angle() or rel_dir < SP.min_dash_angle(): - log.os_log().error(f"(set dash) player({wm.self().unum()}) rel_dir is out of boundary at cycle {wm.time()}. power={power}") + log.os_log().error(f"(set dash) player({wm.self().unum}) rel_dir is out of boundary at cycle {wm.time()}. power={power}") SP.normalize_dash_angle(rel_dir) rel_dir = SP.discretize_dash_angle(rel_dir) @@ -362,7 +362,7 @@ def set_dash(self, power: float, rel_dir: Union[AngleDeg, float] = 0): dir_rate = SP.dash_dir_rate(rel_dir) accel_mag = abs(power*dir_rate*wm.self().dash_rate()) accel_mag = min(accel_mag, SP.player_accel_max()) - accel_angle = wm.self().body() + rel_dir + accel_angle = wm.self().body + rel_dir self._dash_power = power self._dash_dir = rel_dir @@ -377,14 +377,14 @@ def set_turn(self, moment: Union[AngleDeg, float]): moment = float(AngleDeg(moment)) SP = ServerParam.i() wm = self._agent.world() - speed = wm.self().vel().r() + speed = wm.self().vel.r() - moment *= 1 + speed * wm.self().player_type().inertia_moment() + moment *= 1 + speed * wm.self().player_type.inertia_moment() if moment > SP.max_moment() or moment < SP.min_moment(): - log.os_log().error(f"(set turn) player({wm.self().unum()}) moment is out of boundary at cycle {wm.time()}. moment={moment}") + log.os_log().error(f"(set turn) player({wm.self().unum}) moment is out of boundary at cycle {wm.time()}. moment={moment}") moment = SP.max_moment() if moment > SP.max_moment() else SP.min_moment() - self._turn_actual = moment / (1 + speed*wm.self().player_type().inertia_moment()) + self._turn_actual = moment / (1 + speed*wm.self().player_type.inertia_moment()) self._turn_error = abs(SP.player_rand()*self._turn_actual) log.sw_log().action().add_text( f"(set turn) moment={moment}, actual_turn={self._turn_actual}, error={self._turn_error}") @@ -398,20 +398,20 @@ def set_move(self, x: float, y: float): wm = self._agent.world() if abs(x) > SP.pitch_half_length() or abs(y) > SP.pitch_half_width(): - log.os_log().error(f"(set move) player({wm.self().unum()}) position is out of pitch at cycle {wm.time()}. pos=({x},{y})") + log.os_log().error(f"(set move) player({wm.self().unum}) position is out of pitch at cycle {wm.time()}. pos=({x},{y})") x = min_max(-SP.pitch_half_length(), x, SP.pitch_half_length()) y = min_max(-SP.pitch_half_width(), y, SP.pitch_half_width()) if SP.kickoff_offside() and x > 0: - log.os_log().error(f"(set move) player({wm.self().unum()}) position is in opponent side at cycle {wm.time()}. pos=({x},{y})") + log.os_log().error(f"(set move) player({wm.self().unum}) position is in opponent side at cycle {wm.time()}. pos=({x},{y})") x = -0.1 - if wm.game_mode().type().is_goalie_catch_ball() and wm.game_mode().side() == wm.our_side(): + if wm.game_mode().type().is_goalie_catch_ball() and wm.game_mode().side == wm.our_side(): if x < -SP.pitch_half_length() + 1 or x > -SP.our_penalty_area_line_x() - 1: - log.os_log().error(f"(set move) player({wm.self().unum()}) position is out of penalty area at cycle {wm.time()}. pos=({x},{y})") + log.os_log().error(f"(set move) player({wm.self().unum}) position is out of penalty area at cycle {wm.time()}. pos=({x},{y})") x = min_max(-SP.pitch_half_length()+1, x, -SP.our_penalty_area_line_x()-1) if abs(y) > SP.penalty_area_half_width() -1: - log.os_log().error(f"(set move) player({wm.self().unum()}) position is out of penalty area at cycle {wm.time()}. pos=({x},{y})") + log.os_log().error(f"(set move) player({wm.self().unum}) position is out of penalty area at cycle {wm.time()}. pos=({x},{y})") y = min_max(-SP.penalty_area_half_width(),y, SP.penalty_area_half_width()) self._move_pos.assign(x, y) @@ -424,7 +424,7 @@ def set_catch(self): wm = self._agent.world() diagonal_angle = AngleDeg.atan2_deg(SP.catch_area_w()*0.5, SP.catch_area_l()) - ball_rel_angle = wm.ball().angle_from_self() - wm.self().body() + ball_rel_angle = wm.ball().angle_from_self - wm.self().body catch_angle = (ball_rel_angle + diagonal_angle).degree() if not (SP.min_catch_angle() < catch_angle < SP.max_catch_angle()): @@ -438,7 +438,7 @@ def set_tackle(self, dir: Union[float, AngleDeg], foul: bool): dir = float(dir) if abs(dir) > 180: - log.os_log().error(f"(set tackle) player({wm.self().unum()}) dir is out of range at cycle {wm.time()}. dir={dir}") + log.os_log().error(f"(set tackle) player({wm.self().unum}) dir is out of range at cycle {wm.time()}. dir={dir}") dir = AngleDeg.normalize_angle(dir) self._tackle_power = ServerParam.i().max_tackle_power() @@ -454,14 +454,14 @@ def set_turn_neck(self, moment: Union[AngleDeg, float]): moment = float(moment) if not (SP.min_neck_moment() < moment < SP.max_neck_moment()): - log.os_log().error(f"(set turn neck) player({wm.self().unum()}) moment is out of range at cycle {wm.time()}. moment={moment}") + log.os_log().error(f"(set turn neck) player({wm.self().unum}) moment is out of range at cycle {wm.time()}. moment={moment}") moment = min_max(SP.min_neck_moment(), moment, SP.max_neck_moment()) - next_neck_angle = wm.self().neck().degree() + moment + next_neck_angle = wm.self().neck.degree() + moment if not(SP.min_neck_angle() < next_neck_angle < SP.max_neck_angle()): - log.os_log().error(f"(set turn neck) player({wm.self().unum()}) \ + log.os_log().error(f"(set turn neck) player({wm.self().unum}) \ next neck angle is out of range at cycle {wm.time()}. next neck angle={next_neck_angle}") - moment = min_max(SP.min_neck_angle(), next_neck_angle, SP.max_neck_angle()) - wm.self().neck().degree() + moment = min_max(SP.min_neck_angle(), next_neck_angle, SP.max_neck_angle()) - wm.self().neck.degree() self._turn_neck_moment = moment self._neck_command = PlayerTurnNeckCommand(round(moment, 2)) @@ -481,8 +481,8 @@ def set_pointto(self, x, y): wm = self._agent.world() target = Vector2D(x,y) - target = target - wm.self().pos() - target.rotate(-wm.self().face()) + target = target - wm.self().pos + target.rotate(-wm.self().face) self._pointto_command = PlayerPointtoCommand(target.r(), target.th()) return self._pointto_command @@ -611,7 +611,7 @@ def set_attentionto_off(self): return self._attentionto_command def queued_next_self_body(self) -> AngleDeg: - next_angle = self._agent.world().self().body().copy() + next_angle = self._agent.world().self().body.copy() if self._body_command and self._body_command.type() is CommandType.TURN: moment = self.get_turn_info() next_angle += moment @@ -620,7 +620,7 @@ def queued_next_self_body(self) -> AngleDeg: def queued_next_view_width(self) -> ViewWidth: if self._change_view_command: return self._change_view_command.width() - return self._agent.world().self().view_width() + return self._agent.world().self().view_width def queued_next_self_face(self) -> AngleDeg: next_face = self.queued_next_self_neck() + self.queued_next_self_body() @@ -632,8 +632,8 @@ def queued_next_self_neck(self): def queued_next_focus_point(self) -> Vector2D: me = self._agent.world().self() - next_focus_dist = me.focus_point_dist() + self.get_change_focus_moment_dist() - next_focus_dir = me.focus_point_dir() + self.get_change_focus_moment_dir() + next_focus_dist = me.focus_point_dist + self.get_change_focus_moment_dist() + next_focus_dir = me.focus_point_dir + self.get_change_focus_moment_dir() next_view_width_half = self.queued_next_view_width().width() / 2.0 next_focus_dir = min_max(-next_view_width_half, next_focus_dir.degree(), next_view_width_half) next_focus_dir_to_pos = self.queued_next_self_face() + next_focus_dir @@ -641,15 +641,15 @@ def queued_next_focus_point(self) -> Vector2D: def queued_next_self_pos(self) -> Vector2D: me = self._agent.world().self() - vel = me.vel() + vel = me.vel.copy() if self._body_command and self._body_command.type() is CommandType.DASH: accel, _ = self.get_dash_info() vel += accel tmp = vel.r() - if tmp > me.player_type().player_speed_max(): - vel *= me.player_type().player_speed_max() / tmp - return me.pos() + vel + if tmp > me.player_type.player_speed_max(): + vel *= me.player_type.player_speed_max() / tmp + return me.pos + vel def queued_next_ball_pos(self): wm = self._agent.world() @@ -661,13 +661,13 @@ def queued_next_ball_pos(self): accel = Vector2D(0,0) if wm.ball().vel_valid(): - vel = wm.ball().vel() + vel = wm.ball().vel.copy() if self._body_command and self._body_command.type() == CommandType.KICK: accel = self.get_kick_info() vel += accel - return wm.ball().pos() + vel + return wm.ball().pos + vel def queued_next_angle_from_body(self, target: Vector2D): next_rpos = target - self.queued_next_self_pos() @@ -680,7 +680,7 @@ def queued_next_ball_vel(self): wm = self._agent.world() if wm.ball().vel_valid(): - vel = wm.ball().vel().copy() + vel = wm.ball().vel.copy() if self._body_command and self._body_command.type() == CommandType.KICK: accel = self.get_kick_info() @@ -690,13 +690,13 @@ def queued_next_ball_vel(self): return vel def queued_next_ball_kickable(self): - if self._agent.world().ball().rpos_count() >= 3: + if self._agent.world().ball().rpos_count >= 3: return False my_next = self.queued_next_self_pos() ball_next = self.queued_next_ball_pos() - return my_next.dist(ball_next) < self._agent.world().self().player_type().kickable_area() - 0.06 + return my_next.dist(ball_next) < self._agent.world().self().player_type.kickable_area() - 0.06 def get_say_message_length(self): l = 0 diff --git a/lib/player/localizer.py b/lib/player/localizer.py index 97fa666c..833d80f5 100644 --- a/lib/player/localizer.py +++ b/lib/player/localizer.py @@ -299,13 +299,13 @@ def localize_self(self, see: SeeParser, view_width: ViewWidth, self_face: float, return None, Vector2D(0, 0), [None] self.update_points_by_markers(view_width, markers, self_face, self_face_error) self_pos, self_pos_err = self.average_points() - possible_self_pos = [self_pos.copy() if isinstance(self_pos, Vector2D) else None] + possible_self_pos = [self_pos.copy() if self_pos is not None else None] if len(behind_markers) == 0: return self_pos, self_pos_err, possible_self_pos self.update_points_by_behind_marker(view_width, markers, behind_markers, self_pos, self_face, self_face_error) self_pos, self_pos_err = self.average_points() - possible_self_pos = [self_pos.copy() if isinstance(self_pos, Vector2D) else None] + possible_self_pos = [self_pos.copy() if self_pos is not None else None] return self_pos, self_pos_err, possible_self_pos def localize_ball_relative(self, diff --git a/lib/player/object.py b/lib/player/object.py index a9d5e023..bce1915b 100644 --- a/lib/player/object.py +++ b/lib/player/object.py @@ -3,130 +3,58 @@ class Object: # TODO IMPORTANT; Getter functions do not have to return a copy of the value, the reference is enough def __init__(self): - self._pos = Vector2D.invalid() - self._pos_error = Vector2D(0, 0) - self._pos_count: int = 1000 - self._possible_poses: list[Vector2D] = [] + self.pos = Vector2D.invalid() + self.pos_error = Vector2D(0, 0) + self.pos_count: int = 1000 + self.possible_poses: list[Vector2D] = [] - self._seen_pos: Vector2D = Vector2D.invalid() - self._seen_pos_count: int = 1000 + self.seen_pos: Vector2D = Vector2D.invalid() + self.seen_pos_count: int = 1000 - self._heard_pos: Vector2D = Vector2D.invalid() - self._heard_pos_count: int = 1000 + self.heard_pos: Vector2D = Vector2D.invalid() + self.heard_pos_count: int = 1000 - self._vel = Vector2D.invalid() - self._vel_error = Vector2D(0, 0) - self._vel_count: int = 1000 + self.vel = Vector2D.invalid() + self.vel_error = Vector2D(0, 0) + self.vel_count: int = 1000 - self._seen_vel: Vector2D = Vector2D.invalid() - self._seen_vel_count: int = 1000 + self.seen_vel: Vector2D = Vector2D.invalid() + self.seen_vel_count: int = 1000 - self._heard_vel: Vector2D = Vector2D.invalid() - self._heard_vel_count: int = 100 + self.heard_vel: Vector2D = Vector2D.invalid() + self.heard_vel_count: int = 100 - self._rpos = Vector2D.invalid() - self._rpos_error = Vector2D(0, 0) - self._rpos_count: int = 1000 + self.rpos = Vector2D.invalid() + self.rpos_error = Vector2D(0, 0) + self.rpos_count: int = 1000 - self._seen_rpos: Vector2D = Vector2D.invalid() - self._seen_rpos_error: Vector2D = Vector2D(0, 0) + self.seen_rpos: Vector2D = Vector2D.invalid() + self.seen_rpos_error: Vector2D = Vector2D(0, 0) - self._dist_from_self: float = 0 - self._angle_from_self: AngleDeg = AngleDeg(0) - self._dist_from_ball: float = 0 - self._angle_from_ball: AngleDeg = AngleDeg(0) + self.dist_from_self: float = 0 + self.angle_from_self: AngleDeg = AngleDeg(0) + self.dist_from_ball: float = 0 + self.angle_from_ball: AngleDeg = AngleDeg(0) - self._ghost_count: int = 0 - self._pos_history: list[Vector2D] = [] + self.ghost_count: int = 0 + self.pos_history: list[Vector2D] = [] - self._pos_count_thr: Union[None, int] = None - self._relation_pos_count_thr: Union[None, int] = None - self._vel_count_thr: Union[None, int] = None - - def pos(self) -> Vector2D: - return self._pos.copy() - - def pos_error(self) -> Vector2D: - return self._pos_error.copy() - - def pos_count(self) -> int: - return self._pos_count - - def possible_posses(self) -> list[Vector2D]: - return self._possible_poses - - def seen_pos(self) -> Vector2D: - return self._seen_pos.copy() - - def seen_pos_error(self) -> Vector2D: - raise Exception("Object.seen_pos_error is not implemented") - - def seen_pos_count(self) -> int: - return self._seen_pos_count - - def heard_pos(self) -> Vector2D: - return self._heard_pos - - def heard_pos_count(self) -> int: - return self._heard_pos_count - - def vel(self) -> Vector2D: - return self._vel.copy() - - def vel_error(self) -> Vector2D: - return self._vel_error.copy() - - def vel_count(self) -> int: - return self._vel_count - - def seen_vel(self) -> Vector2D: - return self._seen_vel.copy() - - def seen_vel_count(self) -> int: - return self._seen_vel_count - - def rpos(self) -> Vector2D: - return self._rpos.copy() - - def rpos_error(self) -> Vector2D: - return self._rpos_error.copy() - - def rpos_count(self) -> int: - return self._rpos_count - - def seen_rpos(self) -> Vector2D: - return self._seen_rpos - - def seen_rpos_error(self) -> Vector2D: - return self._seen_rpos_error - - def dist_from_self(self) -> float: - return self._dist_from_self - - def angle_from_self(self) -> AngleDeg: - return self._angle_from_self - - def dist_from_ball(self) -> float: - return self._dist_from_ball - - def angle_from_ball(self) -> AngleDeg: - return self._angle_from_ball - - def ghost_count(self): - return self._ghost_count + self.pos_count_thr: Union[None, int] = None + self.relation_pos_count_thr: Union[None, int] = None + self.vel_count_thr: Union[None, int] = None def vel_valid(self): - return self.vel_count() < self._vel_count_thr + return self.vel_count < self.vel_count_thr def pos_valid(self): - return self.pos_count() < self._pos_count_thr + return self.pos_count < self.pos_count_thr def rpos_valid(self): - return self._rpos_count < self._relation_pos_count_thr + return self.rpos_count < self.relation_pos_count_thr def reverse(self): - self._pos.reverse() - self._vel.reverse() + self.pos.reverse() + self.vel.reverse() self.reverse_more() def reverse_more(self): @@ -142,49 +70,45 @@ def update_with_world(self, wm): self._update_dist_from_self(wm) def update_more_with_full_state(self, wm: 'WorldModel'): - self._rpos = self.pos() - wm.self().pos() - self._rpos_count = 0 - self._seen_rpos = self.pos() - wm.self().pos() - self._dist_from_self: float = wm.self().pos().dist(self.pos()) - self._angle_from_self: AngleDeg = (wm.self().pos() - self.pos()).th() - self._dist_from_ball: float = (wm.ball().pos() - self.pos()) - self._angle_from_ball: AngleDeg = (wm.ball().pos() - self.pos()).th() + self.rpos = self.pos - wm.self().pos + self.rpos_count = 0 + self.seen_rpos = self.pos - wm.self().pos + self.dist_from_self: float = wm.self().pos.dist(self.pos) + self.angle_from_self: AngleDeg = (wm.self().pos - self.pos).th() + self.dist_from_ball: float = (wm.ball().pos - self.pos) + self.angle_from_ball: AngleDeg = (wm.ball().pos - self.pos).th() def _update_rpos(self, wm): - self._rpos: Vector2D = self._pos - wm.self().pos() + self.rpos: Vector2D = self.pos - wm.self().pos def _update_dist_from_self(self, wm): - self._dist_from_self = self._rpos.r() + self.dist_from_self = self.rpos.r() def long_str(self): - return f'pos: {self._pos}, ' \ - f'pos_error: {self._pos_error}, ' \ - f'pos_count: {self._pos_count}, ' \ - f'seen_pos: {self._seen_pos}, ' \ - f'seen_pos_count: {self._seen_pos_count}, ' \ - f'heard_pos: {self._heard_pos}, ' \ - f'heard_pos_count: {self._heard_pos_count}, ' \ - f'vel: {self._vel}, ' \ - f'vel_error: {self._vel_error}, ' \ - f'vel_count: {self._vel_count}, ' \ - f'seen_vel: {self._seen_vel}, ' \ - f'seen_vel_count: {self._seen_vel_count}, ' \ - f'heard_vel: {self._heard_vel}, ' \ - f'heard_vel_count: {self._heard_vel_count}, ' \ - f'rpos: {self._rpos}, ' \ - f'rpos_error: {self._rpos_error}, ' \ - f'rpos_count: {self._rpos_count}, ' \ - f'seen_rpos: {self._seen_rpos}, ' \ - f'seen_rpos_error: {self._seen_rpos_error}, ' \ - f'dist_from_self: {self._dist_from_self}, ' \ - f'angle_from_self: {self._angle_from_self}, ' \ - f'dist_from_ball: {self._dist_from_ball}, ' \ - f'angle_from_ball: {self._angle_from_ball}, ' \ - f'ghost_count: {self._ghost_count},' - # pos_history: {self._pos_history}, + return f'pos: {self.pos}, ' \ + f'pos_error: {self.pos_error}, ' \ + f'pos_count: {self.pos_count}, ' \ + f'seen_pos: {self.seen_pos}, ' \ + f'seen_pos_count: {self.seen_pos_count}, ' \ + f'heard_pos: {self.heard_pos}, ' \ + f'heard_pos_count: {self.heard_pos_count}, ' \ + f'vel: {self.vel}, ' \ + f'vel_error: {self.vel_error}, ' \ + f'vel_count: {self.vel_count}, ' \ + f'seen_vel: {self.seen_vel}, ' \ + f'seen_vel_count: {self.seen_vel_count}, ' \ + f'heard_vel: {self.heard_vel}, ' \ + f'heard_vel_count: {self.heard_vel_count}, ' \ + f'rpos: {self.rpos}, ' \ + f'rpos_error: {self.rpos_error}, ' \ + f'rpos_count: {self.rpos_count}, ' \ + f'seen_rpos: {self.seen_rpos}, ' \ + f'seen_rpos_error: {self.seen_rpos_error}, ' \ + f'dist_from_self: {self.dist_from_self}, ' \ + f'angle_from_self: {self.angle_from_self}, ' \ + f'dist_from_ball: {self.dist_from_ball}, ' \ + f'angle_from_ball: {self.angle_from_ball}, ' \ + f'ghost_count: {self.ghost_count},' def __str__(self): - return f'''pos: {self.pos()} vel:{self.vel()}''' - - def heard_vel_count(self): - return self._heard_vel_count \ No newline at end of file + return f'''pos: {self.pos} vel:{self.vel}''' diff --git a/lib/player/object_ball.py b/lib/player/object_ball.py index ce7feb1d..b2e874e9 100644 --- a/lib/player/object_ball.py +++ b/lib/player/object_ball.py @@ -20,11 +20,11 @@ class BallObject(Object): def __init__(self, string=None): super().__init__() - self._pos_count_thr: Union[None, int] = 10 - self._relation_pos_count_thr: Union[None, int] = 5 - self._vel_count_thr: Union[None, int] = 10 + self.pos_count_thr: Union[None, int] = 10 + self.relation_pos_count_thr: Union[None, int] = 5 + self.vel_count_thr: Union[None, int] = 10 - self._lost_count: int = 1000 + self.lost_count: int = 1000 if string is None: return @@ -32,49 +32,49 @@ def __init__(self, string=None): def init_str(self, string: str): data = string.split(" ") - self._pos = Vector2D(float(data[0]), float(data[1])) - self._seen_pos = Vector2D(float(data[0]), float(data[1])) - self._vel = Vector2D(float(data[2]), float(data[3])) - self._seen_vel = Vector2D(float(data[2]), float(data[3])) - self._pos_count = 0 - self._seen_pos_count = 0 - self._rpos_count = 0 - self._vel_count = 0 - self._seen_vel_count = 0 - self._ghost_count = 0 + self.pos = Vector2D(float(data[0]), float(data[1])) + self.seen_pos = Vector2D(float(data[0]), float(data[1])) + self.vel = Vector2D(float(data[2]), float(data[3])) + self.seen_vel = Vector2D(float(data[2]), float(data[3])) + self.pos_count = 0 + self.seen_pos_count = 0 + self.rpos_count = 0 + self.vel_count = 0 + self.seen_vel_count = 0 + self.ghost_count = 0 def inertia_point(self, cycle: int) -> Vector2D: - return inertia_n_step_point(self._pos, - self._vel, + return inertia_n_step_point(self.pos, + self.vel, cycle, ServerParam.i().ball_decay()) def inertia_final_point(self): - return inertia_final_point(self.pos(), - self.vel(), + return inertia_final_point(self.pos, + self.vel, ServerParam.i().ball_decay()) def copy(self): ball = BallObject() - ball._pos = self._pos.copy() - ball._vel = self._vel.copy() - ball._rpos = self._rpos.copy() - ball._seen_pos = self._seen_pos.copy() - ball._seen_vel = self._seen_vel.copy() - ball._heard_pos = self._heard_pos.copy() - ball._heard_vel = self._heard_vel.copy() - ball._dist_from_self = self._dist_from_self - ball._angle_from_self = self._angle_from_self + ball.pos = self.pos.copy() + ball.vel = self.vel.copy() + ball.rpos = self.rpos.copy() + ball.seen_pos = self.seen_pos.copy() + ball.seen_vel = self.seen_vel.copy() + ball.heard_pos = self.heard_pos.copy() + ball.heard_vel = self.heard_vel.copy() + ball.dist_from_self = self.dist_from_self + ball.angle_from_self = self.angle_from_self - ball._pos_count = self.pos_count() - ball._vel_count = self.vel_count() - ball._ghost_count = self.ghost_count() - ball._seen_pos_count = self.seen_pos_count() - ball._rpos_count = self.rpos_count() - ball._heard_pos_count = self.heard_pos_count() - ball._heard_vel_count = self.heard_vel_count() - ball._lost_count = self.lost_count() - ball._seen_vel_count = self.seen_vel_count() + ball.pos_count = self.pos_count + ball.vel_count = self.vel_count + ball.ghost_count = self.ghost_count + ball.seen_pos_count = self.seen_pos_count + ball.rpos_count = self.rpos_count + ball.heard_pos_count = self.heard_pos_count + ball.heard_vel_count = self.heard_vel_count + ball.lost_count = self.lost_count + ball.seen_vel_count = self.seen_vel_count return ball @@ -83,7 +83,7 @@ def update_by_last_cycle(self, act: 'ActionEffector', game_mode: GameMode): new_vel = Vector2D(0, 0) if self.vel_valid(): - new_vel = self.vel() + new_vel = self.vel if act.last_body_command() == CommandType.KICK: accel = act.get_kick_info() log.sw_log().world().add_text(f"ESTIMATING BALL VEL WITH KICK ACTION") @@ -91,7 +91,7 @@ def update_by_last_cycle(self, act: 'ActionEffector', game_mode: GameMode): if accel.r() > SP.ball_accel_max(): accel.set_length(SP.ball_accel_max()) new_vel += accel - self._vel_count = 0 + self.vel_count = 0 if new_vel.r() > SP.ball_speed_max(): new_vel.set_length(SP.ball_speed_max()) @@ -100,45 +100,45 @@ def update_by_last_cycle(self, act: 'ActionEffector', game_mode: GameMode): or game_mode.type().is_goal_kick() or game_mode.type().is_goalie_catch_ball() or game_mode.type().is_penalty_taken()): - self._pos_count = min(1000, self._pos_count + 1) + self.pos_count = min(1000, self.pos_count + 1) else: - if (self._pos_count >= 5 or (self._rpos_count >= 2 - and self.dist_from_self() * 1.05 < SP.visible_distance())): - self._pos_count = 1000 + if (self.pos_count >= 5 or (self.rpos_count >= 2 + and self.dist_from_self * 1.05 < SP.visible_distance())): + self.pos_count = 1000 else: - self._pos_count = 1 + self.pos_count = 1 new_vel.assign(0, 0) - self._vel_count = 0 - self._seen_vel.assign(0, 0) - self._seen_vel_count = 0 + self.vel_count = 0 + self.seen_vel.assign(0, 0) + self.seen_vel_count = 0 if self.pos_valid(): - self._pos += new_vel + self.pos += new_vel - self._vel = new_vel - self._vel *= SP.ball_decay() + self.vel = new_vel + self.vel *= SP.ball_decay() - self._rpos_count = min(1000, self._rpos_count + 1) - self._seen_pos_count = min(1000, self._seen_pos_count + 1) - self._heard_pos_count = min(1000, self._heard_pos_count + 1) - self._vel_count = min(1000, self._vel_count + 1) - self._seen_vel_count = min(1000, self._seen_vel_count + 1) - self._heard_vel_count = min(1000, self._heard_vel_count + 1) - self._lost_count = min(1000, self._lost_count + 1) + self.rpos_count = min(1000, self.rpos_count + 1) + self.seen_pos_count = min(1000, self.seen_pos_count + 1) + self.heard_pos_count = min(1000, self.heard_pos_count + 1) + self.vel_count = min(1000, self.vel_count + 1) + self.seen_vel_count = min(1000, self.seen_vel_count + 1) + self.heard_vel_count = min(1000, self.heard_vel_count + 1) + self.lost_count = min(1000, self.lost_count + 1) def update_only_vel(self, vel: Vector2D, vel_err: Vector2D, vel_count:int): - self._vel = vel.copy() - self._vel_error = vel_err.copy() - self._vel_count = vel_count - self._seen_vel = vel.copy() - self._seen_vel_count = vel_count + self.vel = vel.copy() + self.vel_error = vel_err.copy() + self.vel_count = vel_count + self.seen_vel = vel.copy() + self.seen_vel_count = vel_count def update_only_relative_pos(self, rpos: Vector2D, rpos_err: Vector2D): - self._rpos = rpos.copy() - self._rpos_error = rpos_err.copy() - self._rpos_count = 0 - self._seen_rpos = rpos.copy() + self.rpos = rpos.copy() + self.rpos_error = rpos_err.copy() + self.rpos_count = 0 + self.seen_rpos = rpos.copy() def update_pos(self, pos: Vector2D, @@ -146,16 +146,16 @@ def update_pos(self, pos_count: int, rpos: Vector2D, rpos_err: Vector2D): - self._pos = pos.copy() - self._pos_error = pos_err.copy() - self._pos_count = pos_count - self._seen_pos = pos.copy() - self._seen_pos_count = 0 + self.pos = pos.copy() + self.pos_error = pos_err.copy() + self.pos_count = pos_count + self.seen_pos = pos.copy() + self.seen_pos_count = 0 self.update_only_relative_pos(rpos, rpos_err) - self._lost_count = 0 - self._ghost_count = 0 + self.lost_count = 0 + self.ghost_count = 0 def update_all(self, pos: Vector2D, @@ -181,54 +181,54 @@ def update_by_game_mode(self, game_mode: GameMode): GMT.PenaltyTaken_Right]: return - self._vel = Vector2D(0, 0) - self._vel_count = 0 - self._seen_vel = Vector2D(0,0) - self._seen_vel_count = 0 + self.vel = Vector2D(0, 0) + self.vel_count = 0 + self.seen_vel = Vector2D(0,0) + self.seen_vel_count = 0 if type.is_goalie_catch_ball(): return if type.is_corner_kick(): - if self.pos_count() <= 1 and self.rpos().r2() > 3 ** 2: - self._pos.assign( - (SP.pitch_half_length() - SP.corner_kick_margin()) * (1 if self.pos().x() > 0 else -1), - (SP.pitch_half_width() - SP.corner_kick_margin()) * (1 if self.pos().y() > 0 else -1) + if self.pos_count <= 1 and self.rpos.r2() > 3 ** 2: + self.pos.assign( + (SP.pitch_half_length() - SP.corner_kick_margin()) * (1 if self.pos.x() > 0 else -1), + (SP.pitch_half_width() - SP.corner_kick_margin()) * (1 if self.pos.y() > 0 else -1) ) return if type.is_kick_in(): - if self.pos_count() <= 1 and self.rpos().r2() > 3**2: - self._pos._y = SP.pitch_half_width() * (1 if self.pos().y() > 0 else -1) + if self.pos_count <= 1 and self.rpos.r2() > 3**2: + self.pos._y = SP.pitch_half_width() * (1 if self.pos._y > 0 else -1) return if type in [GMT.BeforeKickOff, GMT.KickOff_Left, GMT.KickOff_Right]: - self._pos.assign(0,0) - self._pos_count = 0 - self._seen_pos.assign(0, 0) - self._seen_pos_count = 0 - self._ghost_count = 0 + self.pos.assign(0,0) + self.pos_count = 0 + self.seen_pos.assign(0, 0) + self.seen_pos_count = 0 + self.ghost_count = 0 def update_self_related(self, player: 'SelfObject' , prev: 'BallObject'): - if self.rpos_count() == 0: - self._dist_from_self = self.rpos().r() - self._angle_from_self = self.rpos().th() + if self.rpos_count == 0: + self.dist_from_self = self.rpos.r() + self.angle_from_self = self.rpos.th() else: - if prev.rpos().is_valid() and player.last_move().is_valid(): - self._rpos = prev.rpos() + self.vel() / ServerParam.i().ball_decay() - player.last_move() + if prev.rpos.is_valid() and player.last_move().is_valid(): + self.rpos = prev.rpos + self.vel / ServerParam.i().ball_decay() - player.last_move() - if self.rpos().is_valid() and self.pos_count() > self.rpos_count(): - self._pos = player.pos() + self.rpos() - self._dist_from_self = self.rpos().r() - self._angle_from_self = self.rpos().th() + if self.rpos.is_valid() and self.pos_count > self.rpos_count: + self.pos = player.pos + self.rpos + self.dist_from_self = self.rpos.r() + self.angle_from_self = self.rpos.th() elif self.pos_valid() and player.pos_valid(): - self._rpos = self.pos() - player.pos() - self._dist_from_self = self.rpos().r() - self._angle_from_self = self.rpos().th() + self.rpos = self.pos - player.pos + self.dist_from_self = self.rpos.r() + self.angle_from_self = self.rpos.th() else: - self._dist_from_self = 1000 - self._angle_from_self = AngleDeg(0) + self.dist_from_self = 1000 + self.angle_from_self = AngleDeg(0) def update_by_hear(self, act: 'ActionEffector', @@ -237,68 +237,65 @@ def update_by_hear(self, heard_vel: Vector2D, is_pass: bool = False): if BallObject.DEBUG: - log.sw_log().sensor().add_text( f"(update ball by hear) prior_pos={self.pos()} new_pos={heard_pos}") - log.sw_log().sensor().add_text( f"(update ball by hear) prior_vel={self.vel()} new_pos={heard_vel}") + log.sw_log().sensor().add_text( f"(update ball by hear) prior_pos={self.pos} new_pos={heard_pos}") + log.sw_log().sensor().add_text( f"(update ball by hear) prior_vel={self.vel} new_pos={heard_vel}") - self._heard_pos =heard_pos.copy() - self._heard_vel = heard_vel.copy() - self._heard_pos_count = 0 - self._heard_vel_count = 0 + self.heard_pos =heard_pos.copy() + self.heard_vel = heard_vel.copy() + self.heard_pos_count = 0 + self.heard_vel_count = 0 if act.last_body_command() == CommandType.KICK: return - dist_diff = heard_pos.dist(self.pos()) - if is_pass and heard_vel.is_valid() and self.seen_vel_count() > 0: - if self.seen_pos_count() > 0: - self._pos = heard_pos.copy() - self._pos_count = 1 - self._vel = heard_vel.copy() - self._vel_count = 1 + dist_diff = heard_pos.dist(self.pos) + if is_pass and heard_vel.is_valid() and self.seen_vel_count > 0: + if self.seen_pos_count > 0: + self.pos = heard_pos.copy() + self.pos_count = 1 + self.vel = heard_vel.copy() + self.vel_count = 1 return - if (self._ghost_count == 1 and self.pos_count() == 1 and dist_diff < 3) or self.ghost_count() > 1: - self._pos = heard_pos.copy() - self._pos_count = 1 + if (self.ghost_count == 1 and self.pos_count == 1 and dist_diff < 3) or self.ghost_count > 1: + self.pos = heard_pos.copy() + self.pos_count = 1 if heard_vel.is_valid(): - self._vel = heard_vel.copy() - self._vel_count =1 + self.vel = heard_vel.copy() + self.vel_count =1 return - if self.pos_count() >= 5 or (self.pos_count() >= 2 + if self.pos_count >= 5 or (self.pos_count >= 2 and (dist_diff > sender_to_ball_dist *0.05 + 1 - or sender_to_ball_dist < self._dist_from_self *0.95)): - self._pos = heard_pos.copy() - self._pos_count = 1 + or sender_to_ball_dist < self.dist_from_self *0.95)): + self.pos = heard_pos.copy() + self.pos_count = 1 if heard_vel.is_valid(): - self._vel = heard_vel.copy() - self._vel_count =1 + self.vel = heard_vel.copy() + self.vel_count =1 return - if self.pos_count() > 0 and sender_to_ball_dist+ 1 < ServerParam.i().visible_distance() < self.dist_from_self(): - self._pos = heard_pos.copy() - self._pos_count = 1 + if self.pos_count > 0 and sender_to_ball_dist+ 1 < ServerParam.i().visible_distance() < self.dist_from_self: + self.pos = heard_pos.copy() + self.pos_count = 1 if heard_vel.is_valid(): - self._vel = heard_vel.copy() - self._vel_count =1 + self.vel = heard_vel.copy() + self.vel_count =1 return def set_ghost(self): - if self._ghost_count > 0: - self._pos_count = 1000 - self._rpos_count = 1000 - self._lost_count = 0 - self._ghost_count += 1 + if self.ghost_count > 0: + self.pos_count = 1000 + self.rpos_count = 1000 + self.lost_count = 0 + self.ghost_count += 1 - self._dist_from_self = 1000 + self.dist_from_self = 1000 else: - self._ghost_count = 1 - - def lost_count(self): - return self._lost_count + self.ghost_count = 1 def __str__(self): - return f'''Ball pos: {self.pos()} vel:{self.vel()}''' + return f'''Ball pos: {self.pos} vel:{self.vel}''' diff --git a/lib/player/object_player.py b/lib/player/object_player.py index e6a069ea..b30a87c4 100644 --- a/lib/player/object_player.py +++ b/lib/player/object_player.py @@ -19,302 +19,227 @@ class PlayerObject(Object): def __init__(self, side: SideID = None, player: Localizer.PlayerT = None): super().__init__() - self._unum: int = UNUM_UNKNOWN - self._unum_count: int = 1000 - self._side: SideID = SideID.NEUTRAL - self._goalie: bool = False - self._player_type: PlayerType = PlayerType() - self._player_type_id: Union[None, int] = None - self._body: AngleDeg = AngleDeg(0) - self._body_count: int = 1000 - self._face: AngleDeg = AngleDeg(0) - self._face_count: int = 1000 - self._pointto_angle: float = 0 - self._pointto_count: int = 1000 - self._kick: bool = False - self._tackle: bool = False - self._charged: bool = False - self._kicking: bool = False - self._card: Card = Card.NO_CARD - self._kick_rate: float = 0.0 - self._tackle_count: int = 1000 + self.unum: int = UNUM_UNKNOWN + self.unum_count: int = 1000 + self.side: SideID = SideID.NEUTRAL + self.goalie: bool = False + self.player_type: PlayerType = PlayerType() + self.player_type_id: Union[None, int] = None + self.body: AngleDeg = AngleDeg(0) + self.body_count: int = 1000 + self.face: AngleDeg = AngleDeg(0) + self.face_count: int = 1000 + self.pointto_angle: float = 0 + self.pointto_count: int = 1000 + self.kick: bool = False + self.tackle: bool = False + self.charged: bool = False + self.kicking: bool = False + self.card: Card = Card.NO_CARD + self.kick_rate: float = 0.0 + self.tackle_count: int = 1000 if side is not None and player is not None: - self._side = side - self._unum = player.unum_ - self._goalie = player.goalie_ - self._pos = player.pos_.copy() - self._pos_count = 0 - self._seen_pos = player.pos_.copy() - self._seen_pos_count = 0 + self.side = side + self.unum = player.unum_ + self.goalie = player.goalie_ + self.pos = player.pos_.copy() + self.pos_count = 0 + self.seen_pos = player.pos_.copy() + self.seen_pos_count = 0 if player.unum_ != UNUM_UNKNOWN: - self._unum_count = 0 + self.unum_count = 0 - self._pos_count_thr: Union[None, int] = 30 - self._relation_pos_count_thr: Union[None, int] = 30 - self._vel_count_thr: Union[None, int] = 5 - self._body_count_thr: Union[None, int] = 2 + self.pos_count_thr: Union[None, int] = 30 + self.relation_pos_count_thr: Union[None, int] = 30 + self.vel_count_thr: Union[None, int] = 5 + self.body_count_thr: Union[None, int] = 2 # update with server data def init_dic(self, dic: dict): - self._unum = int(dic["unum"]) - self._pos = Vector2D(float(dic["pos_x"]), float(dic["pos_y"])) - self._vel = Vector2D(float(dic["vel_x"]), float(dic["vel_y"])) - self._side = SideID.RIGHT if dic["side_id"] == 'r' else SideID.LEFT if dic["side_id"] == 'l' else SideID.NEUTRAL - self._body = AngleDeg(float(dic["body"])) - self._neck = AngleDeg(float(dic["neck"])) - self._face = self._body + self._neck - self._goalie = True if "goalie" in dic else False - self._player_type_id = int(dic["player_type"]) - # self._pointto = Vector2D.invalid() TODO check this on full state + self.unum = int(dic["unum"]) + self.pos = Vector2D(float(dic["pos_x"]), float(dic["pos_y"])) + self.vel = Vector2D(float(dic["vel_x"]), float(dic["vel_y"])) + self.side = SideID.RIGHT if dic["side_id"] == 'r' else SideID.LEFT if dic["side_id"] == 'l' else SideID.NEUTRAL + self.body = AngleDeg(float(dic["body"])) + self.neck = AngleDeg(float(dic["neck"])) + self.face = self.body + self.neck + self.goalie = True if "goalie" in dic else False + self.player_type_id = int(dic["player_type"]) + # self.pointto = Vector2D.invalid() TODO check this on full state # if "pointto_dist" in dic: - # self._pointto = Vector2D.polar2vector(float(dic["pointto_dist"]), float(dic["pointto_dir"])) - self._stamina_model = StaminaModel(**dic["stamina"]) - self._kick = True if "kick" in dic else False - self._tackle = True if "tackle" in dic else False - self._charged = True if "charged" in dic else False - self._card = Card.NO_CARD + # self.pointto = Vector2D.polar2vector(float(dic["pointto_dist"]), float(dic["pointto_dir"])) + self.stamina_model = StaminaModel(**dic["stamina"]) + self.kick = True if "kick" in dic else False + self.tackle = True if "tackle" in dic else False + self.charged = True if "charged" in dic else False + self.card = Card.NO_CARD if "card" in dic: - self._card = Card.YELLOW if dic["card"] == "y" else Card.RED - self._kick_rate: float = 0.0 - self._rpos_count = 0 - self._vel_count = 0 - self._pos_count = 0 - self._body_count = 0 - self._ghost_count = 0 + self.card = Card.YELLOW if dic["card"] == "y" else Card.RED + self.kick_rate: float = 0.0 + self.rpos_count = 0 + self.vel_count = 0 + self.pos_count = 0 + self.body_count = 0 + self.ghost_count = 0 def reverse_more(self): - self._body.reverse() - self._neck.reverse() # TODO neck is relative?!?!?! + self.body.reverse() + self.neck.reverse() # TODO neck is relative?!?!?! def set_player_type(self, player_type: PlayerType): - self._player_type = player_type - self._player_type_id = player_type.id() - - def side(self): - return self._side - - def body(self) -> AngleDeg: - return self._body.copy() - - def neck(self): - return self._neck - - def face(self): - return self._face - - def goalie(self): - return self._goalie - - def player_type(self) -> PlayerType: - return self._player_type - - def pointto_angle(self): - return self._pointto_angle - - def pointto_count(self): - return self._pointto_count - - def stamina_model(self) -> StaminaModel: - return self._stamina_model.copy() - - def stamina(self): - return self._stamina_model.stamina() - - def recovery(self): - return self._stamina_model.recovery() - - def kick(self): - return self._kick - - def tackle(self): - return self._tackle - - def charged(self): - return self._charged - - def card(self): - return self._card + self.player_type = player_type + self.player_type_id = player_type.id() def set_kickable(self, ika: bool): - self._kickable = ika + self.kickable = ika def is_kickable(self, buf=0.05): - if self.player_type() is None: - return self.dist_from_ball() < ServerParam.i().kickable_area() - return self.dist_from_ball() < self.player_type().kickable_area() - buf - - def kick_rate(self): - return self._kick_rate - - def player_type_id(self): - return self._player_type_id + if self.player_type is None: + return self.dist_from_ball < ServerParam.i().kickable_area() + return self.dist_from_ball < self.player_type.kickable_area() - buf def inertia_point(self, n_step): - return self.player_type().inertia_point(self.pos(), self.vel(), n_step) + return self.player_type.inertia_point(self.pos, self.vel, n_step) def inertia_final_point(self): - return inertia_final_point(self.pos(), - self.vel(), + return inertia_final_point(self.pos, + self.vel, ServerParam.i().default_player_decay()) - def unum(self): - return self._unum - - def effort(self): # TODO update effort - return SP.i().default_effort_max() - def dash_rate(self): - return self.effort() * self.player_type().dash_power_rate() - - def dist_from_ball(self): - return self._dist_from_ball - - def tackle_probability(self): # TODO should be written again - return 0.25 - - def is_tackling(self): - return self._tackle - - def tackle_count(self): - return self._tackle_count - - def face_count(self): - return self._face_count + return self.stamina_model.effort() * self.player_type.dash_power_rate() def is_frozen(self): - return False + return False def is_ghost(self): - return self._ghost_count > 0 - - def body_count(self): - return self._body_count + return self.ghost_count > 0 def get_safety_dash_power(self, dash_power): - return self.stamina_model().get_safety_dash_power(self.player_type(), + return self.stamina_model.get_safety_dash_power(self.player_type, dash_power) def body_valid(self): - return self._body_count < self._body_count_thr + return self.body_count < self.body_count_thr def update_by_last_cycle(self): - self._pos_history = [self._pos] + self._pos_history - if len(self._pos_history) > 100: - self._pos_history = self._pos_history[:-1] + self.pos_history = [self.pos] + self.pos_history + if len(self.pos_history) > 100: + self.pos_history = self.pos_history[:-1] if self.vel_valid(): - self._pos += self.vel() + self.pos += self.vel - self._unum_count = min(1000, self._unum_count + 1) - self._pos_count = min(1000, self._pos_count + 1) - self._seen_pos_count = min(1000, self._seen_pos_count + 1) - self._heard_pos_count = min(1000, self._heard_pos_count + 1) - self._vel_count = min(1000, self._vel_count + 1) - self._body_count = min(1000, self._body_count + 1) - self._face_count = min(1000, self._face_count + 1) - self._pointto_count = min(1000, self._pointto_count + 1) - # self._kicking = min(1000, self._kicking + 1) - self._tackle_count = min(1000, self._tackle_count + 1) + self.unum_count = min(1000, self.unum_count + 1) + self.pos_count = min(1000, self.pos_count + 1) + self.seen_pos_count = min(1000, self.seen_pos_count + 1) + self.heard_pos_count = min(1000, self.heard_pos_count + 1) + self.vel_count = min(1000, self.vel_count + 1) + self.body_count = min(1000, self.body_count + 1) + self.face_count = min(1000, self.face_count + 1) + self.pointto_count = min(1000, self.pointto_count + 1) + # self.kicking = min(1000, self.kicking + 1) + self.tackle_count = min(1000, self.tackle_count + 1) def forgot(self): - self._pos_count = 1000 - self._seen_pos_count = 1000 - self._heard_pos_count = 1000 - self._vel_count = 1000 - self._seen_vel_count = 1000 - self._face_count = 1000 - self._pointto_count = 1000 - self._tackle_count = 1000 + self.pos_count = 1000 + self.seen_pos_count = 1000 + self.heard_pos_count = 1000 + self.vel_count = 1000 + self.seen_vel_count = 1000 + self.face_count = 1000 + self.pointto_count = 1000 + self.tackle_count = 1000 def update_by_see(self, side: SideID, player: Localizer.PlayerT): SP = ServerParam.i() - self._side = side - self._ghost_count = 0 + self.side = side + self.ghost_count = 0 if player.unum_ != UNUM_UNKNOWN: - self._unum = player.unum_ - self._unum_count = 0 + self.unum = player.unum_ + self.unum_count = 0 if not player.goalie_: - self._goalie = False + self.goalie = False if player.goalie_: - self._goalie = True + self.goalie = True - last_seen_move = player.pos_ - self._seen_pos - last_seen_pos_count = self._seen_pos_count + last_seen_move = player.pos_ - self.seen_pos + last_seen_pos_count = self.seen_pos_count if player.has_vel(): - self._vel = player.vel_ - self._vel_count = 0 - self._seen_vel = player.vel_ - self._seen_vel_count = 0 - elif (0 < self._pos_count <= 2 + self.vel = player.vel_ + self.vel_count = 0 + self.seen_vel = player.vel_ + self.seen_vel_count = 0 + elif (0 < self.pos_count <= 2 and player.rpos_.r2() < 40**2): - speed_max = self.player_type().real_speed_max() if self._player_type else SP.default_player_real_speed_max() - decay = self.player_type().player_decay() if self.player_type() else SP.default_player_decay() - self._vel = last_seen_move / last_seen_pos_count - tmp = self._vel.r() + speed_max = self.player_type.real_speed_max() if self.player_type else SP.default_player_real_speed_max() + decay = self.player_type.player_decay() if self.player_type else SP.default_player_decay() + self.vel = last_seen_move / last_seen_pos_count + tmp = self.vel.r() if tmp > speed_max: - self._vel *= speed_max / tmp + self.vel *= speed_max / tmp - self._vel *= decay - self._vel_count = last_seen_pos_count - self._seen_vel = self._vel.copy() - self._seen_vel_count = 0 + self.vel *= decay + self.vel_count = last_seen_pos_count + self.seen_vel = self.vel.copy() + self.seen_vel_count = 0 else: - self._vel = Vector2D(0, 0) - self._vel_count = 1000 + self.vel = Vector2D(0, 0) + self.vel_count = 1000 - self._pos = player.pos_.copy() - self._seen_pos = player.pos_.copy() - self._pos_count = 0 - self._seen_pos_count = 0 + self.pos = player.pos_.copy() + self.seen_pos = player.pos_.copy() + self.pos_count = 0 + self.seen_pos_count = 0 if player.has_angle(): - self._body = AngleDeg(player.body_) - self._face = AngleDeg(player.face_) - self._body_count = 0 - self._face_count = 0 + self.body = AngleDeg(player.body_) + self.face = AngleDeg(player.face_) + self.body_count = 0 + self.face_count = 0 elif last_seen_pos_count <= 2 and last_seen_move.r2() > 0.2**2: - self._body = last_seen_move.th() - self._body_count = max(0, last_seen_pos_count - 1) - self._face = AngleDeg(0) - self._face_count = 1000 - elif self.vel_valid() and self.vel().r2() > 0.2**2: - self._body = self.vel().th() - self._body_count = self.vel_count() - self._face = AngleDeg(0) - self._face_count = 1000 + self.body = last_seen_move.th() + self.body_count = max(0, last_seen_pos_count - 1) + self.face = AngleDeg(0) + self.face_count = 1000 + elif self.vel_valid() and self.vel.r2() > 0.2**2: + self.body = self.vel.th() + self.body_count = self.vel_count + self.face = AngleDeg(0) + self.face_count = 1000 - if player.is_pointing() and self._pointto_count >= SP.point_to_ban(): - self._pointto_angle = player.arm_ - self._pointto_count = 0 + if player.is_pointing() and self.pointto_count >= SP.point_to_ban(): + self.pointto_angle = player.arm_ + self.pointto_count = 0 - self._kicking = player.is_kicking() + self.kicking = player.is_kicking() if player.is_tackling(): - if self._tackle_count > SP.tackle_cycles(): - self._tackle_count = 0 + if self.tackle_count > SP.tackle_cycles(): + self.tackle_count = 0 elif player.rpos_.r2() > SP.visible_distance()**2: - self._tackle_count = 1000 + self.tackle_count = 1000 def update_self_ball_related(self, self_pos: Vector2D, ball_pos: Vector2D): - self._dist_from_self = (self.pos() - self_pos).r() - self._angle_from_self = (self.pos() - self_pos).th() - self._dist_from_ball = (self.pos() - ball_pos).r() - self._angle_from_ball = (self.pos() - ball_pos).th() + self.dist_from_self = (self.pos - self_pos).r() + self.angle_from_self = (self.pos - self_pos).th() + self.dist_from_ball = (self.pos - ball_pos).r() + self.angle_from_ball = (self.pos - ball_pos).th() def set_team(self, side: SideID, unum: int, goalie: bool): - self._side = side - self._unum = unum - self._goalie = goalie + self.side = side + self.unum = unum + self.goalie = goalie def update_by_hear(self, side: SideID, @@ -324,70 +249,70 @@ def update_by_hear(self, body: float): if PlayerObject.DEBUG: - log.sw_log().sensor().add_text( f"(update player by hear) unum={unum} prior_pos={self.pos()} new_pos={pos}") + log.sw_log().sensor().add_text( f"(update player by hear) unum={unum} prior_pos={self.pos} new_pos={pos}") - self._heard_pos = pos.copy() - self._heard_pos_count = 0 - self._ghost_count = 0 + self.heard_pos = pos.copy() + self.heard_pos_count = 0 + self.ghost_count = 0 if side is not SideID.NEUTRAL: - self._side = side + self.side = side - if unum != UNUM_UNKNOWN and self._unum_count > 0: - self._unum = unum + if unum != UNUM_UNKNOWN and self.unum_count > 0: + self.unum = unum - self._goalie = goalie + self.goalie = goalie - if self._unum_count > 2: - self._unum_count = 2 + if self.unum_count > 2: + self.unum_count = 2 - if (self._seen_pos_count >= 2 - or (self._seen_pos_count > 0 and self.dist_from_self() > 20)): - self._pos = pos.copy() - self._pos_count = 1 + if (self.seen_pos_count >= 2 + or (self.seen_pos_count > 0 and self.dist_from_self > 20)): + self.pos = pos.copy() + self.pos_count = 1 if body != -360: - if self._body_count >= 2: - self._body = AngleDeg(body) - self._body_count = 1 + if self.body_count >= 2: + self.body = AngleDeg(body) + self.body_count = 1 def is_self(self): return False def set_ghost(self): - self._ghost_count += 1 + self.ghost_count += 1 def is_goalie(self): - return self._goalie + return self.goalie - def unum_count(self): - return self._unum_count + def is_tackling(self): + return self.tackle def long_str(self): - res = f'unum: {self._unum} ' \ - f'side: {self._side} ' \ - f'body: {self._body} ' \ - f'goalie: {self._goalie} ' \ - f'player_type:({self._player_type}) ' \ - f'player_type_id: {self._player_type_id} ' \ - f'pointto_angle: {self._pointto_angle} ' \ - f'kick: {self._kick}' \ - f'tackle: {self._tackle}' \ - f'charged: {self._charged}' \ - f'kicking: {self._kicking}' \ - f'card: {self._card}' \ - f'kick_rate: {self._kick_rate}' \ - f'face: {self._face}' \ - f'body_count: {self._body_count}' \ - f'face_count: {self._face_count}' \ - f'pointto_count: {self._pointto_count}' \ - f'unum_count: {self._unum_count}' \ - f'tackle_count: {self._tackle_count}' + res = f'unum: {self.unum} ' \ + f'side: {self.side} ' \ + f'body: {self.body} ' \ + f'goalie: {self.goalie} ' \ + f'player_type:({self.player_type}) ' \ + f'player_type_id: {self.player_type_id} ' \ + f'pointto_angle: {self.pointto_angle} ' \ + f'kick: {self.kick}' \ + f'tackle: {self.tackle}' \ + f'charged: {self.charged}' \ + f'kicking: {self.kicking}' \ + f'card: {self.card}' \ + f'kick_rate: {self.kick_rate}' \ + f'face: {self.face}' \ + f'body_count: {self.body_count}' \ + f'face_count: {self.face_count}' \ + f'pointto_count: {self.pointto_count}' \ + f'unum_count: {self.unum_count}' \ + f'tackle_count: {self.tackle_count}' res += super(PlayerObject, self).long_str() return res def __str__(self): - return f'''Player side:{self._side.name} unum:{self._unum} pos:{self.pos()} vel:{self.vel()} body:{self._body} poscount:{self._pos_count} ghostcount:{self._ghost_count}''' + return f'''Player side:{self.side.name} unum:{self.unum} pos:{self.pos} vel:{self.vel} body:{self.body} poscount:{self.pos_count} ghostcount:{self.ghost_count}''' def __repr__(self): return self.__str__() diff --git a/lib/player/object_self.py b/lib/player/object_self.py index 0b24bdc4..693b4b72 100644 --- a/lib/player/object_self.py +++ b/lib/player/object_self.py @@ -22,107 +22,101 @@ class SelfObject(PlayerObject): def __init__(self, player: PlayerObject = None): super().__init__() - self._time: GameTime = GameTime() - self._sense_body_time: GameTime = GameTime() - self._view_width: ViewWidth = ViewWidth.ILLEGAL - self._neck: AngleDeg = AngleDeg(0) - self._face_error = 0.5 - self._stamina_model: StaminaModel = StaminaModel() - self._last_catch_time: GameTime = GameTime() - self._tackle_expires: int = 0 - self._charge_expires: int = 0 - self._arm_moveable: int = 0 - self._arm_expires: int = 0 - self._pointto_rpos: Vector2D = Vector2D.invalid() - self._pointto_pos: Vector2D = Vector2D.invalid() - self._last_pointto_time: GameTime = GameTime() - self._attentionto_side: SideID = SideID.NEUTRAL - self._attentionto_unum: int = 0 - self._collision_estimated: bool = False - self._collides_with_none: bool = False - self._collides_with_ball: bool = False - self._collides_with_player: bool = False - self._collides_with_post: bool = False - self._kickable: bool = False - self._kick_rate: float = 0 - self._catch_probability: float = 0 - self._tackle_probability: float = 0 - self._foul_probability: float = 0 - self._last_move: Vector2D = Vector2D(0, 0) - self._last_moves: list[Vector2D] = [Vector2D(0, 0) for _ in range(4)] - self._arm_movable: int = 0 - self._face_count_thr: Union[None, int] = 5 + self.time: GameTime = GameTime() + self.sense_body_time: GameTime = GameTime() + self.view_width: ViewWidth = ViewWidth.ILLEGAL + self.neck: AngleDeg = AngleDeg(0) + self.face_error = 0.5 + self.stamina_model: StaminaModel = StaminaModel() + self.last_catch_time: GameTime = GameTime() + self.tackle_expires: int = 0 + self.charge_expires: int = 0 + self.arm_expires: int = 0 + self.pointto_rpos: Vector2D = Vector2D.invalid() + self.pointto_pos: Vector2D = Vector2D.invalid() + self.last_pointto_time: GameTime = GameTime() + self.attentionto_side: SideID = SideID.NEUTRAL + self.attentionto_unum: int = 0 + self.collision_estimated: bool = False + self.collides_with_none: bool = False + self.collides_with_ball: bool = False + self.collides_with_player: bool = False + self.collides_with_post: bool = False + self.kickable: bool = False + self.kick_rate: float = 0 + self.catch_probability: float = 0 + self.tackle_probability: float = 0 + self.foul_probability: float = 0 + self.last_move_: Vector2D = Vector2D(0, 0) + self.last_moves: list[Vector2D] = [Vector2D(0, 0) for _ in range(4)] + self.arm_movable: int = 0 + self.change_focus_count: int = 0 + self.focus_point_dist: float = 0 + self.focus_point_dir: AngleDeg = AngleDeg(0) + + self.face_count_thr: Union[None, int] = 5 def init(self, side: SideID, unum: int, goalie: bool): - self._side = side - self._unum = unum - self._goalie = goalie + self.side = side + self.unum = unum + self.goalie = goalie def update_by_player_info(self, player: PlayerObject): - self._unum = player._unum - self._pos = player._pos - self._vel = player._vel - self._side = player._side - self._body = player._body - self._neck = player._neck - self._face = player._face - self._goalie = player._goalie - self._player_type_id = player._player_type_id - self._player_type = player.player_type() - self._stamina_model = player._stamina_model - self._kick = player._kick - self._tackle = player._tackle - self._charged = player._charged - self._card = player._card - self._card = player._card - self._kick_rate = player._kick_rate - self._rpos_count = 0 - self._vel_count = 0 - self._pos_count = 0 - self._body_count = 0 - self._change_focus_count = 0 - self._focus_point_dist = 0 - self._focus_point_dir = AngleDeg(0) - self._ghost_count = 0 - - def view_width(self): - return self._view_width - - def face_error(self): - return self._face_error + self.unum = player.unum + self.pos = player.pos + self.vel = player.vel + self.side = player.side + self.body = player.body + self.neck = player.neck + self.face = player.face + self.goalie = player.goalie + self.player_type_id = player.player_type_id + self.player_type = player.player_type + self.stamina_model = player.stamina_model + self.kick = player.kick + self.tackle = player.tackle + self.charged = player.charged + self.card = player.card + self.card = player.card + self.kick_rate = player.kick_rate + self.rpos_count = 0 + self.vel_count = 0 + self.pos_count = 0 + self.body_count = 0 + self.change_focus_count = 0 + self.focus_point_dist = 0 + self.focus_point_dir = AngleDeg(0) + self.ghost_count = 0 def is_frozen(self): - return self._tackle_expires > 0 or self._charge_expires > 0 + return self.tackle_expires > 0 or self.charge_expires > 0 def face_valid(self): - return self._face_count < SelfObject.FACE_COUNT_THR + return self.face_count < SelfObject.FACE_COUNT_THR def last_move(self, index=None): if index: - index = min_max(0, index, len(self._last_moves)-1) - return self._last_moves[index] - return self._last_move + index = min_max(0, index, len(self.last_moves)-1) + return self.last_moves[index] + return self.last_move_ def is_kicking(self): - return self._kicking + return self.kicking def is_kickable(self, buf=0.0): - return self._kickable + return self.kickable def set_view_mode(self, vw: ViewWidth): - self._view_width = vw + self.view_width = vw - def catch_time(self): - return self._last_catch_time - def update_by_last_cycle(self, act: ActionEffector, current_time: GameTime): - if self._time == current_time: + if self.time == current_time: return SP = ServerParam.i() - self._time = current_time.copy() - self._kicking = False + self.time = current_time.copy() + self.kicking = False accel = Vector2D(0,0) dash_power = 0 @@ -137,71 +131,71 @@ def update_by_last_cycle(self, act: ActionEffector, current_time: GameTime): elif act.last_body_command() == CommandType.TACKLE: if not act.tackle_foul(): - self._tackle_expires = SP.tackle_cycles() - self._kicking = True + self.tackle_expires = SP.tackle_cycles() + self.kicking = True elif act.last_body_command() == CommandType.MOVE: - self._pos = act.get_move_pos() + self.pos = act.get_move_pos() elif act.last_body_command() == CommandType.CATCH: pass elif act.last_body_command() == CommandType.KICK: - self._kicking = True + self.kicking = True if act.done_turn_neck(): neck_moment = act.get_turn_neck_moment() - self._neck += min_max(SP.min_neck_angle(), neck_moment, SP.max_neck_angle()) + self.neck += min_max(SP.min_neck_angle(), neck_moment, SP.max_neck_angle()) if act.done_change_focus(): - self._focus_point_dir += act.get_change_focus_moment_dir() - self._focus_point_dist += act.get_change_focus_moment_dist() + self.focus_point_dir += act.get_change_focus_moment_dir() + self.focus_point_dist += act.get_change_focus_moment_dist() - self._stamina_model.simulate_dash(self.player_type(), dash_power) + self.stamina_model.simulate_dash(self.player_type, dash_power) - self._body += turn_moment - self._face = self._body + self._neck - self._face_error = 0.5 + self.body += turn_moment + self.face = self.body + self.neck + self.face_error = 0.5 if self.vel_valid(): - self._vel += accel + self.vel += accel if self.pos_valid(): - self._pos += self._vel - self._vel *= self.player_type().player_decay() + self.pos += self.vel + self.vel *= self.player_type.player_decay() - self._pos_count += 1 - self._seen_pos_count += 1 - self._vel_count += 1 - self._seen_vel_count += 1 - self._body_count += 1 - self._face_count += 1 - self._pointto_count = min(1000, self._pointto_count + 1) - self._tackle_expires = max(0, self._tackle_expires - 1) - self._charge_expires = max(0, self._charge_expires - 1) - self._arm_movable = max(0, self._arm_movable - 1) - self._arm_expires = max(0, self._arm_expires - 1) - self._last_move = self._vel / self.player_type().player_decay() - self._last_moves = [self._last_move] + self._last_moves[0:-1] - self._collision_estimated = False - self._collides_with_none = False - self._collides_with_ball = False - self._collides_with_player = False - self._collides_with_post = False + self.pos_count += 1 + self.seen_pos_count += 1 + self.vel_count += 1 + self.seen_vel_count += 1 + self.body_count += 1 + self.face_count += 1 + self.pointto_count = min(1000, self.pointto_count + 1) + self.tackle_expires = max(0, self.tackle_expires - 1) + self.charge_expires = max(0, self.charge_expires - 1) + self.arm_movable = max(0, self.arm_movable - 1) + self.arm_expires = max(0, self.arm_expires - 1) + self.last_move_ = self.vel / self.player_type.player_decay() + self.last_moves = [self.last_move_] + self.last_moves[0:-1] + self.collision_estimated = False + self.collides_with_none = False + self.collides_with_ball = False + self.collides_with_player = False + self.collides_with_post = False def update_angle_by_see(self, face: float, angle_face_error, current_time: GameTime): - self._time = current_time.copy() - self._face = AngleDeg(face) - self._body = AngleDeg(face - self._neck.degree()) - self._face_error = angle_face_error - self._body_count = 0 - self._face_count = 0 + self.time = current_time.copy() + self.face = AngleDeg(face) + self.body = AngleDeg(face - self.neck.degree()) + self.face_error = angle_face_error + self.body_count = 0 + self.face_count = 0 def update_vel_dir_after_see(self, sense: SenseBodyParser, current_time: GameTime): if sense.time() != current_time: log.os_log().error("(update vel dir after see) sense time does not match current time") return - if self.face_count() == 0: + if self.face_count == 0: sensed_speed_dir = sense.speed_dir() sensed_speed_dir_error = 0.5 if sensed_speed_dir == 0.0: @@ -211,199 +205,199 @@ def update_vel_dir_after_see(self, sense: SenseBodyParser, current_time: GameTim elif sensed_speed_dir < 0: sensed_speed_dir = AngleDeg.normalize_angle(sensed_speed_dir - 0.5) - vel_ang = self._face + sensed_speed_dir + vel_ang = self.face + sensed_speed_dir - self._vel.set_polar(sense.speed_mag(), vel_ang) - self._vel_count = 0 - self._seen_vel = self.vel().copy() - self._seen_vel_count = 0 + self.vel.set_polar(sense.speed_mag(), vel_ang) + self.vel_count = 0 + self.seen_vel = self.vel.copy() + self.seen_vel_count = 0 # TODO cos_min_max and sin_min_max should be implemented # min_cos, max_cos = vel_ang.cos_min_max(self.face_error() + sensed_speed_dir_error) # min_sin, max_sin = vel_ang.sin_min_max(self.face_error() + sensed_speed_dir_error) - # self._vel_error.assign((max_cos - min_cos) * (sense.speed_mag() + 0.005), (max_sin - min_sin) * (sense.speed_mag() + 0.005)) + # self.vel_error.assign((max_cos - min_cos) * (sense.speed_mag() + 0.005), (max_sin - min_sin) * (sense.speed_mag() + 0.005)) - if not self._collision_estimated: - new_last_move = self._vel/self.player_type().player_decay() - self._last_move.assign(new_last_move.x(), new_last_move.y()) + if not self.collision_estimated: + new_last_move = self.vel/self.player_type.player_decay() + self.last_move_.assign(new_last_move.x(), new_last_move.y()) def update_pos_by_see(self, pos: Vector2D, pos_err: Vector2D, my_possible_posses: list[Vector2D], face: float, face_err: float, current_time: GameTime): - self._time = current_time.copy() + self.time = current_time.copy() - if self._pos_count == 1: + if self.pos_count == 1: new_pos = pos.copy() new_err = pos_err.copy() - if self._pos_error.x() < pos_err.x(): - new_pos.set_x(pos.x() + (self.pos().x() - pos.x()) * (pos_err.x() / (self._pos_error.x() + pos_err.x()))) - new_err.set_x((self._pos_error.x() + pos_err.x()) * 0.5) - if self._pos_error.y() < pos_err.y(): - new_pos.set_y(pos.y() + (self.pos().y() - pos.y()) * (pos_err.y() / (self._pos_error.y() + pos_err.y()))) - new_err.set_y((self._pos_error.y() + pos_err.y()) * 0.5) - self._pos = new_pos.copy() - self._pos_error = new_err.copy() - self._possible_posses = [self._pos.copy()] + if self.pos_error.x() < pos_err.x(): + new_pos.set_x(pos.x() + (self.pos.x() - pos.x()) * (pos_err.x() / (self.pos_error.x() + pos_err.x()))) + new_err.set_x((self.pos_error.x() + pos_err.x()) * 0.5) + if self.pos_error.y() < pos_err.y(): + new_pos.set_y(pos.y() + (self.pos.y() - pos.y()) * (pos_err.y() / (self.pos_error.y() + pos_err.y()))) + new_err.set_y((self.pos_error.y() + pos_err.y()) * 0.5) + self.pos = new_pos.copy() + self.pos_error = new_err.copy() + self.possible_posses = [self.pos.copy()] # TODO has sensed collision -> collisionEstimated - if self._seen_pos_count == 1 and (self.has_sensed_collision() or not self.last_move().is_valid()): - self._last_move = new_pos - self._seen_pos - self._last_moves[0] = self.last_move().copy() + if self.seen_pos_count == 1 and (self.has_sensed_collision() or not self.last_move().is_valid()): + self._last_move = new_pos - self.seen_pos + self.last_moves[0] = self.last_move().copy() else: - self._pos = pos.copy() - self._pos_error = pos_err.copy() - self._possible_posses = my_possible_posses - - self._seen_pos = pos.copy() - self._face = AngleDeg(face) - self._body = AngleDeg(face) - self._neck - - self._pos_count = 0 - self._seen_pos_count = 0 - self._body_count = 0 - self._face_count = 0 + self.pos = pos.copy() + self.pos_error = pos_err.copy() + self.possible_posses = my_possible_posses + + self.seen_pos = pos.copy() + self.face = AngleDeg(face) + self.body = AngleDeg(face) - self.neck + + self.pos_count = 0 + self.seen_pos_count = 0 + self.body_count = 0 + self.face_count = 0 def has_sensed_collision(self): return( - self._collides_with_none - or self._collides_with_ball - or self._collides_with_player - or self._collides_with_post + self.collides_with_none + or self.collides_with_ball + or self.collides_with_player + or self.collides_with_post ) def update_self_after_sense_body(self, sense_body: SenseBodyParser, act: ActionEffector, current_time: GameTime): - if self._sense_body_time == current_time: + if self.sense_body_time == current_time: log.os_log().critical(f"(self update after see) called twice at {current_time}") return - self._sense_body_time = current_time.copy() + self.sense_body_time = current_time.copy() self.update_by_last_cycle(act, current_time) - self._kicking = act.last_body_command() == CommandType.KICK or act.last_body_command() == CommandType.TACKLE - self._view_width = sense_body.view_width() + self.kicking = act.last_body_command() == CommandType.KICK or act.last_body_command() == CommandType.TACKLE + self.view_width = sense_body.view_width() - self._stamina_model.update_by_sense_body(sense_body.stamina(), + self.stamina_model.update_by_sense_body(sense_body.stamina(), sense_body.effort(), sense_body.stamina_capacity(), current_time) - if abs(self._neck.degree() - sense_body.neck_relative()) > 0.5: - self._neck = AngleDeg(sense_body.neck_relative()) + if abs(self.neck.degree() - sense_body.neck_relative()) > 0.5: + self.neck = AngleDeg(sense_body.neck_relative()) if (sense_body.none_collided() or sense_body.ball_collided() or sense_body.player_collided() or sense_body.post_collided()): - self._collision_estimated = False + self.collision_estimated = False if sense_body.none_collided(): - self._collides_with_none = True + self.collides_with_none = True if sense_body.ball_collided(): - self._collides_with_ball = True - self._collision_estimated = True + self.collides_with_ball = True + self.collision_estimated = True if sense_body.player_collided(): - self._collides_with_player = True - self._collision_estimated = True + self.collides_with_player = True + self.collision_estimated = True if sense_body.post_collided(): - self._collides_with_post = True - self._collision_estimated = True + self.collides_with_post = True + self.collision_estimated = True if self.face_valid(): - self._face = self._body + self._neck + self.face = self.body + self.neck - estimate_vel = self._vel.copy() + estimate_vel = self.vel.copy() sensed_speed_dir = sense_body.speed_dir() if sensed_speed_dir > 0: sensed_speed_dir = AngleDeg.normalize_angle(sensed_speed_dir + 0.5) elif sensed_speed_dir < 0: sensed_speed_dir = AngleDeg.normalize_angle(sensed_speed_dir - 0.5) - vel_ang = self._face + sensed_speed_dir - self._vel.set_polar(sense_body.speed_mag(), vel_ang) + vel_ang = self.face + sensed_speed_dir + self.vel.set_polar(sense_body.speed_mag(), vel_ang) if (not self.has_sensed_collision() and self.vel_valid() - and sense_body.speed_mag() < self.player_type().real_speed_max()*self.player_type().player_decay()*0.11): + and sense_body.speed_mag() < self.player_type.real_speed_max()*self.player_type.player_decay()*0.11): if (estimate_vel.r() > 0.01 and sense_body.speed_mag() < estimate_vel.r() *0.2 - and (estimate_vel.abs_x() < 0.08 or estimate_vel.x() * self._vel.x() < 0) - and (estimate_vel.abs_y() < 0.08 or estimate_vel.y() * self._vel.y() < 0)): + and (estimate_vel.abs_x() < 0.08 or estimate_vel.x() * self.vel.x() < 0) + and (estimate_vel.abs_y() < 0.08 or estimate_vel.y() * self.vel.y() < 0)): - self._collision_estimated = True + self.collision_estimated = True - self._vel_count = self.face_count() + self.vel_count = self.face_count if sense_body.arm_expires() == 0: - self._pointto_pos.invalidate() - self._pointto_count = 1000 + self.pointto_pos.invalidate() + self.pointto_count = 1000 - if not self._collision_estimated: - new_last_move=self._vel / self.player_type().player_decay() - self._last_move.assign(new_last_move.x(), new_last_move.y()) + if not self.collision_estimated: + new_last_move=self.vel / self.player_type.player_decay() + self.last_move_.assign(new_last_move.x(), new_last_move.y()) else: - self._last_move.invalidate() + self.last_move_.invalidate() - if self._collision_estimated or self._collides_with_ball: - self._last_moves[0].invalidate() + if self.collision_estimated or self.collides_with_ball: + self.last_moves[0].invalidate() - self._attentionto_side = sense_body.attentionto_side() - self._attentionto_unum = sense_body.attentionto_unum() - self._tackle_expires = sense_body.tackle_expires() - self._arm_movable = sense_body.arm_movable() - self._arm_expires = sense_body.arm_expires() - self._charge_expires = sense_body.charged_expires() - self._card = sense_body.card() - self._change_focus_count = sense_body.change_focus_count() - self._focus_point_dist = sense_body.focus_point_dist() - self._focus_point_dir = AngleDeg(sense_body.focus_point_dir()) + self.attentionto_side = sense_body.attentionto_side() + self.attentionto_unum = sense_body.attentionto_unum() + self.tackle_expires = sense_body.tackle_expires() + self.arm_movable = sense_body.arm_movable() + self.arm_expires = sense_body.arm_expires() + self.charge_expires = sense_body.charged_expires() + self.card = sense_body.card + self.change_focus_count = sense_body.change_focus_count() + self.focus_point_dist = sense_body.focus_point_dist() + self.focus_point_dir = AngleDeg(sense_body.focus_point_dir()) def set_pointto(self,point: Vector2D, done_time: GameTime): - self._pointto_pos = point.copy() - self._last_pointto_time = done_time + self.pointto_pos = point.copy() + self.last_pointto_time = done_time if self.pos_valid(): - self._pointto_angle = (point - self.pos()).th() - self._pointto_count = 0 + self.pointto_angle = (point - self.pos).th() + self.pointto_count = 0 def update_ball_info(self, ball: BallObject): - self._kickable = False - self._kick_rate = 0 - self._catch_probability = 0 - self._tackle_probability = 0 - self._foul_probability = 0 + self.kickable = False + self.kick_rate = 0 + self.catch_probability = 0 + self.tackle_probability = 0 + self.foul_probability = 0 - if self.pos_count() > 100 or not ball.pos_valid(): + if self.pos_count > 100 or not ball.pos_valid(): return - self._dist_from_ball = ball.dist_from_self() - self._angle_from_ball = ball.angle_from_self() + 180 + self.dist_from_ball = ball.dist_from_self + self.angle_from_ball = ball.angle_from_self + 180 - if ball.ghost_count() > 0: + if ball.ghost_count > 0: return SP = ServerParam.i() - ptype = self.player_type() + ptype = self.player_type if SelfObject.DEBUG: log.os_log().debug(f"(self obj update ball_info) player_type_id={ptype.id()}") log.os_log().debug(f"(self obj update ball_info) kickable_area={ptype.kickable_area()}") - if ball.dist_from_self() <= ptype.kickable_area(): + if ball.dist_from_self <= ptype.kickable_area(): buff = 0.055 - if ball.seen_pos_count() >= 1: + if ball.seen_pos_count >= 1: buff = 0.155 - if ball.seen_pos_count() >= 2: + if ball.seen_pos_count >= 2: buff = 0.255 - if ball.dist_from_self() <= ptype.kickable_area() - buff: - self._kickable = True + if ball.dist_from_self <= ptype.kickable_area() - buff: + self.kickable = True - self._kick_rate = ptype.kick_rate(ball.dist_from_self(), - (ball.angle_from_self() - self.body()).degree()) + self.kick_rate = ptype.kick_rate(ball.dist_from_self, + (ball.angle_from_self - self.body).degree()) - if self._last_catch_time.cycle() + SP.catch_ban_cycle() <= self._time.cycle(): - self._catch_probability = ptype.get_catch_probability(self.pos(), self.body(), ball.pos(), 0.055, 0.5) + if self.last_catch_time.cycle() + SP.catch_ban_cycle() <= self.time.cycle(): + self.catch_probability = ptype.get_catch_probability(self.pos, self.body, ball.pos, 0.055, 0.5) - player2ball = (ball.pos() - self.pos()).rotated_vector(-self.body()) + player2ball = (ball.pos - self.pos).rotated_vector(-self.body) tackle_dist = SP.tackle_dist() if player2ball.x() > 0 else SP.tackle_back_dist() tackle_fail_prob = 1 foul_fail_prob = 1 @@ -415,185 +409,165 @@ def update_ball_info(self, ball: BallObject): + (player2ball.abs_y()/SP.tackle_width())**SP.foul_exponent()) if tackle_fail_prob < 1: - self._tackle_probability = 1 - tackle_fail_prob + self.tackle_probability = 1 - tackle_fail_prob if foul_fail_prob < 1: - self._foul_probability = 1 - foul_fail_prob + self.foul_probability = 1 - foul_fail_prob def update_kickable_state(self, ball: BallObject, self_reach_cycle: int, teammate_reach_cycle: int, opponent_reach_cycle: int): - if (not self._kickable - and ball.seen_pos_count() == 0 - and ball.dist_from_self() < self.player_type().kickable_area() - 0.001): + if (not self.kickable + and ball.seen_pos_count == 0 + and ball.dist_from_self < self.player_type.kickable_area() - 0.001): if (self_reach_cycle >= 10 and opponent_reach_cycle < min(self_reach_cycle, teammate_reach_cycle) - 7): - self._kickable = True + self.kickable = True return min_cycle = min(self_reach_cycle, teammate_reach_cycle, opponent_reach_cycle) ball_pos = ball.inertia_point(min_cycle) if ball_pos.abs_x() > ServerParam.i().pitch_half_length() or ball_pos.abs_y() > ServerParam.i().pitch_half_width(): - self._kickable = True + self.kickable = True return if opponent_reach_cycle > 0: - self._foul_probability = 0 - - def attentionto_side(self): - return self._attentionto_side - - def attentionto_unum(self): - return self._attentionto_unum + self.foul_probability = 0 def set_attentionto(self, side: SideID, unum: int): - self._attentionto_side = side - self._attentionto_unum = unum + self.attentionto_side = side + self.attentionto_unum = unum def is_self(self): return True - def tackle_probability(self): - return self._tackle_probability - - def foul_probability(self): - return self._foul_probability - - def change_focus_count(self): - return self._change_focus_count - - def focus_point_dist(self) -> float: - return self._focus_point_dist - - def focus_point_dir(self) -> AngleDeg: - return self._focus_point_dir - def focus_point(self) -> Vector2D: - return self._pos + Vector2D.polar2vector(self.focus_point_dist(), self.face() + self.focus_point_dir()) + return self.pos + Vector2D.polar2vector(self.focus_point_dist, self.face + self.focus_point_dir) def str_sensed_body(self): return f''' - self._sense_body_time + self.sense_body_time ''' def long_str(self): res = super(SelfObject, self).long_str() - res += f'time: {self._time}, ' \ - f'sense_body_time: {self._sense_body_time}, ' \ - f'view_width: {self._view_width}, ' \ - f'neck: {self._neck}, ' \ - f'face_error: {self._face_error}, ' \ - f'stamina_model: {self._stamina_model}, ' \ - f'last_catch_time: {self._last_catch_time}, ' \ - f'tackle_expires: {self._tackle_expires}, ' \ - f'charge_expires: {self._charge_expires}, ' \ - f'arm_moveable: {self._arm_moveable}, ' \ - f'arm_expires: {self._arm_expires}, ' \ - f'pointto_rpos: {self._pointto_rpos}, ' \ - f'pointto_pos: {self._pointto_pos}, ' \ - f'last_pointto_time: {self._last_pointto_time}, ' \ - f'attentionto_side: {self._attentionto_side}, ' \ - f'attentionto_unum: {self._attentionto_unum}, ' \ - f'collision_estimated: {self._collision_estimated}, ' \ - f'collides_with_none: {self._collides_with_none}, ' \ - f'collides_with_ball: {self._collides_with_ball}, ' \ - f'collides_with_player: {self._collides_with_player}, ' \ - f'collides_with_post: {self._collides_with_post}, ' \ - f'kickable: {self._kickable}, ' \ - f'kick_rate: {self._kick_rate}, ' \ - f'catch_probability: {self._catch_probability}, ' \ - f'tackle_probability: {self._tackle_probability}, ' \ - f'foul_probability: {self._foul_probability}, ' \ - f'last_move: {self._last_move}, ' \ - f'last_moves: {self._last_moves}, ' \ - f'arm_movable: {self._arm_movable}, ' + res += f'time: {self.time}, ' \ + f'sense_body_time: {self.sense_body_time}, ' \ + f'view_width: {self.view_width}, ' \ + f'neck: {self.neck}, ' \ + f'face_error: {self.face_error}, ' \ + f'stamina_model: {self.stamina_model}, ' \ + f'last_catch_time: {self.last_catch_time}, ' \ + f'tackle_expires: {self.tackle_expires}, ' \ + f'charge_expires: {self.charge_expires}, ' \ + f'arm_movable: {self.arm_movable}, ' \ + f'arm_expires: {self.arm_expires}, ' \ + f'pointto_rpos: {self.pointto_rpos}, ' \ + f'pointto_pos: {self.pointto_pos}, ' \ + f'last_pointto_time: {self.last_pointto_time}, ' \ + f'attentionto_side: {self.attentionto_side}, ' \ + f'attentionto_unum: {self.attentionto_unum}, ' \ + f'collision_estimated: {self.collision_estimated}, ' \ + f'collides_with_none: {self.collides_with_none}, ' \ + f'collides_with_ball: {self.collides_with_ball}, ' \ + f'collides_with_player: {self.collides_with_player}, ' \ + f'collides_with_post: {self.collides_with_post}, ' \ + f'kickable: {self.kickable}, ' \ + f'kick_rate: {self.kick_rate}, ' \ + f'catch_probability: {self.catch_probability}, ' \ + f'tackle_probability: {self.tackle_probability}, ' \ + f'foul_probability: {self.foul_probability}, ' \ + f'last_move: {self.last_move_}, ' \ + f'last_moves: {self.last_moves}, ' \ + f'arm_movable: {self.arm_movable}, ' return res def __str__(self): - return f'''Self Player side:{self._side} unum:{self._unum} pos:{self.pos()} vel:{self.vel()} body:{self._body}''' + return f'''Self Player side:{self.side} unum:{self.unum} pos:{self.pos} vel:{self.vel} body:{self.body}''' - self._sense_body_time = current_time.copy() +# TODO CHECK IT +''' self.sense_body_time = current_time.copy() self.update_by_last_cycle(act, current_time) - self._kicking = act.last_body_command() == CommandType.KICK or act.last_body_command() == CommandType.TACKLE - self._view_width = sense_body.view_width() + self.kicking = act.last_body_command() == CommandType.KICK or act.last_body_command() == CommandType.TACKLE + self.view_width = sense_body.view_width() - self._stamina_model.update_by_sense_body(sense_body.stamina(), + self.stamina_model.update_by_sense_body(sense_body.stamina(), sense_body.effort(), sense_body.stamina_capacity(), current_time) - if abs(self._neck.degree() - sense_body.neck_relative()) > 0.5: - self._neck = AngleDeg(sense_body.neck_relative()) + if abs(self.neck.degree() - sense_body.neck_relative()) > 0.5: + self.neck = AngleDeg(sense_body.neck_relative()) if (sense_body.none_collided() or sense_body.ball_collided() or sense_body.player_collided() or sense_body.post_collided()): - self._collision_estimated = False + self.collision_estimated = False if sense_body.none_collided(): - self._collides_with_none = True + self.collides_with_none = True if sense_body.ball_collided(): - self._collides_with_ball = True - self._collision_estimated = True + self.collides_with_ball = True + self.collision_estimated = True if sense_body.player_collided(): - self._collides_with_player = True - self._collision_estimated = True + self.collides_with_player = True + self.collision_estimated = True if sense_body.post_collided(): - self._collides_with_post = True - self._collision_estimated = True + self.collides_with_post = True + self.collision_estimated = True if self.face_valid(): - self._face = self._body + self._neck + self.face = self.body + self.neck - estimate_vel = self._vel.copy() + estimate_vel = self.vel.copy() sensed_speed_dir = sense_body.speed_dir() if sensed_speed_dir > 0: sensed_speed_dir = AngleDeg.normalize_angle(sensed_speed_dir + 0.5) elif sensed_speed_dir < 0: sensed_speed_dir = AngleDeg.normalize_angle(sensed_speed_dir - 0.5) - vel_ang = self._face + sensed_speed_dir - self._vel.set_polar(sense_body.speed_mag(), vel_ang) + vel_ang = self.face + sensed_speed_dir + self.vel.set_polar(sense_body.speed_mag(), vel_ang) if (not self.has_sensed_collision() and self.vel_valid() - and sense_body.speed_mag() < self.player_type().real_speed_max() * self.player_type().player_decay() * 0.11): + and sense_body.speed_mag() < self.player_type.real_speed_max() * self.player_type.player_decay() * 0.11): if (estimate_vel.r() > 0.01 and sense_body.speed_mag() < estimate_vel.r() * 0.2 - and (estimate_vel.abs_x() < 0.08 or estimate_vel.x() * self._vel.x() < 0) - and (estimate_vel.abs_y() < 0.08 or estimate_vel.y() * self._vel.y() < 0)): - self._collision_estimated = True + and (estimate_vel.abs_x() < 0.08 or estimate_vel.x() * self.vel.x() < 0) + and (estimate_vel.abs_y() < 0.08 or estimate_vel.y() * self.vel.y() < 0)): + self.collision_estimated = True - self._vel_count = self.face_count() + self.vel_count = self.face_count if sense_body.arm_expires() == 0: - self._pointto_pos.invalidate() - self._pointto_count = 1000 + self.pointto_pos.invalidate() + self.pointto_count = 1000 - if not self._collision_estimated: - new_last_move = self._vel / self.player_type().player_decay() - self._last_move.assign(new_last_move.x(), new_last_move.y()) + if not self.collision_estimated: + new_last_move = self.vel / self.player_type.player_decay() + self.last_move_.assign(new_last_move.x(), new_last_move.y()) else: - self._last_move.invalidate() - - if self._collision_estimated or self._collides_with_ball: - self._last_moves[0].invalidate() - - self._attentionto_side = sense_body.attentionto_side() - self._attentionto_unum = sense_body.attentionto_unum() - self._tackle_expires = sense_body.tackle_expires() - self._arm_movable = sense_body.arm_movable() - self._arm_expires = sense_body.arm_expires() - self._charge_expires = sense_body.charged_expires() - self._card = sense_body.card() - self._change_focus_count = sense_body.change_focus_count() - self._focus_point_dist = sense_body.focus_point_dist() - self._focus_point_dir = AngleDeg(sense_body.focus_point_dir()) \ No newline at end of file + self.last_move_.invalidate() + + if self.collision_estimated or self.collides_with_ball: + self.last_moves[0].invalidate() + + self.attentionto_side = sense_body.attentionto_side() + self.attentionto_unum = sense_body.attentionto_unum() + self.tackle_expires = sense_body.tackle_expires() + self.arm_movable = sense_body.arm_movable() + self.arm_expires = sense_body.arm_expires() + self.charge_expires = sense_body.charged_expires() + self.card = sense_body.card + self.change_focus_count = sense_body.change_focus_count() + self.focus_point_dist = sense_body.focus_point_dist() + self.focus_point_dir = AngleDeg(sense_body.focus_point_dir())''' \ No newline at end of file diff --git a/lib/player/player_agent.py b/lib/player/player_agent.py index fcef44b6..c05ae1c9 100644 --- a/lib/player/player_agent.py +++ b/lib/player/player_agent.py @@ -106,7 +106,7 @@ def parse_see_message(self, message: str): self._team_name, self._current_time) self._see_state.update_by_see(self._current_time, - self.real_world().self().view_width()) + self.real_world().self().view_width) if DEBUG: log.sw_log().sensor().add_text('===Received See Message Sensor===\n' + message) @@ -237,7 +237,7 @@ def is_decision_time(self, timeout_count: int, waited_msec): if self._last_decision_time == self._current_time: return False - if self.world().self().unum() == UNUM_UNKNOWN: + if self.world().self().unum == UNUM_UNKNOWN: return False if self.world().see_time() == self._current_time: @@ -343,16 +343,16 @@ def run(self): def debug_players(self): for p in self.world()._teammates + self.world()._opponents + self.world()._unknown_players: if p.pos_valid(): - log.sw_log().world().add_circle(1, center=p.pos(), color=Color(string='blue')) + log.sw_log().world().add_circle(1, center=p.pos, color=Color(string='blue')) if self.world().ball().pos_valid(): - log.sw_log().world().add_circle(center=self.world().ball().pos(), r=0.5, color=Color(string="blue"), fill=True) + log.sw_log().world().add_circle(center=self.world().ball().pos, r=0.5, color=Color(string="blue"), fill=True) if self.full_world_exists(): for p in self.full_world()._teammates + self.full_world()._opponents + self.full_world()._unknown_players: if p.pos_valid(): - log.sw_log().world().add_circle(1, center=p.pos(), color=Color(string='red')) + log.sw_log().world().add_circle(1, center=p.pos, color=Color(string='red')) if self.world().ball().pos_valid(): - log.sw_log().world().add_circle(center=self.world().ball().pos(), r=0.5, color=Color(string="red"), + log.sw_log().world().add_circle(center=self.world().ball().pos, r=0.5, color=Color(string="red"), fill=True) def change_player_type_parser(self, msg: str): @@ -431,7 +431,7 @@ def do_catch(self): log.os_log().error(f"(do catch) player({self._real_world.self_unum()} is frozen!") return False - if not wm.self().goalie(): + if not wm.self().goalie: log.os_log().error(f"(do catch) player({self._real_world.self_unum()} is not goalie!") return False @@ -458,18 +458,18 @@ def do_change_focus(self, moment_dist: float, moment_dir: Union[float, AngleDeg] moment_dir = AngleDeg(moment_dir) aligned_moment_dist = moment_dist - if self.world().self().focus_point_dist() + aligned_moment_dist < 0.0: + if self.world().self().focus_point_dist + aligned_moment_dist < 0.0: log.os_log().warn(f"(do_change_focus) player({self._real_world.self_unum()} focus dist can not be less than 0") - aligned_moment_dist = -self.world().self().focus_point_dist() - if self.world().self().focus_point_dist() + aligned_moment_dist > 40.0: + aligned_moment_dist = -self.world().self().focus_point_dist + if self.world().self().focus_point_dist + aligned_moment_dist > 40.0: log.os_log().warn(f"(do_change_focus) player({self._real_world.self_unum()} focus dist can not be more than 40") - aligned_moment_dist = 40.0 - self.world().self().focus_point_dist() + aligned_moment_dist = 40.0 - self.world().self().focus_point_dist next_view = self.effector().queued_next_view_width() next_half_angle = next_view.width() * 0.5 aligned_moment_dir = moment_dir focus_point_dir_after_change_view = AngleDeg( - min_max(-next_half_angle, self.world().self().focus_point_dir().degree(), next_half_angle)) + min_max(-next_half_angle, self.world().self().focus_point_dir.degree(), next_half_angle)) if focus_point_dir_after_change_view.degree() + aligned_moment_dir.degree() < -next_half_angle: aligned_moment_dir = -next_half_angle - focus_point_dir_after_change_view.degree() elif focus_point_dir_after_change_view.degree() + aligned_moment_dir.degree() > next_half_angle: @@ -491,11 +491,11 @@ def do_attentionto(self, side: SideID, unum: int): # log.os_log().error(f"(player agent do attentionto) unum is not in range! unum={unum}") return False - if self.world().our_side() == side and self.world().self().unum() == unum: + if self.world().our_side() == side and self.world().self().unum == unum: # log.os_log().error(f"(player agent do attentionto) attentioning to self!") return False - if self.world().self().attentionto_side() == side and self.world().self().attentionto_unum() == unum: + if self.world().self().attentionto_side == side and self.world().self().attentionto_unum == unum: # log.os_log().error(f"(player agent do attentionto) already attended to the player! unum={unum}") return False @@ -594,10 +594,10 @@ def update_before_decision(self): def action(self): if (self.world().self_unum() is None - or self.world().self().unum() != self.world().self_unum()): + or self.world().self().unum != self.world().self_unum()): return self.update_before_decision() - KickTable.instance().create_tables(self.world().self().player_type()) # TODO should be moved! + KickTable.instance().create_tables(self.world().self().player_type) # TODO should be moved! self._effector.reset() self.action_impl() self.do_view_action() @@ -607,8 +607,8 @@ def action(self): self.communicate_impl() self._last_decision_time = self._current_time.copy() - log.os_log().debug("body " + str(self.world().self().body())) - log.os_log().debug("pos " + str(self.world().self().pos())) + log.os_log().debug("body " + str(self.world().self().body)) + log.os_log().debug("pos " + str(self.world().self().pos)) self.real_world().update_just_after_decision(self._effector) if self.full_world_exists(): @@ -621,7 +621,7 @@ def action(self): log.os_log().debug("next pos " + str(self.effector().queued_next_self_pos())) # log.os_log().debug(str(self.world().self().long_str())) - self._see_state.set_view_mode(self.world().self().view_width()) + self._see_state.set_view_mode(self.world().self().view_width) message_command = self._effector.make_say_message_command(self.world()) if message_command: diff --git a/lib/player/sensor/see_state.py b/lib/player/sensor/see_state.py index 5531a265..1a463005 100644 --- a/lib/player/sensor/see_state.py +++ b/lib/player/sensor/see_state.py @@ -21,11 +21,13 @@ def update_by_sense_body(self, sense_time: GameTime, vw: ViewWidth): if self._view_width != vw: if DEBUG: log.sw_log().system().add_text(f"see state: (update by sense body)" - f"vew_width does not match." + f" view_width does not match." + f" @{sense_time}" f" old={self._view_width}, new={vw}") log.os_log().info(f"see state: (update by sense body)" - f"vew_width does not match." - f" old={self._view_width}, new={vw}") + f" view_width does not match." + f" @{sense_time}" + f" old={self._view_width}, new={vw}") self._view_width = vw def update_by_see(self, see_time: GameTime, vw: ViewWidth): diff --git a/lib/player/world_model.py b/lib/player/world_model.py index 0877bdca..424643fe 100644 --- a/lib/player/world_model.py +++ b/lib/player/world_model.py @@ -29,15 +29,15 @@ def player_accuracy_value(p: PlayerObject): value: int = 0 - if p.goalie(): + if p.goalie: value += -1000 - elif p.unum() == UNUM_UNKNOWN: + elif p.unum == UNUM_UNKNOWN: value += 1000 - value += p.pos_count() + p.ghost_count() * 10 + value += p.pos_count + p.ghost_count * 10 return value def player_count_value(p: PlayerObject): - return p.pos_count() + p.ghost_count() * 10 + return p.pos_count + p.ghost_count * 10 def player_valid_check(p: PlayerObject): return p.pos_valid() @@ -197,19 +197,19 @@ def _update_players(self): # TODO REMOVE IT self._exist_kickable_teammates = False self._exist_kickable_opponents = False for i in range(len(self._our_players)): - if self._our_players[i].player_type() is None: + if self._our_players[i].player_type is None: continue self._our_players[i].update_with_world(self) if self._our_players[i].is_kickable(): self._last_kicker_side = self.our_side() - if i != self.self().unum(): + if i != self.self().unum: self._exist_kickable_teammates = True for i in range(len(self._their_players)): - if self._their_players[i].player_type() is None: + if self._their_players[i].player_type is None: continue self._their_players[i].update_with_world(self) if self._our_players[i].is_kickable(): - self._last_kicker_side = self._their_players[i].side() + self._last_kicker_side = self._their_players[i].side self._exist_kickable_opponents = True def update_offside_line(self): @@ -221,12 +221,12 @@ def update_offside_line(self): if (self._game_mode.type().is_kick_in() or self._game_mode.type().is_corner_kick() or (self._game_mode.type().is_goal_kick() - and self._game_mode.side() == self._our_side)): + and self._game_mode.side == self._our_side)): self._offside_line_count = 0 self._offside_line_x = ServerParam.i().pitch_half_length() return - if (self._game_mode.side() != self._our_side + if (self._game_mode.side != self._our_side and (self._game_mode.type().is_goalie_catch_ball() or self._game_mode.type().is_goal_kick())): self._offside_line_count = 0 @@ -257,23 +257,23 @@ def update_xx(self): # TODO REMOVE IT def update_their_defense_line(self): speed_rate = ServerParam.i().default_player_speed_max() * (0.8 - if self.ball().vel().x() < -1 + if self.ball().vel.x() < -1 else 0.25) first, second = 0, 0 first_count, second_count = 1000, 1000 for it in self._opponents_from_ball: - x = it.pos().x() - if it.vel_count() <= 1 and it.vel().x() > 0: - x += min(0.8, it.vel().x() / it.player_type().player_decay()) - elif it.body_count() <= 3 and it.body().abs() < 100: - x -= speed_rate * min(10, it.pos_count() - 1.5) + x = it.pos.x() + if it.vel_count <= 1 and it.vel.x() > 0: + x += min(0.8, it.vel.x() / it.player_type.player_decay()) + elif it.body_count <= 3 and it.body.abs() < 100: + x -= speed_rate * min(10, it.pos_count - 1.5) else: - x -= speed_rate * min(10, it.pos_count()) + x -= speed_rate * min(10, it.pos_count) if x > second: second = x - second_count = it.pos_count() + second_count = it.pos_count if second > first: # swap first, second = second, first @@ -283,7 +283,7 @@ def update_their_defense_line(self): goalie = self.get_opponent_goalie() if goalie is None: - if 20 < self.ball().pos().x() < ServerParam.i().their_penalty_area_line_x(): + if 20 < self.ball().pos.x() < ServerParam.i().their_penalty_area_line_x(): if first < ServerParam.i().their_penalty_area_line_x(): new_line = first count = 30 @@ -300,11 +300,11 @@ def update_their_defense_line(self): if (self._game_mode.type() == GameModeType.BeforeKickOff and self._game_mode.type().is_after_goal() - and self.ball().pos_count() <= 3): - ball_next = self.ball().pos() + self.ball().vel() + and self.ball().pos_count <= 3): + ball_next = self.ball().pos + self.ball().vel if ball_next.x() > new_line: new_line = ball_next.x() - count = self.ball().pos_count() + count = self.ball().pos_count self._their_defense_line_x = new_line self._their_defense_line_count = count @@ -327,15 +327,15 @@ def _set_goalies_unum(self): # TODO REMOVE IT for tm in self._our_players: if tm is None: continue - if tm.goalie(): - self._our_goalie_unum = tm.unum() + if tm.goalie: + self._our_goalie_unum = tm.unum break for opp in self._their_players: if opp is None: continue - if opp.goalie(): - self._their_goalie_unum = opp.unum() + if opp.goalie: + self._their_goalie_unum = opp.unum break def teammates_from_ball(self): @@ -353,12 +353,12 @@ def opponents_from_self(self): def _set_teammates_from_ball(self): self._teammates_from_ball = [] for tm in self._our_players: - if tm is None or tm.unum() == self._self_unum: + if tm is None or tm.unum == self._self_unum: continue self._teammates_from_ball.append(tm) - self._teammates_from_ball.sort(key=lambda player: player.dist_from_ball()) + self._teammates_from_ball.sort(key=lambda player: player.dist_from_ball) def last_kicker_side(self) -> SideID: return self._last_kicker_side @@ -384,12 +384,12 @@ def _set_players_from_ball_and_self(self): # TODO REMOVE THIS AND INSIDE FUNCTIO def _set_teammates_from_self(self): self._teammates_from_self = [] for tm in self._our_players: - if tm is None or tm.unum() == self._self_unum: + if tm is None or tm.unum == self._self_unum: continue self._teammates_from_self.append(tm) - self._teammates_from_self.sort(key=lambda player: player.dist_from_self()) + self._teammates_from_self.sort(key=lambda player: player.dist_from_self) def _set_opponents_from_self(self): self._opponents_from_self = [] @@ -399,7 +399,7 @@ def _set_opponents_from_self(self): self._opponents_from_self.append(opp) - self._opponents_from_self.sort(key=lambda player: player.dist_from_self()) + self._opponents_from_self.sort(key=lambda player: player.dist_from_self) def _set_opponents_from_ball(self): self._opponents_from_ball = [] @@ -409,7 +409,7 @@ def _set_opponents_from_ball(self): self._opponents_from_ball.append(opp) - self._opponents_from_ball.sort(key=lambda player: player.dist_from_ball()) + self._opponents_from_ball.sort(key=lambda player: player.dist_from_ball) def offside_line_x(self) -> float: return self._offside_line_x @@ -432,10 +432,10 @@ def get_first_player(self, count_thr: int, with_goalie: bool) -> PlayerObject: for p in players: - if not with_goalie and p.goalie(): + if not with_goalie and p.goalie: continue - if not p.is_ghost() and p.pos_count() <= count_thr: + if not p.is_ghost() and p.pos_count <= count_thr: return p return None @@ -458,13 +458,13 @@ def update_by_last_cycle(self, act: 'ActionEffector', agent_current_time: GameTi self._previous_kickable_teammate_unum = UNUM_UNKNOWN if self._kickable_teammate is not None: self._previous_kickable_teammate = True - self._previous_kickable_teammate_unum = self._kickable_teammate.unum() + self._previous_kickable_teammate_unum = self._kickable_teammate.unum self._previous_kickable_opponent = False self._previous_kickable_opponent_unum = UNUM_UNKNOWN if self._kickable_opponent is not None: self._previous_kickable_opponent = True - self._previous_kickable_opponent_unum = self._kickable_opponent.unum() + self._previous_kickable_opponent_unum = self._kickable_opponent.unum self._kickable_teammate = None self._kickable_opponent = None @@ -489,15 +489,15 @@ def update_by_last_cycle(self, act: 'ActionEffector', agent_current_time: GameTi for p in self._teammates: p.update_by_last_cycle() - self._teammates = list(filter(lambda p: p.pos_count() < 30,self._teammates)) + self._teammates = list(filter(lambda p: p.pos_count < 30,self._teammates)) for p in self._opponents: p.update_by_last_cycle() - self._opponents = list(filter(lambda p: p.pos_count() < 30,self._opponents)) + self._opponents = list(filter(lambda p: p.pos_count < 30,self._opponents)) for p in self._unknown_players: p.update_by_last_cycle() - self._unknown_players = list(filter(lambda p: p.pos_count() < 30,self._unknown_players)) + self._unknown_players = list(filter(lambda p: p.pos_count < 30,self._unknown_players)) self._dir_count = [c+1 for c in self._dir_count] @@ -505,78 +505,78 @@ def estimate_ball_by_pos_diff(self, see: SeeParser, act: 'ActionEffector', rpos: SP = ServerParam.i() if self.self().has_sensed_collision(): - if self.self()._collides_with_player or self.self()._collides_with_post: + if self.self().collides_with_player or self.self().collides_with_post: return 1000 - if self.ball().rpos_count() == 1: + if self.ball().rpos_count == 1: if (see.balls()[0].dist_ < SP.visible_distance() - and self._prev_ball.rpos().is_valid() + and self._prev_ball.rpos.is_valid() and self.self().vel_valid() and self.self().last_move().is_valid()): - rpos_diff = rpos - self._prev_ball.rpos() + rpos_diff = rpos - self._prev_ball.rpos tmp_vel = (rpos_diff + self.self().last_move()) * SP.ball_decay() - tmp_vel_error = rpos_error + self.self().vel_error() * SP.ball_decay() + tmp_vel_error = rpos_error + self.self().vel_error * SP.ball_decay() - if (self.ball().seen_vel_count() <= 2 - and self._prev_ball.rpos().r() > 1.5 + if (self.ball().seen_vel_count <= 2 + and self._prev_ball.rpos.r() > 1.5 and see.balls()[0].dist_ > 1.5 - and abs(tmp_vel.x() - self.ball().vel().x()) < 0.1 - and abs(tmp_vel.y() - self.ball().vel().y()) < 0.1): + and abs(tmp_vel.x() - self.ball().vel.x()) < 0.1 + and abs(tmp_vel.y() - self.ball().vel.y()) < 0.1): return 1000 vel.assign(tmp_vel.x(), tmp_vel.y()) vel_error.assign(tmp_vel_error.x(), tmp_vel_error.y()) return 1 - elif self.ball().rpos_count() == 2: + elif self.ball().rpos_count == 2: if (see.balls()[0].dist_ < SP.visible_distance() and act.last_body_command() is not CommandType.KICK - and self.ball().seen_rpos().is_valid() - and self.ball().seen_rpos().r() < SP.visible_distance() + and self.ball().seen_rpos.is_valid() + and self.ball().seen_rpos.r() < SP.visible_distance() and self.self().vel_valid() and self.self().last_move(0).is_valid() and self.self().last_move(1).is_valid()): - ball_move: Vector2D = rpos - self.ball().seen_rpos() + ball_move: Vector2D = rpos - self.ball().seen_rpos for i in range(2): ball_move += self.self().last_move(i) vel.set_vector(ball_move * ((SP.ball_decay() ** 2) / (1 + SP.ball_decay()))) vel_r = vel.r() - estimate_speed = self.ball().vel().r() + estimate_speed = self.ball().vel.r() if (vel_r > estimate_speed + 0.1 or vel_r < estimate_speed*(1-SP.ball_rand()*2) - 0.1 - or (vel - self.ball().vel()).r() > estimate_speed * SP.ball_rand()*2 + 0.1): + or (vel - self.ball().vel).r() > estimate_speed * SP.ball_rand()*2 + 0.1): vel.invalidate() return 1000 else: - vel_error.set_vector((rpos_error * 2.0) + self.self().vel_error()) + vel_error.set_vector((rpos_error * 2.0) + self.self().vel_error) vel_error *= SP.ball_decay() return 2 - elif self.ball().rpos_count() == 3: + elif self.ball().rpos_count == 3: if (see.balls()[0].dist_ < SP.visible_distance() and act.last_body_command(0) is not CommandType.KICK and act.last_body_command(1) is not CommandType.KICK - and self.ball().seen_rpos().is_valid() - and self.ball().seen_rpos().r() < SP.visible_distance() + and self.ball().seen_rpos.is_valid() + and self.ball().seen_rpos.r() < SP.visible_distance() and self.self().vel_valid() and self.self().last_move(0).is_valid() and self.self().last_move(1).is_valid() and self.self().last_move(2).is_valid()): - ball_move: Vector2D = rpos - self.ball().seen_rpos() + ball_move: Vector2D = rpos - self.ball().seen_rpos for i in range(3): ball_move += self.self().last_move(i) vel.set_vector(ball_move * (SP.ball_decay()**3 / (1 + SP.ball_decay() + SP.ball_decay()**2))) vel_r = vel.r() - estimate_speed = self.ball().vel().r() + estimate_speed = self.ball().vel.r() if (vel_r > estimate_speed + 0.1 or vel_r < estimate_speed*(1-SP.ball_rand()*3) - 0.1 - or (vel - self.ball().vel()).r() > estimate_speed * SP.ball_rand()*3 + 0.1): + or (vel - self.ball().vel).r() > estimate_speed * SP.ball_rand()*3 + 0.1): vel.invalidate() return 1000 else: - vel_error.set_vector((rpos_error * 3.0) + self.self().vel_error()) + vel_error.set_vector((rpos_error * 3.0) + self.self().vel_error) return 3 return vel_count @@ -585,7 +585,7 @@ def localize_self(self, body: SenseBodyParser, act: 'ActionEffector', current_time: GameTime): - angle_face, angle_face_error = self._localizer.estimate_self_face(see, self.self().view_width()) + angle_face, angle_face_error = self._localizer.estimate_self_face(see, self.self().view_width) if angle_face is None: return False @@ -596,7 +596,7 @@ def localize_self(self, self.self().update_vel_dir_after_see(body, current_time) # my_pos: Vector2D = self._localizer.localize_self_simple(see, angle_face) - my_pos, my_pos_err, my_possible_posses = self._localizer.localize_self(see, self.self().view_width(), angle_face, angle_face_error) + my_pos, my_pos_err, my_possible_posses = self._localizer.localize_self(see, self.self().view_width, angle_face, angle_face_error) if my_pos is None: return False if reverse_side: @@ -611,19 +611,19 @@ def localize_ball(self, see: SeeParser, act: 'ActionEffector'): return rpos, rpos_err, rvel, vel_err = self._localizer.localize_ball_relative(see, - self.self().face(), - self.self().face_error(), - self.self().view_width()) + self.self().face, + self.self().face_error, + self.self().view_width) if rpos is None or not rpos.is_valid(): return if not self.self().pos_valid(): - if (self._prev_ball.rpos_count() == 0 - and see.balls()[0].dist_ > self.self().player_type().player_size() + SP.ball_size() + 0.1 + if (self._prev_ball.rpos_count == 0 + and see.balls()[0].dist_ > self.self().player_type.player_size() + SP.ball_size() + 0.1 and self.self().last_move().is_valid()): - tvel = (rpos - self._prev_ball.rpos()) + self.self().last_move() - tvel_err = rpos_err + self.self().vel_error() + tvel = (rpos - self._prev_ball.rpos) + self.self().last_move() + tvel_err = rpos_err + self.self().vel_error tvel *= SP.ball_decay() tvel_err *= SP.ball_decay() @@ -631,18 +631,18 @@ def localize_ball(self, see: SeeParser, act: 'ActionEffector'): self._ball.update_only_relative_pos(rpos, rpos_err) return - pos = self.self().pos() + rpos - pos_err = self.self().pos_error() + rpos_err + pos = self.self().pos + rpos + pos_err = self.self().pos_error + rpos_err gvel = Vector2D.invalid() vel_count = 1000 if WorldModel.DEBUG: - log.sw_log().world().add_text( f"(localize ball) rvel_valid={rvel.is_valid()}, self_vel_valid={self.self().vel_valid()}, self_vel_count={self.self().vel_count()}") - log.sw_log().world().add_text( f"(localize ball) rvel={rvel}, self_vel={self.self().vel()}") + log.sw_log().world().add_text( f"(localize ball) rvel_valid={rvel.is_valid()}, self_vel_valid={self.self().vel_valid()}, self_vel_count={self.self().vel_count}") + log.sw_log().world().add_text( f"(localize ball) rvel={rvel}, self_vel={self.self().vel}") if rvel.is_valid() and self.self().vel_valid(): - gvel = self.self().vel() + rvel - vel_err += self.self().vel_error() + gvel = self.self().vel + rvel + vel_err += self.self().vel_error vel_count = 0 if not gvel.is_valid(): @@ -650,20 +650,20 @@ def localize_ball(self, see: SeeParser, act: 'ActionEffector'): if not gvel.is_valid(): if (see.balls()[0].dist_ < 2 - and self._prev_ball.seen_pos_count() == 0 - and self._prev_ball.rpos_count() == 0 - and self._prev_ball.rpos().r() < 5): + and self._prev_ball.seen_pos_count == 0 + and self._prev_ball.rpos_count == 0 + and self._prev_ball.rpos.r() < 5): - gvel = pos - self._prev_ball.pos() - vel_err += pos_err + self._prev_ball._pos_error + self._prev_ball._vel_error + gvel = pos - self._prev_ball.pos + vel_err += pos_err + self._prev_ball.pos_error + self._prev_ball.vel_error vel_count = 2 elif (see.balls()[0].dist_ < 2 and not self.self().is_kicking() - and 2 <= self._ball.seen_pos_count() <= 6 + and 2 <= self._ball.seen_pos_count <= 6 and self.self().last_move(0).is_valid() and self.self().last_move(1).is_valid()): - prev_pos = self._ball.seen_pos() - move_step = self._ball.seen_pos_count() + prev_pos = self._ball.seen_pos + move_step = self._ball.seen_pos_count ball_move: Vector2D = pos - prev_pos dist = ball_move.r() speed = SP.first_ball_speed(dist, move_step) @@ -672,11 +672,11 @@ def localize_ball(self, see: SeeParser, act: 'ActionEffector'): vel_count = move_step if gvel.is_valid(): - self._ball.update_all(pos, pos_err, self.self().pos_count(), + self._ball.update_all(pos, pos_err, self.self().pos_count, rpos, rpos_err, gvel, vel_err, vel_count) else: - self._ball.update_pos(pos, pos_err, self.self().pos_count(), rpos, rpos_err) + self._ball.update_pos(pos, pos_err, self.self().pos_count, rpos, rpos_err) def their_side(self): return SideID.LEFT if self._our_side is SideID.RIGHT else SideID.RIGHT @@ -692,11 +692,11 @@ def check_team_player(self, if player.unum_ != UNUM_UNKNOWN: for p in old_known_players: log.os_log().debug(f'--------------?? {p}') - if p.unum() == player.unum_: + if p.unum == player.unum_: p.update_by_see(side, player) new_known_players.append(p) old_known_players.remove(p) - log.os_log().debug(f'--------------> update {p.unum()}') + log.os_log().debug(f'--------------> update {p.unum}') return min_team_dist = 1000 @@ -707,17 +707,17 @@ def check_team_player(self, log.os_log().debug(f'------- check with old known B') for p in old_known_players: log.os_log().debug(f'--------------?? {p}') - if p.unum() != UNUM_UNKNOWN and player.unum_ != UNUM_UNKNOWN and p.unum() != player.unum_: + if p.unum != UNUM_UNKNOWN and player.unum_ != UNUM_UNKNOWN and p.unum != player.unum_: log.os_log().debug(f'--------------<< No (unum)') continue - count = p.seen_pos_count() - old_pos = p.seen_pos() - if p.heard_pos_count() < p.seen_pos_count(): - count = p.heard_pos_count() - old_pos = p.heard_pos() + count = p.seen_pos_count + old_pos = p.seen_pos + if p.heard_pos_count < p.seen_pos_count: + count = p.heard_pos_count + old_pos = p.heard_pos d = player.pos_.dist(old_pos) - if d > p.player_type().real_speed_max() * count + player.dist_error_ * 2.0: + if d > p.player_type.real_speed_max() * count + player.dist_error_ * 2.0: log.os_log().debug(f'--------------<< No (dist)') continue @@ -728,18 +728,18 @@ def check_team_player(self, log.os_log().debug(f'------- check with old unknown') for p in old_unknown_players: - if p.unum() != UNUM_UNKNOWN and player.unum_ != UNUM_UNKNOWN and p.unum() != player.unum_: + if p.unum != UNUM_UNKNOWN and player.unum_ != UNUM_UNKNOWN and p.unum != player.unum_: log.os_log().debug(f'--------------<< No (unum)') continue - count = p.seen_pos_count() - old_pos = p.seen_pos() - if p.heard_pos_count() < p.seen_pos_count(): - count = p.heard_pos_count() - old_pos = p.heard_pos() + count = p.seen_pos_count + old_pos = p.seen_pos + if p.heard_pos_count < p.seen_pos_count: + count = p.heard_pos_count + old_pos = p.heard_pos d = player.pos_.dist(old_pos) - if d > p.player_type().real_speed_max() * count + player.dist_error_ * 2.0: + if d > p.player_type.real_speed_max() * count + player.dist_error_ * 2.0: log.os_log().debug(f'--------------<< No (dist)') continue @@ -762,7 +762,7 @@ def check_team_player(self, if candidate is not None and target_list is not None: candidate.update_by_see(side, player) - log.os_log().debug(f'---> update {candidate.unum()}') + log.os_log().debug(f'---> update {candidate.unum}') new_known_players.append(candidate) target_list.remove(candidate) return @@ -787,19 +787,19 @@ def check_unknown_player(self, candidate_unknown: PlayerObject = None for p in old_opponents: - if (p.unum() != UNUM_UNKNOWN + if (p.unum != UNUM_UNKNOWN and player.unum_ != UNUM_UNKNOWN - and p.unum() != player.unum_): + and p.unum != player.unum_): continue - count = p.seen_pos_count() - old_pos = p.seen_pos() - if p.heard_pos_count() < p.seen_pos_count(): - count = p.heard_pos_count() - old_pos = p.heard_pos() + count = p.seen_pos_count + old_pos = p.seen_pos + if p.heard_pos_count < p.seen_pos_count: + count = p.heard_pos_count + old_pos = p.heard_pos d = player.pos_.dist(old_pos) - if d > p.player_type().real_speed_max() * count: + if d > p.player_type.real_speed_max() * count: continue if d < min_opponent_dist: @@ -807,19 +807,19 @@ def check_unknown_player(self, candidate_opponent = p for p in old_teammates: - if (p.unum() != UNUM_UNKNOWN + if (p.unum != UNUM_UNKNOWN and player.unum_ != UNUM_UNKNOWN - and p.unum() != player.unum_): + and p.unum != player.unum_): continue - count = p.seen_pos_count() - old_pos = p.seen_pos() - if p.heard_pos_count() < p.seen_pos_count(): - count = p.heard_pos_count() - old_pos = p.heard_pos() + count = p.seen_pos_count + old_pos = p.seen_pos + if p.heard_pos_count < p.seen_pos_count: + count = p.heard_pos_count + old_pos = p.heard_pos d = player.pos_.dist(old_pos) - if d > p.player_type().real_speed_max() * count: + if d > p.player_type.real_speed_max() * count: continue if d < min_teammate_dist: @@ -827,19 +827,19 @@ def check_unknown_player(self, candidate_teammate = p for p in old_unknown_players: - if (p.unum() != UNUM_UNKNOWN + if (p.unum != UNUM_UNKNOWN and player.unum_ != UNUM_UNKNOWN - and p.unum() != player.unum_): + and p.unum != player.unum_): continue - count = p.seen_pos_count() - old_pos = p.seen_pos() - if p.heard_pos_count() < p.seen_pos_count(): - count = p.heard_pos_count() - old_pos = p.heard_pos() + count = p.seen_pos_count + old_pos = p.seen_pos + if p.heard_pos_count < p.seen_pos_count: + count = p.heard_pos_count + old_pos = p.heard_pos d = player.pos_.dist(old_pos) - if d > p.player_type().real_speed_max() * count: + if d > p.player_type.real_speed_max() * count: continue if d < min_unknown_dist: @@ -889,13 +889,13 @@ def localize_players(self, see: SeeParser): new_opponents: list[PlayerObject] = [] new_unknown_players: list[PlayerObject] = [] - my_pos = self.self().pos() - my_vel = self.self().vel() - my_face = self.self().face() - my_face_err = self.self().face_error() + my_pos = self.self().pos + my_vel = self.self().vel + my_face = self.self().face + my_face_err = self.self().face_error for p in see.opponents() + see.unknown_opponents(): - player = self._localizer.localize_player(p, my_face, my_face_err, my_pos, my_vel, self.self().view_width()) + player = self._localizer.localize_player(p, my_face, my_face_err, my_pos, my_vel, self.self().view_width) if DEBUG: log.os_log().debug(f'{"-"*30} opp {player}') if player is None: @@ -907,7 +907,7 @@ def localize_players(self, see: SeeParser): new_opponents) for p in see.teammates() + see.unknown_teammates(): - player = self._localizer.localize_player(p, my_face, my_face_err, my_pos, my_vel, self.self().view_width()) + player = self._localizer.localize_player(p, my_face, my_face_err, my_pos, my_vel, self.self().view_width) if DEBUG: log.os_log().debug(f'{"-"*30} mate {player}') if player is None: @@ -919,7 +919,7 @@ def localize_players(self, see: SeeParser): new_teammates) for p in see.unknown_players(): - player = self._localizer.localize_player(p, my_face, my_face_err, my_pos, my_vel, self.self().view_width()) + player = self._localizer.localize_player(p, my_face, my_face_err, my_pos, my_vel, self.self().view_width) if DEBUG: log.os_log().debug(f'{"-"*30} unk {player}') if player is None: @@ -966,14 +966,14 @@ def localize_players(self, see: SeeParser): def update_player_type(self): for p in self._teammates: - unum = p.unum() - 1 + unum = p.unum - 1 if 0 <= unum < 11: p.set_player_type(self._player_types[self._our_players_type[unum]]) else: p.set_player_type(self._player_types[HETERO_DEFAULT]) for p in self._opponents: - unum = p.unum() - 1 + unum = p.unum - 1 if 0 <= unum < 11: p.set_player_type(self._player_types[self._their_players_type[unum]]) else: @@ -1006,27 +1006,27 @@ def update_world_after_see(self, self.localize_players(see) self.update_player_type() - if self.self().pos_count() <= 10: - varea = ViewArea(self.self().view_width().width(), - self.self().pos(), - self.self().face(), + if self.self().pos_count <= 10: + varea = ViewArea(self.self().view_width.width(), + self.self().pos, + self.self().face, current_time) self.check_ghost(varea) # TODO self.update_dir_count(varea) def update_world_after_sense_body(self, body_sensor: SenseBodyParser, act: 'ActionEffector', agent_current_time: GameTime): if self._sense_body_time == agent_current_time: - log.os_log().critical(f"({self.team_name()} {self.self().unum()}): update after sense body called twice in a cycle") - log.sw_log().sensor(f"({self.team_name()} {self.self().unum()}): update after sense body called twice in a cycle") + log.os_log().critical(f"({self.team_name()} {self.self().unum}): update after sense body called twice in a cycle") + log.sw_log().sensor(f"({self.team_name()} {self.self().unum}): update after sense body called twice in a cycle") return self._sense_body_time = body_sensor.time().copy() if body_sensor.time() == agent_current_time: self.self().update_self_after_sense_body(body_sensor, act, agent_current_time) - self._our_recovery[self.self().unum() - 1] = self.self().recovery() - self._our_stamina_capacity[self.self().unum() - 1] = self.self().stamina_model().capacity() - self._our_card[self.self().unum() - 1] = body_sensor.card() + self._our_recovery[self.self().unum - 1] = self.self().stamina_model.recovery() + self._our_stamina_capacity[self.self().unum - 1] = self.self().stamina_model.capacity() + self._our_card[self.self().unum - 1] = body_sensor.card else: log.os_log().error(f'body_sensor.time()[{body_sensor.time()}] != current_time[{agent_current_time}]') @@ -1075,17 +1075,17 @@ def create_set_player(self, def update_kickables(self): for p in self._teammates_from_ball: - if p.is_ghost() or p.is_tackling() or p.pos_count() > self.ball().pos_count(): + if p.is_ghost() or p.is_tackling() or p.pos_count > self.ball().pos_count: continue if p.is_kickable(0): self._kickable_teammate = p break for p in self._opponents_from_ball: - if p.is_ghost() or p.is_tackling() or p.pos_count() >= 10: + if p.is_ghost() or p.is_tackling() or p.pos_count >= 10: continue - if p.dist_from_ball() > 5: + if p.dist_from_ball > 5: break if p.is_kickable(0): @@ -1100,24 +1100,24 @@ def update_player_state_cache(self): self.create_set_player(self._teammates, self._teammates_from_self, self._teammates_from_ball, - self.self().pos(), - self.ball().pos()) + self.self().pos, + self.ball().pos) self.create_set_player(self._opponents, self._opponents_from_self, self._opponents_from_ball, - self.self().pos(), - self.ball().pos()) + self.self().pos, + self.ball().pos) self.create_set_player(self._unknown_players, self._opponents_from_self, self._opponents_from_ball, - self.self().pos(), - self.ball().pos()) + self.self().pos, + self.ball().pos) - self._teammates_from_ball.sort(key=lambda p: p.dist_from_ball()) - self._opponents_from_ball.sort(key=lambda p: p.dist_from_ball()) + self._teammates_from_ball.sort(key=lambda p: p.dist_from_ball) + self._opponents_from_ball.sort(key=lambda p: p.dist_from_ball) - self._teammates_from_self.sort(key=lambda p: p.dist_from_self()) - self._opponents_from_self.sort(key=lambda p: p.dist_from_self()) + self._teammates_from_self.sort(key=lambda p: p.dist_from_self) + self._opponents_from_self.sort(key=lambda p: p.dist_from_self) # self.estimate_unknown_player_unum() # TODO IMP FUNC?! self.estimate_goalie() @@ -1132,17 +1132,17 @@ def update_player_state_cache(self): self._our_players_array[i] = None self._their_players_array[i] = None - self._our_players_array[self.self().unum()] = self.self() + self._our_players_array[self.self().unum] = self.self() for p in self._teammates: self._all_players.append(p) self._our_players.append(p) - if p.unum() != UNUM_UNKNOWN: - self._our_players_array[p.unum()] = p + if p.unum != UNUM_UNKNOWN: + self._our_players_array[p.unum] = p for p in self._opponents: self._all_players.append(p) self._their_players.append(p) - if p.unum() != UNUM_UNKNOWN: - self._their_players_array[p.unum()] = p + if p.unum != UNUM_UNKNOWN: + self._their_players_array[p.unum] = p self.update_kickables() @@ -1150,21 +1150,21 @@ def estimate_goalie(self): our_goalie: PlayerObject = None their_goalie: PlayerObject = None - if self.self().goalie(): + if self.self().goalie: our_goalie = self.self() else: for p in self._teammates: - if p.goalie(): + if p.goalie: our_goalie = p for p in self._opponents: - if p.goalie(): + if p.goalie: their_goalie = p - if our_goalie and our_goalie.unum() != self.our_goalie_unum(): - self._our_goalie_unum = our_goalie.unum() + if our_goalie and our_goalie.unum != self.our_goalie_unum(): + self._our_goalie_unum = our_goalie.unum - if their_goalie and their_goalie.unum() != self._their_goalie_unum: - self._their_goalie_unum = their_goalie.unum() + if their_goalie and their_goalie.unum != self._their_goalie_unum: + self._their_goalie_unum = their_goalie.unum if (self.game_mode().type() is GameModeType.BeforeKickOff or self.game_mode().type().is_after_goal()): @@ -1180,7 +1180,7 @@ def estimate_their_goalie(self): max_x: float = 0 second_max_x: float = 0 for p in self._opponents: - x = p.pos().x() + x = p.pos.x() if x > second_max_x: second_max_x = x @@ -1191,7 +1191,7 @@ def estimate_their_goalie(self): from_unknown = False for p in self._unknown_players: - x = p.pos().x() + x = p.pos.x() if x > second_max_x: second_max_x = x @@ -1215,7 +1215,7 @@ def estimate_our_goalie(self): min_x: float = 0 second_min_x: float = 0 for p in self._teammates: - x = p.pos().x() + x = p.pos.x() if x < second_min_x: second_min_x = x @@ -1226,7 +1226,7 @@ def estimate_our_goalie(self): from_unknown = False for p in self._unknown_players: - x = p.pos().x() + x = p.pos.x() if x < second_min_x: second_min_x = x @@ -1259,11 +1259,11 @@ def update_goalie_by_hear(self): goalie: PlayerObject = None for o in self._opponents: - if o.goalie(): + if o.goalie: goalie = o break - if goalie is not None and goalie.pos_count() == 0 and goalie.body_count() == 0: + if goalie is not None and goalie.pos_count == 0 and goalie.body_count == 0: return heard_pos = Vector2D(0, 0) @@ -1286,13 +1286,13 @@ def update_goalie_by_hear(self): goalie_speed_max = SP.default_player_speed_max() min_dist = 1000. for o in self._opponents + self._unknown_players: - if o.unum() != UNUM_UNKNOWN: + if o.unum != UNUM_UNKNOWN: continue - if o.pos().x() < SP.their_penalty_area_line_x() or o.pos().abs_y() > SP.penalty_area_half_width(): + if o.pos.x() < SP.their_penalty_area_line_x() or o.pos.abs_y() > SP.penalty_area_half_width(): continue - d = o.pos().dist(heard_pos) - if d < min_dist and d < o.pos_count() * goalie_speed_max + o.dist_from_self() * 0.06: + d = o.pos.dist(heard_pos) + if d < min_dist and d < o.pos_count * goalie_speed_max + o.dist_from_self * 0.06: min_dist = d goalie = o @@ -1338,13 +1338,13 @@ def update_by_full_state_message(self, parser: FullStateWorldMessageParser): for player_dic in parser.dic()['players']: player = PlayerObject() player.init_dic(player_dic) - player.set_player_type(self._player_types[player.player_type_id()]) - if player.side().value == self._our_side: - if player.unum() == self._self_unum: + player.set_player_type(self._player_types[player.player_type_id]) + if player.side.value == self._our_side: + if player.unum == self._self_unum: self._self.update_by_player_info(player) else: self._teammates.append(player) - elif player.side() == SideID.NEUTRAL: + elif player.side == SideID.NEUTRAL: self._unknown_players.append(player) else: self._opponents.append(player) @@ -1382,7 +1382,7 @@ def update_just_before_decision(self, act: 'ActionEffector', current_time: GameT if DEBUG: log.sw_log().world().add_text('===After processing see message===') - log.sw_log().world().add_text(f'self.kickrate={self.self().kick_rate()}') + log.sw_log().world().add_text(f'self.kickrate={self.self().kick_rate}') log.sw_log().world().add_text(f'===Our Players=== {len(self.our_players())} {self._name}') for p in self.our_players(): log.sw_log().world().add_text(str(p)) @@ -1412,7 +1412,7 @@ def update_just_after_decision(self, act: 'ActionEffector'): attention = act.attentionto_command() if attention: if attention.is_on(): - if attention.side() == PlayerAttentiontoCommand.SideType.OUR: + if attention.side == PlayerAttentiontoCommand.SideType.OUR: self.self().set_attentionto(self.our_side(), attention.number()) else: self.self().set_attentionto(self.their_side(), attention.number()) @@ -1436,31 +1436,31 @@ def update_players_by_hear(self): unum = player.unum_ if player.unum_ <= 11 else player.unum_ - 11 unum = round(unum) - if side == self.our_side() and unum == self.self().unum(): + if side == self.our_side() and unum == self.self().unum: return target_player: PlayerObject = None unknown: PlayerObject = None players = self._teammates if side == self.our_side() else self._opponents for p in players: - if p.unum() == unum: + if p.unum == unum: target_player = p break min_dist = 1000 if target_player is None: for p in players: - if p.unum() != UNUM_UNKNOWN and p.unum() != unum: + if p.unum != UNUM_UNKNOWN and p.unum != unum: continue - d = p.pos().dist(player.pos_) - if d < min_dist and p.pos_count()*1.2 + p.dist_from_self() *0.06: + d = p.pos.dist(player.pos_) + if d < min_dist and p.pos_count*1.2 + p.dist_from_self *0.06: min_dist = d target_player = p for p in self._unknown_players: - d = p.pos().dist(player.pos_) - if d < min_dist and d < p.pos_count()*1.2 + p.dist_from_self() *0.06: + d = p.pos.dist(player.pos_) + if d < min_dist and d < p.pos_count*1.2 + p.dist_from_self *0.06: min_dist = d target_player = p unknown = p @@ -1512,12 +1512,12 @@ def update_ball_by_hear(self, act: 'ActionEffector'): sender: PlayerObject = None for player in self._teammates: - if player.unum() == ball.sender_: + if player.unum == ball.sender_: sender = player break if sender: - dist = sender.pos().dist(self.ball().pos()) + dist = sender.pos.dist(self.ball().pos) if dist < min_dist: min_dist = dist heared_pos = ball.pos_ @@ -1558,10 +1558,10 @@ def update_dir_count(self, varea: ViewArea): while dir.is_left_of(right_limit): idx = int((dir.degree() - 0.5 + 180) / WorldModel.DIR_STEP) if idx > WorldModel.DIR_CONF_DIVS - 1: - log.os_log().warn(f"{self.team_name()}({self.self().unum()}) DIR CONF overflow! idx={idx}") + log.os_log().warn(f"{self.team_name()}({self.self().unum}) DIR CONF overflow! idx={idx}") idx = WorldModel.DIR_CONF_DIVS - 1 elif idx < 0: - log.os_log().error(f"{self.team_name()}({self.self().unum()}) DIR CONF downflow! idx={idx}") + log.os_log().error(f"{self.team_name()}({self.self().unum}) DIR CONF downflow! idx={idx}") idx = 0 self._dir_count[idx] = 0 dir += WorldModel.DIR_STEP @@ -1592,28 +1592,28 @@ def check_ghost(self, varea: ViewArea): angle_buf = 5. - if self.ball().rpos_count() > 0 and self.ball().pos_valid(): + if self.ball().rpos_count > 0 and self.ball().pos_valid(): ball_vis_dist2 = ( SP.visible_distance() - - (self.self().vel().r() / self.self().player_type().player_decay()) * 0.1 - - (self.ball().vel().r() / SP.ball_decay()) * 0.05 - - (0.12 * min(4, self.ball().pos_count())) + - (self.self().vel.r() / self.self().player_type.player_decay()) * 0.1 + - (self.ball().vel.r() / SP.ball_decay()) * 0.05 + - (0.12 * min(4, self.ball().pos_count)) - 0.25 )**2 - if varea.contains(self.ball().pos(), angle_buf, ball_vis_dist2): + if varea.contains(self.ball().pos, angle_buf, ball_vis_dist2): self._ball.set_ghost() vis_dist2 = ( SP.visible_distance() - - (self.self().vel().r() / self.self().player_type().player_decay()) * 0.1 + - (self.self().vel.r() / self.self().player_type.player_decay()) * 0.1 - 0.25 )**2 removing_teammates = [] for p in self._teammates: - if p.pos_count() > 0 and varea.contains(p.pos(), angle_buf, vis_dist2): - if p.unum() == UNUM_UNKNOWN and p.pos_count() >= 10 and p.ghost_count() >= 2: + if p.pos_count > 0 and varea.contains(p.pos, angle_buf, vis_dist2): + if p.unum == UNUM_UNKNOWN and p.pos_count >= 10 and p.ghost_count >= 2: removing_teammates.append(p) continue p.set_ghost() @@ -1622,8 +1622,8 @@ def check_ghost(self, varea: ViewArea): removing_opponents = [] for p in self._opponents: - if p.pos_count() > 0 and varea.contains(p.pos(), 1., vis_dist2): - if p.unum() == UNUM_UNKNOWN and p.pos_count() >= 10 and p.ghost_count() >= 2: + if p.pos_count > 0 and varea.contains(p.pos, 1., vis_dist2): + if p.unum == UNUM_UNKNOWN and p.pos_count >= 10 and p.ghost_count >= 2: removing_opponents.append(p) continue log.sw_log().world().add_text(f'opponent is going to be a ghost: {p}') @@ -1633,8 +1633,8 @@ def check_ghost(self, varea: ViewArea): removing_unknown_players = [] for p in self._unknown_players: - if p.pos_count() > 0 and varea.contains(p.pos(), 1., vis_dist2): - if p.dist_from_self() < 40 *1.06 and p.is_ghost(): + if p.pos_count > 0 and varea.contains(p.pos, 1., vis_dist2): + if p.dist_from_self < 40 *1.06 and p.is_ghost(): removing_unknown_players.append(p) continue p.set_ghost() @@ -1690,7 +1690,7 @@ def get_their_goalie(self): return self.their_player(self._their_goalie_unum) for p in self._opponents: - if p.goalie(): + if p.goalie: return p return None @@ -1706,10 +1706,10 @@ def set_our_player_type(self, unum: int, player_type_id: int): self._our_players_type[unum - 1] = player_type_id self._our_card[unum - 1] = Card.NO_CARD - if unum == self.self().unum(): + if unum == self.self().unum: tmp = self._player_types[player_type_id] if tmp is None: - log.os_log().error(f'{self.team_name()} {self.self().unum()}: illegal player type id') + log.os_log().error(f'{self.team_name()} {self.self().unum}: illegal player type id') return self.self().set_player_type(tmp) @@ -1720,8 +1720,8 @@ def exist_teammates_in(self, region: Region2D, count_thr: int, with_goalie: bool for p in self._teammates: if p is None: continue - if p.pos_count() > count_thr or p.is_ghost(): + if p.pos_count > count_thr or p.is_ghost(): continue - if region.contains(p.pos()): + if region.contains(p.pos): return True return False diff --git a/lib/rcsc/game_mode.py b/lib/rcsc/game_mode.py index 9600b877..eabe3e1e 100644 --- a/lib/rcsc/game_mode.py +++ b/lib/rcsc/game_mode.py @@ -37,7 +37,7 @@ def mode_name(self) -> str: return self._mode_name def _set_side(self) -> SideID: - return self._game_mode.side() + return self._game_mode.side def time(self): return self._time @@ -111,14 +111,14 @@ def update(self, mode: str, current_time: GameTime): if (self._game_mode.is_goalie_catch_ball() and game_mode.is_free_kick() - and self._game_mode.side() == game_mode.side() + and self._game_mode.side == game_mode.side and self._time == current_time): pass else: self._game_mode = game_mode - self._side = self._game_mode.side() + self._side = self._game_mode.side self._time = current_time.copy() return True diff --git a/start.sh b/start.sh index 57635c68..5b4401ac 100755 --- a/start.sh +++ b/start.sh @@ -13,4 +13,4 @@ while [ $i -le 11 ] ; do done sleep 2 -python coach_main.py ${1+"$@"} +python base/coach_main.py ${1+"$@"}