306 lines
8.2 KiB
Rust
306 lines
8.2 KiB
Rust
use ggez;
|
|
use ggez::event::{KeyCode, KeyMods};
|
|
use ggez::graphics;
|
|
use ggez::graphics::DrawParam;
|
|
use ggez::graphics::Image;
|
|
use ggez::nalgebra as na;
|
|
use ggez::{conf, event, Context, GameResult};
|
|
use specs::{
|
|
join::Join, Builder, Component, Read, ReadStorage, RunNow, System, VecStorage, World, WorldExt,
|
|
Write, WriteStorage,
|
|
};
|
|
|
|
use std::path;
|
|
|
|
const TILE_WIDTH: f32 = 32.0;
|
|
|
|
// Components
|
|
#[derive(Debug, Component, Clone, Copy)]
|
|
#[storage(VecStorage)]
|
|
pub struct Position {
|
|
x: u8,
|
|
y: u8,
|
|
z: u8,
|
|
}
|
|
|
|
impl Position {
|
|
pub fn new(x: u8, y: u8) -> Self {
|
|
Position { x, y, z: 0 }
|
|
}
|
|
}
|
|
|
|
#[derive(Component)]
|
|
#[storage(VecStorage)]
|
|
pub struct Renderable {
|
|
path: String,
|
|
}
|
|
|
|
#[derive(Component)]
|
|
#[storage(VecStorage)]
|
|
pub struct Wall {}
|
|
|
|
#[derive(Component)]
|
|
#[storage(VecStorage)]
|
|
pub struct Player {}
|
|
|
|
#[derive(Component)]
|
|
#[storage(VecStorage)]
|
|
pub struct Box {}
|
|
|
|
#[derive(Component)]
|
|
#[storage(VecStorage)]
|
|
pub struct BoxSpot {}
|
|
|
|
// Resources
|
|
#[derive(Default)]
|
|
pub struct InputQueue {
|
|
pub keys_pressed: Vec<KeyCode>,
|
|
}
|
|
|
|
// Systems
|
|
pub struct RenderingSystem<'a> {
|
|
context: &'a mut Context,
|
|
}
|
|
|
|
impl<'a> System<'a> for RenderingSystem<'a> {
|
|
type SystemData = (ReadStorage<'a, Position>, ReadStorage<'a, Renderable>);
|
|
|
|
fn run(&mut self, data: Self::SystemData) {
|
|
let (positions, renderables) = data;
|
|
|
|
// Clear the screen/set the background
|
|
graphics::clear(self.context, graphics::Color::new(0.95, 0.95, 0.95, 1.0));
|
|
|
|
// Get all the renderables with their positions and sort by the position z
|
|
// This will allow us to have entities layered visually.
|
|
let mut rendering_data = (&positions, &renderables).join().collect::<Vec<_>>();
|
|
rendering_data.sort_by(|&a, &b| a.0.z.partial_cmp(&b.0.z).expect("expected comparison"));
|
|
|
|
// Iterate through all paris of positions & renderables, load the image
|
|
// and draw it at the specified position.
|
|
for (position, renderable) in rendering_data.iter() {
|
|
// Load the image
|
|
let image = Image::new(self.context, renderable.path.clone()).expect("expected image");
|
|
let x = position.x as f32 * TILE_WIDTH;
|
|
let y = position.y as f32 * TILE_WIDTH;
|
|
|
|
// draw
|
|
let draw_params = DrawParam::new().dest(na::Point2::new(x, y));
|
|
graphics::draw(self.context, &image, draw_params).expect("expected render");
|
|
}
|
|
|
|
// Finally, present the context, this will actually display everything
|
|
// on the screen.
|
|
graphics::present(self.context).expect("expected to present");
|
|
}
|
|
}
|
|
|
|
pub struct InputSystem {}
|
|
|
|
impl<'a> System<'a> for InputSystem {
|
|
// Data
|
|
type SystemData = (
|
|
Write<'a, InputQueue>,
|
|
WriteStorage<'a, Position>,
|
|
ReadStorage<'a, Player>,
|
|
);
|
|
|
|
fn run(&mut self, data: Self::SystemData) {
|
|
let (mut input_queue, mut positions, players) = data;
|
|
|
|
for (position, _player) in (&mut positions, &players).join() {
|
|
// Get the first key pressed
|
|
if let Some(key) = input_queue.keys_pressed.pop() {
|
|
// Apply the key to the position
|
|
match key {
|
|
KeyCode::Up => position.y -= 1,
|
|
KeyCode::Down => position.y += 1,
|
|
KeyCode::Left => position.x -= 1,
|
|
KeyCode::Right => position.x += 1,
|
|
_ => (),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// All the game state
|
|
struct Game {
|
|
world: World,
|
|
}
|
|
|
|
impl event::EventHandler for Game {
|
|
fn update(&mut self, _context: &mut Context) -> GameResult {
|
|
// Run input system
|
|
{
|
|
let mut is = InputSystem {};
|
|
is.run_now(&self.world);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn draw(&mut self, context: &mut Context) -> GameResult {
|
|
// Render gaem entities
|
|
{
|
|
let mut rs = RenderingSystem { context };
|
|
rs.run_now(&self.world);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn key_down_event(
|
|
&mut self,
|
|
_context: &mut Context,
|
|
keycode: KeyCode,
|
|
_keymod: KeyMods,
|
|
_repeat: bool,
|
|
) {
|
|
println!("Key pressed: {:?}", keycode);
|
|
|
|
let mut input_queue = self.world.write_resource::<InputQueue>();
|
|
input_queue.keys_pressed.push(keycode);
|
|
}
|
|
}
|
|
|
|
pub fn register_components(world: &mut World) {
|
|
world.register::<Position>();
|
|
world.register::<Renderable>();
|
|
world.register::<Player>();
|
|
world.register::<Wall>();
|
|
world.register::<Box>();
|
|
world.register::<BoxSpot>();
|
|
}
|
|
|
|
pub fn register_resources(world: &mut World) {
|
|
world.insert(InputQueue::default())
|
|
}
|
|
|
|
pub fn create_wall(world: &mut World, position: Position) {
|
|
world
|
|
.create_entity()
|
|
.with(Position { z: 10, ..position })
|
|
.with(Renderable {
|
|
path: "/images/wall.png".to_string(),
|
|
})
|
|
.with(Wall {})
|
|
.build();
|
|
}
|
|
|
|
pub fn create_floor(world: &mut World, position: Position) {
|
|
world
|
|
.create_entity()
|
|
.with(Position { z: 5, ..position })
|
|
.with(Renderable {
|
|
path: "/images/floor.png".to_string(),
|
|
})
|
|
.build();
|
|
}
|
|
|
|
pub fn create_box(world: &mut World, position: Position) {
|
|
world
|
|
.create_entity()
|
|
.with(Position { z: 10, ..position })
|
|
.with(Renderable {
|
|
path: "/images/box.png".to_string(),
|
|
})
|
|
.build();
|
|
}
|
|
|
|
pub fn create_box_spot(world: &mut World, position: Position) {
|
|
world
|
|
.create_entity()
|
|
.with(Position { z: 9, ..position })
|
|
.with(Renderable {
|
|
path: "/images/box_spot.png".to_string(),
|
|
})
|
|
.with(BoxSpot {})
|
|
.build();
|
|
}
|
|
|
|
pub fn create_player(world: &mut World, position: Position) {
|
|
world
|
|
.create_entity()
|
|
.with(Position { z: 10, ..position })
|
|
.with(Renderable {
|
|
path: "/images/player.png".to_string(),
|
|
})
|
|
.with(Player {})
|
|
.build();
|
|
}
|
|
|
|
pub fn load_map(world: &mut World, map_string: String) {
|
|
// read all lines
|
|
let rows: Vec<&str> = map_string.trim().split('\n').map(|x| x.trim()).collect();
|
|
|
|
for (y, row) in rows.iter().enumerate() {
|
|
let columns: Vec<&str> = row.split(' ').collect();
|
|
|
|
for (x, column) in columns.iter().enumerate() {
|
|
// Create the position at which to create something on the map
|
|
let position = Position::new(x as u8, y as u8);
|
|
|
|
// Figure out which object to create
|
|
match *column {
|
|
"." => create_floor(world, position),
|
|
"W" => {
|
|
create_floor(world, position);
|
|
create_wall(world, position);
|
|
}
|
|
"P" => {
|
|
create_floor(world, position);
|
|
create_player(world, position);
|
|
}
|
|
"B" => {
|
|
create_floor(world, position);
|
|
create_box(world, position);
|
|
}
|
|
"S" => {
|
|
create_floor(world, position);
|
|
create_box_spot(world, position);
|
|
}
|
|
"N" => (),
|
|
c => panic!("unrecognized map item {}", c),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn initialize_level(world: &mut World) {
|
|
const MAP: &str = "
|
|
N N W W W W W W
|
|
W W W . . . . W
|
|
W . . . B . . W
|
|
W . . . . . . W
|
|
W . P . . . . W
|
|
W . . . . . . W
|
|
W . . S . . . W
|
|
W . . . . . . W
|
|
W W W W W W W W
|
|
";
|
|
|
|
load_map(world, MAP.to_string());
|
|
}
|
|
|
|
pub fn main() -> GameResult {
|
|
let mut world = World::new();
|
|
register_components(&mut world);
|
|
register_resources(&mut world);
|
|
initialize_level(&mut world);
|
|
|
|
// Create a game context and event loop
|
|
let context_builder = ggez::ContextBuilder::new("rust_sokoban", "Timothy J. Warren")
|
|
.window_setup(conf::WindowSetup::default().title("Rust Sokoban!"))
|
|
.window_mode(conf::WindowMode::default().dimensions(800.0, 600.0))
|
|
.add_resource_path(path::PathBuf::from("./resources"));
|
|
|
|
let (context, event_loop) = &mut context_builder.build()?;
|
|
|
|
// Create the game state
|
|
let game = &mut Game { world };
|
|
|
|
// Run the main event loop
|
|
event::run(context, event_loop, game)
|
|
}
|