diff --git a/.gitignore b/.gitignore
index 96ef6c0..a9d37c5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,2 @@
-/target
+target
 Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
index 389320f..a85e3dc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,4 +13,3 @@ homepage = "https://github.com/zkat/big-brain"
 
 [dependencies]
 bevy = "0.5.0"
-
diff --git a/examples/dorf_hero/Cargo.toml b/examples/dorf_hero/Cargo.toml
new file mode 100644
index 0000000..ce6318f
--- /dev/null
+++ b/examples/dorf_hero/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "dorf_hero"
+version = "0.1.0"
+authors = ["Kat Marchán <kzm@zkat.tech>"]
+edition = "2018"
+
+[dependencies]
+bevy_tilemap = "0.4.0"
+rand = "0.8.3"
+pathfinding = "2.1.2"
+bevy = "0.5.0"
+big-brain = { path = "../../" }
diff --git a/examples/dorf_hero/LICENSE b/examples/dorf_hero/LICENSE
new file mode 100644
index 0000000..3f6419d
--- /dev/null
+++ b/examples/dorf_hero/LICENSE
@@ -0,0 +1,27 @@
+This example is based on one from bevy_tilemap, found here:
+https://github.com/joshuajbouw/bevy_tilemap/blob/9e19adb/examples/examples/random_dungeon.rs
+
+It, and the other assets in this subproject, include the following license,
+reproduced here in accordance with its requirements:
+
+MIT License
+
+Copyright (c) 2020 Joshua J. Bouw
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/examples/dorf_hero/assets/textures/dwarf.png b/examples/dorf_hero/assets/textures/dwarf.png
new file mode 100644
index 0000000..ba76254
Binary files /dev/null and b/examples/dorf_hero/assets/textures/dwarf.png differ
diff --git a/examples/dorf_hero/assets/textures/square-dwarf.png b/examples/dorf_hero/assets/textures/square-dwarf.png
new file mode 100644
index 0000000..ba76254
Binary files /dev/null and b/examples/dorf_hero/assets/textures/square-dwarf.png differ
diff --git a/examples/dorf_hero/assets/textures/square-evil-dwarf.png b/examples/dorf_hero/assets/textures/square-evil-dwarf.png
new file mode 100644
index 0000000..5ee3b5a
Binary files /dev/null and b/examples/dorf_hero/assets/textures/square-evil-dwarf.png differ
diff --git a/examples/dorf_hero/assets/textures/square-floor.png b/examples/dorf_hero/assets/textures/square-floor.png
new file mode 100644
index 0000000..5949b46
Binary files /dev/null and b/examples/dorf_hero/assets/textures/square-floor.png differ
diff --git a/examples/dorf_hero/assets/textures/square-floor_alt.png b/examples/dorf_hero/assets/textures/square-floor_alt.png
new file mode 100644
index 0000000..1898f87
Binary files /dev/null and b/examples/dorf_hero/assets/textures/square-floor_alt.png differ
diff --git a/examples/dorf_hero/assets/textures/square-wall.png b/examples/dorf_hero/assets/textures/square-wall.png
new file mode 100644
index 0000000..f60c69f
Binary files /dev/null and b/examples/dorf_hero/assets/textures/square-wall.png differ
diff --git a/examples/dorf_hero/src/ai/actions/chase.rs b/examples/dorf_hero/src/ai/actions/chase.rs
new file mode 100644
index 0000000..78e3c58
--- /dev/null
+++ b/examples/dorf_hero/src/ai/actions/chase.rs
@@ -0,0 +1,69 @@
+use bevy::prelude::*;
+use bevy_tilemap::Tilemap;
+use big_brain::prelude::*;
+
+use crate::components::{Position, Render};
+use crate::resources::GameState;
+
+// Let's define our "default" action, which will be used whenever there's nothing in particular getting our dorf's attention.
+#[derive(Default, Debug, Clone)]
+pub struct ChaseBuilder;
+
+#[derive(Debug, Default, Clone)]
+pub struct Chase {
+    
+}
+
+impl Chase {
+    pub fn build() -> ChaseBuilder {
+        ChaseBuilder
+    }
+}
+
+impl ActionBuilder for ChaseBuilder {
+    fn build(&self, cmd: &mut Commands, action: Entity, _actor: Entity) {
+        cmd.entity(action).insert(Chase::default());
+    }
+}
+
+pub fn meander_action(
+    mut game_state: ResMut<GameState>,
+    time: Res<Time>,
+    mut map_query: Query<(&mut Tilemap, &mut Timer)>,
+    mut location_query: Query<(&mut Position, &Render)>,
+    mut action_q: Query<(&mut Chase, &Actor, &mut ActionState)>,
+) {
+    for (mut map, mut timer) in map_query.iter_mut() {
+        timer.tick(time.delta());
+        if !timer.finished() {
+            continue;
+        }
+        for (mut chase, Actor(actor), mut state) in action_q.iter_mut() {
+            match *state {
+                ActionState::Cancelled => {
+                    // *ALWAYS* handle Cancelled, even if you're doing a single-tick action. Your action might end up hanging otherwise.
+                    *state = ActionState::Success;
+                    continue;
+                }
+                ActionState::Init | ActionState::Success | ActionState::Failure => {
+                    continue;
+                }
+                // These two fall through to logic :)
+                ActionState::Requested => {
+                    *state = ActionState::Executing;
+                }
+                ActionState::Executing => {}
+            }
+            if let Ok((mut pos, render)) = location_query.get_mut(*actor) {
+                if (chase.dx == 0 && chase.dy == 0)
+                    || !game_state.try_move(&mut *map, render, &mut pos, (chase.dx, chase.dy))
+                {
+                    let mut rng = rand::thread_rng();
+                    chase.dx = rng.gen_range(-1..=1);
+                    chase.dy = rng.gen_range(-1..=1);
+                }
+            }
+        }
+    }
+}
+
diff --git a/examples/dorf_hero/src/ai/actions/meander.rs b/examples/dorf_hero/src/ai/actions/meander.rs
new file mode 100644
index 0000000..f0d4802
--- /dev/null
+++ b/examples/dorf_hero/src/ai/actions/meander.rs
@@ -0,0 +1,69 @@
+use bevy::prelude::*;
+use bevy_tilemap::Tilemap;
+use big_brain::prelude::*;
+use rand::Rng;
+
+use crate::components::{Position, Render};
+use crate::resources::GameState;
+// Let's define our "default" action, which will be used whenever there's nothing in particular getting our dorf's attention.
+#[derive(Default, Debug, Clone)]
+pub struct MeanderBuilder;
+
+#[derive(Debug, Default, Clone)]
+pub struct Meander {
+    dx: i32,
+    dy: i32,
+}
+
+impl Meander {
+    pub fn build() -> MeanderBuilder {
+        MeanderBuilder
+    }
+}
+
+impl ActionBuilder for MeanderBuilder {
+    fn build(&self, cmd: &mut Commands, action: Entity, _actor: Entity) {
+        cmd.entity(action).insert(Meander::default());
+    }
+}
+
+pub fn meander_action(
+    mut game_state: ResMut<GameState>,
+    time: Res<Time>,
+    mut map_query: Query<(&mut Tilemap, &mut Timer)>,
+    mut location_query: Query<(&mut Position, &Render)>,
+    mut action_q: Query<(&mut Meander, &Actor, &mut ActionState)>,
+) {
+    for (mut map, mut timer) in map_query.iter_mut() {
+        timer.tick(time.delta());
+        if !timer.finished() {
+            continue;
+        }
+        for (mut meander, Actor(actor), mut state) in action_q.iter_mut() {
+            match *state {
+                ActionState::Cancelled => {
+                    // *ALWAYS* handle Cancelled, even if you're doing a single-tick action. Your action might end up hanging otherwise.
+                    *state = ActionState::Success;
+                    continue;
+                }
+                ActionState::Init | ActionState::Success | ActionState::Failure => {
+                    continue;
+                }
+                // These two fall through to logic :)
+                ActionState::Requested => {
+                    *state = ActionState::Executing;
+                }
+                ActionState::Executing => {}
+            }
+            if let Ok((mut pos, render)) = location_query.get_mut(*actor) {
+                if (meander.dx == 0 && meander.dy == 0)
+                    || !game_state.try_move(&mut *map, render, &mut pos, (meander.dx, meander.dy))
+                {
+                    let mut rng = rand::thread_rng();
+                    meander.dx = rng.gen_range(-1..=1);
+                    meander.dy = rng.gen_range(-1..=1);
+                }
+            }
+        }
+    }
+}
diff --git a/examples/dorf_hero/src/ai/actions/mod.rs b/examples/dorf_hero/src/ai/actions/mod.rs
new file mode 100644
index 0000000..50efd22
--- /dev/null
+++ b/examples/dorf_hero/src/ai/actions/mod.rs
@@ -0,0 +1,2 @@
+pub mod chase;
+pub mod meander;
diff --git a/examples/dorf_hero/src/ai/mod.rs b/examples/dorf_hero/src/ai/mod.rs
new file mode 100644
index 0000000..9cc3b58
--- /dev/null
+++ b/examples/dorf_hero/src/ai/mod.rs
@@ -0,0 +1,16 @@
+use bevy::prelude::*;
+use big_brain::prelude::*;
+
+pub mod actions;
+pub mod scorers;
+
+pub struct DorfHeroAiPlugin;
+
+impl Plugin for DorfHeroAiPlugin {
+    fn build(&self, app: &mut bevy::prelude::AppBuilder) {
+        app.add_plugin(BigBrainPlugin)
+            .add_system(scorers::enemy_distance::enemy_distance.system())
+            .add_system(scorers::fear_of_death::fear_of_death.system())
+            .add_system(actions::meander::meander_action.system());
+    }
+}
diff --git a/examples/dorf_hero/src/ai/scorers/enemy_distance.rs b/examples/dorf_hero/src/ai/scorers/enemy_distance.rs
new file mode 100644
index 0000000..0e7b6c7
--- /dev/null
+++ b/examples/dorf_hero/src/ai/scorers/enemy_distance.rs
@@ -0,0 +1,80 @@
+use bevy::prelude::*;
+use big_brain::{
+    evaluators::{Evaluator, LinearEvaluator},
+    prelude::*,
+};
+
+use crate::components::{EvilDorf, Hero, Position};
+use crate::util;
+
+#[derive(Debug, Default)]
+pub struct EnemyDistanceBuilder {
+    within: f32,
+}
+
+impl EnemyDistanceBuilder {
+    pub fn within(mut self, within: f32) -> Self {
+        self.within = within;
+        self
+    }
+}
+
+impl ScorerBuilder for EnemyDistanceBuilder {
+    fn build(&self, cmd: &mut Commands, scorer: Entity, _actor: Entity) {
+        cmd.entity(scorer).insert(EnemyDistance {
+            within: self.within,
+            evaluator: LinearEvaluator::new_ranged(self.within, 0.0),
+        });
+    }
+}
+
+#[derive(Debug)]
+pub struct EnemyDistance {
+    within: f32,
+    evaluator: LinearEvaluator,
+}
+
+impl EnemyDistance {
+    pub fn build() -> EnemyDistanceBuilder {
+        EnemyDistanceBuilder::default()
+    }
+}
+
+pub fn enemy_distance(
+    enemy_q: Query<&Position, With<EvilDorf>>,
+    hero_q: Query<&Position, With<Hero>>,
+    mut scorer_q: Query<(&Actor, &mut Score, &EnemyDistance)>,
+) {
+    for (Actor(actor), mut score, enemy_distance) in scorer_q.iter_mut() {
+        if let Ok(enemy_pos) = enemy_q.get(*actor) {
+            if let Ok(hero_pos) = hero_q.single() {
+                let distance = util::euclidean_distance(enemy_pos, hero_pos);
+                if distance <= enemy_distance.within {
+                    score.set(
+                        enemy_distance
+                            .evaluator
+                            .evaluate(distance / enemy_distance.within),
+                    );
+                } else {
+                    score.set(0.0);
+                }
+            }
+        }
+        if let Ok(hero_pos) = hero_q.get(*actor) {
+            let mut max = 0.;
+            for enemy_pos in enemy_q.iter() {
+                let distance = util::euclidean_distance(enemy_pos, hero_pos);
+                if distance <= enemy_distance.within {
+                    let val = enemy_distance.evaluator.evaluate(distance / enemy_distance.within);
+                    if val > max {
+                        max = val;
+                    }
+                    if max >= 1.0 {
+                        break;
+                    }
+                }
+            }
+            score.set(max);
+        }
+    }
+}
diff --git a/examples/dorf_hero/src/ai/scorers/fear_of_death.rs b/examples/dorf_hero/src/ai/scorers/fear_of_death.rs
new file mode 100644
index 0000000..d582d36
--- /dev/null
+++ b/examples/dorf_hero/src/ai/scorers/fear_of_death.rs
@@ -0,0 +1,36 @@
+use bevy::prelude::*;
+use big_brain::{
+    evaluators::{Evaluator, PowerEvaluator},
+    prelude::*,
+};
+
+use crate::components::Hp;
+
+pub struct FearOfDeath {
+    evaluator: PowerEvaluator,
+}
+
+impl FearOfDeath {
+    pub fn build() -> FearOfDeathBuilder {
+        FearOfDeathBuilder::default()
+    }
+}
+#[derive(Debug, Default)]
+pub struct FearOfDeathBuilder;
+
+impl ScorerBuilder for FearOfDeathBuilder {
+    fn build(&self, cmd: &mut Commands, scorer: Entity, _actor: Entity) {
+        cmd.entity(scorer).insert(FearOfDeath {
+            evaluator: PowerEvaluator::new_ranged(2., 1.0, 0.0),
+        });
+    }
+}
+
+pub fn fear_of_death(hp_q: Query<&Hp>, mut scorer_q: Query<(&Actor, &mut Score, &FearOfDeath)>) {
+    for (Actor(actor), mut score, fear) in scorer_q.iter_mut() {
+        if let Ok(hp) = hp_q.get(*actor) {
+            let perc = hp.current as f32 / hp.max as f32;
+            score.set(fear.evaluator.evaluate(perc));
+        }
+    }
+}
diff --git a/examples/dorf_hero/src/ai/scorers/mod.rs b/examples/dorf_hero/src/ai/scorers/mod.rs
new file mode 100644
index 0000000..a26c36d
--- /dev/null
+++ b/examples/dorf_hero/src/ai/scorers/mod.rs
@@ -0,0 +1,2 @@
+pub mod enemy_distance;
+pub mod fear_of_death;
diff --git a/examples/dorf_hero/src/components/evil_dorf.rs b/examples/dorf_hero/src/components/evil_dorf.rs
new file mode 100644
index 0000000..49d6344
--- /dev/null
+++ b/examples/dorf_hero/src/components/evil_dorf.rs
@@ -0,0 +1 @@
+pub struct EvilDorf;
diff --git a/examples/dorf_hero/src/components/hero.rs b/examples/dorf_hero/src/components/hero.rs
new file mode 100644
index 0000000..2724391
--- /dev/null
+++ b/examples/dorf_hero/src/components/hero.rs
@@ -0,0 +1,3 @@
+#[derive(Default)]
+pub struct Hero;
+
diff --git a/examples/dorf_hero/src/components/hp.rs b/examples/dorf_hero/src/components/hp.rs
new file mode 100644
index 0000000..10dd2e1
--- /dev/null
+++ b/examples/dorf_hero/src/components/hp.rs
@@ -0,0 +1,10 @@
+pub struct Hp {
+    pub current: u32,
+    pub max: u32,
+}
+
+impl Hp {
+    pub fn new(max: u32) -> Self {
+        Hp { current: max, max }
+    }
+}
diff --git a/examples/dorf_hero/src/components/mod.rs b/examples/dorf_hero/src/components/mod.rs
new file mode 100644
index 0000000..2d87c3f
--- /dev/null
+++ b/examples/dorf_hero/src/components/mod.rs
@@ -0,0 +1,11 @@
+pub use evil_dorf::*;
+pub use hero::*;
+pub use hp::*;
+pub use position::*;
+pub use render::*;
+
+mod evil_dorf;
+mod hero;
+mod hp;
+mod position;
+mod render;
diff --git a/examples/dorf_hero/src/components/position.rs b/examples/dorf_hero/src/components/position.rs
new file mode 100644
index 0000000..f9e5692
--- /dev/null
+++ b/examples/dorf_hero/src/components/position.rs
@@ -0,0 +1,5 @@
+#[derive(Default, Copy, Clone, PartialEq)]
+pub struct Position {
+    pub x: i32,
+    pub y: i32,
+}
diff --git a/examples/dorf_hero/src/components/render.rs b/examples/dorf_hero/src/components/render.rs
new file mode 100644
index 0000000..1669d0f
--- /dev/null
+++ b/examples/dorf_hero/src/components/render.rs
@@ -0,0 +1,6 @@
+#[derive(Default)]
+pub struct Render {
+    pub sprite_index: usize,
+    pub sprite_order: usize,
+}
+
diff --git a/examples/dorf_hero/src/lib.rs b/examples/dorf_hero/src/lib.rs
new file mode 100644
index 0000000..21187d3
--- /dev/null
+++ b/examples/dorf_hero/src/lib.rs
@@ -0,0 +1,287 @@
+use bevy::{
+    asset::LoadState,
+    prelude::*,
+    sprite::{TextureAtlas, TextureAtlasBuilder},
+    window::WindowMode,
+};
+use bevy_tilemap::prelude::*;
+use big_brain::prelude::*;
+use rand::Rng;
+
+use ai::DorfHeroAiPlugin;
+use components::{EvilDorf, Hero, Hp, Position, Render};
+use resources::{GameState, TileSpriteHandles};
+use systems::DorfHeroSystemsPlugin;
+
+mod ai;
+mod components;
+mod resources;
+mod systems;
+mod util;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+enum AppState {
+    Setup,
+    Simulating,
+}
+
+pub fn start() {
+    App::build()
+        .insert_resource(WindowDescriptor {
+            title: "Dorf Hero".to_string(),
+            width: 1024.,
+            height: 1024.,
+            vsync: false,
+            resizable: true,
+            mode: WindowMode::Windowed,
+            ..Default::default()
+        })
+        .init_resource::<TileSpriteHandles>()
+        .init_resource::<GameState>()
+        .add_plugins(DefaultPlugins)
+        .add_plugin(DorfHeroAiPlugin)
+        .add_plugin(DorfHeroSystemsPlugin(AppState::Simulating))
+        .add_state(AppState::Setup)
+        .add_system_set(SystemSet::on_enter(AppState::Setup).with_system(setup.system()))
+        .add_system_set(SystemSet::on_update(AppState::Setup).with_system(check_loaded.system()))
+        .add_system_set(SystemSet::on_exit(AppState::Setup).with_system(load.system()))
+        .add_system_set(
+            SystemSet::on_enter(AppState::Simulating).with_system(build_random_dungeon.system()),
+        )
+        .run()
+}
+
+// Here we have a pretty typical bundle, except we've added a ThinkerBuilder to it.
+const CHUNK_WIDTH: u32 = 16;
+const CHUNK_HEIGHT: u32 = 16;
+const TILEMAP_WIDTH: i32 = CHUNK_WIDTH as i32 * 40;
+const TILEMAP_HEIGHT: i32 = CHUNK_HEIGHT as i32 * 40;
+
+fn setup(mut tile_sprite_handles: ResMut<TileSpriteHandles>, asset_server: Res<AssetServer>) {
+    tile_sprite_handles.handles = asset_server.load_folder("textures").unwrap();
+}
+
+fn load(
+    mut commands: Commands,
+    sprite_handles: Res<TileSpriteHandles>,
+    mut texture_atlases: ResMut<Assets<TextureAtlas>>,
+    mut textures: ResMut<Assets<Texture>>,
+) {
+    let mut texture_atlas_builder = TextureAtlasBuilder::default();
+    for handle in sprite_handles.handles.iter() {
+        let texture = textures.get(handle).unwrap();
+        texture_atlas_builder.add_texture(handle.clone_weak().typed::<Texture>(), &texture);
+    }
+
+    let texture_atlas = texture_atlas_builder.finish(&mut textures).unwrap();
+    let atlas_handle = texture_atlases.add(texture_atlas);
+
+    // These are fairly advanced configurations just to quickly showcase
+    // them.
+    let tilemap = Tilemap::builder()
+        .dimensions(TILEMAP_WIDTH as u32, TILEMAP_HEIGHT as u32)
+        .chunk_dimensions(CHUNK_WIDTH, CHUNK_HEIGHT, 1)
+        .texture_dimensions(32, 32)
+        .auto_chunk()
+        .auto_spawn(2, 2)
+        .add_layer(
+            TilemapLayer {
+                kind: LayerKind::Dense,
+            },
+            0,
+        )
+        .texture_atlas(atlas_handle)
+        .finish()
+        .unwrap();
+
+    let tilemap_components = TilemapBundle {
+        tilemap,
+        visible: Visible {
+            is_visible: true,
+            is_transparent: true,
+        },
+        transform: Default::default(),
+        global_transform: Default::default(),
+    };
+    commands
+        .spawn()
+        .insert_bundle(OrthographicCameraBundle::new_2d());
+    commands
+        .spawn()
+        .insert_bundle(tilemap_components)
+        .insert(Timer::from_seconds(0.1, true));
+}
+
+fn build_random_dungeon(
+    mut commands: Commands,
+    mut game_state: ResMut<GameState>,
+    texture_atlases: Res<Assets<TextureAtlas>>,
+    asset_server: Res<AssetServer>,
+    mut query: Query<&mut Tilemap>,
+) {
+    for mut map in query.iter_mut() {
+        // Then we need to find out what the handles were to our textures we are going to use.
+        let floor_sprite: Handle<Texture> = asset_server.get_handle("textures/square-floor.png");
+        let wall_sprite: Handle<Texture> = asset_server.get_handle("textures/square-wall.png");
+        let texture_atlas = texture_atlases.get(map.texture_atlas()).unwrap();
+        let floor_idx = texture_atlas.get_texture_index(&floor_sprite).unwrap();
+        let wall_idx = texture_atlas.get_texture_index(&wall_sprite).unwrap();
+
+        // Now we fill the entire space with floors.
+        let mut tiles = Vec::new();
+        for y in 0..TILEMAP_HEIGHT {
+            for x in 0..TILEMAP_WIDTH {
+                let y = y - TILEMAP_HEIGHT / 2;
+                let x = x - TILEMAP_WIDTH / 2;
+                // By default tile sets the Z order at 0. Lower means that tile
+                // will render lower than others. 0 is the absolute bottom
+                // level which is perfect for backgrounds.
+                let tile = Tile {
+                    point: (x, y),
+                    sprite_index: floor_idx,
+                    ..Default::default()
+                };
+                tiles.push(tile);
+            }
+        }
+
+        for x in 0..TILEMAP_WIDTH {
+            let x = x - TILEMAP_WIDTH / 2;
+            let tile_a = (x, -TILEMAP_HEIGHT / 2);
+            let tile_b = (x, TILEMAP_HEIGHT / 2 - 1);
+            tiles.push(Tile {
+                point: tile_a,
+                sprite_index: wall_idx,
+                ..Default::default()
+            });
+            tiles.push(Tile {
+                point: tile_b,
+                sprite_index: wall_idx,
+                ..Default::default()
+            });
+            game_state.walls.insert(tile_a);
+            game_state.walls.insert(tile_b);
+        }
+
+        // Then the wall tiles on the Y axis.
+        for y in 0..TILEMAP_HEIGHT {
+            let y = y - TILEMAP_HEIGHT / 2;
+            let tile_a = (-TILEMAP_WIDTH / 2, y);
+            let tile_b = (TILEMAP_WIDTH / 2 - 1, y);
+            tiles.push(Tile {
+                point: tile_a,
+                sprite_index: wall_idx,
+                ..Default::default()
+            });
+            tiles.push(Tile {
+                point: tile_b,
+                sprite_index: wall_idx,
+                ..Default::default()
+            });
+            game_state.walls.insert(tile_a);
+            game_state.walls.insert(tile_b);
+        }
+
+        // Lets just generate some random walls to sparsely place around the dungeon!
+        let range = (TILEMAP_WIDTH * TILEMAP_HEIGHT) as usize / 5;
+        let mut rng = rand::thread_rng();
+        for _ in 0..range {
+            let x = rng.gen_range((-TILEMAP_WIDTH / 2)..(TILEMAP_WIDTH / 2));
+            let y = rng.gen_range((-TILEMAP_HEIGHT / 2)..(TILEMAP_HEIGHT / 2));
+            let coord = (x, y, 0i32);
+            if coord != (0, 0, 0) {
+                tiles.push(Tile {
+                    point: (x, y),
+                    sprite_index: wall_idx,
+                    ..Default::default()
+                });
+                game_state.walls.insert((x, y));
+            }
+        }
+
+        // The above should give us a neat little randomized dungeon! However,
+        // we are missing a hero! First, we need to add a layer. We must make
+        // this layer `Sparse` else we will lose efficiency with our data!
+        //
+        // You might've noticed that we didn't create a layer for z_layer 0 but
+        // yet it still works and exists. By default if a layer doesn't exist
+        // and tiles need to be written there then a Dense layer is created
+        // automatically.
+        map.add_layer(
+            TilemapLayer {
+                kind: LayerKind::Sparse,
+            },
+            1,
+        )
+        .unwrap();
+
+        // Now lets add in a dwarf friend!
+        let dwarf_sprite: Handle<Texture> = asset_server.get_handle("textures/square-dwarf.png");
+        let dwarf_sprite_index = texture_atlas.get_texture_index(&dwarf_sprite).unwrap();
+        // We add in a Z order of 1 to place the tile above the background on Z
+        // order 0.
+        let dwarf_tile = Tile {
+            point: (0, 0),
+            sprite_order: 1,
+            sprite_index: dwarf_sprite_index,
+            ..Default::default()
+        };
+        tiles.push(dwarf_tile);
+
+        commands.spawn().insert_bundle((
+            Hero,
+            Hp::new(100),
+            Position { x: 0, y: 0 },
+            Render {
+                sprite_index: dwarf_sprite_index,
+                sprite_order: 1,
+            },
+            Thinker::build()
+                .picker(FirstToScore::new(80.))
+                .otherwise(ai::actions::meander::Meander::build()),
+        ));
+
+        let evil_sprite: Handle<Texture> =
+            asset_server.get_handle("textures/square-evil-dwarf.png");
+        let evil_sprite_index = texture_atlas.get_texture_index(&evil_sprite).unwrap();
+        // We add in a Z order of 1 to place the tile above the background on Z
+        // order 0.
+        let evil_tile = Tile {
+            point: (0, 0),
+            sprite_order: 1,
+            sprite_index: evil_sprite_index,
+            ..Default::default()
+        };
+        tiles.push(evil_tile);
+
+        commands.spawn().insert_bundle((
+            EvilDorf,
+            Hp::new(10),
+            Position { x: 4, y: 8 },
+            Render {
+                sprite_index: evil_sprite_index,
+                sprite_order: 1,
+            },
+            Thinker::build()
+                .picker(FirstToScore::new(80.))
+                .otherwise(ai::actions::meander::Meander::build()),
+        ));
+
+        // Now we pass all the tiles to our map.
+        map.insert_tiles(tiles).unwrap();
+    }
+}
+
+fn check_loaded(
+    mut state: ResMut<State<AppState>>,
+    asset_server: Res<AssetServer>,
+    sprite_handles: Res<TileSpriteHandles>,
+) {
+    if let LoadState::Loaded =
+        asset_server.get_group_load_state(sprite_handles.handles.iter().map(|handle| handle.id))
+    {
+        state
+            .set(AppState::Simulating)
+            .expect("Failed to switch AppState");
+    }
+}
diff --git a/examples/dorf_hero/src/main.rs b/examples/dorf_hero/src/main.rs
new file mode 100644
index 0000000..3186adf
--- /dev/null
+++ b/examples/dorf_hero/src/main.rs
@@ -0,0 +1,3 @@
+fn main() {
+    dorf_hero::start();
+}
diff --git a/examples/dorf_hero/src/resources/game_state.rs b/examples/dorf_hero/src/resources/game_state.rs
new file mode 100644
index 0000000..d700eb2
--- /dev/null
+++ b/examples/dorf_hero/src/resources/game_state.rs
@@ -0,0 +1,52 @@
+use std::collections::HashSet;
+
+use bevy_tilemap::{Tile, Tilemap};
+
+use crate::components::{Position, Render};
+
+#[derive(Default, Clone)]
+pub struct GameState {
+    pub spawned: bool,
+    pub walls: HashSet<(i32, i32)>,
+}
+
+impl GameState {
+    pub fn try_move(
+        &mut self,
+        map: &mut Tilemap,
+        render: &Render,
+        position: &mut Position,
+        delta_xy: (i32, i32),
+    ) -> bool {
+        let prev_pos = *position;
+        let new_pos = (position.x + delta_xy.0, position.y + delta_xy.1);
+        if !self.walls.contains(&new_pos) {
+            position.x += delta_xy.0;
+            position.y += delta_xy.1;
+            move_sprite(map, prev_pos, *position, render);
+            true
+        } else {
+            false
+        }
+    }
+}
+
+
+fn move_sprite(
+    map: &mut Tilemap,
+    previous_position: Position,
+    position: Position,
+    render: &Render,
+) {
+    // We need to first remove where we were prior.
+    map.clear_tile((previous_position.x, previous_position.y), 1)
+        .unwrap();
+    // We then need to update where we are going!
+    let tile = Tile {
+        point: (position.x, position.y),
+        sprite_index: render.sprite_index,
+        sprite_order: render.sprite_order,
+        ..Default::default()
+    };
+    map.insert_tile(tile).unwrap();
+}
diff --git a/examples/dorf_hero/src/resources/mod.rs b/examples/dorf_hero/src/resources/mod.rs
new file mode 100644
index 0000000..b1beab1
--- /dev/null
+++ b/examples/dorf_hero/src/resources/mod.rs
@@ -0,0 +1,5 @@
+pub use game_state::*;
+pub use tile_sprite_handles::*;
+
+mod game_state;
+mod tile_sprite_handles;
diff --git a/examples/dorf_hero/src/resources/tile_sprite_handles.rs b/examples/dorf_hero/src/resources/tile_sprite_handles.rs
new file mode 100644
index 0000000..969c3cd
--- /dev/null
+++ b/examples/dorf_hero/src/resources/tile_sprite_handles.rs
@@ -0,0 +1,7 @@
+use bevy::prelude::HandleUntyped;
+
+#[derive(Default, Clone)]
+pub struct TileSpriteHandles {
+    pub handles: Vec<HandleUntyped>,
+    pub atlas_loaded: bool,
+}
diff --git a/examples/dorf_hero/src/systems/camera_follow_hero.rs b/examples/dorf_hero/src/systems/camera_follow_hero.rs
new file mode 100644
index 0000000..d8d3cff
--- /dev/null
+++ b/examples/dorf_hero/src/systems/camera_follow_hero.rs
@@ -0,0 +1,13 @@
+use bevy::{prelude::*, render::camera::Camera};
+
+use crate::components::{Hero, Position};
+
+pub fn camera_follow_hero(
+    mut camera_q: Query<&mut Transform, With<Camera>>,
+    player_q: Query<&Position, (With<Hero>, Changed<Position>)>,
+) {
+    if let (Ok(player_pos), Ok(mut camera_trans)) = (player_q.single(), camera_q.single_mut()) {
+        camera_trans.translation.x = player_pos.x as f32 * 32.;
+        camera_trans.translation.y = player_pos.y as f32 * 32.;
+    }
+}
diff --git a/examples/dorf_hero/src/systems/mod.rs b/examples/dorf_hero/src/systems/mod.rs
new file mode 100644
index 0000000..1903011
--- /dev/null
+++ b/examples/dorf_hero/src/systems/mod.rs
@@ -0,0 +1,22 @@
+use std::{fmt::Debug, hash::Hash};
+
+use bevy::{ecs::component::Component, prelude::*};
+use bevy_tilemap::prelude::TilemapDefaultPlugins;
+
+mod camera_follow_hero;
+
+pub struct DorfHeroSystemsPlugin<T>(pub T)
+where
+    T: Component + Debug + Clone + Eq + Hash + Send + Sync;
+
+impl<T> Plugin for DorfHeroSystemsPlugin<T>
+where
+    T: Component + Debug + Clone + Eq + Hash + Send + Sync,
+{
+    fn build(&self, app: &mut AppBuilder) {
+        app.add_plugins(TilemapDefaultPlugins).add_system_set(
+            SystemSet::on_update(self.0.clone())
+                .with_system(camera_follow_hero::camera_follow_hero.system()),
+        );
+    }
+}
diff --git a/examples/dorf_hero/src/util.rs b/examples/dorf_hero/src/util.rs
new file mode 100644
index 0000000..b46cf3f
--- /dev/null
+++ b/examples/dorf_hero/src/util.rs
@@ -0,0 +1,7 @@
+use crate::components::Position;
+
+pub fn euclidean_distance(pos1: &Position, pos2: &Position) -> f32 {
+    let a = (pos1.x - pos2.x) as f32;
+    let b = (pos1.y - pos2.y) as f32;
+    a.hypot(b)
+}