2018-11-28 15:02:33 +00:00
|
|
|
use std::env::args;
|
|
|
|
use std::io::stdout;
|
|
|
|
use std::io::Write;
|
|
|
|
use std::iter::repeat_with;
|
|
|
|
use std::thread::sleep;
|
|
|
|
use std::time::Duration;
|
|
|
|
|
|
|
|
use rand::thread_rng;
|
|
|
|
use rand::Rng;
|
|
|
|
|
2018-11-30 19:34:08 +00:00
|
|
|
use pixelfoo::color::Color;
|
2018-12-01 09:04:23 +00:00
|
|
|
use pixelfoo::point2d::Point2d;
|
2018-12-01 10:49:45 +00:00
|
|
|
use pixelfoo::rect2d::Rect2d;
|
2018-12-02 13:21:59 +00:00
|
|
|
use pixelfoo::vec2d::v2d;
|
2018-12-01 09:04:23 +00:00
|
|
|
use pixelfoo::vec2d::Vec2d;
|
2018-11-28 15:02:33 +00:00
|
|
|
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
|
|
enum Square {
|
|
|
|
Empty,
|
|
|
|
Grass,
|
|
|
|
Rabbit,
|
|
|
|
Fox,
|
|
|
|
}
|
|
|
|
|
2018-12-01 13:29:06 +00:00
|
|
|
struct Board(Vec<Vec<Square>>);
|
|
|
|
|
|
|
|
impl Board {
|
|
|
|
pub fn new(size: Vec2d, mut f: impl FnMut() -> Square) -> Board {
|
|
|
|
Board(
|
|
|
|
repeat_with(|| {
|
|
|
|
repeat_with(&mut f)
|
|
|
|
.take(size.x as usize)
|
|
|
|
.collect::<Vec<_>>()
|
|
|
|
})
|
|
|
|
.take(size.y as usize)
|
|
|
|
.collect::<Vec<_>>(),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
pub fn size(&self) -> Vec2d {
|
|
|
|
let x_size = self.0[0].len() as i32;
|
|
|
|
let y_size = self.0.len() as i32;
|
2018-12-02 13:21:59 +00:00
|
|
|
v2d(x_size, y_size)
|
2018-12-01 13:29:06 +00:00
|
|
|
}
|
|
|
|
pub fn rect(&self) -> Rect2d {
|
|
|
|
Rect2d::new(0, self.size().x, 0, self.size().y)
|
|
|
|
}
|
|
|
|
pub fn get(&self, pos: Point2d) -> Square {
|
|
|
|
self.0[pos.y as usize][pos.x as usize]
|
|
|
|
}
|
|
|
|
pub fn set(&mut self, pos: Point2d, sq: Square) {
|
|
|
|
self.0[pos.y as usize][pos.x as usize] = sq;
|
|
|
|
}
|
|
|
|
}
|
2018-11-28 15:02:33 +00:00
|
|
|
|
|
|
|
fn send<T: Write>(w: &mut T, board: &Board) -> std::io::Result<()> {
|
2018-12-01 13:29:06 +00:00
|
|
|
let Board(lines) = board;
|
|
|
|
for line in lines {
|
2018-11-28 15:02:33 +00:00
|
|
|
for square in line {
|
2018-11-30 19:34:08 +00:00
|
|
|
let c = match square {
|
2018-11-28 15:02:33 +00:00
|
|
|
Square::Empty => Color::blue(),
|
|
|
|
Square::Grass => Color::green(),
|
|
|
|
Square::Rabbit => Color::yellow(),
|
|
|
|
Square::Fox => Color::red(),
|
|
|
|
};
|
2018-11-30 19:34:08 +00:00
|
|
|
w.write_all(&c.rgb())?;
|
2018-11-28 15:02:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
w.flush()
|
|
|
|
}
|
|
|
|
|
|
|
|
const DEFAULT_ARG: usize = 10;
|
|
|
|
|
2018-12-01 09:04:23 +00:00
|
|
|
fn grow(board: &Board, pos: Point2d, grow: Square, die: Square) -> Square {
|
2018-12-01 13:41:19 +00:00
|
|
|
for pos1 in pos.neighbours() {
|
2018-12-01 13:29:06 +00:00
|
|
|
if board.rect().contains(pos1) {
|
2018-12-01 13:40:50 +00:00
|
|
|
let neigh_sq = board.get(pos1);
|
2018-11-28 15:02:33 +00:00
|
|
|
if neigh_sq == grow {
|
|
|
|
return grow;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
die
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() -> std::io::Result<()> {
|
|
|
|
let args = args().collect::<Vec<_>>();
|
|
|
|
eprintln!("executing {}", args[0]);
|
|
|
|
|
|
|
|
let x_size = args[1].parse::<usize>().unwrap();
|
|
|
|
let y_size = args[2].parse::<usize>().unwrap();
|
|
|
|
let arg = args[3].parse::<usize>().unwrap_or(DEFAULT_ARG);
|
|
|
|
eprintln!("screen size {}x{}, arg {}", x_size, y_size, arg);
|
|
|
|
|
|
|
|
let mut rng = thread_rng();
|
2018-12-02 13:21:59 +00:00
|
|
|
let size = v2d(x_size as i32, y_size as i32);
|
2018-11-28 15:02:33 +00:00
|
|
|
|
|
|
|
let p_empty = 0.25;
|
|
|
|
let p_grass = 0.25;
|
|
|
|
let p_rabbit = 0.25;
|
|
|
|
// p_fox = 0.05
|
2018-12-01 13:29:06 +00:00
|
|
|
let mut board = Board::new(size, || {
|
|
|
|
let p = rng.gen::<f64>();
|
|
|
|
if p < p_empty {
|
|
|
|
Square::Empty
|
|
|
|
} else if p < p_empty + p_grass {
|
|
|
|
Square::Grass
|
|
|
|
} else if p < p_empty + p_grass + p_rabbit {
|
|
|
|
Square::Rabbit
|
|
|
|
} else {
|
|
|
|
Square::Fox
|
|
|
|
}
|
|
|
|
});
|
2018-11-28 15:02:33 +00:00
|
|
|
|
|
|
|
let t_frame = 0.040; // s
|
|
|
|
let delay = Duration::new(0, (1_000_000_000.0 * t_frame) as u32);
|
|
|
|
|
2018-12-01 09:04:23 +00:00
|
|
|
// mid point of the board
|
2018-11-28 15:02:33 +00:00
|
|
|
let x_mid = (x_size - 1) as f64 / 2.0;
|
|
|
|
let y_mid = (y_size - 1) as f64 / 2.0;
|
2018-12-01 09:04:23 +00:00
|
|
|
|
|
|
|
// radius of the death zone in the middle
|
2018-11-28 15:02:33 +00:00
|
|
|
let r = (x_size.min(y_size) - 1) as f64 / 2.5;
|
2018-12-01 09:04:23 +00:00
|
|
|
|
2018-11-28 15:02:33 +00:00
|
|
|
loop {
|
|
|
|
for _ in 0..arg {
|
2018-12-01 13:29:06 +00:00
|
|
|
let pos = board.rect().random_point(&mut rng);
|
|
|
|
let sq = board.get(pos);
|
2018-12-01 10:49:45 +00:00
|
|
|
let dx = (pos.x as f64 - x_mid as f64) / r as f64;
|
|
|
|
let dy = (pos.y as f64 - y_mid as f64) / r as f64;
|
2018-11-28 15:02:33 +00:00
|
|
|
let p0 = (dx * dx + dy * dy).min(1.0);
|
|
|
|
let p_survive = match sq {
|
|
|
|
Square::Empty => 1.0,
|
|
|
|
Square::Grass => p0,
|
|
|
|
Square::Rabbit => p0,
|
|
|
|
Square::Fox => 0.8 * p0,
|
|
|
|
};
|
|
|
|
let new_sq = if rng.gen::<f64>() < p_survive {
|
|
|
|
sq
|
|
|
|
} else {
|
|
|
|
Square::Empty
|
|
|
|
};
|
2018-12-01 13:29:06 +00:00
|
|
|
board.set(
|
|
|
|
pos,
|
|
|
|
match sq {
|
|
|
|
Square::Empty => grow(&board, pos, Square::Grass, new_sq),
|
|
|
|
Square::Grass => grow(&board, pos, Square::Rabbit, new_sq),
|
|
|
|
Square::Rabbit => grow(&board, pos, Square::Fox, new_sq),
|
|
|
|
Square::Fox => new_sq,
|
|
|
|
},
|
|
|
|
);
|
2018-11-28 15:02:33 +00:00
|
|
|
}
|
2018-12-01 09:04:23 +00:00
|
|
|
|
2018-11-28 15:02:33 +00:00
|
|
|
let mut buf = Vec::with_capacity(x_size * y_size * 3);
|
|
|
|
send(&mut buf, &board)?;
|
|
|
|
stdout().write_all(&buf)?;
|
|
|
|
stdout().flush()?;
|
|
|
|
sleep(delay);
|
|
|
|
}
|
|
|
|
}
|