automation events
There is no browser build of this example yet.
Is it the same as C?
- Desktop:verified The Zig version renders a final frame that is byte-identical to the C example.
- Browser:not checked yet The browser comparison does not cover this example yet.
//! raylib [core] example - automation events
//!
//! Zig-API translation of examples/core/core_automation_events.c (raylib 6.2).
//! Example licensed under an unmodified zlib/libpng license.
//! Copyright (c) 2023-2025 Ramon Santamaria (@raysan5)
const std = @import("std");
const rl = @import("raylib");
const gravity = 400;
const player_jump_spd: f32 = 350.0;
const player_hor_spd: f32 = 200.0;
const Player = struct {
position: rl.Vector2,
speed: f32,
can_jump: bool,
const start: Player = .{ .position = .{ .x = 400, .y = 280 }, .speed = 0, .can_jump = false };
};
const EnvElement = struct {
rect: rl.Rectangle,
blocking: bool,
color: rl.Color,
};
const screen_width = 800;
const screen_height = 450;
pub fn main() void {
// Initialization
rl.initWindow(screen_width, screen_height, "raylib [core] example - automation events");
defer rl.closeWindow(); // Close window and OpenGL context
// Define player
var player: Player = .start;
// Define environment elements (platforms)
const env_elements = [_]EnvElement{
.{ .rect = .{ .x = 0, .y = 0, .width = 1000, .height = 400 }, .blocking = false, .color = .light_gray },
.{ .rect = .{ .x = 0, .y = 400, .width = 1000, .height = 200 }, .blocking = true, .color = .gray },
.{ .rect = .{ .x = 300, .y = 200, .width = 400, .height = 10 }, .blocking = true, .color = .gray },
.{ .rect = .{ .x = 250, .y = 300, .width = 100, .height = 10 }, .blocking = true, .color = .gray },
.{ .rect = .{ .x = 650, .y = 300, .width = 100, .height = 10 }, .blocking = true, .color = .gray },
};
// Define camera
var camera = resetCamera(player);
// Automation events
var aelist = rl.loadAutomationEventList(null); // Initialize list of automation events to record new events
defer rl.unloadAutomationEventList(aelist);
rl.setAutomationEventList(&aelist);
var event_recording = false;
var event_playing = false;
var frame_counter: u32 = 0;
var play_frame_counter: u32 = 0;
var current_play_frame: u32 = 0;
rl.setTargetFPS(60);
// Main game loop
while (!rl.windowShouldClose()) {
// Update
const delta_time: f32 = 0.015; // rl.getFrameTime();
// Dropped files logic
if (rl.isFileDropped()) {
const dropped_files = rl.loadDroppedFiles();
defer rl.unloadDroppedFiles(dropped_files); // Unload filepaths from memory
// Supports loading .rgs style files (text or binary) and .png style palette images
const path = std.mem.span(dropped_files.slice()[0]);
if (rl.isFileExtension(path, ".txt;.rae")) {
rl.unloadAutomationEventList(aelist);
aelist = rl.loadAutomationEventList(path);
event_recording = false;
// Reset scene state to play
event_playing = true;
play_frame_counter = 0;
current_play_frame = 0;
player = .start;
camera = resetCamera(player);
}
}
// Update player
if (rl.isKeyDown(.left)) player.position.x -= player_hor_spd * delta_time;
if (rl.isKeyDown(.right)) player.position.x += player_hor_spd * delta_time;
if (rl.isKeyDown(.space) and player.can_jump) {
player.speed = -player_jump_spd;
player.can_jump = false;
}
var hit_obstacle = false;
for (env_elements) |element| {
const p = &player.position;
if (element.blocking and
element.rect.x <= p.x and
element.rect.x + element.rect.width >= p.x and
element.rect.y >= p.y and
element.rect.y <= p.y + player.speed * delta_time)
{
hit_obstacle = true;
player.speed = 0.0;
p.y = element.rect.y;
}
}
if (!hit_obstacle) {
player.position.y += player.speed * delta_time;
player.speed += gravity * delta_time;
player.can_jump = false;
} else player.can_jump = true;
if (rl.isKeyPressed(.r)) {
// Reset game state
player = .start;
camera = resetCamera(player);
}
// Events playing
// NOTE: Logic must be before Camera update because it depends on mouse-wheel value,
// that can be set by the played event... but some other inputs could be affected
if (event_playing) {
// NOTE: Multiple events could be executed in a single frame
const events = aelist.slice();
while (play_frame_counter == events[current_play_frame].frame) {
rl.playAutomationEvent(events[current_play_frame]);
current_play_frame += 1;
if (current_play_frame == aelist.count) {
event_playing = false;
current_play_frame = 0;
play_frame_counter = 0;
rl.traceLog(.info, "FINISH PLAYING!", .{});
break;
}
}
play_frame_counter += 1;
}
// Update camera
camera.target = player.position;
camera.offset = renderCenter();
var min_x: f32 = 1000;
var min_y: f32 = 1000;
var max_x: f32 = -1000;
var max_y: f32 = -1000;
// WARNING: On event replay, mouse-wheel internal value is set
camera.zoom += rl.getMouseWheelMove() * 0.05;
camera.zoom = std.math.clamp(camera.zoom, 0.25, 3.0);
for (env_elements) |element| {
min_x = @min(element.rect.x, min_x);
max_x = @max(element.rect.x + element.rect.width, max_x);
min_y = @min(element.rect.y, min_y);
max_y = @max(element.rect.y + element.rect.height, max_y);
}
const max = rl.getWorldToScreen2D(.{ .x = max_x, .y = max_y }, camera);
const min = rl.getWorldToScreen2D(.{ .x = min_x, .y = min_y }, camera);
if (max.x < screen_width) camera.offset.x = screen_width - (max.x - screen_width / 2.0);
if (max.y < screen_height) camera.offset.y = screen_height - (max.y - screen_height / 2.0);
if (min.x > 0) camera.offset.x = screen_width / 2.0 - min.x;
if (min.y > 0) camera.offset.y = screen_height / 2.0 - min.y;
// Events management
if (rl.isKeyPressed(.s)) { // Toggle events recording
if (!event_playing) {
if (event_recording) {
rl.stopAutomationEventRecording();
event_recording = false;
_ = rl.exportAutomationEventList(aelist, "automation.rae");
rl.traceLog(.info, "RECORDED FRAMES: {d}", .{aelist.count});
} else {
rl.setAutomationEventBaseFrame(180);
rl.startAutomationEventRecording();
event_recording = true;
}
}
} else if (rl.isKeyPressed(.a)) { // Toggle events playing (WARNING: Starts next frame)
if (!event_recording and aelist.count > 0) {
// Reset scene state to play
event_playing = true;
play_frame_counter = 0;
current_play_frame = 0;
player = .start;
camera = resetCamera(player);
}
}
if (event_recording or event_playing) frame_counter += 1 else frame_counter = 0;
// Draw
rl.beginDrawing();
defer rl.endDrawing();
rl.clearBackground(.light_gray);
{
rl.beginMode2D(camera);
defer rl.endMode2D();
// Draw environment elements
for (env_elements) |element| rl.drawRectangleRec(element.rect, element.color);
// Draw player rectangle
rl.drawRectangleRec(.{ .x = player.position.x - 20, .y = player.position.y - 40, .width = 40, .height = 40 }, .red);
}
// Draw game controls
rl.drawRectangle(10, 10, 290, 145, rl.fade(.sky_blue, 0.5));
rl.drawRectangleLines(10, 10, 290, 145, rl.fade(.blue, 0.8));
rl.drawText("Controls:", 20, 20, 10, .black);
rl.drawText("- RIGHT | LEFT: Player movement", 30, 40, 10, .dark_gray);
rl.drawText("- SPACE: Player jump", 30, 60, 10, .dark_gray);
rl.drawText("- R: Reset game state", 30, 80, 10, .dark_gray);
rl.drawText("- S: START/STOP RECORDING INPUT EVENTS", 30, 110, 10, .black);
rl.drawText("- A: REPLAY LAST RECORDED INPUT EVENTS", 30, 130, 10, .black);
// Draw automation events recording indicator
const blink_on = (frame_counter / 15) % 2 == 1;
if (event_recording) {
rl.drawRectangle(10, 160, 290, 30, rl.fade(.red, 0.3));
rl.drawRectangleLines(10, 160, 290, 30, rl.fade(.maroon, 0.8));
rl.drawCircle(30, 175, 10, .maroon);
if (blink_on) rl.drawText(rl.textFormat("RECORDING EVENTS... [{d}]", .{aelist.count}), 50, 170, 10, .maroon);
} else if (event_playing) {
rl.drawRectangle(10, 160, 290, 30, rl.fade(.lime, 0.3));
rl.drawRectangleLines(10, 160, 290, 30, rl.fade(.dark_green, 0.8));
rl.drawTriangle(.{ .x = 20, .y = 155 + 10 }, .{ .x = 20, .y = 155 + 30 }, .{ .x = 40, .y = 155 + 20 }, .dark_green);
if (blink_on) rl.drawText(rl.textFormat("PLAYING RECORDED EVENTS... [{d}]", .{current_play_frame}), 50, 170, 10, .dark_green);
}
}
}
fn renderCenter() rl.Vector2 {
return .{
.x = @as(f32, @floatFromInt(rl.getRenderWidth())) / 2.0,
.y = @as(f32, @floatFromInt(rl.getRenderHeight())) / 2.0,
};
}
fn resetCamera(player: Player) rl.Camera2D {
return .{ .target = player.position, .offset = renderCenter(), .rotation = 0.0, .zoom = 1.0 };
}/*******************************************************************************************
*
* raylib [core] example - automation events
*
* Example complexity rating: [★★★☆] 3/4
*
* Example originally created with raylib 5.0, last time updated with raylib 5.0
*
* Example based on 2d_camera_platformer example by arvyy (@arvyy)
*
* Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
* BSD-like license that allows static linking with closed source software
*
* Copyright (c) 2023-2025 Ramon Santamaria (@raysan5)
*
********************************************************************************************/
#include "raylib.h"
#include "raymath.h"
#define GRAVITY 400
#define PLAYER_JUMP_SPD 350.0f
#define PLAYER_HOR_SPD 200.0f
#define MAX_ENVIRONMENT_ELEMENTS 5
//----------------------------------------------------------------------------------
// Types and Structures Definition
//----------------------------------------------------------------------------------
typedef struct Player {
Vector2 position;
float speed;
bool canJump;
} Player;
typedef struct EnvElement {
Rectangle rect;
int blocking;
Color color;
} EnvElement;
//------------------------------------------------------------------------------------
// Program main entry point
//------------------------------------------------------------------------------------
int main(void)
{
// Initialization
//--------------------------------------------------------------------------------------
const int screenWidth = 800;
const int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [core] example - automation events");
// Define player
Player player = { 0 };
player.position = (Vector2){ 400, 280 };
player.speed = 0;
player.canJump = false;
// Define environment elements (platforms)
EnvElement envElements[MAX_ENVIRONMENT_ELEMENTS] = {
{{ 0, 0, 1000, 400 }, 0, LIGHTGRAY },
{{ 0, 400, 1000, 200 }, 1, GRAY },
{{ 300, 200, 400, 10 }, 1, GRAY },
{{ 250, 300, 100, 10 }, 1, GRAY },
{{ 650, 300, 100, 10 }, 1, GRAY }
};
// Define camera
Camera2D camera = { 0 };
camera.target = player.position;
camera.offset = (Vector2){ GetRenderWidth()/2.0f, GetRenderHeight()/2.0f };
camera.rotation = 0.0f;
camera.zoom = 1.0f;
// Automation events
AutomationEventList aelist = LoadAutomationEventList(0); // Initialize list of automation events to record new events
SetAutomationEventList(&aelist);
bool eventRecording = false;
bool eventPlaying = false;
unsigned int frameCounter = 0;
unsigned int playFrameCounter = 0;
unsigned int currentPlayFrame = 0;
SetTargetFPS(60);
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose())
{
// Update
//----------------------------------------------------------------------------------
float deltaTime = 0.015f;//GetFrameTime();
// Dropped files logic
//----------------------------------------------------------------------------------
if (IsFileDropped())
{
FilePathList droppedFiles = LoadDroppedFiles();
// Supports loading .rgs style files (text or binary) and .png style palette images
if (IsFileExtension(droppedFiles.paths[0], ".txt;.rae"))
{
UnloadAutomationEventList(aelist);
aelist = LoadAutomationEventList(droppedFiles.paths[0]);
eventRecording = false;
// Reset scene state to play
eventPlaying = true;
playFrameCounter = 0;
currentPlayFrame = 0;
player.position = (Vector2){ 400, 280 };
player.speed = 0;
player.canJump = false;
camera.target = player.position;
camera.offset = (Vector2){ GetRenderWidth()/2.0f, GetRenderHeight()/2.0f };
camera.rotation = 0.0f;
camera.zoom = 1.0f;
}
UnloadDroppedFiles(droppedFiles); // Unload filepaths from memory
}
//----------------------------------------------------------------------------------
// Update player
//----------------------------------------------------------------------------------
if (IsKeyDown(KEY_LEFT)) player.position.x -= PLAYER_HOR_SPD*deltaTime;
if (IsKeyDown(KEY_RIGHT)) player.position.x += PLAYER_HOR_SPD*deltaTime;
if (IsKeyDown(KEY_SPACE) && player.canJump)
{
player.speed = -PLAYER_JUMP_SPD;
player.canJump = false;
}
int hitObstacle = 0;
for (int i = 0; i < MAX_ENVIRONMENT_ELEMENTS; i++)
{
EnvElement *element = &envElements[i];
Vector2 *p = &(player.position);
if (element->blocking &&
element->rect.x <= p->x &&
element->rect.x + element->rect.width >= p->x &&
element->rect.y >= p->y &&
element->rect.y <= p->y + player.speed*deltaTime)
{
hitObstacle = 1;
player.speed = 0.0f;
p->y = element->rect.y;
}
}
if (!hitObstacle)
{
player.position.y += player.speed*deltaTime;
player.speed += GRAVITY*deltaTime;
player.canJump = false;
}
else player.canJump = true;
if (IsKeyPressed(KEY_R))
{
// Reset game state
player.position = (Vector2){ 400, 280 };
player.speed = 0;
player.canJump = false;
camera.target = player.position;
camera.offset = (Vector2){ GetRenderWidth()/2.0f, GetRenderHeight()/2.0f };
camera.rotation = 0.0f;
camera.zoom = 1.0f;
}
//----------------------------------------------------------------------------------
// Events playing
// NOTE: Logic must be before Camera update because it depends on mouse-wheel value,
// that can be set by the played event... but some other inputs could be affected
//----------------------------------------------------------------------------------
if (eventPlaying)
{
// NOTE: Multiple events could be executed in a single frame
while (playFrameCounter == aelist.events[currentPlayFrame].frame)
{
PlayAutomationEvent(aelist.events[currentPlayFrame]);
currentPlayFrame++;
if (currentPlayFrame == aelist.count)
{
eventPlaying = false;
currentPlayFrame = 0;
playFrameCounter = 0;
TraceLog(LOG_INFO, "FINISH PLAYING!");
break;
}
}
playFrameCounter++;
}
//----------------------------------------------------------------------------------
// Update camera
//----------------------------------------------------------------------------------
camera.target = player.position;
camera.offset = (Vector2){ GetRenderWidth()/2.0f, GetRenderHeight()/2.0f };
float minX = 1000, minY = 1000, maxX = -1000, maxY = -1000;
// WARNING: On event replay, mouse-wheel internal value is set
camera.zoom += ((float)GetMouseWheelMove()*0.05f);
if (camera.zoom > 3.0f) camera.zoom = 3.0f;
else if (camera.zoom < 0.25f) camera.zoom = 0.25f;
for (int i = 0; i < MAX_ENVIRONMENT_ELEMENTS; i++)
{
EnvElement *element = &envElements[i];
minX = fminf(element->rect.x, minX);
maxX = fmaxf(element->rect.x + element->rect.width, maxX);
minY = fminf(element->rect.y, minY);
maxY = fmaxf(element->rect.y + element->rect.height, maxY);
}
Vector2 max = GetWorldToScreen2D((Vector2){ maxX, maxY }, camera);
Vector2 min = GetWorldToScreen2D((Vector2){ minX, minY }, camera);
if (max.x < screenWidth) camera.offset.x = screenWidth - (max.x - (float)screenWidth/2);
if (max.y < screenHeight) camera.offset.y = screenHeight - (max.y - (float)screenHeight/2);
if (min.x > 0) camera.offset.x = (float)screenWidth/2 - min.x;
if (min.y > 0) camera.offset.y = (float)screenHeight/2 - min.y;
//----------------------------------------------------------------------------------
// Events management
if (IsKeyPressed(KEY_S)) // Toggle events recording
{
if (!eventPlaying)
{
if (eventRecording)
{
StopAutomationEventRecording();
eventRecording = false;
ExportAutomationEventList(aelist, "automation.rae");
TraceLog(LOG_INFO, "RECORDED FRAMES: %i", aelist.count);
}
else
{
SetAutomationEventBaseFrame(180);
StartAutomationEventRecording();
eventRecording = true;
}
}
}
else if (IsKeyPressed(KEY_A)) // Toggle events playing (WARNING: Starts next frame)
{
if (!eventRecording && (aelist.count > 0))
{
// Reset scene state to play
eventPlaying = true;
playFrameCounter = 0;
currentPlayFrame = 0;
player.position = (Vector2){ 400, 280 };
player.speed = 0;
player.canJump = false;
camera.target = player.position;
camera.offset = (Vector2){ GetRenderWidth()/2.0f, GetRenderHeight()/2.0f };
camera.rotation = 0.0f;
camera.zoom = 1.0f;
}
}
if (eventRecording || eventPlaying) frameCounter++;
else frameCounter = 0;
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(LIGHTGRAY);
BeginMode2D(camera);
// Draw environment elements
for (int i = 0; i < MAX_ENVIRONMENT_ELEMENTS; i++)
{
DrawRectangleRec(envElements[i].rect, envElements[i].color);
}
// Draw player rectangle
DrawRectangleRec((Rectangle){ player.position.x - 20, player.position.y - 40, 40, 40 }, RED);
EndMode2D();
// Draw game controls
DrawRectangle(10, 10, 290, 145, Fade(SKYBLUE, 0.5f));
DrawRectangleLines(10, 10, 290, 145, Fade(BLUE, 0.8f));
DrawText("Controls:", 20, 20, 10, BLACK);
DrawText("- RIGHT | LEFT: Player movement", 30, 40, 10, DARKGRAY);
DrawText("- SPACE: Player jump", 30, 60, 10, DARKGRAY);
DrawText("- R: Reset game state", 30, 80, 10, DARKGRAY);
DrawText("- S: START/STOP RECORDING INPUT EVENTS", 30, 110, 10, BLACK);
DrawText("- A: REPLAY LAST RECORDED INPUT EVENTS", 30, 130, 10, BLACK);
// Draw automation events recording indicator
if (eventRecording)
{
DrawRectangle(10, 160, 290, 30, Fade(RED, 0.3f));
DrawRectangleLines(10, 160, 290, 30, Fade(MAROON, 0.8f));
DrawCircle(30, 175, 10, MAROON);
if (((frameCounter/15)%2) == 1) DrawText(TextFormat("RECORDING EVENTS... [%i]", aelist.count), 50, 170, 10, MAROON);
}
else if (eventPlaying)
{
DrawRectangle(10, 160, 290, 30, Fade(LIME, 0.3f));
DrawRectangleLines(10, 160, 290, 30, Fade(DARKGREEN, 0.8f));
DrawTriangle((Vector2){ 20, 155 + 10 }, (Vector2){ 20, 155 + 30 }, (Vector2){ 40, 155 + 20 }, DARKGREEN);
if (((frameCounter/15)%2) == 1) DrawText(TextFormat("PLAYING RECORDED EVENTS... [%i]", currentPlayFrame), 50, 170, 10, DARKGREEN);
}
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
}From raylib 6.2. The original on GitHub.