901 lines
28 KiB
Rust
901 lines
28 KiB
Rust
//! This example showcases an interactive version of the Game of Life, invented
|
|
//! by John Conway. It leverages a `Canvas` together with other widgets.
|
|
mod preset;
|
|
|
|
use grid::Grid;
|
|
use preset::Preset;
|
|
|
|
use iced::time::{self, milliseconds};
|
|
use iced::widget::{
|
|
button, checkbox, column, container, pick_list, row, slider, text,
|
|
};
|
|
use iced::{Center, Element, Fill, Function, Subscription, Task, Theme};
|
|
|
|
pub fn main() -> iced::Result {
|
|
tracing_subscriber::fmt::init();
|
|
|
|
iced::application(
|
|
"Game of Life - Iced",
|
|
GameOfLife::update,
|
|
GameOfLife::view,
|
|
)
|
|
.subscription(GameOfLife::subscription)
|
|
.theme(|_| Theme::Dark)
|
|
.antialiasing(true)
|
|
.centered()
|
|
.run()
|
|
}
|
|
|
|
struct GameOfLife {
|
|
grid: Grid,
|
|
is_playing: bool,
|
|
queued_ticks: usize,
|
|
speed: usize,
|
|
next_speed: Option<usize>,
|
|
version: usize,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum Message {
|
|
Grid(usize, grid::Message),
|
|
Tick,
|
|
TogglePlayback,
|
|
ToggleGrid(bool),
|
|
Next,
|
|
Clear,
|
|
SpeedChanged(f32),
|
|
PresetPicked(Preset),
|
|
}
|
|
|
|
impl GameOfLife {
|
|
fn new() -> Self {
|
|
Self {
|
|
grid: Grid::default(),
|
|
is_playing: false,
|
|
queued_ticks: 0,
|
|
speed: 5,
|
|
next_speed: None,
|
|
version: 0,
|
|
}
|
|
}
|
|
|
|
fn update(&mut self, message: Message) -> Task<Message> {
|
|
match message {
|
|
Message::Grid(version, message) => {
|
|
if version == self.version {
|
|
self.grid.update(message);
|
|
}
|
|
}
|
|
Message::Tick | Message::Next => {
|
|
self.queued_ticks = (self.queued_ticks + 1).min(self.speed);
|
|
|
|
if let Some(task) = self.grid.tick(self.queued_ticks) {
|
|
if let Some(speed) = self.next_speed.take() {
|
|
self.speed = speed;
|
|
}
|
|
|
|
self.queued_ticks = 0;
|
|
|
|
let version = self.version;
|
|
|
|
return Task::perform(task, Message::Grid.with(version));
|
|
}
|
|
}
|
|
Message::TogglePlayback => {
|
|
self.is_playing = !self.is_playing;
|
|
}
|
|
Message::ToggleGrid(show_grid_lines) => {
|
|
self.grid.toggle_lines(show_grid_lines);
|
|
}
|
|
Message::Clear => {
|
|
self.grid.clear();
|
|
self.version += 1;
|
|
}
|
|
Message::SpeedChanged(speed) => {
|
|
if self.is_playing {
|
|
self.next_speed = Some(speed.round() as usize);
|
|
} else {
|
|
self.speed = speed.round() as usize;
|
|
}
|
|
}
|
|
Message::PresetPicked(new_preset) => {
|
|
self.grid = Grid::from_preset(new_preset);
|
|
self.version += 1;
|
|
}
|
|
}
|
|
|
|
Task::none()
|
|
}
|
|
|
|
fn subscription(&self) -> Subscription<Message> {
|
|
if self.is_playing {
|
|
time::every(milliseconds(1000 / self.speed as u64))
|
|
.map(|_| Message::Tick)
|
|
} else {
|
|
Subscription::none()
|
|
}
|
|
}
|
|
|
|
fn view(&self) -> Element<Message> {
|
|
let version = self.version;
|
|
let selected_speed = self.next_speed.unwrap_or(self.speed);
|
|
let controls = view_controls(
|
|
self.is_playing,
|
|
self.grid.are_lines_visible(),
|
|
selected_speed,
|
|
self.grid.preset(),
|
|
);
|
|
|
|
let content = column![
|
|
self.grid.view().map(Message::Grid.with(version)),
|
|
controls,
|
|
]
|
|
.height(Fill);
|
|
|
|
container(content).width(Fill).height(Fill).into()
|
|
}
|
|
}
|
|
|
|
impl Default for GameOfLife {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
fn view_controls<'a>(
|
|
is_playing: bool,
|
|
is_grid_enabled: bool,
|
|
speed: usize,
|
|
preset: Preset,
|
|
) -> Element<'a, Message> {
|
|
let playback_controls = row![
|
|
button(if is_playing { "Pause" } else { "Play" })
|
|
.on_press(Message::TogglePlayback),
|
|
button("Next")
|
|
.on_press(Message::Next)
|
|
.style(button::secondary),
|
|
]
|
|
.spacing(10);
|
|
|
|
let speed_controls = row![
|
|
slider(1.0..=1000.0, speed as f32, Message::SpeedChanged),
|
|
text!("x{speed}").size(16),
|
|
]
|
|
.align_y(Center)
|
|
.spacing(10);
|
|
|
|
row![
|
|
playback_controls,
|
|
speed_controls,
|
|
checkbox("Grid", is_grid_enabled).on_toggle(Message::ToggleGrid),
|
|
row![
|
|
pick_list(preset::ALL, Some(preset), Message::PresetPicked),
|
|
button("Clear")
|
|
.on_press(Message::Clear)
|
|
.style(button::danger)
|
|
]
|
|
.spacing(10)
|
|
]
|
|
.padding(10)
|
|
.spacing(20)
|
|
.align_y(Center)
|
|
.into()
|
|
}
|
|
|
|
mod grid {
|
|
use crate::Preset;
|
|
use iced::alignment;
|
|
use iced::mouse;
|
|
use iced::time::{Duration, Instant};
|
|
use iced::touch;
|
|
use iced::widget::canvas;
|
|
use iced::widget::canvas::{
|
|
Cache, Canvas, Event, Frame, Geometry, Path, Text,
|
|
};
|
|
use iced::{
|
|
Color, Element, Fill, Point, Rectangle, Renderer, Size, Theme, Vector,
|
|
};
|
|
use rustc_hash::{FxHashMap, FxHashSet};
|
|
use std::ops::RangeInclusive;
|
|
|
|
pub struct Grid {
|
|
state: State,
|
|
preset: Preset,
|
|
life_cache: Cache,
|
|
grid_cache: Cache,
|
|
translation: Vector,
|
|
scaling: f32,
|
|
show_lines: bool,
|
|
last_tick_duration: Duration,
|
|
last_queued_ticks: usize,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Message {
|
|
Populate(Cell),
|
|
Unpopulate(Cell),
|
|
Translated(Vector),
|
|
Scaled(f32, Option<Vector>),
|
|
Ticked {
|
|
result: Result<Life, TickError>,
|
|
tick_duration: Duration,
|
|
},
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum TickError {
|
|
JoinFailed,
|
|
}
|
|
|
|
impl Default for Grid {
|
|
fn default() -> Self {
|
|
Self::from_preset(Preset::default())
|
|
}
|
|
}
|
|
|
|
impl Grid {
|
|
const MIN_SCALING: f32 = 0.1;
|
|
const MAX_SCALING: f32 = 2.0;
|
|
|
|
pub fn from_preset(preset: Preset) -> Self {
|
|
Self {
|
|
state: State::with_life(
|
|
preset
|
|
.life()
|
|
.into_iter()
|
|
.map(|(i, j)| Cell { i, j })
|
|
.collect(),
|
|
),
|
|
preset,
|
|
life_cache: Cache::default(),
|
|
grid_cache: Cache::default(),
|
|
translation: Vector::default(),
|
|
scaling: 1.0,
|
|
show_lines: true,
|
|
last_tick_duration: Duration::default(),
|
|
last_queued_ticks: 0,
|
|
}
|
|
}
|
|
|
|
pub fn tick(
|
|
&mut self,
|
|
amount: usize,
|
|
) -> Option<impl Future<Output = Message> + use<>> {
|
|
let tick = self.state.tick(amount)?;
|
|
|
|
self.last_queued_ticks = amount;
|
|
|
|
Some(async move {
|
|
let start = Instant::now();
|
|
let result = tick.await;
|
|
let tick_duration = start.elapsed() / amount as u32;
|
|
|
|
Message::Ticked {
|
|
result,
|
|
tick_duration,
|
|
}
|
|
})
|
|
}
|
|
|
|
pub fn update(&mut self, message: Message) {
|
|
match message {
|
|
Message::Populate(cell) => {
|
|
self.state.populate(cell);
|
|
self.life_cache.clear();
|
|
|
|
self.preset = Preset::Custom;
|
|
}
|
|
Message::Unpopulate(cell) => {
|
|
self.state.unpopulate(&cell);
|
|
self.life_cache.clear();
|
|
|
|
self.preset = Preset::Custom;
|
|
}
|
|
Message::Translated(translation) => {
|
|
self.translation = translation;
|
|
|
|
self.life_cache.clear();
|
|
self.grid_cache.clear();
|
|
}
|
|
Message::Scaled(scaling, translation) => {
|
|
self.scaling = scaling;
|
|
|
|
if let Some(translation) = translation {
|
|
self.translation = translation;
|
|
}
|
|
|
|
self.life_cache.clear();
|
|
self.grid_cache.clear();
|
|
}
|
|
Message::Ticked {
|
|
result: Ok(life),
|
|
tick_duration,
|
|
} => {
|
|
self.state.update(life);
|
|
self.life_cache.clear();
|
|
|
|
self.last_tick_duration = tick_duration;
|
|
}
|
|
Message::Ticked {
|
|
result: Err(error), ..
|
|
} => {
|
|
dbg!(error);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn view(&self) -> Element<Message> {
|
|
Canvas::new(self).width(Fill).height(Fill).into()
|
|
}
|
|
|
|
pub fn clear(&mut self) {
|
|
self.state = State::default();
|
|
self.preset = Preset::Custom;
|
|
|
|
self.life_cache.clear();
|
|
}
|
|
|
|
pub fn preset(&self) -> Preset {
|
|
self.preset
|
|
}
|
|
|
|
pub fn toggle_lines(&mut self, enabled: bool) {
|
|
self.show_lines = enabled;
|
|
}
|
|
|
|
pub fn are_lines_visible(&self) -> bool {
|
|
self.show_lines
|
|
}
|
|
|
|
fn visible_region(&self, size: Size) -> Region {
|
|
let width = size.width / self.scaling;
|
|
let height = size.height / self.scaling;
|
|
|
|
Region {
|
|
x: -self.translation.x - width / 2.0,
|
|
y: -self.translation.y - height / 2.0,
|
|
width,
|
|
height,
|
|
}
|
|
}
|
|
|
|
fn project(&self, position: Point, size: Size) -> Point {
|
|
let region = self.visible_region(size);
|
|
|
|
Point::new(
|
|
position.x / self.scaling + region.x,
|
|
position.y / self.scaling + region.y,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl canvas::Program<Message> for Grid {
|
|
type State = Interaction;
|
|
|
|
fn update(
|
|
&self,
|
|
interaction: &mut Interaction,
|
|
event: &Event,
|
|
bounds: Rectangle,
|
|
cursor: mouse::Cursor,
|
|
) -> Option<canvas::Action<Message>> {
|
|
if let Event::Mouse(mouse::Event::ButtonReleased(_)) = event {
|
|
*interaction = Interaction::None;
|
|
}
|
|
|
|
let cursor_position = cursor.position_in(bounds)?;
|
|
|
|
let cell = Cell::at(self.project(cursor_position, bounds.size()));
|
|
let is_populated = self.state.contains(&cell);
|
|
|
|
let (populate, unpopulate) = if is_populated {
|
|
(None, Some(Message::Unpopulate(cell)))
|
|
} else {
|
|
(Some(Message::Populate(cell)), None)
|
|
};
|
|
|
|
match event {
|
|
Event::Touch(touch::Event::FingerMoved { .. }) => {
|
|
let message = {
|
|
*interaction = if is_populated {
|
|
Interaction::Erasing
|
|
} else {
|
|
Interaction::Drawing
|
|
};
|
|
|
|
populate.or(unpopulate)
|
|
};
|
|
|
|
Some(
|
|
message
|
|
.map(canvas::Action::publish)
|
|
.unwrap_or(canvas::Action::request_redraw())
|
|
.and_capture(),
|
|
)
|
|
}
|
|
Event::Mouse(mouse_event) => match mouse_event {
|
|
mouse::Event::ButtonPressed(button) => {
|
|
let message = match button {
|
|
mouse::Button::Left => {
|
|
*interaction = if is_populated {
|
|
Interaction::Erasing
|
|
} else {
|
|
Interaction::Drawing
|
|
};
|
|
|
|
populate.or(unpopulate)
|
|
}
|
|
mouse::Button::Right => {
|
|
*interaction = Interaction::Panning {
|
|
translation: self.translation,
|
|
start: cursor_position,
|
|
};
|
|
|
|
None
|
|
}
|
|
_ => None,
|
|
};
|
|
|
|
Some(
|
|
message
|
|
.map(canvas::Action::publish)
|
|
.unwrap_or(canvas::Action::request_redraw())
|
|
.and_capture(),
|
|
)
|
|
}
|
|
mouse::Event::CursorMoved { .. } => {
|
|
let message = match *interaction {
|
|
Interaction::Drawing => populate,
|
|
Interaction::Erasing => unpopulate,
|
|
Interaction::Panning { translation, start } => {
|
|
Some(Message::Translated(
|
|
translation
|
|
+ (cursor_position - start)
|
|
* (1.0 / self.scaling),
|
|
))
|
|
}
|
|
Interaction::None => None,
|
|
};
|
|
|
|
let action = message
|
|
.map(canvas::Action::publish)
|
|
.unwrap_or(canvas::Action::request_redraw());
|
|
|
|
Some(match interaction {
|
|
Interaction::None => action,
|
|
_ => action.and_capture(),
|
|
})
|
|
}
|
|
mouse::Event::WheelScrolled { delta } => match *delta {
|
|
mouse::ScrollDelta::Lines { y, .. }
|
|
| mouse::ScrollDelta::Pixels { y, .. } => {
|
|
if y < 0.0 && self.scaling > Self::MIN_SCALING
|
|
|| y > 0.0 && self.scaling < Self::MAX_SCALING
|
|
{
|
|
let old_scaling = self.scaling;
|
|
|
|
let scaling = (self.scaling * (1.0 + y / 30.0))
|
|
.clamp(
|
|
Self::MIN_SCALING,
|
|
Self::MAX_SCALING,
|
|
);
|
|
|
|
let translation =
|
|
if let Some(cursor_to_center) =
|
|
cursor.position_from(bounds.center())
|
|
{
|
|
let factor = scaling - old_scaling;
|
|
|
|
Some(
|
|
self.translation
|
|
- Vector::new(
|
|
cursor_to_center.x * factor
|
|
/ (old_scaling
|
|
* old_scaling),
|
|
cursor_to_center.y * factor
|
|
/ (old_scaling
|
|
* old_scaling),
|
|
),
|
|
)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
Some(
|
|
canvas::Action::publish(Message::Scaled(
|
|
scaling,
|
|
translation,
|
|
))
|
|
.and_capture(),
|
|
)
|
|
} else {
|
|
Some(canvas::Action::capture())
|
|
}
|
|
}
|
|
},
|
|
_ => None,
|
|
},
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn draw(
|
|
&self,
|
|
_interaction: &Interaction,
|
|
renderer: &Renderer,
|
|
_theme: &Theme,
|
|
bounds: Rectangle,
|
|
cursor: mouse::Cursor,
|
|
) -> Vec<Geometry> {
|
|
let center = Vector::new(bounds.width / 2.0, bounds.height / 2.0);
|
|
|
|
let life = self.life_cache.draw(renderer, bounds.size(), |frame| {
|
|
let background = Path::rectangle(Point::ORIGIN, frame.size());
|
|
frame.fill(&background, Color::from_rgb8(0x40, 0x44, 0x4B));
|
|
|
|
frame.with_save(|frame| {
|
|
frame.translate(center);
|
|
frame.scale(self.scaling);
|
|
frame.translate(self.translation);
|
|
frame.scale(Cell::SIZE);
|
|
|
|
let region = self.visible_region(frame.size());
|
|
|
|
for cell in region.cull(self.state.cells()) {
|
|
frame.fill_rectangle(
|
|
Point::new(cell.j as f32, cell.i as f32),
|
|
Size::UNIT,
|
|
Color::WHITE,
|
|
);
|
|
}
|
|
});
|
|
});
|
|
|
|
let overlay = {
|
|
let mut frame = Frame::new(renderer, bounds.size());
|
|
|
|
let hovered_cell = cursor.position_in(bounds).map(|position| {
|
|
Cell::at(self.project(position, frame.size()))
|
|
});
|
|
|
|
if let Some(cell) = hovered_cell {
|
|
frame.with_save(|frame| {
|
|
frame.translate(center);
|
|
frame.scale(self.scaling);
|
|
frame.translate(self.translation);
|
|
frame.scale(Cell::SIZE);
|
|
|
|
frame.fill_rectangle(
|
|
Point::new(cell.j as f32, cell.i as f32),
|
|
Size::UNIT,
|
|
Color {
|
|
a: 0.5,
|
|
..Color::BLACK
|
|
},
|
|
);
|
|
});
|
|
}
|
|
|
|
let text = Text {
|
|
color: Color::WHITE,
|
|
size: 14.0.into(),
|
|
position: Point::new(frame.width(), frame.height()),
|
|
align_x: alignment::Horizontal::Right,
|
|
align_y: alignment::Vertical::Bottom,
|
|
..Text::default()
|
|
};
|
|
|
|
if let Some(cell) = hovered_cell {
|
|
frame.fill_text(Text {
|
|
content: format!("({}, {})", cell.j, cell.i),
|
|
position: text.position - Vector::new(0.0, 16.0),
|
|
..text
|
|
});
|
|
}
|
|
|
|
let cell_count = self.state.cell_count();
|
|
|
|
frame.fill_text(Text {
|
|
content: format!(
|
|
"{cell_count} cell{} @ {:?} ({})",
|
|
if cell_count == 1 { "" } else { "s" },
|
|
self.last_tick_duration,
|
|
self.last_queued_ticks
|
|
),
|
|
..text
|
|
});
|
|
|
|
frame.into_geometry()
|
|
};
|
|
|
|
if self.scaling >= 0.2 && self.show_lines {
|
|
let grid =
|
|
self.grid_cache.draw(renderer, bounds.size(), |frame| {
|
|
frame.translate(center);
|
|
frame.scale(self.scaling);
|
|
frame.translate(self.translation);
|
|
frame.scale(Cell::SIZE);
|
|
|
|
let region = self.visible_region(frame.size());
|
|
let rows = region.rows();
|
|
let columns = region.columns();
|
|
let (total_rows, total_columns) =
|
|
(rows.clone().count(), columns.clone().count());
|
|
let width = 2.0 / Cell::SIZE as f32;
|
|
let color = Color::from_rgb8(70, 74, 83);
|
|
|
|
frame
|
|
.translate(Vector::new(-width / 2.0, -width / 2.0));
|
|
|
|
for row in region.rows() {
|
|
frame.fill_rectangle(
|
|
Point::new(*columns.start() as f32, row as f32),
|
|
Size::new(total_columns as f32, width),
|
|
color,
|
|
);
|
|
}
|
|
|
|
for column in region.columns() {
|
|
frame.fill_rectangle(
|
|
Point::new(column as f32, *rows.start() as f32),
|
|
Size::new(width, total_rows as f32),
|
|
color,
|
|
);
|
|
}
|
|
});
|
|
|
|
vec![life, grid, overlay]
|
|
} else {
|
|
vec![life, overlay]
|
|
}
|
|
}
|
|
|
|
fn mouse_interaction(
|
|
&self,
|
|
interaction: &Interaction,
|
|
bounds: Rectangle,
|
|
cursor: mouse::Cursor,
|
|
) -> mouse::Interaction {
|
|
match interaction {
|
|
Interaction::Drawing => mouse::Interaction::Crosshair,
|
|
Interaction::Erasing => mouse::Interaction::Crosshair,
|
|
Interaction::Panning { .. } => mouse::Interaction::Grabbing,
|
|
Interaction::None if cursor.is_over(bounds) => {
|
|
mouse::Interaction::Crosshair
|
|
}
|
|
Interaction::None => mouse::Interaction::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct State {
|
|
life: Life,
|
|
births: FxHashSet<Cell>,
|
|
is_ticking: bool,
|
|
}
|
|
|
|
impl State {
|
|
pub fn with_life(life: Life) -> Self {
|
|
Self {
|
|
life,
|
|
..Self::default()
|
|
}
|
|
}
|
|
|
|
fn cell_count(&self) -> usize {
|
|
self.life.len() + self.births.len()
|
|
}
|
|
|
|
fn contains(&self, cell: &Cell) -> bool {
|
|
self.life.contains(cell) || self.births.contains(cell)
|
|
}
|
|
|
|
fn cells(&self) -> impl Iterator<Item = &Cell> {
|
|
self.life.iter().chain(self.births.iter())
|
|
}
|
|
|
|
fn populate(&mut self, cell: Cell) {
|
|
if self.is_ticking {
|
|
self.births.insert(cell);
|
|
} else {
|
|
self.life.populate(cell);
|
|
}
|
|
}
|
|
|
|
fn unpopulate(&mut self, cell: &Cell) {
|
|
if self.is_ticking {
|
|
let _ = self.births.remove(cell);
|
|
} else {
|
|
self.life.unpopulate(cell);
|
|
}
|
|
}
|
|
|
|
fn update(&mut self, mut life: Life) {
|
|
self.births.drain().for_each(|cell| life.populate(cell));
|
|
|
|
self.life = life;
|
|
self.is_ticking = false;
|
|
}
|
|
|
|
fn tick(
|
|
&mut self,
|
|
amount: usize,
|
|
) -> Option<impl Future<Output = Result<Life, TickError>> + use<>>
|
|
{
|
|
if self.is_ticking {
|
|
return None;
|
|
}
|
|
|
|
self.is_ticking = true;
|
|
|
|
let mut life = self.life.clone();
|
|
|
|
Some(async move {
|
|
tokio::task::spawn_blocking(move || {
|
|
for _ in 0..amount {
|
|
life.tick();
|
|
}
|
|
|
|
life
|
|
})
|
|
.await
|
|
.map_err(|_| TickError::JoinFailed)
|
|
})
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Default)]
|
|
pub struct Life {
|
|
cells: FxHashSet<Cell>,
|
|
}
|
|
|
|
impl Life {
|
|
fn len(&self) -> usize {
|
|
self.cells.len()
|
|
}
|
|
|
|
fn contains(&self, cell: &Cell) -> bool {
|
|
self.cells.contains(cell)
|
|
}
|
|
|
|
fn populate(&mut self, cell: Cell) {
|
|
self.cells.insert(cell);
|
|
}
|
|
|
|
fn unpopulate(&mut self, cell: &Cell) {
|
|
let _ = self.cells.remove(cell);
|
|
}
|
|
|
|
fn tick(&mut self) {
|
|
let mut adjacent_life = FxHashMap::default();
|
|
|
|
for cell in &self.cells {
|
|
let _ = adjacent_life.entry(*cell).or_insert(0);
|
|
|
|
for neighbor in Cell::neighbors(*cell) {
|
|
let amount = adjacent_life.entry(neighbor).or_insert(0);
|
|
|
|
*amount += 1;
|
|
}
|
|
}
|
|
|
|
for (cell, amount) in &adjacent_life {
|
|
match amount {
|
|
2 => {}
|
|
3 => {
|
|
let _ = self.cells.insert(*cell);
|
|
}
|
|
_ => {
|
|
let _ = self.cells.remove(cell);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn iter(&self) -> impl Iterator<Item = &Cell> {
|
|
self.cells.iter()
|
|
}
|
|
}
|
|
|
|
impl std::iter::FromIterator<Cell> for Life {
|
|
fn from_iter<I: IntoIterator<Item = Cell>>(iter: I) -> Self {
|
|
Life {
|
|
cells: iter.into_iter().collect(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl std::fmt::Debug for Life {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
f.debug_struct("Life")
|
|
.field("cells", &self.cells.len())
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
|
pub struct Cell {
|
|
i: isize,
|
|
j: isize,
|
|
}
|
|
|
|
impl Cell {
|
|
const SIZE: u16 = 20;
|
|
|
|
fn at(position: Point) -> Cell {
|
|
let i = (position.y / Cell::SIZE as f32).ceil() as isize;
|
|
let j = (position.x / Cell::SIZE as f32).ceil() as isize;
|
|
|
|
Cell {
|
|
i: i.saturating_sub(1),
|
|
j: j.saturating_sub(1),
|
|
}
|
|
}
|
|
|
|
fn cluster(cell: Cell) -> impl Iterator<Item = Cell> {
|
|
use itertools::Itertools;
|
|
|
|
let rows = cell.i.saturating_sub(1)..=cell.i.saturating_add(1);
|
|
let columns = cell.j.saturating_sub(1)..=cell.j.saturating_add(1);
|
|
|
|
rows.cartesian_product(columns).map(|(i, j)| Cell { i, j })
|
|
}
|
|
|
|
fn neighbors(cell: Cell) -> impl Iterator<Item = Cell> {
|
|
Cell::cluster(cell).filter(move |candidate| *candidate != cell)
|
|
}
|
|
}
|
|
|
|
pub struct Region {
|
|
x: f32,
|
|
y: f32,
|
|
width: f32,
|
|
height: f32,
|
|
}
|
|
|
|
impl Region {
|
|
fn rows(&self) -> RangeInclusive<isize> {
|
|
let first_row = (self.y / Cell::SIZE as f32).floor() as isize;
|
|
|
|
let visible_rows =
|
|
(self.height / Cell::SIZE as f32).ceil() as isize;
|
|
|
|
first_row..=first_row + visible_rows
|
|
}
|
|
|
|
fn columns(&self) -> RangeInclusive<isize> {
|
|
let first_column = (self.x / Cell::SIZE as f32).floor() as isize;
|
|
|
|
let visible_columns =
|
|
(self.width / Cell::SIZE as f32).ceil() as isize;
|
|
|
|
first_column..=first_column + visible_columns
|
|
}
|
|
|
|
fn cull<'a>(
|
|
&self,
|
|
cells: impl Iterator<Item = &'a Cell>,
|
|
) -> impl Iterator<Item = &'a Cell> {
|
|
let rows = self.rows();
|
|
let columns = self.columns();
|
|
|
|
cells.filter(move |cell| {
|
|
rows.contains(&cell.i) && columns.contains(&cell.j)
|
|
})
|
|
}
|
|
}
|
|
|
|
pub enum Interaction {
|
|
None,
|
|
Drawing,
|
|
Erasing,
|
|
Panning { translation: Vector, start: Point },
|
|
}
|
|
|
|
impl Default for Interaction {
|
|
fn default() -> Self {
|
|
Self::None
|
|
}
|
|
}
|
|
}
|