Crate cat_box

Work in progress game engine, inspired by arcade.

use cat_box::{draw_text, Game, Sprite, SpriteCollection, get_mouse_state, get_keyboard_state};
use sdl2::keyboard::Scancode;

fn main() {
   let game = Game::new("catbox demo", 1000, 800);

    let mut i = 0u8;
    let mut s = Sprite::new("duck.png", 500, 400).unwrap();
    let mut s2 = Sprite::new("duck.png", 400, 500).unwrap();

    let mut coll = SpriteCollection::new();
    for n in 0..10 {
        for o in 0..8 {
            let x = Sprite::new("duck.png", n * 100, o * 100).unwrap();
            coll.push(x);
        }
    }
    game.run(|ctx| {
        i = (i + 1) % 255;
        ctx.set_background_colour(i as u8, 64, 255);

        draw_text(
            ctx,
            format!("i is {}", i),
            "MesloLGS NF Regular.ttf",
            72,
            (300, 300),
            cat_box::TextMode::Shaded {
                foreground: (255, 255, 255),
                background: (0, 0, 0),
            },
        )
        .unwrap();

        let (start_x, start_y) = s.position().into();
        let m = get_mouse_state(ctx);
        let x_diff = m.x - start_x;
        let y_diff = m.y - start_y;

        let angle = (y_diff as f64).atan2(x_diff as f64);
        s.set_angle(angle.to_degrees());

        for spr in coll.iter() {
            let (start_x, start_y) = spr.position().into();
            let m = get_mouse_state(ctx);
            let x_diff = m.x - start_x;
            let y_diff = m.y - start_y;

            let angle = (y_diff as f64).atan2(x_diff as f64);
            spr.set_angle(angle.to_degrees());
        }

        let keys = get_keyboard_state(ctx).keys;

        for key in keys {
            let offset = match key {
                Scancode::Escape => {
                    game.terminate();
                    (0, 0)
                },
                Scancode::W | Scancode::Up => (0, 5),
                Scancode::S | Scancode::Down => (0, -5),
                Scancode::A | Scancode::Left => (-5, 0),
                Scancode::D | Scancode::Right => (5, 0),
                _ => (0, 0),
            };

            s.translate(offset);

            for spr in coll.iter() {
                spr.translate(offset);
            }
        }

        s2.draw(ctx).unwrap();
        s.draw(ctx).unwrap();
        coll.draw(ctx).unwrap();
    })
    .unwrap();
}

Re-exports

pub use sdl2;

pub use sdl2::event::Event;

pub use sdl2::keyboard::Scancode;

pub use sdl2::pixels::Color;

Modules

physics

Basic physics utilities for cat-box.

vec2

Types representing directions and locations in 2d and 3d space.

Macros

cloned

Utility macro for cloning things into closures.

Structs

CatboxError

Context

Game context.

Events

Wrapper type around SDL’s EventPump. See those docs for more info.

Game

Representation of the game.

KeyboardRepr

Representation of the keyboard state.

MouseRepr

Representation of the mouse state.

Sprite

Representation of a sprite.

SpriteCollection

Manages a collection of Sprites.

Enums

TextMode

Set the mode for drawing text.

Functions

draw_text

Draw text to the screen.

get_keyboard_state

Get the keyboard state.

get_mouse_state

Get the mouse state.

Type Aliases

Result