diff --git a/.cargo/config.toml b/.cargo/config.toml
index 9079b92..8099b7a 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,4 +1,4 @@
 [target.x86_64-unknown-linux-gnu]
 linker = "clang"
 # TODO: Share generics when using nightly no longer causes an undefined symbol error
-rustflags = ["-C", "link-arg=-fuse-ld=/usr/bin/mold", "-Zshare-generics=y"]
+rustflags = ["-C", "link-arg=-fuse-ld=/usr/bin/mold"] #, "-Zshare-generics=y"]
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 48ad4dc..424d2c8 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -15,13 +15,13 @@
       "cwd": "${workspaceFolder}",
       "env": {
         "CARGO_MANIFEST_DIR": "${workspaceFolder}",
-        "LD_LIBRARY_PATH": "${workspaceFolder}/target/debug/deps:${env:HOME}/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib"
+        "LD_LIBRARY_PATH": "${workspaceFolder}/target/debug/deps:${env:HOME}/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib"
       },
       "presentation": {
         "hidden": false,
         "group": "run",
         "order": 1
-      },
+      }
     },
     {
       "type": "lldb",
@@ -34,14 +34,13 @@
       "cwd": "${workspaceFolder}",
       "env": {
         "CARGO_MANIFEST_DIR": "${workspaceFolder}",
-        "LD_LIBRARY_PATH": "${workspaceFolder}/target/debug/deps:${env:HOME}/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib"
+        "LD_LIBRARY_PATH": "${workspaceFolder}/target/debug/deps:${env:HOME}/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib"
       },
       "presentation": {
         "hidden": false,
         "group": "run",
         "order": 2
-      },
-	  "suppressMultipleSessionWarning": true,
+      }
     },
     {
       "type": "lldb",
@@ -54,14 +53,13 @@
       "cwd": "${workspaceFolder}",
       "env": {
         "CARGO_MANIFEST_DIR": "${workspaceFolder}",
-        "LD_LIBRARY_PATH": "${workspaceFolder}/target/debug/deps:${env:HOME}/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib"
+        "LD_LIBRARY_PATH": "${workspaceFolder}/target/debug/deps:${env:HOME}/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib"
       },
       "presentation": {
         "hidden": false,
         "group": "run",
         "order": 2
-      },
-	  "suppressMultipleSessionWarning": true,
-    },
-  ],
+      }
+    }
+  ]
 }
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 8ebe79c..7d9ea05 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -15,12 +15,6 @@
     "RUSTFLAGS": "-Clinker=clang -Clink-arg=-fuse-ld=lld"
   },
   "rust-analyzer.check.command": "clippy", // "check", //
-//   "rust-analyzer.check.overrideCommand": [
-//     "bevy_lint",
-//     "--workspace",
-//     "--all-targets",
-//     "--message-format=json-diagnostic-rendered-ansi",
-//   ],
   "rust-analyzer.cargo.targetDir": true,
   "cSpell.words": [
     "Backquote",
diff --git a/Cargo.lock b/Cargo.lock
index 6780b49..90ccc97 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1623,9 +1623,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.48"
+version = "4.5.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2134bb3ea021b78629caa971416385309e0131b351b25e01dc16fb54e1b5fae"
+checksum = "fd60e63e9be68e5fb56422e397cf9baddded06dae1d2e523401542383bc72a9f"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -1633,9 +1633,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.48"
+version = "4.5.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2ba64afa3c0a6df7fa517765e31314e983f51dda798ffba27b988194fb65dc9"
+checksum = "89cc6392a1f72bbeb820d71f32108f61fdaf18bc526e1d23954168a67759ef51"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1645,9 +1645,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.47"
+version = "4.5.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbfd7eae0b0f1a6e63d4b13c9c478de77c2eb546fba158ad50b4203dc24b9f9c"
+checksum = "09176aae279615badda0765c0c0b3f6ed53f4709118af73cf4655d85d1530cd7"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -1923,7 +1923,7 @@ dependencies = [
  "clap",
  "crossbeam-channel",
  "log",
- "rand 0.9.2",
+ "rand 0.9.1",
  "uuid",
  "wyrand",
 ]
@@ -2680,9 +2680,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.28"
+version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 
 [[package]]
 name = "malloc_buf"
@@ -3549,9 +3549,9 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.2"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.3",
@@ -4480,9 +4480,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.18.1"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2"
+checksum = "3cf4199d1e5d15ddd86a694e4d0dffa9c323ce759fea589f00fef9d81cc1931d"
 dependencies = [
  "getrandom 0.3.3",
  "js-sys",
diff --git a/Cargo.toml b/Cargo.toml
index d8468b5..a48d89a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,32 +5,12 @@ edition = "2024"
 description = "Experimental distributed physics system"
 license = "AGPL-3.0-only"
 
-[lints.rust]
-# Mark `bevy_lint` as a valid `cfg`, as it is set when the Bevy linter runs.
-unexpected_cfgs = { level = "warn", check-cfg = ["cfg(bevy_lint)"] }
-
-[lints.clippy]
-# Bevy supplies arguments to systems via dependency injection, so it's natural for systems to
-# request more than 7 arguments, which would undesirably trigger this lint.
-too_many_arguments = "allow"
-# Queries may access many components, which would undesirably trigger this lint.
-type_complexity = "allow"
-# Make sure macros use their standard braces, such as `[]` for `bevy_ecs::children!`.
-nonstandard_macro_braces = "warn"
-
-[package.metadata.bevy_lint]
-panicking_methods = "deny"
-pedantic = "warn"
-
 [profile.dev]
 opt-level = 1
 
 [profile.dev.package."*"]
 opt-level = 3
 
-[profile.dev.package.wgpu-types]
-debug-assertions = false
-
 [profile.release]
 lto = true
 opt-level = 3
@@ -55,14 +35,14 @@ bevy = { version = "0.16.1", default-features = false, features = [
 	"wayland",
 ] }
 bevy_rand = { version = "0.11.0", features = ["wyrand", "std"] }
-clap = { version = "4.5.48", features = ["derive"] }
+clap = { version = "4.5.39", features = ["derive"] }
 crossbeam-channel = "0.5.15"
-log = { version = "0.4.28", features = ["release_max_level_warn"] }
-rand = { version = "0.9.2", default-features = false, features = [
+log = { version = "0.4.27", features = ["release_max_level_warn"] }
+rand = { version = "0.9.1", default-features = false, features = [
 	"std",
 	"thread_rng",
 ] }
-uuid = { version = "1.18.1", features = ["v4"] }
+uuid = { version = "1.17.0", features = ["v4"] }
 wyrand = "0.3.2"
 
 [features]
diff --git a/clippy.toml b/clippy.toml
deleted file mode 100644
index af8b632..0000000
--- a/clippy.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-# Require `bevy_ecs::children!` to use `[]` braces, instead of `()` or `{}`.
-standard-macro-braces = [{ name = "children", brace = "[" }]
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 5d56faf..c672579 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,2 +1,3 @@
 [toolchain]
-channel = "nightly"
+# TODO: Switch back to nightly when it no longer causes an undefined symbol error
+channel = "stable" # "nightly"
diff --git a/src/game/net.rs b/src/game/net.rs
index c52f85f..8e43e3f 100644
--- a/src/game/net.rs
+++ b/src/game/net.rs
@@ -2,16 +2,13 @@ use bevy::prelude::*;
 
 use crate::net::prelude::*;
 
-pub fn handle_new_peer(new_peers: Query<&PeerID, Added<Peer>>) {
+pub fn handle_new_peer(new_peers: Query<&Peer, Added<Peer>>) {
     for peer in new_peers {
         info!("Peer {} was added", peer.id);
     }
 }
 
-pub fn handle_deleted_peer(
-    mut old_peers: RemovedComponents<Peer>,
-    peers: Query<&PeerID>,
-) -> Result {
+pub fn handle_deleted_peer(mut old_peers: RemovedComponents<Peer>, peers: Query<&Peer>) -> Result {
     for entity in old_peers.read() {
         if let Ok(peer) = peers.get(entity) {
             info!("Peer {} was removed", peer.id);
@@ -23,7 +20,7 @@ pub fn handle_deleted_peer(
 }
 
 pub fn handle_incoming_packets(mut packets: EventReader<InboundPacket>) {
-    for InboundPacket(packet) in packets.read() {
-        info!("Packet received: {:?}", packet.message);
+    for packet in packets.read() {
+        info!("Packet received: {:?}", packet.0.message);
     }
 }
diff --git a/src/game/plugin.rs b/src/game/plugin.rs
index a7fdf48..d879c20 100644
--- a/src/game/plugin.rs
+++ b/src/game/plugin.rs
@@ -13,10 +13,7 @@ use super::{
         check_for_seed, setup_balls, setup_camera, setup_from_seed, setup_player, setup_walls,
     },
     state::AppState,
-    ui::{
-        setup_peer_ui, setup_potential_peer_ui, setup_seed_ui, update_peer_ui,
-        update_peer_ui_timings, update_potential_peer_ui, update_seed_ui,
-    },
+    ui::{setup_peer_ui, setup_seed_ui, update_peer_ui, update_peer_ui_timings, update_seed_ui},
 };
 
 #[derive(Debug, Clone, Copy)]
@@ -58,20 +55,11 @@ impl GamePlugin {
 impl Plugin for GamePlugin {
     fn build(&self, app: &mut App) {
         app.add_plugins((
-            NetIOPlugin::maybe_peer(self.port, self.source.try_to_address()),
-            distribution_plugin::<Seed>,
+            NetIOPlugin::new(self.port, self.source.try_to_address()),
             PhysicsPlugins::default().with_length_unit(50.0),
         ))
         .init_state::<AppState>()
-        .add_systems(
-            Startup,
-            (
-                setup_camera,
-                setup_seed_ui,
-                setup_peer_ui,
-                setup_potential_peer_ui,
-            ),
-        )
+        .add_systems(Startup, (setup_camera, setup_seed_ui, setup_peer_ui))
         .add_systems(
             OnEnter(AppState::InGame),
             (
@@ -87,7 +75,8 @@ impl Plugin for GamePlugin {
                     handle_new_peer,
                     handle_deleted_peer,
                     handle_incoming_packets,
-                ),
+                )
+                    .run_if(in_state(NetworkState::MultiPlayer)),
             ),
         )
         .add_systems(
@@ -96,15 +85,14 @@ impl Plugin for GamePlugin {
                 ((move_player, move_camera).chain(), zoom_camera)
                     .run_if(in_state(AppState::InGame)),
                 update_seed_ui,
-                (
-                    update_peer_ui,
-                    update_peer_ui_timings,
-                    update_potential_peer_ui,
-                ),
+                (update_peer_ui, update_peer_ui_timings)
+                    .run_if(in_state(NetworkState::MultiPlayer)),
                 quit.run_if(input_pressed(KeyCode::KeyQ)),
             ),
         );
 
+        Seed::register(app);
+
         match self.source {
             DataSource::Address(peer) => {
                 info!("Will retrieve seed from peer => {peer}");
diff --git a/src/game/seed.rs b/src/game/seed.rs
index d95a957..085c10c 100644
--- a/src/game/seed.rs
+++ b/src/game/seed.rs
@@ -61,7 +61,7 @@ impl From<Seed> for Vec<u8> {
 impl TryFrom<Vec<u8>> for Seed {
     type Error = TryFromSliceError;
 
-    fn try_from(value: Vec<u8>) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
         Ok(TryInto::<[u8; 8]>::try_into(value.as_slice())?.into())
     }
 }
diff --git a/src/game/ui.rs b/src/game/ui.rs
index 60f17a1..391a39f 100644
--- a/src/game/ui.rs
+++ b/src/game/ui.rs
@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 
-use crate::net::prelude::{Peer, PeerID, PeerReceiveTiming, PeerSendTiming, PotentialPeers};
+use crate::net::prelude::{Peer, PeerReceiveTiming, PeerSendTiming};
 
 use super::seed::Seed;
 
@@ -54,11 +54,11 @@ pub fn setup_peer_ui(mut commands: Commands) {
 }
 
 #[derive(Component)]
-pub struct UIPeerID(Entity);
+pub struct PeerID(Entity);
 
 pub fn update_peer_ui(
     ui: Query<(Entity, &Children), With<PeerUI>>,
-    rows: Query<&UIPeerID>,
+    rows: Query<&PeerID>,
     added: Query<Entity, Added<Peer>>,
     mut removed: RemovedComponents<Peer>,
     mut commands: Commands,
@@ -67,14 +67,14 @@ pub fn update_peer_ui(
         for addition in added {
             commands
                 .entity(table)
-                .with_child((Text::new("---- ---- ----"), UIPeerID(addition)));
+                .with_child((Text::new("---- ---- ----"), PeerID(addition)));
         }
         for removal in removed.read() {
             for child in children {
-                if let Ok(&UIPeerID(id)) = rows.get(*child)
-                    && id == removal
-                {
-                    commands.entity(*child).despawn();
+                if let Ok(id) = rows.get(*child) {
+                    if id.0 == removal {
+                        commands.entity(*child).despawn();
+                    }
                 }
             }
         }
@@ -82,12 +82,12 @@ pub fn update_peer_ui(
 }
 
 pub fn update_peer_ui_timings(
-    rows: Query<(&mut Text, &UIPeerID)>,
-    peers: Query<(&PeerID, &PeerReceiveTiming, &PeerSendTiming)>,
+    rows: Query<(&mut Text, &PeerID)>,
+    peers: Query<(&Peer, &PeerReceiveTiming, &PeerSendTiming)>,
     time: Res<Time>,
 ) {
-    for (mut row, &UIPeerID(id)) in rows {
-        if let Ok((peer, recv, send)) = peers.get(id) {
+    for (mut row, id) in rows {
+        if let Ok((peer, recv, send)) = peers.get(id.0) {
             **row = format!(
                 "{} {:.2} {:.2}",
                 peer.id,
@@ -97,34 +97,3 @@ pub fn update_peer_ui_timings(
         }
     }
 }
-
-#[derive(Component, Debug)]
-pub struct PotentialPeerUI;
-
-pub fn setup_potential_peer_ui(mut commands: Commands) {
-    commands
-        .spawn((
-            Text::new("Potential peers:"),
-            Node {
-                position_type: PositionType::Absolute,
-                bottom: Val::Px(5.0),
-                right: Val::Px(5.0),
-                ..default()
-            },
-        ))
-        .with_child((TextSpan::new(""), PotentialPeerUI));
-}
-
-pub fn update_potential_peer_ui(
-    potential_peers: Res<PotentialPeers>,
-    text: Query<&mut TextSpan, With<PotentialPeerUI>>,
-) {
-    for mut span in text {
-        **span = potential_peers
-            .addresses
-            .iter()
-            .map(|addr| addr.to_string())
-            .collect::<Vec<String>>()
-            .join("\n");
-    }
-}
diff --git a/src/lib.rs b/src/lib.rs
index bce6a14..0c637a8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -15,7 +15,7 @@ use game::prelude::*;
 /// Also functions as a Bevy plugin to pass the configuration into the app.
 #[derive(Parser)]
 #[command(version, about)]
-pub struct AppSettingsPlugin {
+pub struct AppSettings {
     #[command(flatten)]
     source: Source,
 
@@ -36,7 +36,7 @@ struct Source {
     connect: Option<SocketAddr>,
 }
 
-impl Plugin for AppSettingsPlugin {
+impl Plugin for AppSettings {
     fn build(&self, app: &mut App) {
         app.insert_resource(Gravity(Vector::ZERO)).add_plugins((
             DefaultPlugins.set(WindowPlugin {
diff --git a/src/main.rs b/src/main.rs
index 23da80f..ffb5f8a 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,8 +1,8 @@
 use bevy::prelude::{App, AppExit};
 use clap::Parser;
 
-use distributed_physics_test::AppSettingsPlugin;
+use distributed_physics_test::AppSettings;
 
 fn main() -> AppExit {
-    App::new().add_plugins(AppSettingsPlugin::parse()).run()
+    App::new().add_plugins(AppSettings::parse()).run()
 }
diff --git a/src/net/distribution.rs b/src/net/distribution.rs
index 943c435..161ea1a 100644
--- a/src/net/distribution.rs
+++ b/src/net/distribution.rs
@@ -2,32 +2,48 @@ use bevy::prelude::*;
 
 use super::{
     packet::{InboundPacket, OutboundPacket, Packet},
-    peer::{Peer, PeerID},
+    peer::Peer,
+    state::NetworkState,
 };
 
 fn spawner<T: TryFrom<Vec<u8>> + Component>(
     mut inbound: EventReader<InboundPacket>,
     mut commands: Commands,
 ) {
-    for InboundPacket(packet) in inbound.read() {
-        if let Ok(entity) = T::try_from(packet.message.clone()) {
+    for packet in inbound.read() {
+        if let Ok(entity) = T::try_from(packet.0.message.clone()) {
             commands.spawn(entity);
         }
     }
 }
 
 fn sender<T: Into<Vec<u8>> + Component + Clone>(
-    peers: Query<&PeerID, Added<Peer>>,
+    peers: Query<&Peer, Added<Peer>>,
     entities: Query<&T>,
     mut outbound: EventWriter<OutboundPacket>,
 ) {
     for peer in peers {
         for entity in entities {
-            outbound.write(Packet::create((*entity).clone().into(), peer.id));
+            outbound.write(OutboundPacket(Packet::new(
+                (*entity).clone().into(),
+                peer.id,
+            )));
         }
     }
 }
 
-pub fn distribution_plugin<T: Into<Vec<u8>> + TryFrom<Vec<u8>> + Component + Clone>(app: &mut App) {
-    app.add_systems(FixedUpdate, (sender::<T>, spawner::<T>));
+pub trait Networked: Into<Vec<u8>> + TryFrom<Vec<u8>> + Component + Clone {
+    fn register(app: &mut App);
+}
+
+impl<T> Networked for T
+where
+    T: Into<Vec<u8>> + TryFrom<Vec<u8>> + Component + Clone,
+{
+    fn register(app: &mut App) {
+        app.add_systems(
+            FixedUpdate,
+            (sender::<T>, spawner::<T>).run_if(in_state(NetworkState::MultiPlayer)),
+        );
+    }
 }
diff --git a/src/net/heartbeat.rs b/src/net/heartbeat.rs
deleted file mode 100644
index 671fe4a..0000000
--- a/src/net/heartbeat.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use std::time::Duration;
-
-use bevy::prelude::*;
-
-use crate::net::{packet::PacketType, peer::PotentialPeers};
-
-use super::{
-    io::{Config, format_message},
-    packet::{OutboundPacket, Packet},
-    peer::{Peer, PeerChangeEvent, PeerID, PeerReceiveTiming, PeerSendTiming},
-    queues::NetworkSend,
-};
-
-const PING_FREQUENCY: Duration = Duration::from_secs(3);
-const MISSED_PINGS: u32 = 3;
-
-// TODO: Perhaps this needs a state rethink, is Single/Multiplayer actually useful vs Disconnected, Connecting, Connected?
-// Would also help to state-scope some of these things, like InitialAddresses vs PeerMap
-pub fn heartbeat(
-    peers: Query<(&PeerID, &PeerSendTiming)>,
-    time: Res<Time>,
-    mut outbound: EventWriter<OutboundPacket>,
-) -> Result {
-    for (peer, last) in peers {
-        // Allow for 2 consecutive missed heartbeats without timing out
-        if last.time() + PING_FREQUENCY > time.elapsed() {
-            continue;
-        }
-        outbound.write(Packet::create(Vec::new(), peer.id));
-    }
-    Ok(())
-}
-
-pub fn timeout(
-    peers: Query<(&PeerID, &PeerReceiveTiming), With<Peer>>, // I mean... With<Peer> is inherent, but I guess I'll keep it as that might change
-    time: Res<Time>,
-    mut delete: EventWriter<PeerChangeEvent>,
-) {
-    for (peer, last) in peers {
-        if last.time() + PING_FREQUENCY * MISSED_PINGS < time.elapsed() {
-            warn!("Peer {} timed out", peer.id);
-            delete.write(PeerChangeEvent::new(peer.id, None));
-        }
-    }
-}
-
-#[derive(Debug, Resource)]
-pub struct PotentialPeerTimer {
-    timer: Timer,
-}
-
-impl Default for PotentialPeerTimer {
-    fn default() -> Self {
-        Self {
-            timer: Timer::new(PING_FREQUENCY, TimerMode::Repeating),
-        }
-    }
-}
-
-pub fn ping_potential_peers(
-    mut timer: ResMut<PotentialPeerTimer>,
-    time: Res<Time>,
-    peers: Res<PotentialPeers>,
-    to_socket: Res<NetworkSend>,
-    config: Res<Config>,
-) -> Result {
-    timer.timer.tick(time.delta());
-    if timer.timer.finished() {
-        for peer in &peers.addresses {
-            to_socket.send(
-                format_message(&Vec::new(), PacketType::Peer, config.id),
-                *peer,
-            )?;
-        }
-    }
-    Ok(())
-}
diff --git a/src/net/io.rs b/src/net/io.rs
index 3e7aca7..25774b6 100644
--- a/src/net/io.rs
+++ b/src/net/io.rs
@@ -1,29 +1,16 @@
+use std::time::Duration;
+
 use bevy::prelude::*;
 use uuid::Uuid;
 
-use crate::net::packet::PacketType;
+use crate::net::peer::PotentialPeer;
 
 use super::{
     packet::{InboundPacket, OutboundPacket, Packet},
-    peer::{PeerChangeEvent, PeerData, PeerMap, PeerReceiveTiming, PeerSendTiming},
+    peer::{Peer, PeerChangeEvent, PeerData, PeerMap, PeerReceiveTiming, PeerSendTiming},
     queues::{NetworkReceive, NetworkSend},
 };
 
-#[derive(Debug, Resource)]
-pub struct Config {
-    pub id: Uuid,
-}
-
-impl Default for Config {
-    fn default() -> Self {
-        Self { id: Uuid::new_v4() }
-    }
-}
-
-pub fn format_message(data: &Vec<u8>, variant: PacketType, id: Uuid) -> Vec<u8> {
-    [data.as_slice(), &[variant as u8], id.as_bytes()].concat()
-}
-
 pub fn handle_network_input(
     from_socket: Res<NetworkReceive>,
     peer_map: Res<PeerMap>,
@@ -32,24 +19,26 @@ pub fn handle_network_input(
     time: Res<Time>,
     mut change_peer: EventWriter<PeerChangeEvent>,
 ) -> Result {
-    for (message, address) in from_socket.iter() {
-        match Packet::try_from(message) {
-            Ok(packet) => {
-                // TODO: Handle packet variant
-                if !packet.message.is_empty() {
-                    to_app.write(packet.clone().into());
-                }
-                if let Some(peer_id) = peer_map.get(&packet.peer) {
-                    let (peer, mut last) = peers.get_mut(*peer_id)?;
-                    last.update(&time);
-                    if address == peer.addr {
-                        continue;
-                    }
-                }
-                change_peer.write(PeerChangeEvent::new(packet.peer, Some(address)));
-            }
-            Err(err) => warn!("Error reading packet: {:?}", err),
+    for (mut message, address) in from_socket.iter() {
+        if message.len() < 16 {
+            return Err(format!(
+                "Message of length {} is not large enough to contain UUID",
+                message.len()
+            )
+            .into());
         }
+        let uuid = Uuid::from_slice(message.split_off(message.len() - 16).as_slice())?;
+        if !message.is_empty() {
+            to_app.write(InboundPacket(Packet::new(message, uuid)));
+        }
+        if let Some(peer_id) = peer_map.get(&uuid) {
+            let (peer, mut last) = peers.get_mut(*peer_id)?;
+            last.update(&time);
+            if address == peer.addr {
+                continue;
+            }
+        }
+        change_peer.write(PeerChangeEvent::new(uuid, Some(address)));
     }
     Ok(())
 }
@@ -58,16 +47,52 @@ pub fn handle_network_output(
     mut from_app: EventReader<OutboundPacket>,
     peer_map: Res<PeerMap>,
     mut peers: Query<(&PeerData, &mut PeerSendTiming)>,
-    config: Res<Config>,
     to_socket: Res<NetworkSend>,
     time: Res<Time>,
 ) -> Result {
-    for OutboundPacket(packet) in from_app.read() {
-        let peer_id = peer_map.try_get(&packet.peer)?;
+    for packet in from_app.read() {
+        let peer_id = peer_map.try_get(&packet.0.peer)?;
         let (peer, mut last) = peers.get_mut(*peer_id)?;
-        let message = format_message(&packet.message, packet.variant, config.id);
+        // Append our UUID for client identification
+        let message = [packet.0.message.as_slice(), peer.me.as_bytes()].concat();
         to_socket.send(message, peer.addr.into())?;
         last.update(&time);
     }
     Ok(())
 }
+
+const TIMEOUT: Duration = Duration::from_secs(10);
+
+pub fn heartbeat(
+    peers: Query<(AnyOf<(&Peer, &PotentialPeer)>, &PeerSendTiming)>,
+    time: Res<Time>,
+    mut outbound: EventWriter<OutboundPacket>,
+) -> Result {
+    for (peer, last) in peers {
+        // Allow for 2 consecutive missed heartbeats without timing out
+        if last.time() + TIMEOUT / 3 > time.elapsed() {
+            continue;
+        }
+        let id = match peer {
+            (None, None) => return Err("No peer identification".into()),
+            (None, Some(potential)) => potential.id,
+            (Some(actual), None) => actual.id,
+            (Some(_), Some(_)) => return Err("Both a potential and actual peer".into()),
+        };
+        outbound.write(OutboundPacket(Packet::new(Vec::new(), id)));
+    }
+    Ok(())
+}
+
+pub fn timeout(
+    peers: Query<(&Peer, &PeerReceiveTiming)>,
+    time: Res<Time>,
+    mut delete: EventWriter<PeerChangeEvent>,
+) {
+    for (peer, last) in peers {
+        if last.time() + TIMEOUT < time.elapsed() {
+            warn!("Peer {} timed out", peer.id);
+            delete.write(PeerChangeEvent::new(peer.id, None));
+        }
+    }
+}
diff --git a/src/net/mod.rs b/src/net/mod.rs
index 69f2151..e4475c4 100644
--- a/src/net/mod.rs
+++ b/src/net/mod.rs
@@ -1,17 +1,18 @@
 mod distribution;
-mod heartbeat;
 mod io;
 mod packet;
 mod peer;
 mod plugin;
 mod queues;
 mod socket;
+mod state;
 mod thread;
 
 #[allow(unused_imports)]
 pub mod prelude {
-    pub use super::distribution::distribution_plugin;
+    pub use super::distribution::Networked;
     pub use super::packet::{InboundPacket, OutboundPacket, Packet};
-    pub use super::peer::{Peer, PeerID, PeerReceiveTiming, PeerSendTiming, PotentialPeers};
+    pub use super::peer::{Peer, PeerReceiveTiming, PeerSendTiming};
     pub use super::plugin::NetIOPlugin;
+    pub use super::state::NetworkState;
 }
diff --git a/src/net/packet.rs b/src/net/packet.rs
index f7e7a03..d9bf240 100644
--- a/src/net/packet.rs
+++ b/src/net/packet.rs
@@ -2,95 +2,19 @@ use bevy::prelude::*;
 use uuid::Uuid;
 
 #[derive(Debug)]
-pub enum TryFromBytesError {
-    InsufficientLength,
-    NotUUID,
-    NotVariant,
-}
-
-#[derive(Clone, Copy, Debug)]
-pub enum PacketType {
-    Standard = 0x00,
-    Peer = 0x01,
-}
-
-impl From<PacketType> for u8 {
-    fn from(value: PacketType) -> Self {
-        value as u8
-    }
-}
-
-impl TryFrom<u8> for PacketType {
-    type Error = TryFromBytesError;
-
-    fn try_from(value: u8) -> std::result::Result<Self, Self::Error> {
-        match value {
-            value if value == PacketType::Standard as u8 => Ok(PacketType::Standard),
-            value if value == PacketType::Peer as u8 => Ok(PacketType::Peer),
-            _ => Err(TryFromBytesError::NotVariant),
-        }
-    }
-}
-
-pub const UUID_SIZE: usize = 16;
-
-#[derive(Clone, Debug)]
 pub struct Packet {
     pub message: Vec<u8>,
-    pub variant: PacketType,
     pub peer: Uuid,
 }
 
 impl Packet {
-    pub fn new(message: Vec<u8>, variant: PacketType, peer: Uuid) -> Self {
-        Self {
-            message,
-            variant,
-            peer,
-        }
-    }
-
-    pub fn create<T: From<Packet>>(message: Vec<u8>, peer: Uuid) -> T {
-        Self {
-            message,
-            variant: PacketType::Standard,
-            peer,
-        }
-        .into()
-    }
-}
-
-impl TryFrom<Vec<u8>> for Packet {
-    type Error = TryFromBytesError;
-
-    fn try_from(mut value: Vec<u8>) -> std::result::Result<Self, Self::Error> {
-        if value.len() < UUID_SIZE {
-            return Err(TryFromBytesError::InsufficientLength);
-        }
-        let uuid = Uuid::from_slice(value.split_off(value.len() - UUID_SIZE).as_slice())
-            .map_err(|_| TryFromBytesError::NotUUID)?;
-        let variant = value
-            .pop()
-            .ok_or(TryFromBytesError::InsufficientLength)?
-            .try_into()?;
-        Ok(Packet::new(value, variant, uuid))
+    pub fn new(message: Vec<u8>, peer: Uuid) -> Self {
+        Self { peer, message }
     }
 }
 
 #[derive(Debug, Event)]
 pub struct OutboundPacket(pub Packet);
 
-impl From<Packet> for OutboundPacket {
-    fn from(value: Packet) -> Self {
-        Self(value)
-    }
-}
-
 #[derive(Debug, Event)]
 pub struct InboundPacket(pub Packet);
-
-impl From<Packet> for InboundPacket {
-    fn from(value: Packet) -> Self {
-        Self(value)
-    }
-}
diff --git a/src/net/peer.rs b/src/net/peer.rs
index c09dd84..8051f40 100644
--- a/src/net/peer.rs
+++ b/src/net/peer.rs
@@ -1,14 +1,14 @@
 use std::{
     array::TryFromSliceError,
-    collections::{HashMap, HashSet},
-    net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
+    collections::HashMap,
+    net::{IpAddr, Ipv6Addr, SocketAddr},
     time::Duration,
 };
 
 use bevy::prelude::*;
 use uuid::Uuid;
 
-use super::packet::{InboundPacket, OutboundPacket, Packet, PacketType};
+use super::packet::{OutboundPacket, Packet};
 
 #[derive(Component, Debug, Default)]
 pub struct PeerSendTiming(Duration);
@@ -40,12 +40,55 @@ impl PeerReceiveTiming {
     }
 }
 
+#[derive(Component, Debug)]
+#[require(PeerData, PeerReceiveTiming)]
+pub struct Peer {
+    pub id: Uuid,
+}
+
+#[derive(Component, Debug)]
+#[require(PeerData)]
+pub struct PotentialPeer {
+    pub id: Uuid,
+}
+
+impl Default for PotentialPeer {
+    fn default() -> Self {
+        Self { id: Uuid::new_v4() }
+    }
+}
+
+#[derive(Clone, Component, Copy, Debug)]
+#[require(PeerSendTiming)]
+pub struct PeerData {
+    pub addr: Address,
+    pub me: Uuid,
+}
+
+impl PeerData {
+    pub fn new(addr: SocketAddr, me: Uuid) -> Self {
+        Self {
+            addr: addr.into(),
+            me,
+        }
+    }
+}
+
+impl Default for PeerData {
+    fn default() -> Self {
+        Self {
+            addr: Default::default(),
+            me: Uuid::new_v4(),
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug)]
 pub struct Address(SocketAddr);
 
 impl From<Address> for SocketAddr {
-    fn from(Address(value): Address) -> Self {
-        value
+    fn from(value: Address) -> Self {
+        value.0
     }
 }
 
@@ -68,12 +111,12 @@ impl PartialEq<Address> for SocketAddr {
 }
 
 impl From<Address> for Vec<u8> {
-    fn from(Address(value): Address) -> Self {
-        let mut bytes: Vec<u8> = match value.ip() {
+    fn from(value: Address) -> Self {
+        let mut bytes: Vec<u8> = match value.0.ip() {
             IpAddr::V4(ipv4_addr) => ipv4_addr.octets().into(),
             IpAddr::V6(ipv6_addr) => ipv6_addr.octets().into(),
         };
-        bytes.extend(value.port().to_le_bytes());
+        bytes.extend(value.0.port().to_le_bytes());
         bytes
     }
 }
@@ -81,25 +124,14 @@ impl From<Address> for Vec<u8> {
 impl TryFrom<Vec<u8>> for Address {
     type Error = TryFromSliceError;
 
-    fn try_from(value: Vec<u8>) -> std::result::Result<Self, Self::Error> {
-        const PORT_SIZE: usize = 2;
-
-        if value.len() < PORT_SIZE {
-            todo!();
-        }
-        let mut bytes = value.clone();
-        let port = u16::from_le_bytes(TryInto::<[u8; PORT_SIZE]>::try_into(
-            bytes.split_off(bytes.len() - PORT_SIZE).as_slice(),
+    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
+        let port = u16::from_le_bytes(TryInto::<[u8; 2]>::try_into(
+            value.clone().split_off(value.len() - 2).as_slice(),
         )?);
-        let addr = if let Ok(bytes) =
-            TryInto::<[u8; Ipv4Addr::BITS as usize / 8]>::try_into(bytes.as_slice())
-        {
+        let addr = if let Ok(bytes) = TryInto::<[u8; 4]>::try_into(value.as_slice()) {
             SocketAddr::from((bytes, port))
         } else {
-            SocketAddr::from((
-                TryInto::<[u8; Ipv6Addr::BITS as usize / 8]>::try_into(bytes.as_slice())?,
-                port,
-            ))
+            SocketAddr::from((TryInto::<[u8; 16]>::try_into(value.as_slice())?, port))
         };
         Ok(Address(addr))
     }
@@ -111,53 +143,6 @@ impl Default for Address {
     }
 }
 
-#[derive(Clone, Component, Copy, Debug, Default)]
-#[require(PeerSendTiming)]
-pub struct PeerData {
-    pub addr: Address,
-}
-
-impl PeerData {
-    pub fn new(addr: SocketAddr) -> Self {
-        Self { addr: addr.into() }
-    }
-}
-
-#[derive(Component, Debug)]
-#[require(PeerData)]
-pub struct PeerID {
-    pub id: Uuid,
-}
-
-impl PeerID {
-    pub fn new(id: Uuid) -> Self {
-        Self { id }
-    }
-}
-
-impl Default for PeerID {
-    fn default() -> Self {
-        Self { id: Uuid::new_v4() }
-    }
-}
-
-#[derive(Component, Debug)]
-#[require(PeerID, PeerReceiveTiming)]
-pub struct Peer;
-
-#[derive(Debug, Default, Resource)]
-pub struct PotentialPeers {
-    pub addresses: HashSet<SocketAddr>,
-}
-
-impl PotentialPeers {
-    pub fn new(addresses: Vec<SocketAddr>) -> Self {
-        Self {
-            addresses: addresses.into_iter().collect(),
-        }
-    }
-}
-
 #[derive(Debug, Default, Resource)]
 pub struct PeerMap {
     map: HashMap<Uuid, Entity>,
@@ -172,13 +157,17 @@ impl PeerMap {
         self.map.get(uuid)
     }
 
-    pub fn try_get(&self, uuid: &Uuid) -> std::result::Result<&Entity, String> {
-        self.get(uuid).ok_or(format!("No peer with uuid: {uuid}"))
+    pub fn try_get(&self, uuid: &Uuid) -> Result<&Entity, String> {
+        self.get(uuid).ok_or(format!("No entity with uuid: {uuid}"))
     }
 
     pub fn remove(&mut self, uuid: &Uuid) -> Option<Entity> {
         self.map.remove(uuid)
     }
+
+    pub fn len(&self) -> usize {
+        self.map.len()
+    }
 }
 
 #[derive(Debug, Event)]
@@ -197,82 +186,63 @@ pub fn handle_peer_change(
     mut changes: EventReader<PeerChangeEvent>,
     mut peer_map: ResMut<PeerMap>,
     mut peers: Query<&mut PeerData>,
-    mut potential_peers: ResMut<PotentialPeers>,
     mut commands: Commands,
     time: Res<Time>,
 ) -> Result {
     for change in changes.read() {
-        match (peer_map.get(&change.peer), change.addr) {
-            // Peer modification
-            (Some(entity), Some(addr)) => {
+        if let Some(entity) = peer_map.get(&change.peer) {
+            if let Some(addr) = change.addr {
                 if let Ok(mut peer) = peers.get_mut(*entity) {
-                    peer.addr = addr.into();
+                    peer.addr = Address(addr);
                 } else {
                     warn!("Peer {} doesn't exist (just added?)", change.peer);
                 }
-            }
-            // Peer deletion
-            (Some(entity), None) => {
+            } else {
                 commands.get_entity(*entity)?.despawn();
                 peer_map.remove(&change.peer);
             }
-            // Peer addition
-            (None, Some(addr)) => {
-                info!("Adding peer {} ({})", change.peer, addr);
-                peer_map.insert(
-                    change.peer,
-                    commands
-                        .spawn((
-                            Peer,
-                            PeerID::new(change.peer),
-                            PeerData::new(addr),
-                            PeerReceiveTiming::new(&time),
-                        ))
-                        .id(),
-                );
-            }
-            // Double peer deletion
-            (None, None) => warn!("Peer {} already deleted", change.peer),
+        } else if let Some(addr) = change.addr {
+            info!("Adding peer {} ({})", change.peer, addr);
+            peer_map.insert(
+                change.peer,
+                commands
+                    .spawn((
+                        PeerData::new(addr, Uuid::new_v4()),
+                        PeerReceiveTiming::new(&time),
+                    ))
+                    .id(),
+            );
+        } else {
+            warn!("Peer {} already deleted", change.peer);
         }
-        if let Some(addr) = change.addr {
-            potential_peers.addresses.remove(&addr);
+    }
+    if peer_map.len() > 1 {
+        if let Some(entity) = peer_map.remove(&Uuid::nil()) {
+            commands.get_entity(entity)?.despawn();
         }
     }
     Ok(())
 }
 
-pub fn new_peer_message(
-    mut from_network: EventReader<InboundPacket>,
-    peers: Query<&PeerData>,
-    mut potential_peers: ResMut<PotentialPeers>,
-) {
-    'packet: for packet in from_network.read() {
-        if let Ok(addr) = TryInto::<Address>::try_into(packet.0.message.clone()) {
-            if potential_peers.addresses.contains(&addr.into()) {
-                continue;
-            }
-            for peer in peers {
-                if peer.addr == addr.into() {
-                    continue 'packet;
-                }
-            }
-            potential_peers.addresses.insert(addr.into());
-        }
-    }
-}
-
-// TODO: Make this a more generic system
+#[allow(clippy::type_complexity)]
 pub fn handle_new_peer(
-    peers: Query<(Ref<Peer>, &PeerID, &PeerData)>,
+    new_peers: Query<(Option<Ref<Peer>>, Option<&Peer>, &PeerData)>,
     mut outbound: EventWriter<OutboundPacket>,
-) {
-    for (change, peer, _) in peers {
-        if change.is_added() {
-            for (_, other, data) in peers {
-                if peer.id != other.id {
-                    outbound.write(Packet::new(data.addr.into(), PacketType::Peer, peer.id).into());
+) -> Result {
+    for (change, this, data) in new_peers {
+        if let Some(change) = change {
+            if change.is_added() {
+                if let Some(this) = this {
+                    for (_, _, other) in new_peers {
+                        if data.me != other.me {
+                            outbound.write(OutboundPacket(Packet::new(other.addr.into(), this.id)));
+                        }
+                    }
+                } else {
+                    return Err("Ref<Peer> without Peer".into());
                 }
             }
         }
     }
+    Ok(())
 }
diff --git a/src/net/plugin.rs b/src/net/plugin.rs
index c236df5..75b32c8 100644
--- a/src/net/plugin.rs
+++ b/src/net/plugin.rs
@@ -1,59 +1,65 @@
 use std::net::SocketAddr;
 
 use bevy::prelude::*;
+use uuid::Uuid;
 
 use super::{
-    heartbeat::{PotentialPeerTimer, heartbeat, ping_potential_peers, timeout},
-    io::{Config, handle_network_input, handle_network_output},
+    io::{handle_network_input, handle_network_output, heartbeat, timeout},
     packet::{InboundPacket, OutboundPacket},
-    peer::{
-        PeerChangeEvent, PeerMap, PotentialPeers, handle_new_peer, handle_peer_change,
-        new_peer_message,
-    },
+    peer::{PeerChangeEvent, PeerData, PeerMap, handle_new_peer, handle_peer_change},
     queues::{NetworkReceive, NetworkSend},
     socket::bind_socket,
+    state::NetworkState,
 };
 
 pub struct NetIOPlugin {
     listen: u16,
-    initial_peers: Vec<SocketAddr>,
+    peer: Option<SocketAddr>,
 }
 
 impl NetIOPlugin {
-    pub fn maybe_peer(listen: u16, peer: Option<SocketAddr>) -> Self {
-        Self {
-            listen,
-            initial_peers: match peer {
-                Some(addr) => vec![addr],
-                None => Vec::new(),
-            },
-        }
+    pub fn new(listen: u16, peer: Option<SocketAddr>) -> Self {
+        Self { listen, peer }
     }
 }
 
 impl Plugin for NetIOPlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(
-            FixedPreUpdate,
-            (handle_network_input, (handle_peer_change, new_peer_message)).chain(),
-        )
-        .add_systems(
-            FixedUpdate,
-            (heartbeat, timeout, handle_new_peer, ping_potential_peers),
-        )
-        .add_systems(FixedPostUpdate, handle_network_output)
-        .init_resource::<Config>()
-        .init_resource::<PeerMap>()
-        .init_resource::<PotentialPeerTimer>()
-        .insert_resource(PotentialPeers::new(self.initial_peers.clone()))
-        .add_event::<PeerChangeEvent>()
-        .add_event::<InboundPacket>()
-        .add_event::<OutboundPacket>();
+        app.init_state::<NetworkState>()
+            .add_systems(
+                FixedPreUpdate,
+                (handle_network_input, handle_peer_change)
+                    .chain()
+                    .run_if(in_state(NetworkState::MultiPlayer)),
+            )
+            .add_systems(
+                FixedUpdate,
+                (heartbeat, timeout, handle_new_peer).run_if(in_state(NetworkState::MultiPlayer)),
+            )
+            .add_systems(
+                FixedPostUpdate,
+                handle_network_output.run_if(in_state(NetworkState::MultiPlayer)),
+            )
+            .add_event::<PeerChangeEvent>()
+            .add_event::<InboundPacket>()
+            .add_event::<OutboundPacket>();
 
         match bind_socket(self.listen) {
             Ok((send, receive)) => {
-                app.insert_resource(NetworkSend::new(send))
+                app.insert_state(NetworkState::MultiPlayer)
+                    .insert_resource(NetworkSend::new(send))
                     .insert_resource(NetworkReceive::new(receive));
+
+                let mut peer_map = PeerMap::default();
+                if let Some(socket) = self.peer {
+                    let entity = app.world_mut().spawn(PeerData {
+                        addr: socket.into(),
+                        me: Uuid::nil(),
+                    });
+                    peer_map.insert(Uuid::nil(), entity.id());
+                }
+
+                app.insert_resource(peer_map);
             }
             Err(err) => {
                 warn!("Failed to set up networking: {err}");
diff --git a/src/net/state.rs b/src/net/state.rs
new file mode 100644
index 0000000..2321bbe
--- /dev/null
+++ b/src/net/state.rs
@@ -0,0 +1,8 @@
+use bevy::prelude::*;
+
+#[derive(States, Default, Debug, Clone, PartialEq, Eq, Hash)]
+pub enum NetworkState {
+    #[default]
+    SinglePlayer,
+    MultiPlayer,
+}