pong.c

Capstone tutorial - a complete two-player Pong, tying together the subsystems you've seen so far: window, input, drawing, and timing.

Capstone tutorial - a complete two-player Pong, tying together the subsystems you've seen so far: window, input, drawing, and timing.This is the finale of the tutorial series. By the end of audio_pcm.c you knew how to open a window, draw to it, react to input, and time your frames. pong.c is the first tutorial that does all of those things together in a real (if minimal) game.

It is deliberately kept small. It stays with the simple variable-timestep loop from the earlier tutorials rather than the fixed-step API (via a bj_app_fixed_step_fn callback). Reach for fixed-step when determinism across machines matters (networked play, physics that must replay identically); see physics_particle.c and physics_kinematics.c. Pong does not need it, and the simpler loop keeps the capstone readable.

What you'll learn

• How to structure a complete game: one state struct, a fixed update / draw split, and the lifecycle callbacks holding the pieces.
• How to pace a real-time loop with one line, bj_set_frame_rate, instead of scattering sleeps through your code. Without a cap, bj_run_app calls the step callback as fast as it can and burns a full core for a game that only needs about 60 updates per second.
• How to do frame-rate-independent motion using bj_step_delay_stopwatch as your delta-time source, with a clamp to keep the ball from teleporting after a pause.
• How to poll continuous-state input with bj_get_key (the right tool for paddle control; callbacks would only give you edge events).

Controls

• Left paddle: W (up) and S (down).
• Right paddle: Up and Down arrows.
• Quit: ESC.

Walkthrough

1. One state struct, passed through the lifecycle

Earlier tutorials used file-scope globals (window, data, ...). That works for one-screen demos; it scales badly. Pong gathers everything into pong_t, declared zero-initialised on the stack in main (pong_t pong = {0}), and passes a pointer through the setup, step, and teardown callbacks via the App API's user_data parameter (registered with each bj_set_*_callback call). The zero-init matters: bj_stopwatch's "zero-init = valid" property means we don't need an explicit reset call.

2. Frame pacing with no effort

Pong uses the default frame rate (60 Hz), so there's nothing to set. bj_run_app measures how long each iteration took and sleeps off just the time left to reach 60 iterations per second, so the loop yields the CPU instead of melting a core. Non-default rates can be set inside the setup callback with bj_set_frame_rate.

3. Delta time, the right way

bj_step_delay_stopwatch returns the seconds elapsed since the last call and advances the internal step in one go. Every motion computation is then position += velocity * dt, so the game runs at the same speed whether the frame is 1 ms or 16 ms.

The clamped_dt line caps the step at 50 ms. Without it, alt-tabbing away for a few seconds (or any pause longer than a few frames) would resume with a giant dt and teleport the ball through a paddle. Cap-and-continue is the standard remedy.

4. Polled input vs. callbacks

start.c and event_callbacks.c used the callback style, perfect for one-shot events ("ESC was pressed"). For paddles you want the opposite: "is W *currently held*?" bj_get_key answers exactly that. We still use the ESC callback (via bj_close_on_escape), so this tutorial shows the two styles cooperating: callbacks for discrete events, polling for continuous state.

5. Cleanup order

Reverse of init: window, then bj_end. The state struct lives on the stack in main, so there is nothing to free; once bj_run_app returns, main drops it automatically.

What's next

You've finished the tutorial series. From here you can:

• Read any of the single-API demos in examples/ that look interesting (each is now slotted into its topic; visit Bitmap, Audio, Random, Network, …).
• Read the Windows and Audio topics for the rationale behind Banjo's runtime backend selection.
• Start your own project: the FetchContent recipe in Using Banjo has you running in under a minute.

 
#include <banjo/app.h>
#include <banjo/main.h>
#include <banjo/bitmap.h>
#include <banjo/draw.h>
#include <banjo/event.h>
#include <banjo/log.h>
#include <banjo/memory.h>
#include <banjo/rect.h>
#include <banjo/system.h>
#include <banjo/time.h>
#include <banjo/window.h>
 
#define W               800
#define H               600
#define PAD_W            16
#define PAD_H            80
#define PAD_MARGIN       32
#define BALL_R            8
#define PAD_SPEED       360.0f   /* pixels per second                 */
#define BALL_SPEED      280.0f   /* pixels per second (initial)       */
#define BOUNCE_SPEEDUP    1.05f  /* paddle hit accelerates the ball   */
#define MAX_DT            0.05f  /* clamp delta to avoid teleporting  */
 
typedef struct {
    bj_window*    window;
    bj_stopwatch  sw;
 
    float pad_left_y;
    float pad_right_y;
    float ball_x, ball_y;
    float ball_vx, ball_vy;
} pong_t;
 
static void reset_ball(pong_t* p, int last_winner) {
    p->ball_x  = (float)W * 0.5f;
    p->ball_y  = (float)H * 0.5f;
    p->ball_vx = (last_winner >= 0 ? +BALL_SPEED : -BALL_SPEED);
    p->ball_vy = (last_winner & 1) ?  BALL_SPEED * 0.6f
                                   : -BALL_SPEED * 0.6f;
}
 
static void update(pong_t* p, float dt) {
    /* --- Paddle input: continuous-state polling -------------------- */
    if (bj_get_key(p->window, BJ_KEY_W)    == BJ_PRESS) p->pad_left_y  -= PAD_SPEED * dt;
    if (bj_get_key(p->window, BJ_KEY_S)    == BJ_PRESS) p->pad_left_y  += PAD_SPEED * dt;
    if (bj_get_key(p->window, BJ_KEY_UP)   == BJ_PRESS) p->pad_right_y -= PAD_SPEED * dt;
    if (bj_get_key(p->window, BJ_KEY_DOWN) == BJ_PRESS) p->pad_right_y += PAD_SPEED * dt;
 
    /* --- Clamp paddles to the playfield ---------------------------- */
    if (p->pad_left_y  < 0)         p->pad_left_y  = 0;
    if (p->pad_left_y  > H - PAD_H) p->pad_left_y  = (float)(H - PAD_H);
    if (p->pad_right_y < 0)         p->pad_right_y = 0;
    if (p->pad_right_y > H - PAD_H) p->pad_right_y = (float)(H - PAD_H);
 
    /* --- Ball ------------------------------------------------------ */
    p->ball_x += p->ball_vx * dt;
    p->ball_y += p->ball_vy * dt;
 
    /* Top / bottom walls bounce */
    if (p->ball_y < BALL_R) {
        p->ball_y = BALL_R;
        p->ball_vy = -p->ball_vy;
    }
    if (p->ball_y > H - BALL_R) {
        p->ball_y = (float)(H - BALL_R);
        p->ball_vy = -p->ball_vy;
    }
 
    /* Left paddle */
    if (p->ball_vx < 0 &&
        p->ball_x - BALL_R < PAD_MARGIN + PAD_W &&
        p->ball_y > p->pad_left_y &&
        p->ball_y < p->pad_left_y + PAD_H) {
        p->ball_x  = (float)(PAD_MARGIN + PAD_W + BALL_R);
        p->ball_vx = -p->ball_vx * BOUNCE_SPEEDUP;
    }
    /* Right paddle */
    if (p->ball_vx > 0 &&
        p->ball_x + BALL_R > W - PAD_MARGIN - PAD_W &&
        p->ball_y > p->pad_right_y &&
        p->ball_y < p->pad_right_y + PAD_H) {
        p->ball_x  = (float)(W - PAD_MARGIN - PAD_W - BALL_R);
        p->ball_vx = -p->ball_vx * BOUNCE_SPEEDUP;
    }
 
    /* Score (ball escaped past a paddle): reset toward the loser */
    if (p->ball_x < -BALL_R) {
        reset_ball(p, +1);
    } else if (p->ball_x > W + BALL_R) {
        reset_ball(p, -1);
    }
}
 
static void draw(pong_t* p, bj_bitmap* fb) {
    bj_clear_bitmap(fb);
 
    const uint32_t white = bj_make_bitmap_pixel(fb, 0xFF, 0xFF, 0xFF);
    const uint32_t gray  = bj_make_bitmap_pixel(fb, 0x40, 0x40, 0x40);
 
    /* Dashed centre line */
    for (int16_t y = 0; y < H; y = (int16_t)(y + 24)) {
        bj_rect dash = { .x = (int16_t)(W / 2 - 2), .y = y, .w = 4, .h = 12 };
        bj_draw_filled_rectangle(fb, &dash, gray);
    }
 
    /* Paddles */
    bj_rect lpad = { .x = PAD_MARGIN,                  .y = (int16_t)p->pad_left_y,
                     .w = PAD_W,                       .h = PAD_H };
    bj_rect rpad = { .x = (int16_t)(W - PAD_MARGIN - PAD_W), .y = (int16_t)p->pad_right_y,
                     .w = PAD_W,                       .h = PAD_H };
    bj_draw_filled_rectangle(fb, &lpad, white);
    bj_draw_filled_rectangle(fb, &rpad, white);
 
    /* Ball */
    bj_draw_filled_circle(fb, (int)p->ball_x, (int)p->ball_y, BALL_R, white);
}
 
static void on_draw(
    struct bj_window*        window,
    struct bj_render_target* target,
    const struct bj_rect*    dirty,
    void*                    user_data
) {
    (void)window; (void)dirty;
    draw((pong_t*)user_data, bj_render_target_bitmap(target));
}
 
static void* setup(struct bj_app* app, void* init_data) {
    (void)init_data;
    pong_t* p = bj_calloc(sizeof(pong_t));
 
    if (!bj_begin(BJ_VIDEO_SYSTEM, 0)) {
        bj_err("pong: video init failed");
        bj_free(p);
        bj_quit_app(app, 1);
        return 0;
    }
 
    p->window = bj_bind_window("Pong - W/S vs Up/Down (ESC to quit)",
                               100, 100, W, H, 0, 0);
    bj_set_key_callback(bj_close_on_escape, 0);
    bj_set_draw_callback(p->window, on_draw, p);
 
    p->pad_left_y  = (float)(H - PAD_H) * 0.5f;
    p->pad_right_y = (float)(H - PAD_H) * 0.5f;
    reset_ball(p, 0);
    return p;
}
 
static void step(struct bj_app* app, struct bj_tick_info tick, void* user_data) {
    (void)tick;
    pong_t* p = (pong_t*)user_data;
 
    const float dt         = (float)bj_step_delay_stopwatch(&p->sw);
    const float clamped_dt = dt > MAX_DT ? MAX_DT : dt;
 
    update(p, clamped_dt);
    bj_invalidate_window(p->window);
    bj_dispatch_events();
 
    if (bj_should_close_window(p->window)) {
        bj_quit_app(app, 0);
    }
}
 
static void teardown(struct bj_app* app, void* user_data) {
    (void)app;
    pong_t* p = (pong_t*)user_data;
    bj_unbind_window(p->window);
    bj_end();
    bj_free(p);
}
 
int main(int argc, char* argv[]) {
    (void)argc; (void)argv;
    return bj_run_app(setup, step, 0, teardown, 0);
}