qilin 0.3.2

Lightweight Game Engine for making fun 2d Games 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

use crate::game::context::GameContext;
use crate::render::canvas::Canvas;
use crate::scene::Scene;
use crate::types::GameConfig;
use minifb::Window;
use std::time::{Duration, Instant};

/// Main Game initiator to run window and enter scenes.
pub struct Game {
    config: GameConfig,
    scene: Box<dyn Scene>,
}

impl Game {
    /// Create a new game with given entry scene.
    #[inline]
    pub fn new<S: Scene + 'static>() -> Self
    where
        Self: Sized,
    {
        let mut scene = S::new();
        scene.enter();

        Self {
            config: GameConfig::default(),
            scene: Box::new(scene),
        }
    }

    /// Use given [GameConfig] as config.
    #[inline]
    pub fn with_config(mut self, config: GameConfig) -> Self {
        self.config = config;
        self
    }

    /// Enter new [Scene].
    #[inline(never)]
    pub fn enter_scene<S: Scene + 'static>(mut self) -> Self {
        // finish old scene
        self.scene.exit();

        // enter new scene
        let mut scene = S::new();
        scene.enter();
        self.scene = Box::new(scene);

        self
    }

    /// Run game.
    #[inline]
    pub fn play(mut self) -> minifb::Result<()> {
        let width = &self.config.width;
        let height = &self.config.height;

        let mut window = Window::new(
            self.config.title.as_str(),
            self.config.width,
            self.config.height,
            self.config.window,
        )?;

        window.limit_update_rate(Some(self.config.update_rate_limit));

        let mut canvas = Canvas::new(*width, *height);

        let fixed_time_step = self.config.fixed_time_step.0;

        let mut last_time = Instant::now();
        let mut accumulated_time = Duration::from_secs(0);

        while window.is_open() {
            let current_time = Instant::now();
            let delta_time = current_time - last_time;
            last_time = current_time;
            accumulated_time += delta_time;

            canvas.cleanse();

            self.scene
                .update(&mut canvas, &mut GameContext::new(&mut window));

            // Call fixed_update multiple times if necessary.
            while accumulated_time >= fixed_time_step {
                self.scene
                    .fixed_update(&mut canvas, &mut GameContext::new(&mut window));
                accumulated_time -= fixed_time_step;
            }

            window.update_with_buffer(&canvas.clone().buffer(), *width, *height)?;
        }

        // make sure the last scene also calls exit()
        self.scene.exit();

        return Ok(());
    }
}