diff --git a/Cargo.lock b/Cargo.lock
index 14ea77ae..0e1f5b1f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -232,6 +232,42 @@ dependencies = [
  "bevy_internal",
 ]
 
+[[package]]
+name = "bevy-inspector-egui"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0c53ed1cad011e33ea145d2c1f649a966e7457453f3768ddff39bc5064bd525"
+dependencies = [
+ "bevy",
+ "bevy-inspector-egui-derive",
+ "bevy_egui",
+ "image 0.23.14",
+ "nalgebra",
+ "pretty-type-name",
+]
+
+[[package]]
+name = "bevy-inspector-egui-derive"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48ef6260a46924d40781bcb9da157c110d5166bbd573795e4a16f2505913d0d0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "bevy-inspector-egui-rapier"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef372e6960033ec7a04b259c9a08b6a9fb5e3f6b4698091dc58aad4a4d6bc5d"
+dependencies = [
+ "bevy",
+ "bevy-inspector-egui",
+ "bevy_rapier2d",
+]
+
 [[package]]
 name = "bevy-parallax"
 version = "0.1.2"
@@ -416,6 +452,19 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "bevy_gilrs"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "963940426127533164af2a556971a03c493143c0afb95afadb4a070b6ab8c3df"
+dependencies = [
+ "bevy_app",
+ "bevy_ecs",
+ "bevy_input",
+ "bevy_utils",
+ "gilrs",
+]
+
 [[package]]
 name = "bevy_hierarchy"
 version = "0.8.0"
@@ -455,6 +504,7 @@ dependencies = [
  "bevy_derive",
  "bevy_diagnostic",
  "bevy_ecs",
+ "bevy_gilrs",
  "bevy_hierarchy",
  "bevy_input",
  "bevy_log",
@@ -466,8 +516,10 @@ dependencies = [
  "bevy_scene",
  "bevy_sprite",
  "bevy_tasks",
+ "bevy_text",
  "bevy_time",
  "bevy_transform",
+ "bevy_ui",
  "bevy_utils",
  "bevy_window",
  "bevy_winit",
@@ -530,6 +582,18 @@ dependencies = [
  "glam",
 ]
 
+[[package]]
+name = "bevy_mod_debugdump"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f22cfad8fab6ca053d81c1c8795e325fe2174fa47f7455f7be7a959ef9bbaf3"
+dependencies = [
+ "bevy_app",
+ "bevy_ecs",
+ "bevy_render",
+ "pretty-type-name",
+]
+
 [[package]]
 name = "bevy_pbr"
 version = "0.8.0"
@@ -720,6 +784,29 @@ dependencies = [
  "wasm-bindgen-futures",
 ]
 
+[[package]]
+name = "bevy_text"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef05a788c2c04aaa5db95b22a8f0fff0d3a0b08a7bcd1a71f050a628b38eec6e"
+dependencies = [
+ "ab_glyph",
+ "anyhow",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_ecs",
+ "bevy_math",
+ "bevy_reflect",
+ "bevy_render",
+ "bevy_sprite",
+ "bevy_transform",
+ "bevy_utils",
+ "bevy_window",
+ "glyph_brush_layout",
+ "serde",
+ "thiserror",
+]
+
 [[package]]
 name = "bevy_time"
 version = "0.8.0"
@@ -746,6 +833,34 @@ dependencies = [
  "bevy_reflect",
 ]
 
+[[package]]
+name = "bevy_ui"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac181a7b637da61fad72981ff9d2e5b899283ca7d54b2b7ea49c431121331c53"
+dependencies = [
+ "bevy_app",
+ "bevy_asset",
+ "bevy_core_pipeline",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_hierarchy",
+ "bevy_input",
+ "bevy_log",
+ "bevy_math",
+ "bevy_reflect",
+ "bevy_render",
+ "bevy_sprite",
+ "bevy_text",
+ "bevy_transform",
+ "bevy_utils",
+ "bevy_window",
+ "bytemuck",
+ "serde",
+ "smallvec",
+ "taffy",
+]
+
 [[package]]
 name = "bevy_utils"
 version = "0.8.0"
@@ -1695,6 +1810,40 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "gilrs"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d6ba7c37bf8ea7ba0c3e3795dfa1a7771b1e47c4bb417c4d27c7b338d79685f"
+dependencies = [
+ "fnv",
+ "gilrs-core",
+ "log",
+ "uuid",
+ "vec_map",
+]
+
+[[package]]
+name = "gilrs-core"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96a8d94a7fc5afd27e894e08a4cfe5a49237f85bcc7140e90721bad3399c7d02"
+dependencies = [
+ "core-foundation 0.9.3",
+ "io-kit-sys",
+ "js-sys",
+ "libc",
+ "libudev-sys",
+ "log",
+ "nix 0.24.2",
+ "rusty-xinput",
+ "uuid",
+ "vec_map",
+ "wasm-bindgen",
+ "web-sys",
+ "winapi",
+]
+
 [[package]]
 name = "glam"
 version = "0.21.2"
@@ -1736,6 +1885,17 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "glyph_brush_layout"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc32c2334f00ca5ac3695c5009ae35da21da8c62d255b5b96d56e2597a637a38"
+dependencies = [
+ "ab_glyph",
+ "approx",
+ "xi-unicode",
+]
+
 [[package]]
 name = "gpu-alloc"
 version = "0.5.3"
@@ -1785,6 +1945,26 @@ dependencies = [
  "svg_fmt",
 ]
 
+[[package]]
+name = "hash32"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "hash32-derive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59d2aba832b60be25c1b169146b27c64115470981b128ed84c8db18c1b03c6ff"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.11.2"
@@ -1960,6 +2140,16 @@ dependencies = [
  "unic-langid",
 ]
 
+[[package]]
+name = "io-kit-sys"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7789f7f3c9686f96164f5109d69152de759e76e284f736bd57661c6df5091919"
+dependencies = [
+ "core-foundation-sys 0.8.3",
+ "mach",
+]
+
 [[package]]
 name = "itertools"
 version = "0.10.3"
@@ -2087,9 +2277,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
-name = "leafwing_input_manager"
-version = "0.5.0"
-source = "git+https://github.com/Leafwing-Studios/leafwing-input-manager.git?branch=dev#cfa8759212049244a88d0fb173271c1cda740e1c"
+name = "leafwing-input-manager"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524be04b15812de73b2e07add91538a3a67026259421285ae2b2ff0dec308261"
 dependencies = [
  "bevy",
  "derive_more",
@@ -2102,7 +2293,8 @@ dependencies = [
 [[package]]
 name = "leafwing_input_manager_macros"
 version = "0.5.0"
-source = "git+https://github.com/Leafwing-Studios/leafwing-input-manager.git?branch=dev#cfa8759212049244a88d0fb173271c1cda740e1c"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d38676bbe26f336c5554150be0050a7033c72e882f8df4be5a2b3b1e6b2929cd"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
@@ -2132,6 +2324,16 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da83a57f3f5ba3680950aa3cbc806fc297bc0b289d42e8942ed528ace71b8145"
 
+[[package]]
+name = "libudev-sys"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c8469b4a23b962c1396b9b451dda50ef5b283e8dd309d69033475fa9b334324"
+dependencies = [
+ "libc",
+ "pkg-config",
+]
+
 [[package]]
 name = "lock_api"
 version = "0.4.7"
@@ -2435,6 +2637,17 @@ dependencies = [
  "memoffset",
 ]
 
+[[package]]
+name = "nix"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "195cdbc1741b8134346d515b3a56a1c94b0912758009cfd53f99ea0f57b065fc"
+dependencies = [
+ "bitflags",
+ "cfg-if 1.0.0",
+ "libc",
+]
+
 [[package]]
 name = "nohash-hasher"
 version = "0.2.0"
@@ -2819,6 +3032,12 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
 
+[[package]]
+name = "pretty-type-name"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8815d101cfb4cb491154896bdab292a395a7ac9ab185a9941a2f5be0135900d"
+
 [[package]]
 name = "proc-macro-crate"
 version = "1.1.3"
@@ -2875,17 +3094,20 @@ dependencies = [
  "anyhow",
  "async-channel",
  "bevy",
+ "bevy-inspector-egui",
+ "bevy-inspector-egui-rapier",
  "bevy-parallax",
  "bevy_egui",
  "bevy_fluent",
  "bevy_kira_audio",
+ "bevy_mod_debugdump",
  "bevy_rapier2d",
  "directories",
  "egui_extras",
  "fluent",
  "getrandom",
  "iyes_loopless",
- "leafwing_input_manager",
+ "leafwing-input-manager",
  "once_cell",
  "punchy_macros",
  "rand",
@@ -3083,6 +3305,17 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rusty-xinput"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2aa654bc32eb9ca14cce1a084abc9dfe43949a4547c35269a094c39272db3bb"
+dependencies = [
+ "lazy_static",
+ "log",
+ "winapi",
+]
+
 [[package]]
 name = "ryu"
 version = "1.0.10"
@@ -3400,6 +3633,19 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "taffy"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec27dea659b100d489dffa57cf0efc6d7bfefb119af817b92cc14006c0b214e3"
+dependencies = [
+ "arrayvec",
+ "hash32",
+ "hash32-derive",
+ "num-traits",
+ "typenum",
+]
+
 [[package]]
 name = "termcolor"
 version = "1.1.3"
@@ -4051,3 +4297,9 @@ dependencies = [
  "winapi",
  "winapi-wsapoll",
 ]
+
+[[package]]
+name = "xi-unicode"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a67300977d3dc3f8034dae89778f502b6ba20b269527b3223ba59c0cf393bb8a"
diff --git a/Cargo.toml b/Cargo.toml
index d2fb6b92..67f954df 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,7 +18,8 @@ default-features = false
 features = [
     "x11",
     "png",
-    "filesystem_watcher"
+    "filesystem_watcher",
+    "bevy_gilrs"
 ]
 
 [dependencies]
@@ -38,7 +39,7 @@ structopt = "0.3.26"
 rand = "0.8.5"
 getrandom = { version = "0.2", features = ["js"] }
 
-leafwing_input_manager = { git = "https://github.com/Leafwing-Studios/leafwing-input-manager.git", default-features = false, branch = "dev" }
+leafwing-input-manager = { version = "0.5", default-features = false }
 unic-langid = "0.9.0"
 bevy_fluent = { git = "https://github.com/kgv/bevy_fluent.git" }
 sys-locale = "0.2.1"
@@ -48,17 +49,17 @@ async-channel = "1.6.1"
 once_cell = "1.13.0"
 
 # Waiting for updates to Bevy 0.8
-# bevy_mod_debugdump = { version = "0.4", optional = true }
-# bevy-inspector-egui = { version = "0.11", optional = true }
-# bevy-inspector-egui-rapier = { version = "0.4", optional = true, features = ["rapier2d"] }
+bevy_mod_debugdump = { version = "0.5.0", optional = true }
+bevy-inspector-egui = { version = "0.12.1", optional = true }
+bevy-inspector-egui-rapier = { version = "0.5.0", optional = true, features = ["rapier2d"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 web-sys = { version = "0.3", features = ["Window","Location","Storage"] }
 
 [features]
 default = []
-# Waiting for update to Bevy 0.8
-# schedule_graph = ["bevy_mod_debugdump"]
+debug = ["bevy_mod_debugdump", "bevy-inspector-egui", "bevy-inspector-egui-rapier"]
+schedule_graph = ["bevy_mod_debugdump"]
 
 # Enable optimizations for dependencies but not for our code
 [profile.dev.package."*"]
diff --git a/assets/fighters/bandit/bandit.fighter.yaml b/assets/fighters/bandit/bandit.fighter.yaml
index 25ea77fc..e0031743 100644
--- a/assets/fighters/bandit/bandit.fighter.yaml
+++ b/assets/fighters/bandit/bandit.fighter.yaml
@@ -1,8 +1,8 @@
 name: Bandit
 
 stats:
-  health: 150
-  damage: 20
+  max_health: 150
+  damage: 4
   movement_speed: 150
 
 hud:
diff --git a/assets/fighters/brute/brute.fighter.yaml b/assets/fighters/brute/brute.fighter.yaml
index 3a60fe39..e9905051 100644
--- a/assets/fighters/brute/brute.fighter.yaml
+++ b/assets/fighters/brute/brute.fighter.yaml
@@ -1,8 +1,8 @@
 name: Brute
 
 stats:
-  health: 200
-  damage: 50
+  max_health: 200
+  damage: 10
   movement_speed: 50
 
 hud:
diff --git a/assets/fighters/fishy/fishy.fighter.yaml b/assets/fighters/fishy/fishy.fighter.yaml
index 5aa40dfc..b351ebde 100644
--- a/assets/fighters/fishy/fishy.fighter.yaml
+++ b/assets/fighters/fishy/fishy.fighter.yaml
@@ -1,7 +1,7 @@
 name: Fishy The Fearsome
 
 stats:
-  health: 100
+  max_health: 600
   damage: 35
   movement_speed: 150
 
diff --git a/assets/fighters/sharky/sharky.fighter.yaml b/assets/fighters/sharky/sharky.fighter.yaml
index 2b8b9338..e3ccb046 100644
--- a/assets/fighters/sharky/sharky.fighter.yaml
+++ b/assets/fighters/sharky/sharky.fighter.yaml
@@ -1,7 +1,7 @@
 name: Scrumptious Sharky
 
 stats:
-  health: 100
+  max_health: 600
   damage: 35
   movement_speed: 150
 
diff --git a/assets/fighters/slinger/slinger.fighter.yaml b/assets/fighters/slinger/slinger.fighter.yaml
index 4b75d464..ee233631 100644
--- a/assets/fighters/slinger/slinger.fighter.yaml
+++ b/assets/fighters/slinger/slinger.fighter.yaml
@@ -1,8 +1,8 @@
 name: Slinger
 
 stats:
-  health: 100
-  damage: 35
+  max_health: 100
+  damage: 7
   movement_speed: 150
 
 hud:
diff --git a/assets/items/bottle/bottle.item.yaml b/assets/items/bottle/bottle.item.yaml
index 9f947c8d..25b35c5d 100644
--- a/assets/items/bottle/bottle.item.yaml
+++ b/assets/items/bottle/bottle.item.yaml
@@ -3,3 +3,6 @@ name: Bottle
 image:
     image: bottle.png
     image_size: [11, 31]
+
+kind: !Throwable
+    damage: 10
diff --git a/assets/items/health/health.item.yaml b/assets/items/health/health.item.yaml
index aeee288b..e528ebcf 100644
--- a/assets/items/health/health.item.yaml
+++ b/assets/items/health/health.item.yaml
@@ -1,5 +1,8 @@
 name: Health
 
 image:
-    image: health.png
-    image_size: [22, 20]
+  image: health.png
+  image_size: [22, 20]
+
+kind: !Health
+  health: 1000000 # Refill all of it
diff --git a/src/animation.rs b/src/animation.rs
index 7ca95e1e..0dfe33ae 100644
--- a/src/animation.rs
+++ b/src/animation.rs
@@ -1,8 +1,8 @@
 use std::ops::Range;
 
-use crate::{state::State, GameStage, GameState};
+use crate::GameState;
 use bevy::{
-    prelude::{App, Changed, Component, Plugin, Query, Res},
+    prelude::*,
     sprite::TextureAtlasSprite,
     time::{Time, Timer},
     utils::HashMap,
@@ -15,10 +15,9 @@ pub struct AnimationPlugin;
 impl Plugin for AnimationPlugin {
     fn build(&self, app: &mut App) {
         app.add_system_set_to_stage(
-            GameStage::Animation,
+            CoreStage::Last,
             ConditionSet::new()
                 .run_in_state(GameState::InGame)
-                .with_system(animate_on_state_changed)
                 .with_system(animation_flipping)
                 .with_system(animation_cycling)
                 .into(),
@@ -26,6 +25,14 @@ impl Plugin for AnimationPlugin {
     }
 }
 
+/// Bundle for animated sprite sheets
+#[derive(Bundle)]
+pub struct AnimatedSpriteSheetBundle {
+    #[bundle]
+    pub sprite_sheet: SpriteSheetBundle,
+    pub animation: Animation,
+}
+
 #[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
 #[derive(Component, PartialEq, Eq, Clone)]
 pub enum Facing {
@@ -37,10 +44,6 @@ impl Facing {
     pub fn is_left(&self) -> bool {
         self == &Facing::Left
     }
-
-    pub fn set(&mut self, facing: Facing) {
-        *self = facing;
-    }
 }
 
 #[derive(serde::Deserialize, Clone, Debug)]
@@ -95,31 +98,41 @@ impl<'de> serde::de::Visitor<'de> for RangeVisitor {
 
 #[derive(Component)]
 pub struct Animation {
-    pub animations: HashMap<State, Clip>,
+    pub animations: HashMap<String, Clip>,
     pub current_frame: usize,
-    current_state: Option<State>,
+    pub current_animation: Option<String>,
     pub timer: Timer,
     pub played_once: bool,
 }
 
 impl Animation {
-    pub fn new(fps: f32, animations: HashMap<State, Clip>) -> Self {
+    pub fn new(fps: f32, animations: HashMap<String, Clip>) -> Self {
         Self {
             animations,
             current_frame: 0,
-            current_state: None,
+            current_animation: None,
             timer: Timer::from_seconds(fps, false),
             played_once: false,
         }
     }
 
+    /// Start playing a new animation
+    pub fn play(&mut self, name: &str, repeating: bool) {
+        self.current_animation = Some(name.to_owned());
+        self.current_frame = 0;
+        self.timer.reset();
+        self.timer.unpause();
+        self.timer.set_repeating(repeating);
+        self.played_once = false;
+    }
+
     pub fn is_finished(&self) -> bool {
         self.played_once
     }
 
     pub fn is_repeating(&self) -> bool {
-        if let Some(state) = self.current_state {
-            if let Some(clip) = self.animations.get(&state) {
+        if let Some(animation) = &self.current_animation {
+            if let Some(clip) = self.animations.get(animation) {
                 return clip.repeat;
             }
         }
@@ -138,8 +151,8 @@ impl Animation {
     }
 
     pub fn get_current_indices(&self) -> Option<&Range<usize>> {
-        if let Some(state) = self.current_state {
-            match self.animations.get(&state) {
+        if let Some(animation) = &self.current_animation {
+            match self.animations.get(animation) {
                 Some(clip) => return Some(&clip.frames),
                 None => return None,
             }
@@ -157,22 +170,11 @@ impl Animation {
     }
 }
 
-fn animate_on_state_changed(mut query: Query<(&mut Animation, &State), Changed<State>>) {
-    for (mut animation, state) in query.iter_mut() {
-        if animation.current_state != Some(*state) {
-            animation.played_once = false;
-            animation.current_frame = 0;
-            animation.current_state = Some(*state);
-            animation.timer.reset();
-        }
-    }
-}
-
 fn animation_cycling(mut query: Query<(&mut TextureAtlasSprite, &mut Animation)>, time: Res<Time>) {
     //TODO: Add a tick method on Animation
     for (mut texture_atlas_sprite, mut animation) in query.iter_mut() {
         if animation.is_finished() && !animation.is_repeating() {
-            return;
+            continue;
         }
 
         animation.timer.tick(time.delta());
diff --git a/src/assets.rs b/src/assets.rs
index 26772b59..7ce7cd33 100644
--- a/src/assets.rs
+++ b/src/assets.rs
@@ -262,7 +262,7 @@ impl AssetLoader for FighterLoader {
                     let frame_audio_handles = meta
                         .audio
                         .effect_handles
-                        .entry(*state)
+                        .entry(state.clone())
                         .or_insert_with(HashMap::new);
 
                     frame_audio_handles.insert(*animation_i, effect_handle);
diff --git a/src/attack.rs b/src/attack.rs
index 2901e4d9..82ea1a54 100644
--- a/src/attack.rs
+++ b/src/attack.rs
@@ -1,66 +1,52 @@
-use std::time::Duration;
-
 use bevy::{
-    hierarchy::{BuildChildren, Children, DespawnRecursiveExt},
-    math::{Vec2, Vec3},
+    hierarchy::DespawnRecursiveExt,
+    math::Vec2,
     prelude::{
-        default, App, AssetServer, Assets, Bundle, Commands, Component, Entity, EventReader,
-        Handle, Local, Parent, Plugin, Query, Res, Transform, With, Without,
+        App, Commands, Component, CoreStage, Entity, EventReader, EventWriter, Parent, Plugin,
+        Query, With, Without,
     },
-    sprite::SpriteBundle,
-    time::{Time, Timer},
-    transform::TransformBundle,
 };
 use bevy_rapier2d::prelude::*;
 use iyes_loopless::prelude::*;
-use leafwing_input_manager::prelude::ActionState;
 
 use crate::{
-    animation::{Animation, Facing},
-    audio::FighterStateEffectsPlayback,
-    collisions::BodyLayers,
-    consts::{
-        self, ATTACK_HEIGHT, ATTACK_LAYER, ATTACK_WIDTH, ITEM_BOTTLE_NAME, ITEM_HEIGHT, ITEM_LAYER,
-        ITEM_WIDTH, THROW_ITEM_ROTATION_SPEED,
-    },
-    input::PlayerAction,
-    item::item_carried_by_player,
-    metadata::{FighterMeta, ItemMeta},
-    movement::{MoveInArc, MoveInDirection, PlayerMovementClamper, Rotate, Target},
-    state::State,
-    ArrivedEvent, Enemy, GameState, Player, Stats,
+    animation::Animation,
+    consts::{ATTACK_HEIGHT, ATTACK_WIDTH},
+    damage::{DamageEvent, Damageable, Health},
+    GameState,
 };
 
 pub struct AttackPlugin;
 
 impl Plugin for AttackPlugin {
     fn build(&self, app: &mut App) {
-        app.add_system_set(
-            ConditionSet::new()
-                .run_in_state(GameState::InGame)
-                .with_system(player_projectile_attack)
-                .with_system(player_throw)
-                .with_system(player_flop)
-                .with_system(activate_hitbox)
-                .with_system(deactivate_hitbox)
-                .with_system(projectile_cleanup)
-                .with_system(projectile_tick)
-                .into(),
-        )
-        .add_system(
-            enemy_attack
-                .run_in_state(GameState::InGame)
-                .after("move_to_target"),
-        );
+        app
+            // Add systems
+            .add_system_set(
+                ConditionSet::new()
+                    .run_in_state(GameState::InGame)
+                    .with_system(activate_hitbox)
+                    .with_system(deactivate_hitbox)
+                    .into(),
+            )
+            // Attack damage is run in PostUpdate to make sure it runs after rapier generates collision events
+            .add_system_to_stage(CoreStage::PostUpdate, attack_damage_system);
     }
 }
 
+/// A component representing an attack that can do damage to [`Damageable`]s with [`Health`].
 #[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
-#[derive(Component)]
+#[derive(Component, Clone, Copy)]
 pub struct Attack {
     pub damage: i32,
+    /// The direction and speed that the attack is hitting something in.
+    pub velocity: Vec2,
 }
 
+/// A component identifying the attacks active collision frames.
+///
+/// Must be added to an entity that is a child of an entity with an [`Animation`] and an [`Attack`]
+/// and will be used to spawn a collider for that attack during the `active` frames.
 #[derive(Component)]
 pub struct AttackFrames {
     pub startup: usize,
@@ -68,397 +54,14 @@ pub struct AttackFrames {
     pub recovery: usize,
 }
 
-#[derive(Component)]
-pub struct ProjectileLifetime(pub Timer);
-
-#[derive(Bundle)]
-pub struct Projectile {
-    #[bundle]
-    sprite_bundle: SpriteBundle,
-    rotate: Rotate,
-    collider: Collider,
-    sensor: Sensor,
-    events: ActiveEvents,
-    collision_types: ActiveCollisionTypes,
-    collision_groups: CollisionGroups,
-    facing: Facing,
-    move_in_direction: MoveInDirection,
-    attack: Attack,
-    attack_timer: ProjectileLifetime,
-}
-
-impl Projectile {
-    pub fn new(
-        transform: &Transform,
-        facing: &Facing,
-        dir: Vec2,
-        asset_server: &Res<AssetServer>,
-    ) -> Self {
-        Self {
-            sprite_bundle: SpriteBundle {
-                texture: asset_server.load("bottled_seaweed11x31.png"),
-                transform: Transform::from_xyz(
-                    transform.translation.x,
-                    transform.translation.y,
-                    ATTACK_LAYER,
-                ),
-                ..default()
-            },
-            rotate: Rotate {
-                speed: THROW_ITEM_ROTATION_SPEED,
-                to_right: !facing.is_left(),
-            },
-            collider: Collider::cuboid(ATTACK_WIDTH / 2., ATTACK_HEIGHT / 2.),
-            sensor: Sensor,
-            events: ActiveEvents::COLLISION_EVENTS,
-            collision_types: ActiveCollisionTypes::default() | ActiveCollisionTypes::STATIC_STATIC,
-            //TODO: define collision layer based on the fighter shooting projectile, load for asset files of fighter which "team" they are on
-            collision_groups: CollisionGroups::new(BodyLayers::PLAYER_ATTACK, BodyLayers::ENEMY),
-            facing: facing.clone(),
-            move_in_direction: MoveInDirection(dir * 300.), //TODO: Put the velocity in a cons,
-            attack: Attack { damage: 10 },
-            attack_timer: ProjectileLifetime(Timer::new(Duration::from_secs(1), false)),
-        }
-    }
-}
-
-#[derive(Bundle)]
-pub struct ThrownItem {
-    #[bundle]
-    sprite_bundle: SpriteBundle,
-    rotate: Rotate,
-    move_in_arc: MoveInArc,
-    collider: Collider,
-    sensor: Sensor,
-    events: ActiveEvents,
-    collision_types: ActiveCollisionTypes,
-    collision_groups: CollisionGroups,
-    attack: Attack,
-}
-
-impl ThrownItem {
-    pub fn new(
-        angles: (f32, f32),
-        position: Vec2,
-        facing: Facing,
-        asset_server: &AssetServer,
-    ) -> Self {
-        Self {
-            sprite_bundle: SpriteBundle {
-                texture: asset_server.load("bottled_seaweed11x31.png"),
-                transform: Transform::from_xyz(position.x, position.y, ITEM_LAYER),
-                ..default()
-            },
-            rotate: Rotate {
-                speed: consts::THROW_ITEM_ROTATION_SPEED,
-                to_right: !facing.is_left(),
-            },
-            move_in_arc: MoveInArc {
-                //TODO: Set in consts
-                radius: Vec2::new(
-                    50.,
-                    consts::PLAYER_HEIGHT + consts::THROW_ITEM_Y_OFFSET + consts::ITEM_HEIGHT,
-                ),
-                speed: consts::THROW_ITEM_SPEED,
-                angle: angles.0,
-                end_angle: angles.1,
-                inverse_direction: facing.is_left(),
-                origin: position,
-            },
-            collider: Collider::cuboid(ITEM_WIDTH / 2., ITEM_HEIGHT / 2.),
-            sensor: Sensor,
-            events: ActiveEvents::COLLISION_EVENTS,
-            collision_types: ActiveCollisionTypes::default() | ActiveCollisionTypes::STATIC_STATIC,
-            //TODO: define collision layer based on the fighter throwing the item, load for asset files of fighter which "team" they are on
-            collision_groups: CollisionGroups::new(BodyLayers::ITEM, BodyLayers::ENEMY),
-            attack: Attack {
-                damage: consts::THROW_ITEM_DAMAGE,
-            },
-        }
-    }
-}
-
-fn player_projectile_attack(
-    player_query: Query<
-        (
-            &Children,
-            &Transform,
-            &Facing,
-            &State,
-            &ActionState<PlayerAction>,
-        ),
-        With<Player>,
-    >,
-    items_meta_query: Query<&Handle<ItemMeta>>,
-    items_meta: Res<Assets<ItemMeta>>,
-    mut commands: Commands,
-    asset_server: Res<AssetServer>,
-) {
-    for (player_children, transform, facing, state, input) in player_query.iter() {
-        if *state != State::Idle && *state != State::Running {
-            continue;
-        }
-
-        let carried_item = item_carried_by_player(
-            player_children,
-            ITEM_BOTTLE_NAME,
-            &items_meta_query,
-            &items_meta,
-        );
-
-        if let Some(bottle_id) = carried_item {
-            if input.just_pressed(PlayerAction::Shoot) {
-                let mut dir = Vec2::X;
-
-                if facing.is_left() {
-                    dir = -dir;
-                }
-
-                let projectile = Projectile::new(transform, facing, dir, &asset_server);
-
-                commands.spawn_bundle(projectile);
-
-                commands.entity(bottle_id).despawn();
-            }
-        }
-    }
-}
-
-fn player_throw(
-    mut commands: Commands,
-    player_query: Query<
-        (
-            &Children,
-            &Transform,
-            Option<&Facing>,
-            &ActionState<PlayerAction>,
-        ),
-        With<Player>,
-    >,
-    items_meta_query: Query<&Handle<ItemMeta>>,
-    items_meta: Res<Assets<ItemMeta>>,
-    asset_server: Res<AssetServer>,
-) {
-    for (player_children, transform, facing_option, input) in player_query.iter() {
-        let carried_item = item_carried_by_player(
-            player_children,
-            ITEM_BOTTLE_NAME,
-            &items_meta_query,
-            &items_meta,
-        );
-
-        if let Some(bottle_id) = carried_item {
-            if input.just_pressed(PlayerAction::Throw) {
-                let facing = match facing_option {
-                    Some(f) => f.clone(),
-                    None => Facing::Right,
-                };
-
-                let mut position = transform.translation.truncate();
-
-                //Offset the position depending on the facing
-                if facing.is_left() {
-                    position.x -= consts::THROW_ITEM_X_OFFSET;
-                } else {
-                    position.x += consts::THROW_ITEM_X_OFFSET;
-                }
-
-                position.y -= consts::PLAYER_HEIGHT / 2.; //Set to the player feet
-
-                let angles = match facing {
-                    Facing::Left => (90. - consts::THROW_ITEM_ANGLE_OFFSET, 180.),
-                    Facing::Right => (90. + consts::THROW_ITEM_ANGLE_OFFSET, 0.),
-                };
-
-                let thrown_item = ThrownItem::new(angles, position, facing, &asset_server);
-
-                commands.spawn_bundle(thrown_item);
-
-                commands.entity(bottle_id).despawn()
-            }
-        }
-    }
-}
-
-fn player_flop(
-    mut commands: Commands,
-    mut query: Query<
-        (
-            Entity,
-            &mut State,
-            &mut Transform,
-            &Stats,
-            &Animation,
-            &Facing,
-            &ActionState<PlayerAction>,
-            &Handle<FighterMeta>,
-        ),
-        With<Player>,
-    >,
-    player_movement_clamper: PlayerMovementClamper,
-    fighter_assets: Res<Assets<FighterMeta>>,
-    time: Res<Time>,
-    mut start_y: Local<Option<f32>>,
-) {
-    let players_movement = query
-        .iter_mut()
-        .map(
-            |(entity, mut state, transform, stats, animation, facing, input, fighter_meta)| {
-                if *state != State::Attacking {
-                    if !(*state != State::Idle && *state != State::Running)
-                        && input.just_pressed(PlayerAction::FlopAttack)
-                    {
-                        state.set(State::Attacking);
-
-                        let attack_entity = commands
-                            .spawn_bundle(TransformBundle::default())
-                            .insert(Sensor)
-                            .insert(ActiveEvents::COLLISION_EVENTS)
-                            .insert(
-                                ActiveCollisionTypes::default()
-                                    | ActiveCollisionTypes::STATIC_STATIC,
-                            )
-                            .insert(CollisionGroups::new(
-                                BodyLayers::PLAYER_ATTACK,
-                                BodyLayers::ENEMY,
-                            ))
-                            .insert(Attack {
-                                damage: stats.damage,
-                            })
-                            .insert(AttackFrames {
-                                startup: 0,
-                                active: 3,
-                                recovery: 4,
-                            })
-                            .id();
-                        commands.entity(entity).push_children(&[attack_entity]);
-                        //TODO: define hitbox size and placement through resources
-
-                        //maybe move audio effects?
-                        if let Some(fighter) = fighter_assets.get(fighter_meta) {
-                            if let Some(effects) = fighter.audio.effect_handles.get(&state) {
-                                let fx_playback =
-                                    FighterStateEffectsPlayback::new(*state, effects.clone());
-                                commands.entity(entity).insert(fx_playback);
-                            }
-                        }
-                        // commands.
-                        // commands.entity(entity)
-                    }
-
-                    (transform.translation, None)
-                } else {
-                    let mut movement = Vec2::ZERO;
-
-                    //TODO: Replace with movement intent eventwriter in movement rewrite!
-                    //TODO: Fix hacky way to get a forward jump
-                    if animation.current_frame < 3 {
-                        if facing.is_left() {
-                            movement.x -= 200. * time.delta_seconds();
-                        } else {
-                            movement.x += 200. * time.delta_seconds();
-                        }
-                    }
-
-                    // For currently unclear reasons, the first Animation frame may run for less Bevy frames
-                    // than expected. When this is the case, the player jumps less then it should, netting,
-                    // at the end of the animation, a slightly negative Y than the beginning, which causes
-                    // problems. This is a workaround.
-                    //
-                    if start_y.is_none() {
-                        *start_y = Some(transform.translation.y);
-                    }
-
-                    if animation.current_frame < 1 {
-                        movement.y += 180. * time.delta_seconds();
-                    } else if animation.current_frame < 3 {
-                        movement.y -= 90. * time.delta_seconds();
-                    } else if animation.is_finished() {
-                        movement.y = start_y.unwrap();
-                        *start_y = None;
-                    }
-
-                    (transform.translation, Some(movement))
-                }
-            },
-        )
-        .collect::<Vec<_>>();
-
-    let players_movement = player_movement_clamper.clamp(players_movement);
-
-    for ((_, _, mut transform, _, _, _, _, _), player_dir) in query.iter_mut().zip(players_movement)
-    {
-        if let Some(player_dir) = player_dir {
-            transform.translation += player_dir.extend(0.);
-        }
-    }
-}
-
-fn enemy_attack(
-    mut query: Query<
-        (Entity, &mut State, &Facing, &Handle<FighterMeta>),
-        (With<Enemy>, With<Target>),
-    >,
-    mut event_reader: EventReader<ArrivedEvent>,
-    mut commands: Commands,
-    fighter_assets: Res<Assets<FighterMeta>>,
-) {
-    for event in event_reader.iter() {
-        if let Ok((entity, mut state, facing, fighter_handle)) = query.get_mut(event.0) {
-            if *state != State::Attacking {
-                if rand::random() && *state != State::Waiting {
-                    state.set(State::Waiting);
-                } else {
-                    state.set(State::Attacking);
-
-                    //TODO: remove this offset in favor of offsets defined in fighter assets
-                    let offset = match facing {
-                        Facing::Left => -24.0,
-                        Facing::Right => 24.0,
-                    };
-
-                    let attack_entity = commands
-                        .spawn_bundle(TransformBundle::from_transform(
-                            Transform::from_translation(Vec3::new(offset, 0.0, 0.0)),
-                        ))
-                        .insert(Sensor)
-                        .insert(ActiveEvents::COLLISION_EVENTS)
-                        .insert(
-                            ActiveCollisionTypes::default() | ActiveCollisionTypes::STATIC_STATIC,
-                        )
-                        .insert(CollisionGroups::new(
-                            BodyLayers::ENEMY_ATTACK,
-                            BodyLayers::PLAYER,
-                        ))
-                        .insert(Attack { damage: 10 })
-                        .insert(AttackFrames {
-                            startup: 1,
-                            active: 2,
-                            recovery: 3,
-                        })
-                        .id();
-                    commands.entity(event.0).push_children(&[attack_entity]);
-
-                    if let Some(fighter) = fighter_assets.get(fighter_handle) {
-                        if let Some(effects) = fighter.audio.effect_handles.get(&state) {
-                            let fx_playback =
-                                FighterStateEffectsPlayback::new(*state, effects.clone());
-                            commands.entity(entity).insert(fx_playback);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
+/// Activate collisions for entities with [`AttackFrames`]
 fn activate_hitbox(
     attack_query: Query<(Entity, &AttackFrames, &Parent), Without<Collider>>,
-    fighter_query: Query<&Animation, With<State>>,
+    animated_query: Query<&Animation>,
     mut commands: Commands,
 ) {
     for (entity, attack_frames, parent) in attack_query.iter() {
-        if let Ok(animation) = fighter_query.get(**parent) {
+        if let Ok(animation) = animated_query.get(**parent) {
             if animation.current_frame >= attack_frames.startup
                 && animation.current_frame <= attack_frames.active
             {
@@ -471,13 +74,14 @@ fn activate_hitbox(
     }
 }
 
+/// Deactivate collisions for entities with [`AttackFrames`]
 fn deactivate_hitbox(
     query: Query<(Entity, &AttackFrames, &Parent), (With<Attack>, With<Collider>)>,
-    fighter_query: Query<&Animation, With<State>>,
+    animated_query: Query<&Animation>,
     mut commands: Commands,
 ) {
     for (entity, attack_frames, parent) in query.iter() {
-        if let Ok(animation) = fighter_query.get(**parent) {
+        if let Ok(animation) = animated_query.get(**parent) {
             if animation.current_frame >= attack_frames.recovery {
                 commands.entity(entity).despawn_recursive();
             }
@@ -485,19 +89,37 @@ fn deactivate_hitbox(
     }
 }
 
-fn projectile_cleanup(
-    query: Query<(Entity, &ProjectileLifetime), With<Attack>>,
-    mut commands: Commands,
+/// Depletes the health of damageables that have collided with attacks
+fn attack_damage_system(
+    mut events: EventReader<CollisionEvent>,
+    mut damageables: Query<(&mut Health, &Damageable)>,
+    attacks: Query<&Attack>,
+    mut event_writer: EventWriter<DamageEvent>,
 ) {
-    for (entity, timer) in query.iter() {
-        if timer.0.finished() {
-            commands.entity(entity).despawn_recursive();
-        }
-    }
-}
+    for event in events.iter() {
+        if let CollisionEvent::Started(e1, e2, _flags) = event {
+            let (attack_entity, damageable_entity) =
+                if attacks.contains(*e1) && damageables.contains(*e2) {
+                    (*e1, *e2)
+                } else if attacks.contains(*e2) && damageables.contains(*e1) {
+                    (*e2, *e1)
+                } else {
+                    continue;
+                };
+
+            let attack = attacks.get(attack_entity).unwrap();
+            let (mut health, damageable) = damageables.get_mut(damageable_entity).unwrap();
+
+            if **damageable {
+                **health -= attack.damage;
 
-fn projectile_tick(mut query: Query<&mut ProjectileLifetime, With<Attack>>, time: Res<Time>) {
-    for mut timer in query.iter_mut() {
-        timer.0.tick(time.delta());
+                event_writer.send(DamageEvent {
+                    damageing_entity: attack_entity,
+                    damage_velocity: attack.velocity,
+                    damage: attack.damage,
+                    damaged_entity: damageable_entity,
+                })
+            }
+        }
     }
 }
diff --git a/src/audio.rs b/src/audio.rs
index 9bea38d3..1ab6cd24 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -3,12 +3,13 @@
 
 use bevy::{prelude::*, utils::HashMap};
 use bevy_kira_audio::{AudioChannel, AudioSource};
+use iyes_loopless::prelude::*;
 
 use crate::{
     animation::Animation,
     config::ENGINE_CONFIG,
     metadata::{GameMeta, LevelMeta},
-    state::State,
+    GameState,
 };
 
 /// For readability.
@@ -26,39 +27,49 @@ pub fn set_audio_channels_volume(
     effects_channel.set_volume(0.5);
 }
 
+pub struct AudioPlugin;
+
+impl Plugin for AudioPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugin(bevy_kira_audio::AudioPlugin)
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                animation_audio_playback.run_in_state(GameState::InGame),
+            );
+    }
+}
+
 /// Add this to a fighter, when want to play sound effects attached to certain animation indexes.
 #[derive(Component)]
-pub struct FighterStateEffectsPlayback {
-    pub state: State,
+pub struct AnimationAudioPlayback {
+    pub animation_name: String,
     pub effects: HashMap<usize, Handle<AudioSource>>,
     pub last_played: Option<usize>,
 }
 
-impl FighterStateEffectsPlayback {
-    pub fn new(state: State, effects: HashMap<usize, Handle<AudioSource>>) -> Self {
+impl AnimationAudioPlayback {
+    pub fn new(animation_name: String, effects: HashMap<usize, Handle<AudioSource>>) -> Self {
         Self {
-            state,
+            animation_name,
             effects,
             last_played: None,
         }
     }
 }
 
-pub fn fighter_sound_effect(
+pub fn animation_audio_playback(
     mut commands: Commands,
-    mut query: Query<(Entity, &State, &Animation, &mut FighterStateEffectsPlayback)>,
+    mut query: Query<(Entity, &Animation, &mut AnimationAudioPlayback)>,
     effects_channel: Res<AudioChannel<EffectsChannel>>,
 ) {
-    for (entity, fighter_state, animation, mut state_effects) in query.iter_mut() {
+    for (entity, animation, mut state_effects) in query.iter_mut() {
         // The safest way to remove the sound component is on the next state, because the component
         // can be remove only at the last frame of animation, which in theory, may be skipped if
         // there is an unexpected lag.
         // Alternatively, we could just not care, since subsequent states+effects will overwrite
         // the component.
-        if *fighter_state != state_effects.state {
-            commands
-                .entity(entity)
-                .remove::<FighterStateEffectsPlayback>();
+        if animation.current_animation.as_ref() != Some(&state_effects.animation_name) {
+            commands.entity(entity).remove::<AnimationAudioPlayback>();
 
             continue;
         }
diff --git a/src/camera.rs b/src/camera.rs
index 2e5509c9..a5d6ae6f 100644
--- a/src/camera.rs
+++ b/src/camera.rs
@@ -1,7 +1,34 @@
-use bevy::prelude::{Camera, EventWriter, Query, Res, Transform, With, Without};
+use bevy::prelude::*;
 use bevy_parallax::ParallaxMoveEvent;
+use iyes_loopless::prelude::*;
 
-use crate::{consts, metadata::GameMeta, Player};
+use crate::{consts, metadata::GameMeta, movement::VelocitySystems, GameState, Player};
+
+pub struct CameraPlugin;
+
+impl Plugin for CameraPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_system_set_to_stage(
+            CoreStage::PostUpdate,
+            ConditionSet::new()
+                .run_in_state(GameState::InGame)
+                .after(VelocitySystems)
+                .with_system(camera_follow_player)
+                .with_system(y_sort)
+                .into(),
+        );
+    }
+}
+
+#[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
+#[derive(Component, Default)]
+pub struct YSort(f32);
+
+pub fn y_sort(mut query: Query<(&mut Transform, &YSort)>) {
+    for (mut transform, ysort) in query.iter_mut() {
+        transform.translation.z = ysort.0 - transform.translation.y;
+    }
+}
 
 /// Moves the camera according to the RIGHT_BOUNDARY_DISTANCE. Note that this does not enforce
 /// limitations of any kind - that's up to the players movement logic (e.g. max distance).
diff --git a/src/collision.rs b/src/collision.rs
new file mode 100644
index 00000000..693c93a7
--- /dev/null
+++ b/src/collision.rs
@@ -0,0 +1,46 @@
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+use crate::consts;
+
+/// Empty struct simply for grouping collision layer constants.
+#[derive(Copy, Clone)]
+pub struct BodyLayers;
+
+impl BodyLayers {
+    // Each successive layer represents a different bit in the 32-bit u32 type.
+    //
+    // The layer is represented by 1 shifted 0 places to the left:          0b0001.
+    // The second layer is represented by 1 shifted one place to the left:  0b0010.
+    // And so on for the rest of the layers.
+    pub const ENEMY: u32 = 1 << 0;
+    pub const PLAYER: u32 = 1 << 1;
+    pub const PLAYER_ATTACK: u32 = 1 << 2;
+    pub const ENEMY_ATTACK: u32 = 1 << 3;
+    // u32::MAX is a u32 with all of it's bits set to 1, so this will contain all of the layers.
+    pub const ALL: u32 = u32::MAX;
+}
+
+#[derive(Bundle)]
+pub struct PhysicsBundle {
+    pub collider: Collider,
+    pub sensor: Sensor,
+    pub active_events: ActiveEvents,
+    pub active_collision_types: ActiveCollisionTypes,
+    pub collision_groups: CollisionGroups,
+}
+impl Default for PhysicsBundle {
+    fn default() -> Self {
+        PhysicsBundle {
+            collider: (Collider::cuboid(
+                consts::PLAYER_SPRITE_WIDTH / 8.,
+                consts::PLAYER_HITBOX_HEIGHT / 8.,
+            )),
+            sensor: Sensor,
+            active_events: ActiveEvents::COLLISION_EVENTS,
+            active_collision_types: ActiveCollisionTypes::default()
+                | ActiveCollisionTypes::STATIC_STATIC,
+            collision_groups: CollisionGroups::default(),
+        }
+    }
+}
diff --git a/src/collisions.rs b/src/collisions.rs
deleted file mode 100644
index 4c026dd3..00000000
--- a/src/collisions.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-use bevy::{
-    hierarchy::DespawnRecursiveExt,
-    math::Vec2,
-    prelude::{Commands, EventReader, Query, Transform},
-    time::Timer,
-};
-use bevy_rapier2d::prelude::*;
-
-use crate::{
-    attack::{Attack, ProjectileLifetime},
-    movement::Knockback,
-    state::State,
-    Stats,
-};
-
-#[derive(Copy, Clone)]
-pub struct BodyLayers;
-
-impl BodyLayers {
-    // Each successive layer represents a different bit in the 32-bit u32 type.
-    //
-    // The layer is represented by 1 shifted 0 places to the left:          0b0001.
-    // The second layer is represented by 1 shifted one place to the left:  0b0010.
-    // And so on for the rest of the layers.
-    pub const ENEMY: u32 = 1 << 0;
-    pub const PLAYER: u32 = 1 << 1;
-    pub const PLAYER_ATTACK: u32 = 1 << 2;
-    pub const ENEMY_ATTACK: u32 = 1 << 3;
-    pub const ITEM: u32 = 1 << 4;
-    // u32::MAX is a u32 with all of it's bits set to 1, so this will contain all of the layers.
-    pub const ALL: u32 = u32::MAX;
-}
-
-pub fn attack_fighter_collision(
-    mut commands: Commands,
-    mut events: EventReader<CollisionEvent>,
-    mut fighter_query: Query<(&mut State, &mut Stats, &Transform)>,
-    attack_query: Query<(&Attack, &Transform, Option<&ProjectileLifetime>)>,
-) {
-    for event in events.iter() {
-        if let CollisionEvent::Started(e1, e2, _flags) = event {
-            let (attack_entity, fighter_entity) = if attack_query.contains(*e1) {
-                // In this case, it's guaranteed that e1 is found (as projectile), but e2 and the
-                // entities in the else case, may potentially not be found.
-                (*e1, *e2)
-            } else {
-                (*e2, *e1)
-            };
-
-            if let Ok((mut f_state, mut f_stats, f_transform)) =
-                fighter_query.get_mut(fighter_entity)
-            {
-                if let Ok((a_attack, a_transform, maybe_projectile)) =
-                    attack_query.get(attack_entity)
-                {
-                    f_stats.health -= a_attack.damage;
-
-                    let force = 150.; //TODO: set this to a constant
-                    let mut direction = Vec2::new(0., 0.);
-
-                    if a_transform.translation.x < f_transform.translation.x {
-                        f_state.set(State::KnockedLeft);
-                        direction.x = force;
-                    } else {
-                        f_state.set(State::KnockedRight);
-                        direction.x = -force;
-                    }
-
-                    commands.entity(fighter_entity).insert(Knockback {
-                        direction,
-                        duration: Timer::from_seconds(0.15, false),
-                    });
-
-                    if maybe_projectile.is_some() {
-                        commands.entity(attack_entity).despawn_recursive();
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/src/consts.rs b/src/consts.rs
index c8fcabfe..06e0531a 100644
--- a/src/consts.rs
+++ b/src/consts.rs
@@ -1,9 +1,8 @@
+use bevy::math::Vec2;
+
 pub const PLAYER_SPRITE_WIDTH: f32 = 96.;
-pub const PLAYER_SPRITE_HEIGHT: f32 = 80.;
 pub const PLAYER_HITBOX_HEIGHT: f32 = 50.;
 
-pub const PLAYER_HEIGHT: f32 = PLAYER_SPRITE_HEIGHT - 50.;
-
 /// Absolute value.
 pub const ENEMY_TARGET_MAX_OFFSET: f32 = 40.;
 
@@ -23,23 +22,19 @@ pub const CAMERA_SPEED: f32 = 0.8;
 pub const MAX_Y: f32 = (GROUND_HEIGHT / 2.) + GROUND_Y;
 pub const MIN_Y: f32 = -(GROUND_HEIGHT / 2.) + GROUND_Y;
 
-pub const ATTACK_LAYER: f32 = 101.;
 pub const ATTACK_WIDTH: f32 = 16.;
 pub const ATTACK_HEIGHT: f32 = 16.;
+pub const ATTACK_VELOCITY: f32 = 250.0;
 
 pub const ITEM_LAYER: f32 = 100.;
 pub const ITEM_WIDTH: f32 = 30.;
 pub const ITEM_HEIGHT: f32 = 10.;
 
-pub const THROW_ITEM_X_OFFSET: f32 = 5.;
-pub const THROW_ITEM_Y_OFFSET: f32 = 30.;
-pub const THROW_ITEM_ANGLE_OFFSET: f32 = 5.;
-pub const THROW_ITEM_SPEED: f32 = 200.;
-pub const THROW_ITEM_DAMAGE: i32 = 10;
-pub const THROW_ITEM_ROTATION_SPEED: f32 = 10.;
+pub const PROJECTILE_Z: f32 = 101.;
+pub const THROW_ITEM_OFFSET: Vec2 = Vec2::from_array([5.0, 30.0]);
+pub const THROW_ITEM_SPEED: Vec2 = Vec2::from_array([200.0, 300.0]);
+pub const THROW_ITEM_LIFETIME: f32 = 0.64;
+pub const THROW_ITEM_ROTATION_SPEED: f32 = -20.;
+pub const THROW_ITEM_GRAVITY: f32 = 1200.0;
 
 pub const PICK_ITEM_RADIUS: f32 = 24.;
-
-pub const ITEM_BOTTLE_NAME: &str = "Bottle";
-
-pub const ITEM_HEALTH_NAME: &str = "Health";
diff --git a/src/damage.rs b/src/damage.rs
new file mode 100644
index 00000000..b6dfa1cb
--- /dev/null
+++ b/src/damage.rs
@@ -0,0 +1,35 @@
+use bevy::prelude::*;
+
+pub struct DamagePlugin;
+
+impl Plugin for DamagePlugin {
+    fn build(&self, app: &mut App) {
+        app.add_event::<DamageEvent>();
+    }
+}
+
+/// A component indicating how much health something has, or in other words, how much damage
+/// something can take before being destroyed.
+#[derive(Component, Deref, DerefMut)]
+pub struct Health(pub i32);
+
+/// A component that indicates whether an entity can be damaged.
+///
+/// In other words, something that has [`Health`] but isn't [`Damageable`] is currently invincible.
+#[derive(Component, Deref, DerefMut)]
+#[component(storage = "SparseSet")]
+pub struct Damageable(pub bool);
+
+impl Default for Damageable {
+    fn default() -> Self {
+        Self(true)
+    }
+}
+
+/// Event emitted when an entity is damaged
+pub struct DamageEvent {
+    pub damage_velocity: Vec2,
+    pub damageing_entity: Entity,
+    pub damaged_entity: Entity,
+    pub damage: i32,
+}
diff --git a/src/enemy_ai.rs b/src/enemy_ai.rs
new file mode 100644
index 00000000..2bcfd377
--- /dev/null
+++ b/src/enemy_ai.rs
@@ -0,0 +1,134 @@
+//! Enemy fighter AI
+
+use bevy::prelude::*;
+use rand::{prelude::SliceRandom, Rng};
+
+use crate::{
+    animation::Facing,
+    consts::{self, ENEMY_MAX_ATTACK_DISTANCE, ENEMY_MIN_ATTACK_DISTANCE, ENEMY_TARGET_MAX_OFFSET},
+    enemy::{Enemy, TripPointX},
+    fighter_state::{Attacking, Idling, Moving, StateTransition, StateTransitionIntents},
+    player::Player,
+    Stats,
+};
+
+/// A place that an enemy fighter is going to move to, in an attempt to attack a player.
+///
+/// The attack distance is for randomization purposes, and it's the distance that triggers the
+/// attack. More precisely, it's the max distance - if the enemy finds itself at a smaller distance,
+/// it will attack.
+#[derive(Component)]
+#[component(storage = "SparseSet")]
+pub struct EnemyTarget {
+    pub position: Vec2,
+    pub attack_distance: f32,
+}
+
+// For enemys without current target, pick a new spot near the player as target
+///
+/// This is added to the [`crate::fighter_state::FighterStateCollectSystems`] to collect figher
+/// actions for enemies.
+pub fn set_target_near_player(
+    mut commands: Commands,
+    mut enemies_query: Query<
+        (Entity, &mut TripPointX),
+        (With<Enemy>, With<Idling>, Without<EnemyTarget>),
+    >,
+    player_query: Query<&Transform, With<Player>>,
+) {
+    let mut rng = rand::thread_rng();
+    let p_transforms = player_query.iter().collect::<Vec<_>>();
+    let max_player_x = p_transforms
+        .iter()
+        .map(|transform| transform.translation.x)
+        .max_by(f32::total_cmp);
+
+    if let Some(max_player_x) = max_player_x {
+        for (e_entity, mut e_trip_point_x) in enemies_query.iter_mut() {
+            if let Some(p_transform) = p_transforms.choose(&mut rng) {
+                if max_player_x > e_trip_point_x.0 {
+                    e_trip_point_x.0 = f32::MIN;
+
+                    let x_offset = rng.gen_range(-ENEMY_TARGET_MAX_OFFSET..ENEMY_TARGET_MAX_OFFSET);
+                    let y_offset = rng.gen_range(-ENEMY_TARGET_MAX_OFFSET..ENEMY_TARGET_MAX_OFFSET);
+
+                    let attack_distance =
+                        rng.gen_range(ENEMY_MIN_ATTACK_DISTANCE..ENEMY_MAX_ATTACK_DISTANCE);
+
+                    commands.entity(e_entity).insert(EnemyTarget {
+                        position: Vec2::new(
+                            p_transform.translation.x + x_offset,
+                            (p_transform.translation.y + y_offset)
+                                .clamp(consts::MIN_Y, consts::MAX_Y),
+                        ),
+                        attack_distance,
+                    });
+                }
+            }
+        }
+    }
+}
+
+/// Controls enemy AI fighters
+///
+/// This is added to the [`crate::fighter_state::FighterStateCollectSystems`] to collect figher
+/// actions for enemies.
+pub fn emit_enemy_intents(
+    mut query: Query<
+        (
+            Entity,
+            &Transform,
+            &Stats,
+            &EnemyTarget,
+            &mut Facing,
+            &mut StateTransitionIntents,
+        ),
+        // All enemies that are either moving or idling
+        (With<Enemy>, Or<(With<Idling>, With<Moving>)>),
+    >,
+    mut commands: Commands,
+) {
+    for (entity, transform, stats, target, mut facing, mut intents) in &mut query {
+        let position = transform.translation.truncate();
+        let velocity = (target.position - position).normalize() * stats.movement_speed;
+
+        // If we're close to our target
+        if position.distance(target.position) <= target.attack_distance {
+            // Note that the target includes an offset, so this can still not point to the
+            // player.
+
+            // Remove the target
+            commands.entity(entity).remove::<EnemyTarget>();
+
+            // Face the target position
+            *facing = if target.position.x > position.x {
+                Facing::Right
+            } else {
+                Facing::Left
+            };
+
+            // And attack!
+            intents.push_back(StateTransition::new(
+                Attacking::default(),
+                Attacking::PRIORITY,
+                false,
+            ));
+
+        // If we aren't near our target yet
+        } else {
+            // Face the cirection we're moving
+            *facing = if velocity.x < 0.0 {
+                Facing::Left
+            } else {
+                Facing::Right
+            };
+
+            // Move towards our target
+            intents.push_back(StateTransition::new(
+                Moving { velocity },
+                Moving::PRIORITY,
+                false,
+            ));
+        }
+    }
+}
diff --git a/src/fighter.rs b/src/fighter.rs
index 63eb4d54..9bca9cb1 100644
--- a/src/fighter.rs
+++ b/src/fighter.rs
@@ -1,22 +1,62 @@
 use bevy::prelude::*;
 use bevy_rapier2d::prelude::CollisionGroups;
 use rand::prelude::SliceRandom;
+use serde::Deserialize;
 
 use crate::{
-    animation::Animation, collisions::BodyLayers, enemy::Enemy, metadata::FighterMeta,
-    player::Player, AnimatedSpriteSheetBundle, CharacterBundle, PhysicsBundle,
+    animation::{AnimatedSpriteSheetBundle, Animation},
+    camera::YSort,
+    collision::{BodyLayers, PhysicsBundle},
+    damage::{Damageable, Health},
+    enemy::Enemy,
+    fighter_state::{Idling, StateTransitionIntents},
+    metadata::{FighterMeta, ItemMeta},
+    movement::LinearVelocity,
+    player::Player,
 };
 
 /// Bundle added to a fighter stub, in order to activate it.
 #[derive(Bundle)]
 pub struct ActiveFighterBundle {
-    name: Name,
+    pub name: Name,
     #[bundle]
-    animated_spritesheet_bundle: AnimatedSpriteSheetBundle,
+    pub animated_spritesheet_bundle: AnimatedSpriteSheetBundle,
     #[bundle]
-    character_bundle: CharacterBundle,
-    #[bundle]
-    physics_bundle: PhysicsBundle,
+    pub physics_bundle: PhysicsBundle,
+    pub stats: Stats,
+    pub ysort: YSort,
+    pub health: Health,
+    pub damageable: Damageable,
+    pub inventory: Inventory,
+    pub state_transition_intents: StateTransitionIntents,
+    /// Fighters start off idling, but this component may be removed when the fighter state changes.
+    pub idling: Idling,
+    pub velocity: LinearVelocity,
+}
+
+#[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
+#[derive(Component, Deserialize, Clone, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct Stats {
+    pub max_health: i32,
+    pub damage: i32,
+    pub movement_speed: f32,
+}
+
+/// The player inventory.
+///
+/// A player may be holding one item
+#[derive(Component, Clone, Debug, Default, Deref, DerefMut)]
+pub struct Inventory(Option<Handle<ItemMeta>>);
+
+impl Default for Stats {
+    fn default() -> Self {
+        Stats {
+            max_health: 100,
+            damage: 35,
+            movement_speed: 17000.,
+        }
+    }
 }
 
 /// Turns a fighter stub data (loaded from the metadata) into a fully active fighter.
@@ -56,14 +96,18 @@ impl ActiveFighterBundle {
                     fighter.spritesheet.animations.clone(),
                 ),
             },
-            character_bundle: CharacterBundle {
-                stats: fighter.stats.clone(),
-                ..default()
-            },
+            stats: fighter.stats.clone(),
+            health: Health(fighter.stats.max_health),
+            inventory: default(),
+            damageable: default(),
             physics_bundle: PhysicsBundle {
                 collision_groups: CollisionGroups::new(body_layers, BodyLayers::ALL),
                 ..default()
             },
+            idling: Idling,
+            state_transition_intents: default(),
+            ysort: default(),
+            velocity: default(),
         };
 
         commands.entity(entity).insert_bundle(active_fighter_bundle);
diff --git a/src/fighter_state.rs b/src/fighter_state.rs
new file mode 100644
index 00000000..d005c57e
--- /dev/null
+++ b/src/fighter_state.rs
@@ -0,0 +1,754 @@
+use std::collections::VecDeque;
+
+use bevy::{prelude::*, reflect::FromType, utils::HashSet};
+use bevy_rapier2d::prelude::{ActiveCollisionTypes, ActiveEvents, CollisionGroups, Sensor};
+use iyes_loopless::prelude::*;
+use leafwing_input_manager::{plugin::InputManagerSystem, prelude::ActionState};
+
+use crate::{
+    animation::{Animation, Facing},
+    attack::{Attack, AttackFrames},
+    audio::AnimationAudioPlayback,
+    collision::BodyLayers,
+    consts,
+    damage::{DamageEvent, Health},
+    enemy::Enemy,
+    enemy_ai,
+    fighter::Inventory,
+    input::PlayerAction,
+    item::{Item, Projectile},
+    metadata::{FighterMeta, ItemKind, ItemMeta},
+    movement::LinearVelocity,
+    player::Player,
+    GameState, Stats,
+};
+
+/// Plugin for managing fighter states
+pub struct FighterStatePlugin;
+
+/// The system set that fighter state change intents are collected
+#[derive(Clone, SystemLabel)]
+pub struct FighterStateCollectSystems;
+
+impl Plugin for FighterStatePlugin {
+    fn build(&self, app: &mut App) {
+        app
+            // The collect systems
+            .add_system_set_to_stage(
+                CoreStage::PreUpdate,
+                ConditionSet::new()
+                    .label(FighterStateCollectSystems)
+                    .after(InputManagerSystem::Update)
+                    .run_in_state(GameState::InGame)
+                    .with_system(collect_fighter_eliminations)
+                    .with_system(collect_attack_knockbacks)
+                    .with_system(collect_player_actions)
+                    .with_system(
+                        enemy_ai::set_target_near_player.chain(enemy_ai::emit_enemy_intents),
+                    )
+                    .into(),
+            )
+            // The transition systems
+            .add_system_set_to_stage(
+                CoreStage::PreUpdate,
+                ConditionSet::new()
+                    .after(FighterStateCollectSystems)
+                    .run_in_state(GameState::InGame)
+                    .with_system(transition_from_idle)
+                    .with_system(transition_from_attacking)
+                    .with_system(transition_from_knocked_back)
+                    .into(),
+            )
+            // State handler systems
+            .add_system_set_to_stage(
+                CoreStage::Update,
+                ConditionSet::new()
+                    .run_in_state(GameState::InGame)
+                    .with_system(idling)
+                    .with_system(attacking)
+                    .with_system(moving)
+                    .with_system(throwing)
+                    .with_system(grabbing)
+                    .with_system(knocked_back)
+                    .with_system(dying)
+                    .into(),
+            );
+    }
+}
+
+/// A state transition
+pub struct StateTransition {
+    /// The [`ReflectComponent`] of the state component we want to transition to
+    reflect_component: ReflectComponent,
+    /// The data of the component we want to transition to
+    data: Box<dyn Reflect>,
+    /// The priority of the state transition
+    ///
+    /// A priority of `i32::MAX` should usually be transitioned to immediately regardless of
+    /// the current state.
+    priority: i32,
+    /// If a state transition is additive, it means that the existing state should not be removed
+    /// when this state is applied.
+    is_additive: bool,
+}
+
+impl StateTransition {
+    /// Create a new fighter state event from the given state and priority
+    pub fn new<T>(component: T, priority: i32, is_additive: bool) -> Self
+    where
+        T: Reflect + Default + Component,
+    {
+        let reflect_component = <ReflectComponent as FromType<T>>::from_type();
+        let data = Box::new(component) as _;
+        Self {
+            reflect_component,
+            data,
+            priority,
+            is_additive,
+        }
+    }
+
+    /// Apply this state transition to the given entity.
+    ///
+    /// Returns whether or not the transition was additive.
+    ///
+    /// If a transition was additive, it means the current state will still be active.
+    pub fn apply<CurrentState: Component>(self, entity: Entity, commands: &mut Commands) -> bool {
+        if !self.is_additive {
+            commands.entity(entity).remove::<CurrentState>();
+        }
+
+        commands.add(move |world: &mut World| {
+            // Insert the component stored in this state transition onto the entity
+            self.reflect_component
+                .insert(world, entity, self.data.as_reflect());
+        });
+
+        self.is_additive
+    }
+}
+
+/// Component on fighters that contains the queue of state transition intents
+#[derive(Component, Default, Deref, DerefMut)]
+pub struct StateTransitionIntents(VecDeque<StateTransition>);
+
+impl StateTransitionIntents {
+    /// Helper to transition to any higher priority states
+    ///
+    /// Returns `true` if a non-additive state has been transitioned to and the current state has been
+    /// removed.
+    fn transition_to_higher_priority_states<CurrentState: Component>(
+        &mut self,
+        entity: Entity,
+        current_state_priority: i32,
+        commands: &mut Commands,
+    ) -> bool {
+        // Collect transitions and sort by priority
+        let mut transitions = self.drain(..).collect::<Vec<_>>();
+        transitions.sort_by(|a, b| b.priority.cmp(&a.priority));
+
+        // For every intent
+        for intent in transitions {
+            // If it's a higher priority
+            if intent.priority > current_state_priority {
+                // Apply the state
+                let was_additive = intent.apply::<CurrentState>(entity, commands);
+
+                // If it was not an additive transition
+                if !was_additive {
+                    // Skip processing other transitions because our current state was removed, and
+                    // return true to indicate that a non-additive transition has been performed.
+                    return true;
+                }
+            }
+        }
+
+        // I we got here we are still in the same state so return false to indicate no non-additive
+        // transitions have been performed.
+        false
+    }
+}
+
+/// Component on fighters containing the action intent queue.
+///
+/// Actions are things that the fighter should try to do that doesn't represent a state change. The
+/// current fighter state must choose to act upon an action intent for it to be effect, and it will
+/// otherwise be ignored.q
+#[derive(Component, Default, Deref, DerefMut)]
+pub struct ActionIntents(VecDeque<Box<dyn Reflect>>);
+
+//
+// Fighter state components
+//
+
+/// Component indicating the player is idling
+#[derive(Component, Reflect, Default, Debug)]
+#[component(storage = "SparseSet")]
+pub struct Idling;
+impl Idling {
+    pub const PRIORITY: i32 = 0;
+    pub const ANIMATION: &'static str = "idle";
+}
+
+/// Component indicating the player is moving
+#[derive(Component, Reflect, Default, Debug)]
+#[component(storage = "SparseSet")]
+pub struct Moving {
+    pub velocity: Vec2,
+}
+impl Moving {
+    pub const PRIORITY: i32 = 10;
+    pub const ANIMATION: &'static str = "running";
+}
+
+/// The player is throwing an item
+#[derive(Component, Reflect, Default, Debug)]
+pub struct Throwing;
+impl Throwing {
+    pub const PRIORITY: i32 = 15;
+}
+
+/// The player is grabbing an item ( or trying to)
+#[derive(Component, Reflect, Default, Debug)]
+pub struct Grabbing;
+impl Grabbing {
+    pub const PRIORITY: i32 = Throwing::PRIORITY;
+}
+
+/// Component indicating the player is flopping
+#[derive(Component, Reflect, Default, Debug)]
+#[component(storage = "SparseSet")]
+pub struct Attacking {
+    /// The initial y-height of the figther when starting the attack
+    pub start_y: f32,
+    pub has_started: bool,
+    pub is_finished: bool,
+}
+impl Attacking {
+    pub const PRIORITY: i32 = 30;
+    pub const ANIMATION: &'static str = "attacking";
+}
+
+/// Component indicating the player is getting knocked back
+#[derive(Component, Reflect, Default, Debug)]
+#[component(storage = "SparseSet")]
+pub struct KnockedBack {
+    pub velocity: Vec2,
+    pub timer: Timer,
+}
+impl KnockedBack {
+    pub const PRIORITY: i32 = 20;
+    pub const ANIMATION_LEFT: &'static str = "knocked_left";
+    pub const ANIMATION_RIGHT: &'static str = "knocked_right";
+}
+
+/// Component indicating the player is dying
+#[derive(Component, Reflect, Default, Debug)]
+#[component(storage = "SparseSet")]
+pub struct Dying;
+impl Dying {
+    pub const PRIORITY: i32 = 1000;
+    pub const ANIMATION: &'static str = "dying";
+}
+
+//
+// Fighter input collector systems
+//
+
+/// Emits state transitions based on fighter actions
+fn collect_player_actions(
+    mut players: Query<
+        (
+            &ActionState<PlayerAction>,
+            &mut StateTransitionIntents,
+            &Inventory,
+            &Stats,
+        ),
+        With<Player>,
+    >,
+) {
+    for (action_state, mut transition_intents, inventory, stats) in &mut players {
+        // Trigger attacks
+        if action_state.just_pressed(PlayerAction::Attack) {
+            transition_intents.push_back(StateTransition::new(
+                Attacking::default(),
+                Attacking::PRIORITY,
+                false,
+            ));
+        }
+
+        // Trigger grab/throw
+        if action_state.just_pressed(PlayerAction::Throw) {
+            if inventory.is_some() {
+                transition_intents.push_back(StateTransition::new(
+                    Throwing,
+                    Throwing::PRIORITY,
+                    true,
+                ));
+            } else {
+                transition_intents.push_back(StateTransition::new(
+                    Grabbing,
+                    Grabbing::PRIORITY,
+                    true,
+                ));
+            }
+        }
+
+        // Trigger movement
+        if action_state.pressed(PlayerAction::Move) {
+            let dual_axis = action_state.clamped_axis_pair(PlayerAction::Move).unwrap();
+            let direction = dual_axis.xy();
+
+            transition_intents.push_back(StateTransition::new(
+                Moving {
+                    velocity: direction * stats.movement_speed,
+                },
+                Moving::PRIORITY,
+                false,
+            ));
+        }
+    }
+}
+
+/// Look for attacks that have contacted a figher and knock them back
+///
+/// TODO: Not all attacks will have knockback. Maybe we should replace `damage_velocity` with
+/// `damage_impulse` including the knockback time so that it can be ignored by this system if it's
+/// velocity or time is zero.
+fn collect_attack_knockbacks(
+    mut fighters: Query<&mut StateTransitionIntents, With<Handle<FighterMeta>>>,
+    mut damage_events: EventReader<DamageEvent>,
+) {
+    for event in damage_events.iter() {
+        // If the damaged entity was a fighter
+        if let Ok(mut transition_intents) = fighters.get_mut(event.damaged_entity) {
+            // Trigger knock back
+            transition_intents.push_back(StateTransition::new(
+                KnockedBack {
+                    velocity: event.damage_velocity,
+                    timer: Timer::from_seconds(0.18, false),
+                },
+                KnockedBack::PRIORITY,
+                false,
+            ));
+        }
+    }
+}
+
+/// Look for fighters with their health depleated and transition them to dying state
+fn collect_fighter_eliminations(
+    mut fighters: Query<(&Health, &mut StateTransitionIntents), With<Handle<FighterMeta>>>,
+) {
+    for (health, mut transition_intents) in &mut fighters {
+        // If the fighter health is depleted
+        if **health <= 0 {
+            // Transition to dying state
+            transition_intents.push_back(StateTransition::new(Dying, Dying::PRIORITY, false));
+        }
+    }
+}
+
+//
+// Transition states systems
+//
+
+/// Initiate any transitions from the idling state
+fn transition_from_idle(
+    mut commands: Commands,
+    mut fighters: Query<(Entity, &mut StateTransitionIntents), With<Idling>>,
+) {
+    for (entity, mut transition_intents) in &mut fighters {
+        // Transition to higher priority states
+        transition_intents.transition_to_higher_priority_states::<Idling>(
+            entity,
+            Idling::PRIORITY,
+            &mut commands,
+        );
+    }
+}
+
+// Initiate any transitions from the flopping state
+fn transition_from_attacking(
+    mut commands: Commands,
+    mut fighters: Query<(Entity, &mut StateTransitionIntents, &Attacking)>,
+) {
+    'entity: for (entity, mut transition_intents, flopping) in &mut fighters {
+        // Transition to any higher priority states
+        let current_state_removed = transition_intents
+            .transition_to_higher_priority_states::<Attacking>(
+                entity,
+                Attacking::PRIORITY,
+                &mut commands,
+            );
+
+        // If our current state was removed, don't continue processing this fighter
+        if current_state_removed {
+            continue 'entity;
+        }
+
+        // If we're done flopping
+        if flopping.is_finished {
+            // Go back to idle
+            commands.entity(entity).remove::<Attacking>().insert(Idling);
+        }
+    }
+}
+
+// Initiate any transitions from the knocked back state
+fn transition_from_knocked_back(
+    mut commands: Commands,
+    mut fighters: Query<(Entity, &mut StateTransitionIntents, &KnockedBack)>,
+) {
+    'entity: for (entity, mut transition_intents, knocked_back) in &mut fighters {
+        // Transition to any higher priority states
+        let current_state_removed = transition_intents
+            .transition_to_higher_priority_states::<KnockedBack>(
+                entity,
+                KnockedBack::PRIORITY,
+                &mut commands,
+            );
+
+        // If our current state was removed, don't continue processing this fighter
+        if current_state_removed {
+            continue 'entity;
+        }
+
+        // Transition to idle when finished
+        if knocked_back.timer.finished() {
+            commands
+                .entity(entity)
+                .remove::<KnockedBack>()
+                .insert(Idling);
+        }
+    }
+}
+
+//
+// Handle state systems
+//
+
+/// Handle fighter idle state
+fn idling(mut fighters: Query<(&mut Animation, &mut LinearVelocity), With<Idling>>) {
+    for (mut animation, mut velocity) in &mut fighters {
+        // If we aren't playing the idle animation
+        if animation.current_animation.as_deref() != Some(Idling::ANIMATION) {
+            // Start the idle animation from the beginning
+            animation.play(Idling::ANIMATION, true /* repeating */)
+        }
+
+        // Stop moving playe when we idle
+        **velocity = Vec2::ZERO;
+    }
+}
+
+/// Handle fighter attacking state
+///
+/// > **Note:** This system currently applies attacks for both enemies and players, doing a sort of
+/// > jumping "punch". In the future there will be different attacks, which will each have their own
+/// > state system, and we will trigger different attack states for different players and enemies,
+/// > based on the attacks available to that fighter.
+fn attacking(
+    mut commands: Commands,
+    mut fighters: Query<(
+        Entity,
+        &mut Animation,
+        &mut Transform,
+        &mut LinearVelocity,
+        &Facing,
+        &Stats,
+        &Handle<FighterMeta>,
+        &mut Attacking,
+        Option<&Player>,
+        Option<&Enemy>,
+    )>,
+    fighter_assets: Res<Assets<FighterMeta>>,
+) {
+    for (
+        entity,
+        mut animation,
+        mut transform,
+        mut velocity,
+        facing,
+        stats,
+        meta_handle,
+        mut attacking,
+        player,
+        enemy,
+    ) in &mut fighters
+    {
+        let is_player = player.is_some();
+        let is_enemy = enemy.is_some();
+        if !is_player && !is_enemy {
+            // This system only knows how to attack for players and enemies
+            continue;
+        }
+
+        // Start the attack
+        if !attacking.has_started {
+            attacking.has_started = true;
+            attacking.start_y = transform.translation.y;
+
+            // Start the attack  from the beginning
+            animation.play(Attacking::ANIMATION, false);
+
+            // Spawn the attack entity
+            let attack_entity = commands
+                .spawn_bundle(TransformBundle::default())
+                .insert(Sensor)
+                .insert(ActiveEvents::COLLISION_EVENTS)
+                .insert(ActiveCollisionTypes::default() | ActiveCollisionTypes::STATIC_STATIC)
+                .insert(CollisionGroups::new(
+                    if is_player {
+                        BodyLayers::PLAYER_ATTACK
+                    } else {
+                        BodyLayers::ENEMY_ATTACK
+                    },
+                    if is_player {
+                        BodyLayers::ENEMY
+                    } else {
+                        BodyLayers::PLAYER
+                    },
+                ))
+                .insert(Attack {
+                    damage: stats.damage,
+                    velocity: if facing.is_left() {
+                        Vec2::NEG_X
+                    } else {
+                        Vec2::X
+                    } * Vec2::new(consts::ATTACK_VELOCITY, 0.0),
+                })
+                // TODO: Read from figher metadata
+                .insert(AttackFrames {
+                    startup: 0,
+                    active: 3,
+                    recovery: 4,
+                })
+                .id();
+            commands.entity(entity).push_children(&[attack_entity]);
+
+            // Play attack sound effect
+            if let Some(fighter) = fighter_assets.get(meta_handle) {
+                if let Some(effects) = fighter.audio.effect_handles.get(Attacking::ANIMATION) {
+                    let fx_playback = AnimationAudioPlayback::new(
+                        Attacking::ANIMATION.to_owned(),
+                        effects.clone(),
+                    );
+                    commands.entity(entity).insert(fx_playback);
+                }
+            }
+        }
+
+        // Reset velocity
+        **velocity = Vec2::ZERO;
+
+        // Do a forward jump thing
+        //TODO: Fix hacky way to get a forward jump
+        if animation.current_frame < 3 {
+            if facing.is_left() {
+                velocity.x -= 200.0;
+            } else {
+                velocity.x += 200.0;
+            }
+
+            if animation.current_frame < 1 {
+                velocity.y += 180.0;
+            } else if animation.current_frame < 3 {
+                velocity.y -= 90.0;
+            }
+        }
+
+        if animation.is_finished() {
+            // Stop moving
+            **velocity = Vec2::ZERO;
+
+            // Make sure we "land on the ground" ( i.e. the player y position hasn't changed )
+            transform.translation.y = attacking.start_y;
+
+            // Set flopping to finished
+            attacking.is_finished = true;
+        }
+    }
+}
+
+/// Handle fighter moving state
+fn moving(
+    mut commands: Commands,
+    mut fighters: Query<(
+        Entity,
+        &mut Animation,
+        &mut Facing,
+        &mut LinearVelocity,
+        &Moving,
+    )>,
+) {
+    for (entity, mut animation, mut facing, mut velocity, moving) in &mut fighters {
+        // If we aren't playing the moving animation
+        if animation.current_animation.as_deref() != Some(Moving::ANIMATION) {
+            // Start the moving animation from the beginning
+            animation.play(Moving::ANIMATION, true /* repeating */);
+        }
+
+        // Update our velocity to match our movement velocity
+        **velocity = moving.velocity;
+
+        // Make sure we face in the direction we are moving
+        if velocity.x > 0.0 {
+            *facing = Facing::Right
+        } else if velocity.x < 0.0 {
+            *facing = Facing::Left
+        }
+
+        // Moving is a little different than the other states because we transition out of it at the
+        // end of every frame, so that we only move if the player continually inputs a movement.
+        commands.entity(entity).remove::<Moving>().insert(Idling);
+    }
+}
+
+/// Update knocked back players
+fn knocked_back(
+    mut fighters: Query<(
+        &mut Animation,
+        &Facing,
+        &mut LinearVelocity,
+        &mut KnockedBack,
+    )>,
+    time: Res<Time>,
+) {
+    for (mut animation, facing, mut velocity, mut knocked_back) in &mut fighters {
+        // If this is the start of the knock back
+        if knocked_back.timer.elapsed_secs() == 0.0 {
+            // Calculate animation to use based on attack direction
+            let is_left = knocked_back.velocity.x < 0.0;
+            let use_left_anim = if facing.is_left() { !is_left } else { is_left };
+            let animation_name = if use_left_anim {
+                KnockedBack::ANIMATION_LEFT
+            } else {
+                KnockedBack::ANIMATION_RIGHT
+            };
+
+            // Play the animation
+            animation.play(animation_name, false);
+        }
+
+        // Tick the knock-back timer
+        knocked_back.timer.tick(time.delta());
+
+        // Set our figher velocity to the knock back velocity
+        **velocity = knocked_back.velocity;
+    }
+}
+
+/// Update dying players
+fn dying(
+    mut commands: Commands,
+    mut fighters: Query<(Entity, &mut Animation, &mut LinearVelocity), With<Dying>>,
+) {
+    for (entity, mut animation, mut velocity) in &mut fighters {
+        // Start playing the dying animation if it isn't already
+        if animation.current_animation.as_deref() != Some(Dying::ANIMATION) {
+            **velocity = Vec2::ZERO;
+            animation.play(Dying::ANIMATION, false);
+
+        // When the animatino is finished, despawn the fighter
+        } else if animation.is_finished() {
+            commands.entity(entity).despawn_recursive();
+        }
+    }
+}
+
+/// Throw the item in the player's inventory
+fn throwing(
+    mut commands: Commands,
+    mut fighters: Query<
+        (
+            Entity,
+            &Transform,
+            &Facing,
+            &Stats,
+            &mut Inventory,
+            &mut Health,
+        ),
+        With<Throwing>,
+    >,
+    item_assets: Res<Assets<ItemMeta>>,
+) {
+    for (entity, fighter_transform, facing, stats, mut inventory, mut health) in &mut fighters {
+        // If the player has an item in their inventory
+        if let Some(meta_handle) = inventory.take() {
+            // If the item asset has loaded
+            if let Some(item) = item_assets.get(&meta_handle) {
+                // Check what kind of item this is.
+                //
+                // TODO: We should probably create a flexible item system abstraction similar to the
+                // fighter state abstraction so that items can flexibly defined without a
+                // centralized enum.
+                match item.kind {
+                    ItemKind::Throwable { .. } => {
+                        // Throw the item!
+                        commands.spawn_bundle(Projectile::from_thrown_item(
+                            fighter_transform.translation + consts::THROW_ITEM_OFFSET.extend(0.0),
+                            item,
+                            facing,
+                        ));
+                    }
+                    ItemKind::Health {
+                        health: item_health,
+                    } => {
+                        // Refill player's health
+                        **health = (**health + item_health).clamp(0, stats.max_health);
+                    }
+                }
+
+            // If the item asset isn't loaded yet
+            } else {
+                // This shouldn't happen because we make sure our assets are loaded before we start
+                // the game. But just in case, we'll want to know about it if it does happen.
+                warn!("Thrown item not spawned because it has not been loaded yet");
+            }
+        }
+
+        // Throwing is an "instant" state, that is removed at the end of every frame. Eventually it
+        // will not be and will play a fighter animation.
+        commands.entity(entity).remove::<Throwing>();
+    }
+}
+
+// Trying to grab an item off the map
+fn grabbing(
+    mut commands: Commands,
+    mut fighters: Query<(Entity, &Transform, &mut Inventory), With<Grabbing>>,
+    items_query: Query<(Entity, &Transform, &Handle<ItemMeta>), With<Item>>,
+) {
+    // We need to track the picked items, otherwise, in theory, two players could pick the same item.
+    let mut picked_item_ids = HashSet::new();
+
+    for (fighter_ent, fighter_transform, mut fighter_inventory) in &mut fighters {
+        // If several items are at pick distance, an arbitrary one is picked.
+        for (item_ent, item_transform, item_meta_handle) in &items_query {
+            if !picked_item_ids.contains(&item_ent) {
+                // Get the distance the figher is from the item
+                let fighter_item_distance = fighter_transform
+                    .translation
+                    .truncate()
+                    .distance(item_transform.translation.truncate());
+
+                // If we are close enough
+                if fighter_item_distance <= consts::PICK_ITEM_RADIUS {
+                    // And our fighter isn't carrying another item
+                    if fighter_inventory.is_none() {
+                        // Pick up the item
+                        picked_item_ids.insert(item_ent);
+                        **fighter_inventory = Some(item_meta_handle.clone());
+                        commands.entity(item_ent).despawn_recursive();
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        // Grabbing is an "instant" state, that is removed at the end of every frame. Eventually it
+        // may not be and it might play a fighter animation.
+        commands.entity(fighter_ent).remove::<Grabbing>();
+    }
+}
diff --git a/src/input.rs b/src/input.rs
index 11261a26..aeba0a66 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -5,7 +5,7 @@ use serde::Deserialize;
 pub enum PlayerAction {
     Move,
     // Attacks
-    FlopAttack,
+    Attack,
     Throw,
     Shoot,
 }
diff --git a/src/item.rs b/src/item.rs
index 89aa7015..b07f289a 100644
--- a/src/item.rs
+++ b/src/item.rs
@@ -1,33 +1,25 @@
-use std::collections::HashSet;
-
-use bevy::{
-    ecs::system::EntityCommands,
-    hierarchy::{BuildChildren, Children},
-    math::Vec3,
-    prelude::{Assets, Bundle, Commands, Component, Entity, Handle, Query, Res, Transform, With},
-    transform::TransformBundle,
-};
-use leafwing_input_manager::prelude::ActionState;
+use bevy::{ecs::system::EntityCommands, prelude::*};
+use bevy_rapier2d::prelude::*;
 
 use crate::{
-    consts::{self, ITEM_HEALTH_NAME, ITEM_LAYER, PICK_ITEM_RADIUS},
-    input::PlayerAction,
-    metadata::{FighterMeta, ItemMeta, ItemSpawnMeta},
-    player::Player,
-    state::State,
-    Stats,
+    animation::Facing,
+    attack::Attack,
+    collision::BodyLayers,
+    consts,
+    lifetime::Lifetime,
+    metadata::{ItemMeta, ItemSpawnMeta},
+    movement::{AngularVelocity, Force, LinearVelocity},
 };
 
 #[derive(Component)]
 pub struct Item;
 
-/// Represents an item, that is either on the map (waiting to be picked up), or carried.
-/// If an item is on the map, it has a TransformBundle; if it's carried, it doesn't, and it's the
-/// child entity of a Player.
+/// Represents an item, that is either on the map.
 #[derive(Bundle)]
 pub struct ItemBundle {
     item: Item,
     item_meta_handle: Handle<ItemMeta>,
+    name: Name,
 }
 
 impl ItemBundle {
@@ -35,11 +27,13 @@ impl ItemBundle {
         Self {
             item: Item,
             item_meta_handle: item_spawn_meta.item_handle.clone(),
+            // TODO: Actually include the item's name at some point
+            name: Name::new("Map Item"),
         }
     }
 
     pub fn spawn(mut commands: EntityCommands, item_spawn_meta: &ItemSpawnMeta) {
-        let ground_offset = Vec3::new(0.0, consts::GROUND_Y, ITEM_LAYER);
+        let ground_offset = Vec3::new(0.0, consts::GROUND_Y, consts::ITEM_LAYER);
         let transform_bundle = TransformBundle::from_transform(Transform::from_translation(
             item_spawn_meta.location + ground_offset,
         ));
@@ -48,79 +42,55 @@ impl ItemBundle {
     }
 }
 
-pub fn pick_items(
-    mut commands: Commands,
-    player_query: Query<(Entity, &Transform, &State, &ActionState<PlayerAction>), With<Player>>,
-    items_query: Query<(Entity, &Transform), With<Item>>,
-) {
-    // We need to track the picked items, otherwise, in theory, two players could pick the same item.
-    let mut picked_item_ids = HashSet::new();
-
-    for (player_id, player_transform, player_state, input) in player_query.iter() {
-        if *player_state != State::Idle && *player_state != State::Running {
-            continue;
-        }
-
-        if input.just_pressed(PlayerAction::Throw) {
-            // If several items are at pick distance, an arbitrary one is picked.
-            for (item_id, item_transform) in items_query.iter() {
-                if !picked_item_ids.contains(&item_id) {
-                    let player_item_distance = player_transform
-                        .translation
-                        .truncate()
-                        .distance(item_transform.translation.truncate());
-
-                    if player_item_distance <= PICK_ITEM_RADIUS {
-                        commands.entity(item_id).remove_bundle::<TransformBundle>();
-                        commands.entity(player_id).add_child(item_id);
-                        picked_item_ids.insert(item_id);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// Utility method, not system!
-pub fn item_carried_by_player(
-    children: &Children,
-    item_name: &str,
-    items_meta_query: &Query<&Handle<ItemMeta>>,
-    items_meta: &Assets<ItemMeta>,
-) -> Option<Entity> {
-    for child_id in children.iter() {
-        if let Ok(item_meta_handle) = items_meta_query.get(*child_id) {
-            if let Some(item_meta) = items_meta.get(item_meta_handle) {
-                if item_meta.name == item_name {
-                    return Some(*child_id);
-                }
-            }
-        }
-    }
-
-    None
+#[derive(Bundle)]
+pub struct Projectile {
+    #[bundle]
+    sprite_bundle: SpriteBundle,
+    velocity: LinearVelocity,
+    angular_velocity: AngularVelocity,
+    force: Force,
+    collider: Collider,
+    sensor: Sensor,
+    events: ActiveEvents,
+    collision_types: ActiveCollisionTypes,
+    collision_groups: CollisionGroups,
+    attack: Attack,
+    lifetime: Lifetime,
 }
 
-pub fn use_health_item(
-    mut player_query: Query<(&Children, &mut Stats, &Handle<FighterMeta>), With<Player>>,
-    items_meta_query: Query<&Handle<ItemMeta>>,
-    items_meta: Res<Assets<ItemMeta>>,
-    mut commands: Commands,
-    fighter_assets: Res<Assets<FighterMeta>>,
-) {
-    for (player_children, mut stats, player_meta) in player_query.iter_mut() {
-        let health_item = item_carried_by_player(
-            player_children,
-            ITEM_HEALTH_NAME,
-            &items_meta_query,
-            &items_meta,
-        );
+impl Projectile {
+    pub fn from_thrown_item(translation: Vec3, item: &ItemMeta, facing: &Facing) -> Self {
+        let direction_mul = if facing.is_left() {
+            Vec2::new(-1.0, 1.0)
+        } else {
+            Vec2::ONE
+        };
 
-        if let Some(health_id) = health_item {
-            let player_meta = fighter_assets.get(player_meta).unwrap();
-            stats.health = player_meta.stats.health;
-            commands.entity(health_id).despawn();
+        Self {
+            sprite_bundle: SpriteBundle {
+                texture: item.image.image_handle.clone(),
+                transform: Transform::from_xyz(translation.x, translation.y, consts::PROJECTILE_Z),
+                ..default()
+            },
+            attack: Attack {
+                damage: match item.kind {
+                    crate::metadata::ItemKind::Throwable { damage } => damage,
+                    crate::metadata::ItemKind::Health { .. } => panic!("Cannot throw health item"),
+                },
+                velocity: Vec2::new(consts::ATTACK_VELOCITY, 0.0) * direction_mul,
+            },
+            velocity: LinearVelocity(consts::THROW_ITEM_SPEED * direction_mul),
+            // Gravity
+            force: Force(Vec2::new(0.0, -consts::THROW_ITEM_GRAVITY)),
+            angular_velocity: AngularVelocity(consts::THROW_ITEM_ROTATION_SPEED * direction_mul.x),
+            collider: Collider::cuboid(consts::ITEM_WIDTH / 2., consts::ITEM_HEIGHT / 2.),
+            sensor: Sensor,
+            events: ActiveEvents::COLLISION_EVENTS,
+            collision_types: ActiveCollisionTypes::default() | ActiveCollisionTypes::STATIC_STATIC,
+            //TODO: define collision layer based on the fighter shooting projectile, load for asset
+            //files of fighter which "team" they are on
+            collision_groups: CollisionGroups::new(BodyLayers::PLAYER_ATTACK, BodyLayers::ENEMY),
+            lifetime: Lifetime(Timer::from_seconds(consts::THROW_ITEM_LIFETIME, false)),
         }
     }
 }
diff --git a/src/lifetime.rs b/src/lifetime.rs
new file mode 100644
index 00000000..e42da1ea
--- /dev/null
+++ b/src/lifetime.rs
@@ -0,0 +1,28 @@
+use bevy::prelude::*;
+
+pub struct LifetimePlugin;
+
+impl Plugin for LifetimePlugin {
+    fn build(&self, app: &mut App) {
+        app.add_system_to_stage(CoreStage::Last, lifetime_system);
+    }
+}
+
+/// Component added to entities that should despawn after a timer.
+#[derive(Component, Deref, DerefMut, Debug, Clone)]
+pub struct Lifetime(pub Timer);
+
+/// Despawn entities who's lifetime has expired
+fn lifetime_system(
+    mut commands: Commands,
+    mut entities: Query<(Entity, &mut Lifetime)>,
+    time: Res<Time>,
+) {
+    for (entity, mut lifetime) in &mut entities {
+        lifetime.tick(time.delta());
+
+        if lifetime.finished() {
+            commands.entity(entity).despawn_recursive();
+        }
+    }
+}
diff --git a/src/loading.rs b/src/loading.rs
index 471a5beb..97ce2f6d 100644
--- a/src/loading.rs
+++ b/src/loading.rs
@@ -1,4 +1,4 @@
-use bevy::{asset::AssetStage, prelude::*};
+use bevy::prelude::*;
 use bevy_parallax::ParallaxResource;
 use iyes_loopless::{prelude::*, state::NextState};
 
@@ -14,7 +14,7 @@ use crate::{
     metadata::{BorderImageMeta, FighterMeta, GameMeta, ItemMeta, LevelMeta, Settings},
     platform::Storage,
     player::{Player, PlayerBundle},
-    GameStage, GameState, Stats,
+    GameState, Stats,
 };
 
 use bevy::{ecs::system::SystemParam, render::camera::ScalingMode};
@@ -50,20 +50,15 @@ impl Plugin for LoadingPlugin {
 
         // Configure hot reload
         if ENGINE_CONFIG.hot_reload {
-            app.add_stage_after(
-                AssetStage::LoadAssets,
-                GameStage::HotReload,
-                SystemStage::parallel(),
-            )
-            .add_system_to_stage(GameStage::HotReload, hot_reload_game)
-            .add_system_set_to_stage(
-                GameStage::HotReload,
-                ConditionSet::new()
-                    .run_in_state(GameState::InGame)
-                    .with_system(hot_reload_level)
-                    .with_system(hot_reload_fighters)
-                    .into(),
-            );
+            app.add_system_to_stage(CoreStage::Last, hot_reload_game)
+                .add_system_set_to_stage(
+                    CoreStage::Last,
+                    ConditionSet::new()
+                        .run_in_state(GameState::InGame)
+                        .with_system(hot_reload_level)
+                        .with_system(hot_reload_fighters)
+                        .into(),
+                );
         }
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 00ea395c..eeecae91 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,20 +3,16 @@
 #![allow(clippy::too_many_arguments)]
 
 use bevy::{
-    asset::AssetServerSettings, ecs::bundle::Bundle, log::LogSettings, prelude::*,
-    render::texture::ImageSettings,
+    asset::AssetServerSettings, log::LogSettings, prelude::*, render::texture::ImageSettings,
 };
-use bevy_kira_audio::{AudioApp, AudioPlugin};
+use bevy_kira_audio::AudioApp;
 use bevy_parallax::{ParallaxPlugin, ParallaxResource};
 use bevy_rapier2d::prelude::*;
-use consts::ENEMY_TARGET_MAX_OFFSET;
-use consts::{ENEMY_MAX_ATTACK_DISTANCE, ENEMY_MIN_ATTACK_DISTANCE};
-use enemy::*;
+use fighter::Stats;
 use input::MenuAction;
 use iyes_loopless::prelude::*;
 use leafwing_input_manager::prelude::*;
 use player::*;
-use rand::{seq::SliceRandom, Rng};
 
 #[cfg(feature = "debug")]
 use bevy_inspector_egui::{RegisterInspectable, WorldInspectorPlugin};
@@ -31,67 +27,42 @@ mod assets;
 mod attack;
 mod audio;
 mod camera;
-mod collisions;
+mod collision;
 mod config;
 mod consts;
+mod damage;
 mod enemy;
+mod enemy_ai;
 mod fighter;
+mod fighter_state;
 mod input;
 mod item;
+mod lifetime;
 mod loading;
 mod localization;
 mod metadata;
 mod movement;
 mod platform;
 mod player;
-mod state;
 mod ui;
 mod utils;
-mod y_sort;
 
 use animation::*;
 use attack::AttackPlugin;
 use audio::*;
 use camera::*;
-use collisions::*;
 use metadata::GameMeta;
-use movement::*;
-use serde::Deserialize;
-use state::{State, StatePlugin};
 use ui::UIPlugin;
 use utils::ResetController;
-use y_sort::*;
 
 use crate::{
+    damage::DamagePlugin,
+    fighter_state::FighterStatePlugin,
     input::PlayerAction,
-    item::{pick_items, use_health_item},
+    lifetime::LifetimePlugin,
+    movement::{LeftMovementBoundary, MovementPlugin},
 };
 
-#[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
-#[derive(Component, Deserialize, Clone, Debug)]
-#[serde(deny_unknown_fields)]
-pub struct Stats {
-    pub health: i32,
-    pub damage: i32,
-    pub movement_speed: f32,
-}
-
-impl Default for Stats {
-    fn default() -> Self {
-        Stats {
-            health: 100,
-            damage: 35,
-            movement_speed: 150.,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, StageLabel)]
-enum GameStage {
-    Animation,
-    HotReload,
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 enum GameState {
     LoadingStorage,
@@ -103,49 +74,6 @@ enum GameState {
     //Editor,
 }
 
-#[derive(Component)]
-pub struct DespawnMarker;
-
-#[derive(Bundle, Default)]
-struct CharacterBundle {
-    state: State,
-    stats: Stats,
-    ysort: YSort,
-}
-
-#[derive(Bundle)]
-struct AnimatedSpriteSheetBundle {
-    #[bundle]
-    sprite_sheet: SpriteSheetBundle,
-    animation: Animation,
-}
-
-#[derive(Bundle)]
-struct PhysicsBundle {
-    collider: Collider,
-    sensor: Sensor,
-    active_events: ActiveEvents,
-    active_collision_types: ActiveCollisionTypes,
-    collision_groups: CollisionGroups,
-}
-impl Default for PhysicsBundle {
-    fn default() -> Self {
-        PhysicsBundle {
-            collider: (Collider::cuboid(
-                consts::PLAYER_SPRITE_WIDTH / 8.,
-                consts::PLAYER_HITBOX_HEIGHT / 8.,
-            )),
-            sensor: Sensor,
-            active_events: ActiveEvents::COLLISION_EVENTS,
-            active_collision_types: ActiveCollisionTypes::default()
-                | ActiveCollisionTypes::STATIC_STATIC,
-            collision_groups: CollisionGroups::default(),
-        }
-    }
-}
-
-pub struct ArrivedEvent(Entity);
-
 fn main() {
     // Load engine config. This will parse CLI arguments or web query string so we want to do it
     // before we create the app to make sure everything is in order.
@@ -185,12 +113,6 @@ fn main() {
 
     // Add other systems and resources
     app.insert_resource(ClearColor(Color::BLACK))
-        .add_stage_after(
-            CoreStage::Update,
-            GameStage::Animation,
-            SystemStage::parallel(),
-        )
-        .add_event::<ArrivedEvent>()
         .add_loopless_state(GameState::LoadingStorage)
         .add_plugin(platform::PlatformPlugin)
         .add_plugin(localization::LocalizationPlugin)
@@ -200,10 +122,14 @@ fn main() {
         .add_plugin(InputManagerPlugin::<MenuAction>::default())
         .add_plugin(AttackPlugin)
         .add_plugin(AnimationPlugin)
-        .add_plugin(AudioPlugin)
-        .add_plugin(StatePlugin)
         .add_plugin(ParallaxPlugin)
         .add_plugin(UIPlugin)
+        .add_plugin(FighterStatePlugin)
+        .add_plugin(MovementPlugin)
+        .add_plugin(AudioPlugin)
+        .add_plugin(DamagePlugin)
+        .add_plugin(LifetimePlugin)
+        .add_plugin(CameraPlugin)
         .add_audio_channel::<MusicChannel>()
         .add_audio_channel::<EffectsChannel>()
         .insert_resource(ParallaxResource::default())
@@ -212,45 +138,13 @@ fn main() {
         .add_startup_system(set_audio_channels_volume)
         .add_enter_system(GameState::InGame, play_level_music)
         .add_exit_system(GameState::InGame, stop_level_music)
-        .add_system_set(
-            ConditionSet::new()
-                .run_in_state(GameState::InGame)
-                .with_system(player_controller)
-                .with_system(pick_items)
-                .with_system(use_health_item)
-                .with_system(y_sort)
-                .with_system(attack_fighter_collision)
-                .with_system(kill_entities)
-                .with_system(knockback_system)
-                .with_system(move_direction_system)
-                .with_system(pause)
-                .into(),
-        )
-        .add_system(
-            set_target_near_player
-                .run_in_state(GameState::InGame)
-                .label("set_target_near_player"),
-        )
-        .add_system(
-            move_to_target
-                .run_in_state(GameState::InGame)
-                .after("set_target_near_player")
-                .label("move_to_target"),
-        )
-        .add_system(unpause.run_in_state(GameState::Paused))
         .add_system_set_to_stage(
             CoreStage::PostUpdate,
             ConditionSet::new()
                 .run_in_state(GameState::InGame)
-                .with_system(move_in_arc_system)
-                .with_system(rotate_system)
-                .with_system(camera_follow_player)
-                .with_system(update_left_movement_boundary)
-                .with_system(fighter_sound_effect)
                 .with_system(game_over_on_players_death)
                 .into(),
-        )
-        .add_system_to_stage(CoreStage::Last, despawn_entities);
+        );
 
     // Add debug plugins
     #[cfg(feature = "debug")]
@@ -258,10 +152,9 @@ fn main() {
         .add_plugin(InspectableRapierPlugin)
         .add_plugin(WorldInspectorPlugin::new())
         .register_inspectable::<Stats>()
-        .register_inspectable::<State>()
-        .register_inspectable::<MoveInDirection>()
-        .register_inspectable::<MoveInArc>()
-        .register_inspectable::<Rotate>()
+        .register_inspectable::<crate::movement::LinearVelocity>()
+        .register_inspectable::<crate::movement::AngularVelocity>()
+        // .register_inspectable::<MoveInArc>()
         .register_inspectable::<attack::Attack>()
         .register_inspectable::<YSort>()
         .register_inspectable::<Facing>();
@@ -286,44 +179,7 @@ fn main() {
     app.run();
 }
 
-/// Transition game to pause state
-fn pause(mut commands: Commands, input: Query<&ActionState<MenuAction>>) {
-    let input = input.single();
-    if input.just_pressed(MenuAction::Pause) {
-        commands.insert_resource(NextState(GameState::Paused));
-    }
-}
-
-// Transition game out of paused state
-fn unpause(mut commands: Commands, input: Query<&ActionState<MenuAction>>) {
-    let input = input.single();
-    if input.just_pressed(MenuAction::Pause) {
-        commands.insert_resource(NextState(GameState::InGame));
-    }
-}
-
-fn kill_entities(
-    mut commands: Commands,
-    mut query: Query<(Entity, &Stats, &Animation, &mut State)>,
-) {
-    for (entity, stats, animation, mut state) in query.iter_mut() {
-        if stats.health <= 0 {
-            state.set(State::Dying);
-        }
-
-        if *state == State::Dying && animation.is_finished() {
-            commands.entity(entity).insert(DespawnMarker);
-            // commands.entity(entity).despawn_recursive();
-        }
-    }
-}
-
-fn despawn_entities(mut commands: Commands, query: Query<Entity, With<DespawnMarker>>) {
-    for entity in query.iter() {
-        commands.entity(entity).despawn_recursive();
-    }
-}
-
+/// Transition back to main menu and reset world when all players have died
 fn game_over_on_players_death(
     mut commands: Commands,
     query: Query<(), With<Player>>,
@@ -335,46 +191,3 @@ fn game_over_on_players_death(
         reset_controller.reset_world();
     }
 }
-
-//for enemys without current target, pick a new spot near the player as target
-fn set_target_near_player(
-    mut commands: Commands,
-    mut enemies_query: Query<(Entity, &State, &mut TripPointX), (With<Enemy>, Without<Target>)>,
-    player_query: Query<&Transform, With<Player>>,
-) {
-    let mut rng = rand::thread_rng();
-    let p_transforms = player_query.iter().collect::<Vec<_>>();
-    let max_player_x = p_transforms
-        .iter()
-        .map(|transform| transform.translation.x)
-        .max_by(f32::total_cmp);
-
-    if let Some(max_player_x) = max_player_x {
-        for (e_entity, e_state, mut e_trip_point_x) in enemies_query.iter_mut() {
-            if *e_state == State::Idle {
-                if let Some(p_transform) = p_transforms.choose(&mut rng) {
-                    if max_player_x > e_trip_point_x.0 {
-                        e_trip_point_x.0 = f32::MIN;
-
-                        let x_offset =
-                            rng.gen_range(-ENEMY_TARGET_MAX_OFFSET..ENEMY_TARGET_MAX_OFFSET);
-                        let y_offset =
-                            rng.gen_range(-ENEMY_TARGET_MAX_OFFSET..ENEMY_TARGET_MAX_OFFSET);
-
-                        let attack_distance =
-                            rng.gen_range(ENEMY_MIN_ATTACK_DISTANCE..ENEMY_MAX_ATTACK_DISTANCE);
-
-                        commands.entity(e_entity).insert(Target {
-                            position: Vec2::new(
-                                p_transform.translation.x + x_offset,
-                                (p_transform.translation.y + y_offset)
-                                    .clamp(consts::MIN_Y, consts::MAX_Y),
-                            ),
-                            attack_distance,
-                        });
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/src/metadata.rs b/src/metadata.rs
index 0324d48e..3e4abd0f 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -11,7 +11,7 @@ use bevy_parallax::{LayerData, ParallaxResource};
 use punchy_macros::HasLoadProgress;
 use serde::Deserialize;
 
-use crate::{animation::Clip, assets::EguiFont, state::State, Stats};
+use crate::{animation::Clip, assets::EguiFont, fighter::Stats};
 
 pub mod settings;
 pub use settings::*;
@@ -99,6 +99,14 @@ pub struct FighterMeta {
 pub struct ItemMeta {
     pub name: String,
     pub image: ImageMeta,
+    pub kind: ItemKind,
+}
+
+#[derive(Deserialize, Clone, Debug)]
+#[serde(deny_unknown_fields)]
+pub enum ItemKind {
+    Throwable { damage: i32 },
+    Health { health: i32 },
 }
 
 #[derive(Deserialize, Clone, Debug)]
@@ -117,15 +125,15 @@ pub struct FighterSpritesheetMeta {
     pub columns: usize,
     pub rows: usize,
     pub animation_fps: f32,
-    pub animations: HashMap<State, Clip>,
+    pub animations: HashMap<String, Clip>,
 }
 
 #[derive(Deserialize, Clone, Debug)]
 #[serde(deny_unknown_fields)]
 pub struct AudioMeta {
-    pub effects: HashMap<State, HashMap<usize, String>>,
+    pub effects: HashMap<String, HashMap<usize, String>>,
     #[serde(skip)]
-    pub effect_handles: HashMap<State, HashMap<usize, Handle<AudioSource>>>,
+    pub effect_handles: HashMap<String, HashMap<usize, Handle<AudioSource>>>,
 }
 
 #[derive(HasLoadProgress, Deserialize, Clone, Debug)]
diff --git a/src/metadata/settings.rs b/src/metadata/settings.rs
index aba89030..9fd6b238 100644
--- a/src/metadata/settings.rs
+++ b/src/metadata/settings.rs
@@ -37,7 +37,7 @@ impl PlayerControlMethods {
 
         let mut add_controls = |ctrls: &PlayerControls| {
             input_map.insert(ctrls.movement.clone(), PlayerAction::Move);
-            input_map.insert(ctrls.flop_attack, PlayerAction::FlopAttack);
+            input_map.insert(ctrls.flop_attack, PlayerAction::Attack);
             input_map.insert(ctrls.shoot, PlayerAction::Shoot);
             input_map.insert(ctrls.throw, PlayerAction::Throw);
         };
diff --git a/src/movement.rs b/src/movement.rs
index f51bb128..207abb5c 100644
--- a/src/movement.rs
+++ b/src/movement.rs
@@ -1,293 +1,134 @@
 use bevy::{
-    ecs::system::SystemParam,
-    math::{Quat, Vec2, Vec3},
-    prelude::{
-        Commands, Component, Deref, DerefMut, Entity, EventWriter, Query, Res, ResMut, Transform,
-        With,
-    },
-    time::{Time, Timer},
+    math::{Quat, Vec2},
+    prelude::*,
+    time::Time,
 };
-use leafwing_input_manager::prelude::ActionState;
+use iyes_loopless::prelude::*;
 
 use crate::{
-    animation::Facing,
     consts::{self, LEFT_BOUNDARY_MAX_DISTANCE},
     enemy::SpawnLocationX,
-    input::PlayerAction,
     metadata::{GameMeta, LevelMeta},
-    state::State,
-    ArrivedEvent, DespawnMarker, Player, Stats,
+    GameState, Player,
 };
 
-#[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
-#[derive(Component, Deref, DerefMut)]
-pub struct MoveInDirection(pub Vec2);
-
-// (Moving) bondary before which, the players can't go back.
-#[derive(Component)]
-pub struct LeftMovementBoundary(f32);
-
-impl Default for LeftMovementBoundary {
-    fn default() -> Self {
-        Self(-LEFT_BOUNDARY_MAX_DISTANCE)
+/// Plugin handling movement and rotation through velocities and torques.
+pub struct MovementPlugin;
+
+#[derive(Clone, SystemLabel)]
+pub struct ForceSystems;
+
+#[derive(Clone, SystemLabel)]
+pub struct VelocitySystems;
+
+impl Plugin for MovementPlugin {
+    fn build(&self, app: &mut App) {
+        app
+            // Add systems that modify velocity based on forces
+            .add_system_set_to_stage(
+                CoreStage::PostUpdate,
+                ConditionSet::new()
+                    .label(ForceSystems)
+                    .run_in_state(GameState::InGame)
+                    .with_system(force_system)
+                    .with_system(torque_system)
+                    .into(),
+            )
+            // Add systems that modify translation and rotation based on velocity
+            .add_system_set_to_stage(
+                CoreStage::PostUpdate,
+                ConditionSet::new()
+                    .label(VelocitySystems)
+                    .after(ForceSystems)
+                    .run_in_state(GameState::InGame)
+                    .with_system(
+                        // Here we add a chain of systems that act as constraints on movements, ending
+                        // the chain with the velocity system itself which applies the velocities to the
+                        // entities.
+                        update_left_movement_boundary
+                            .chain(constrain_player_movement)
+                            .chain(velocity_system),
+                    )
+                    .with_system(angular_velocity_system)
+                    .into(),
+            );
     }
 }
 
-#[derive(Component)]
-pub struct Knockback {
-    pub direction: Vec2,
-    pub duration: Timer,
-}
-
-pub fn knockback_system(
-    mut commands: Commands,
-    mut query: Query<(Entity, &mut Transform, &mut Knockback, Option<&Player>)>,
-    player_movement_clamper: PlayerMovementClamper,
-    time: Res<Time>,
-) {
-    let mut all_knockbacks = query.iter_mut().collect::<Vec<_>>();
-
-    // Separate the finished knockbacks, and despawn them.
-
-    let (finished_knockbacks, mut current_knockbacks): (Vec<_>, Vec<_>) = all_knockbacks
-        .iter_mut()
-        .partition(|(_, _, knockback, _)| knockback.duration.finished());
-
-    for (entity, _, _, _) in &finished_knockbacks {
-        commands.entity(*entity).remove::<Knockback>();
-    }
-
-    // Tick the timer for the current knockbacks.
-
-    for (_, _, knockback, _) in current_knockbacks.iter_mut() {
-        knockback.duration.tick(time.delta());
-    }
-
-    // Separate the enemy knocbacks, and apply them, unclamped.
-
-    let (mut enemy_knockbacks, mut player_knockbacks): (Vec<_>, Vec<_>) = current_knockbacks
-        .iter_mut()
-        .partition(|(_, _, _, player)| player.is_none());
-
-    for (_, transform, knockback, _) in enemy_knockbacks.iter_mut() {
-        transform.translation.x += knockback.direction.x * time.delta_seconds();
-        transform.translation.y += knockback.direction.y * time.delta_seconds();
-    }
-
-    // Extract the players movement data, and apply the knockbacks, clamped.
-
-    let player_movements = player_knockbacks
-        .iter()
-        .map(|(_, transform, knockback, _)| {
-            (
-                transform.translation,
-                Some(knockback.direction * time.delta_seconds()),
-            )
-        })
-        .collect::<Vec<_>>();
-
-    let player_dirs = player_movement_clamper.clamp(player_movements);
+/// An entity's linear velocity.
+///
+/// This is similar to the velocity you would set in a physics simulation, but in our case we use a
+/// simple constraints system instead of actual physics simulation.
+#[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
+#[derive(Component, Deref, DerefMut, Default, Clone, Copy)]
+pub struct LinearVelocity(pub Vec2);
 
-    for ((_, transform, _, _), player_dir) in player_knockbacks.iter_mut().zip(player_dirs) {
-        transform.translation += player_dir.unwrap().extend(0.);
+/// System that updates translations based on entity velocities.
+pub fn velocity_system(mut query: Query<(&mut Transform, &LinearVelocity)>, time: Res<Time>) {
+    for (mut transform, dir) in &mut query.iter_mut() {
+        transform.translation += dir.0.extend(0.) * time.delta_seconds();
     }
 }
 
-pub fn player_controller(
-    mut query: Query<
-        (
-            &mut State,
-            &Stats,
-            &mut Transform,
-            &mut Facing,
-            &ActionState<PlayerAction>,
-        ),
-        With<Player>,
-    >,
-    player_movement_clamper: PlayerMovementClamper,
-    time: Res<Time>,
-) {
-    // Compute the new direction vectors; can be None if the state is not (idle or running).
-    //
-    let player_movements = query
-        .iter()
-        .map(|(state, stats, transform, _, input)| {
-            if *state != State::Idle && *state != State::Running {
-                (transform.translation, None)
-            } else {
-                let mut dir = if input.pressed(PlayerAction::Move) {
-                    input.axis_pair(PlayerAction::Move).unwrap().xy()
-                } else {
-                    Vec2::ZERO
-                };
-
-                // Apply speed
-                dir = dir * stats.movement_speed * time.delta_seconds();
-
-                //Move the player
-                (transform.translation, Some(dir))
-            }
-        })
-        .collect::<Vec<_>>();
-
-    let player_dirs = player_movement_clamper.clamp(player_movements);
-
-    for ((mut state, _, mut transform, mut facing, _), dir) in
-        query.iter_mut().zip(player_dirs.iter())
-    {
-        if let Some(dir) = dir {
-            transform.translation.x += dir.x;
-            transform.translation.y += dir.y;
-
-            //Set the player state and direction
-            if dir.x < 0. {
-                facing.set(Facing::Left);
-            } else if dir.x > 0. {
-                facing.set(Facing::Right);
-            }
+/// An entity's angular velocity.
+///
+/// A positive value means a clockwise rotation and a negative value means couter-clockwise.
+#[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
+#[derive(Component, Deref, DerefMut, Default)]
+pub struct AngularVelocity(pub f32);
 
-            if dir == &Vec2::ZERO {
-                state.set(State::Idle);
-            } else {
-                state.set(State::Running);
-            }
-        }
+impl AngularVelocity {
+    #[allow(unused)] // TODO: Remove when used
+    pub fn with_clockwise(r: f32, clockwise: bool) -> Self {
+        AngularVelocity(r * if clockwise { 0.0 } else { -1.0 })
     }
 }
 
-pub fn move_direction_system(
-    mut query: Query<(&mut Transform, &MoveInDirection)>,
+/// System that applies rotations based on entity torques.
+pub fn angular_velocity_system(
+    mut query: Query<(&mut Transform, &AngularVelocity)>,
     time: Res<Time>,
 ) {
-    for (mut transform, dir) in &mut query.iter_mut() {
-        transform.translation += dir.0.extend(0.) * time.delta_seconds();
+    for (mut transform, torque) in &mut query.iter_mut() {
+        transform.rotation *= Quat::from_rotation_z(**torque * time.delta_seconds());
     }
 }
 
+/// A force that while present continually modified an entity's linear velocity.
 #[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
-#[derive(Component)]
-pub struct MoveInArc {
-    pub radius: Vec2,
-    pub speed: f32,
-    pub angle: f32,
-    pub end_angle: f32,
-    pub inverse_direction: bool,
-    pub origin: Vec2,
-}
-
-pub fn move_in_arc_system(
-    mut query: Query<(&mut Transform, &mut MoveInArc, Entity)>,
-    time: Res<Time>,
-    mut commands: Commands,
-) {
-    for (mut transform, mut arc, entity) in &mut query.iter_mut() {
-        if arc.inverse_direction {
-            arc.angle += time.delta_seconds() * arc.speed;
-
-            if arc.angle >= arc.end_angle {
-                //TODO: Choose between removing the entity or the component
-                // commands.entity(entity).despawn();
-                commands.entity(entity).insert(DespawnMarker);
-                // commands.entity(entity).remove::<MoveInArc>();
-            }
-        } else {
-            arc.angle -= time.delta_seconds() * arc.speed;
-            if arc.angle <= arc.end_angle {
-                // commands.entity(entity).despawn();
-                commands.entity(entity).insert(DespawnMarker);
-                // commands.entity(entity).remove::<MoveInArc>();
-            }
-        }
-
-        let dir = Vec2::new(
-            arc.angle.to_radians().cos(),
-            arc.angle.to_radians().sin(),
-        )
-        // .normalize()
-            * arc.radius;
+#[derive(Component, Deref, DerefMut, Default, Clone, Copy)]
+pub struct Force(pub Vec2);
 
-        transform.translation.x = arc.origin.x + dir.x;
-        transform.translation.y = arc.origin.y + dir.y;
+// Applies forces to linear velocities
+pub fn force_system(mut query: Query<(&mut LinearVelocity, &Force)>, time: Res<Time>) {
+    for (mut velocity, force) in &mut query.iter_mut() {
+        **velocity += **force * time.delta_seconds();
     }
 }
 
+/// A force that while present continually modified an entity's angular velocity
 #[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
-#[derive(Component)]
-pub struct Rotate {
-    pub speed: f32,
-    pub to_right: bool,
-}
-
-pub fn rotate_system(mut query: Query<(&mut Transform, &Rotate)>, time: Res<Time>) {
-    for (mut transform, rotate) in &mut query.iter_mut() {
-        let rotation_factor = match rotate.to_right {
-            true => -1.,
-            false => 1.,
-        };
+#[derive(Component, Deref, DerefMut, Default, Clone, Copy)]
+pub struct Torque(pub f32);
 
-        transform.rotation *=
-            Quat::from_rotation_z(rotation_factor * rotate.speed * time.delta_seconds());
+// Applies torques to angular velocities
+pub fn torque_system(mut query: Query<(&mut AngularVelocity, &Torque)>, time: Res<Time>) {
+    for (mut velocity, torque) in &mut query.iter_mut() {
+        **velocity += **torque * time.delta_seconds();
     }
 }
 
-/// Target belonging to an enemy (therefore, the player).
-/// The attack distance is for randomization purposes, and it's the distance that triggers the
-/// attack. More precisely, it's the max distance - if the enemy finds itself at a smaller
-/// distance, it will attack.
+// (Moving) bondary before which, the players can't go back.
 #[derive(Component)]
-pub struct Target {
-    pub position: Vec2,
-    pub attack_distance: f32,
-}
+pub struct LeftMovementBoundary(f32);
 
-pub fn move_to_target(
-    mut query: Query<(
-        Entity,
-        &mut Transform,
-        &Stats,
-        &Target,
-        &mut State,
-        &mut Facing,
-    )>,
-    mut commands: Commands,
-    time: Res<Time>,
-    mut event_writer: EventWriter<ArrivedEvent>,
-) {
-    for (entity, mut transform, stats, target, mut state, mut facing) in query.iter_mut() {
-        if *state == State::Idle || *state == State::Running {
-            let translation_old = transform.translation;
-            transform.translation += (target.position.extend(0.) - translation_old).normalize()
-                * stats.movement_speed
-                * time.delta_seconds();
-
-            let target_distance = transform.translation.truncate().distance(target.position);
-
-            if target_distance <= target.attack_distance {
-                // Note that the target includes an offset, so this can still not point to the
-                // player.
-
-                *facing = if target.position.x > transform.translation.x {
-                    Facing::Right
-                } else {
-                    Facing::Left
-                };
-
-                commands.entity(entity).remove::<Target>();
-                *state = State::Idle;
-                event_writer.send(ArrivedEvent(entity))
-            } else {
-                *facing = if transform.translation.x > translation_old.x {
-                    Facing::Right
-                } else {
-                    Facing::Left
-                };
-
-                *state = State::Running;
-            }
-        }
+impl Default for LeftMovementBoundary {
+    fn default() -> Self {
+        Self(-LEFT_BOUNDARY_MAX_DISTANCE)
     }
 }
 
+/// Updates player left movement boundary
 pub fn update_left_movement_boundary(
     query: Query<&Transform, With<Player>>,
     mut boundary: ResMut<LeftMovementBoundary>,
@@ -305,110 +146,86 @@ pub fn update_left_movement_boundary(
     }
 }
 
-#[derive(SystemParam)]
-pub struct PlayerMovementClamper<'w, 's> {
-    enemy_spawn_locations_query: Query<'w, 's, &'static SpawnLocationX>,
-    level_meta: Res<'w, LevelMeta>,
-    game_meta: Res<'w, GameMeta>,
-    left_movement_boundary: Res<'w, LeftMovementBoundary>,
-}
+/// Constrains player movement based on multiple factors
+fn constrain_player_movement(
+    enemy_spawn_locations_query: Query<&'static SpawnLocationX>,
+    level_meta: Res<LevelMeta>,
+    game_meta: Res<GameMeta>,
+    left_movement_boundary: Res<LeftMovementBoundary>,
+    mut players: Query<(&Transform, &mut LinearVelocity), With<Player>>,
+    time: Res<Time>,
+) {
+    let dt = time.delta_seconds();
 
-impl<'w, 's> PlayerMovementClamper<'w, 's> {
-    /// Returns the direction vectors, with X/Y clamping.
-    ///
-    /// Not a system, but a utility method!.
-    ///
-    /// player_movements: array of (location, direction vector).
-    /// enemy_spawn_location_query: spawn locations of _alive_ enemies.
-    ///
-    /// WATCH OUT! All players must be included, even if they don't move, in which case, pass
-    /// None as direction. This is because clamping is based on the position of _all_ the
-    /// players.
-    /// It's possible to pass an empty array; this can happen if the system doesn't guard the case
-    /// where all the players are dead; an empty array will be returned.
-    pub fn clamp(&self, mut player_movements: Vec<(Vec3, Option<Vec2>)>) -> Vec<Option<Vec2>> {
-        // In the first pass, we check the camera stop points. If a player is moving across a stop
-        // point, all the enemies up to that point must have been defeated, in order to move.
-
-        let current_stop_point = self.level_meta.stop_points.iter().find(|point_x| {
-            player_movements.iter().any(|(location, dir)| {
-                if let Some(dir) = dir {
-                    location.x < **point_x && **point_x <= location.x + dir.x
-                } else {
-                    false
-                }
-            })
-        });
+    // Collect player positions and velocities
+    let mut player_velocities = players
+        .iter_mut()
+        .map(|(transform, vel)| (transform.translation, vel))
+        .collect::<Vec<_>>();
 
-        if let Some(current_stop_point) = current_stop_point {
-            let any_enemy_behind_stop_point = self
-                .enemy_spawn_locations_query
-                .iter()
-                .any(|SpawnLocationX(spawn_x)| spawn_x <= current_stop_point);
-
-            if any_enemy_behind_stop_point {
-                for (location, movement) in player_movements.iter_mut() {
-                    if let Some(movement) = movement.as_mut() {
-                        // Can be simplified, but it's harder to understand.
-                        if location.x + movement.x > *current_stop_point {
-                            movement.x = 0.;
-                        }
-                    }
+    // Identify the current stop point
+    let current_stop_point = level_meta.stop_points.iter().find(|point_x| {
+        player_velocities
+            .iter()
+            .any(|(location, dir)| location.x < **point_x && **point_x <= location.x + dir.x)
+    });
+
+    // If there is a current stop point
+    if let Some(current_stop_point) = current_stop_point {
+        let any_enemy_behind_stop_point = enemy_spawn_locations_query
+            .iter()
+            .any(|SpawnLocationX(spawn_x)| spawn_x <= current_stop_point);
+
+        // Prevent movement beyond the stop point if there are enemies not yet defeated behind the
+        // stop point.
+        if any_enemy_behind_stop_point {
+            for (location, velocity) in player_velocities.iter_mut() {
+                // Can be simplified, but it's harder to understand.
+                if location.x + velocity.x * dt > *current_stop_point {
+                    velocity.x = 0.;
                 }
             }
         }
+    }
 
-        // Then, we perform the absolute clamping (screen top/left/bottom), and we collect the data
-        // required for the relative clamping.
-
-        let mut min_new_player_x = f32::MAX;
+    // Then, we perform the absolute clamping (screen top/left/bottom), and we collect the data
+    // required for the relative clamping.
 
-        let player_movements = player_movements
-            .iter()
-            .map(|(location, movement)| {
-                let new_movement = movement.map(|mut movement| {
-                    let new_x = location.x + movement.x;
+    let mut min_new_player_x = f32::MAX;
 
-                    if new_x < self.left_movement_boundary.0 {
-                        movement.x = 0.;
-                    }
+    #[allow(clippy::needless_collect)] // False alarm
+    let velocities = player_velocities
+        .into_iter()
+        .map(|(location, mut velocity)| {
+            let new_x = location.x + velocity.x * dt;
 
-                    //Restrict player to the ground
-                    let new_y = location.y + movement.y + consts::GROUND_OFFSET;
+            if new_x < left_movement_boundary.0 {
+                velocity.x = 0.;
+            }
 
-                    if new_y >= consts::MAX_Y || new_y <= consts::MIN_Y {
-                        movement.y = 0.;
-                    }
+            //Restrict player to the ground
+            let new_y = location.y + velocity.y * dt + consts::GROUND_OFFSET;
 
-                    (movement, new_x)
-                });
+            if new_y >= consts::MAX_Y || new_y <= consts::MIN_Y {
+                velocity.y = 0.;
+            }
 
-                if let Some((_, new_x)) = new_movement {
-                    min_new_player_x = min_new_player_x.min(new_x);
-                } else {
-                    min_new_player_x = min_new_player_x.min(location.x);
-                }
+            let new_velocity = (velocity, new_x);
 
-                (location, new_movement)
-            })
-            .collect::<Vec<_>>();
+            min_new_player_x = min_new_player_x.min(new_x);
 
-        // Then, we perform the clamping of the players relative to each other.
+            (location, new_velocity)
+        })
+        .collect::<Vec<_>>();
 
-        let max_players_x_distance =
-            LEFT_BOUNDARY_MAX_DISTANCE + self.game_meta.camera_move_right_boundary;
+    // Then, we perform the clamping of the players relative to each other.
+    let max_players_x_distance = LEFT_BOUNDARY_MAX_DISTANCE + game_meta.camera_move_right_boundary;
 
-        player_movements
-            .iter()
-            .map(|(_, player_movement)| {
-                player_movement.map(|(player_dir, new_player_x)| {
-                    if new_player_x > min_new_player_x + max_players_x_distance {
-                        Vec2::ZERO
-                    } else {
-                        player_dir
-                    }
-                })
-            })
-            .collect::<Vec<_>>()
-    }
+    velocities
+        .into_iter()
+        .for_each(|(_, (mut velocity, new_player_x))| {
+            if new_player_x > min_new_player_x + max_players_x_distance {
+                **velocity = Vec2::ZERO
+            }
+        });
 }
diff --git a/src/state.rs b/src/state.rs
deleted file mode 100644
index d9b2a39c..00000000
--- a/src/state.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use bevy::prelude::{App, Component, CoreStage, Plugin, Query};
-use serde::Deserialize;
-
-use crate::animation::Animation;
-
-pub struct StatePlugin;
-
-impl Plugin for StatePlugin {
-    fn build(&self, app: &mut App) {
-        app.add_system_to_stage(CoreStage::PostUpdate, return_to_idle);
-    }
-}
-
-#[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
-#[derive(Component, Debug, PartialEq, Eq, Hash, Clone, Copy, Deserialize)]
-#[serde(try_from = "String")]
-pub enum State {
-    Idle,
-    Running,
-    Attacking,
-    KnockedLeft,
-    KnockedRight,
-    // Hitstun,
-    Waiting,
-    Dying,
-}
-
-impl TryFrom<String> for State {
-    type Error = &'static str;
-
-    fn try_from(value: String) -> Result<Self, Self::Error> {
-        Ok(match value.as_str() {
-            "idle" => State::Idle,
-            "running" => State::Running,
-            "attacking" => State::Attacking,
-            "knocked_left" => State::KnockedLeft,
-            "knocked_right" => State::KnockedRight,
-            // "hitstun" => State::Hitstun,
-            "waiting" => State::Waiting,
-            "dying" => State::Dying,
-            _ => {
-                return Err("invalid value");
-            }
-        })
-    }
-}
-
-impl State {
-    pub fn set(&mut self, state: State) {
-        *self = state;
-    }
-
-    // pub fn is_knocked(&self) -> bool {
-    //     matches!(self, State::KnockedLeft | State::KnockedRight)
-    // }
-}
-
-impl Default for State {
-    fn default() -> Self {
-        State::Idle
-    }
-}
-
-fn return_to_idle(mut query: Query<(&mut State, &Animation)>) {
-    for (mut state, animation) in query.iter_mut() {
-        if !animation.is_repeating() && animation.is_finished() && *state != State::Dying {
-            state.set(State::Idle);
-        }
-    }
-}
diff --git a/src/ui.rs b/src/ui.rs
index 17a79cdd..c61f0cd2 100644
--- a/src/ui.rs
+++ b/src/ui.rs
@@ -25,7 +25,14 @@ impl Plugin for UIPlugin {
             .add_enter_system(GameState::MainMenu, audio::play_menu_music)
             .add_exit_system(GameState::MainMenu, main_menu::despawn_main_menu_background)
             .add_exit_system(GameState::MainMenu, audio::stop_menu_music)
-            .add_system(hud::render_hud.run_in_state(GameState::InGame))
+            .add_system(unpause.run_in_state(GameState::Paused))
+            .add_system_set(
+                ConditionSet::new()
+                    .run_in_state(GameState::InGame)
+                    .with_system(hud::render_hud)
+                    .with_system(pause)
+                    .into(),
+            )
             .add_system(update_egui_fonts)
             .add_system(update_ui_scale.run_if_resource_exists::<GameMeta>())
             .add_system_set(
@@ -43,6 +50,22 @@ impl Plugin for UIPlugin {
     }
 }
 
+/// Transition game to pause state
+fn pause(mut commands: Commands, input: Query<&ActionState<MenuAction>>) {
+    let input = input.single();
+    if input.just_pressed(MenuAction::Pause) {
+        commands.insert_resource(NextState(GameState::Paused));
+    }
+}
+
+// Transition game out of paused state
+fn unpause(mut commands: Commands, input: Query<&ActionState<MenuAction>>) {
+    let input = input.single();
+    if input.just_pressed(MenuAction::Pause) {
+        commands.insert_resource(NextState(GameState::InGame));
+    }
+}
+
 /// Resource that stores which ui widgets are adjacent to which other widgets.
 ///
 /// This is used to figure out which widget to focus on next when you press a direction on the
diff --git a/src/ui/hud.rs b/src/ui/hud.rs
index 7b00e10b..fa910ce5 100644
--- a/src/ui/hud.rs
+++ b/src/ui/hud.rs
@@ -4,6 +4,7 @@ use bevy::prelude::*;
 use bevy_egui::{egui, EguiContext};
 
 use crate::{
+    damage::Health,
     metadata::{FighterMeta, GameMeta},
     player::PlayerIndex,
     ui::widgets::{bordered_frame::BorderedFrame, progress_bar::ProgressBar, EguiUIExt},
@@ -12,7 +13,7 @@ use crate::{
 
 pub fn render_hud(
     mut egui_context: ResMut<EguiContext>,
-    players: Query<(&PlayerIndex, &Stats, &Handle<FighterMeta>), With<Player>>,
+    players: Query<(&PlayerIndex, &Stats, &Health, &Handle<FighterMeta>), With<Player>>,
     game: Res<GameMeta>,
     fighter_assets: Res<Assets<FighterMeta>>,
 ) {
@@ -28,16 +29,16 @@ pub fn render_hud(
 
     // Collect player info
     let mut players = players.iter().collect::<Vec<_>>();
-    players.sort_by_key(|(player_i, _, _)| player_i.0);
+    players.sort_by_key(|(player_i, _, _, _)| player_i.0);
 
     let player_infos = players
         .into_iter()
-        .filter_map(|(_, stats, fighter_handle)| {
+        .filter_map(|(_, stats, health, fighter_handle)| {
             fighter_assets.get(fighter_handle).map(|fighter| {
                 let portrait_size = fighter.hud.portrait.image_size;
                 PlayerInfo {
                     name: fighter.name.clone(),
-                    life: stats.health as f32 / fighter.stats.health as f32,
+                    life: **health as f32 / stats.max_health as f32,
                     portrait_texture_id: egui_context
                         .add_image(fighter.hud.portrait.image_handle.clone_weak()),
                     portrait_size: egui::Vec2::new(portrait_size.x, portrait_size.y),
diff --git a/src/y_sort.rs b/src/y_sort.rs
deleted file mode 100644
index f5d964bd..00000000
--- a/src/y_sort.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use bevy::prelude::{Component, Query, Transform};
-
-#[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
-#[derive(Component, Default)]
-pub struct YSort(f32);
-
-pub fn y_sort(mut query: Query<(&mut Transform, &YSort)>) {
-    for (mut transform, ysort) in query.iter_mut() {
-        transform.translation.z = ysort.0 - transform.translation.y;
-    }
-}