patica 0.0.3

A terminal based pixel art editor
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

use crate::{
    command::Command,
    config::Config,
    model::Model,
    view::{View, WindowCanvas},
};
use pagurus::{
    event::{Event, TimeoutTag},
    failure::OrFail,
    image::Canvas,
    video::VideoFrame,
    Result, System,
};
use std::time::Duration;

const TICK_TIMEOUT_TAG: TimeoutTag = TimeoutTag::new(0);

#[derive(Debug, Default)]
pub struct Game {
    video_frame: VideoFrame,
    view: View,
    model: Model,
}

impl Game {
    pub fn set_config(&mut self, config: Config) {
        self.view.set_key_config(config.key);

        self.model
            .apply(&Command::BackgroundColor(config.initial.background_color));
        for (name, point) in &config.initial.anchors {
            let command = pati::Command::anchor(name.clone(), Some(*point));
            self.model.canvas_mut().apply(&command);
        }
    }

    pub fn model(&self) -> &Model {
        &self.model
    }

    pub fn model_mut(&mut self) -> &mut Model {
        &mut self.model
    }

    fn render<S: System>(&mut self, system: &mut S) {
        let size = self.video_frame.spec().resolution;
        let mut canvas = WindowCanvas::new(Canvas::new(&mut self.video_frame), size);
        self.view.render(&self.model, &mut canvas);
        system.video_draw(self.video_frame.as_ref());
    }

    fn set_tick_timeout<S: System>(&mut self, system: &mut S) {
        system.clock_set_timeout(TICK_TIMEOUT_TAG, Duration::from_secs(1) / self.model.fps());
    }
}

impl<S: System> pagurus::Game<S> for Game {
    fn initialize(&mut self, system: &mut S) -> Result<()> {
        self.model.initialize().or_fail()?;
        self.set_tick_timeout(system);
        Ok(())
    }

    fn handle_event(&mut self, system: &mut S, event: Event) -> Result<bool> {
        let mut set_timeout = false;
        match event {
            Event::WindowResized(size) => {
                self.video_frame = VideoFrame::new(system.video_init(size));
            }
            Event::Timeout(TICK_TIMEOUT_TAG) => {
                self.model.tick();
                set_timeout = true;
            }
            _ => {}
        }
        self.view
            .handle_event(system, &mut self.model, event)
            .or_fail()?;
        self.render(system);
        if set_timeout {
            self.set_tick_timeout(system);
        }
        Ok(!self.model.quit())
    }
}