wip

Cargo.toml

@@ -7,4 +7,9 @@ edition = "2018"
 
 [dependencies]
 bevy = { version = "0.5.0", features = ["dynamic"] }
+bevy_ecs_tilemap = { git = "https://github.com/StarArawn/bevy_ecs_tilemap", version = "0.4.0", features = ["tiled_map"]} 
+rand = "0.8.4"
+env_logger = "0.8"
+log = "0.4"
+
 # bevy = { version = "0.5.0" }
\ No newline at end of file

README.md

@@ -6,14 +6,27 @@ A small example of sprite animation. Tested under linux (arch) and win10.
 
 - Rust toolchain with nightly (for faster builds)
 
+Tested mainly under win10.
+
 ## Usage
 
 > cargo run --release
 
+## Key dependencies
+- [bevy](https://www.bevy.com/)
+- [bevy_esc_tilemap](https://github.com/StarArawn/bevy_ecs_tilemap)
+
 ## Assets
 
-- [bevy](https://www.bevy.com/)
 - [Zombie sprite sheet](https://www.kenney.nl/assets/toon-characters-1)
+- [Tiles](https://kenney.nl/assets/pixel-platformer)
+
+## Tools
+
+Tile map created with [tiled](https://www.mapeditor.org/)
+
+## Design 
+
 
 ## License
 

assets/tmap.tsx

+<?xml version="1.0" encoding="UTF-8"?>
+<tileset version="1.5" tiledversion="1.7.1" name="tiles_packed" tilewidth="16" tileheight="16" tilecount="220" columns="22">
+ <image source="tiles_packed.png" trans="000000" width="360" height="162"/>
+</tileset>

src/main.rs

 #![allow(unused)]
-use bevy::{core::FixedTimestep, prelude::*};
+use bevy::{
+    core::FixedTimestep,
+    prelude::*,
+    render::{camera::Camera, texture::FilterMode},
+};
+use bevy_ecs_tilemap::{prelude::*, MapQuery};
 use std::f32::consts::PI;
 
 const PLAYER_SHEET: &str = "character_zombie_sheet.png";
 fn main() {
+    env_logger::Builder::from_default_env()
+        .filter_level(log::LevelFilter::Info)
+        .init();
+
     App::build()
-        .insert_resource(ClearColor(Color::rgb(0.04, 0.04, 0.04)))
+        .insert_resource(ClearColor(Color::rgb(0.0, 0.0, 0.0)))
         .insert_resource(WindowDescriptor {
             title: "My Little Zombie".to_string(),
             width: 1920.,
@@ -15,16 +24,38 @@ fn main() {
             // resizable: false,
             ..Default::default()
         })
+        .add_plugins(DefaultPlugins)
+        .add_plugin(TilemapPlugin)
+        .add_plugin(TiledMapPlugin)
         .add_startup_system(setup.system())
         .add_system_set(
             SystemSet::new()
                 .with_run_criteria(FixedTimestep::step(1.0 / 60.0))
-                .with_system(player_movement.system()),
+                .with_system(player_movement.system())
+                .with_system(camera.system())
+                .with_system(parallax.system()),
         )
-        .add_plugins(DefaultPlugins)
+        .add_system(set_texture_filters_to_nearest.system())
         .run();
 }
 
+fn set_texture_filters_to_nearest(
+    mut texture_events: EventReader<AssetEvent<Texture>>,
+    mut textures: ResMut<Assets<Texture>>,
+) {
+    // quick and dirty, run this for all textures anytime a texture is created.
+    for event in texture_events.iter() {
+        match event {
+            AssetEvent::Created { handle } => {
+                if let Some(mut texture) = textures.get_mut(handle) {
+                    texture.sampler.min_filter = FilterMode::Nearest;
+                }
+            }
+            _ => (),
+        }
+    }
+}
+
 fn setup(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
@@ -34,8 +65,24 @@ fn setup(
 ) {
     let mut window = windows.get_primary_mut().unwrap();
     commands.spawn_bundle(OrthographicCameraBundle::new_2d());
-
     let bottom = -window.height() / 2.0;
+
+    // load the tile map
+    let handle: Handle<TiledMap> = asset_server.load("tmap.tmx");
+    let map_entity = commands.spawn().id();
+    commands.entity(map_entity).insert_bundle(TiledMapBundle {
+        tiled_map: handle,
+        map: Map::new(0u16, map_entity),
+
+        transform: Transform {
+            translation: Vec3::new(0., bottom, 1.0),
+            scale: Vec3::new(4.0, 4.0, 1.0),
+            ..Default::default()
+        },
+
+        ..Default::default()
+    });
+
     let texture_handle = asset_server.load(PLAYER_SHEET);
     let texture_atlas = TextureAtlas::from_grid(texture_handle, Vec2::new(96.0, 128.0), 9, 5);
     let atlas_handle = texture_atlases.add(texture_atlas);
@@ -174,3 +221,60 @@ fn player_movement(
         transform.translation.x += dir;
     }
 }
+
+// A simple camera system for moving and zooming the camera.
+pub fn camera(
+    time: Res<Time>,
+    keyboard_input: Res<Input<KeyCode>>,
+    mut query: Query<&mut Transform, With<Camera>>,
+) {
+    // println!("camera");
+    for mut transform in query.iter_mut() {
+        // print!("-");
+        let mut direction = Vec3::ZERO;
+        let scale = transform.scale.x;
+
+        if keyboard_input.pressed(KeyCode::A) {
+            direction -= Vec3::new(1.0, 0.0, 0.0);
+        }
+
+        if keyboard_input.pressed(KeyCode::D) {
+            direction += Vec3::new(1.0, 0.0, 0.0);
+        }
+
+        if keyboard_input.pressed(KeyCode::W) {
+            direction += Vec3::new(0.0, 1.0, 0.0);
+        }
+
+        if keyboard_input.pressed(KeyCode::S) {
+            direction -= Vec3::new(0.0, 1.0, 0.0);
+        }
+
+        if keyboard_input.pressed(KeyCode::Z) {
+            let scale = scale + 0.1;
+            transform.scale = Vec3::splat(scale);
+        }
+
+        if keyboard_input.pressed(KeyCode::X) {
+            let scale = scale - 0.1;
+            transform.scale = Vec3::splat(scale);
+        }
+
+        if transform.scale.x < 1.0 {
+            transform.scale = Vec3::splat(1.0)
+        }
+
+        transform.translation += time.delta_seconds() * direction * 500.;
+    }
+}
+
+// parallaxing
+pub fn parallax(mut query: Query<(&mut Transform, &Layer)>) {
+    println!("parallax");
+    for (mut _transform, layer) in query.iter_mut() {
+        print!(
+            "layer_id {:?}, map_id {:?}",
+            layer.settings.layer_id, layer.settings.map_id
+        );
+    }
+}