From 89769dcd531d83236f646d8b330dc3160fb0bcbb Mon Sep 17 00:00:00 2001 From: Aref Date: Tue, 15 Aug 2023 16:12:01 -0230 Subject: [PATCH 01/22] remove getters in obj.py --- lib/player/object.py | 75 -------------------------------------------- 1 file changed, 75 deletions(-) diff --git a/lib/player/object.py b/lib/player/object.py index a9d5e02..614eae0 100644 --- a/lib/player/object.py +++ b/lib/player/object.py @@ -43,78 +43,6 @@ def __init__(self): 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 - def vel_valid(self): return self.vel_count() < self._vel_count_thr @@ -185,6 +113,3 @@ def long_str(self): 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 From 6116652720df31d81512e6ff88994be48b13240e Mon Sep 17 00:00:00 2001 From: Aref Date: Tue, 15 Aug 2023 16:14:37 -0230 Subject: [PATCH 02/22] move everything to public in obj.py --- lib/player/object.py | 135 +++++++++++++++++++++---------------------- 1 file changed, 67 insertions(+), 68 deletions(-) diff --git a/lib/player/object.py b/lib/player/object.py index 614eae0..91c08d5 100644 --- a/lib/player/object.py +++ b/lib/player/object.py @@ -3,58 +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 + 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): @@ -70,46 +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()}''' From 904e0e3f512f654aa1c5d1a623f37b44d90787cc Mon Sep 17 00:00:00 2001 From: Aref Date: Tue, 15 Aug 2023 16:18:55 -0230 Subject: [PATCH 03/22] remove getters in obj player py --- lib/player/object_player.py | 428 +++++++++++++++--------------------- 1 file changed, 175 insertions(+), 253 deletions(-) diff --git a/lib/player/object_player.py b/lib/player/object_player.py index e6a069e..7fd9316 100644 --- a/lib/player/object_player.py +++ b/lib/player/object_player.py @@ -19,138 +19,87 @@ 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 - def inertia_point(self, n_step): return self.player_type().inertia_point(self.pos(), self.vel(), n_step) @@ -159,162 +108,138 @@ def inertia_final_point(self): 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 - 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(), 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() + 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() + 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 + 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 = 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, @@ -326,68 +251,65 @@ def update_by_hear(self, if PlayerObject.DEBUG: 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 - - def unum_count(self): - return self._unum_count + return self.goalie 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__() From 308875a7d63a6727103de9967a32ded30eeaa1ab Mon Sep 17 00:00:00 2001 From: Aref Date: Tue, 15 Aug 2023 16:28:11 -0230 Subject: [PATCH 04/22] remove getters in obj player py --- lib/player/object_player.py | 38 ++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/lib/player/object_player.py b/lib/player/object_player.py index 7fd9316..178b34c 100644 --- a/lib/player/object_player.py +++ b/lib/player/object_player.py @@ -96,20 +96,20 @@ def set_kickable(self, ika: bool): self.kickable = ika def is_kickable(self, buf=0.05): - if self.player_type() is None: + 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 + 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 dash_rate(self): - return self.effort() * self.player_type().dash_power_rate() + return self.stamina_model.effort() * self.player_type.dash_power_rate() def is_frozen(self): return False @@ -118,7 +118,7 @@ def is_ghost(self): 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): @@ -130,7 +130,7 @@ def update_by_last_cycle(self): 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) @@ -180,8 +180,8 @@ def update_by_see(self, side: SideID, player: Localizer.PlayerT): 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() + 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() @@ -211,9 +211,9 @@ def update_by_see(self, side: SideID, player: Localizer.PlayerT): 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() + 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 @@ -231,10 +231,10 @@ def update_by_see(self, side: SideID, player: Localizer.PlayerT): 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 @@ -267,7 +267,7 @@ def update_by_hear(self, self.unum_count = 2 if (self.seen_pos_count >= 2 - or (self.seen_pos_count > 0 and self.dist_from_self() > 20)): + or (self.seen_pos_count > 0 and self.dist_from_self > 20)): self.pos = pos.copy() self.pos_count = 1 @@ -309,7 +309,7 @@ def long_str(self): 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__() From f90dc3bd500f86b5a4cd133ac162dc9925e471da Mon Sep 17 00:00:00 2001 From: Aref Date: Tue, 15 Aug 2023 16:28:20 -0230 Subject: [PATCH 05/22] remove getters and clean ball objecet --- lib/player/object_ball.py | 277 +++++++++++++++++++------------------- 1 file changed, 137 insertions(+), 140 deletions(-) diff --git a/lib/player/object_ball.py b/lib/player/object_ball.py index ce7feb1..4c9d62f 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 + if (self.pos_count >= 5 or (self.rpos_count >= 2 and self.dist_from_self() * 1.05 < SP.visible_distance())): - self._pos_count = 1000 + 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}''' From 7ffcfd065c68d1763b615ac037e0cf51e0ae82ca Mon Sep 17 00:00:00 2001 From: Aref Date: Tue, 15 Aug 2023 16:36:18 -0230 Subject: [PATCH 06/22] remove getters and clean self obj --- lib/player/object_self.py | 611 ++++++++++++++++++-------------------- 1 file changed, 291 insertions(+), 320 deletions(-) diff --git a/lib/player/object_self.py b/lib/player/object_self.py index 0b24bdc..8c6454b 100644 --- a/lib/player/object_self.py +++ b/lib/player/object_self.py @@ -22,107 +22,98 @@ 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.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.last_moves: list[Vector2D] = [Vector2D(0, 0) for _ in range(4)] + self.arm_movable: int = 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 +128,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,178 +202,178 @@ 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: 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()}") @@ -395,15 +386,15 @@ def update_ball_info(self, ball: BallObject): if ball.seen_pos_count() >= 2: buff = 0.255 if ball.dist_from_self() <= ptype.kickable_area() - buff: - self._kickable = True + 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,152 +406,132 @@ 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 + if (not self.kickable and ball.seen_pos_count() == 0 - and ball.dist_from_self() < self.player_type().kickable_area() - 0.001): + 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_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}, ' 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() @@ -568,32 +539,32 @@ def __str__(self): 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 From adf2e057accea341be80df848e93f52aedaa3c36 Mon Sep 17 00:00:00 2001 From: Aref Date: Tue, 15 Aug 2023 17:22:09 -0230 Subject: [PATCH 07/22] modify pos() -> pos; checked where copy is required --- base/basic_tackle.py | 10 +++---- base/bhv_block.py | 2 +- base/generator_action.py | 4 +-- base/generator_clear.py | 6 ++-- base/generator_dribble.py | 14 +++++----- base/generator_pass.py | 22 +++++++-------- base/generator_shoot.py | 18 ++++++------ base/sample_communication.py | 8 +++--- base/set_play/bhv_goalie_set_play.py | 4 +-- base/set_play/bhv_set_play.py | 4 +-- base/stamina_manager.py | 8 +++--- base/strategy.py | 2 +- base/tackle_generator.py | 8 +++--- base/tools.py | 2 +- lib/action/basic_actions.py | 2 +- lib/action/go_to_point.py | 6 ++-- lib/action/hold_ball.py | 26 ++++++++--------- lib/action/intercept.py | 22 +++++++-------- lib/action/intercept_player.py | 2 +- lib/action/intercept_self.py | 42 ++++++++++++++-------------- lib/action/intercept_table.py | 18 ++++++------ lib/action/kick_table.py | 24 ++++++++-------- lib/action/neck_body_to_ball.py | 2 +- lib/action/neck_body_to_point.py | 2 +- lib/action/neck_scan_field.py | 2 +- lib/action/neck_scan_players.py | 4 +-- lib/action/neck_turn_to_ball.py | 4 +-- lib/action/scan_field.py | 2 +- lib/action/smart_kick.py | 2 +- lib/action/stop_ball.py | 8 +++--- lib/debug/debug_client.py | 14 +++++----- lib/player/object.py | 14 +++++----- 32 files changed, 154 insertions(+), 154 deletions(-) diff --git a/base/basic_tackle.py b/base/basic_tackle.py index 886fd4f..32cba68 100644 --- a/base/basic_tackle.py +++ b/base/basic_tackle.py @@ -27,8 +27,8 @@ def execute(self, agent: 'PlayerAgent'): 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 (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 @@ -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,7 +57,7 @@ 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 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,7 +69,7 @@ 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() diff --git a/base/bhv_block.py b/base/bhv_block.py index e1e1a02..3df8f82 100644 --- a/base/bhv_block.py +++ b/base/bhv_block.py @@ -30,7 +30,7 @@ def execute(self, agent: 'PlayerAgent'): 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) + 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: diff --git a/base/generator_action.py b/base/generator_action.py index 964aed0..fe7ac34 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) @@ -107,7 +107,7 @@ def can_opponent_cut_ball(self, wm: 'WorldModel', ball_pos, cycle): opp: 'PlayerObject' = wm.their_player(unum) if opp.unum() == 0: continue - opp_cycle = opp.pos().dist(ball_pos) - opp.player_type().kickable_area() + 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 diff --git a/base/generator_clear.py b/base/generator_clear.py index 06c85e8..856bfff 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}') @@ -78,7 +78,7 @@ def generate_clear_ball(self, wm: 'WorldModel'): continue 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 = 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() diff --git a/base/generator_dribble.py b/base/generator_dribble.py index 7152781..5209ba6 100644 --- a/base/generator_dribble.py +++ b/base/generator_dribble.py @@ -50,12 +50,12 @@ def generate_simple_dribble(self, wm: 'WorldModel'): for a in range(angle_div): 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 @@ -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,7 +137,7 @@ 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.start_ball_speed = first_vel.r() @@ -164,8 +164,8 @@ def create_self_cache(self, wm: 'WorldModel', dash_angle, n_turn, n_dash, self_c stamina_model = wm.self().stamina_model() - 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() @@ -218,7 +218,7 @@ def check_opponent(self, wm: 'WorldModel', ball_trap_pos: Vector2D, dribble_step 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: diff --git a/base/generator_pass.py b/base/generator_pass.py index ece617c..e936a87 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) @@ -71,15 +71,15 @@ def update_receivers(self, wm: 'WorldModel'): 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') 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() @@ -87,14 +87,14 @@ def generate_direct_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): 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: + 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())) return # TODO sp.ourTeamGoalPos() - if receiver.pos().x() < wm.ball().pos().x() + 1.0 \ + 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())) diff --git a/base/generator_shoot.py b/base/generator_shoot.py index 0424798..0105a03 100644 --- a/base/generator_shoot.py +++ b/base/generator_shoot.py @@ -30,9 +30,9 @@ def generator(self, wm: 'WorldModel') -> ShootAction: 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) @@ -68,7 +68,7 @@ def create_shoot(self, wm: 'WorldModel', target_point: Vector2D): or wm.game_mode().is_penalty_kick_mode() \ 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_speed = max_one_step_vel.r() @@ -123,14 +123,14 @@ def check_shoot(self, wm: 'WorldModel', target_point: Vector2D, first_ball_speed 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 @@ -159,7 +159,7 @@ def maybe_goalie_catch(self, goalie: 'PlayerObject', course: ShootAction, wm: 'W 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(), + 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 @@ -169,7 +169,7 @@ def maybe_goalie_catch(self, goalie: 'PlayerObject', course: ShootAction, wm: 'W 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) diff --git a/base/sample_communication.py b/base/sample_communication.py index 91b6c9e..97e214a 100644 --- a/base/sample_communication.py +++ b/base/sample_communication.py @@ -133,11 +133,11 @@ def should_say_opponent_goalie(self, agent: 'PlayerAgent'): 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.: + 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 @@ -224,7 +224,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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].player = p diff --git a/base/set_play/bhv_goalie_set_play.py b/base/set_play/bhv_goalie_set_play.py index 46afcb4..5c14f6a 100644 --- a/base/set_play/bhv_goalie_set_play.py +++ b/base/set_play/bhv_goalie_set_play.py @@ -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 @@ -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 0293171..f6a7603 100644 --- a/base/set_play/bhv_set_play.py +++ b/base/set_play/bhv_set_play.py @@ -46,12 +46,12 @@ def execute(self, agent: 'PlayerAgent'): if tm is None: continue if tm.unum() == i: - dist = tm.pos().dist(wm.ball().pos()) + 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() + target = wm.ball().pos.copy() if GoToPoint(target, 0.5, 100).execute(agent): agent.set_neck_action(NeckTurnToBallOrScan()) return True diff --git a/base/stamina_manager.py b/base/stamina_manager.py index cd6a036..323e34b 100644 --- a/base/stamina_manager.py +++ b/base/stamina_manager.py @@ -25,8 +25,8 @@ def get_normal_dash_power(wm: 'WorldModel', s_recover_mode: bool): dash_power = SP.i().max_dash_power() my_inc = wm.self().player_type().stamina_inc_max() * wm.self().recovery() - # TODO wm.ourDefenseLineX() > wm.self().pos().x - # TODO wm.ball().pos().x() < wm.ourDefenseLineX() + 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: @@ -35,9 +35,9 @@ def get_normal_dash_power(wm: 'WorldModel', s_recover_mode: bool): dash_power = 0.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 46f93c8..b6f83a5 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/tackle_generator.py b/base/tackle_generator.py index 71aa923..faae9ec 100644 --- a/base/tackle_generator.py +++ b/base/tackle_generator.py @@ -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,7 +145,7 @@ 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) + 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) diff --git a/base/tools.py b/base/tools.py index 75b268f..772c8f4 100644 --- a/base/tools.py +++ b/base/tools.py @@ -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 diff --git a/lib/action/basic_actions.py b/lib/action/basic_actions.py index 31324ac..ccce197 100644 --- a/lib/action/basic_actions.py +++ b/lib/action/basic_actions.py @@ -28,7 +28,7 @@ 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) diff --git a/lib/action/go_to_point.py b/lib/action/go_to_point.py index f9c30b1..2f25777 100644 --- a/lib/action/go_to_point.py +++ b/lib/action/go_to_point.py @@ -112,8 +112,8 @@ def check_collision(self, agent): 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: @@ -124,7 +124,7 @@ def check_collision(self, agent): 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 diff --git a/lib/action/hold_ball.py b/lib/action/hold_ball.py index 1ff1850..682d7c4 100644 --- a/lib/action/hold_ball.py +++ b/lib/action/hold_ball.py @@ -111,7 +111,7 @@ 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() + 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(), @@ -157,7 +157,7 @@ def createKeepPoints(self, wm: 'WorldModel', candidates): # 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 @@ -176,7 +176,7 @@ def createKeepPoints(self, wm: 'WorldModel', candidates): 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() + ball_move = near_pos - wm.ball().pos kick_accel = ball_move - wm.ball().vel() # can kick to the point by 1 step kick @@ -191,7 +191,7 @@ 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() + ball_move = mid_pos - wm.ball().pos kick_accel = ball_move - wm.ball().vel() kick_power = kick_accel.r() / wm.self().kick_rate() @@ -217,7 +217,7 @@ 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() + ball_move = far_pos - wm.ball().pos kick_accel = ball_move - wm.ball().vel() kick_power = kick_accel.r() / wm.self().kick_rate() @@ -271,7 +271,7 @@ 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(): @@ -287,7 +287,7 @@ def evaluateKeepPoint(self, wm: 'WorldModel', continue player_type = o.player_type() - opp_next = o.pos() + o.vel() + 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() @@ -380,8 +380,8 @@ 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): @@ -430,7 +430,7 @@ def keepFront(self, agent: 'PlayerAgent'): wm = agent.world() 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()) @@ -438,7 +438,7 @@ def keepFront(self, agent: 'PlayerAgent'): or front_pos.abs_y() > max_pitch_y): return False - ball_move = front_pos - wm.ball().pos() + ball_move = front_pos - wm.ball().pos kick_accel = ball_move - wm.ball().vel() kick_power = kick_accel.r() / wm.self().kick_rate() @@ -469,7 +469,7 @@ 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 @@ -498,7 +498,7 @@ def keepReverse(self, agent: 'PlayerAgent'): or keep_pos.abs_y() > max_pitch_y): continue - ball_move = keep_pos - wm.ball().pos() + ball_move = keep_pos - wm.ball().pos kick_accel = ball_move - wm.ball().vel() kick_power = kick_accel.r() / wm.self().kick_rate() diff --git a/lib/action/intercept.py b/lib/action/intercept.py index 4b79342..10dbe3f 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)") @@ -106,8 +106,8 @@ def do_kickable_opponent_check(self, 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( @@ -309,7 +309,7 @@ def get_best_intercept(self, wm: 'WorldModel', if nearest_best is not None: return nearest_best - if (wm.self().pos().x() > 40 + 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): @@ -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)") @@ -372,12 +372,12 @@ def do_wait_turn(self, 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() @@ -407,7 +407,7 @@ def do_inertia_dash(self, agent.do_dash(info.dash_power(), info.dash_angle()) return True - target_rel = target_point - wm.self().pos() + target_rel = target_point - wm.self().pos target_rel.rotate(-wm.self().body()) accel_angle = wm.self().body() @@ -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 d52d166..dc3c29f 100644 --- a/lib/action/intercept_player.py +++ b/lib/action/intercept_player.py @@ -30,7 +30,7 @@ def predict(self, 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 = 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())) diff --git a/lib/action/intercept_self.py b/lib/action/intercept_self.py index 9eaadc6..a04d4b5 100644 --- a/lib/action/intercept_self.py +++ b/lib/action/intercept_self.py @@ -49,7 +49,7 @@ 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 \ goalie_mode else \ @@ -71,8 +71,8 @@ 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 \ goalie_mode else \ @@ -143,7 +143,7 @@ def predict_one_dash(self, self_cache): me: PlayerObject = wm.self() 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 \ @@ -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,8 +302,8 @@ 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) @@ -388,7 +388,7 @@ def predict_short_step(self, max_cycle, save_recovery, self_cache): 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())) @@ -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:]: @@ -502,8 +502,8 @@ def predict_omni_dash_short(self, continue first_dash_power = 0 - my_pos = me.pos() - my_vel = me.vel() + my_pos = me.pos.copy() + my_vel = me.vel.copy() stamina_model = me.stamina_model() n_omni_dash, first_dash_power = self.predict_adjust_omni_dash(cycle, @@ -560,7 +560,7 @@ 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(): mode = (InterceptInfo.Mode.EXHAUST @@ -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() @@ -820,7 +820,7 @@ def predict_long_step(self, max_cycle: int, save_recovery: bool, self_cache: lis ptype = me.player_type() # calc y distance from ball line - ball_to_self = me.pos() - ball.pos() + 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() @@ -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 @@ -1008,7 +1008,7 @@ def can_reach_after_dash(self, 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_noise = (wm.ball().pos.dist(ball_pos) * SP.ball_rand() * 0.5) noised_ball_x = ball_rel.x() + ball_noise @@ -1080,7 +1080,7 @@ 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)) @@ -1105,7 +1105,7 @@ 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() diff --git a/lib/action/intercept_table.py b/lib/action/intercept_table.py index f8c90fa..01603cf 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) @@ -222,7 +222,7 @@ def predict_opponent(self, wm: 'WorldModel'): 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: @@ -273,7 +273,7 @@ def predict_teammate(self, wm: 'WorldModel'): 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(): diff --git a/lib/action/kick_table.py b/lib/action/kick_table.py index e7059e7..696dd67 100644 --- a/lib/action/kick_table.py +++ b/lib/action/kick_table.py @@ -489,7 +489,7 @@ def create_state_cache(self, world: 'WorldModel'): self._current_state.index_ = 0 # self._current_state.pos_ = world.ball().rpos() - self._current_state.pos_ = world.ball().pos() + 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 +498,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() @@ -565,8 +565,8 @@ def check_collision_after_release(self, world: 'WorldModel', target_point: Vecto 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 @@ -630,7 +630,7 @@ def check_interfere_at(world: 'WorldModel', 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(): @@ -742,7 +742,7 @@ def check_interfere_after_release(self, *args): # , **kwargs):): 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()): @@ -816,14 +816,14 @@ def simulate_one_step(self, world: 'WorldModel', target_point: Vector2D, first_s 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_ """ @@ -869,7 +869,7 @@ def simulate_two_step(self, world: 'WorldModel', target_point: Vector2D, first_s 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,7 +891,7 @@ 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() + vel = state.pos_ - world.ball().pos accel = vel - world.ball().vel() accel_r = accel.r() @@ -1020,7 +1020,7 @@ def simulate_three_step(self, world: 'WorldModel', kick_miss_flag = SAFETY - vel1 = state_1st.pos_ - world.ball().pos() + vel1 = state_1st.pos_ - world.ball().pos accel = vel1 - world.ball().vel() accel_r2 = accel.r2() diff --git a/lib/action/neck_body_to_ball.py b/lib/action/neck_body_to_ball.py index 7b53cd3..e9d7669 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 89b26e3..1068172 100644 --- a/lib/action/neck_body_to_point.py +++ b/lib/action/neck_body_to_point.py @@ -27,7 +27,7 @@ def execute(self, agent: 'PlayerAgent'): angle_buf = bound(0., self._angle_buf, 180.) - my_next = wm.self().pos() + wm.self().vel() + 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: diff --git a/lib/action/neck_scan_field.py b/lib/action/neck_scan_field.py index 4e0b92e..ad794a1 100644 --- a/lib/action/neck_scan_field.py +++ b/lib/action/neck_scan_field.py @@ -175,7 +175,7 @@ def calc_angle_for_wide_pitch_edge(self, agent: 'PlayerAgent'): 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 866a6df..3a0aa77 100644 --- a/lib/action/neck_scan_players.py +++ b/lib/action/neck_scan_players.py @@ -122,7 +122,7 @@ 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): @@ -138,7 +138,7 @@ def calculate_score(wm: WorldModel, next_self_pos: Vector2D, left_angle: AngleDe 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 diff --git a/lib/action/neck_turn_to_ball.py b/lib/action/neck_turn_to_ball.py index 94d188c..5c4636c 100644 --- a/lib/action/neck_turn_to_ball.py +++ b/lib/action/neck_turn_to_ball.py @@ -61,8 +61,8 @@ def execute(self, agent: 'PlayerAgent'): 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)): best_angle = NeckScanPlayers.INVALID_ANGLE diff --git a/lib/action/scan_field.py b/lib/action/scan_field.py index f8b286e..301b8fe 100644 --- a/lib/action/scan_field.py +++ b/lib/action/scan_field.py @@ -38,7 +38,7 @@ 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() + 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 diff --git a/lib/action/smart_kick.py b/lib/action/smart_kick.py index 35895ad..726ee6e 100644 --- a/lib/action/smart_kick.py +++ b/lib/action/smart_kick.py @@ -67,7 +67,7 @@ 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() + 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()}") diff --git a/lib/action/stop_ball.py b/lib/action/stop_ball.py index 303a246..20af0e4 100644 --- a/lib/action/stop_ball.py +++ b/lib/action/stop_ball.py @@ -39,7 +39,7 @@ 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()) + 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()), @@ -74,12 +74,12 @@ def calcAccel(self, agent): 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 += target_rel # target relative to current - required_accel -= wm.self().pos() - wm.ball().pos() # vel = pos diff + required_accel -= wm.self().pos - wm.ball().pos # vel = pos diff required_accel -= wm.ball().vel() # required accel self._accel_radius = required_accel.r() @@ -99,7 +99,7 @@ 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.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 diff --git a/lib/debug/debug_client.py b/lib/debug/debug_client.py index 97534c7..cc494d3 100644 --- a/lib/debug/debug_client.py +++ b/lib/debug/debug_client.py @@ -36,7 +36,7 @@ def player_printer(p: 'PlayerObject', our_side: SideID): 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())})" @@ -131,13 +131,13 @@ 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().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)) + ' ' \ @@ -148,9 +148,9 @@ def to_str(self, world: 'WorldModel', effector): 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))) diff --git a/lib/player/object.py b/lib/player/object.py index 91c08d5..985d2e9 100644 --- a/lib/player/object.py +++ b/lib/player/object.py @@ -70,16 +70,16 @@ 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 = 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.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() From 7c2e021007d06eb9f98c26eece37857d81e7d5e5 Mon Sep 17 00:00:00 2001 From: Aref Date: Wed, 16 Aug 2023 14:00:07 -0230 Subject: [PATCH 08/22] modify pos() -> pos; and vel() -> vel checked where copy is required --- base/basic_tackle.py | 2 +- base/bhv_block.py | 2 +- base/generator_dribble.py | 6 +- base/generator_pass.py | 54 ++++++------ base/generator_shoot.py | 10 +-- base/sample_communication.py | 98 +++++++++++----------- base/tackle_generator.py | 10 +-- lib/action/basic_actions.py | 2 +- lib/action/go_to_point.py | 4 +- lib/action/hold_ball.py | 42 +++++----- lib/action/intercept.py | 24 +++--- lib/action/intercept_player.py | 4 +- lib/action/intercept_self.py | 30 +++---- lib/action/kick_table.py | 18 ++-- lib/action/neck_body_to_ball.py | 2 +- lib/action/neck_body_to_point.py | 4 +- lib/action/smart_kick.py | 2 +- lib/action/stop_ball.py | 10 +-- lib/debug/debug_client.py | 8 +- lib/messenger/ball_pos_vel_messenger.py | 4 +- lib/messenger/player_pos_unum_messenger.py | 2 +- lib/player/action_effector.py | 16 ++-- lib/player/object.py | 2 +- lib/player/object_ball.py | 4 +- lib/player/object_player.py | 2 +- lib/player/object_self.py | 8 +- lib/player/player_agent.py | 8 +- lib/player/world_model.py | 72 ++++++++-------- 28 files changed, 225 insertions(+), 225 deletions(-) diff --git a/base/basic_tackle.py b/base/basic_tackle.py index 32cba68..412db44 100644 --- a/base/basic_tackle.py +++ b/base/basic_tackle.py @@ -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)) diff --git a/base/bhv_block.py b/base/bhv_block.py index 3df8f82..8c75aa9 100644 --- a/base/bhv_block.py +++ b/base/bhv_block.py @@ -30,7 +30,7 @@ def execute(self, agent: 'PlayerAgent'): 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) + 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: diff --git a/base/generator_dribble.py b/base/generator_dribble.py index 5209ba6..4a2981d 100644 --- a/base/generator_dribble.py +++ b/base/generator_dribble.py @@ -45,7 +45,7 @@ def generate_simple_dribble(self, wm: 'WorldModel'): sp = SP.i() 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) @@ -114,7 +114,7 @@ def simulate_kick_turns_dashes(self, wm: 'WorldModel', dash_angle, n_turn): 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_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( @@ -239,7 +239,7 @@ def check_opponent(self, wm: 'WorldModel', ball_trap_pos: Vector2D, dribble_step n_turn = 1 if opp.body_count() > 1 else Tools.predict_player_turn_cycle(ptype, opp.body(), - opp.vel().r(), + opp.vel.r(), target_dist, (ball_trap_pos - opp_pos).th(), control_area, diff --git a/base/generator_pass.py b/base/generator_pass.py index e936a87..a65c857 100644 --- a/base/generator_pass.py +++ b/base/generator_pass.py @@ -94,8 +94,8 @@ def generate_direct_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): 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())) return @@ -108,8 +108,8 @@ def generate_direct_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): # 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: @@ -151,7 +151,7 @@ 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())) return @@ -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,7 +182,7 @@ 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) + 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 \ @@ -192,7 +192,7 @@ def generate_lead_pass(self, wm: 'WorldModel', receiver): 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)) @@ -205,7 +205,7 @@ def generate_lead_pass(self, wm: 'WorldModel', receiver): 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: @@ -250,23 +250,23 @@ 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())) 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())) 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())) 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())) 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())) return @@ -289,14 +289,14 @@ 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) + 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 \ @@ -311,7 +311,7 @@ def generate_through_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): 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: @@ -351,7 +351,7 @@ def predict_receiver_reach_step(self, receiver, pos: Vector2D, use_penalty, pass 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, ( + receiver.vel.r(), target_dist, ( pos - receiver.inertia_point( 1)).th(), ptype.kickable_area(), False) @@ -389,7 +389,7 @@ def create_pass(self, wm: 'WorldModel', receiver, receive_point: Vector2D, '##Pass {},to {} {}, step:{}, ball_speed:{}, first ball speed is low'.format( self.index, receiver.unum(), - receiver.pos(), + receiver.pos, step, first_ball_speed)) self.debug_list.append((self.index, receive_point, False)) @@ -401,7 +401,7 @@ def create_pass(self, wm: 'WorldModel', receiver, receive_point: Vector2D, '##Pass {},to {} {}, step:{}, ball_speed:{}, first ball speed is high'.format( self.index, receiver.unum(), - receiver.pos(), + receiver.pos, step, first_ball_speed)) self.debug_list.append((self.index, receive_point, False)) @@ -415,7 +415,7 @@ def create_pass(self, wm: 'WorldModel', receiver, receive_point: Vector2D, '##Pass {},to {} {}, step:{}, ball_speed:{}, rball_speed:{}, receive ball speed is low'.format( self.index, receiver.unum(), - receiver.pos(), + receiver.pos, step, first_ball_speed, receive_ball_speed)) @@ -428,7 +428,7 @@ def create_pass(self, wm: 'WorldModel', receiver, receive_point: Vector2D, '##Pass {},to {} {}, step:{}, ball_speed:{}, rball_speed:{}, receive ball speed is high'.format( self.index, receiver.unum(), - receiver.pos(), + receiver.pos, step, first_ball_speed, receive_ball_speed)) @@ -437,7 +437,7 @@ def create_pass(self, wm: 'WorldModel', receiver, receive_point: Vector2D, 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) @@ -474,7 +474,7 @@ 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.start_ball_speed = first_ball_speed @@ -521,7 +521,7 @@ 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, + 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 @@ -565,7 +565,7 @@ def predict_opponent_reach_step(self, wm: 'WorldModel', opp: 'PlayerObject', fir n_turn = 0 if opponent.body_count() > 1: - n_turn = Tools.predict_player_turn_cycle(ptype, opponent.body(), opponent.vel().r(), target_dist, + 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 0105a03..e299fe6 100644 --- a/base/generator_shoot.py +++ b/base/generator_shoot.py @@ -164,7 +164,7 @@ def maybe_goalie_catch(self, goalie: 'PlayerObject', course: ShootAction, wm: 'W if min_cycle < 0: return False - goalie_speed = goalie.vel().r() + goalie_speed = goalie.vel.r() seen_dist_noise = goalie.dist_from_self() * 0.02 max_cycle = course.ball_reach_step @@ -218,17 +218,17 @@ def opponent_can_reach(self, opponent, course: ShootAction, wm: 'WorldModel'): sp = SP.i() 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: @@ -272,7 +272,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 diff --git a/base/sample_communication.py b/base/sample_communication.py index 97e214a..0d971b4 100644 --- a/base/sample_communication.py +++ b/base/sample_communication.py @@ -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 ( @@ -137,7 +137,7 @@ def should_say_opponent_goalie(self, agent: 'PlayerAgent'): 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 @@ -200,9 +200,9 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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) @@ -224,7 +224,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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].player = p @@ -233,7 +233,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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].player = p @@ -292,7 +292,7 @@ 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.pos + goalie.vel, goalie.body())) self._ball_send_time = wm.time().copy() self.update_player_send_time(wm, goalie.side(), goalie.unum()) @@ -312,7 +312,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): agent.add_say_message(BallPlayerMessenger(ef.queued_next_ball_pos(), ball_vel, send_players[0].number, - p.pos() + p.vel(), + p.pos + p.vel, p.body())) self._ball_send_time = wm.time().copy() @@ -321,14 +321,14 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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.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]: @@ -339,7 +339,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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), @@ -349,17 +349,17 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): goalie.body(), ( player.unum() if player.side() == wm.our_side() else player.unum() + 11), - player.pos() + player.vel())) + 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), @@ -371,7 +371,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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]: @@ -383,11 +383,11 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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())) + 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()) @@ -403,9 +403,9 @@ 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())) + p1.pos + p1.vel())) self.update_player_send_time(wm, p0.side(), p0.unum()) self.update_player_send_time(wm, p1.side(), p1.unum()) @@ -418,10 +418,10 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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.pos.x() > 53. - 16. \ + and p0.pos.abs_y() < 20 \ and p0.dist_from_self() < 25: - goalie_pos = p0.pos() + p0.vel() + goalie_pos = p0.pos + p0.vel goalie_pos.assign( bound(53. - 16., goalie_pos.x(), 52.9), bound(-20, goalie_pos.y(), 20), @@ -440,7 +440,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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()) @@ -459,7 +459,7 @@ def update_current_sender(self, agent: 'PlayerAgent'): 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: @@ -500,19 +500,19 @@ 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: 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.: break @@ -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 @@ -533,8 +533,8 @@ 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') + 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 @@ -557,8 +557,8 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC 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') + 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 @@ -571,8 +571,8 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC 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') + 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 @@ -581,8 +581,8 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC 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') + 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 @@ -591,8 +591,8 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC 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') + 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 @@ -600,8 +600,8 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC 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') diff --git a/base/tackle_generator.py b/base/tackle_generator.py index faae9ec..6cb624f 100644 --- a/base/tackle_generator.py +++ b/base/tackle_generator.py @@ -93,7 +93,7 @@ def calculate(self, wm: 'WorldModel'): 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()) @@ -146,9 +146,9 @@ def evaluate(self, wm, result: TackleAction): 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()) + 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) @@ -208,9 +208,9 @@ def predict_opponent_reach_step(self, SP = ServerParam.i() 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) diff --git a/lib/action/basic_actions.py b/lib/action/basic_actions.py index ccce197..88ae7fd 100644 --- a/lib/action/basic_actions.py +++ b/lib/action/basic_actions.py @@ -120,7 +120,7 @@ def execute(self, agent: 'PlayerAgent'): 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 diff --git a/lib/action/go_to_point.py b/lib/action/go_to_point.py index 2f25777..9b07b19 100644 --- a/lib/action/go_to_point.py +++ b/lib/action/go_to_point.py @@ -51,7 +51,7 @@ 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()) + 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() @@ -89,7 +89,7 @@ def do_dash(self, agent): 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: diff --git a/lib/action/hold_ball.py b/lib/action/hold_ball.py index 682d7c4..4aa24ac 100644 --- a/lib/action/hold_ball.py +++ b/lib/action/hold_ball.py @@ -112,7 +112,7 @@ def avoidOpponent(self, agent: 'PlayerAgent'): 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() + 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()) @@ -157,14 +157,14 @@ def createKeepPoints(self, wm: 'WorldModel', candidates): # 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() + 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_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: @@ -177,7 +177,7 @@ def createKeepPoints(self, wm: 'WorldModel', candidates): 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() + 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(): @@ -192,7 +192,7 @@ def createKeepPoints(self, wm: 'WorldModel', candidates): 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_accel = ball_move - wm.ball().vel kick_power = kick_accel.r() / wm.self().kick_rate() # can kick to the point by 1 step kick @@ -218,7 +218,7 @@ def createKeepPoints(self, wm: 'WorldModel', candidates): 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_accel = ball_move - wm.ball().vel kick_power = kick_accel.r() / wm.self().kick_rate() # can kick to the point by 1 step kick @@ -271,7 +271,7 @@ 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(): @@ -287,7 +287,7 @@ def evaluateKeepPoint(self, wm: 'WorldModel', continue player_type = o.player_type() - opp_next = o.pos + o.vel() + 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() @@ -308,8 +308,8 @@ def evaluateKeepPoint(self, wm: 'WorldModel', 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() @@ -380,15 +380,15 @@ 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) @@ -430,7 +430,7 @@ def keepFront(self, agent: 'PlayerAgent'): wm = agent.world() 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()) @@ -439,7 +439,7 @@ def keepFront(self, agent: 'PlayerAgent'): return False ball_move = front_pos - wm.ball().pos - kick_accel = ball_move - wm.ball().vel() + 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 @@ -469,9 +469,9 @@ 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() + 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() @@ -479,7 +479,7 @@ def keepReverse(self, agent: 'PlayerAgent'): - 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() @@ -499,7 +499,7 @@ def keepReverse(self, agent: 'PlayerAgent'): continue ball_move = keep_pos - wm.ball().pos - kick_accel = ball_move - wm.ball().vel() + kick_accel = ball_move - wm.ball().vel kick_power = kick_accel.r() / wm.self().kick_rate() if kick_power > param.max_power(): diff --git a/lib/action/intercept.py b/lib/action/intercept.py index 10dbe3f..197145b 100644 --- a/lib/action/intercept.py +++ b/lib/action/intercept.py @@ -171,7 +171,7 @@ 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: @@ -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,13 +282,13 @@ 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 and nearest_best.ball_dist() < noturn_best.ball_dist() @@ -310,8 +310,8 @@ def get_best_intercept(self, wm: 'WorldModel', return nearest_best if (wm.self().pos.x() > 40 - and wm.ball().vel().r() > 1.8 - and wm.ball().vel().th().abs() < 100 + 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): @@ -340,7 +340,7 @@ def do_wait_turn(self, 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() @@ -360,7 +360,7 @@ 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 @@ -414,7 +414,7 @@ def do_inertia_dash(self, if info.dash_power() < 0: accel_angle += 180 - ball_vel = wm.ball().vel() * ServerParam.i().ball_decay() ** info.reach_cycle() + 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): @@ -448,7 +448,7 @@ def do_inertia_dash(self, 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 + 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()) @@ -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()) diff --git a/lib/action/intercept_player.py b/lib/action/intercept_player.py index dc3c29f..6d9177e 100644 --- a/lib/action/intercept_player.py +++ b/lib/action/intercept_player.py @@ -31,7 +31,7 @@ def predict(self, 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.rotate(-wm.ball().vel.th()) min_cycle = int(floor(ball_to_player.abs_y() / player_type.real_speed_max())) @@ -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) diff --git a/lib/action/intercept_self.py b/lib/action/intercept_self.py index a04d4b5..a5c2ca7 100644 --- a/lib/action/intercept_self.py +++ b/lib/action/intercept_self.py @@ -78,7 +78,7 @@ def predict_no_dash(self, self_cache) -> bool: 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() + ball_noise: float = wm.ball().vel.r() * SP.ball_rand() next_ball_dist: float = next_ball_rel.r() # out of control area @@ -105,7 +105,7 @@ def predict_no_dash(self, self_cache) -> bool: 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 @@ -175,8 +175,8 @@ def predict_one_dash(self, self_cache): 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, @@ -388,7 +388,7 @@ def predict_short_step(self, max_cycle, save_recovery, self_cache): 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 = [] @@ -685,7 +685,7 @@ def predict_dash_cycle_short(self, 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.simulate_waits(ptype, n_turn) @@ -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() @@ -821,7 +821,7 @@ def predict_long_step(self, max_cycle: int, save_recovery: bool, self_cache: lis # calc y distance from ball line ball_to_self = me.pos - ball.pos - ball_to_self.rotate(-ball.vel().th()) + 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 @@ -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 @@ -1016,10 +1016,10 @@ 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) diff --git a/lib/action/kick_table.py b/lib/action/kick_table.py index 696dd67..bab51b0 100644 --- a/lib/action/kick_table.py +++ b/lib/action/kick_table.py @@ -807,13 +807,13 @@ def simulate_one_step(self, world: 'WorldModel', target_point: Vector2D, first_s 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() + 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) @@ -858,7 +858,7 @@ def simulate_two_step(self, world: 'WorldModel', target_point: Vector2D, first_s param = ServerParam.i() my_kickable_area = self_type.kickable_area() - my_noise = world.self().vel().r() * param.player_rand() + 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() @@ -867,9 +867,9 @@ def simulate_two_step(self, world: 'WorldModel', target_point: Vector2D, first_s / 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 @@ -892,7 +892,7 @@ def simulate_two_step(self, world: 'WorldModel', target_point: Vector2D, first_s target_vel = (target_point - state.pos_).set_length_vector(first_speed) vel = state.pos_ - world.ball().pos - accel = vel - world.ball().vel() + accel = vel - world.ball().vel accel_r = accel.r() if accel_r > current_max_accel: @@ -967,14 +967,14 @@ def simulate_three_step(self, world: 'WorldModel', my_kickable_area = self_type.kickable_area() - my_noise1 = world.self().vel().r() * param.player_rand() + 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() @@ -1021,7 +1021,7 @@ def simulate_three_step(self, world: 'WorldModel', kick_miss_flag = SAFETY vel1 = state_1st.pos_ - world.ball().pos - accel = vel1 - world.ball().vel() + accel = vel1 - world.ball().vel accel_r2 = accel.r2() if accel_r2 > current_max_accel2: diff --git a/lib/action/neck_body_to_ball.py b/lib/action/neck_body_to_ball.py index e9d7669..98dc55c 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 1068172..6f8710c 100644 --- a/lib/action/neck_body_to_point.py +++ b/lib/action/neck_body_to_point.py @@ -27,7 +27,7 @@ def execute(self, agent: 'PlayerAgent'): angle_buf = bound(0., self._angle_buf, 180.) - my_next = wm.self().pos + wm.self().vel() + 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: @@ -35,7 +35,7 @@ def execute(self, agent: 'PlayerAgent'): 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/smart_kick.py b/lib/action/smart_kick.py index 726ee6e..de06853 100644 --- a/lib/action/smart_kick.py +++ b/lib/action/smart_kick.py @@ -68,7 +68,7 @@ def execute(self, agent: 'PlayerAgent'): 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() + 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()}") diff --git a/lib/action/stop_ball.py b/lib/action/stop_ball.py index 20af0e4..eaa3aff 100644 --- a/lib/action/stop_ball.py +++ b/lib/action/stop_ball.py @@ -39,7 +39,7 @@ 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()) + 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()), @@ -77,10 +77,10 @@ def calcAccel(self, agent): 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.ball().vel # required accel self._accel_radius = required_accel.r() @@ -98,9 +98,9 @@ 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().vel.copy() next_ball_to_self -= wm.self().pos - wm.ball().pos - next_ball_to_self -= wm.ball().vel() + next_ball_to_self -= wm.ball().vel keep_dist = wm.self().player_type().player_size() + wm.self().player_type().kickable_margin() * 0.4 diff --git a/lib/debug/debug_client.py b/lib/debug/debug_client.py index cc494d3..bc72d62 100644 --- a/lib/debug/debug_client.py +++ b/lib/debug/debug_client.py @@ -138,8 +138,8 @@ def to_str(self, world: 'WorldModel', effector): + 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().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()) + ' ' \ @@ -152,8 +152,8 @@ def to_str(self, world: 'WorldModel', effector): 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 += (' ' + 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())) + '\'))' diff --git a/lib/messenger/ball_pos_vel_messenger.py b/lib/messenger/ball_pos_vel_messenger.py index b43f4b7..06e4540 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 9b3c2c0..019b5a4 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 3a49359..edfb831 100644 --- a/lib/player/action_effector.py +++ b/lib/player/action_effector.py @@ -312,7 +312,7 @@ 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_mag = wm.self().player_type().normalize_accel(wm.self().vel, accel_angle=accel_angle, accel_mag=accel_mag) @@ -377,7 +377,7 @@ 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() if moment > SP.max_moment() or moment < SP.min_moment(): @@ -481,7 +481,7 @@ def set_pointto(self, x, y): wm = self._agent.world() target = Vector2D(x,y) - target = target - wm.self().pos() + target = target - wm.self().pos target.rotate(-wm.self().face()) self._pointto_command = PlayerPointtoCommand(target.r(), target.th()) @@ -641,7 +641,7 @@ 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 @@ -649,7 +649,7 @@ def queued_next_self_pos(self) -> Vector2D: tmp = vel.r() if tmp > me.player_type().player_speed_max(): vel *= me.player_type().player_speed_max() / tmp - return me.pos() + vel + 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() diff --git a/lib/player/object.py b/lib/player/object.py index 985d2e9..bce1915 100644 --- a/lib/player/object.py +++ b/lib/player/object.py @@ -111,4 +111,4 @@ def long_str(self): f'ghost_count: {self.ghost_count},' def __str__(self): - return f'''pos: {self.pos()} vel:{self.vel()}''' + return f'''pos: {self.pos} vel:{self.vel}''' diff --git a/lib/player/object_ball.py b/lib/player/object_ball.py index 4c9d62f..296c797 100644 --- a/lib/player/object_ball.py +++ b/lib/player/object_ball.py @@ -219,11 +219,11 @@ def update_self_related(self, player: 'SelfObject' , prev: 'BallObject'): 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.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.rpos = self.pos - player.pos self.dist_from_self = self.rpos().r() self.angle_from_self = self.rpos().th() else: diff --git a/lib/player/object_player.py b/lib/player/object_player.py index 178b34c..3749108 100644 --- a/lib/player/object_player.py +++ b/lib/player/object_player.py @@ -249,7 +249,7 @@ 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 diff --git a/lib/player/object_self.py b/lib/player/object_self.py index 8c6454b..dc09457 100644 --- a/lib/player/object_self.py +++ b/lib/player/object_self.py @@ -206,7 +206,7 @@ def update_vel_dir_after_see(self, sense: SenseBodyParser, current_time: GameTim self.vel.set_polar(sense.speed_mag(), vel_ang) self.vel_count = 0 - self.seen_vel = self.vel().copy() + self.seen_vel = self.vel.copy() self.seen_vel_count = 0 # TODO cos_min_max and sin_min_max should be implemented @@ -392,9 +392,9 @@ def update_ball_info(self, ball: BallObject): (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) + 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 @@ -483,7 +483,7 @@ def long_str(self): 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}''' # TODO CHECK IT ''' self.sense_body_time = current_time.copy() diff --git a/lib/player/player_agent.py b/lib/player/player_agent.py index fcef44b..8c91620 100644 --- a/lib/player/player_agent.py +++ b/lib/player/player_agent.py @@ -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): diff --git a/lib/player/world_model.py b/lib/player/world_model.py index 0877bdc..007572b 100644 --- a/lib/player/world_model.py +++ b/lib/player/world_model.py @@ -257,15 +257,15 @@ 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()) + 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: @@ -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 @@ -301,7 +301,7 @@ 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() + ball_next = self.ball().pos + self.ball().vel if ball_next.x() > new_line: new_line = ball_next.x() count = self.ball().pos_count() @@ -520,8 +520,8 @@ def estimate_ball_by_pos_diff(self, see: SeeParser, act: 'ActionEffector', rpos: 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()) @@ -540,7 +540,7 @@ def estimate_ball_by_pos_diff(self, see: SeeParser, act: 'ActionEffector', rpos: 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): @@ -568,7 +568,7 @@ def estimate_ball_by_pos_diff(self, see: SeeParser, act: 'ActionEffector', rpos: 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): @@ -631,17 +631,17 @@ def localize_ball(self, see: SeeParser, act: 'ActionEffector'): self._ball.update_only_relative_pos(rpos, rpos_err) return - pos = self.self().pos() + rpos + 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={rvel}, self_vel={self.self().vel}") if rvel.is_valid() and self.self().vel_valid(): - gvel = self.self().vel() + rvel + gvel = self.self().vel + rvel vel_err += self.self().vel_error() vel_count = 0 @@ -654,7 +654,7 @@ def localize_ball(self, see: SeeParser, act: 'ActionEffector'): and self._prev_ball.rpos_count() == 0 and self._prev_ball.rpos().r() < 5): - gvel = pos - self._prev_ball.pos() + 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 @@ -889,8 +889,8 @@ 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_pos = self.self().pos + my_vel = self.self().vel my_face = self.self().face() my_face_err = self.self().face_error() @@ -1008,7 +1008,7 @@ def update_world_after_see(self, if self.self().pos_count() <= 10: varea = ViewArea(self.self().view_width().width(), - self.self().pos(), + self.self().pos, self.self().face(), current_time) self.check_ghost(varea) # TODO @@ -1100,17 +1100,17 @@ def update_player_state_cache(self): self.create_set_player(self._teammates, self._teammates_from_self, self._teammates_from_ball, - self.self().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.self().pos, self.ball().pos()) self.create_set_player(self._unknown_players, self._opponents_from_self, self._opponents_from_ball, - self.self().pos(), + self.self().pos, self.ball().pos()) self._teammates_from_ball.sort(key=lambda p: p.dist_from_ball()) @@ -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 @@ -1288,10 +1288,10 @@ def update_goalie_by_hear(self): for o in self._opponents + self._unknown_players: 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) + 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 @@ -1453,13 +1453,13 @@ def update_players_by_hear(self): if p.unum() != UNUM_UNKNOWN and p.unum() != unum: continue - d = p.pos().dist(player.pos_) + 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_) + 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 @@ -1517,7 +1517,7 @@ def update_ball_by_hear(self, act: 'ActionEffector'): 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_ @@ -1595,24 +1595,24 @@ def check_ghost(self, varea: ViewArea): 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 + - (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.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 @@ -1622,7 +1622,7 @@ 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.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 @@ -1633,7 +1633,7 @@ 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.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 From eea24b1fc7e8af80ad73962890e27fbb0cb5c01b Mon Sep 17 00:00:00 2001 From: Aref Date: Wed, 16 Aug 2023 14:07:37 -0230 Subject: [PATCH 09/22] modify body() -> body checked where copy is required --- base/bhv_block.py | 2 +- base/generator_dribble.py | 4 ++-- base/generator_pass.py | 4 ++-- base/generator_shoot.py | 4 ++-- base/sample_communication.py | 6 +++--- base/tackle_generator.py | 6 +++--- lib/action/basic_actions.py | 6 +++--- lib/action/go_to_point.py | 4 ++-- lib/action/hold_ball.py | 4 ++-- lib/action/intercept.py | 4 ++-- lib/action/intercept_self.py | 14 +++++++------- lib/action/kick_table.py | 6 +++--- lib/action/neck_body_to_point.py | 2 +- lib/action/smart_kick.py | 4 ++-- lib/action/turn_to_point.py | 2 +- lib/debug/debug_client.py | 4 ++-- lib/player/action_effector.py | 10 +++++----- lib/player/world_model.py | 2 +- 18 files changed, 44 insertions(+), 44 deletions(-) diff --git a/base/bhv_block.py b/base/bhv_block.py index 8c75aa9..25b7d58 100644 --- a/base/bhv_block.py +++ b/base/bhv_block.py @@ -30,7 +30,7 @@ def execute(self, agent: 'PlayerAgent'): 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) + 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: diff --git a/base/generator_dribble.py b/base/generator_dribble.py index 4a2981d..aa5f22d 100644 --- a/base/generator_dribble.py +++ b/base/generator_dribble.py @@ -48,7 +48,7 @@ def generate_simple_dribble(self, wm: 'WorldModel'): 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 debug_dribble: @@ -238,7 +238,7 @@ def check_opponent(self, wm: 'WorldModel', ball_trap_pos: Vector2D, dribble_step 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.body, opp.vel.r(), target_dist, (ball_trap_pos - opp_pos).th(), diff --git a/base/generator_pass.py b/base/generator_pass.py index a65c857..072876a 100644 --- a/base/generator_pass.py +++ b/base/generator_pass.py @@ -350,7 +350,7 @@ def predict_receiver_reach_step(self, receiver, pos: Vector2D, use_penalty, pass 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(), + 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(), @@ -565,7 +565,7 @@ def predict_opponent_reach_step(self, wm: 'WorldModel', opp: 'PlayerObject', fir n_turn = 0 if opponent.body_count() > 1: - n_turn = Tools.predict_player_turn_cycle(ptype, opponent.body(), opponent.vel.r(), target_dist, + 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 e299fe6..020ed25 100644 --- a/base/generator_shoot.py +++ b/base/generator_shoot.py @@ -195,7 +195,7 @@ def maybe_goalie_catch(self, goalie: 'PlayerObject', course: ShootAction, wm: 'W continue n_turn = 0 if goalie.body_count() <= 1: - Tools.predict_player_turn_cycle(ptype, goalie.body(), goalie_speed, target_dist, + 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: @@ -243,7 +243,7 @@ def opponent_can_reach(self, opponent, course: ShootAction, wm: 'WorldModel'): n_turn = 1 if opponent.body_count() == 0: - n_turn = Tools.predict_player_turn_cycle(ptype, opponent.body(), opponent_speed, target_dist, + 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: diff --git a/base/sample_communication.py b/base/sample_communication.py index 0d971b4..3b49147 100644 --- a/base/sample_communication.py +++ b/base/sample_communication.py @@ -346,7 +346,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): ) 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())) @@ -354,7 +354,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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'goalie({goalie.unum()}): p={goalie.pos} b={goalie.body}' f'player({player.side()}{player.unum()}: {player.pos})') return True @@ -371,7 +371,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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]: diff --git a/base/tackle_generator.py b/base/tackle_generator.py index 6cb624f..12f9d3d 100644 --- a/base/tackle_generator.py +++ b/base/tackle_generator.py @@ -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,7 +90,7 @@ 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 @@ -246,7 +246,7 @@ def predict_opponent_reach_step(self, continue n_turn = 0 if opponent.body_count() > 1 else Tools.predict_player_turn_cycle(ptype, - opponent.body(), + opponent.body, opponent_speed, target_dist, (ball_pos - inertia_pos).th(), diff --git a/lib/action/basic_actions.py b/lib/action/basic_actions.py index 88ae7fd..3536bc2 100644 --- a/lib/action/basic_actions.py +++ b/lib/action/basic_actions.py @@ -32,7 +32,7 @@ def execute(self, agent: 'PlayerAgent'): 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: @@ -103,7 +103,7 @@ def execute(self, agent: 'PlayerAgent'): return False target_angle = (self._point - wm.ball().pos()).th() - target_rel_angle = target_angle - wm.self().body() + target_rel_angle = target_angle - wm.self().body # if agent.config().version() < 12.0: # if target_rel_angle.abs() < 90.0: @@ -113,7 +113,7 @@ 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)) diff --git a/lib/action/go_to_point.py b/lib/action/go_to_point.py index 9b07b19..8b288ae 100644 --- a/lib/action/go_to_point.py +++ b/lib/action/go_to_point.py @@ -52,7 +52,7 @@ def do_turn(self, agent): 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() + 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() @@ -75,7 +75,7 @@ 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 diff --git a/lib/action/hold_ball.py b/lib/action/hold_ball.py index 4aa24ac..08dd258 100644 --- a/lib/action/hold_ball.py +++ b/lib/action/hold_ball.py @@ -306,7 +306,7 @@ def evaluateKeepPoint(self, wm: 'WorldModel', score -= 25.0 if o.body_count() == 0: - opp_body = o.body() + opp_body = o.body elif o.vel.r() > 0.2: # o.velCount() <= 1 #and opp_body = o.vel.th() @@ -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) diff --git a/lib/action/intercept.py b/lib/action/intercept.py index 197145b..d28f61e 100644 --- a/lib/action/intercept.py +++ b/lib/action/intercept.py @@ -410,14 +410,14 @@ def do_inertia_dash(self, 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() 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 diff --git a/lib/action/intercept_self.py b/lib/action/intercept_self.py index a5c2ca7..281fe79 100644 --- a/lib/action/intercept_self.py +++ b/lib/action/intercept_self.py @@ -159,7 +159,7 @@ 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}") @@ -473,7 +473,7 @@ def predict_omni_dash_short(self, me = wm.self() 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) @@ -593,7 +593,7 @@ def predict_adjust_omni_dash(self, 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) @@ -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 @@ -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, @@ -1128,7 +1128,7 @@ def predict_final(self, max_cycle: int, self_cache: list): 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, diff --git a/lib/action/kick_table.py b/lib/action/kick_table.py index bab51b0..d6d35ed 100644 --- a/lib/action/kick_table.py +++ b/lib/action/kick_table.py @@ -652,7 +652,7 @@ def check_interfere_at(world: 'WorldModel', flag |= KICKABLE break - opp_body = o.body() if o.body_count() <= 1 else (state.pos_ - opp_next).th() + opp_body = o.body if o.body_count() <= 1 else (state.pos_ - opp_next).th() player_2_pos = Vector2D(state.pos_ - opp_next) player_2_pos.rotate(- opp_body) # @@ -762,7 +762,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) @@ -977,7 +977,7 @@ def simulate_three_step(self, world: 'WorldModel', 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: diff --git a/lib/action/neck_body_to_point.py b/lib/action/neck_body_to_point.py index 6f8710c..e37183c 100644 --- a/lib/action/neck_body_to_point.py +++ b/lib/action/neck_body_to_point.py @@ -28,7 +28,7 @@ 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() + 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.) diff --git a/lib/action/smart_kick.py b/lib/action/smart_kick.py index de06853..1cc432b 100644 --- a/lib/action/smart_kick.py +++ b/lib/action/smart_kick.py @@ -70,8 +70,8 @@ def execute(self, agent: 'PlayerAgent'): 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()) diff --git a/lib/action/turn_to_point.py b/lib/action/turn_to_point.py index 10623e5..2d7138e 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/debug/debug_client.py b/lib/debug/debug_client.py index bc72d62..5281ed8 100644 --- a/lib/debug/debug_client.py +++ b/lib/debug/debug_client.py @@ -38,7 +38,7 @@ def player_printer(p: 'PlayerObject', our_side: SideID): 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()))})" @@ -140,7 +140,7 @@ def to_str(self, world: 'WorldModel', effector): + 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().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()) diff --git a/lib/player/action_effector.py b/lib/player/action_effector.py index edfb831..c26cc2a 100644 --- a/lib/player/action_effector.py +++ b/lib/player/action_effector.py @@ -311,7 +311,7 @@ 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_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) @@ -334,7 +334,7 @@ def set_kick(self, power: float, rel_dir: Union[AngleDeg, float]): 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) + 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) @@ -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 @@ -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()): @@ -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 diff --git a/lib/player/world_model.py b/lib/player/world_model.py index 007572b..bbf4b60 100644 --- a/lib/player/world_model.py +++ b/lib/player/world_model.py @@ -266,7 +266,7 @@ def update_their_defense_line(self): 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: + 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()) From 81981bce21f9839e7a9ae799d900367300c2decc Mon Sep 17 00:00:00 2001 From: Aref Date: Wed, 16 Aug 2023 15:55:14 -0230 Subject: [PATCH 10/22] modifying lots of things obj.py --- base/bhv_move.py | 2 +- base/decision.py | 4 +- base/generator_dribble.py | 6 +- base/generator_pass.py | 8 +- base/generator_shoot.py | 24 ++-- base/goalie_decision.py | 2 +- base/sample_communication.py | 36 +++--- base/sample_player.py | 6 +- base/sample_trainer.py | 2 +- base/set_play/bhv_set_play.py | 8 +- base/stamina_manager.py | 2 +- base/tackle_generator.py | 2 +- base/tools.py | 2 +- base/view_tactical.py | 6 +- lib/action/basic_actions.py | 2 +- lib/action/hold_ball.py | 12 +- lib/action/intercept.py | 8 +- lib/action/intercept_player.py | 54 ++++---- lib/action/intercept_self.py | 2 +- lib/action/intercept_table.py | 8 +- lib/action/kick_table.py | 24 ++-- lib/action/neck_scan_field.py | 6 +- lib/action/neck_scan_players.py | 8 +- lib/action/neck_turn_to_ball.py | 8 +- lib/action/neck_turn_to_ball_or_scan.py | 4 +- lib/action/scan_field.py | 2 +- lib/action/stop_ball.py | 2 +- lib/player/action_effector.py | 4 +- lib/player/object_ball.py | 20 +-- lib/player/object_player.py | 4 +- lib/player/object_self.py | 22 ++-- lib/player/world_model.py | 158 ++++++++++++------------ 32 files changed, 229 insertions(+), 229 deletions(-) diff --git a/base/bhv_move.py b/base/bhv_move.py index ed9e9c5..e850625 100644 --- a/base/bhv_move.py +++ b/base/bhv_move.py @@ -63,7 +63,7 @@ def execute(self, agent: 'PlayerAgent'): 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 ede8096..d92e7d1 100644 --- a/base/decision.py +++ b/base/decision.py @@ -35,9 +35,9 @@ 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()} ' + 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'seen pos count {wm.ball().seen_pos_count} ' f'is? {wm.self()._kickable}') if wm.self().is_kickable(): return BhvKick().execute(agent) diff --git a/base/generator_dribble.py b/base/generator_dribble.py index aa5f22d..8e5a8a7 100644 --- a/base/generator_dribble.py +++ b/base/generator_dribble.py @@ -203,7 +203,7 @@ def check_opponent(self, wm: 'WorldModel', ball_trap_pos: Vector2D, dribble_step 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 @@ -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 072876a..8d7dc49 100644 --- a/base/generator_pass.py +++ b/base/generator_pass.py @@ -65,8 +65,8 @@ def update_receivers(self, wm: 'WorldModel'): 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') @@ -556,11 +556,11 @@ 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 diff --git a/base/generator_shoot.py b/base/generator_shoot.py index 020ed25..a8ee4e0 100644 --- a/base/generator_shoot.py +++ b/base/generator_shoot.py @@ -57,7 +57,7 @@ def generator(self, wm: 'WorldModel') -> ShootAction: def create_shoot(self, wm: 'WorldModel', target_point: Vector2D): 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 @@ -140,10 +140,10 @@ def check_shoot(self, wm: 'WorldModel', target_point: Vector2D, first_ball_speed 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 @@ -165,7 +165,7 @@ def maybe_goalie_catch(self, goalie: 'PlayerObject', course: ShootAction, wm: 'W return False goalie_speed = goalie.vel.r() - seen_dist_noise = goalie.dist_from_self() * 0.02 + seen_dist_noise = goalie.dist_from_self * 0.02 max_cycle = course.ball_reach_step for cycle in range(min_cycle, max_cycle): @@ -191,7 +191,7 @@ 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: @@ -201,8 +201,8 @@ def maybe_goalie_catch(self, goalie: 'PlayerObject', course: ShootAction, wm: 'W 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,7 +210,7 @@ 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 @@ -238,7 +238,7 @@ 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 @@ -248,7 +248,7 @@ def opponent_can_reach(self, opponent, course: ShootAction, wm: 'WorldModel'): 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 +257,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: diff --git a/base/goalie_decision.py b/base/goalie_decision.py index 16c234a..31c6f61 100644 --- a/base/goalie_decision.py +++ b/base/goalie_decision.py @@ -44,7 +44,7 @@ def decision(agent: 'PlayerAgent'): 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 wm.ball().dist_from_self < SP.catchable_area() - 0.05 and our_penalty.contains(wm.ball().pos())): agent.do_catch() diff --git a/base/sample_communication.py b/base/sample_communication.py index 3b49147..49dc01c 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 @@ -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,11 +128,11 @@ def should_say_opponent_goalie(self, agent: 'PlayerAgent'): if goalie is None: return False - if goalie.seen_pos_count() == 0 \ + 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 goalie.dist_from_self < 25. \ and 51. - 16. < goalie.pos.x() < 52.5 \ and goalie.pos.abs_y() < 20.: @@ -194,7 +194,7 @@ 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 @@ -325,12 +325,12 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): goalie: PlayerObject = wm.get_their_goalie() if goalie is not None \ - and goalie.seen_pos_count() == 0 \ + 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.dist_from_self < 25: if available_len >= Messenger.SIZES[Messenger.Types.GOALIE_PLAYER]: player: PlayerObject = None for p in send_players: @@ -420,7 +420,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): and p0.goalie() \ and p0.pos.x() > 53. - 16. \ and p0.pos.abs_y() < 20 \ - and p0.dist_from_self() < 25: + and p0.dist_from_self < 25: goalie_pos = p0.pos + p0.vel goalie_pos.assign( bound(53. - 16., goalie_pos.x(), 52.9), @@ -514,7 +514,7 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC for p in wm.teammates_from_self(): 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) @@ -568,8 +568,8 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC 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.: + 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') @@ -578,8 +578,8 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC 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.: + 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') @@ -588,8 +588,8 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC 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: + 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') diff --git a/base/sample_player.py b/base/sample_player.py index 1765726..62680d0 100644 --- a/base/sample_player.py +++ b/base/sample_player.py @@ -41,7 +41,7 @@ def do_preprocess(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): + 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 @@ -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 2eb5c3c..c153097 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_set_play.py b/base/set_play/bhv_set_play.py index f6a7603..1001f2a 100644 --- a/base/set_play/bhv_set_play.py +++ b/base/set_play/bhv_set_play.py @@ -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 @@ -124,14 +124,14 @@ def is_kicker(agent): 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: + 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: + 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: diff --git a/base/stamina_manager.py b/base/stamina_manager.py index 323e34b..728487e 100644 --- a/base/stamina_manager.py +++ b/base/stamina_manager.py @@ -33,7 +33,7 @@ def get_normal_dash_power(wm: 'WorldModel', s_recover_mode: bool): 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(): dash_power = SP.i().max_dash_power() diff --git a/base/tackle_generator.py b/base/tackle_generator.py index 12f9d3d..15eeffe 100644 --- a/base/tackle_generator.py +++ b/base/tackle_generator.py @@ -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): diff --git a/base/tools.py b/base/tools.py index 772c8f4..de459b3 100644 --- a/base/tools.py +++ b/base/tools.py @@ -73,7 +73,7 @@ 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()) + pos_count = min(10, player.pos_count, player.seen_pos_count()) max_speed = player.player_type().real_speed_max() * 0.8 d = 0. diff --git a/base/view_tactical.py b/base/view_tactical.py index 897cd59..affeb18 100644 --- a/base/view_tactical.py +++ b/base/view_tactical.py @@ -88,15 +88,15 @@ 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() 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 diff --git a/lib/action/basic_actions.py b/lib/action/basic_actions.py index 3536bc2..e3cded5 100644 --- a/lib/action/basic_actions.py +++ b/lib/action/basic_actions.py @@ -113,7 +113,7 @@ 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)) diff --git a/lib/action/hold_ball.py b/lib/action/hold_ball.py index 08dd258..fcbac11 100644 --- a/lib/action/hold_ball.py +++ b/lib/action/hold_ball.py @@ -160,9 +160,9 @@ def createKeepPoints(self, wm: 'WorldModel', candidates): 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 + 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())) @@ -277,9 +277,9 @@ def evaluateKeepPoint(self, wm: 'WorldModel', for o in wm.opponents_from_ball(): 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 @@ -472,9 +472,9 @@ def keepReverse(self, agent: 'PlayerAgent'): 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 + current_dir_diff_rate = (wm.ball().angle_from_self - wm.self().body()).abs() / 180.0 - current_dist_rate = (wm.ball().dist_from_self() + current_dist_rate = (wm.ball().dist_from_self - wm.self().player_type().player_size() - param.ball_size()) / wm.self().player_type().kickable_margin() diff --git a/lib/action/intercept.py b/lib/action/intercept.py index d28f61e..e586a88 100644 --- a/lib/action/intercept.py +++ b/lib/action/intercept.py @@ -102,7 +102,7 @@ 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) @@ -330,7 +330,7 @@ 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: @@ -365,7 +365,7 @@ def do_wait_turn(self, 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 -= 0.1 * wm.ball().seen_pos_count if target_dist > dist_buf: return False @@ -447,7 +447,7 @@ def do_inertia_dash(self, target_rel -= Vector2D(buf, 0) used_power = info.dash_power() - if (wm.ball().seen_pos_count() <= 2 + 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() diff --git a/lib/action/intercept_player.py b/lib/action/intercept_player.py index 6d9177e..99eb783 100644 --- a/lib/action/intercept_player.py +++ b/lib/action/intercept_player.py @@ -25,10 +25,10 @@ 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()) @@ -40,7 +40,7 @@ def predict(self, ServerParam.i().tackle_cycles() - player.tackle_count() - 2) min_cycle = max(0, - min_cycle - min(player.seen_pos_count(), + min_cycle - min(player.seen_pos_count, player.pos_count())) if min_cycle > max_cycle: return self.predict_final(player, player_type) @@ -73,13 +73,13 @@ 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) @@ -101,7 +101,7 @@ def predict_final(self, player: PlayerObject, player_type: PlayerType): dash_dist -= control_area if player.side() != wm.our_side(): - dash_dist -= player.dist_from_self() * 0.03 + dash_dist -= player.dist_from_self * 0.03 if dash_dist < 0: return ball_step @@ -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 @@ -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,7 +211,7 @@ 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, diff --git a/lib/action/intercept_self.py b/lib/action/intercept_self.py index 281fe79..0a458ee 100644 --- a/lib/action/intercept_self.py +++ b/lib/action/intercept_self.py @@ -56,7 +56,7 @@ def predict_one_step(self, self_cache): 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() \ + control_area: diff --git a/lib/action/intercept_table.py b/lib/action/intercept_table.py index 01603cf..8870129 100644 --- a/lib/action/intercept_table.py +++ b/lib/action/intercept_table.py @@ -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,7 +211,7 @@ 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() @@ -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,7 +261,7 @@ 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() diff --git a/lib/action/kick_table.py b/lib/action/kick_table.py index d6d35ed..9b1cbe1 100644 --- a/lib/action/kick_table.py +++ b/lib/action/kick_table.py @@ -473,8 +473,8 @@ def create_state_cache(self, world: 'WorldModel'): 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,7 +488,7 @@ 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().rpos.copy() self._current_state.pos_ = world.ball().pos.copy() self._current_state.kick_rate_ = world.self().kick_rate() @@ -623,11 +623,11 @@ def check_interfere_at(world: 'WorldModel', for o in OFB: 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 @@ -648,7 +648,7 @@ def check_interfere_at(world: 'WorldModel', # # 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 @@ -734,11 +734,11 @@ def check_interfere_after_release(self, *args): # , **kwargs):): for o in OFB: 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(): @@ -859,9 +859,9 @@ def simulate_two_step(self, world: 'WorldModel', target_point: Vector2D, first_s 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 + 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()) @@ -968,8 +968,8 @@ def simulate_three_step(self, world: 'WorldModel', 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() + 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()) diff --git a/lib/action/neck_scan_field.py b/lib/action/neck_scan_field.py index ad794a1..0945144 100644 --- a/lib/action/neck_scan_field.py +++ b/lib/action/neck_scan_field.py @@ -50,7 +50,7 @@ def execute(self, agent: 'PlayerAgent'): 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 @@ -71,7 +71,7 @@ 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) @@ -172,7 +172,7 @@ 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 diff --git a/lib/action/neck_scan_players.py b/lib/action/neck_scan_players.py index 3a0aa77..260ef7b 100644 --- a/lib/action/neck_scan_players.py +++ b/lib/action/neck_scan_players.py @@ -128,11 +128,11 @@ def calculate_score(wm: WorldModel, next_self_pos: Vector2D, left_angle: AngleDe 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 @@ -142,7 +142,7 @@ def calculate_score(wm: WorldModel, next_self_pos: Vector2D, left_angle: AngleDe 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 5c4636c..5ad739a 100644 --- a/lib/action/neck_turn_to_ball.py +++ b/lib/action/neck_turn_to_ball.py @@ -54,8 +54,8 @@ 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) @@ -64,10 +64,10 @@ def execute(self, agent: 'PlayerAgent'): 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()) diff --git a/lib/action/neck_turn_to_ball_or_scan.py b/lib/action/neck_turn_to_ball_or_scan.py index 48bb622..b8b3db3 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/scan_field.py b/lib/action/scan_field.py index 301b8fe..da9bb12 100644 --- a/lib/action/scan_field.py +++ b/lib/action/scan_field.py @@ -39,7 +39,7 @@ def find_ball(self, agent: 'PlayerAgent'): 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() + 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 if search_flag%2==1: diff --git a/lib/action/stop_ball.py b/lib/action/stop_ball.py index eaa3aff..3ac915a 100644 --- a/lib/action/stop_ball.py +++ b/lib/action/stop_ball.py @@ -67,7 +67,7 @@ def calcAccel(self, agent): 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 diff --git a/lib/player/action_effector.py b/lib/player/action_effector.py index c26cc2a..94a56ab 100644 --- a/lib/player/action_effector.py +++ b/lib/player/action_effector.py @@ -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()): @@ -690,7 +690,7 @@ 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() diff --git a/lib/player/object_ball.py b/lib/player/object_ball.py index 296c797..b2e874e 100644 --- a/lib/player/object_ball.py +++ b/lib/player/object_ball.py @@ -103,7 +103,7 @@ def update_by_last_cycle(self, act: 'ActionEffector', game_mode: GameMode): 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())): + and self.dist_from_self * 1.05 < SP.visible_distance())): self.pos_count = 1000 else: self.pos_count = 1 @@ -212,20 +212,20 @@ def update_by_game_mode(self, game_mode: GameMode): 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() + 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 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.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) @@ -277,7 +277,7 @@ def update_by_hear(self, self.vel_count =1 return - if self.pos_count > 0 and sender_to_ball_dist+ 1 < ServerParam.i().visible_distance() < self.dist_from_self(): + 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 diff --git a/lib/player/object_player.py b/lib/player/object_player.py index 3749108..d028b2f 100644 --- a/lib/player/object_player.py +++ b/lib/player/object_player.py @@ -97,8 +97,8 @@ def set_kickable(self, ika: bool): 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 + 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) diff --git a/lib/player/object_self.py b/lib/player/object_self.py index dc09457..4d10865 100644 --- a/lib/player/object_self.py +++ b/lib/player/object_self.py @@ -366,10 +366,10 @@ def update_ball_info(self, ball: BallObject): 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() @@ -379,17 +379,17 @@ def update_ball_info(self, ball: BallObject): 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: + 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) @@ -416,8 +416,8 @@ def update_kickable_state(self, 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): + 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): diff --git a/lib/player/world_model.py b/lib/player/world_model.py index bbf4b60..efa8103 100644 --- a/lib/player/world_model.py +++ b/lib/player/world_model.py @@ -33,11 +33,11 @@ def player_accuracy_value(p: PlayerObject): value += -1000 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() @@ -264,16 +264,16 @@ def update_their_defense_line(self): for it in self._opponents_from_ball: x = it.pos.x() - if it.vel_count() <= 1 and it.vel.x() > 0: + 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 -= speed_rate * min(10, it.pos_count - 1.5) else: 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 @@ -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): + 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 @@ -435,7 +435,7 @@ def get_first_player(self, 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 @@ -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] @@ -508,17 +508,17 @@ def estimate_ball_by_pos_diff(self, see: SeeParser, act: 'ActionEffector', rpos: 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): @@ -527,15 +527,15 @@ def estimate_ball_by_pos_diff(self, see: SeeParser, act: 'ActionEffector', rpos: 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()))) @@ -552,18 +552,18 @@ def estimate_ball_by_pos_diff(self, see: SeeParser, act: 'ActionEffector', rpos: 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))) @@ -619,11 +619,11 @@ def localize_ball(self, see: SeeParser, act: 'ActionEffector'): return if not self.self().pos_valid(): - if (self._prev_ball.rpos_count() == 0 + 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_err = rpos_err + self.self().vel_error tvel *= SP.ball_decay() tvel_err *= SP.ball_decay() @@ -632,17 +632,17 @@ def localize_ball(self, see: SeeParser, act: 'ActionEffector'): return pos = self.self().pos + rpos - pos_err = self.self().pos_error() + rpos_err + 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_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() + 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 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 @@ -710,11 +710,11 @@ def check_team_player(self, 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: @@ -732,11 +732,11 @@ def check_team_player(self, 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: @@ -792,11 +792,11 @@ def check_unknown_player(self, 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: @@ -812,11 +812,11 @@ def check_unknown_player(self, 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: @@ -832,11 +832,11 @@ def check_unknown_player(self, 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: @@ -1006,7 +1006,7 @@ def update_world_after_see(self, self.localize_players(see) self.update_player_type() - if self.self().pos_count() <= 10: + if self.self().pos_count <= 10: varea = ViewArea(self.self().view_width().width(), self.self().pos, self.self().face(), @@ -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): @@ -1263,7 +1263,7 @@ def update_goalie_by_hear(self): 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) @@ -1292,7 +1292,7 @@ def update_goalie_by_hear(self): 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: + if d < min_dist and d < o.pos_count * goalie_speed_max + o.dist_from_self * 0.06: min_dist = d goalie = o @@ -1454,13 +1454,13 @@ def update_players_by_hear(self): continue d = p.pos.dist(player.pos_) - if d < min_dist and p.pos_count()*1.2 + p.dist_from_self() *0.06: + 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: + 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 @@ -1592,7 +1592,7 @@ 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 @@ -1612,8 +1612,8 @@ def check_ghost(self, varea: ViewArea): 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() @@ -1720,7 +1720,7 @@ 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()): return True From ab5a9c065e10cf70037e8010043d32074f00d2fe Mon Sep 17 00:00:00 2001 From: Aref Date: Wed, 16 Aug 2023 15:58:35 -0230 Subject: [PATCH 11/22] modifying lots of things obj.py --- base/basic_tackle.py | 2 +- base/bhv_block.py | 2 +- base/generator_dribble.py | 6 +-- base/generator_pass.py | 42 +++++++++---------- base/generator_shoot.py | 12 +++--- base/goalie_decision.py | 2 +- base/sample_communication.py | 2 +- base/set_play/bhv_set_play.py | 4 +- base/set_play/bhv_set_play_before_kick_off.py | 2 +- base/tackle_generator.py | 2 +- lib/action/basic_actions.py | 2 +- lib/action/go_to_point.py | 2 +- lib/action/hold_ball.py | 6 +-- lib/action/intercept_self.py | 6 +-- lib/action/kick_table.py | 8 ++-- lib/action/stop_ball.py | 2 +- lib/player/object_self.py | 4 +- lib/player/player_agent.py | 2 +- lib/player/world_model.py | 10 ++--- 19 files changed, 59 insertions(+), 59 deletions(-) diff --git a/base/basic_tackle.py b/base/basic_tackle.py index 412db44..4730bc3 100644 --- a/base/basic_tackle.py +++ b/base/basic_tackle.py @@ -58,7 +58,7 @@ def execute(self, agent: 'PlayerAgent'): 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 ((SP.their_team_goal_pos() - wm.self().pos).th() - wm.self().body()).abs() < 45.)): return False diff --git a/base/bhv_block.py b/base/bhv_block.py index 25b7d58..38b47c7 100644 --- a/base/bhv_block.py +++ b/base/bhv_block.py @@ -30,7 +30,7 @@ def execute(self, agent: 'PlayerAgent'): 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) + 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: diff --git a/base/generator_dribble.py b/base/generator_dribble.py index 8e5a8a7..a0aac25 100644 --- a/base/generator_dribble.py +++ b/base/generator_dribble.py @@ -113,7 +113,7 @@ 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 + 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() @@ -194,7 +194,7 @@ 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) @@ -218,7 +218,7 @@ def check_opponent(self, wm: 'WorldModel', ball_trap_pos: Vector2D, dribble_step 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: diff --git a/base/generator_pass.py b/base/generator_pass.py index 8d7dc49..4bb7fa0 100644 --- a/base/generator_pass.py +++ b/base/generator_pass.py @@ -91,13 +91,13 @@ def generate_direct_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): 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 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() @@ -113,7 +113,7 @@ def generate_direct_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): 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 @@ -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 @@ -183,7 +183,7 @@ def generate_lead_pass(self, wm: 'WorldModel', receiver): move_dist_penalty_step = 0 ball_move_line = Line2D(wm.ball().pos, receive_point) - player_line_dist = ball_move_line.dist(receiver.pos()) + 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 \ @@ -222,7 +222,7 @@ def generate_lead_pass(self, wm: 'WorldModel', receiver): 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) @@ -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 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 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 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 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 @@ -289,7 +289,7 @@ 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): @@ -297,7 +297,7 @@ def generate_through_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): move_dist_penalty_step = 0 ball_move_line = Line2D(wm.ball().pos, receive_point) - player_line_dist = ball_move_line.dist(receiver.pos()) + 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 \ @@ -328,7 +328,7 @@ def generate_through_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): 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) @@ -363,7 +363,7 @@ 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: n_turn += 1 diff --git a/base/generator_shoot.py b/base/generator_shoot.py index a8ee4e0..642e764 100644 --- a/base/generator_shoot.py +++ b/base/generator_shoot.py @@ -27,8 +27,8 @@ 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 @@ -55,7 +55,7 @@ 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): # TODO and wm.dirCount( ball_move_angle ) > 3 @@ -130,7 +130,7 @@ def check_shoot(self, wm: 'WorldModel', target_point: Vector2D, first_ball_speed 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 @@ -272,7 +272,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 @@ -293,7 +293,7 @@ def evaluate_courses(self, wm: 'WorldModel'): 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 31c6f61..913ae9c 100644 --- a/base/goalie_decision.py +++ b/base/goalie_decision.py @@ -45,7 +45,7 @@ def decision(agent: 'PlayerAgent'): 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())): + 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 49dc01c..4881863 100644 --- a/base/sample_communication.py +++ b/base/sample_communication.py @@ -377,7 +377,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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 diff --git a/base/set_play/bhv_set_play.py b/base/set_play/bhv_set_play.py index 1001f2a..1ccd249 100644 --- a/base/set_play/bhv_set_play.py +++ b/base/set_play/bhv_set_play.py @@ -46,7 +46,7 @@ def execute(self, agent: 'PlayerAgent'): if tm is None: continue if tm.unum() == i: - dist = tm.pos.dist(wm.ball().pos()) + dist = tm.pos.dist(wm.ball().pos) if dist < nearest_tm_dist: nearest_tm_dist = dist nearest_tm = i @@ -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 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 dca191e..1992cc0 100644 --- a/base/set_play/bhv_set_play_before_kick_off.py +++ b/base/set_play/bhv_set_play_before_kick_off.py @@ -15,7 +15,7 @@ def execute(self, agent: 'PlayerAgent'): 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/tackle_generator.py b/base/tackle_generator.py index 15eeffe..4385275 100644 --- a/base/tackle_generator.py +++ b/base/tackle_generator.py @@ -155,7 +155,7 @@ def evaluate(self, wm, result: TackleAction): 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)) diff --git a/lib/action/basic_actions.py b/lib/action/basic_actions.py index e3cded5..fb8fbb2 100644 --- a/lib/action/basic_actions.py +++ b/lib/action/basic_actions.py @@ -102,7 +102,7 @@ def execute(self, agent: 'PlayerAgent'): if wm.self().tackle_probability() < self._min_prob: return False - target_angle = (self._point - wm.ball().pos()).th() + target_angle = (self._point - wm.ball().pos).th() target_rel_angle = target_angle - wm.self().body # if agent.config().version() < 12.0: diff --git a/lib/action/go_to_point.py b/lib/action/go_to_point.py index 8b288ae..6b8443d 100644 --- a/lib/action/go_to_point.py +++ b/lib/action/go_to_point.py @@ -128,7 +128,7 @@ def check_collision(self, agent): 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()): diff --git a/lib/action/hold_ball.py b/lib/action/hold_ball.py index fcbac11..6a4bd9f 100644 --- a/lib/action/hold_ball.py +++ b/lib/action/hold_ball.py @@ -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 @@ -289,7 +289,7 @@ def evaluateKeepPoint(self, wm: 'WorldModel', 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( + 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) @@ -361,7 +361,7 @@ 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() + 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 diff --git a/lib/action/intercept_self.py b/lib/action/intercept_self.py index 0a458ee..4b972a5 100644 --- a/lib/action/intercept_self.py +++ b/lib/action/intercept_self.py @@ -388,7 +388,7 @@ def predict_short_step(self, max_cycle, save_recovery, self_cache): 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())) @@ -562,7 +562,7 @@ def predict_omni_dash_short(self, 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() and not stamina_model.capacity_is_empty() @@ -1007,7 +1007,7 @@ def can_reach_after_dash(self, 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_rel = (ball_pos - wm.self().pos).rotated_vector(dash_angle_minus) ball_noise = (wm.ball().pos.dist(ball_pos) * SP.ball_rand() * 0.5) diff --git a/lib/action/kick_table.py b/lib/action/kick_table.py index 9b1cbe1..185e804 100644 --- a/lib/action/kick_table.py +++ b/lib/action/kick_table.py @@ -642,7 +642,7 @@ 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_ + o.goalie() and penalty_area.contains(o.pos) and penalty_area.contains(state.pos_ )) else o.player_type().kickable_area() # @@ -749,7 +749,7 @@ def check_interfere_after_release(self, *args): # , **kwargs):): 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( + o.goalie() and penalty_area.contains(o.pos) and penalty_area.contains( state.pos_)) else o.player_type().kickable_area() control_area += 0.1 @@ -804,7 +804,7 @@ 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 @@ -977,7 +977,7 @@ def simulate_three_step(self, world: 'WorldModel', 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: diff --git a/lib/action/stop_ball.py b/lib/action/stop_ball.py index 3ac915a..87083d9 100644 --- a/lib/action/stop_ball.py +++ b/lib/action/stop_ball.py @@ -39,7 +39,7 @@ 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()) + 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()), diff --git a/lib/player/object_self.py b/lib/player/object_self.py index 4d10865..c70486b 100644 --- a/lib/player/object_self.py +++ b/lib/player/object_self.py @@ -353,7 +353,7 @@ def set_pointto(self,point: Vector2D, done_time: GameTime): self.last_pointto_time = done_time if self.pos_valid(): - self.pointto_angle = (point - self.pos()).th() + self.pointto_angle = (point - self.pos).th() self.pointto_count = 0 def update_ball_info(self, ball: BallObject): @@ -394,7 +394,7 @@ def update_ball_info(self, ball: BallObject): 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 diff --git a/lib/player/player_agent.py b/lib/player/player_agent.py index 8c91620..811e69e 100644 --- a/lib/player/player_agent.py +++ b/lib/player/player_agent.py @@ -608,7 +608,7 @@ def action(self): 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("pos " + str(self.world().self().pos)) self.real_world().update_just_after_decision(self._effector) if self.full_world_exists(): diff --git a/lib/player/world_model.py b/lib/player/world_model.py index efa8103..9f33cf1 100644 --- a/lib/player/world_model.py +++ b/lib/player/world_model.py @@ -1101,17 +1101,17 @@ def update_player_state_cache(self): self._teammates_from_self, self._teammates_from_ball, self.self().pos, - self.ball().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.ball().pos) self.create_set_player(self._unknown_players, self._opponents_from_self, self._opponents_from_ball, self.self().pos, - self.ball().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()) @@ -1517,7 +1517,7 @@ def update_ball_by_hear(self, act: 'ActionEffector'): 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_ @@ -1722,6 +1722,6 @@ def exist_teammates_in(self, region: Region2D, count_thr: int, with_goalie: bool continue 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 From 336a70a47f53ffaf21179c366867b80a84e6b67d Mon Sep 17 00:00:00 2001 From: Aref Date: Wed, 16 Aug 2023 15:59:16 -0230 Subject: [PATCH 12/22] modifying lots of things obj.py --- base/generator_pass.py | 2 +- base/generator_shoot.py | 2 +- base/sample_communication.py | 8 ++++---- base/tools.py | 2 +- lib/action/kick_table.py | 2 +- lib/player/world_model.py | 4 ++-- 6 files changed, 10 insertions(+), 10 deletions(-) diff --git a/base/generator_pass.py b/base/generator_pass.py index 4bb7fa0..f0f1887 100644 --- a/base/generator_pass.py +++ b/base/generator_pass.py @@ -108,7 +108,7 @@ def generate_direct_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): # TODO SP.defaultRealSpeedMax() min_ball_speed = 1.0 - receive_point = ptype.inertiaFinalPoint(receiver.pos, receiver.vel()) + 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: diff --git a/base/generator_shoot.py b/base/generator_shoot.py index 642e764..13f8b7c 100644 --- a/base/generator_shoot.py +++ b/base/generator_shoot.py @@ -70,7 +70,7 @@ def create_shoot(self, wm: 'WorldModel', target_point: Vector2D): 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) diff --git a/base/sample_communication.py b/base/sample_communication.py index 4881863..0e3650c 100644 --- a/base/sample_communication.py +++ b/base/sample_communication.py @@ -349,7 +349,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): goalie.body, ( player.unum() if player.side() == wm.our_side() else player.unum() + 11), - player.pos + player.vel())) + player.pos + player.vel)) self.update_player_send_time(wm, goalie.side(), goalie.unum()) self.update_player_send_time(wm, player.side(), player.unum()) @@ -387,7 +387,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): send_players[1].number, p1.pos + p1.vel, send_players[2].number, - p2.pos + p2.vel())) + 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()) @@ -405,7 +405,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): agent.add_say_message(TwoPlayerMessenger(send_players[0].number, p0.pos + p0.vel, send_players[1].number, - p1.pos + p1.vel())) + p1.pos + p1.vel)) self.update_player_send_time(wm, p0.side(), p0.unum()) self.update_player_send_time(wm, p1.side(), p1.unum()) @@ -440,7 +440,7 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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()) diff --git a/base/tools.py b/base/tools.py index de459b3..4105f8f 100644 --- a/base/tools.py +++ b/base/tools.py @@ -40,7 +40,7 @@ def predict_kick_count(wm: 'WorldModel', kicker, first_ball_speed, ball_move_ang 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()) + 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: diff --git a/lib/action/kick_table.py b/lib/action/kick_table.py index 185e804..df61560 100644 --- a/lib/action/kick_table.py +++ b/lib/action/kick_table.py @@ -812,7 +812,7 @@ def simulate_one_step(self, world: 'WorldModel', target_point: Vector2D, first_s if accel_r > current_max_accel: max_vel = calc_max_velocity(target_vel.th(), self._current_state.kick_rate_, - world.ball().vel()) + world.ball().vel) accel = max_vel - world.ball().vel self._candidates.append(Sequence()) self._candidates[-1].flag_ = self._current_state.flag_ diff --git a/lib/player/world_model.py b/lib/player/world_model.py index 9f33cf1..beafa6a 100644 --- a/lib/player/world_model.py +++ b/lib/player/world_model.py @@ -543,7 +543,7 @@ def estimate_ball_by_pos_diff(self, see: SeeParser, act: 'ActionEffector', rpos: 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 @@ -571,7 +571,7 @@ def estimate_ball_by_pos_diff(self, see: SeeParser, act: 'ActionEffector', rpos: 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 From bb79b96b7477ae750a52df362ea9799ea95ddd0d Mon Sep 17 00:00:00 2001 From: Aref Date: Wed, 16 Aug 2023 16:03:20 -0230 Subject: [PATCH 13/22] modifying lots of things obj.py --- base/generator_clear.py | 2 +- base/sample_communication.py | 2 +- base/tackle_generator.py | 2 +- base/tools.py | 2 +- lib/action/intercept_player.py | 10 +++++----- lib/debug/debug_client.py | 10 +++++----- lib/player/world_model.py | 26 +++++++++++++------------- 7 files changed, 27 insertions(+), 27 deletions(-) diff --git a/base/generator_clear.py b/base/generator_clear.py index 856bfff..e9ecea6 100644 --- a/base/generator_clear.py +++ b/base/generator_clear.py @@ -79,7 +79,7 @@ def generate_clear_ball(self, wm: 'WorldModel'): 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 -= min(0, opp.pos_count) if opp_cycle <= c: receiver_opp = opp.unum() break diff --git a/base/sample_communication.py b/base/sample_communication.py index 0e3650c..5001114 100644 --- a/base/sample_communication.py +++ b/base/sample_communication.py @@ -554,7 +554,7 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC 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') diff --git a/base/tackle_generator.py b/base/tackle_generator.py index 4385275..3e57d02 100644 --- a/base/tackle_generator.py +++ b/base/tackle_generator.py @@ -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 4105f8f..da8ea82 100644 --- a/base/tools.py +++ b/base/tools.py @@ -73,7 +73,7 @@ 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()) + pos_count = min(10, player.pos_count, player.seen_pos_count) max_speed = player.player_type().real_speed_max() * 0.8 d = 0. diff --git a/lib/action/intercept_player.py b/lib/action/intercept_player.py index 99eb783..a72ad15 100644 --- a/lib/action/intercept_player.py +++ b/lib/action/intercept_player.py @@ -25,7 +25,7 @@ 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()) + 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) @@ -41,7 +41,7 @@ def predict(self, min_cycle = max(0, min_cycle - min(player.seen_pos_count, - player.pos_count())) + player.pos_count)) if min_cycle > max_cycle: return self.predict_final(player, player_type) @@ -73,7 +73,7 @@ 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()) + 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) @@ -187,7 +187,7 @@ 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()) + 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) @@ -215,7 +215,7 @@ def can_reach_after_dash(self, 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) diff --git a/lib/debug/debug_client.py b/lib/debug/debug_client.py index 5281ed8..2d2d0ab 100644 --- a/lib/debug/debug_client.py +++ b/lib/debug/debug_client.py @@ -142,8 +142,8 @@ def to_str(self, world: 'WorldModel', effector): + 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()) + + ' (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 += '"))' @@ -154,9 +154,9 @@ def to_str(self, world: 'WorldModel', effector): 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 += (' (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/player/world_model.py b/lib/player/world_model.py index beafa6a..4985d45 100644 --- a/lib/player/world_model.py +++ b/lib/player/world_model.py @@ -269,7 +269,7 @@ def update_their_defense_line(self): 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 @@ -358,7 +358,7 @@ def _set_teammates_from_ball(self): 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 @@ -389,7 +389,7 @@ def _set_teammates_from_self(self): 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 @@ -548,7 +548,7 @@ def estimate_ball_by_pos_diff(self, see: SeeParser, act: 'ActionEffector', rpos: 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 @@ -576,7 +576,7 @@ def estimate_ball_by_pos_diff(self, see: SeeParser, act: 'ActionEffector', rpos: 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 @@ -622,7 +622,7 @@ def localize_ball(self, see: SeeParser, act: 'ActionEffector'): 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 = (rpos - self._prev_ball.rpos) + self.self().last_move() tvel_err = rpos_err + self.self().vel_error tvel *= SP.ball_decay() @@ -1113,11 +1113,11 @@ def update_player_state_cache(self): 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() @@ -1597,7 +1597,7 @@ def check_ghost(self, varea: ViewArea): 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())) + - (0.12 * min(4, self.ball().pos_count)) - 0.25 )**2 From 98c2f681f6e89e7e122925d095382bef3571ccb8 Mon Sep 17 00:00:00 2001 From: Aref Date: Wed, 16 Aug 2023 16:09:56 -0230 Subject: [PATCH 14/22] ball and plyer .py --- base/basic_tackle.py | 6 +- base/bhv_block.py | 6 +- base/bhv_move.py | 2 +- base/decision.py | 4 +- base/generator_action.py | 8 +- base/generator_clear.py | 6 +- base/generator_dribble.py | 18 +- base/generator_pass.py | 110 +++++----- base/generator_shoot.py | 20 +- base/sample_communication.py | 134 ++++++------ base/sample_player.py | 4 +- base/set_play/bhv_goalie_set_play.py | 4 +- base/set_play/bhv_set_play.py | 40 ++-- base/set_play/bhv_set_play_before_kick_off.py | 2 +- base/stamina_manager.py | 6 +- base/strategy_formation.py | 2 +- base/tackle_generator.py | 4 +- base/tools.py | 6 +- base/view_tactical.py | 8 +- lib/action/basic_actions.py | 2 +- lib/action/go_to_point.py | 14 +- lib/action/hold_ball.py | 84 ++++---- lib/action/intercept.py | 28 +-- lib/action/intercept_player.py | 14 +- lib/action/intercept_self.py | 48 ++--- lib/action/intercept_table.py | 22 +- lib/action/kick_table.py | 50 ++--- lib/action/neck_body_to_point.py | 2 +- lib/action/neck_scan_field.py | 4 +- lib/action/neck_scan_players.py | 2 +- lib/action/neck_turn_to_ball.py | 4 +- lib/action/scan_field.py | 2 +- lib/action/smart_kick.py | 12 +- lib/action/stop_ball.py | 16 +- lib/coach/gloabl_world_model.py | 10 +- lib/debug/debug_client.py | 32 +-- lib/player/action_effector.py | 204 +++++++++--------- lib/player/object_self.py | 10 +- lib/player/player_agent.py | 12 +- lib/player/world_model.py | 168 +++++++-------- lib/rcsc/game_mode.py | 6 +- 41 files changed, 568 insertions(+), 568 deletions(-) diff --git a/base/basic_tackle.py b/base/basic_tackle.py index 4730bc3..647b792 100644 --- a/base/basic_tackle.py +++ b/base/basic_tackle.py @@ -26,7 +26,7 @@ def execute(self, agent: 'PlayerAgent'): use_foul = False tackle_prob = wm.self().tackle_probability() - if wm.self().card() == Card.NO_CARD \ + 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(): @@ -58,7 +58,7 @@ def execute(self, agent: 'PlayerAgent'): 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 ((SP.their_team_goal_pos() - wm.self().pos).th() - wm.self().body).abs() < 45.)): return False @@ -72,7 +72,7 @@ def executeV14(self, agent: 'PlayerAgent', use_foul: bool): 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 38b47c7..f734a43 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 e850625..a70f070 100644 --- a/base/bhv_move.py +++ b/base/bhv_move.py @@ -57,7 +57,7 @@ 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') diff --git a/base/decision.py b/base/decision.py index d92e7d1..2e19842 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 @@ -36,7 +36,7 @@ def get_decision(agent: 'PlayerAgent'): 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'ka {wm.self().player_type.kickable_area()} ' f'seen pos count {wm.ball().seen_pos_count} ' f'is? {wm.self()._kickable}') if wm.self().is_kickable(): diff --git a/base/generator_action.py b/base/generator_action.py index fe7ac34..a9ce951 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 e9ecea6..6928c53 100644 --- a/base/generator_clear.py +++ b/base/generator_clear.py @@ -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 = 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 a0aac25..21c974b 100644 --- a/base/generator_dribble.py +++ b/base/generator_dribble.py @@ -43,7 +43,7 @@ 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() @@ -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) @@ -115,7 +115,7 @@ def simulate_kick_turns_dashes(self, wm: 'WorldModel', dash_angle, n_turn): 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() + 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): @@ -139,7 +139,7 @@ def simulate_kick_turns_dashes(self, wm: 'WorldModel', dash_angle, n_turn): candidate.type = KickActionType.Dribble 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,7 +158,7 @@ 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() @@ -198,7 +198,7 @@ def check_opponent(self, wm: 'WorldModel', ball_trap_pos: Vector2D, dribble_step 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 @@ -208,10 +208,10 @@ def check_opponent(self, wm: 'WorldModel', ball_trap_pos: Vector2D, dribble_step 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()) @@ -237,7 +237,7 @@ 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, + n_turn = 1 if opp.body_count > 1 else Tools.predict_player_turn_cycle(ptype, opp.body, opp.vel.r(), target_dist, diff --git a/base/generator_pass.py b/base/generator_pass.py index f0f1887..0b13330 100644 --- a/base/generator_pass.py +++ b/base/generator_pass.py @@ -30,7 +30,7 @@ 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: # break @@ -59,11 +59,11 @@ 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}') @@ -74,10 +74,10 @@ def update_receivers(self, wm: 'WorldModel'): 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: + 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) @@ -86,22 +86,22 @@ def generate_direct_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): 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 + 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 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() @@ -113,7 +113,7 @@ def generate_direct_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): 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,7 +121,7 @@ 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() + ( @@ -134,7 +134,7 @@ def generate_direct_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): # 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, @@ -153,7 +153,7 @@ def generate_lead_pass(self, wm: 'WorldModel', receiver): max_player_distance = 35 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() @@ -189,35 +189,35 @@ def generate_lead_pass(self, wm: 'WorldModel', receiver): 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() \ 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] \ 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) 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, @@ -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, @@ -252,23 +252,23 @@ def generate_through_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): max_player_distance = 35 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 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 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 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 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() @@ -303,27 +303,27 @@ def generate_through_pass(self, wm: 'WorldModel', receiver: 'PlayerObject'): 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) 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, @@ -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,10 +347,10 @@ 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, + 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(), @@ -365,7 +365,7 @@ def predict_receiver_reach_step(self, receiver, pos: Vector2D, use_penalty, pass 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,7 +388,7 @@ 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.unum, receiver.pos, step, first_ball_speed)) @@ -400,7 +400,7 @@ 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.unum, receiver.pos, step, first_ball_speed)) @@ -414,7 +414,7 @@ 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.unum, receiver.pos, step, first_ball_speed, @@ -427,7 +427,7 @@ 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.unum, receiver.pos, step, first_ball_speed, @@ -435,7 +435,7 @@ def create_pass(self, wm: 'WorldModel', receiver, receive_point: Vector2D, 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, first_ball_speed, ball_move_angle, @@ -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, @@ -476,7 +476,7 @@ def create_pass(self, wm: 'WorldModel', receiver, receive_point: Vector2D, candidate.type = KickActionType.Pass 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,7 +520,7 @@ def predict_opponent_reach_step(self, wm: 'WorldModel', opp: 'PlayerObject', fir opponent = opp - ptype = opponent.player_type() + ptype = opponent.player_type min_cycle = Tools.estimate_min_reach_cycle(opponent.pos, ptype.real_speed_max(), first_ball_pos, ball_move_angle) @@ -564,7 +564,7 @@ def predict_opponent_reach_step(self, wm: 'WorldModel', opp: 'PlayerObject', fir continue n_turn = 0 - if opponent.body_count() > 1: + 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) diff --git a/base/generator_shoot.py b/base/generator_shoot.py index 13f8b7c..62e85a8 100644 --- a/base/generator_shoot.py +++ b/base/generator_shoot.py @@ -57,7 +57,7 @@ def generator(self, wm: 'WorldModel') -> ShootAction: def create_shoot(self, wm: 'WorldModel', target_point: Vector2D): 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) - 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,7 +117,7 @@ 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 opp.unum < 1: log.sw_log().shoot().add_text( '## opp {} can not, unum') continue if opp.is_tackling(): @@ -134,7 +134,7 @@ def check_shoot(self, wm: 'WorldModel', target_point: Vector2D, first_ball_speed 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') @@ -158,7 +158,7 @@ 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() + 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: @@ -194,7 +194,7 @@ def maybe_goalie_catch(self, goalie: 'PlayerObject', course: ShootAction, wm: 'W if n_dash > cycle + goalie.pos_count: continue n_turn = 0 - if goalie.body_count() <= 1: + 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 @@ -216,7 +216,7 @@ def maybe_goalie_catch(self, goalie: 'PlayerObject', course: ShootAction, wm: 'W 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, course.ball_move_angle) @@ -242,7 +242,7 @@ def opponent_can_reach(self, opponent, course: ShootAction, wm: 'WorldModel'): continue n_turn = 1 - if opponent.body_count() == 0: + 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 @@ -287,7 +287,7 @@ 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) ) diff --git a/base/sample_communication.py b/base/sample_communication.py index 5001114..94c8df8 100644 --- a/base/sample_communication.py +++ b/base/sample_communication.py @@ -129,9 +129,9 @@ def should_say_opponent_goalie(self, agent: 'PlayerAgent'): 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.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.: @@ -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 @@ -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 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 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)) @@ -293,19 +293,19 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): agent.add_say_message(BallGoalieMessenger(ef.queued_next_ball_pos(), ball_vel, goalie.pos + goalie.vel, - goalie.body())) + 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: @@ -313,12 +313,12 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): ball_vel, send_players[0].number, p.pos + p.vel, - p.body())) + 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: @@ -326,15 +326,15 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): if goalie is not None \ and goalie.seen_pos_count == 0 \ - and goalie.body_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.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 @@ -344,18 +344,18 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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, ( - player.unum() if player.side() == wm.our_side() else player.unum() + 11), + 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()) + 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]: @@ -364,14 +364,14 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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]: @@ -388,14 +388,14 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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()) + 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]: @@ -406,18 +406,18 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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()) + 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() \ + 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: @@ -426,14 +426,14 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): 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]: @@ -442,10 +442,10 @@ def say_ball_and_players(self, agent: 'PlayerAgent'): agent.add_say_message(OnePlayerMessenger(send_players[0].number, 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,7 +453,7 @@ 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 @@ -502,7 +502,7 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC 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: @@ -512,7 +512,7 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC 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.: break @@ -532,10 +532,10 @@ 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_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()) + agent.do_attentionto(wm.our_side(), target_teammate.unum) return if wm.self().attentionto_unum() > 0: @@ -550,53 +550,53 @@ 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 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_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()) + 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_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()) + agent.do_attentionto(wm.our_side(), nearest_teammate.unum) return if nearest_teammate is not None \ - and nearest_teammate.unum() != UNUM_UNKNOWN \ + 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_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()) + agent.do_attentionto(wm.our_side(), nearest_teammate.unum) return if nearest_teammate is not None \ - and nearest_teammate.unum() != 45. \ + 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_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()) + 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: @@ -622,7 +622,7 @@ 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 self._current_sender_unum == wm.self().unum \ and wm.self().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 62680d0..eb2019b 100644 --- a/base/sample_player.py +++ b/base/sample_player.py @@ -40,7 +40,7 @@ def do_preprocess(self): ScanField().execute(self) return True - count_thr = 10 if wm.self().goalie() else 5 + 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) @@ -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 diff --git a/base/set_play/bhv_goalie_set_play.py b/base/set_play/bhv_goalie_set_play.py index 5c14f6a..a9de921 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 diff --git a/base/set_play/bhv_set_play.py b/base/set_play/bhv_set_play.py index 1ccd249..eb8464d 100644 --- a/base/set_play/bhv_set_play.py +++ b/base/set_play/bhv_set_play.py @@ -31,26 +31,26 @@ 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: + 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(): + 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()) @@ -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 @@ -119,17 +119,17 @@ 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() + 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() + 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} (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: log.sw_log().team().add_text( "(is kicker) other kicker") @@ -137,7 +137,7 @@ def is_kicker(agent): 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 1992cc0..6931559 100644 --- a/base/set_play/bhv_set_play_before_kick_off.py +++ b/base/set_play/bhv_set_play_before_kick_off.py @@ -12,7 +12,7 @@ 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.: diff --git a/base/stamina_manager.py b/base/stamina_manager.py index 728487e..4933ba5 100644 --- a/base/stamina_manager.py +++ b/base/stamina_manager.py @@ -8,7 +8,7 @@ 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()) + return min(SP.i().max_dash_power(), wm.self().stamina() + wm.self().player_type.extra_stamina()) self_min = wm.intercept_table().self_reach_cycle() mate_min = wm.intercept_table().teammate_reach_cycle() @@ -23,11 +23,11 @@ def get_normal_dash_power(wm: 'WorldModel', s_recover_mode: bool): 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().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: + 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 diff --git a/base/strategy_formation.py b/base/strategy_formation.py index 2467bc4..666bfc5 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 3e57d02..51ce720 100644 --- a/base/tackle_generator.py +++ b/base/tackle_generator.py @@ -206,7 +206,7 @@ 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() @@ -245,7 +245,7 @@ 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, + n_turn = 0 if opponent.body_count > 1 else Tools.predict_player_turn_cycle(ptype, opponent.body, opponent_speed, target_dist, diff --git a/base/tools.py b/base/tools.py index da8ea82..79996a7 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: @@ -74,7 +74,7 @@ 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 + 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 affeb18..db59790 100644 --- a/base/view_tactical.py +++ b/base/view_tactical.py @@ -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 @@ -92,7 +92,7 @@ def get_default_view_width(self, agent: 'PlayerAgent'): if len(wm.opponents_from_ball()) > 0: 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 @@ -102,7 +102,7 @@ def get_default_view_width(self, agent: 'PlayerAgent'): 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 fb8fbb2..f87d030 100644 --- a/lib/action/basic_actions.py +++ b/lib/action/basic_actions.py @@ -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 diff --git a/lib/action/go_to_point.py b/lib/action/go_to_point.py index 6b8443d..acbb662 100644 --- a/lib/action/go_to_point.py +++ b/lib/action/go_to_point.py @@ -51,7 +51,7 @@ 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()) + 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() @@ -80,10 +80,10 @@ def do_dash(self, agent): 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) @@ -105,7 +105,7 @@ 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()) @@ -120,7 +120,7 @@ def check_collision(self, agent): 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) @@ -131,7 +131,7 @@ def check_collision(self, agent): 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 6a4bd9f..c300e48 100644 --- a/lib/action/hold_ball.py +++ b/lib/action/hold_ball.py @@ -114,8 +114,8 @@ def avoidOpponent(self, agent: 'PlayerAgent'): 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,25 +151,25 @@ 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_noise = wm.self().vel.r() * param.player_rand() - current_dir_diff_rate = (wm.ball().angle_from_self - wm.self().body()).abs() / 180.0 + 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())) 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 @@ -180,8 +180,8 @@ def createKeepPoints(self, wm: 'WorldModel', candidates): 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, @@ -193,7 +193,7 @@ def createKeepPoints(self, wm: 'WorldModel', candidates): 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() + 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, @@ -219,19 +219,19 @@ def createKeepPoints(self, wm: 'WorldModel', candidates): 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() + 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, @@ -275,7 +275,7 @@ def evaluateKeepPoint(self, wm: 'WorldModel', 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: break @@ -286,11 +286,11 @@ def evaluateKeepPoint(self, wm: 'WorldModel', if o.is_tackling(): continue - player_type = o.player_type() + 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() + 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,7 +305,7 @@ def evaluateKeepPoint(self, wm: 'WorldModel', score -= 25.0 - if o.body_count() == 0: + if o.body_count == 0: opp_body = o.body elif o.vel.r() > 0.2: # o.velCount() <= 1 #and @@ -362,9 +362,9 @@ def evaluateKeepPoint(self, wm: 'WorldModel', score -= 10.0 ball_move_dist = (keep_point - wm.ball().pos).r() - if ball_move_dist > wm.self().player_type().kickable_area() * 1.6: + 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 @@ -392,7 +392,7 @@ def turnToPoint(self, agent: 'PlayerAgent'): 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)): @@ -428,11 +428,11 @@ 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 - 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): @@ -440,7 +440,7 @@ def keepFront(self, agent: 'PlayerAgent'): ball_move = front_pos - wm.ball().pos kick_accel = ball_move - wm.ball().vel - kick_power = kick_accel.r() / wm.self().kick_rate() + 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 """ @@ -472,22 +472,22 @@ def keepReverse(self, agent: 'PlayerAgent'): 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 + 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.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())) 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: @@ -500,27 +500,27 @@ def keepReverse(self, agent: 'PlayerAgent'): ball_move = keep_pos - wm.ball().pos kick_accel = ball_move - wm.ball().vel - kick_power = kick_accel.r() / wm.self().kick_rate() + 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 e586a88..fe81954 100644 --- a/lib/action/intercept.py +++ b/lib/action/intercept.py @@ -72,7 +72,7 @@ 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 @@ -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() @@ -177,13 +177,13 @@ def get_best_intercept(self, wm: 'WorldModel', 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: @@ -290,7 +290,7 @@ def get_best_intercept(self, wm: 'WorldModel', 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 @@ -337,7 +337,7 @@ def do_wait_turn(self, 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(), @@ -360,11 +360,11 @@ 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 = wm.self().player_type.kickable_area() - 0.3 + extra_buf dist_buf -= 0.1 * wm.ball().seen_pos_count if target_dist > dist_buf: @@ -384,7 +384,7 @@ def do_wait_turn(self, 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,21 +401,21 @@ 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.rotate(-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() + if ((not wm.self().goalie or wm.last_kicker_side() == wm.our_side()) and wm.self().body.abs() < 50): buf = 0.3 @@ -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()) diff --git a/lib/action/intercept_player.py b/lib/action/intercept_player.py index a72ad15..e5875c9 100644 --- a/lib/action/intercept_player.py +++ b/lib/action/intercept_player.py @@ -37,7 +37,7 @@ def predict(self, 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, @@ -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()) @@ -85,7 +85,7 @@ def predict_final(self, player: PlayerObject, player_type: PlayerType): 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,7 +100,7 @@ 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(): + if player.side != wm.our_side(): dash_dist -= player.dist_from_self * 0.03 if dash_dist < 0: @@ -108,7 +108,7 @@ def predict_final(self, player: PlayerObject, player_type: PlayerType): 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) @@ -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): @@ -218,7 +218,7 @@ def can_reach_after_dash(self, 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 4b972a5..8175c7d 100644 --- a/lib/action/intercept_self.py +++ b/lib/action/intercept_self.py @@ -51,14 +51,14 @@ def predict_one_step(self, self_cache): wm = self._wm 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 > \ 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): @@ -74,10 +74,10 @@ def predict_no_dash(self, self_cache) -> bool: 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()) + 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() @@ -89,7 +89,7 @@ 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.simulate_wait(me.player_type) self_cache.append(InterceptInfo(InterceptInfo.Mode.NORMAL, 1, 0, @@ -101,7 +101,7 @@ 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()) @@ -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,7 +141,7 @@ 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 goalie_mode: bool = self.is_goalie_mode(ball_next) @@ -306,7 +306,7 @@ def predict_one_dash_adjust(self, my_pos = me.pos + my_vel stamina_model = me.stamina_model() - stamina_model.simulate_dash(me.player_type(), dash_power) + 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,7 +383,7 @@ 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 @@ -471,7 +471,7 @@ 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.copy() my_inertia = me.inertia_point(cycle) @@ -588,7 +588,7 @@ 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) @@ -678,7 +678,7 @@ 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 @@ -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) @@ -817,7 +817,7 @@ 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 @@ -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 @@ -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,7 +974,7 @@ 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() + total_recover = (wm.self().player_type.stamina_inc_max() * wm.self().recovery() * (cycle - 1)) result_stamina = (wm.self().stamina() @@ -1001,7 +1001,7 @@ 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() @@ -1122,7 +1122,7 @@ 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) diff --git a/lib/action/intercept_table.py b/lib/action/intercept_table.py index 8870129..760f5f5 100644 --- a/lib/action/intercept_table.py +++ b/lib/action/intercept_table.py @@ -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 = [] @@ -214,15 +214,15 @@ def predict_opponent(self, wm: 'WorldModel'): 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: @@ -264,19 +264,19 @@ def predict_teammate(self, wm: 'WorldModel'): 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 df61560..ff76206 100644 --- a/lib/action/kick_table.py +++ b/lib/action/kick_table.py @@ -468,7 +468,7 @@ 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) @@ -490,7 +490,7 @@ def create_state_cache(self, world: 'WorldModel'): # 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._current_state.kick_rate_ = world.self().kick_rate self.check_interfere_at(world, self._current_state) # 0 @@ -512,7 +512,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 +526,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 +541,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,7 +561,7 @@ 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) @@ -621,7 +621,7 @@ 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: continue @@ -641,9 +641,9 @@ 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 @@ -652,7 +652,7 @@ def check_interfere_at(world: 'WorldModel', flag |= KICKABLE break - opp_body = o.body if o.body_count() <= 1 else (state.pos_ - opp_next).th() + opp_body = o.body if o.body_count <= 1 else (state.pos_ - opp_next).th() player_2_pos = Vector2D(state.pos_ - opp_next) player_2_pos.rotate(- opp_body) # @@ -669,7 +669,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,7 +732,7 @@ 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: continue @@ -745,12 +745,12 @@ def check_interfere_after_release(self, *args): # , **kwargs):): 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 +762,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 +774,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 @@ -851,7 +851,7 @@ 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) @@ -859,7 +859,7 @@ def simulate_two_step(self, world: 'WorldModel', target_point: Vector2D, first_s 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 + 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() @@ -897,7 +897,7 @@ def simulate_two_step(self, world: 'WorldModel', target_point: Vector2D, first_s 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,12 +963,12 @@ 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_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()) @@ -1027,7 +1027,7 @@ def simulate_three_step(self, world: 'WorldModel', 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_point.py b/lib/action/neck_body_to_point.py index e37183c..c4ae023 100644 --- a/lib/action/neck_body_to_point.py +++ b/lib/action/neck_body_to_point.py @@ -35,7 +35,7 @@ def execute(self, agent: 'PlayerAgent'): 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 0945144..a003508 100644 --- a/lib/action/neck_scan_field.py +++ b/lib/action/neck_scan_field.py @@ -71,12 +71,12 @@ 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 diff --git a/lib/action/neck_scan_players.py b/lib/action/neck_scan_players.py index 260ef7b..3916b44 100644 --- a/lib/action/neck_scan_players.py +++ b/lib/action/neck_scan_players.py @@ -138,7 +138,7 @@ def calculate_score(wm: WorldModel, next_self_pos: Vector2D, left_angle: AngleDe 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 diff --git a/lib/action/neck_turn_to_ball.py b/lib/action/neck_turn_to_ball.py index 5ad739a..6c10da4 100644 --- a/lib/action/neck_turn_to_ball.py +++ b/lib/action/neck_turn_to_ball.py @@ -54,8 +54,8 @@ 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) diff --git a/lib/action/scan_field.py b/lib/action/scan_field.py index da9bb12..aba0037 100644 --- a/lib/action/scan_field.py +++ b/lib/action/scan_field.py @@ -41,7 +41,7 @@ def find_ball(self, agent: 'PlayerAgent'): 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. diff --git a/lib/action/smart_kick.py b/lib/action/smart_kick.py index 1cc432b..ff8de78 100644 --- a/lib/action/smart_kick.py +++ b/lib/action/smart_kick.py @@ -70,14 +70,14 @@ def execute(self, agent: 'PlayerAgent'): 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 87083d9..42be3bc 100644 --- a/lib/action/stop_ball.py +++ b/lib/action/stop_ball.py @@ -40,10 +40,10 @@ def execute(self, agent: 'PlayerAgent'): 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() + 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,20 +59,20 @@ 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 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.set_length(target_dist) @@ -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() @@ -102,7 +102,7 @@ def calcAccel(self, agent): 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/coach/gloabl_world_model.py b/lib/coach/gloabl_world_model.py index cea117f..3093ca9 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 2d2d0ab..dd7a0ff 100644 --- a/lib/debug/debug_client.py +++ b/lib/debug/debug_client.py @@ -15,22 +15,22 @@ 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: @@ -40,8 +40,8 @@ def player_printer(p: 'PlayerObject', our_side: SideID): if p.body_valid(): 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 @@ -134,8 +134,8 @@ def to_str(self, world: 'WorldModel', effector): 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(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)) + ' ' \ @@ -143,8 +143,8 @@ def to_str(self, world: 'WorldModel', effector): + 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().vel_count) + ' ' + str(world.self().face_count) + if world.self().card == Card.YELLOW: ostr_player += 'y' ostr_player += '"))' diff --git a/lib/player/action_effector.py b/lib/player/action_effector.py index 94a56ab..23d4fde 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,73 +228,73 @@ 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.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 self._tackle_dir = 0 self._tackle_foul = False - self._command_counter[CommandType.TACKLE.value] = body_sensor.tackle_count() + 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() + 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}") @@ -312,7 +312,7 @@ 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_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(), + 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() + 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) @@ -379,12 +379,12 @@ def set_turn(self, moment: Union[AngleDeg, float]): wm = self._agent.world() 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) @@ -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,12 +454,12 @@ 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 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() self._turn_neck_moment = moment @@ -482,7 +482,7 @@ def set_pointto(self, x, y): target = Vector2D(x,y) target = target - wm.self().pos - target.rotate(-wm.self().face()) + target.rotate(-wm.self().face) self._pointto_command = PlayerPointtoCommand(target.r(), target.th()) return self._pointto_command @@ -647,8 +647,8 @@ def queued_next_self_pos(self) -> Vector2D: vel += accel tmp = vel.r() - if tmp > me.player_type().player_speed_max(): - vel *= me.player_type().player_speed_max() / tmp + 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): @@ -696,7 +696,7 @@ def queued_next_ball_kickable(self): 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/object_self.py b/lib/player/object_self.py index c70486b..9d11ec0 100644 --- a/lib/player/object_self.py +++ b/lib/player/object_self.py @@ -343,7 +343,7 @@ def update_self_after_sense_body(self, sense_body: SenseBodyParser, act: ActionE 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.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()) @@ -535,7 +535,7 @@ def __str__(self): 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 @@ -543,14 +543,14 @@ def __str__(self): 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 if not self.collision_estimated: - new_last_move = self.vel / self.player_type().player_decay() + 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() @@ -564,7 +564,7 @@ def __str__(self): 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.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 811e69e..a1bd3f7 100644 --- a/lib/player/player_agent.py +++ b/lib/player/player_agent.py @@ -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: @@ -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 @@ -491,7 +491,7 @@ 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 @@ -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,7 +607,7 @@ 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("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) diff --git a/lib/player/world_model.py b/lib/player/world_model.py index 4985d45..8c6fe7d 100644 --- a/lib/player/world_model.py +++ b/lib/player/world_model.py @@ -29,9 +29,9 @@ 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 return value @@ -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 @@ -265,8 +265,8 @@ def update_their_defense_line(self): 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 += 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) @@ -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,7 +353,7 @@ 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) @@ -384,7 +384,7 @@ 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) @@ -432,7 +432,7 @@ 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: @@ -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 @@ -611,7 +611,7 @@ 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, self.self().face_error(), self.self().view_width()) @@ -620,7 +620,7 @@ def localize_ball(self, see: SeeParser, act: 'ActionEffector'): 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 + 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 @@ -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,7 +707,7 @@ 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 @@ -717,7 +717,7 @@ def check_team_player(self, 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,7 +728,7 @@ 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 @@ -739,7 +739,7 @@ def check_team_player(self, 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,9 +787,9 @@ 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 @@ -799,7 +799,7 @@ def check_unknown_player(self, 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,9 +807,9 @@ 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 @@ -819,7 +819,7 @@ def check_unknown_player(self, 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,9 +827,9 @@ 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 @@ -839,7 +839,7 @@ def check_unknown_player(self, 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: @@ -891,7 +891,7 @@ def localize_players(self, see: SeeParser): my_pos = self.self().pos my_vel = self.self().vel - my_face = self.self().face() + my_face = self.self().face my_face_err = self.self().face_error() for p in see.opponents() + see.unknown_opponents(): @@ -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: @@ -1009,24 +1009,24 @@ def update_world_after_see(self, if self.self().pos_count <= 10: varea = ViewArea(self.self().view_width().width(), self.self().pos, - self.self().face(), + 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().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}]') @@ -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()): @@ -1253,28 +1253,28 @@ def update_goalie_by_hear(self): # TODO CHECK FULL STATE TIME log.sw_log().world().add_text(f'{"#"*20} UPDATE GOALIE BY HEAR {"#"*20}') - if self._messenger_memory.goalie_time() != self.time() or len(self._messenger_memory.goalie()) == 0: + if self._messenger_memory.goalie_time() != self.time() or len(self._messenger_memory.goalie) == 0: return 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) heard_body = 0. - for g in self._messenger_memory.goalie(): + for g in self._messenger_memory.goalie: heard_pos += g.pos_ heard_body += AngleDeg(g.body_).degree() - heard_body /= len(self._messenger_memory.goalie()) - heard_pos /= len(self._messenger_memory.goalie()) + heard_body /= len(self._messenger_memory.goalie) + heard_pos /= len(self._messenger_memory.goalie) if goalie is not None: goalie.update_by_hear(self.their_side(), self._their_goalie_unum,True, heard_pos, heard_body) @@ -1286,7 +1286,7 @@ 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(): continue @@ -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,21 +1436,21 @@ 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_) @@ -1512,7 +1512,7 @@ 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 @@ -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 @@ -1595,7 +1595,7 @@ def check_ghost(self, varea: ViewArea): 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.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 @@ -1606,14 +1606,14 @@ def check_ghost(self, varea: ViewArea): 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.unum == UNUM_UNKNOWN and p.pos_count >= 10 and p.ghost_count >= 2: removing_teammates.append(p) continue p.set_ghost() @@ -1623,7 +1623,7 @@ 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.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}') @@ -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) diff --git a/lib/rcsc/game_mode.py b/lib/rcsc/game_mode.py index 9600b87..eabe3e1 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 From b4f68f5c072e641fe4de7bb387f477c36294ac96 Mon Sep 17 00:00:00 2001 From: Aref Date: Thu, 17 Aug 2023 10:37:39 -0230 Subject: [PATCH 15/22] fix last_move bug --- lib/player/object_self.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/lib/player/object_self.py b/lib/player/object_self.py index 9d11ec0..fe7f126 100644 --- a/lib/player/object_self.py +++ b/lib/player/object_self.py @@ -48,7 +48,7 @@ def __init__(self, player: PlayerObject = None): self.catch_probability: float = 0 self.tackle_probability: float = 0 self.foul_probability: float = 0 - self._last_move: Vector2D = Vector2D(0, 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 @@ -95,7 +95,7 @@ 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 + return self.last_move_ def is_kicking(self): return self.kicking @@ -171,8 +171,8 @@ def update_by_last_cycle(self, act: ActionEffector, current_time: GameTime): 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.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 @@ -216,7 +216,7 @@ def update_vel_dir_after_see(self, sense: SenseBodyParser, current_time: GameTim 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()) + 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() @@ -330,9 +330,9 @@ def update_self_after_sense_body(self, sense_body: SenseBodyParser, act: ActionE 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()) + 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() @@ -477,7 +477,7 @@ def long_str(self): 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_move: {self.last_move_}, ' \ f'last_moves: {self.last_moves}, ' \ f'arm_movable: {self.arm_movable}, ' return res @@ -551,9 +551,9 @@ def __str__(self): 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()) + 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() From 7cd50b5600ded1085561b520716dc322500d5659 Mon Sep 17 00:00:00 2001 From: Aref Date: Thu, 17 Aug 2023 11:01:13 -0230 Subject: [PATCH 16/22] obj self () -> --- base/basic_tackle.py | 2 +- base/generator_dribble.py | 2 +- base/sample_communication.py | 2 +- base/stamina_manager.py | 4 ++-- base/tackle_generator.py | 2 +- base/view_tactical.py | 2 +- lib/action/basic_actions.py | 6 +++--- lib/action/go_to_point.py | 2 +- lib/action/intercept.py | 2 +- lib/action/intercept_self.py | 18 +++++++++--------- lib/action/neck_scan_field.py | 8 ++++---- lib/action/neck_scan_players.py | 2 +- lib/action/neck_turn_to_ball.py | 8 ++++---- lib/action/neck_turn_to_point.py | 2 +- lib/action/neck_turn_to_relative.py | 2 +- lib/action/scan_field.py | 4 ++-- lib/debug/debug_client.py | 2 +- lib/player/action_effector.py | 10 +++++----- lib/player/object_self.py | 7 +++++-- lib/player/player_agent.py | 16 ++++++++-------- lib/player/world_model.py | 20 ++++++++++---------- 21 files changed, 63 insertions(+), 60 deletions(-) diff --git a/base/basic_tackle.py b/base/basic_tackle.py index 647b792..0dadf91 100644 --- a/base/basic_tackle.py +++ b/base/basic_tackle.py @@ -24,7 +24,7 @@ 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 diff --git a/base/generator_dribble.py b/base/generator_dribble.py index 21c974b..ce90e0c 100644 --- a/base/generator_dribble.py +++ b/base/generator_dribble.py @@ -162,7 +162,7 @@ def create_self_cache(self, wm: 'WorldModel', dash_angle, n_turn, n_dash, self_c self_cache.clear() - stamina_model = wm.self().stamina_model() + stamina_model = wm.self().stamina_model.copy() my_pos = wm.self().pos.copy() my_vel = wm.self().vel.copy() diff --git a/base/sample_communication.py b/base/sample_communication.py index 94c8df8..3d5fc72 100644 --- a/base/sample_communication.py +++ b/base/sample_communication.py @@ -538,7 +538,7 @@ def attention_to_someone(self, agent: 'PlayerAgent'): # TODO IMP FUNC 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() diff --git a/base/stamina_manager.py b/base/stamina_manager.py index 4933ba5..97937ae 100644 --- a/base/stamina_manager.py +++ b/base/stamina_manager.py @@ -7,7 +7,7 @@ def get_normal_dash_power(wm: 'WorldModel', s_recover_mode: bool): - if wm.self().stamina_model().capacity_is_empty(): + if wm.self().stamina_model.capacity_is_empty(): return min(SP.i().max_dash_power(), wm.self().stamina() + wm.self().player_type.extra_stamina()) self_min = wm.intercept_table().self_reach_cycle() @@ -15,7 +15,7 @@ def get_normal_dash_power(wm: 'WorldModel', s_recover_mode: bool): 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: s_recover_mode = True diff --git a/base/tackle_generator.py b/base/tackle_generator.py index 51ce720..2dda076 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: diff --git a/base/view_tactical.py b/base/view_tactical.py index db59790..00689a6 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() diff --git a/lib/action/basic_actions.py b/lib/action/basic_actions.py index f87d030..cc6ea1f 100644 --- a/lib/action/basic_actions.py +++ b/lib/action/basic_actions.py @@ -99,7 +99,7 @@ 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() @@ -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 acbb662..5a5a922 100644 --- a/lib/action/go_to_point.py +++ b/lib/action/go_to_point.py @@ -53,7 +53,7 @@ def do_turn(self, agent): 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: + 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: diff --git a/lib/action/intercept.py b/lib/action/intercept.py index fe81954..2069a53 100644 --- a/lib/action/intercept.py +++ b/lib/action/intercept.py @@ -77,7 +77,7 @@ def execute(self, agent: 'PlayerAgent'): 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 diff --git a/lib/action/intercept_self.py b/lib/action/intercept_self.py index 8175c7d..e124f6a 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) @@ -88,7 +88,7 @@ def predict_no_dash(self, self_cache) -> bool: # if goalie immediately success if goalie_mode: - stamina_model: StaminaModel = me.stamina_model() + stamina_model: StaminaModel = me.stamina_model.copy() stamina_model.simulate_wait(me.player_type) self_cache.append(InterceptInfo(InterceptInfo.Mode.NORMAL, @@ -111,7 +111,7 @@ def predict_no_dash(self, self_cache) -> bool: 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, @@ -305,7 +305,7 @@ def predict_one_dash_adjust(self, my_vel = me.vel + accel my_pos = me.pos + my_vel - stamina_model = me.stamina_model() + 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 \ @@ -504,7 +504,7 @@ def predict_omni_dash_short(self, first_dash_power = 0 my_pos = me.pos.copy() my_vel = me.vel.copy() - stamina_model = me.stamina_model() + stamina_model = me.stamina_model.copy() n_omni_dash, first_dash_power = self.predict_adjust_omni_dash(cycle, ball_pos, @@ -564,7 +564,7 @@ def predict_omni_dash_short(self, 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(): 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, @@ -687,7 +687,7 @@ def predict_dash_cycle_short(self, my_pos = me.inertia_point(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: @@ -1023,7 +1023,7 @@ def can_reach_after_dash(self, 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() @@ -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/neck_scan_field.py b/lib/action/neck_scan_field.py index a003508..043bb18 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,7 +44,7 @@ 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 @@ -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() @@ -80,7 +80,7 @@ def execute(self, agent: 'PlayerAgent'): 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 diff --git a/lib/action/neck_scan_players.py b/lib/action/neck_scan_players.py index 3916b44..816c0a2 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 diff --git a/lib/action/neck_turn_to_ball.py b/lib/action/neck_turn_to_ball.py index 6c10da4..5efefc9 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 @@ -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_point.py b/lib/action/neck_turn_to_point.py index 2e3ea01..cf48ec9 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 567d9b7..38ea6df 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 aba0037..def77d3 100644 --- a/lib/action/scan_field.py +++ b/lib/action/scan_field.py @@ -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/debug/debug_client.py b/lib/debug/debug_client.py index dd7a0ff..467a1a5 100644 --- a/lib/debug/debug_client.py +++ b/lib/debug/debug_client.py @@ -141,7 +141,7 @@ def to_str(self, world: 'WorldModel', effector): + 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)) \ + + 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: diff --git a/lib/player/action_effector.py b/lib/player/action_effector.py index 23d4fde..004dc22 100644 --- a/lib/player/action_effector.py +++ b/lib/player/action_effector.py @@ -457,11 +457,11 @@ def set_turn_neck(self, moment: Union[AngleDeg, float]): 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}) \ 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)) @@ -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 diff --git a/lib/player/object_self.py b/lib/player/object_self.py index fe7f126..693b4b7 100644 --- a/lib/player/object_self.py +++ b/lib/player/object_self.py @@ -31,7 +31,6 @@ def __init__(self, player: PlayerObject = None): 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() @@ -51,6 +50,10 @@ def __init__(self, player: PlayerObject = None): 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): @@ -460,7 +463,7 @@ def long_str(self): 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_movable: {self.arm_movable}, ' \ f'arm_expires: {self.arm_expires}, ' \ f'pointto_rpos: {self.pointto_rpos}, ' \ f'pointto_pos: {self.pointto_pos}, ' \ diff --git a/lib/player/player_agent.py b/lib/player/player_agent.py index a1bd3f7..c05ae1c 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) @@ -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: @@ -495,7 +495,7 @@ def do_attentionto(self, side: SideID, unum: int): # 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 @@ -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/world_model.py b/lib/player/world_model.py index 8c6fe7d..308ca2b 100644 --- a/lib/player/world_model.py +++ b/lib/player/world_model.py @@ -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: @@ -612,8 +612,8 @@ def localize_ball(self, see: SeeParser, act: 'ActionEffector'): 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_error, + self.self().view_width) if rpos is None or not rpos.is_valid(): return @@ -892,10 +892,10 @@ def localize_players(self, see: SeeParser): my_pos = self.self().pos my_vel = self.self().vel my_face = self.self().face - my_face_err = self.self().face_error() + 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: @@ -1007,7 +1007,7 @@ def update_world_after_see(self, self.update_player_type() if self.self().pos_count <= 10: - varea = ViewArea(self.self().view_width().width(), + varea = ViewArea(self.self().view_width.width(), self.self().pos, self.self().face, current_time) @@ -1025,7 +1025,7 @@ def update_world_after_sense_body(self, body_sensor: SenseBodyParser, act: 'Acti 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_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}]') From 627956ee482f0512526621789774cad7116260ab Mon Sep 17 00:00:00 2001 From: Aref Date: Thu, 17 Aug 2023 12:03:10 -0230 Subject: [PATCH 17/22] it runs, has bugs tho --- base/decision.py | 2 +- base/goalie_decision.py | 2 +- base/sample_communication.py | 6 +++--- base/set_play/bhv_goalie_set_play.py | 2 +- base/stamina_manager.py | 8 ++++---- lib/action/intercept.py | 4 ++-- lib/action/intercept_self.py | 12 ++++++------ lib/player/action_effector.py | 4 ++-- lib/player/object_player.py | 3 +++ lib/player/world_model.py | 14 +++++++------- start.sh | 2 +- 11 files changed, 31 insertions(+), 28 deletions(-) diff --git a/base/decision.py b/base/decision.py index 2e19842..c40e842 100644 --- a/base/decision.py +++ b/base/decision.py @@ -38,7 +38,7 @@ def get_decision(agent: 'PlayerAgent'): 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}') + f'is? {wm.self().is_kickable()}') if wm.self().is_kickable(): return BhvKick().execute(agent) if BhvMove().execute(agent): diff --git a/base/goalie_decision.py b/base/goalie_decision.py index 913ae9c..f225849 100644 --- a/base/goalie_decision.py +++ b/base/goalie_decision.py @@ -43,7 +43,7 @@ def decision(agent: 'PlayerAgent'): return True return False - if (wm.time().cycle() > wm.self().catch_time().cycle() + SP.catch_ban_cycle() + 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)): diff --git a/base/sample_communication.py b/base/sample_communication.py index 3d5fc72..c326919 100644 --- a/base/sample_communication.py +++ b/base/sample_communication.py @@ -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 @@ -623,7 +623,7 @@ def execute(self, agent: 'PlayerAgent'): 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 wm.self().stamina_model.recovery() < ServerParam.i().recover_init() - 0.002: say_recovery = True self.say_recovery(agent) diff --git a/base/set_play/bhv_goalie_set_play.py b/base/set_play/bhv_goalie_set_play.py index a9de921..57a901d 100644 --- a/base/set_play/bhv_goalie_set_play.py +++ b/base/set_play/bhv_goalie_set_play.py @@ -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 diff --git a/base/stamina_manager.py b/base/stamina_manager.py index 97937ae..e6736e9 100644 --- a/base/stamina_manager.py +++ b/base/stamina_manager.py @@ -8,7 +8,7 @@ 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()) + 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() @@ -17,13 +17,13 @@ def get_normal_dash_power(wm: 'WorldModel', s_recover_mode: bool): 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 diff --git a/lib/action/intercept.py b/lib/action/intercept.py index 2069a53..2239410 100644 --- a/lib/action/intercept.py +++ b/lib/action/intercept.py @@ -82,7 +82,7 @@ def execute(self, agent: 'PlayerAgent'): 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)") @@ -451,7 +451,7 @@ def do_inertia_dash(self, 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(), diff --git a/lib/action/intercept_self.py b/lib/action/intercept_self.py index e124f6a..d8cff8f 100644 --- a/lib/action/intercept_self.py +++ b/lib/action/intercept_self.py @@ -165,10 +165,10 @@ def predict_one_dash(self, self_cache): # 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, @@ -975,9 +975,9 @@ 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() + * wm.self().stamina_model.recovery() * (cycle - 1)) - result_stamina = (wm.self().stamina() + result_stamina = (wm.self().stamina_model.stamina() - total_consume + total_recover) @@ -1085,7 +1085,7 @@ def can_reach_after_dash(self, 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, @@ -1108,7 +1108,7 @@ def can_reach_after_dash(self, 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, diff --git a/lib/player/action_effector.py b/lib/player/action_effector.py index 004dc22..e16e5b2 100644 --- a/lib/player/action_effector.py +++ b/lib/player/action_effector.py @@ -254,7 +254,7 @@ def check_command_count(self, body_sensor: SenseBodyParser): self._tackle_power = 0 self._tackle_dir = 0 self._tackle_foul = False - self._command_counter[CommandType.TACKLE.value] = body_sensor.tackle_count + 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()}") @@ -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}") diff --git a/lib/player/object_player.py b/lib/player/object_player.py index d028b2f..b30a87c 100644 --- a/lib/player/object_player.py +++ b/lib/player/object_player.py @@ -285,6 +285,9 @@ def set_ghost(self): def is_goalie(self): return self.goalie + def is_tackling(self): + return self.tackle + def long_str(self): res = f'unum: {self.unum} ' \ f'side: {self.side} ' \ diff --git a/lib/player/world_model.py b/lib/player/world_model.py index 308ca2b..424643f 100644 --- a/lib/player/world_model.py +++ b/lib/player/world_model.py @@ -505,7 +505,7 @@ 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: @@ -655,7 +655,7 @@ def localize_ball(self, see: SeeParser, act: 'ActionEffector'): 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 + 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() @@ -1024,7 +1024,7 @@ def update_world_after_sense_body(self, body_sensor: SenseBodyParser, act: 'Acti 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_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: @@ -1253,7 +1253,7 @@ def update_goalie_by_hear(self): # TODO CHECK FULL STATE TIME log.sw_log().world().add_text(f'{"#"*20} UPDATE GOALIE BY HEAR {"#"*20}') - if self._messenger_memory.goalie_time() != self.time() or len(self._messenger_memory.goalie) == 0: + if self._messenger_memory.goalie_time() != self.time() or len(self._messenger_memory.goalie()) == 0: return goalie: PlayerObject = None @@ -1269,12 +1269,12 @@ def update_goalie_by_hear(self): heard_pos = Vector2D(0, 0) heard_body = 0. - for g in self._messenger_memory.goalie: + for g in self._messenger_memory.goalie(): heard_pos += g.pos_ heard_body += AngleDeg(g.body_).degree() - heard_body /= len(self._messenger_memory.goalie) - heard_pos /= len(self._messenger_memory.goalie) + heard_body /= len(self._messenger_memory.goalie()) + heard_pos /= len(self._messenger_memory.goalie()) if goalie is not None: goalie.update_by_hear(self.their_side(), self._their_goalie_unum,True, heard_pos, heard_body) diff --git a/start.sh b/start.sh index 57635c6..5b4401a 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+"$@"} From 57aa4c43bf4ec8889f2da95c0b4a9a64a12a75af Mon Sep 17 00:00:00 2001 From: Aref Date: Thu, 17 Aug 2023 16:13:22 -0230 Subject: [PATCH 18/22] tackle bug fixed --- base/basic_tackle.py | 4 ++-- lib/player/action_effector.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/base/basic_tackle.py b/base/basic_tackle.py index 0dadf91..dff8223 100644 --- a/base/basic_tackle.py +++ b/base/basic_tackle.py @@ -29,8 +29,8 @@ def execute(self, agent: 'PlayerAgent'): 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() + and tackle_prob < wm.self().foul_probability: + tackle_prob = wm.self().foul_probability use_foul = True if tackle_prob < self._min_prob: diff --git a/lib/player/action_effector.py b/lib/player/action_effector.py index e16e5b2..4692350 100644 --- a/lib/player/action_effector.py +++ b/lib/player/action_effector.py @@ -244,7 +244,7 @@ def check_command_count(self, body_sensor: SenseBodyParser): 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.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()}") From 6b73773d3506c5b0b0d6ff8270da7c7858a6e11e Mon Sep 17 00:00:00 2001 From: Aref Date: Mon, 21 Aug 2023 16:17:42 -0230 Subject: [PATCH 19/22] vector2d --- lib/action/kick_table.py | 2 +- lib/player/localizer.py | 4 ++-- lib/player/sensor/see_state.py | 8 +++++--- 3 files changed, 8 insertions(+), 6 deletions(-) diff --git a/lib/action/kick_table.py b/lib/action/kick_table.py index ff76206..6938a69 100644 --- a/lib/action/kick_table.py +++ b/lib/action/kick_table.py @@ -653,7 +653,7 @@ def check_interfere_at(world: 'WorldModel', break opp_body = o.body if o.body_count <= 1 else (state.pos_ - opp_next).th() - player_2_pos = Vector2D(state.pos_ - opp_next) + player_2_pos = state.pos_ - opp_next player_2_pos.rotate(- opp_body) # # check tackle possibility diff --git a/lib/player/localizer.py b/lib/player/localizer.py index 97fa666..833d80f 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/sensor/see_state.py b/lib/player/sensor/see_state.py index 5531a26..1a46300 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): From 53ed079e5323044a68c9d3aa36ef76a505ba1270 Mon Sep 17 00:00:00 2001 From: Aref Date: Mon, 21 Aug 2023 17:33:43 -0230 Subject: [PATCH 20/22] None bug --- base/generator_shoot.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/base/generator_shoot.py b/base/generator_shoot.py index 62e85a8..78fbfd6 100644 --- a/base/generator_shoot.py +++ b/base/generator_shoot.py @@ -117,6 +117,8 @@ def check_shoot(self, wm: 'WorldModel', target_point: Vector2D, first_ball_speed for o in range(1, 12): opp = wm.their_player(o) + if o is None: + continue if opp.unum < 1: log.sw_log().shoot().add_text( '## opp {} can not, unum') continue From 360095c0c2728be838a3ad5db6b76f096189c506 Mon Sep 17 00:00:00 2001 From: Aref Date: Tue, 22 Aug 2023 15:09:30 -0230 Subject: [PATCH 21/22] remove unused code --- lib/action/kick_table.py | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/lib/action/kick_table.py b/lib/action/kick_table.py index 6938a69..0a80ce1 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] = [] From 13f6f21dd6ea03fcbabcf8f368f7ea191918e66d Mon Sep 17 00:00:00 2001 From: Aref Date: Wed, 23 Aug 2023 12:23:01 -0230 Subject: [PATCH 22/22] gamemode if --- base/generator_pass.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/generator_pass.py b/base/generator_pass.py index 0b13330..f569340 100644 --- a/base/generator_pass.py +++ b/base/generator_pass.py @@ -198,7 +198,7 @@ def generate_lead_pass(self, wm: 'WorldModel', receiver): 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: