<filename>src/bot.py<gh_stars>0
import math

from rlbot.agents.base_agent import BaseAgent, SimpleControllerState
from rlbot.utils.structures.game_data_struct import GameTickPacket

from util.orientation import Orientation
from util.vec import Vec3
from util.action_chain import Action_chain


class MyBot(BaseAgent):

    def initialize_agent(self):
        # This runs once before the bot starts up
        self.controller_state = SimpleControllerState()
        self.ball_predictions = None
        self.current_action_chain = None
        self.time = 0
        self.delta_time = 0

    def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
        self.delta_time = packet.game_info.seconds_elapsed-self.time
        self.time = packet.game_info.seconds_elapsed
        self.ball_predictions = self.get_ball_prediction_struct()
        predicted_goal = find_future_goal(self.ball_predictions)
        goal_text = "No Goal Threats"

        if predicted_goal:
            goal_text = f"Goal in {'%.4s' % str(predicted_goal[1]-packet.game_info.seconds_elapsed)}s"

        ball_location = Vec3(packet.game_ball.physics.location)

        my_car = packet.game_cars[self.index]
        car_location = Vec3(my_car.physics.location)

        car_to_ball = ball_location - car_location

        # Find the direction of our car using the Orientation class
        car_orientation = Orientation(my_car.physics.rotation)
        car_direction = car_orientation.forward

        steer_correction_radians = find_correction(car_direction, car_to_ball)

        if steer_correction_radians > 0:
            # Positive radians in the unit circle is a turn to the left.
            turn = -1.0  # Negative value for a turn to the left.
            action_display = "turn left"
        else:
            turn = 1.0
            action_display = "turn right"

        self.controller_state.throttle = 1.0
        self.controller_state.steer = turn

        draw_debug(self.renderer, my_car, packet.game_ball, action_display,goal_text)

        if self.current_action_chain != None:
            if not self.current_action_chain.complete:
                self.controller_state = self.current_action_chain.update(self.delta_time)
            else:
                self.current_action_chain = None
        else:
            if int(self.time) % 5 == 0:
                self.current_action_chain = simple_front_flip_chain()

        return self.controller_state


def find_correction(current: Vec3, ideal: Vec3) -> float:
    # Finds the angle from current to ideal vector in the xy-plane. Angle will be between -pi and +pi.

    # The in-game axes are left handed, so use -x
    current_in_radians = math.atan2(current.y, -current.x)
    ideal_in_radians = math.atan2(ideal.y, -ideal.x)

    diff = ideal_in_radians - current_in_radians

    # Make sure that diff is between -pi and +pi.
    if abs(diff) > math.pi:
        if diff < 0:
            diff += 2 * math.pi
        else:
            diff -= 2 * math.pi

    return diff



def draw_debug(renderer, car, ball, action_display,goal_text):
    renderer.begin_rendering()
    # draw a line from the car to the ball
    renderer.draw_line_3d(car.physics.location, ball.physics.location, renderer.white())
    # print the action that the bot is taking
    renderer.draw_string_3d(car.physics.location, 2, 2, action_display, renderer.white())
    renderer.draw_string_2d(100, 50, 3, 3, goal_text, renderer.yellow())
    renderer.end_rendering()

def find_future_goal(ball_predictions):
    for i in range(0, ball_predictions.num_slices):
        if abs(ball_predictions.slices[i].physics.location.y) >= 5235: #field length(5120) + ball radius(93) = 5213 however that results in false positives
            #returns the position the ball crosses the goal as well as the time it's predicted to occur
            return [Vec3(ball_predictions.slices[i].physics.location),ball_predictions.slices[i].game_seconds]

    return None

def simple_front_flip_chain():
    first_controller = SimpleControllerState()
    second_controller = SimpleControllerState()
    third_controller = SimpleControllerState()

    first_controller.jump = True
    first_duration = 0.1

    second_controller.jump = False
    second_controller.pitch = -1
    second_duration = 0.1

    third_controller.jump = True
    third_controller.pitch = -1
    third_duration = 0.1

    return Action_chain([first_controller,second_controller,third_controller],[first_duration,second_duration,
                                                                               third_duration])