rocket_league.api

Submodules

Classes

`Car`	Abstract base class for generic types.
`GameConfig`
`GameState`	Abstract base class for generic types.
`PhysicsObject`

Package Contents

class rocket_league.api.Car

Bases: Generic[rlgym.api.AgentID]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

team_num: int

hitbox_type: int

ball_touches: int

bump_victim_id: rlgym.api.AgentID | None

demo_respawn_timer: float

wheels_with_contact: tuple[bool, bool, bool, bool]

supersonic_time: float

boost_amount: float

boost_active_time: float

handbrake: float

is_jumping: bool

has_jumped: bool

is_holding_jump: bool

jump_time: float

has_flipped: bool

has_double_jumped: bool

air_time_since_jump: float

flip_time: float

flip_torque: numpy.ndarray

is_autoflipping: bool

autoflip_timer: float

autoflip_direction: float

physics: rocket_league.api.physics_object.PhysicsObject

_inverted_physics: rocket_league.api.physics_object.PhysicsObject

__slots__

property is_blue: bool

property is_orange: bool

property is_demoed: bool

property is_boosting: bool

property is_supersonic: bool

property on_ground: bool

property has_flip: bool

property can_flip: bool

property is_flipping: bool

property had_car_contact: bool

property inverted_physics: rocket_league.api.physics_object.PhysicsObject

class rocket_league.api.GameConfig

gravity: float

boost_consumption: float

dodge_deadzone: float

__slots__

class rocket_league.api.GameState

Bases: Generic[rlgym.api.AgentID]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

tick_count: int

goal_scored: bool

config: rocket_league.api.game_config.GameConfig

cars: Dict[rlgym.api.AgentID, rocket_league.api.car.Car[rlgym.api.AgentID]]

ball: rocket_league.api.physics_object.PhysicsObject

_inverted_ball: rocket_league.api.physics_object.PhysicsObject

boost_pad_timers: numpy.ndarray

_inverted_boost_pad_timers: numpy.ndarray

__slots__

property scoring_team: int | None

property inverted_ball: rocket_league.api.physics_object.PhysicsObject

property inverted_boost_pad_timers: numpy.ndarray

class rocket_league.api.PhysicsObject

INV_VEC

INV_MTX

position: numpy.ndarray

linear_velocity: numpy.ndarray

angular_velocity: numpy.ndarray

_quaternion: numpy.ndarray | None

_rotation_mtx: numpy.ndarray | None

_euler_angles: numpy.ndarray | None

__slots__

inverted() → T

property quaternion: numpy.ndarray

property rotation_mtx: numpy.ndarray

property euler_angles: numpy.ndarray

property forward: numpy.ndarray

property right: numpy.ndarray

property left: numpy.ndarray

property up: numpy.ndarray

property pitch: float

property yaw: float

property roll: float