252 lines
8.2 KiB
Rust
252 lines
8.2 KiB
Rust
extern crate piston_window;
|
|
use piston_window::*;
|
|
|
|
use std::f64::consts::*;
|
|
|
|
#[derive(Copy, Clone, PartialEq, Debug)]
|
|
struct Position {
|
|
x: f64,
|
|
y: f64,
|
|
}
|
|
|
|
impl Position {
|
|
pub fn distance(&self, other: Position) -> f64 {
|
|
((self.x - other.x).powi(2) + (self.y - other.y).powi(2)).sqrt()
|
|
}
|
|
|
|
pub fn distance_sqr(&self, other: Position) -> f64 {
|
|
(self.x - other.x).powi(2) + (self.y - other.y.powi(2))
|
|
}
|
|
}
|
|
|
|
type Degree = f64;
|
|
type Radian = f64;
|
|
|
|
#[derive(Debug)]
|
|
struct Player {
|
|
pos: Position,
|
|
angle: Degree,
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq)]
|
|
pub enum Tile {
|
|
Empty,
|
|
Wall,
|
|
}
|
|
|
|
pub struct Level {
|
|
pub width: usize,
|
|
pub height: usize,
|
|
pub tiles: Vec<Tile>,
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Debug)]
|
|
pub enum Movement {
|
|
Forward,
|
|
Backward,
|
|
TurnLeft,
|
|
TurnRight,
|
|
}
|
|
|
|
impl Level {
|
|
pub fn contains(&self, pos: Position) -> bool {
|
|
0.0 <= pos.x && pos.x <= self.width as f64 && 0.0 <= pos.y && pos.y <= self.height as f64
|
|
}
|
|
}
|
|
|
|
pub struct Engine {
|
|
w: f64,
|
|
h: f64,
|
|
horiz_fov: Degree,
|
|
player: Player,
|
|
level: Level,
|
|
inputs: Vec<Movement>,
|
|
}
|
|
|
|
impl Engine {
|
|
pub fn new(size: Size) -> Engine {
|
|
Engine {
|
|
w: size.width as f64,
|
|
h: size.height as f64,
|
|
horiz_fov: 90.,
|
|
player: Player {
|
|
pos: Position { x: 2., y: 2. },
|
|
angle: 90.,
|
|
},
|
|
level: Level {
|
|
width: 0,
|
|
height: 0,
|
|
tiles: vec![],
|
|
},
|
|
inputs: [].to_vec(),
|
|
}
|
|
}
|
|
|
|
fn closest_point(level: &Level, pos: &Position, angle: Radian) -> (Tile, Position) {
|
|
assert!((0.0..(PI * 2.0)).contains(&angle));
|
|
|
|
let (y_step, x_step) = match angle {
|
|
x if x == 0.0 => (0.0, std::f64::INFINITY),
|
|
x if x == PI * 0.5 => (std::f64::INFINITY, 0.0),
|
|
x if x == PI => (0.0, std::f64::NEG_INFINITY),
|
|
x if x == PI * 1.5 => (std::f64::NEG_INFINITY, 0.0),
|
|
x if (0.0..(PI * 0.5)).contains(&x) => (angle.tan(), ((PI / 2.0) - angle).tan()),
|
|
x if ((PI * 0.5)..PI).contains(&x) => ((PI - x).tan(), -((x - (PI / 2.0)).tan())),
|
|
x if (PI..(PI * 1.5)).contains(&x) => (-((x - PI).tan()), -(((PI * 1.5) - x).tan())),
|
|
x if ((PI * 1.5)..(PI * 2.0)).contains(&x) => (((PI * 2.0) - x).tan(), -((x - (PI * 1.5)).tan())),
|
|
_ => panic!("Invalid angle value {}.", angle),
|
|
};
|
|
|
|
let (x_remain, y_remain) = match (x_step, y_step) {
|
|
(x, y) if x >= 0.0 && y >= 0.0 => (1.0 - pos.x.fract(), 1.0 - pos.y.fract()),
|
|
(x, y) if x <= 0.0 && y >= 0.0 => (-pos.x.fract(), 1.0 - pos.y.fract()),
|
|
(x, y) if x >= 0.0 && y <= 0.0 => (1.0 - pos.x.fract(), -pos.y.fract()),
|
|
(x, y) if x <= 0.0 && y <= 0.0 => (-pos.x.fract(), -pos.y.fract()),
|
|
_ => panic!("Invalid steps"),
|
|
};
|
|
|
|
let x_dist_factor = x_remain / x_step;
|
|
let y_dist_factor = y_remain / y_step;
|
|
|
|
let mut x_candidate = Position {
|
|
x: pos.x + x_remain, // x_remain = x_step * x_dist_factor
|
|
y: pos.y + y_step * x_dist_factor,
|
|
};
|
|
let mut y_candidate = Position {
|
|
x: pos.x + x_step * y_dist_factor,
|
|
y: pos.y + y_remain, // y_remain = y_step * y_dist_factor
|
|
};
|
|
|
|
let mut next_point: Position = *pos;
|
|
let mut tile = Tile::Empty;
|
|
|
|
while tile == Tile::Empty && level.contains(next_point) {
|
|
if next_point.distance(x_candidate) < next_point.distance(y_candidate) {
|
|
next_point = x_candidate;
|
|
x_candidate = Position {
|
|
x: x_candidate.x + x_step.signum(),
|
|
y: x_candidate.y + y_step,
|
|
};
|
|
} else {
|
|
next_point = y_candidate;
|
|
y_candidate = Position {
|
|
x: y_candidate.x + x_step,
|
|
y: y_candidate.y + y_step.signum(),
|
|
};
|
|
}
|
|
|
|
tile = if next_point.x.fract() == 0.0 {
|
|
let x_index = (next_point.x.trunc() + x_step.signum()) as usize;
|
|
assert!(x_index < level.width);
|
|
let y_index = next_point.y.trunc() as usize;
|
|
assert!(y_index < level.height);
|
|
let index: usize = x_index + y_index * level.width;
|
|
level.tiles[index]
|
|
} else {
|
|
let x_index = next_point.x.trunc() as usize;
|
|
assert!(x_index < level.width);
|
|
let y_index = (next_point.y.trunc() + y_step.signum()) as usize;
|
|
assert!(y_index < level.height);
|
|
let index: usize = x_index + y_index * level.width;
|
|
level.tiles[index]
|
|
};
|
|
}
|
|
|
|
assert!(tile != Tile::Empty);
|
|
|
|
(tile, next_point)
|
|
}
|
|
|
|
pub fn render(&mut self, context: Context, graphics: &mut G2d) {
|
|
|
|
clear([1.0; 4], graphics);
|
|
|
|
// Ceiling
|
|
let ceiling_color = [0.3, 0.3, 0.3, 1.0];
|
|
rectangle(ceiling_color,
|
|
[0.0, 0.0, self.w, self.h / 2.0],
|
|
context.transform,
|
|
graphics);
|
|
|
|
// Floor
|
|
let floor_color = [0.5, 0.5, 0.5, 1.0];
|
|
rectangle(floor_color,
|
|
[0.0, self.h / 2.0, self.w, self.h / 2.0],
|
|
context.transform,
|
|
graphics);
|
|
|
|
let left = self.player.angle + (self.horiz_fov / 2.0);
|
|
let right = self.player.angle - (self.horiz_fov / 2.0);
|
|
let step = self.horiz_fov / self.w;
|
|
let mut ray_angle = left;
|
|
let width = self.w as i32;
|
|
for n in 0..width {
|
|
let ray_angle = ((left - (n as f64) * step) + 360.0) % 360.0;
|
|
let ray_radian = ray_angle.to_radians();
|
|
//println!("degree: {} -> radian: {}", ray_angle, ray_radian);
|
|
let (tile, pos) = Engine::closest_point(&self.level, &self.player.pos, ray_radian);
|
|
let distance = self.player.pos.distance(pos);
|
|
let player_space_distance = (self.player.pos.x - pos.x).abs() * self.player.angle.to_radians().cos()
|
|
- (self.player.pos.y - pos.y).abs() * self.player.angle.to_radians().sin();
|
|
if tile == Tile::Wall {
|
|
//println!("ray: {}, wall at {:?}, distance: {}", n, pos, distance);
|
|
let wall_height = (self.h / (distance * 3.0)).min(self.h);
|
|
let wall_color = [0.2, 0.2, 0.9, 1.0];
|
|
//println!("wall height: {}", wall_height);
|
|
rectangle(wall_color,
|
|
[n as f64, (self.h - wall_height) / 2.0, (n + 1) as f64, wall_height],
|
|
context.transform,
|
|
graphics);
|
|
|
|
};
|
|
}
|
|
}
|
|
|
|
pub fn load_level(&mut self, level: Level) {
|
|
self.level = level;
|
|
}
|
|
|
|
pub fn add_movement(&mut self, movement: Movement) {
|
|
self.inputs.push(movement);
|
|
}
|
|
|
|
pub fn update(&mut self, dt: f64) {
|
|
for input in &self.inputs {
|
|
match input {
|
|
Movement::Forward => {
|
|
self.player.pos.x += self.player.angle.to_radians().cos() * dt;
|
|
self.player.pos.y += self.player.angle.to_radians().sin() * dt;
|
|
}
|
|
Movement::Backward => {
|
|
self.player.pos.x -= self.player.angle.to_radians().cos() * dt;
|
|
self.player.pos.y -= self.player.angle.to_radians().sin() * dt;
|
|
},
|
|
Movement::TurnLeft => {
|
|
self.player.angle += 90.0 * dt;
|
|
self.player.angle = (self.player.angle + 360.0) % 360.0;
|
|
}
|
|
Movement::TurnRight => {
|
|
self.player.angle -= 90.0 * dt;
|
|
self.player.angle = (self.player.angle + 360.0) % 360.0;
|
|
}
|
|
}
|
|
}
|
|
self.inputs.clear();
|
|
|
|
println!("player: {:?}", &self.player);
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn closest_point() {
|
|
let origin = super::Position { x: 2.2, y: 2.3 };
|
|
let angle = 0.;
|
|
let closest = Engine::closest_point(origin, angle);
|
|
assert_eq!(closest, super::Position { x: 3.0, y: 2.3 });
|
|
}
|
|
}
|