Exemplo n.º 1
0
    def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
        self.quick_chat_handler.handle_quick_chats(packet)

        # Collect data from the packet
        self.mode = (Gamemode.DROPSHOT if self.get_field_info().num_boosts == 0
                     else Gamemode.SOCCAR)
        self.time = packet.game_info.seconds_elapsed
        ball_location = Vector3(packet.game_ball.physics.location)
        self.car = packet.game_cars[self.index]
        car_location = Vector3(self.car.physics.location)
        car_velocity = Vector3(self.car.physics.velocity)
        car_direction = get_car_facing_vector(self.car)
        car_to_ball = ball_location - car_location
        is_1v1 = (packet.num_cars == 2
                  and packet.game_cars[not self.index].team != self.car.team)
        team_sign = (1 if self.car.team == (
            is_1v1 and packet.teams[self.car.team].score == 7
            and packet.teams[not self.car.team].score == 0) else -1)
        enemy_goal = Vector2(0, team_sign * 5120)
        kickoff = (ball_location.x == 0 and ball_location.y == 0)
        impact, impact_time = get_impact(
            self.get_ball_prediction_struct(), self.car,
            Vector3(packet.game_ball.physics.location.x,
                    packet.game_ball.physics.location.y,
                    packet.game_ball.physics.location.z), self.renderer)
        impact_projection = project_to_wall(car_location,
                                            impact.flatten() - car_location)
        rotation_matrix = Matrix3D([
            self.car.physics.rotation.pitch, self.car.physics.rotation.yaw,
            self.car.physics.rotation.roll
        ])
        rotation_velocity = rotation_matrix.dot(
            self.car.physics.angular_velocity)
        correct_side_of_ball: bool = (
            (impact_projection.y - car_location.y) * team_sign > 0)
        # Hi robbie!

        # Handle bouncing
        ball_bounces: List[Slice] = get_ball_bounces(
            self.get_ball_prediction_struct())
        bounce_location = None
        for b in ball_bounces:
            time: float = b.game_seconds - self.time
            if time < impact_time - 0.3:
                continue
            bounce_location: Vector2 = Vector2(b.physics.location)
            break
        if bounce_location is None:
            time = 0

        # Handle aerials
        if self.aerial is not None:
            if self.car.has_wheel_contact and self.aerial.jt + 0.5 < self.time:
                # Give up on an aerial
                self.aerial = None
            else:
                # Get the output of the aerial
                aerial_output = self.aerial.execute(
                    packet, self.index, self.get_ball_prediction_struct())
                if self.aerial.target is not None:
                    self.renderer.begin_rendering()
                    self.renderer.draw_line_3d(
                        car_location, car_location + self.aerial.target,
                        self.renderer.white())
                    self.renderer.end_rendering()
                return aerial_output
        if self.aerial is None and self.car.has_wheel_contact and impact.z - self.car.physics.location.z > 500 and car_velocity.length > 100 and self.demo is None and\
           (self.car.boost > 20 or (abs(time - 0.6) < 0.1 and (impact - car_location).flatten().length < 1000))\
            and abs(self.steer_correction_radians) < 0.4 and impact_time < 2.5 and (impact_projection.y * team_sign > -5000 or abs(impact_projection.x) > 1000)\
            and math.cos(car_velocity.angle_between(impact - car_location)) * car_velocity.flatten().length > 400:
            # Start a new aerial
            self.aerial = Aerial(self.time)
            return self.aerial.execute(packet, self.index,
                                       self.get_ball_prediction_struct())

        # Set a destination for Anarchy to reach
        teammate_going_for_ball: bool = False
        min_teammate_distance = float("inf")
        for index, car in enumerate(packet.game_cars[:packet.num_cars]):
            if self.car.team == self.team and index != self.index:
                teammate_to_ball: Vector3 = ball_location - Vector3(
                    self.car.physics.location)
                vector = get_car_facing_vector(self.car)
                teammate_facing_direction: Vector3 = Vector3(
                    vector.x, vector.y, 0)
                teammate_velocity_direction: Vector3 = Vector3(
                    self.car.physics.velocity)
                min_teammate_distance = min(min_teammate_distance,
                                            teammate_to_ball.length)
                if teammate_to_ball.length < (car_to_ball.length if correct_side_of_ball else max(1.8 * car_to_ball.length, 900)) and teammate_to_ball.y * team_sign > 0 and \
                        (abs(teammate_to_ball.angle_between(teammate_facing_direction)) < 0.4 * math.pi or
                         abs(teammate_to_ball.angle_between(teammate_velocity_direction)) < 0.4 * math.pi or
                         teammate_to_ball.length < 1200):
                    teammate_going_for_ball = True
                    self.renderer.begin_rendering('teammate')
                    self.renderer.draw_line_3d(car_location,
                                               self.car.physics.location,
                                               self.renderer.black())
                    self.renderer.draw_rect_3d(self.car.physics.location, 4, 4,
                                               True, self.renderer.black())
                    self.renderer.end_rendering()
                    break

        avoid_own_goal = impact_projection.y * team_sign < -5000
        wait = (ball_location.z > 200 and self.car.physics.location.z < 200)
        #take_serious_shot = (not kickoff and correct_side_of_ball and ball_velocity.flatten().length < 3000 and abs((impact - car_location).flatten().normalized.y) > 0.75)
        take_serious_shot = (
            not kickoff and correct_side_of_ball
            and impact.y * team_sign > 1000 + min(2, impact_time) * 500)
        obey_turning_radius = True  # Slow down if the target is in the turning radius
        demoing = (self.demo is not None)
        need_boost = (not self.car.is_super_sonic and self.car.boost < 30)
        close_boost = closest_boost(Vector3(-impact.x, impact.y, 0) if teammate_going_for_ball and impact_time < 2.5 and not kickoff else car_location\
                                    , self.get_field_info().boost_pads, packet.game_boosts)
        park_car = False
        not_our_kickoff = (kickoff and
                           min_teammate_distance < car_to_ball.length - 100)

        if wait and bounce_location is not None:
            destination = Vector3(bounce_location.x, bounce_location.y, 0)
        else:
            destination = impact
            time = 0
        if kickoff and not not_our_kickoff:
            destination = ball_location + Vector3(0, -92.75 * team_sign, 0)
            obey_turning_radius = False
        elif avoid_own_goal and not not_our_kickoff and not demoing and (
                not teammate_going_for_ball or impact.y * team_sign > -4000):
            offset = (max(0, impact_time - 0.5) * 160 + 110)
            destination += Vector2(offset * -sign(impact_projection.x),
                                   (140 if wait else 0) * -team_sign)
            obey_turning_radius = True
        elif not_our_kickoff or teammate_going_for_ball or self.demo is not None or \
             (close_boost and need_boost and (close_boost - car_location.flatten()).length * 5 < car_to_ball.length):
            if close_boost: destination = close_boost
            obey_turning_radius = True

            demo_location = None
            if not need_boost and not not_our_kickoff:
                if self.demo is None:
                    self.demo = Demolition.start_demo(self, packet)
                demo_location, demo_time = (self.demo.get_destination(packet)
                                            if self.demo is not None else None)
                if demo_location is not None and (demoing or
                                                  demo_time < max_demo_time):
                    destination = demo_location
                    obey_turning_radius = False
                    demoing = True
                    time = 0
            if not demoing or self.demo is None or demo_location is None:
                self.demo = None
                demoing = False
                if (not need_boost and car_to_ball.length > 2500
                    ) if not not_our_kickoff else (
                        abs(car_location.x) < 50):  #Middle
                    park_car = True
                    destination = Vector2(0, -4900 * team_sign)
                    destination += (impact.flatten() - destination) / 8
                    destination = Vector3(destination.x, destination.y, 17)
        elif abs(ball_location.x) < 750 or (
                not take_serious_shot and
            (team_sign * car_location.y > team_sign * ball_location.y or
             (abs(ball_location.x) > 3200
              and abs(ball_location.x) + 100 > abs(car_location.x)))):
            destination.y -= max(
                abs(car_to_ball.y) / 3.3, 70 if wait else 100) * team_sign
        else:
            destination += (destination - enemy_goal).normalized * max(
                (destination - car_location).length /
                ((2.1 + impact_time / 1.9) if take_serious_shot else 3.7),
                60 if wait else 110)
        if abs(car_location.y) > 5120:
            destination.x = min(700,
                                max(-700,
                                    destination.x))  #Don't get stuck in goal
        car_to_destination = (destination - car_location)

        # Rendering
        self.renderer.begin_rendering()
        if kickoff:
            self.renderer.draw_string_2d(20, 140, 2, 2, "Kickoff",
                                         self.renderer.white())
        if take_serious_shot:
            self.renderer.draw_string_2d(20, 140, 2, 2, "Shoot",
                                         self.renderer.white())
        self.renderer.draw_line_3d([destination.x, destination.y, impact.z],
                                   [impact.x, impact.y, impact.z],
                                   self.renderer.blue())
        if avoid_own_goal:
            self.renderer.draw_line_3d(
                [car_location.x, car_location.y, 0],
                [impact_projection.x, impact_projection.y, 0],
                self.renderer.yellow())
        if not demoing:
            self.renderer.clear_screen(Demolition.get_render_name(self))
        if park_car:
            self.renderer.draw_string_2d(20, 140, 2, 2, "Parking!",
                                         self.renderer.yellow())
        self.renderer.end_rendering()

        if self.zero_two is not None and self.time > 10.0:
            self.zero_two.render(self.renderer)

        # Choose whether to drive backwards or not
        wall_touch = (distance_from_wall(impact.flatten()) < 500
                      and team_sign * impact.y < 4000)
        local = rotation_matrix.dot(
            Vector3(car_to_destination.x, car_to_destination.y,
                    (impact.z if wall_touch else 17.010000228881836) -
                    self.car.physics.location.z))
        self.steer_correction_radians = math.atan2(local.y, local.x)
        slow_down = park_car or (abs(self.steer_correction_radians > 0.2)
                                 and inside_turning_radius(
                                     local, car_velocity.length)
                                 and obey_turning_radius)
        if slow_down:
            self.renderer.begin_rendering()
            self.renderer.draw_string_2d(
                triforce(20, 50), triforce(10, 20), 6, 6, 'Uh Oh',
                self.renderer.pink() if
                (self.time % 0.5) < 0.25 else self.renderer.red())
            self.renderer.end_rendering()
        turning_radians = self.steer_correction_radians
        backwards = (math.cos(turning_radians) < 0 and not demoing
                     and not self.car.is_super_sonic and not slow_down)
        if backwards:
            turning_radians = invert_angle(turning_radians)
        throttle_sign = (-1 if backwards else 1)

        # Speed control
        target_velocity = (((bounce_location - car_location).length /
                            time) if time > 0 else 2300)
        velocity_change = (target_velocity - car_velocity.flatten().length)
        if park_car:
            self.controller.boost = False
            self.controller.throttle = clamp11(
                (destination - car_location).length / 2000) * throttle_sign
        elif slow_down:
            self.controller.boost = False
            if car_velocity.length > 400:
                self.controller.throttle = -sign(
                    math.cos(
                        car_direction.correction_to(car_velocity.flatten())))
            else:
                self.controller.throttle = 0
        elif (velocity_change > 300 or target_velocity > 1410 or demoing):
            self.controller.boost = (abs(turning_radians) < 0.2
                                     and not self.car.is_super_sonic
                                     and not backwards)
            if self.controller.boost and self.mode is Gamemode.DROPSHOT:
                self.controller.boost = (
                    30 < self.car.boost - (2200 - car_velocity.length) /
                    ((911 + (2 / 3)) if self.car.has_wheel_contact else 1000) *
                    (100 / 3))
            self.controller.throttle = throttle_sign
        elif velocity_change > -150:
            self.controller.boost = False
            self.controller.throttle = 0
        else:
            self.controller.boost = False
            self.controller.throttle = -throttle_sign

        # Steering
        turn = clamp11(turning_radians * 4)
        self.controller.steer = turn
        self.controller.handbrake = (abs(turning_radians) > 1.1
                                     and not self.car.is_super_sonic
                                     and not (slow_down or park_car))

        # Dodging
        self.controller.jump = False
        dodge_for_speed = (velocity_change > 500 and not backwards
                           and self.car.boost < 14
                           and self.time > self.next_dodge_time + 0.85
                           and car_to_destination.size >
                           (2000 if take_serious_shot else 1200)
                           and abs(turning_radians) < 0.1 and not demoing)
        if (((car_to_ball.flatten().size < 400 and ball_location.z < 300)
             or dodge_for_speed) and car_velocity.size > 1100) or self.dodging:
            dodge_at_ball = (impact_time < 0.4)
            dodge_angle = (car_direction.correction_to(car_to_ball)
                           if dodge_at_ball else
                           car_direction.correction_to(car_to_destination))
            dodge(self, dodge_angle, rotation_velocity,
                  4 if dodge_at_ball else 1)

        # Half-flips
        if backwards and not park_car and (
                time if wait else
                impact_time) > 0.6 and car_velocity.size > 900 and abs(
                    turning_radians) < 0.1 or self.halfflipping:
            halfflip(self, rotation_velocity)

        # Recovery
        if not (self.dodging or self.halfflipping):
            if not self.car.has_wheel_contact:
                self.controller.steer = 0
                recover(self,
                        rotation_velocity,
                        allow_yaw_wrap=car_location.z > 250)
                self.controller.boost = False
            else:
                self.controller.roll = 0
                self.controller.pitch = 0
                self.controller.yaw = 0

        return self.controller
Exemplo n.º 2
0
    def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
        self.quick_chat_handler.handle_quick_chats(packet)
        if self.enable_goal_music:
            self.jukebox.update(packet)

        # Collect data from the packet
        self.mode = (Gamemode.DROPSHOT if self.get_field_info().num_boosts == 0
                     else Gamemode.SOCCAR)
        self.time = packet.game_info.seconds_elapsed
        ball_location = Vector3(packet.game_ball.physics.location)
        self.car = packet.game_cars[self.index]
        car_location = Vector3(self.car.physics.location)
        car_velocity = Vector3(self.car.physics.velocity)
        car_direction = get_car_facing_vector(self.car)
        self.car_direction = car_direction
        car_to_ball = ball_location - car_location
        is_1v1 = (packet.num_cars == 2
                  and packet.game_cars[not self.index].team != self.car.team)
        team_sign = (1 if self.car.team == (
            is_1v1 and packet.teams[self.car.team].score == 7
            and packet.teams[not self.car.team].score == 0) else -1)
        enemy_goal = Vector2(0, team_sign * 5120)
        kickoff = packet.game_info.is_kickoff_pause
        ball_prediction = self.get_ball_prediction_struct()
        impacts = [
            get_impact(ball_prediction, car, self.time, self.renderer)
            for car in packet.game_cars[:packet.num_cars]
        ]
        impact, impact_time = impacts[self.index]
        self.impact = impact
        impact_projection = project_to_wall(car_location,
                                            impact.flatten() - car_location)
        rotation_matrix = Matrix3D([
            self.car.physics.rotation.pitch,
            self.car.physics.rotation.yaw,
            self.car.physics.rotation.roll,
        ])
        self.rotation_matrix = rotation_matrix
        rotation_velocity = rotation_matrix.dot(
            self.car.physics.angular_velocity)
        self.rotation_velocity = rotation_velocity
        car_local_velocity = rotation_matrix.dot(car_velocity)
        correct_side_of_ball: bool = (
            (impact_projection.y - car_location.y) * team_sign > 0)
        # Hi robbie!
        if self.time == packet.game_ball.latest_touch.time_seconds and self.enable_ball_touch_audio:
            print(
                "\a"
            )  # for all the people who mute anarchy because they dont like 'boing' :)

        if self.render_disco_ball:
            # this kinda kills the anime and idk what to do about it
            self.renderer.begin_rendering("disco")
            for i in range(100):
                hmmm = ball_location + Vector3(
                    random.randint(-1000, 1000),
                    random.randint(-1000, 1000),
                    random.randint(-1000, 1000),
                )
                self.renderer.draw_line_3d(
                    [ball_location.x, ball_location.y, ball_location.z],
                    [hmmm.x, hmmm.y, hmmm.z],
                    self.renderer.create_color(
                        255,
                        random.randint(0, 255),
                        random.randint(0, 255),
                        random.randint(0, 255),
                    ),
                )
            self.renderer.end_rendering()

        # Action.
        if self.action:
            print(self.action.__class__.__name__)
            if not hasattr(self.action,
                           "finished") or not self.action.finished:
                return self.action.step(packet)
            self.action = None

        # Handle bouncing
        ball_bounces: List[Slice] = get_ball_bounces(
            self.get_ball_prediction_struct())
        bounce_location = None
        for b in ball_bounces:
            time: float = b.game_seconds - self.time
            if time < impact_time - 0.3:
                continue
            bounce_location: Vector2 = Vector2(b.physics.location)
            break
        if bounce_location is None:
            time = 0

        # Handle aerials
        if self.aerial is not None:
            if self.car.has_wheel_contact and self.aerial.jt + 0.5 < self.time:
                # Give up on an aerial
                self.aerial = None
            else:
                # Get the output of the aerial
                aerial_output = self.aerial.execute(
                    packet, self.index, self.get_ball_prediction_struct())
                if self.aerial.target is not None:
                    self.renderer.begin_rendering()
                    self.renderer.draw_line_3d(
                        car_location,
                        car_location + self.aerial.target,
                        self.renderer.white(),
                    )
                    self.renderer.end_rendering()
                return aerial_output
        if (self.aerial is None and self.car.has_wheel_contact
                and impact.z - self.car.physics.location.z > 500
                and car_velocity.length > 100 and self.demo is None
                and (self.car.boost > 20 or
                     (abs(time - 0.6) < 0.1 and
                      (impact - car_location).flatten().length < 1000))
                and abs(self.steer_correction_radians) < 0.4
                and impact_time < 2.5
                and (impact_projection.y * team_sign > -5000
                     or abs(impact_projection.x) > 1000) and
                math.cos(car_velocity.angle_between(impact - car_location)) *
                car_velocity.flatten().length > 400):
            # Start a new aerial
            self.aerial = Aerial(self.time)
            return self.aerial.execute(packet, self.index,
                                       self.get_ball_prediction_struct())

        # Set a destination for Anarchy to reach
        teammate_going_for_ball: bool = False
        for index, car in enumerate(packet.game_cars[:packet.num_cars]):
            if car.team == self.team and index != self.index:
                teammate_location = Vector3(car.physics.location)
                teammate_correct_side_of_ball: bool = (
                    (impacts[index][0].y - teammate_location.y) * team_sign >
                    0)
                if correct_side_of_ball and not teammate_correct_side_of_ball:
                    continue
                if impacts[index][1] + 0.1 < impact_time or (
                        not correct_side_of_ball
                        and teammate_correct_side_of_ball):
                    teammate_going_for_ball = True
                    self.renderer.begin_rendering("teammate")
                    self.renderer.draw_line_3d(car_location, teammate_location,
                                               self.renderer.black())
                    self.renderer.draw_rect_3d(teammate_location, 4, 4, True,
                                               self.renderer.black())
                    self.renderer.end_rendering()
                    break

        avoid_own_goal = impact_projection.y * team_sign < -5000
        wait = ball_location.z > 200 and self.car.physics.location.z < 200
        take_serious_shot = False
        obey_turning_radius = True  # Slow down if the target is in the turning radius
        demoing = self.demo is not None
        close_boost = closest_boost(
            Vector3(-impact.x, impact.y, 0) if teammate_going_for_ball
            and impact_time < 2.5 and not kickoff else car_location,
            self.get_field_info().boost_pads,
            packet.game_boosts,
        )
        convenient_boost = (close_boost
                            and (close_boost - car_location).flatten().length *
                            (5 if is_1v1 else 3) <
                            (impact - car_location).flatten().length)
        need_boost = not self.car.is_super_sonic and self.car.boost < (
            40 if convenient_boost else 30)
        park_car = False
        not_our_kickoff = kickoff and teammate_going_for_ball

        if wait and bounce_location is not None:
            destination = Vector3(bounce_location.x, bounce_location.y, 0)
        else:
            destination = impact
            time = 0
        if kickoff and not not_our_kickoff:
            destination = ball_location + Vector3(0, -92.75 * team_sign, 0)
            obey_turning_radius = False
        elif (avoid_own_goal and not kickoff and not demoing and
              (not teammate_going_for_ball or impact.y * team_sign > -4000)):
            offset = max(0, impact_time - 0.5) * 160 + 110
            destination += Vector2(offset * -sign(impact_projection.x),
                                   (140 if wait else 0) * -team_sign)
        elif (not_our_kickoff or teammate_going_for_ball or demoing
              or (close_boost and need_boost and
                  (not is_1v1 or convenient_boost))):
            if close_boost:
                destination = close_boost

            demo_location = None
            if (demoing or not need_boost) and not kickoff:
                if not demoing:
                    self.demo = Demolition.start_demo(self, packet)
                demo_location, demo_time = (self.demo.get_destination(packet)
                                            if self.demo is not None else
                                            (None, 0))
                if demo_location is not None:
                    destination = demo_location
                    obey_turning_radius = False
                    demoing = True
                    time = 0
            if demo_location is None:
                self.demo = None
                demoing = False
                if ((not need_boost and car_to_ball.length > 2500)
                        if not not_our_kickoff else
                    (abs(car_location.x) < 50)):  # Middle
                    park_car = True
                    destination = Vector2(0, -4900 * team_sign)
                    destination += (impact.flatten() - destination) / 8
                    destination = Vector3(destination.x, destination.y, 17)
        elif team_sign * (car_location.y - ball_location.y) > 0:
            destination.x += max(car_to_ball.length / 3, 80
                                 if wait else 120) * -sign(impact_projection.x)
        else:
            destination += (destination - enemy_goal).normalized * max(
                (destination - car_location).length /
                ((2.1 + impact_time / 1.9) if take_serious_shot else 3.7),
                60 if wait else 110,
            )
            take_serious_shot = True
        if abs(car_location.y) > 5120:
            destination.x = min(700,
                                max(-700,
                                    destination.x))  # Don't get stuck in goal
        car_to_destination = destination - car_location

        # Rendering
        self.renderer.begin_rendering()
        if kickoff:
            self.renderer.draw_string_2d(20, 140, 2, 2, "Kickoff",
                                         self.renderer.white())
        if take_serious_shot:
            self.renderer.draw_string_2d(20, 140, 2, 2, "Shoot",
                                         self.renderer.white())
        self.renderer.draw_line_3d(
            [destination.x, destination.y, impact.z],
            [impact.x, impact.y, impact.z],
            self.renderer.blue(),
        )
        if avoid_own_goal:
            self.renderer.draw_line_3d(
                [car_location.x, car_location.y, 0],
                [impact_projection.x, impact_projection.y, 0],
                self.renderer.yellow(),
            )
        if not demoing:
            self.renderer.clear_screen(Demolition.get_render_name(self))
        if park_car:
            self.renderer.draw_string_2d(20, 140, 2, 2, "Parking!",
                                         self.renderer.yellow())
        self.renderer.end_rendering()

        if self.zero_two is not None and self.time > 10.0:
            self.zero_two.render(self.renderer)

        # Choose whether to drive backwards or not
        wall_touch = (distance_from_wall(impact.flatten()) < 500
                      and team_sign * impact.y < 4000)
        local = rotation_matrix.dot(
            Vector3(
                car_to_destination.x,
                car_to_destination.y,
                (impact.z if wall_touch else 17.010000228881836) -
                self.car.physics.location.z,
            ))
        self.steer_correction_radians = math.atan2(local.y, local.x)
        slow_down = (abs(self.steer_correction_radians) > 0.2
                     and inside_turning_radius(local, car_velocity.length)
                     and obey_turning_radius)
        if slow_down:
            self.renderer.begin_rendering()
            self.renderer.draw_string_2d(
                triforce(20, 50),
                triforce(10, 20),
                6,
                6,
                "Uh Oh",
                self.renderer.pink() if
                (self.time % 0.5) < 0.25 else self.renderer.red(),
            )
            self.renderer.end_rendering()
        turning_radians = self.steer_correction_radians
        backwards = (math.cos(turning_radians) < 0 and not demoing
                     and not self.car.is_super_sonic)
        if backwards:
            turning_radians = invert_angle(turning_radians)
        throttle_sign = -1 if backwards else 1

        # Speed control
        target_velocity = (((bounce_location - car_location).length /
                            time) if time > 0 else 2300)
        velocity_change = target_velocity - car_velocity.flatten().length
        if park_car:
            self.controller.boost = False
            self.controller.throttle = (clamp11(
                (destination - car_location).length / 2000) * throttle_sign)
        elif slow_down:
            if car_velocity.length > 400:
                self.controller.throttle = -sign(
                    rotation_matrix.data[0].dot(destination - car_location))
                self.controller.boost = self.controller.throttle > 0
            else:
                self.controller.throttle = 0
        elif velocity_change > 300 or target_velocity > 1410 or demoing:
            self.controller.boost = (abs(turning_radians) < 0.2
                                     and not self.car.is_super_sonic
                                     and not backwards)
            if self.controller.boost and self.mode is Gamemode.DROPSHOT:
                self.controller.boost = 30 < self.car.boost - (
                    2200 - car_velocity.length) / (
                        (911 + (2 / 3))
                        if self.car.has_wheel_contact else 1000) * (100 / 3)
            self.controller.throttle = throttle_sign
        elif velocity_change > -150:
            self.controller.boost = False
            self.controller.throttle = 0
        else:
            self.controller.boost = False
            self.controller.throttle = -throttle_sign

        # Steering
        turn = clamp11(turning_radians * 4)
        self.controller.steer = turn
        self.controller.handbrake = (abs(turning_radians) > 1.1
                                     and not self.car.is_super_sonic
                                     and not (slow_down or park_car))

        # prevent inefficient powerslides
        if sign(rotation_velocity.z) != sign(self.controller.steer) or sign(
                car_local_velocity.x) != sign(self.controller.throttle):
            self.controller.handbrake = False

        # Dodging
        self.controller.jump = False
        dodge_for_speed = (velocity_change > 500 and not backwards
                           and self.car.boost < 14
                           and self.time > self.next_dodge_time + 0.85
                           and car_to_destination.size >
                           (2000 if take_serious_shot else 1200)
                           and abs(turning_radians) < 0.1 and not demoing)
        if kickoff:
            dodge_for_speed = car_velocity.size > 1250
        if (((car_to_ball.flatten().size < 400 and ball_location.z < 300)
             or dodge_for_speed) and car_velocity.size > 1100) or self.dodging:
            dodge_at_ball = impact_time < 0.4
            dodge_direction = car_to_ball if dodge_at_ball else car_to_destination
            self.action = Dodge(self, dodge_direction)
            return self.action.step(packet)

        # Half-flips
        if (backwards and not park_car and
            (time if wait else impact_time) > 0.6 and car_velocity.size > 900
                and abs(turning_radians) < 0.1 or self.halfflipping):
            halfflip(self, rotation_velocity)

        # Recovery
        if not (self.dodging
                or self.halfflipping) and not self.car.has_wheel_contact:
            self.action = Recover(self,
                                  rotation_velocity,
                                  allow_yaw_wrap=(car_location.z > 250))
            return self.action.step(packet)

        return self.controller