pong.c

Go to the documentation of this file.

 
#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);
}