comfy 0.4.0

A comfy 2d game engine in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use comfy::*;

simple_game!("LDTK Example", GameState, setup, update);

const LDTK_PATH: &str = "assets/comfy_ldtk.ldtk";

pub struct GameState {
    pub ldtk_map: LdtkWorldMap,
}

impl GameState {
    pub fn new(_c: &EngineState) -> Self {
        Self {
            ldtk_map: LdtkWorldMap::new(
                parse_ldtk_map(include_str!("../../assets/comfy_ldtk.ldtk"))
                    .unwrap(),
                LDTK_PATH,
            ),
        }
    }
}

fn setup(_state: &mut GameState, c: &mut EngineContext) {
    c.load_texture_from_bytes(
        "comfy",
        include_bytes!(concat!(
            env!("CARGO_MANIFEST_DIR"),
            "/../assets/comfy.png"
        )),
    );

    c.load_texture_from_bytes(
        "tileset",
        include_bytes!(concat!(
            env!("CARGO_MANIFEST_DIR"),
            "/../assets/tiles.png"
        )),
    );
}

fn update(state: &mut GameState, _c: &mut EngineContext) {
    clear_background(AQUAMARINE);

    let map = &state.ldtk_map.json;
    let level = &map.levels[0];
    for (i, layer) in
        level.layer_instances.as_ref().unwrap().iter().rev().enumerate()
    {
        let grid_size = layer.grid_size as f32;

        let tileset = layer
            .tileset_def_uid
            .and_then(|uid| map.defs.tilesets.iter().find(|t| t.uid == uid));

        if let Some(_tileset) = tileset {
            let texture = texture_id("tileset");

            // WORLD - TILES
            for tile in layer.grid_tiles.iter() {
                let pos = tile.to_world(layer);

                draw_sprite_ex(
                    texture,
                    pos,
                    WHITE,
                    10 + i as i32,
                    DrawTextureParams {
                        dest_size: Some(
                            splat(grid_size / 16.0).as_world_size(),
                        ),
                        source_rect: Some(IRect::new(
                            ivec2(tile.src[0] as i32, tile.src[1] as i32),
                            ivec2(grid_size as i32, grid_size as i32),
                        )),
                        flip_x: tile.f == 1 || tile.f == 3,
                        flip_y: tile.f == 2 || tile.f == 3,
                        ..Default::default()
                    },
                );
            }
        }

        // CHARACTERS - ENTITIES
        for entity in layer.entity_instances.iter() {
            if entity.identifier == "Character" {
                let center = entity.world_pos(layer.c_hei, layer.grid_size);
                let size = entity.world_size(layer.grid_size);

                draw_rect(center, size, RED.alpha(0.5), 100);
                draw_text(
                    entity.str_field("Name").unwrap_or_default(),
                    center,
                    BLACK,
                    TextAlign::Center,
                );
            } else {
                error!("Missing: entity {:?}", entity);
            }
        }
    }
}