Skip to content

Rendering

Jump to bottom
Eric Veilleux edited this page Mar 8, 2025 · 7 revisions

About

Rendering allows you to draw objects on screen, which can make debugging and testing your bot so much easier. For example, you could draw the predicted ball path, or draw where the bot wants to go.

The basics

The renderer object is built into the Bot class, so you don't need to import anything other than Bot. Each time you want to render something, you start with self.renderer.begin_rendering() and end with self.renderer.end_rendering(). The rendering code goes in between the begin_rendering() and end_rendering(). Let's take a look at an example:

fromrlbot.managersimportBotfromrlbot.flatimportGamePacket, ControllerStateclassRenderingTutorial(Bot):
defget_output(self, packet: GamePacket) ->ControllerState:
controller=ControllerState()
self.renderer.begin_rendering()
self.renderer.draw_rect_2d(20, 20, 200, 200, self.renderer.black, True)
self.renderer.end_rendering()
returncontroller# ...

We can see here that upon every call of get_output, the on-screen drawings get updated. In this example, the draw_rect_2d method is used.

Rendering a large amount

If you try rendering a lot of things at once, you will start to notice this message: Too many bytes sent this tick, skipping message

There are a few ways to get around this.

  1. Reduce the amount of things you are rendering. This is the most straightforward way to reduce the amount of bytes sent. If you're rendering all 720 ball prediction slices, try only rendering 1 of 4 slices or so.
  2. Use the renderer.draw_polyline_3d method. This method more efficiently sends a large amount of points to be drawn in a continuous line.
  3. Avoid drawing every frame. If you only need to draw something once, don't draw it every frame. When calling start_rendering, you can pass in a group_id string. By default, the group id is just "default". Old renders are only cleared when a new render with the same group id is sent. Using this, you can send parts of your render every frame, and that render will persist until the match ends (or a new render from the same process gets sent with the same group id).

The methods of renderer

renderer.create_color and other colors

defcreate_color(red: int, green: int, blue: int, alpha: int=255) ->Color: ...
  • red, green, blue, and alpha are integers between 0 and 255.

This is used for creating colors that you can use for the other methods that draw on screen. The renderer also has various attributes that gives you the most common colors:

renderer.transparentrenderer.blackrenderer.whiterenderer.greyrenderer.grayrenderer.bluerenderer.redrenderer.greenrenderer.limerenderer.yellowrenderer.orangerenderer.cyanrenderer.pinkrenderer.purplerenderer.teal

Lastly, there's the team_color method. Using this your bot renders with different colors depending on which team it is on.

defteam_color(team: int, alt_color: bool=False) ->Color: ...
  • team: Index of a team (0 for blue, 1 for orange)
  • alt_color: (Optional, False by default) If True, the alternate team color will be used.

renderer.draw_rect_2d

defdraw_rect_2d(
self,
x: float,
y: float,
width: float,
height: float,
color: Color,
centered: bool=True,
): ...
  • x, y: The position of the rectangle. Range is from 0 to 1. (0, 0) is the top left corner of the screen.
  • width, height: The size of the rectangle. Range is from 0 to 1.
  • color: The color of the rectangle.
  • centered: (Optional, True by default) If True, the rectangle will be drawn centered on the x and y coordinates. Otherwise, the top left corner of the rectangle will be drawn on the x and y coordinates.

renderer.draw_string_2d

defdraw_string_2d(
self,
text: str,
x: float,
y: float,
scale: float,
foreground: Color,
background: Color=Color(),
h_align: TextHAlign=TextHAlign.Left,
v_align: TextVAlign=TextVAlign.Top,
): ...
  • x, y: The position of the rectangle. Range is from 0 to 1. (0, 0) is the top left corner of the screen.
  • scale: The size of the text. 1 is the "normal" size.
  • foreground: The color of the text.
  • background: (Optional) The color of the background of the text. Transparent by default.
  • h_align: (Optional) The horizontal alignment of the text. Default is Left.
  • v_align: (Optional) The vertical alignment of the text. Default is Top.

renderer.draw_rect_3d

defdraw_rect_3d(
self,
anchor: RenderAnchor|BallAnchor|CarAnchor|Vector3,
width: float,
height: float,
color: Color,
): ...
  • anchor: The position of the rectangle. Can be a RenderAnchor, BallAnchor, CarAnchor, or Vector3.
  • width, height: The size of the rectangle.
  • color: The color of the rectangle.

renderer.draw_string_3d

defdraw_string_3d(
self,
text: str,
anchor: RenderAnchor|BallAnchor|CarAnchor|Vector3,
scale: float,
foreground: Color,
background: Color=Color(),
h_align: TextHAlign=TextHAlign.Left,
v_align: TextVAlign=TextVAlign.Top,
): ...
  • text: The text to draw.
  • anchor: The position of the text. Can be a RenderAnchor, BallAnchor, CarAnchor, or Vector3.
  • scale: The size of the text. 1 is the "normal" size.
  • foreground: The color of the text.
  • background: (Optional) The color of the background of the text. Transparent by default.
  • h_align: (Optional) The horizontal alignment of the text. Default is Left.
  • v_align: (Optional) The vertical alignment of the text. Default is Top.

renderer.draw_line_3d

defdraw_line_3d(
self,
start: RenderAnchor|BallAnchor|CarAnchor|Vector3,
end: RenderAnchor|BallAnchor|CarAnchor|Vector3,
color: Color,
): ...
  • start: The start of the line. Can be a RenderAnchor, BallAnchor, CarAnchor, or Vector3.
  • end: The end of the line. Can be a RenderAnchor, BallAnchor, CarAnchor, or Vector3.
  • color: The color of the line.

renderer.draw_polyline_3d

defdraw_polyline_3d(
self,
points: Sequence[Vector3],
color: Color,
): ...
  • points: A list of Vector3s that make up the polyline.
  • color: The color of the polyline.

Clone this wiki locally