151 lines
3.6 KiB
Rust
151 lines
3.6 KiB
Rust
#![no_main]
|
|
#![no_std]
|
|
|
|
use core::{
|
|
fmt::Write,
|
|
iter::repeat,
|
|
ops::{Deref, DerefMut},
|
|
};
|
|
|
|
use heapless::{String, Vec};
|
|
use system::with_stdout;
|
|
use uefi::prelude::*;
|
|
|
|
const WIDTH: usize = 30;
|
|
const HEIGHT: usize = 30;
|
|
|
|
type Matrix = Vec<Vec<bool, WIDTH>, HEIGHT>;
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct Life {
|
|
matrix: Matrix,
|
|
}
|
|
|
|
impl Deref for Life {
|
|
type Target = Matrix;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.matrix
|
|
}
|
|
}
|
|
|
|
impl Default for Life {
|
|
fn default() -> Self {
|
|
let mut matrix: Vec<Vec<bool, WIDTH>, HEIGHT> = Vec::default();
|
|
for _ in 0..HEIGHT {
|
|
matrix.push(repeat(false).take(WIDTH).collect()).unwrap();
|
|
}
|
|
Life { matrix }
|
|
}
|
|
}
|
|
|
|
impl DerefMut for Life {
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
&mut self.matrix
|
|
}
|
|
}
|
|
|
|
impl Life {
|
|
fn with_starter(starter: &[(usize, usize)]) -> Self {
|
|
let mut life = Self::default();
|
|
for (i, j) in starter.iter() {
|
|
life[*i][*j] = true;
|
|
}
|
|
life
|
|
}
|
|
|
|
fn play(self) -> Life {
|
|
const OFFSETS: &[(i64, i64)] = &[
|
|
(-1, -1),
|
|
(-1, 0),
|
|
(-1, 1),
|
|
(0, -1),
|
|
(0, 1),
|
|
(1, -1),
|
|
(1, 0),
|
|
(1, 1),
|
|
];
|
|
let mut future = Life::default();
|
|
self.iter().enumerate().for_each(|(row, line)| {
|
|
line.iter().enumerate().for_each(|(column, alive)| {
|
|
let neighbors = OFFSETS
|
|
.iter()
|
|
.filter(|offset| {
|
|
let neighbor = ((row as i64) + offset.0, (column as i64) + offset.1);
|
|
let i = neighbor.0;
|
|
let j = neighbor.1;
|
|
i >= 0
|
|
&& j >= 0
|
|
&& (i as usize) < HEIGHT
|
|
&& (j as usize) < WIDTH
|
|
&& self[i as usize][j as usize]
|
|
})
|
|
.count();
|
|
future[row][column] =
|
|
(*alive && (neighbors == 2 || neighbors == 3)) || (!*alive && neighbors == 3);
|
|
})
|
|
});
|
|
future
|
|
}
|
|
|
|
/// Buffers output into one string per frame since println does not buffer output in uefi-rs.
|
|
fn render(&self) -> Frame {
|
|
let mut frame = Frame::default();
|
|
for l in self.iter() {
|
|
for cell in l.iter() {
|
|
if *cell {
|
|
frame.push('X').unwrap()
|
|
} else {
|
|
frame.push(' ').unwrap()
|
|
}
|
|
}
|
|
frame.push('\n').unwrap()
|
|
}
|
|
frame
|
|
}
|
|
}
|
|
|
|
type FrameBuffer = String<{ (WIDTH * HEIGHT) + HEIGHT }>;
|
|
|
|
#[derive(Default)]
|
|
struct Frame {
|
|
buffer: FrameBuffer,
|
|
}
|
|
|
|
impl Deref for Frame {
|
|
type Target = FrameBuffer;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.buffer
|
|
}
|
|
}
|
|
|
|
impl DerefMut for Frame {
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
&mut self.buffer
|
|
}
|
|
}
|
|
|
|
const BREEDER: &[(usize, usize)] = &[(15, 16), (16, 15), (16, 16), (17, 16), (17, 17)];
|
|
const RENDER_DELAY: usize = 100_000;
|
|
|
|
#[entry]
|
|
fn main() -> Status {
|
|
uefi::helpers::init().unwrap();
|
|
|
|
let mut life = Life::with_starter(&BREEDER);
|
|
|
|
for _ in repeat(()) {
|
|
life = life.play();
|
|
|
|
let frame = life.render();
|
|
with_stdout(|stdout| {
|
|
stdout.reset(true).unwrap();
|
|
stdout.write_str(&frame).unwrap()
|
|
});
|
|
// Stall the loop a bit so it is easier to watch
|
|
boot::stall(RENDER_DELAY);
|
|
}
|
|
|
|
Status::SUCCESS
|
|
}
|