diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 0d3f0e7..bb0eeb4 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -13,9 +13,9 @@ on:
         type: string
 
 env:
-  binary: hello-bevy # [CHANGE]: This needs to match the project name in cargo.toml
+  binary: charon
   add_binaries_to_github_release: true
-  # itch_target: eerii/hello-bevy # [CHANGE]: If you want to deploy to itch, set this as your username/project-url
+  itch_target: eerii/charon
 
 jobs:
   get-version:
diff --git a/Cargo.lock b/Cargo.lock
index 6ce6e27..39d7275 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -644,6 +644,16 @@ dependencies = [
  "syn 2.0.39",
 ]
 
+[[package]]
+name = "bevy_ecs_tilemap"
+version = "0.12.0"
+source = "git+https://github.com/divark/bevy_ecs_tilemap.git?branch=0.12-fixes#658b6c12441a808c8342233a230863d3c74f780f"
+dependencies = [
+ "bevy",
+ "log",
+ "regex",
+]
+
 [[package]]
 name = "bevy_egui"
 version = "0.23.0"
@@ -1411,6 +1421,23 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
 
+[[package]]
+name = "charon"
+version = "0.1.0"
+dependencies = [
+ "bevy",
+ "bevy-inspector-egui",
+ "bevy-persistent",
+ "bevy_asset_loader",
+ "bevy_ecs_tilemap",
+ "bevy_embedded_assets",
+ "bevy_kira_audio",
+ "bevy_mod_debugdump",
+ "iyes_progress",
+ "rand",
+ "serde",
+]
+
 [[package]]
 name = "clang-sys"
 version = "1.6.1"
@@ -2209,22 +2236,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "hello-bevy"
-version = "0.12.3"
-dependencies = [
- "bevy",
- "bevy-inspector-egui",
- "bevy-persistent",
- "bevy_asset_loader",
- "bevy_embedded_assets",
- "bevy_kira_audio",
- "bevy_mod_debugdump",
- "iyes_progress",
- "rand",
- "serde",
-]
-
 [[package]]
 name = "hexasphere"
 version = "9.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index d565f94..e3a53a8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
-name = "hello-bevy" # [CHANGE]: Set your project name.
-version = "0.12.3"
+name = "charon"
+version = "0.1.0"
 edition = "2021"
-description = "a bevy game template"
+description = "a game for the bevy jam 4"
 exclude = ["build", "assets", ".data"]
 
 [profile.dev.package."*"]
@@ -32,5 +32,6 @@ iyes_progress = { version = "0.10", features = [ "assets" ] } # Track loading an
 bevy-inspector-egui = { version = "0.21" } # Inspector
 bevy-persistent = { version = "0.4", features = ["toml"] } # Persistent values (for saving)
 bevy_mod_debugdump = { version = "0.9" } # Debug graphs
+bevy_ecs_tilemap = { git = "https://github.com/divark/bevy_ecs_tilemap.git", branch = "0.12-fixes" } # Tilemap (main repo is not updated for 0.12)
 rand = { version = "0.8" }
 serde = { version = "1.0", features = ["derive"] }
diff --git a/assets/fonts/pixel.ttf b/assets/fonts/pixel.ttf
deleted file mode 100644
index 5cf4045..0000000
Binary files a/assets/fonts/pixel.ttf and /dev/null differ
diff --git a/assets/icons/pixelbevy.png b/assets/icons/pixelbevy.png
deleted file mode 100644
index cced526..0000000
Binary files a/assets/icons/pixelbevy.png and /dev/null differ
diff --git a/assets/sprites/temp_tile.png b/assets/sprites/temp_tile.png
new file mode 100644
index 0000000..bb7579e
Binary files /dev/null and b/assets/sprites/temp_tile.png differ
diff --git a/examples/dvd.rs b/examples/dvd.rs
deleted file mode 100644
index 023da23..0000000
--- a/examples/dvd.rs
+++ /dev/null
@@ -1,210 +0,0 @@
-use bevy::{prelude::*, sprite::MaterialMesh2dBundle, window::WindowResolution};
-use bevy_embedded_assets::{EmbeddedAssetPlugin, PluginMode};
-use bevy_kira_audio::prelude::*;
-use bevy_persistent::Persistent;
-use hello_bevy::{
-    config::GameOptions,
-    load::{GameAssets, SampleAssets},
-    GamePlugin, GameState,
-};
-
-const SIZE: Vec2 = Vec2::new(600., 600.);
-
-fn main() {
-    App::new()
-        .add_plugins((
-            EmbeddedAssetPlugin {
-                mode: PluginMode::ReplaceDefault,
-            },
-            DefaultPlugins.set(WindowPlugin {
-                primary_window: Some(Window {
-                    title: "DVD Screensaver".to_string(),
-                    resolution: WindowResolution::new(SIZE.x, SIZE.y),
-                    resizable: false,
-                    canvas: Some("#bevy".to_string()),
-                    prevent_default_event_handling: false,
-                    ..default()
-                }),
-                ..default()
-            }),
-            GamePlugin,
-            SampleGamePlugin,
-        ))
-        // Run
-        .run();
-}
-
-// ······
-// Plugin
-// ······
-
-pub struct SampleGamePlugin;
-
-impl Plugin for SampleGamePlugin {
-    fn build(&self, app: &mut App) {
-        app.add_event::<CollisionEvent>()
-            .add_systems(
-                OnEnter(GameState::Play),
-                (init_sample.run_if(run_once()), resume_game),
-            )
-            .add_systems(
-                Update,
-                (update_sample, on_collision).run_if(in_state(GameState::Play)),
-            )
-            .add_systems(OnExit(GameState::Play), pause_game);
-    }
-}
-
-// ··········
-// Components
-// ··········
-
-#[derive(Component)]
-struct Velocity(Vec2);
-
-#[derive(Component)]
-struct Counter(u32);
-
-#[derive(Component)]
-struct GameCamera;
-
-// ······
-// Events
-// ······
-
-#[derive(Event)]
-struct CollisionEvent(Entity);
-
-// ·······
-// Systems
-// ·······
-
-fn init_sample(
-    mut cmd: Commands,
-    assets: Res<GameAssets>,
-    opts: Res<Persistent<GameOptions>>,
-    mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<ColorMaterial>>,
-) {
-    // Camera
-    cmd.spawn((Camera2dBundle::default(), GameCamera));
-
-    // Background
-    cmd.spawn(MaterialMesh2dBundle {
-        mesh: meshes.add(Mesh::from(shape::Quad::default())).into(),
-        transform: Transform::from_xyz(0., 0., -10.).with_scale(SIZE.extend(1.)),
-        material: materials.add(ColorMaterial::from(opts.color.darker)),
-        ..default()
-    });
-
-    // Sprites
-    for velocity in [
-        Vec2::new(300., 250.),
-        Vec2::new(-150., 400.),
-        Vec2::new(200., -350.),
-    ] {
-        cmd.spawn((
-            SpriteBundle {
-                texture: assets.bevy_icon.clone(),
-                sprite: Sprite {
-                    custom_size: Some(Vec2::new(96., 96.)),
-                    ..default()
-                },
-                transform: Transform::from_translation(Vec3::new(0., 0., 1.)),
-                ..default()
-            },
-            Velocity(velocity),
-        ));
-    }
-
-    // Counter text
-    cmd.spawn((
-        Text2dBundle {
-            text: Text::from_section(
-                "0",
-                TextStyle {
-                    font: assets.font.clone(),
-                    font_size: 192.,
-                    color: opts.color.mid,
-                },
-            ),
-            ..default()
-        },
-        Counter(0),
-    ));
-}
-
-fn update_sample(
-    time: Res<Time>,
-    mut objects: Query<(Entity, &mut Transform, &mut Velocity, &Sprite)>,
-    mut event_collision: EventWriter<CollisionEvent>,
-) {
-    let win_bound = Rect::from_center_size(Vec2::ZERO, SIZE);
-
-    for (entity, mut trans, mut vel, sprite) in objects.iter_mut() {
-        // Update position based on velocity
-        let t = &mut trans.translation;
-        *t += vel.0.extend(0.) * time.delta_seconds();
-
-        // Calculate the sprite bound
-        let obj_bound = Rect::from_center_size(
-            Vec2::new(t.x, t.y),
-            sprite.custom_size.expect("Sprite needs a custom size"),
-        );
-
-        // Calculate the interection with the level borders and send a collision event
-        let intersection = win_bound.intersect(obj_bound).size();
-        if intersection.x < obj_bound.width() {
-            vel.0.x *= -1.;
-            t.x += (obj_bound.width() - intersection.x) * vel.0.x.signum();
-            event_collision.send(CollisionEvent(entity));
-        }
-        if intersection.y < obj_bound.height() {
-            vel.0.y *= -1.;
-            t.y += (obj_bound.height() - intersection.y) * vel.0.y.signum();
-            event_collision.send(CollisionEvent(entity));
-        }
-    }
-}
-
-fn on_collision(
-    mut objects: Query<&mut Sprite>,
-    mut counter: Query<(&mut Text, &mut Counter)>,
-    mut event_collision: EventReader<CollisionEvent>,
-    audio: Res<Audio>,
-    assets: Res<SampleAssets>,
-) {
-    let (mut text, mut counter) = counter.single_mut();
-
-    // On each collision, increase the counter, change the spirte color and play audio
-    for CollisionEvent(entity) in event_collision.read() {
-        counter.0 += 1;
-        text.sections[0].value = counter.0.to_string();
-
-        if let Ok(mut sprite) = objects.get_mut(*entity) {
-            sprite.color = random_color();
-        }
-
-        audio.play(assets.boing.clone()).with_volume(0.3);
-    }
-}
-
-fn resume_game(mut cam: Query<&mut Camera, With<GameCamera>>) {
-    if let Ok(mut cam) = cam.get_single_mut() {
-        cam.is_active = true;
-    }
-}
-
-fn pause_game(mut cam: Query<&mut Camera, With<GameCamera>>) {
-    if let Ok(mut cam) = cam.get_single_mut() {
-        cam.is_active = false;
-    }
-}
-
-// ·····
-// Extra
-// ·····
-
-fn random_color() -> Color {
-    Color::hsl(rand::random::<f32>() * 360., 0.8, 0.8)
-}
diff --git a/examples/jump.rs b/examples/jump.rs
deleted file mode 100644
index 1cafcc7..0000000
--- a/examples/jump.rs
+++ /dev/null
@@ -1,193 +0,0 @@
-#![allow(clippy::too_many_arguments)]
-
-use bevy::{prelude::*, sprite::MaterialMesh2dBundle, window::WindowResolution};
-use bevy_embedded_assets::{EmbeddedAssetPlugin, PluginMode};
-use bevy_persistent::Persistent;
-use hello_bevy::{
-    config::{GameOptions, Keybinds},
-    input::Bind,
-    load::GameAssets,
-    GamePlugin, GameState,
-};
-
-const SIZE: Vec2 = Vec2::new(600., 600.);
-const INITIAL_VEL: Vec2 = Vec2::new(0., 250.);
-const GRAVITY: f32 = -10000.;
-const JUMP_VEL: f32 = 2000.;
-const MOVE_VEL: f32 = 700.;
-const BOUNCE_CUTOFF: f32 = 100.;
-const BOUNCE_FACTOR: f32 = 0.2;
-const MOVE_CUTOFF: f32 = 100.;
-const MOVE_FACTOR: f32 = 0.85;
-
-fn main() {
-    App::new()
-        .add_plugins((
-            EmbeddedAssetPlugin {
-                mode: PluginMode::ReplaceDefault,
-            },
-            DefaultPlugins.set(WindowPlugin {
-                primary_window: Some(Window {
-                    title: "Endless jump".to_string(),
-                    resolution: WindowResolution::new(SIZE.x, SIZE.y),
-                    resizable: false,
-                    canvas: Some("#bevy".to_string()),
-                    prevent_default_event_handling: false,
-                    ..default()
-                }),
-                ..default()
-            }),
-            GamePlugin,
-            SampleGamePlugin,
-        ))
-        // Run
-        .run();
-}
-
-// ······
-// Plugin
-// ······
-
-pub struct SampleGamePlugin;
-
-impl Plugin for SampleGamePlugin {
-    fn build(&self, app: &mut App) {
-        app.add_systems(
-            OnEnter(GameState::Play),
-            (init_sample.run_if(run_once()), resume_game),
-        )
-        .add_systems(Update, update_sample.run_if(in_state(GameState::Play)))
-        .add_systems(OnExit(GameState::Play), pause_game);
-    }
-}
-
-// ··········
-// Components
-// ··········
-
-#[derive(Component)]
-struct Player {
-    velocity: Vec2,
-}
-
-#[derive(Component)]
-struct Counter(u32);
-
-#[derive(Component)]
-struct GameCamera;
-
-// ·······
-// Systems
-// ·······
-
-fn init_sample(
-    mut cmd: Commands,
-    assets: Res<GameAssets>,
-    opts: Res<Persistent<GameOptions>>,
-    mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<ColorMaterial>>,
-) {
-    // Camera
-    cmd.spawn((Camera2dBundle::default(), GameCamera));
-
-    // Background
-    cmd.spawn(MaterialMesh2dBundle {
-        mesh: meshes.add(Mesh::from(shape::Quad::default())).into(),
-        transform: Transform::from_xyz(0., 0., -10.).with_scale(SIZE.extend(1.)),
-        material: materials.add(ColorMaterial::from(opts.color.darker)),
-        ..default()
-    });
-
-    // Player
-    cmd.spawn((
-        SpriteBundle {
-            texture: assets.bevy_icon.clone(),
-            sprite: Sprite {
-                custom_size: Some(Vec2::new(96., 96.)),
-                ..default()
-            },
-            transform: Transform::from_translation(Vec3::new(0., 0., 1.)),
-            ..default()
-        },
-        Player {
-            velocity: INITIAL_VEL,
-        },
-    ));
-
-    // Counter
-    cmd.spawn((
-        Text2dBundle {
-            text: Text::from_section(
-                "0",
-                TextStyle {
-                    font: assets.font.clone(),
-                    font_size: 192.,
-                    color: opts.color.mid,
-                },
-            ),
-            ..default()
-        },
-        Counter(0),
-    ));
-}
-
-fn update_sample(
-    time: Res<Time>,
-    mut objects: Query<(&mut Player, &mut Transform)>,
-    mut counter: Query<(&mut Text, &mut Counter)>,
-    input: Res<Input<Bind>>,
-    keybinds: Res<Persistent<Keybinds>>,
-) {
-    for (mut player, mut trans) in objects.iter_mut() {
-        let t = &mut trans.translation;
-
-        // Gravity
-        if t.y > -SIZE.y * 0.4 {
-            player.velocity.y += GRAVITY * time.delta_seconds();
-        } else {
-            t.y = -SIZE.y * 0.4;
-            if player.velocity.y.abs() > BOUNCE_CUTOFF {
-                player.velocity.y = player.velocity.y.abs() * BOUNCE_FACTOR;
-            } else {
-                player.velocity.y = 0.;
-            }
-        }
-
-        // Jump
-        if keybinds.jump.iter().any(|bind| input.just_pressed(*bind)) {
-            player.velocity.y = JUMP_VEL;
-
-            let (mut text, mut counter) = counter.single_mut();
-            counter.0 += 1;
-            text.sections[0].value = counter.0.to_string();
-        }
-
-        // Move
-        if keybinds.left.iter().any(|bind| input.pressed(*bind)) {
-            player.velocity.x = -MOVE_VEL;
-        } else if keybinds.right.iter().any(|bind| input.pressed(*bind)) {
-            player.velocity.x = MOVE_VEL;
-        } else if player.velocity.x.abs() > MOVE_CUTOFF {
-            player.velocity.x *= MOVE_FACTOR;
-        } else {
-            player.velocity.x = 0.;
-        }
-
-        // Update position based on velocity and add bounds
-        *t += player.velocity.extend(0.) * time.delta_seconds();
-        t.y = t.y.max(-SIZE.y * 0.4);
-        t.x = (t.x + SIZE.x * 0.5).rem_euclid(SIZE.x) - SIZE.x * 0.5;
-    }
-}
-
-fn resume_game(mut cam: Query<&mut Camera, With<GameCamera>>) {
-    if let Ok(mut cam) = cam.get_single_mut() {
-        cam.is_active = true;
-    }
-}
-
-fn pause_game(mut cam: Query<&mut Camera, With<GameCamera>>) {
-    if let Ok(mut cam) = cam.get_single_mut() {
-        cam.is_active = false;
-    }
-}
diff --git a/src/audio.rs b/src/audio.rs
index f04080e..c0a76a3 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -1,7 +1,5 @@
 use bevy::prelude::*;
-use bevy_kira_audio::{prelude::AudioPlugin as KiraAudioPlugin, prelude::*};
-
-use crate::{load::SampleAssets, GameState};
+use bevy_kira_audio::prelude::AudioPlugin as KiraAudioPlugin;
 
 // ······
 // Plugin
@@ -12,8 +10,8 @@ pub struct AudioPlugin;
 impl Plugin for AudioPlugin {
     fn build(&self, app: &mut App) {
         app.add_plugins(KiraAudioPlugin)
-            .add_systems(OnEnter(GameState::Play), init_music)
-            .add_systems(OnExit(GameState::Play), pause_music)
+            /*.add_systems(OnEnter(GameState::Play), init_music)
+            .add_systems(OnExit(GameState::Play), pause_music)*/
             .init_resource::<MusicHandles>();
     }
 }
@@ -24,14 +22,14 @@ impl Plugin for AudioPlugin {
 
 #[derive(Resource, Default)]
 struct MusicHandles {
-    ambient_music: Option<Handle<AudioInstance>>,
+    //ambient_music: Option<Handle<AudioInstance>>,
 }
 
 // ·······
 // Systems
 // ·······
 
-fn init_music(
+/*fn init_music(
     assets: Res<SampleAssets>,
     audio: Res<Audio>,
     mut handles: ResMut<MusicHandles>,
@@ -62,4 +60,4 @@ fn pause_music(handles: Res<MusicHandles>, mut instances: ResMut<Assets<AudioIns
             inst.pause(default());
         }
     }
-}
+}*/
diff --git a/src/input.rs b/src/input.rs
index 208380d..7203738 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -20,14 +20,18 @@ pub struct InputPlugin;
 impl Plugin for InputPlugin {
     fn build(&self, app: &mut App) {
         app.insert_resource(Input::<Bind>::default())
+            .insert_resource(MousePosition::default())
             .add_systems(
                 PreUpdate,
                 (
-                    handle_input_keyboard,
-                    handle_input_mouse,
-                    handle_input_gamepad,
-                )
-                    .run_if(resource_exists::<Persistent<Keybinds>>()),
+                    (
+                        handle_input_keyboard,
+                        handle_input_mouse,
+                        handle_input_gamepad,
+                    )
+                        .run_if(resource_exists::<Persistent<Keybinds>>()),
+                    handle_mouse_moved,
+                ),
             )
             .add_systems(PostUpdate, clear_input);
     }
@@ -54,6 +58,9 @@ impl ToString for Bind {
     }
 }
 
+#[derive(Resource, Default)]
+pub struct MousePosition(pub Vec2);
+
 // ·······
 // Systems
 // ·······
@@ -117,3 +124,17 @@ fn handle_input_gamepad(
 fn clear_input(mut input: ResMut<Input<Bind>>) {
     input.clear();
 }
+
+fn handle_mouse_moved(
+    camera: Query<(&GlobalTransform, &Camera)>, // TODO: Create game camera and filter it here
+    mut events: EventReader<CursorMoved>,
+    mut mouse: ResMut<MousePosition>,
+) {
+    for event in events.read() {
+        for (trans, cam) in camera.iter() {
+            if let Some(pos) = cam.viewport_to_world_2d(trans, event.position) {
+                *mouse = MousePosition(pos);
+            }
+        }
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 627d1cc..43545d6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,15 +1,14 @@
-pub mod audio;
-pub mod config;
+mod audio;
+mod config;
 mod debug;
-pub mod input;
-pub mod load;
+mod input;
+mod load;
 mod menu;
+mod tilemap;
 mod ui;
 
 use bevy::prelude::*;
 
-// TODO: Option for pixel perfect upscaling camera
-
 // Game state
 #[derive(States, Debug, Default, Clone, Eq, PartialEq, Hash)]
 pub enum GameState {
@@ -31,6 +30,7 @@ impl Plugin for GamePlugin {
             config::ConfigPlugin,
             input::InputPlugin,
             audio::AudioPlugin,
+            tilemap::TilePlugin,
         ));
 
         #[cfg(debug_assertions)]
diff --git a/src/load.rs b/src/load.rs
index 408a987..2337c8c 100644
--- a/src/load.rs
+++ b/src/load.rs
@@ -4,7 +4,6 @@
 use crate::{config::GameOptions, ui::*, GameState};
 use bevy::prelude::*;
 use bevy_asset_loader::prelude::*;
-use bevy_kira_audio::AudioSource;
 use bevy_persistent::Persistent;
 use iyes_progress::prelude::*;
 
@@ -23,7 +22,7 @@ impl Plugin for LoadPlugin {
     fn build(&self, app: &mut App) {
         app.add_loading_state(LoadingState::new(GameState::Loading))
             .init_collection::<GameAssets>()
-            .add_collection_to_loading_state::<_, SampleAssets>(GameState::Loading)
+            .add_collection_to_loading_state::<_, TilemapAssets>(GameState::Loading)
             .add_plugins((ProgressPlugin::new(GameState::Loading)
                 .continue_to(GameState::Menu)
                 .track_assets(),))
@@ -53,14 +52,10 @@ pub struct GameAssets {
     pub font: Handle<Font>,
 }
 
-// Sample assets
 #[derive(AssetCollection, Resource)]
-pub struct SampleAssets {
-    #[asset(path = "sounds/boing.ogg")]
-    pub boing: Handle<AudioSource>,
-
-    #[asset(path = "music/soundscape.ogg")]
-    pub ambient_music: Handle<AudioSource>,
+pub struct TilemapAssets {
+    #[asset(path = "sprites/temp_tile.png")]
+    pub temp: Handle<Image>,
 }
 
 // ··········
diff --git a/src/main.rs b/src/main.rs
index 7bb2d3c..d0cb388 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,18 +1,17 @@
 use bevy::{prelude::*, window::WindowResolution};
 use bevy_embedded_assets::{EmbeddedAssetPlugin, PluginMode};
-use hello_bevy::GamePlugin;
+use charon::GamePlugin;
 
 fn main() {
     App::new()
         .add_plugins((
             EmbeddedAssetPlugin {
-                // Embed assets in binary (else itch.io is broken right now)
                 mode: PluginMode::ReplaceDefault,
             },
             DefaultPlugins.set(WindowPlugin {
                 primary_window: Some(Window {
-                    title: "Hello Bevy!".to_string(), // [CHANGE]: Game title
-                    resolution: WindowResolution::new(600., 600.),
+                    title: "Charon".to_string(),
+                    resolution: WindowResolution::new(1000., 700.),
                     resizable: false, // Or use fit_canvas_to_parent: true for resizing on the web
                     canvas: Some("#bevy".to_string()),
                     prevent_default_event_handling: false,
@@ -20,7 +19,6 @@ fn main() {
                 }),
                 ..default()
             }),
-            //.set(ImagePlugin::default_nearest()), // [CHANGE]: Use if your game is pixel art
             GamePlugin,
         ))
         // Run
diff --git a/src/tilemap.rs b/src/tilemap.rs
new file mode 100644
index 0000000..be97781
--- /dev/null
+++ b/src/tilemap.rs
@@ -0,0 +1,114 @@
+use bevy::prelude::*;
+use bevy_ecs_tilemap::prelude::*;
+
+use crate::{input::MousePosition, load::TilemapAssets, GameState};
+
+const MAP_SIZE: TilemapSize = TilemapSize { x: 14, y: 10 };
+const TILE_SIZE: TilemapTileSize = TilemapTileSize { x: 64., y: 64. };
+const GRID_SIZE: TilemapGridSize = TilemapGridSize { x: 72., y: 72. };
+
+// ······
+// Plugin
+// ······
+
+pub struct TilePlugin;
+
+impl Plugin for TilePlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins(TilemapPlugin)
+            .add_systems(OnEnter(GameState::Play), init_tilemap)
+            .add_systems(Update, select_tile)
+            .add_systems(PostUpdate, highlight_selected_tile);
+    }
+}
+
+// ··········
+// Components
+// ··········
+
+#[derive(Component)]
+pub struct SelectedTile;
+
+// ·······
+// Systems
+// ·······
+
+fn init_tilemap(mut cmd: Commands, tiles: Res<TilemapAssets>) {
+    let tilemap = cmd.spawn_empty().id();
+
+    // Spawn tiles
+    let mut storage = TileStorage::empty(MAP_SIZE);
+    for x in 0..MAP_SIZE.x {
+        for y in 0..MAP_SIZE.y {
+            let pos = TilePos { x, y };
+            let tile = cmd
+                .spawn(TileBundle {
+                    position: pos,
+                    tilemap_id: TilemapId(tilemap),
+                    ..default()
+                })
+                .id();
+            storage.set(&pos, tile);
+        }
+    }
+
+    // Create tilemap
+    let map_type = TilemapType::default();
+    cmd.entity(tilemap).insert(TilemapBundle {
+        size: MAP_SIZE,
+        tile_size: TILE_SIZE,
+        grid_size: GRID_SIZE,
+        map_type,
+        storage,
+        texture: TilemapTexture::Single(tiles.temp.clone()),
+        transform: get_tilemap_center_transform(&MAP_SIZE, &GRID_SIZE, &map_type, 0.0),
+        ..default()
+    });
+
+    // Create atlas (if needed)
+}
+
+fn select_tile(
+    mut cmd: Commands,
+    mouse: Res<MousePosition>,
+    tilemap: Query<(
+        &TilemapSize,
+        &TilemapGridSize,
+        &TilemapType,
+        &TileStorage,
+        &Transform,
+    )>,
+    selected: Query<Entity, With<SelectedTile>>,
+) {
+    for entity in selected.iter() {
+        cmd.entity(entity).remove::<SelectedTile>();
+    }
+
+    for (map_size, grid_size, map_type, tile_storage, map_transform) in tilemap.iter() {
+        let mouse: Vec2 = mouse.0;
+
+        let mouse_in_map_pos: Vec2 = {
+            let mouse = Vec4::from((mouse, 0.0, 1.0));
+            let mouse_in_map_pos = map_transform.compute_matrix().inverse() * mouse;
+            mouse_in_map_pos.xy()
+        };
+
+        if let Some(tile_pos) =
+            TilePos::from_world_pos(&mouse_in_map_pos, map_size, grid_size, map_type)
+        {
+            if let Some(tile_entity) = tile_storage.get(&tile_pos) {
+                cmd.entity(tile_entity).insert(SelectedTile);
+            }
+        }
+    }
+}
+
+fn highlight_selected_tile(mut tile: Query<(&mut TileColor, Option<&SelectedTile>)>) {
+    for (mut color, selected) in tile.iter_mut() {
+        if selected.is_some() {
+            *color = TileColor(Color::GREEN);
+        } else {
+            *color = TileColor(Color::WHITE);
+        }
+    }
+}