Crate rlbot

RLBot is a framework for creating offline Rocket League bots. This crate lets you write bots using a simple, safe interface that should feel comfortable to Rust developers.

Most types in this crate are exported directly from RLBot, so for anything not documented here, you'll need to use RLBot's docs as the authoritative reference.

There are two ways to use this crate:

1. run_bot and Bot – This is the high-level interface. It plays a single match from start to finish. It expects the app to have been launched by the RLBot framework, and runs its own game loop under framework control.
2. init and RLBot – This is the low-level interface. You can use this to directly access the innards of RLBot for scripting, integration tests, or any other custom use-case.

Examples

This crate comes with plenty examples to get you started. All the examples can be run directly from the repo. Follow these steps to run an example:

1. Run Rocket League with the -rlbot flag. The flag causes Rocket League to start a local UDP server that lets RLBot control the game. It also disables the online features of the game.

   Steam.exe -applaunch 252950 -rlbot
   

2. Run RLBot.exe, which is included as part of the Python rlbot package. This is a service process that helps bots communicate with the game.

3. Run the example (here we run the example called simple):

   cargo run --example simple
   

examples/simple (Source)

This is a simple ATBA, or Always Towards Ball Agent.

Key APIs:

• init
• RLBot::start_match
• Packeteer::next
• RLBot::update_player_input

examples/simple_flatbuffer (Source)

Another ATBA, but using the lower-level flatbuffer functions. All of the low-level functions in RLBot's interface make use of flatbuffers.

Key APIs:

• Packeteer::next_flatbuffer
• [RLBot::update_player_input_flatbuffer]

examples/rendering (Source)

This example shows how to draw simple shapes to the game window. If you don't see anything, try pressing PageUp, which is RLBot's shortcut for turning on rendering.

Key APIs:

• RLBot::begin_render_group
• RenderGroup::render

examples/gravity (Source)

A fun example showing how to set game state.

Key APIs:

• [RLBot::set_game_state_struct]

examples/gravity_flatbuffer (Source)

This works exactly the same as the previous example, except it uses the low-level flatbuffer interface.

Key APIs:

• RLBot::set_game_state

examples/bot (Source)

I saved the best for last. This is a full-fledged RLBot bot that can run within the RLBot framework. It's different than the other examples, in that it requires a working RLBot Python setup. Follow the instructions in RLBotPythonExample to make sure you have all the necessary dependencies installed. Once you have that working, you are ready to roll.

Do not run Rocket League or RLBot.exe—the framework will take care of that automatically. Just run this command:

cargo build --example bot && python -c "from rlbot import runner; runner.main()"

Key APIs:

• run_bot

Modules

ffi
flat

Structs

BallInfo
BoostPadState
Color	A color that can be used to draw in a RenderGroup.
ControllerState	The inputs that control a car.
DesiredBallState	State which can be set on the ball.
DesiredBoostState	State which can be set for a boost pickup.
DesiredCarState	State which can be set on a car.
DesiredGameInfoState	State which can be set for a boost pickup.
DesiredGameState	The top-level struct containing all settable game state.
DesiredPhysics	Rigid-body state which can be set.
DropshotBallInfo
DropshotTile
FrameworkArgs	The arguments passed by the RLBot framework.
GameInfo
GameTickPacket
InitOptions	Options for customizing the way the framework is initialized.
LoadoutPaint	Specification for 'painted' items. See https://github.com/RLBot/RLBot/wiki/Bot-Customization
MatchSettings	Options for starting a match.
MutatorSettings
Packeteer	An iterator-like object that yields packets from the game as they occur.
Physicist	An iterator-like object that yields physics ticks from the game as they occur.
Physics
PlayerConfiguration	Describes one of the players in a match.
PlayerInfo
PlayerLoadout	The car type, color, and other aspects of the player's appearance. See https://github.com/RLBot/RLBot/wiki/Bot-Customization
PsyonixBotPlayer	A psyonix bot, e.g. All Star bot
Quaternion	Expresses the rotation state of an object. Learn about quaternions here: https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation You can tinker with them here to build an intuition: https://quaternions.online/
RLBot	The low-level interface to RLBot. All RLBot calls that are available can be made through this struct.
RenderGroup	A render group in the process of being built.
Rotator	Expresses the rotation state of an object in Euler angles, with values in radians.
RotatorPartial	A rotation in 3D space represented by Euler angles.
ScoreInfo
TeamInfo
Touch	Represents contact between a car and the ball.
Vector3
Vector3Partial	Represents a vector in 3D space.

Enums

BallBouncinessOption
BallMaxSpeedOption
BallSizeOption
BallTypeOption
BallWeightOption
BoostOption
DemolishOption
GameMap
GameMode
GameSpeedOption
GravityOption
MatchLength
MaxScore
OvertimeOption
PlayerClass
RespawnTimeOption
RumbleOption
SeriesLengthOption
TileState

Traits

Bot	A bot that can run within the RLBot framework. Instances of Bot are used by the run_bot function.

Functions

init	Initializes RLBot and returns a ready-to-use RLBot object.
init_with_options	Initializes RLBot and returns a ready-to-use RLBot object.
parse_framework_args	Parse the arguments passed by the RLBot framework.
run_bot	Runs a bot under control of the RLBot framework.