emerald 0.3.214

A lite, fully featured 2D game engine.
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use emerald::{
    font::FontKey,
    rendering::components::{Label, Sprite},
    *,
};

// Bunnymark is super disappointing right now, need to fix
// https://github.com/Bombfuse/emerald/issues/10

#[derive(Clone, Debug)]
struct Velocity {
    pub x: f32,
    pub y: f32,
}
impl Velocity {
    pub fn new(x: f32, y: f32) -> Self {
        Velocity { x, y }
    }
}

#[cfg_attr(target_os = "android", ndk_glue::main(backtrace = "on"))]
pub fn main() {
    let mut settings = GameSettings::default();
    settings.render_settings.resolution = (320 * 5, 180 * 5);

    emerald::start(
        Box::new(BunnymarkGame {
            count: 0,
            world: World::new(),
            fps_label: None,
            bunnymark_label: None,
        }),
        settings,
    )
}

pub struct BunnymarkGame {
    count: u64,
    world: World,
    fps_label: Option<Label>,
    bunnymark_label: Option<Label>,
}
impl Game for BunnymarkGame {
    fn initialize(&mut self, mut emd: Emerald) {
        emd.set_asset_folder_root(String::from("./examples/assets/"));

        let sprite = emd.loader().sprite("bunny.png").unwrap();

        let mut transform = Transform::default();

        let start = 1_000;
        self.count = start;
        self.world.spawn_batch((0..start).map(|_| {
            transform.translation.x += 1.0;
            transform.translation.y += 1.0;
            (transform, sprite.clone(), Velocity::new(500.0, 300.0))
        }));

        let font = emd.loader().font("Roboto-Light.ttf", 40).unwrap();
        self.bunnymark_label = Some(Label::new("", font.clone(), 40));
        self.fps_label = Some(Label::new("", font, 40));
    }

    #[inline]
    fn update(&mut self, mut emd: Emerald) {
        let delta = emd.delta();

        let now = std::time::Instant::now();
        let (screen_width, screen_height) = emd.screen_size();
        let screen_width = screen_width as f32;
        let screen_height = screen_height as f32;

        let sprite_width = 32.0;

        if emd.input().is_key_just_pressed(KeyCode::Space) {
            let mut sprite = emd.loader().sprite("bunny.png").unwrap();
            sprite.offset = Vector2::new(-10.0, 0.0);

            let mut transform = Transform::default();
            self.count += 1000;
            self.world.spawn_batch((0..1000).map(|_| {
                transform.translation.x += 6.0;
                transform.translation.y += 1.0;

                (transform, sprite.clone(), Velocity::new(500.0, 300.0))
            }));
        }

        for (_, (_, transform, mut vel)) in self
            .world
            .query::<(&Sprite, &mut Transform, &mut Velocity)>()
            .iter()
        {
            if transform.translation.x >= screen_width / 2.0 - sprite_width / 2.0 {
                transform.translation.x = screen_width / 2.0 - sprite_width / 2.0;
                vel.x *= -1.0;
            }

            if transform.translation.x <= -screen_width / 2.0 {
                transform.translation.x = -screen_width / 2.0;
                vel.x *= -1.0;
            }

            if transform.translation.y >= screen_height / 2.0 - sprite_width {
                transform.translation.y = screen_height / 2.0 - sprite_width;
                vel.y *= -1.0;
            }

            if transform.translation.y <= -screen_height / 2.0 {
                transform.translation.y = -screen_height / 2.0;
                vel.y *= -1.0;
            }

            transform.translation.x += vel.x * delta;
            transform.translation.y += vel.y * delta;
        }
        println!("update {:?}", std::time::Instant::now() - now);
    }

    fn draw(&mut self, mut emd: Emerald) {
        let now = std::time::Instant::now();
        emd.graphics().begin().unwrap();
        emd.graphics().draw_world(&mut self.world).unwrap();

        self.fps_label.as_mut().unwrap().text = format!("FPS: {}", emd.fps() as usize);
        self.bunnymark_label.as_mut().unwrap().text = format!("{} bunnies", (self.count));
        emd.graphics()
            .draw_label(
                &self.fps_label.as_ref().unwrap(),
                &Transform::from_translation((-300.0, 150.0)),
            )
            .unwrap();
        emd.graphics()
            .draw_label(
                &self.bunnymark_label.as_ref().unwrap(),
                &Transform::from_translation((-300.0, 100.0)),
            )
            .unwrap();

        emd.graphics().render().unwrap();
        println!("draw {:?}", std::time::Instant::now() - now);
    }
}