diff --git a/src/dev_tools.rs b/src/dev_tools.rs
index 2056ecb..e5a124f 100644
--- a/src/dev_tools.rs
+++ b/src/dev_tools.rs
@@ -1,29 +1,41 @@
 use bevy::dev_tools::fps_overlay::FpsOverlayPlugin;
 use bevy::dev_tools::states::log_transitions;
-use bevy::input::common_conditions::{input_just_pressed, input_toggle_active};
 use bevy::prelude::*;
 use bevy_inspector_egui::bevy_egui::EguiPlugin;
 use bevy_inspector_egui::quick::WorldInspectorPlugin;
 
+use crate::input::input_map::{Action, action_just_pressed};
 use crate::screens::Screen;
 
-const TOGGLE_KEY: KeyCode = KeyCode::Backquote;
-
 pub fn plugin(app: &mut App) {
     app.add_plugins((
         FpsOverlayPlugin::default(),
         EguiPlugin::default(),
-        WorldInspectorPlugin::new().run_if(input_toggle_active(false, TOGGLE_KEY)),
+        WorldInspectorPlugin::new().run_if(in_state(DebugMode(true))),
     ));
 
     app.add_systems(Update, log_transitions::<Screen>);
 
+    app.init_state::<DebugMode>();
+
     app.add_systems(
         Update,
-        toggle_debug_ui.run_if(input_just_pressed(TOGGLE_KEY)),
+        toggle_debug_mode.run_if(action_just_pressed(Action::DebugMode)),
     );
+
+    app.add_systems(Update, sync_ui_debug.run_if(state_changed::<DebugMode>));
+}
+
+#[derive(States, PartialEq, Eq, Debug, Hash, Reflect, Clone, Default)]
+pub struct DebugMode(pub bool);
+
+fn toggle_debug_mode(
+    debug_mode: Res<State<DebugMode>>,
+    mut next_debug_mode: ResMut<NextState<DebugMode>>,
+) {
+    next_debug_mode.set(DebugMode(!debug_mode.0));
 }
 
-fn toggle_debug_ui(mut options: ResMut<UiDebugOptions>) {
-    options.toggle();
+fn sync_ui_debug(mut options: ResMut<UiDebugOptions>, debug_mode: Res<State<DebugMode>>) {
+    options.enabled = debug_mode.0;
 }
diff --git a/src/gameplay/hud/hotbar.rs b/src/gameplay/hud/hotbar.rs
index 2f705cf..3fe48b2 100644
--- a/src/gameplay/hud/hotbar.rs
+++ b/src/gameplay/hud/hotbar.rs
@@ -1,25 +1,25 @@
 use bevy::{
     ecs::{spawn::SpawnIter, system::SystemParam},
-    input::keyboard::KeyboardInput,
     prelude::*,
 };
 use bevy_aseprite_ultra::prelude::*;
 
 use crate::{
     gameplay::{FactorySystems, structure::assets::StructureDef, world::tilemap::TileClicked},
+    input::input_map::{Action, InputActions},
     screens::Screen,
 };
 
-const DIGIT_KEYS: [KeyCode; 9] = [
-    KeyCode::Digit1,
-    KeyCode::Digit2,
-    KeyCode::Digit3,
-    KeyCode::Digit4,
-    KeyCode::Digit5,
-    KeyCode::Digit6,
-    KeyCode::Digit7,
-    KeyCode::Digit8,
-    KeyCode::Digit9,
+const HOTBAR_ACTIONS: [Action; 9] = [
+    Action::Hotbar1,
+    Action::Hotbar2,
+    Action::Hotbar3,
+    Action::Hotbar4,
+    Action::Hotbar5,
+    Action::Hotbar6,
+    Action::Hotbar7,
+    Action::Hotbar8,
+    Action::Hotbar9,
 ];
 
 pub fn plugin(app: &mut App) {
@@ -36,10 +36,7 @@ pub fn plugin(app: &mut App) {
 
     app.add_systems(
         Update,
-        (
-            select_on_keyboard_shortcuts.run_if(on_message::<KeyboardInput>),
-            highlight_selected_slot,
-        ),
+        (select_on_keyboard_shortcuts, highlight_selected_slot),
     );
 
     app.add_systems(
@@ -124,7 +121,7 @@ pub enum HotbarActionKind {
 
 #[derive(Component, Reflect, Debug)]
 #[reflect(Component)]
-struct HotbarShortcut(KeyCode);
+struct HotbarShortcut(Action);
 
 #[derive(Component, Reflect, Debug)]
 #[reflect(Component)]
@@ -147,7 +144,7 @@ fn spawn_hotbar(mut commands: Commands) {
             ..default()
         },
         Pickable::IGNORE,
-        Children::spawn(SpawnIter((0..DIGIT_KEYS.len()).map(|i| {
+        Children::spawn(SpawnIter((0..HOTBAR_ACTIONS.len()).map(|i| {
             (
                 Name::new(format!("Hotbar Slot {}", i + 1)),
                 Node {
@@ -162,7 +159,7 @@ fn spawn_hotbar(mut commands: Commands) {
                 Pickable::default(),
                 BorderColor::all(Color::WHITE),
                 HotbarSlot,
-                HotbarShortcut(DIGIT_KEYS[i]),
+                HotbarShortcut(HOTBAR_ACTIONS[i]),
             )
         }))),
     ));
@@ -252,12 +249,12 @@ fn select_on_click(
 }
 
 fn select_on_keyboard_shortcuts(
-    keys: Res<ButtonInput<KeyCode>>,
     hotbar_slots: Query<(Entity, &HotbarShortcut), With<HotbarSlot>>,
+    input_actions: Res<InputActions>,
     mut hotbar: HotbarSelector,
 ) {
     for (entity, shortcut) in hotbar_slots {
-        if keys.just_pressed(shortcut.0) {
+        if input_actions.just_pressed.contains(&shortcut.0) {
             hotbar.select(Some(entity));
         }
     }
diff --git a/src/gameplay/hud/inspect/mod.rs b/src/gameplay/hud/inspect/mod.rs
index 6f984c3..9d03a5a 100644
--- a/src/gameplay/hud/inspect/mod.rs
+++ b/src/gameplay/hud/inspect/mod.rs
@@ -1,6 +1,9 @@
-use bevy::{input::common_conditions::input_just_pressed, prelude::*};
+use bevy::prelude::*;
 
-use crate::gameplay::recipe::select::SelectedRecipe;
+use crate::{
+    gameplay::recipe::select::SelectedRecipe,
+    input::input_map::{Action, action_just_pressed},
+};
 
 mod info;
 mod select;
@@ -15,7 +18,7 @@ pub fn plugin(app: &mut App) {
 
     app.add_systems(
         Update,
-        close_menu.run_if(input_just_pressed(KeyCode::Escape)),
+        close_menu.run_if(action_just_pressed(Action::Dismiss)),
     );
 }
 
diff --git a/src/gameplay/hud/inventory/mod.rs b/src/gameplay/hud/inventory/mod.rs
index 13fd7f8..67ecc16 100644
--- a/src/gameplay/hud/inventory/mod.rs
+++ b/src/gameplay/hud/inventory/mod.rs
@@ -1,10 +1,11 @@
 use bevy::{
-    input::common_conditions::input_just_pressed,
     prelude::*,
     ui::Checked,
     ui_widgets::{RadioButton, RadioGroup, ValueChange, observe},
 };
 
+use crate::input::input_map::{Action, action_just_pressed};
+
 pub mod items;
 pub mod people;
 
@@ -25,7 +26,7 @@ pub(super) fn plugin(app: &mut App) {
     app.add_systems(
         Update,
         (
-            toggle_inventory_ui.run_if(input_just_pressed(KeyCode::KeyT)),
+            toggle_inventory_ui.run_if(action_just_pressed(Action::OpenTome)),
             update_tab_color,
             update_entry_color,
         ),
diff --git a/src/gameplay/structure/interactable.rs b/src/gameplay/structure/interactable.rs
index 2720201..0170ba0 100644
--- a/src/gameplay/structure/interactable.rs
+++ b/src/gameplay/structure/interactable.rs
@@ -1,9 +1,10 @@
 use bevy::prelude::*;
 use bevy_aseprite_ultra::prelude::*;
 
-use crate::assets::tracking::LoadResource;
-
-const INTERACTABLE_BUTTON: KeyCode = KeyCode::KeyE;
+use crate::{
+    assets::tracking::LoadResource,
+    input::input_map::{Action, InputMap, action_just_pressed},
+};
 
 pub fn plugin(app: &mut App) {
     app.load_resource::<InteractionAssets>();
@@ -13,7 +14,10 @@ pub fn plugin(app: &mut App) {
     app.add_observer(on_hover);
     app.add_observer(on_leave);
 
-    app.add_systems(Update, on_interact_button_click);
+    app.add_systems(
+        Update,
+        on_interact_button_click.run_if(action_just_pressed(Action::Interact)),
+    );
 }
 
 #[derive(Component, Reflect, Default)]
@@ -73,6 +77,7 @@ fn on_hover(
     mut commands: Commands,
     mut hovered_interactable: ResMut<HoveredInteractable>,
     interaction_assets: Res<InteractionAssets>,
+    input_map: Res<InputMap>,
 ) {
     if !interactables.contains(pointer_over.entity) {
         return;
@@ -85,7 +90,7 @@ fn on_hover(
         Transform::from_xyz(0.0, 0.0, 1.0),
         ChildOf(pointer_over.entity),
         ButtonIndicatorOf(pointer_over.entity),
-        interaction_assets.sprite(INTERACTABLE_BUTTON),
+        interaction_assets.sprite(*input_map.keymap.get(&Action::Interact).unwrap()),
     ));
 
     pointer_over.propagate(false);
@@ -111,14 +116,9 @@ fn on_leave(
 }
 
 fn on_interact_button_click(
-    keys: Res<ButtonInput<KeyCode>>,
     hovered_interactable: Res<HoveredInteractable>,
     mut commands: Commands,
 ) {
-    if !keys.just_pressed(INTERACTABLE_BUTTON) {
-        return;
-    }
-
     let Some(interactable) = hovered_interactable.0 else {
         return;
     };
diff --git a/src/gameplay/world/demolition.rs b/src/gameplay/world/demolition.rs
index e46c113..0cf0c81 100644
--- a/src/gameplay/world/demolition.rs
+++ b/src/gameplay/world/demolition.rs
@@ -1,11 +1,12 @@
 use std::collections::HashSet;
 
-use bevy::{input::common_conditions::input_just_pressed, prelude::*};
+use bevy::prelude::*;
 
-use crate::gameplay::{FactorySystems, world::tilemap::coord::Coord};
+use crate::{
+    gameplay::{FactorySystems, world::tilemap::coord::Coord},
+    input::input_map::{Action, InputActions, action_just_pressed},
+};
 
-pub const DEMOLISH_BUTTON: KeyCode = KeyCode::KeyF;
-pub const DEMOLISH_CANCEL_BUTTON: KeyCode = KeyCode::Escape;
 pub const DEMOLISH_DURATION_SECS: f32 = 1.0;
 
 pub(super) fn plugin(app: &mut App) {
@@ -14,20 +15,21 @@ pub(super) fn plugin(app: &mut App) {
 
     app.add_message::<Demolished>();
 
+    app.add_observer(add_to_selection);
+    app.add_observer(remove_from_selection);
+
     app.add_systems(
-        FixedUpdate,
+        Update,
         (
-            add_to_selection.run_if(on_message::<Pointer<Over>>),
-            remove_from_selection.run_if(on_message::<Pointer<Out>>),
-            clear_selection.run_if(input_just_pressed(DEMOLISH_CANCEL_BUTTON)),
+            clear_selection.run_if(action_just_pressed(Action::Dismiss)),
+            tick_demolish_timer,
         )
-            .in_set(FactorySystems::Demolish),
+            .chain(),
     );
 
     app.add_systems(
         FixedUpdate,
         (
-            tick_demolish_timer,
             highlight_demolition,
             demolish_selection.run_if(demolish_timer_finished),
         )
@@ -63,48 +65,40 @@ impl Default for DemolishTimer {
 
 fn tick_demolish_timer(
     mut timer: ResMut<DemolishTimer>,
-    keys: Res<ButtonInput<KeyCode>>,
     time: Res<Time>,
+    input_actions: Res<InputActions>,
 ) {
-    if keys.just_released(DEMOLISH_BUTTON) {
-        timer.reset();
-    }
-
-    if keys.pressed(DEMOLISH_BUTTON) {
+    if input_actions.pressed.contains(&Action::Demolish) {
         timer.tick(time.delta());
+    } else {
+        timer.reset();
     }
 }
 
 fn demolish_timer_finished(timer: Res<DemolishTimer>) -> bool {
-    timer.just_finished()
+    timer.is_finished()
 }
 
 fn add_to_selection(
-    mut pointer_overs: MessageReader<Pointer<Over>>,
-    mut selection: ResMut<DemolishSelection>,
+    pointer_over: On<Pointer<Over>>,
     demolishables: Query<Entity, With<Demolishable>>,
+    mut selection: ResMut<DemolishSelection>,
 ) {
-    for pointer_over in pointer_overs.read() {
-        if !demolishables.contains(pointer_over.entity) {
-            continue;
-        }
-
+    if demolishables.contains(pointer_over.entity) {
         selection.insert(pointer_over.entity);
     }
 }
 
 fn remove_from_selection(
-    mut pointer_outs: MessageReader<Pointer<Out>>,
+    pointer_out: On<Pointer<Out>>,
+    input_actions: Res<InputActions>,
     mut selection: ResMut<DemolishSelection>,
-    keys: Res<ButtonInput<KeyCode>>,
 ) {
-    for pointer_out in pointer_outs.read() {
-        if keys.pressed(KeyCode::ShiftLeft) {
-            continue;
-        }
-
-        selection.remove(&pointer_out.entity);
+    if input_actions.pressed.contains(&Action::MultiSelect) {
+        return;
     }
+
+    selection.remove(&pointer_out.entity);
 }
 
 fn clear_selection(mut selection: ResMut<DemolishSelection>) {
diff --git a/src/input/input_map.rs b/src/input/input_map.rs
new file mode 100644
index 0000000..337ffad
--- /dev/null
+++ b/src/input/input_map.rs
@@ -0,0 +1,129 @@
+use std::collections::{HashMap, HashSet};
+
+use bevy::prelude::*;
+
+// Basic Interactions
+pub const DEFAULT_KEY_INTERACT: KeyCode = KeyCode::KeyE;
+pub const DEFAULT_KEY_DISMISS: KeyCode = KeyCode::Escape;
+pub const DEFAULT_KEY_OPEN_TOME: KeyCode = KeyCode::KeyT;
+
+// Hotbar
+pub const DEFAULT_KEY_HOTBAR_1: KeyCode = KeyCode::Digit1;
+pub const DEFAULT_KEY_HOTBAR_2: KeyCode = KeyCode::Digit2;
+pub const DEFAULT_KEY_HOTBAR_3: KeyCode = KeyCode::Digit3;
+pub const DEFAULT_KEY_HOTBAR_4: KeyCode = KeyCode::Digit4;
+pub const DEFAULT_KEY_HOTBAR_5: KeyCode = KeyCode::Digit5;
+pub const DEFAULT_KEY_HOTBAR_6: KeyCode = KeyCode::Digit6;
+pub const DEFAULT_KEY_HOTBAR_7: KeyCode = KeyCode::Digit7;
+pub const DEFAULT_KEY_HOTBAR_8: KeyCode = KeyCode::Digit8;
+pub const DEFAULT_KEY_HOTBAR_9: KeyCode = KeyCode::Digit9;
+
+pub const DEFAULT_KEY_DEMOLISH: KeyCode = KeyCode::KeyF;
+pub const DEFAULT_KEY_MULTI_SELECT: KeyCode = KeyCode::ShiftLeft;
+
+pub const DEFAULT_KEY_DEBUG_MODE: KeyCode = KeyCode::Backquote;
+
+#[derive(Clone, Copy, Hash, PartialEq, Eq, Reflect, Debug)]
+pub enum Action {
+    Interact,
+    Dismiss,
+    OpenTome,
+
+    Hotbar1,
+    Hotbar2,
+    Hotbar3,
+    Hotbar4,
+    Hotbar5,
+    Hotbar6,
+    Hotbar7,
+    Hotbar8,
+    Hotbar9,
+
+    Demolish,
+    MultiSelect,
+
+    DebugMode,
+}
+
+pub(super) fn plugin(app: &mut App) {
+    app.init_resource::<InputMap>();
+    app.init_resource::<InputActions>();
+
+    app.add_systems(PreUpdate, populate_keyboard_actions);
+    app.add_systems(PostUpdate, clear_actions);
+}
+
+#[derive(Resource, Reflect, Debug)]
+#[reflect(Resource)]
+pub struct InputMap {
+    pub keymap: HashMap<Action, KeyCode>,
+}
+
+#[derive(Resource, Reflect, Debug, Default)]
+#[reflect(Resource)]
+pub struct InputActions {
+    pub just_pressed: HashSet<Action>,
+    pub pressed: HashSet<Action>,
+}
+
+impl Default for InputMap {
+    fn default() -> Self {
+        Self {
+            keymap: HashMap::from([
+                // Basic Interactions
+                (Action::Interact, DEFAULT_KEY_INTERACT),
+                (Action::Dismiss, DEFAULT_KEY_DISMISS),
+                (Action::OpenTome, DEFAULT_KEY_OPEN_TOME),
+                // Hotbar
+                (Action::Hotbar1, DEFAULT_KEY_HOTBAR_1),
+                (Action::Hotbar2, DEFAULT_KEY_HOTBAR_2),
+                (Action::Hotbar3, DEFAULT_KEY_HOTBAR_3),
+                (Action::Hotbar4, DEFAULT_KEY_HOTBAR_4),
+                (Action::Hotbar5, DEFAULT_KEY_HOTBAR_5),
+                (Action::Hotbar6, DEFAULT_KEY_HOTBAR_6),
+                (Action::Hotbar7, DEFAULT_KEY_HOTBAR_7),
+                (Action::Hotbar8, DEFAULT_KEY_HOTBAR_8),
+                (Action::Hotbar9, DEFAULT_KEY_HOTBAR_9),
+                // Demolish
+                (Action::Demolish, DEFAULT_KEY_DEMOLISH),
+                (Action::MultiSelect, DEFAULT_KEY_MULTI_SELECT),
+                // Debug
+                (Action::DebugMode, DEFAULT_KEY_DEBUG_MODE),
+            ]),
+        }
+    }
+}
+
+fn populate_keyboard_actions(
+    input_map: Res<InputMap>,
+    mut input_actions: ResMut<InputActions>,
+    keys: Res<ButtonInput<KeyCode>>,
+) {
+    for (action, key) in input_map.keymap.iter() {
+        if keys.just_pressed(*key) {
+            input_actions.just_pressed.insert(*action);
+        }
+
+        if keys.pressed(*key) {
+            input_actions.pressed.insert(*action);
+        }
+    }
+}
+
+fn clear_actions(mut input_actions: ResMut<InputActions>) {
+    input_actions.just_pressed.clear();
+    input_actions.pressed.clear();
+}
+
+pub fn action_just_pressed(action: Action) -> impl SystemCondition<()> {
+    IntoSystem::into_system(move |input_actions: Res<InputActions>| {
+        input_actions.just_pressed.contains(&action)
+    })
+}
+
+#[allow(dead_code)]
+pub fn action_pressed(action: Action) -> impl SystemCondition<()> {
+    IntoSystem::into_system(move |input_actions: Res<InputActions>| {
+        input_actions.pressed.contains(&action)
+    })
+}
diff --git a/src/input/mod.rs b/src/input/mod.rs
index cfcf85e..10729ae 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -1,7 +1,8 @@
 use bevy::prelude::*;
 
 pub mod cursor;
+pub mod input_map;
 
 pub(super) fn plugin(app: &mut App) {
-    app.add_plugins(cursor::plugin);
+    app.add_plugins((cursor::plugin, input_map::plugin));
 }