def find_best_waypoint_route(routes: List[List[Position]], position: Position): best = (position.calculate_distance_from(routes[0][0]), 0) for i, route in enumerate(routes): distance = position.calculate_distance_from(route[0]) if distance < best[0]: best = (distance, i) return best[1]
def test_turn_left(self): fake_controller = FakeController() storage = PositionStorage() storage.parse([(0, 2)]) move = MoveState(fake_controller, None, storage) fake_character = FakeCharacter() fake_character.position = Position(0, 0) move.interpret(fake_character, None) fake_character.position = Position(1, 1) move.interpret(fake_character, None) self.assertEqual(math.ceil(pi / 2 / move.RAD_PER_TURN), fake_controller.val)
def test_stop_on_transition_when_too_far_away(self): character = FakeCharacter() character.position = Position(50, 50) self.storage.parse([(20, 20)]) with self.assertRaises(PrerequisiteException) as e: self.start.transition(character, None)
def test_turn_right_to_waypoint(self): character = FakeCharacter() character.position = Position(50, 50) self.storage.parse([(92, 33)]) self.start.interpret(character, None) self.assertEqual(Direction.right, self.controller.turn)
def test_point(self): character = FakeCharacter() character.position = Position(530.0566, -432.1322) character.facing = 1.4452323 self.storage.parse([(529.1963, -434.5789)]) self.start.interpret(character, None) time.sleep(2) character.facing = 2.345232 self.storage.parse([(529.1963, -430.5789)]) self.start.interpret(character, None) time.sleep(2)
def record(self, record_data: Dict[str, str]): self.waypoints = {'format': record_data['wp_format'], 'waypoints': []} signal.signal(signal.SIGINT, lambda *args: self.screen.stop_capturing()) signal.signal(signal.SIGTERM, lambda *args: self.screen.stop_capturing()) try: for screen in self.screen.capture(): data = self.extractor.extract_data_from_screen(screen) self._data_sanitizer.sanitize_data(data) current_position = Position(data.player_position[0], data.player_position[1]) if not self.waypoints['waypoints']: self.waypoints['waypoints'].append(data.player_position) else: last_recorded_coordinates = self.waypoints['waypoints'][ len(self.waypoints['waypoints']) - 1] last_recorded_position = Position( last_recorded_coordinates[0], last_recorded_coordinates[1]) if current_position.calculate_distance_from( last_recorded_position ) >= GlobalConfig.config.core.difference_between_two_waypoints: Logger.info('Recording position: ' + str(data.player_position)) self.waypoints['waypoints'].append( data.player_position) finally: Logger.info('Saving file to: {}'.format( record_data.get('waypoint', 'NO PATH'))) file = Path(record_data['waypoint']) if file.is_file(): self._save_if_file_exist(record_data) else: self._save_if_file_not_exist(record_data)
def test_calculate_trajectory(self): p1 = Position(2, -2) a1 = pi / 3 a2 = 2 * pi / 3 a3 = 4 * pi / 3 a4 = 5 * pi / 3 v1 = calculate_trajectory(p1, a1) v2 = calculate_trajectory(p1, a2) v3 = calculate_trajectory(p1, a3) v4 = calculate_trajectory(p1, a4) print(v1, v2, v3, v4)
def update(self, data: ExtractedData): self.hp = data.player_health self.resource = data.player_resource self.position = Position(data.player_position[0], data.player_position[1]) self.is_in_combat = data.combat self.facing = normalize_facing(data.facing) self.last_ability = data.last_ability self.casting = data.casting self.is_inventory_full = data.is_inventory_full self.has_pet = data.player_has_pet self.first_class_resource = data.player_first_resource_available self.pet_hp = data.pet_health self.pet_mana = data.pet_mana
def __init__(self, resource_type: Resource = Resource.MANA): self.hp = 0 self.resource = 0 self.position = Position(0, 0) self.resource_type = resource_type self.is_moving = False self.is_in_combat = False self.current_waypoint = 0 self.facing = 0 self.casting = CastingState.IDLE self.last_ability = LastAbilityExecution.SUCCESS self.is_inventory_full = False self.has_pet = False self.first_class_resource = False self.pet_hp = 0 self.pet_mana = 0
def __init__(self, controller: CharacterController, behavior: CharacterBehavior, waypoints: PositionStorage = None, transition_state: BaseState = None, transition: TransitionType = TransitionType.SAME_LEVEL): super().__init__(controller, behavior, waypoints, transition_state, transition) self._released = False closest_waypoint_route = find_best_waypoint_route( [[Position(w[0], w[1]) for w in wp['waypoints']] for wp in GlobalConfig.config.waypoint['ghost']], transition_state.persistent_state['last_position']) self.waypoints.parse(GlobalConfig.config.waypoint['ghost'] [closest_waypoint_route]['waypoints']) self.create_sub_state(MoveState)
def interpret(self, frame: Frame): self._positions.append(frame.character.position) if len(self._positions.data) >= self.LAST_N_POSITION + 1: # distance_from_last_position = self._positions.data[-1].calculate_distance_from(self._positions.data[-2]) x_avg = 0 y_avg = 0 for i in range( len(self._positions.data) - 1, len(self._positions.data) - self.LAST_N_POSITION - 1, -1): x_avg += self._positions.data[i].x y_avg += self._positions.data[i].y x_avg = x_avg / self.LAST_N_POSITION y_avg = y_avg / self.LAST_N_POSITION avg_point = Position(x_avg, y_avg) distance_from_last_position = self._positions.data[ -1].calculate_distance_from(avg_point) if self._direction: self.controller.turn( self._direction, random.uniform( GlobalConfig.config.movement.stuck_turn_range[0], GlobalConfig.config.movement.stuck_turn_range[1])) elif self._jumps >= GlobalConfig.config.movement.stuck_first_level_threshold: self._direction = Direction(random.randint(0, 1)) if distance_from_last_position <= GlobalConfig.config.movement.stuck_threshold: self.log("Character is stuck, pressing space.") self.controller.cast_spell('space') self._jumps += 1 else: self._jumps = 0 self._direction = None
def add(self, waypoint: (float, float)): self.waypoints.append(Position(waypoint[0], waypoint[1]))
def parse(self, points: List[Tuple[float, float]]): self.waypoints = [] self.waypoints.extend([Position(x, y) for x, y in points])
def calculate_trajectory(point: Position, facing: float) -> Trajectory: projected_x = point.point.x + 1 * math.cos(facing) projected_y = point.point.y + 1 * math.sin(facing) return Trajectory(point, Position(projected_x, projected_y), facing)
def test_position_close_to(self): p = Position(441.1396, -337.4077) p2 = Position(438.636, -340.0971) print(p.is_close_to(p2, 0.01))
def __init__(self): self.position = Position(0, 0) self.current_waypoint = 0 self.is_moving = False self.facing = 0
def test_calculate_angle(self): a = Position(2, -2) b = Position(1, -3) line = Trajectory(a, b) print(line)