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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

//! This module is home to the [`View`] struct, which handles the printing of pixels to an ANSI standard text output
use crate::utils as crate_utils;
use std::{
    fmt::{self, Display, Formatter},
    io::{self, Write},
};

mod pixel;
mod scale_to_fit;
pub mod utils;
mod view_element;
mod wrapping;

pub use pixel::{
    colchar::{ColChar, Colour, Modifier},
    vec2d::Vec2D,
    Pixel, Point,
};
pub use scale_to_fit::ScaleFitView;
pub use view_element::ViewElement;
pub use wrapping::Wrapping;

/// The View struct is the canvas on which you will print all of your ViewElements. In normal use, you would clear the View, `blit` all your ViewElements to it and then render. The following example demonstrates a piece of code that will render a View of width 9 and height 3, with a single Pixel in the middle
/// ```
/// use gemini_engine::elements::{view::{Wrapping, ColChar}, View, Pixel, Vec2D};
///
/// let mut view = View::new(9, 3, ColChar::BACKGROUND);
/// let pixel = Pixel::new(view.center(), ColChar::SOLID);
///
/// view.blit(&pixel, Wrapping::Panic);
///
/// view.display_render().unwrap();
/// ```
#[derive(Debug, Clone)]
pub struct View {
    /// The width of the View
    pub width: usize,
    /// The height of the View
    pub height: usize,
    /// The character that the View will be filled with by default on clear
    pub background_char: ColChar,
    /// A boolean determining whether the render should contain numbers on the top and left signifying the corresponding pixels' X/Y value values
    pub coord_numbers_in_render: bool,
    /// If true, [`View.display_render`] will block until the console window is resized to fit the `View`
    pub block_until_resized: bool,
    pixels: Vec<ColChar>,
}

impl View {
    /// Create a new `View` using [`width`](View::width), [`height`](View::height) and [`background_char`](View::background_char) parameters
    pub fn new(width: usize, height: usize, background_char: ColChar) -> View {
        let mut view = View {
            width,
            height,
            background_char,
            coord_numbers_in_render: false,
            block_until_resized: false,
            pixels: Vec::with_capacity(width * height),
        };
        view.clear();

        view
    }

    /// Return the `View` with its [`coord_numbers_in_render`](View::coord_numbers_in_render) field set to the chosen value. Consumes the original `View`
    pub fn with_coord_numbers(mut self, coord_numbers_in_render: bool) -> View {
        self.coord_numbers_in_render = coord_numbers_in_render;
        self
    }

    /// Return the `View` with its [`block_until_resized`](View::block_until_resized) field set to the chosen value. Consumes the original `View`
    pub fn with_block_until_resized(mut self, block_until_resized: bool) -> View {
        self.block_until_resized = block_until_resized;
        self
    }

    /// Return the width and height of the `View` as a [`Vec2D`]
    pub fn size(&self) -> Vec2D {
        Vec2D::new(self.width as isize, self.height as isize)
    }

    /// Return [`Vec2D`] coordinates of the centre of the `View`
    pub fn center(&self) -> Vec2D {
        self.size() / 2
    }

    /// Clear the `View` of all pixels
    pub fn clear(&mut self) {
        self.pixels = vec![self.background_char; self.width * self.height]
    }

    /// Plot a pixel to the `View`. Accepts a [`Vec2D`] (the position of the pixel), [`ColChar`] (what the pixel should look like/what colour it should be), and a [`Wrapping`] enum variant (Please see the [Wrapping] documentation for more info)
    pub fn plot(&mut self, pos: Vec2D, c: ColChar, wrapping: Wrapping) {
        if let Some(wrapped_pos) = wrapping.handle_bounds(pos, self.size()) {
            self.pixels[self.width * (wrapped_pos.y as usize) + (wrapped_pos.x as usize)] = c;
        }
    }

    /// Blit a struct implementing [`ViewElement`] to the `View`
    pub fn blit(&mut self, element: &impl ViewElement, wrapping: Wrapping) {
        for pixel in element.active_pixels() {
            self.plot(pixel.pos, pixel.fill_char, wrapping);
        }
    }

    /// Blit a struct implementing [`ViewElement`] to the `View` with a doubled width. Blitting a `Pixel` at `Vec2D(5,3)`, for example, will result in a blit at `Vec2D(10,3)` and `Vec2D(11,3)` being plotted to. Useful when you want to work with more square pixels, as single text characters are much taller than they are wide
    pub fn blit_double_width(&mut self, element: &impl ViewElement, wrapping: Wrapping) {
        for pixel in element.active_pixels() {
            let pos = pixel.pos * Vec2D::new(2, 1);
            self.plot(pos, pixel.fill_char, wrapping);
            self.plot(pos + Vec2D::new(1, 0), pixel.fill_char, wrapping);
        }
    }

    /// Display the `View`. `View` implements the `Display` trait and so can be rendered in many ways (such as `println!("{view}");`), but this is intended to be the fastest way possible.
    ///
    /// Returns the `Result` from writing to `io::stdout().lock()`
    pub fn display_render(&self) -> io::Result<()> {
        let mut stdout = io::stdout().lock();
        if self.block_until_resized {
            let view_size = self.size();
            crate_utils::block_until_resized(view_size);
        }

        write!(stdout, "{self}")
    }
}

impl Display for View {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        let _ = crate::utils::prepare_terminal(f);
        f.write_str("\x1b[H\x1b[J")?;
        if self.coord_numbers_in_render {
            let nums: String = (0..self.width)
                .map(|i| i.to_string().chars().last().unwrap_or(' '))
                .collect();
            writeln!(f, " {}", nums).unwrap();
        }
        for y in 0..self.height {
            if self.coord_numbers_in_render {
                let num = y.to_string().chars().last().unwrap_or(' ');
                write!(f, "{num}").unwrap();
            }

            let row = &self.pixels[self.width * y..self.width * (y + 1)];

            row[0].display_with_prev_and_next(f, None, Some(row[1].modifier))?;
            for x in 1..(row.len() - 1) {
                row[x].display_with_prev_and_next(
                    f,
                    Some(row[x - 1].modifier),
                    Some(row[x + 1].modifier),
                )?;
            }
            row[row.len() - 1].display_with_prev_and_next(
                f,
                Some(row[row.len() - 2].modifier),
                None,
            )?;
            f.write_str("\r\n")?;
        }
        f.write_str("\x1b[J")?;

        Ok(())
    }
}