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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
use crate::prelude::{FontCharType, XpLayer};
use bracket_color::prelude::RGBA;
use bracket_geometry::prelude::{Point, Rect};
use std::any::Any;
/// The internal storage type for tiles in a simple console.
#[derive(PartialEq, Copy, Clone, Debug)]
pub struct Tile {
pub glyph: FontCharType,
pub fg: RGBA,
pub bg: RGBA,
}
#[derive(PartialEq, Copy, Clone, Debug)]
pub enum TextAlign {
Left,
Center,
Right,
}
#[derive(PartialEq, Copy, Clone, Debug)]
pub enum CharacterTranslationMode {
Codepage437,
Unicode,
}
/// Trait that must be implemented by console types.
pub trait Console {
/// Gets the dimensions of the console in characters
fn get_char_size(&self) -> (u32, u32);
// Resizes the viewport
fn resize_pixels(&mut self, width: u32, height: u32);
/// Converts an x/y coordinate to a console index number.
fn at(&self, x: i32, y: i32) -> usize;
/// Clear the console.
fn cls(&mut self);
/// Clear the console to a set background color, if supported.
fn cls_bg(&mut self, background: RGBA);
/// Print a string at the specified x/y coordinate.
fn print(&mut self, x: i32, y: i32, output: &str);
/// Print a string in color at the specified x/y coordinate, with specified foreground and background.
fn print_color(&mut self, x: i32, y: i32, fg: RGBA, bg: RGBA, output: &str);
/// Print a colorized string with the color encoding defined inline.
/// For example: printer(1, 1, "#[blue]This blue text contains a #[pink]pink#[] word")
/// You can get the same effect with a TextBlock, but this can be easier.
/// Thanks to doryen_rs for the idea.
fn printer(&mut self, x: i32, y: i32, output: &str, align: TextAlign, background: Option<RGBA>);
/// Sets a single cell to a color/glyph combination.
fn set(&mut self, x: i32, y: i32, fg: RGBA, bg: RGBA, glyph: FontCharType);
/// Sets a single cell's background color.
fn set_bg(&mut self, x: i32, y: i32, bg: RGBA);
/// Draws a box, starting at x/y with the extents width/height using CP437 line characters
fn draw_box(&mut self, x: i32, y: i32, width: i32, height: i32, fg: RGBA, bg: RGBA);
/// Draws a box, starting at x/y with the extents width/height using CP437 line characters,
/// without filling in the middle
fn draw_hollow_box(&mut self, x: i32, y: i32, width: i32, height: i32, fg: RGBA, bg: RGBA);
/// Draws a box, starting at x/y with the extents width/height using CP437 double line characters
fn draw_box_double(&mut self, x: i32, y: i32, width: i32, height: i32, fg: RGBA, bg: RGBA);
/// Draws a box, starting at x/y with the extents width/height using CP437 double line characters,
/// without filling in the middle
fn draw_hollow_box_double(
&mut self,
x: i32,
y: i32,
width: i32,
height: i32,
fg: RGBA,
bg: RGBA,
);
/// Fills a rectangle-defined region with a given glyph
fn fill_region(&mut self, target: Rect, glyph: FontCharType, fg: RGBA, bg: RGBA);
/// Draws a horizontal progress bar.
#[allow(clippy::too_many_arguments)]
fn draw_bar_horizontal(
&mut self,
x: i32,
y: i32,
width: i32,
n: i32,
max: i32,
fg: RGBA,
bg: RGBA,
);
/// Draws a vertical progress bar.
#[allow(clippy::too_many_arguments)]
fn draw_bar_vertical(
&mut self,
x: i32,
y: i32,
height: i32,
n: i32,
max: i32,
fg: RGBA,
bg: RGBA,
);
/// Prints text, centered to the whole console width, at vertical location y.
fn print_centered(&mut self, y: i32, text: &str);
/// Prints text in color, centered to the whole console width, at vertical location y.
fn print_color_centered(&mut self, y: i32, fg: RGBA, bg: RGBA, text: &str);
/// Prints text, centered on an arbitrary point
fn print_centered_at(&mut self, x: i32, y: i32, text: &str);
/// Prints colored text, centered on an arbitrary point
fn print_color_centered_at(&mut self, x: i32, y: i32, fg: RGBA, bg: RGBA, text: &str);
/// Prints text right-aligned
fn print_right(&mut self, x: i32, y: i32, text: &str);
/// Prints colored text right-aligned
fn print_color_right(&mut self, x: i32, y: i32, fg: RGBA, bg: RGBA, text: &str);
/// Serializes the console layer to an XpFile
fn to_xp_layer(&self) -> XpLayer;
/// Specify a global offset (by character count, so 0.5 is half a character). Useful for
/// drawing walls between tiles.
fn set_offset(&mut self, x: f32, y: f32);
/// Specify a scale and center of the console.
/// A scale above 1.0 will make the text larger.
/// The center of the scale is at character position (center_x, center_y).
fn set_scale(&mut self, scale: f32, center_x: i32, center_y: i32);
/// Get the scale & center of the console.
/// Returns (scale, center_x, center_y).
fn get_scale(&self) -> (f32, i32, i32);
/// Produces the implementor as an Any that can be matched to determine type and access
/// natively.
fn as_any(&self) -> &dyn Any;
/// Produces the implementor as an Any that can be matched to determine type and access
/// natively.
fn as_any_mut(&mut self) -> &mut dyn Any;
/// Permits the creation of an arbitrary clipping rectangle. It's a really good idea
/// to make sure that this rectangle is entirely valid.
fn set_clipping(&mut self, clipping: Option<Rect>);
/// Returns the current arbitrary clipping rectangle, None if there isn't one.
fn get_clipping(&self) -> Option<Rect>;
/// Returns true if an x/y coordinate is within the console bounds
fn in_bounds(&self, x: i32, y: i32) -> bool {
let bounds = self.get_char_size();
if let Some(clip) = self.get_clipping() {
clip.point_in_rect(Point::new(x, y))
&& x >= 0
&& x < bounds.0 as i32
&& y >= 0
&& y < bounds.1 as i32
} else {
x >= 0 && x < bounds.0 as i32 && y >= 0 && y < bounds.1 as i32
}
}
/// Try to use a coordinate: return Some(the coordinate) if it is valid,
/// None if it isn't.
fn try_at(&self, x: i32, y: i32) -> Option<usize> {
if self.in_bounds(x, y) {
Some(self.at(x, y))
} else {
None
}
}
/// Sets ALL tiles foreground alpha (only tiles that exist, in sparse consoles).
fn set_all_fg_alpha(&mut self, alpha: f32);
/// Sets ALL tiles background alpha (only tiles that exist, in sparse consoles).
fn set_all_bg_alpha(&mut self, alpha: f32);
/// Sets ALL tiles foreground alpha (only tiles that exist, in sparse consoles).
fn set_all_alpha(&mut self, fg: f32, bg: f32);
/// Sets the character translation mode
fn set_translation_mode(&mut self, mode: CharacterTranslationMode);
/// Sets the character size of the layer. Be really careful with this.
fn set_char_size(&mut self, width: u32, height: u32);
// Clears the dirty bit
fn clear_dirty(&mut self);
}
pub fn log<S: ToString>(message: S) {
crate::hal::log(&message.to_string());
}