replace customers with bots and refactor some more server code.

17 files changed, 428 insertions, 435 deletions

diff --git a/pixel-client/src/game.rs b/pixel-client/src/game.rs
index dca84d77..eab45478 100644
--- a/pixel-client/src/game.rs
+++ b/pixel-client/src/game.rs
@@ -81,12 +81,11 @@ pub struct Item {
 
 impl Game {
     pub fn new(mut network: Network, layout: &AtlasLayout) -> Self {
-        network
-            .queue_out
-            .push_back(hurrycurry_protocol::PacketS::Join {
-                name: "pixel".to_string(),
-                character: 0,
-            });
+        network.queue_out.push_back(PacketS::Join {
+            id: None,
+            name: "pixel".to_string(),
+            character: 0,
+        });
 
         Self {
             network,
diff --git a/server/bot/src/algos/customer.rs b/server/bot/src/algos/customer.rs
new file mode 100644
index 00000000..167fc0d7
--- /dev/null
+++ b/server/bot/src/algos/customer.rs
@@ -0,0 +1,219 @@
+/*
+    Hurry Curry! - a game about cooking
+    Copyright 2024 metamuffin
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, version 3 of the License only.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+*/
+use crate::{pathfinding::Path, BotAlgo, BotInput};
+use hurrycurry_protocol::{glam::IVec2, DemandIndex};
+
+#[derive(Debug, Clone)]
+pub enum Customer {
+    New,
+    Entering {
+        path: Path,
+        chair: IVec2,
+    },
+    Waiting {
+        demand: DemandIndex,
+        chair: IVec2,
+        timeout: f32,
+    },
+    Eating {
+        demand: DemandIndex,
+        target: IVec2,
+        progress: f32,
+        chair: IVec2,
+    },
+    Exiting {
+        path: Path,
+    },
+}
+
+impl Default for Customer {
+    fn default() -> Self {
+        Customer::New
+    }
+}
+
+impl BotAlgo for Customer {
+    fn tick(
+        &mut self,
+        me: hurrycurry_protocol::PlayerID,
+        game: &hurrycurry_client_lib::Game,
+        dt: f32,
+    ) -> BotInput {
+        let _ = (me, game, dt);
+        BotInput::default()
+        // let Some(playerdata) = game.players.get_mut(&player) else {
+        //     return BotInput::default();
+        // };
+        // match state {
+        // let chair = self.select_chair().ok_or(anyhow!("no free chair found"))?;
+        // let from = game.data.customer_spawn.as_ivec2();
+        // let path = find_path(&game.walkable, from, chair)
+        //     .ok_or(anyhow!("no path from {from} to {chair}"))?;
+        // info!("{id:?} -> entering");
+
+        //     CustomerState::Entering { path, chair } => {
+        //         playerdata
+        //             .movement
+        //             .input(path.next_direction(playerdata.position()), false);
+        //         if path.is_done() {
+        //             let demand = DemandIndex(random::<u32>() as usize % self.demands.len());
+        //             self.cpackets.push_back(PacketS::Communicate {
+        //                 message: Some(Message::Item(self.demands[demand.0].from)),
+        //                 persist: true,
+        //                 player,
+        //             });
+        //             info!("{player:?} -> waiting");
+        //             *state = CustomerState::Waiting {
+        //                 chair: *chair,
+        //                 timeout: 90. + random::<f32>() * 60.,
+        //                 demand,
+        //             };
+        //         }
+        //     }
+        //     CustomerState::Waiting {
+        //         chair,
+        //         demand,
+        //         timeout,
+        //     } => {
+        //         playerdata
+        //             .movement
+        //             .input((chair.as_vec2() + 0.5) - playerdata.position(), false);
+        //         *timeout -= dt;
+        //         if *timeout <= 0. {
+        //             self.cpackets.push_back(PacketS::Communicate {
+        //                 message: None,
+        //                 persist: true,
+        //                 player,
+        //             });
+        //             self.cpackets.push_back(PacketS::Communicate {
+        //                 message: Some(Message::Effect("angry".to_string())),
+        //                 persist: false,
+        //                 player,
+        //             });
+        //             let path = find_path(
+        //                 &game.walkable,
+        //                 playerdata.position().as_ivec2(),
+        //                 game.data.customer_spawn.as_ivec2(),
+        //             )
+        //             .expect("no path to exit");
+        //             *self.chairs.get_mut(chair).unwrap() = true;
+        //             game.score.demands_failed += 1;
+        //             game.score.points -= 1;
+        //             game.score_changed = true;
+        //             info!("{player:?} -> exiting");
+        //             *state = CustomerState::Exiting { path }
+        //         } else {
+        //             let demand_data = &self.demands[demand.0];
+        //             let demand_pos = [IVec2::NEG_X, IVec2::NEG_Y, IVec2::X, IVec2::Y]
+        //                 .into_iter()
+        //                 .find_map(|off| {
+        //                     let pos = *chair + off;
+        //                     if game
+        //                         .tiles
+        //                         .get(&pos)
+        //                         .map(|t| {
+        //                             t.item
+        //                                 .as_ref()
+        //                                 .map(|i| i.kind == demand_data.from)
+        //                                 .unwrap_or_default()
+        //                         })
+        //                         .unwrap_or_default()
+        //                     {
+        //                         Some(pos)
+        //                     } else {
+        //                         None
+        //                     }
+        //                 });
+        //             if let Some(pos) = demand_pos {
+        //                 self.cpackets.push_back(PacketS::Communicate {
+        //                     persist: true,
+        //                     message: None,
+        //                     player,
+        //                 });
+        //                 self.cpackets.push_back(PacketS::Communicate {
+        //                     message: Some(Message::Effect("satisfied".to_string())),
+        //                     persist: false,
+        //                     player,
+        //                 });
+        //                 self.cpackets.push_back(PacketS::Interact {
+        //                     pos: Some(pos),
+        //                     player,
+        //                 });
+        //                 self.cpackets
+        //                     .push_back(PacketS::Interact { pos: None, player });
+        //                 info!("{player:?} -> eating");
+        //                 *state = CustomerState::Eating {
+        //                     demand: *demand,
+        //                     target: pos,
+        //                     progress: 0.,
+        //                     chair: *chair,
+        //                 }
+        //             }
+        //         }
+        //     }
+        //     CustomerState::Eating {
+        //         demand,
+        //         target,
+        //         progress,
+        //         chair,
+        //     } => {
+        //         playerdata
+        //             .movement
+        //             .input((chair.as_vec2() + 0.5) - playerdata.position(), false);
+        //         let demand = &self.demands[demand.0];
+        //         *progress += dt / demand.duration;
+        //         if *progress >= 1. {
+        //             self.cpackets.push_back(PacketS::ReplaceHand {
+        //                 player,
+        //                 item: demand.to,
+        //             });
+        //             if demand.to.is_some() {
+        //                 self.cpackets.push_back(PacketS::Interact {
+        //                     player,
+        //                     pos: Some(*target),
+        //                 });
+        //                 self.cpackets
+        //                     .push_back(PacketS::Interact { player, pos: None });
+        //             }
+        //             let path = find_path(
+        //                 &game.walkable,
+        //                 playerdata.position().as_ivec2(),
+        //                 game.data.customer_spawn.as_ivec2(),
+        //             )
+        //             .ok_or(anyhow!("no path to exit"))?;
+        //             *self.chairs.get_mut(chair).unwrap() = true;
+        //             game.score.demands_completed += 1;
+        //             game.score.points += demand.points;
+        //             game.score_changed = true;
+        //             info!("{player:?} -> exiting");
+        //             *state = CustomerState::Exiting { path }
+        //         }
+        //     }
+        //     CustomerState::Exiting { path } => {
+        //         playerdata
+        //             .movement
+        //             .input(path.next_direction(playerdata.position()), false);
+        //         if path.is_done() {
+        //             info!("{player:?} -> leave");
+        //             self.cpackets.push_back(PacketS::Leave { player });
+        //             customers_to_remove.push(player);
+        //         }
+        //     }
+        // }
+    }
+}
diff --git a/server/bot/src/algos/mod.rs b/server/bot/src/algos/mod.rs
index 7b165da4..d3aba8f4 100644
--- a/server/bot/src/algos/mod.rs
+++ b/server/bot/src/algos/mod.rs
@@ -15,10 +15,12 @@
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 */
+mod customer;
 mod simple;
 mod test;
 mod waiter;
 
+pub use customer::Customer;
 pub use simple::Simple;
 pub use test::Test;
 pub use waiter::Waiter;
@@ -27,4 +29,5 @@ pub const ALGO_CONSTRUCTORS: &'static [(&'static str, fn() -> Box<dyn crate::Bot
     ("test", || Box::new(Test::default())),
     ("simple", || Box::new(Simple::default())),
     ("waiter", || Box::new(Waiter::default())),
+    ("customer", || Box::new(Customer::default())),
 ];
diff --git a/server/bot/src/algos/simple.rs b/server/bot/src/algos/simple.rs
index 22ed50bd..6092e772 100644
--- a/server/bot/src/algos/simple.rs
+++ b/server/bot/src/algos/simple.rs
@@ -68,6 +68,7 @@ impl BotAlgo for Simple {
                 direction,
                 boost: false,
                 interact: if arrived { Some(target) } else { None },
+                ..Default::default()
             };
         }
 
diff --git a/server/bot/src/algos/test.rs b/server/bot/src/algos/test.rs
index d56aa00b..dee4cb88 100644
--- a/server/bot/src/algos/test.rs
+++ b/server/bot/src/algos/test.rs
@@ -41,6 +41,7 @@ impl BotAlgo for Test {
                 direction,
                 boost: false,
                 interact: None,
+                ..Default::default()
             };
         } else {
             if let Some((item, near)) = find_demand(game) {
diff --git a/server/bot/src/algos/waiter.rs b/server/bot/src/algos/waiter.rs
index 7a25108b..ced3097b 100644
--- a/server/bot/src/algos/waiter.rs
+++ b/server/bot/src/algos/waiter.rs
@@ -56,6 +56,7 @@ impl BotAlgo for Waiter {
                 direction,
                 boost: false,
                 interact: if arrived { Some(target) } else { None },
+                ..Default::default()
             };
         }
         Context {
diff --git a/server/bot/src/lib.rs b/server/bot/src/lib.rs
index 385e2334..543a1062 100644
--- a/server/bot/src/lib.rs
+++ b/server/bot/src/lib.rs
@@ -30,7 +30,10 @@ pub struct BotInput {
     pub direction: Vec2,
     pub boost: bool,
     pub interact: Option<IVec2>,
+    pub leave: bool,
 }
+
+pub type DynBotAlgo = Box<dyn BotAlgo + Send + Sync + 'static>;
 pub trait BotAlgo {
     fn tick(&mut self, me: PlayerID, game: &Game, dt: f32) -> BotInput;
 }
diff --git a/server/bot/src/main.rs b/server/bot/src/main.rs
index 9ecd0a84..cf115358 100644
--- a/server/bot/src/main.rs
+++ b/server/bot/src/main.rs
@@ -57,6 +57,7 @@ fn main() -> Result<()> {
     network.queue_out.push_back(PacketS::Join {
         name: format!("{}-bot", args.username.clone().unwrap_or(args.algo.clone())),
         character: args.character,
+        id: None,
     });
 
     let mut bots = Vec::new();
@@ -85,12 +86,19 @@ fn main() -> Result<()> {
             game.apply_packet(packet);
         }
 
-        for b in &mut bots {
+        bots.retain_mut(|b| {
             let BotInput {
                 direction,
                 boost,
                 interact,
+                leave,
             } = b.state.tick(b.id, &game, dt);
+
+            if leave {
+                network.queue_out.push_back(PacketS::Leave { player: b.id });
+                return false;
+            }
+
             if interact.is_some() != b.interacting {
                 b.interacting = interact.is_some();
                 network.queue_out.push_back(PacketS::Interact {
@@ -104,7 +112,8 @@ fn main() -> Result<()> {
                 boost,
                 pos: None,
             });
-        }
+            true
+        });
 
         sleep(Duration::from_secs_f32(dt));
     }
diff --git a/server/protocol/src/lib.rs b/server/protocol/src/lib.rs
index 05561a12..695d45cf 100644
--- a/server/protocol/src/lib.rs
+++ b/server/protocol/src/lib.rs
@@ -87,6 +87,8 @@ pub enum PacketS {
     Join {
         name: String,
         character: i32,
+        #[serde(skip)]
+        id: Option<PlayerID>, // used entity bots that cant receive a response
     },
     Leave {
         player: PlayerID,
diff --git a/server/src/entity/customers/demands.rs b/server/src/data/demands.rs
index 176ca232..176ca232 100644
--- a/server/src/entity/customers/demands.rs
+++ b/server/src/data/demands.rs
diff --git a/server/src/data.rs b/server/src/data/mod.rs
index 021de525..6555fbc4 100644
--- a/server/src/data.rs
+++ b/server/src/data/mod.rs
@@ -16,8 +16,11 @@
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 */
+pub mod demands;
+
 use crate::entity::{construct_entity, Entities, EntityDecl};
 use anyhow::{anyhow, bail, Result};
+use demands::generate_demands;
 use hurrycurry_protocol::{
     glam::{IVec2, Vec2},
     Gamedata, ItemIndex, MapMetadata, Recipe, TileIndex,
@@ -100,6 +103,7 @@ pub struct Demand {
 #[derive(Debug,Clone, Default)]
 #[rustfmt::skip]
 pub struct Serverdata {
+    pub demands: Vec<Demand>,
     pub spec: String,
     pub initial_map: HashMap<IVec2, (TileIndex, Option<ItemIndex>)>,
     pub chef_spawn: Vec2,
@@ -263,16 +267,7 @@ pub fn build_data(
         for (x, tile) in line.trim().chars().enumerate() {
             let pos = IVec2::new(x as i32, y as i32);
             if let Some(ent) = map_in.tile_entities.get(&tile) {
-                entities.push(construct_entity(
-                    Some(pos),
-                    ent,
-                    &reg,
-                    &tiles_used,
-                    &items_used,
-                    &raw_demands,
-                    &recipes,
-                    &initial_map,
-                )?);
+                entities.push(construct_entity(Some(pos), ent, &reg)?);
             }
         }
     }
@@ -281,21 +276,12 @@ pub fn build_data(
         map_in
             .entities
             .iter()
-            .map(|decl| {
-                construct_entity(
-                    None,
-                    decl,
-                    &reg,
-                    &tiles_used,
-                    &items_used,
-                    &raw_demands,
-                    &recipes,
-                    &initial_map,
-                )
-            })
+            .map(|decl| construct_entity(None, decl, &reg))
             .try_collect::<Vec<_>>()?,
     );
 
+    let demands = generate_demands(&tiles_used, &items_used, &raw_demands, &recipes);
+
     let item_names = reg.items.into_inner().unwrap();
     let tile_names = reg.tiles.into_inner().unwrap();
     let tile_collide = tile_names
@@ -319,6 +305,7 @@ pub fn build_data(
         },
         Serverdata {
             spec,
+            demands,
             initial_map,
             chef_spawn,
             customer_spawn,
diff --git a/server/src/entity/bot.rs b/server/src/entity/bot.rs
index 06477e8a..301dbca3 100644
--- a/server/src/entity/bot.rs
+++ b/server/src/entity/bot.rs
@@ -1,13 +1,85 @@
-use super::{EntityContext, Entity};
+/*
+    Hurry Curry! - a game about cooking
+    Copyright 2024 metamuffin
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, version 3 of the License only.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+*/
+use super::{Entity, EntityContext};
 use anyhow::Result;
-use hurrycurry_bot::BotAlgo;
+use hurrycurry_bot::{BotAlgo, DynBotAlgo};
+use hurrycurry_protocol::{PacketS, PlayerID};
+use log::info;
+use rand::random;
+
+pub type DynBotDriver = BotDriver<DynBotAlgo>;
 
-pub struct BotDriver {
-    algo: Box<dyn BotAlgo>,
+pub struct BotDriver<T> {
+    algo: T,
+    join_data: Option<(String, i32)>,
+    id: PlayerID,
+    interacting: bool,
+    pub left: bool,
 }
 
-impl Entity for BotDriver {
+impl<T: BotAlgo> BotDriver<T> {
+    pub fn new(name: String, character: i32, algo: T) -> Self {
+        Self {
+            algo,
+            id: PlayerID(0),
+            interacting: false,
+            join_data: Some((name, character)),
+            left: false,
+        }
+    }
+}
+impl<T: BotAlgo> Entity for BotDriver<T> {
     fn tick(&mut self, c: EntityContext<'_>) -> Result<()> {
+        if let Some((name, character)) = self.join_data.take() {
+            self.id = PlayerID(random()); // TODO bad code, can collide
+            info!("spawn {:?} ({name:?}, {character})", self.id);
+            c.packet_in.push_back(PacketS::Join {
+                name,
+                character,
+                id: Some(self.id),
+            })
+        }
+
+        let input = self.algo.tick(self.id, &c.game, c.dt);
+        if input.leave {
+            info!("leave {:?}", self.id);
+            c.packet_in.push_back(PacketS::Leave { player: self.id });
+            self.left = true;
+            return Ok(());
+        }
+        if input.interact.is_some() != self.interacting {
+            self.interacting = input.interact.is_some();
+            c.packet_in.push_back(PacketS::Interact {
+                player: self.id,
+                pos: input.interact,
+            })
+        }
+        c.packet_in.push_back(PacketS::Movement {
+            player: self.id,
+            dir: input.direction,
+            boost: input.boost,
+            pos: None,
+        });
         Ok(())
     }
+    fn destructor(&mut self, c: EntityContext<'_>) {
+        if self.join_data.is_none() && !self.left {
+            c.packet_in.push_back(PacketS::Leave { player: self.id })
+        }
+    }
 }
diff --git a/server/src/entity/customers.rs b/server/src/entity/customers.rs
new file mode 100644
index 00000000..a89d5687
--- /dev/null
+++ b/server/src/entity/customers.rs
@@ -0,0 +1,62 @@
+/*
+    Hurry Curry! - a game about cooking
+    Copyright 2024 metamuffin
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, version 3 of the License only.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+*/
+use super::{bot::BotDriver, Entity, EntityContext};
+use anyhow::Result;
+use hurrycurry_bot::algos::Customer;
+use rand::random;
+
+pub struct Customers {
+    customers: Vec<BotDriver<Customer>>,
+    spawn_cooldown: f32,
+}
+
+impl Customers {
+    pub fn new() -> Result<Self> {
+        Ok(Self {
+            customers: Default::default(),
+            spawn_cooldown: 0.,
+        })
+    }
+}
+
+impl Entity for Customers {
+    fn tick(&mut self, c: EntityContext) -> Result<()> {
+        self.spawn_cooldown -= c.dt;
+        self.spawn_cooldown = self.spawn_cooldown.max(0.);
+        if self.customers.len() < 5 && self.spawn_cooldown <= 0. {
+            self.spawn_cooldown = 10. + random::<f32>() * 10.;
+            let bot = BotDriver::new(
+                fake::Fake::fake(&fake::faker::name::fr_fr::Name()),
+                -1 - (random::<u16>() as i32),
+                Customer::default(),
+            );
+            self.customers.push(bot)
+        }
+        for bot in &mut self.customers {
+            bot.tick(EntityContext {
+                game: c.game,
+                packet_out: c.packet_out,
+                packet_in: c.packet_in,
+                score_changed: c.score_changed,
+                dt: c.dt,
+            })?;
+        }
+        self.customers.retain(|c| !c.left);
+        Ok(())
+    }
+}
diff --git a/server/src/entity/customers/mod.rs b/server/src/entity/customers/mod.rs
deleted file mode 100644
index 5038eaf2..00000000
--- a/server/src/entity/customers/mod.rs
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
-    Hurry Curry! - a game about cooking
-    Copyright 2024 metamuffin
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, version 3 of the License only.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-*/
-pub mod demands;
-mod pathfinding;
-
-use super::{EntityContext, Entity};
-use crate::{data::Demand, server::Server};
-use anyhow::{anyhow, bail, Result};
-use fake::{faker, Fake};
-use hurrycurry_protocol::{glam::IVec2, DemandIndex, Message, PacketC, PacketS, PlayerID};
-use log::{info, warn};
-use pathfinding::{find_path, Path};
-use rand::{random, thread_rng};
-use std::collections::{HashMap, VecDeque};
-
-#[derive(Debug, Clone)]
-pub struct Customers {
-    demands: Vec<Demand>,
-    cpackets: VecDeque<PacketS>,
-    chairs: HashMap<IVec2, bool>,
-    customers: HashMap<PlayerID, CustomerState>,
-    spawn_cooldown: f32,
-}
-
-#[derive(Debug, Clone)]
-enum CustomerState {
-    Entering {
-        path: Path,
-        chair: IVec2,
-    },
-    Waiting {
-        demand: DemandIndex,
-        chair: IVec2,
-        timeout: f32,
-    },
-    Eating {
-        demand: DemandIndex,
-        target: IVec2,
-        progress: f32,
-        chair: IVec2,
-    },
-    Exiting {
-        path: Path,
-    },
-}
-
-impl Customers {
-    pub fn new(chairs: HashMap<IVec2, bool>, demands: Vec<Demand>) -> Result<Self> {
-        if demands.is_empty() {
-            bail!("one or more demands required for customers entity")
-        }
-        Ok(Self {
-            chairs,
-            customers: Default::default(),
-            demands,
-            spawn_cooldown: 0.,
-            cpackets: VecDeque::new(),
-        })
-    }
-}
-
-impl Entity for Customers {
-    fn tick(&mut self, c: EntityContext) -> Result<()> {
-        // self.spawn_cooldown -= dt;
-        // self.spawn_cooldown = self.spawn_cooldown.max(0.);
-        // if self.customers.len() < 5 && self.spawn_cooldown <= 0. {
-        //     self.spawn_cooldown = 10. + random::<f32>() * 10.;
-        //     let id = game.join_player(
-        //         faker::name::fr_fr::Name().fake(),
-        //         -1 - (random::<u16>() as i32),
-        //         packet_out,
-        //     );
-
-        //     let chair = self.select_chair().ok_or(anyhow!("no free chair found"))?;
-        //     let from = game.data.customer_spawn.as_ivec2();
-        //     let path = find_path(&game.walkable, from, chair)
-        //         .ok_or(anyhow!("no path from {from} to {chair}"))?;
-        //     info!("{id:?} -> entering");
-        //     self.customers
-        //         .insert(id, CustomerState::Entering { path, chair });
-        // }
-        // let mut customers_to_remove = Vec::new();
-        // for (&player, state) in &mut self.customers {
-        //     let Some(playerdata) = game.players.get_mut(&player) else {
-        //         continue;
-        //     };
-
-        //     match state {
-        //         CustomerState::Entering { path, chair } => {
-        //             playerdata
-        //                 .movement
-        //                 .input(path.next_direction(playerdata.position()), false);
-        //             if path.is_done() {
-        //                 let demand = DemandIndex(random::<u32>() as usize % self.demands.len());
-        //                 self.cpackets.push_back(PacketS::Communicate {
-        //                     message: Some(Message::Item(self.demands[demand.0].from)),
-        //                     persist: true,
-        //                     player,
-        //                 });
-        //                 info!("{player:?} -> waiting");
-        //                 *state = CustomerState::Waiting {
-        //                     chair: *chair,
-        //                     timeout: 90. + random::<f32>() * 60.,
-        //                     demand,
-        //                 };
-        //             }
-        //         }
-        //         CustomerState::Waiting {
-        //             chair,
-        //             demand,
-        //             timeout,
-        //         } => {
-        //             playerdata
-        //                 .movement
-        //                 .input((chair.as_vec2() + 0.5) - playerdata.position(), false);
-        //             *timeout -= dt;
-        //             if *timeout <= 0. {
-        //                 self.cpackets.push_back(PacketS::Communicate {
-        //                     message: None,
-        //                     persist: true,
-        //                     player,
-        //                 });
-        //                 self.cpackets.push_back(PacketS::Communicate {
-        //                     message: Some(Message::Effect("angry".to_string())),
-        //                     persist: false,
-        //                     player,
-        //                 });
-        //                 let path = find_path(
-        //                     &game.walkable,
-        //                     playerdata.position().as_ivec2(),
-        //                     game.data.customer_spawn.as_ivec2(),
-        //                 )
-        //                 .expect("no path to exit");
-        //                 *self.chairs.get_mut(chair).unwrap() = true;
-        //                 game.score.demands_failed += 1;
-        //                 game.score.points -= 1;
-        //                 game.score_changed = true;
-        //                 info!("{player:?} -> exiting");
-        //                 *state = CustomerState::Exiting { path }
-        //             } else {
-        //                 let demand_data = &self.demands[demand.0];
-        //                 let demand_pos = [IVec2::NEG_X, IVec2::NEG_Y, IVec2::X, IVec2::Y]
-        //                     .into_iter()
-        //                     .find_map(|off| {
-        //                         let pos = *chair + off;
-        //                         if game
-        //                             .tiles
-        //                             .get(&pos)
-        //                             .map(|t| {
-        //                                 t.item
-        //                                     .as_ref()
-        //                                     .map(|i| i.kind == demand_data.from)
-        //                                     .unwrap_or_default()
-        //                             })
-        //                             .unwrap_or_default()
-        //                         {
-        //                             Some(pos)
-        //                         } else {
-        //                             None
-        //                         }
-        //                     });
-        //                 if let Some(pos) = demand_pos {
-        //                     self.cpackets.push_back(PacketS::Communicate {
-        //                         persist: true,
-        //                         message: None,
-        //                         player,
-        //                     });
-        //                     self.cpackets.push_back(PacketS::Communicate {
-        //                         message: Some(Message::Effect("satisfied".to_string())),
-        //                         persist: false,
-        //                         player,
-        //                     });
-        //                     self.cpackets.push_back(PacketS::Interact {
-        //                         pos: Some(pos),
-        //                         player,
-        //                     });
-        //                     self.cpackets
-        //                         .push_back(PacketS::Interact { pos: None, player });
-        //                     info!("{player:?} -> eating");
-        //                     *state = CustomerState::Eating {
-        //                         demand: *demand,
-        //                         target: pos,
-        //                         progress: 0.,
-        //                         chair: *chair,
-        //                     }
-        //                 }
-        //             }
-        //         }
-        //         CustomerState::Eating {
-        //             demand,
-        //             target,
-        //             progress,
-        //             chair,
-        //         } => {
-        //             playerdata
-        //                 .movement
-        //                 .input((chair.as_vec2() + 0.5) - playerdata.position(), false);
-        //             let demand = &self.demands[demand.0];
-        //             *progress += dt / demand.duration;
-        //             if *progress >= 1. {
-        //                 self.cpackets.push_back(PacketS::ReplaceHand {
-        //                     player,
-        //                     item: demand.to,
-        //                 });
-        //                 if demand.to.is_some() {
-        //                     self.cpackets.push_back(PacketS::Interact {
-        //                         player,
-        //                         pos: Some(*target),
-        //                     });
-        //                     self.cpackets
-        //                         .push_back(PacketS::Interact { player, pos: None });
-        //                 }
-        //                 let path = find_path(
-        //                     &game.walkable,
-        //                     playerdata.position().as_ivec2(),
-        //                     game.data.customer_spawn.as_ivec2(),
-        //                 )
-        //                 .ok_or(anyhow!("no path to exit"))?;
-        //                 *self.chairs.get_mut(chair).unwrap() = true;
-        //                 game.score.demands_completed += 1;
-        //                 game.score.points += demand.points;
-        //                 game.score_changed = true;
-        //                 info!("{player:?} -> exiting");
-        //                 *state = CustomerState::Exiting { path }
-        //             }
-        //         }
-        //         CustomerState::Exiting { path } => {
-        //             playerdata
-        //                 .movement
-        //                 .input(path.next_direction(playerdata.position()), false);
-        //             if path.is_done() {
-        //                 info!("{player:?} -> leave");
-        //                 self.cpackets.push_back(PacketS::Leave { player });
-        //                 customers_to_remove.push(player);
-        //             }
-        //         }
-        //     }
-        // }
-        // for c in customers_to_remove {
-        //     self.customers.remove(&c).unwrap();
-        // }
-        // for packet in self.cpackets.drain(..) {
-        //     if let Err(err) = game.packet_in(packet, &mut vec![], packet_out) {
-        //         warn!("demand packet {err}");
-        //     }
-        // }
-        Ok(())
-    }
-}
-impl Customers {
-    fn select_chair(&mut self) -> Option<IVec2> {
-        use rand::seq::IteratorRandom;
-        let (chosen, free) = self
-            .chairs
-            .iter_mut()
-            .filter(|(_p, free)| **free)
-            .choose(&mut thread_rng())?;
-        *free = false;
-        Some(*chosen)
-    }
-}
diff --git a/server/src/entity/customers/pathfinding.rs b/server/src/entity/customers/pathfinding.rs
deleted file mode 100644
index 87ccf391..00000000
--- a/server/src/entity/customers/pathfinding.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-    Hurry Curry! - a game about cooking
-    Copyright 2024 metamuffin
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, version 3 of the License only.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-*/
-use hurrycurry_protocol::glam::{IVec2, Vec2};
-use log::trace;
-use std::{
-    cmp::Ordering,
-    collections::{BinaryHeap, HashMap, HashSet},
-};
-
-#[derive(Debug, Clone)]
-pub struct Path(Vec<Vec2>);
-
-impl Path {
-    pub fn next_direction(&mut self, position: Vec2) -> Vec2 {
-        if let Some(next) = self.0.last().copied() {
-            trace!("next {next}");
-            if next.distance(position) < if self.0.len() == 1 { 0.1 } else { 0.6 } {
-                self.0.pop();
-            }
-            (next - position).normalize_or_zero() * 0.5
-        } else {
-            Vec2::ZERO
-        }
-    }
-    pub fn is_done(&self) -> bool {
-        self.0.is_empty()
-    }
-}
-
-pub fn find_path(walkable: &HashSet<IVec2>, from: IVec2, to: IVec2) -> Option<Path> {
-    #[derive(Debug, PartialEq, Eq)]
-    struct Open(i32, IVec2, IVec2, i32);
-    impl PartialOrd for Open {
-        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-            Some(self.0.cmp(&other.0))
-        }
-    }
-    impl Ord for Open {
-        fn cmp(&self, other: &Self) -> Ordering {
-            self.0.cmp(&other.0)
-        }
-    }
-
-    let mut visited = HashMap::new();
-    let mut open = BinaryHeap::new();
-    open.push(Open(1, from, from, 0));
-
-    loop {
-        let Open(_, pos, f, distance) = open.pop()?;
-        if visited.contains_key(&pos) {
-            continue;
-        }
-        visited.insert(pos, f);
-        if pos == to {
-            break;
-        }
-        for dir in [IVec2::NEG_X, IVec2::NEG_Y, IVec2::X, IVec2::Y] {
-            let next = pos + dir;
-            if walkable.contains(&next) {
-                open.push(Open(
-                    -(distance + next.distance_squared(to).isqrt()),
-                    next,
-                    pos,
-                    distance + 1,
-                ));
-            }
-        }
-    }
-
-    let mut path = Vec::new();
-    let mut c = to;
-    loop {
-        path.push(c.as_vec2() + 0.5);
-        let cn = visited[&c];
-        if cn == c {
-            break;
-        }
-        c = cn
-    }
-    Some(Path(path))
-}
diff --git a/server/src/entity/mod.rs b/server/src/entity/mod.rs
index efee6a6d..20370d0c 100644
--- a/server/src/entity/mod.rs
+++ b/server/src/entity/mod.rs
@@ -25,17 +25,17 @@ pub mod player_portal;
 use crate::data::ItemTileRegistry;
 use anyhow::{anyhow, Result};
 use conveyor::Conveyor;
-use customers::{demands::generate_demands, Customers};
+use customers::Customers;
 use environment_effect::{EnvironmentController, EnvironmentEffect, EnvironmentEffectController};
 use hurrycurry_client_lib::Game;
 use hurrycurry_protocol::{
     glam::{IVec2, Vec2},
-    ItemIndex, PacketC, PacketS, Recipe, TileIndex,
+    PacketC, PacketS,
 };
 use item_portal::ItemPortal;
 use player_portal::PlayerPortal;
 use serde::{Deserialize, Serialize};
-use std::collections::{HashMap, HashSet, VecDeque};
+use std::collections::VecDeque;
 
 pub type DynEntity = Box<dyn Entity + Send + Sync + 'static>;
 pub type Entities = Vec<DynEntity>;
@@ -104,11 +104,6 @@ pub fn construct_entity(
     pos: Option<IVec2>,
     decl: &EntityDecl,
     reg: &ItemTileRegistry,
-    tiles_used: &HashSet<TileIndex>,
-    items_used: &HashSet<ItemIndex>,
-    raw_demands: &[(ItemIndex, Option<ItemIndex>, f32)],
-    recipes: &[Recipe],
-    initial_map: &HashMap<IVec2, (TileIndex, Option<ItemIndex>)>,
 ) -> Result<DynEntity> {
     Ok(match decl.to_owned() {
         EntityDecl::ItemPortal { from, to } => Box::new(ItemPortal {
@@ -142,16 +137,7 @@ pub fn construct_entity(
                 cooldown: 0.,
             })
         }
-        EntityDecl::Customers {} => {
-            let demands = generate_demands(tiles_used, items_used, raw_demands, recipes);
-            let chair = reg.register_tile("chair".to_string());
-            let chairs = initial_map
-                .iter()
-                .filter(|(_, (tile, _))| *tile == chair)
-                .map(|(e, _)| (*e, true))
-                .collect();
-            Box::new(Customers::new(chairs, demands)?)
-        }
+        EntityDecl::Customers {} => Box::new(Customers::new()?),
         EntityDecl::EnvironmentEffect(config) => Box::new(EnvironmentEffectController::new(config)),
         EntityDecl::Environment(names) => Box::new(EnvironmentController(names)),
     })
diff --git a/server/src/server.rs b/server/src/server.rs
index faac080f..49d0b461 100644
--- a/server/src/server.rs
+++ b/server/src/server.rs
@@ -40,6 +40,7 @@ pub struct ServerState {
     pub lobby: bool,
     pub player_id_counter: PlayerID,
     pub score_changed: bool,
+    pub packet_loopback: VecDeque<PacketS>,
 }
 
 pub struct Server<'a> {
@@ -218,6 +219,7 @@ impl ServerState {
             entities: vec![],
             player_id_counter: PlayerID(1),
             score_changed: false,
+            packet_loopback: VecDeque::new(),
         }
     }
 }
@@ -230,17 +232,25 @@ impl Server<'_> {
     ) {
         self.game.load(gamedata, &serverdata, timer, packet_out);
         self.state.data = serverdata.into();
+        for mut e in self.state.entities.drain(..) {
+            e.destructor(EntityContext {
+                game: self.game,
+                packet_out,
+                packet_in: &mut self.state.packet_loopback,
+                score_changed: &mut self.state.score_changed,
+                dt: 0.,
+            });
+        }
         self.state.entities = entities;
     }
 
     pub fn join_player(
         &mut self,
+        id: PlayerID,
         name: String,
         character: i32,
         packet_out: &mut VecDeque<PacketC>,
-    ) -> PlayerID {
-        let id = self.state.player_id_counter;
-        self.state.player_id_counter.0 += 1;
+    ) {
         let position = if character < 0 {
             self.state.data.customer_spawn
         } else {
@@ -274,7 +284,6 @@ impl Server<'_> {
             position,
             character,
         });
-        id
     }
 
     pub fn packet_in(
@@ -284,8 +293,17 @@ impl Server<'_> {
         packet_out: &mut VecDeque<PacketC>,
     ) -> Result<()> {
         match packet {
-            PacketS::Join { name, character } => {
-                let id = self.join_player(name, character, packet_out);
+            PacketS::Join {
+                name,
+                character,
+                id,
+            } => {
+                let id = id.unwrap_or_else(|| {
+                    let id = self.state.player_id_counter;
+                    self.state.player_id_counter.0 += 1;
+                    id
+                });
+                self.join_player(id, name, character, packet_out);
                 replies.push(PacketC::Joined { id })
             }
             PacketS::Leave { player } => {
@@ -586,20 +604,22 @@ impl Server<'_> {
             );
         }
 
-        let mut packet_in = VecDeque::new();
         for entity in self.state.entities.iter_mut() {
             if let Err(e) = entity.tick(EntityContext {
                 game: self.game,
                 packet_out,
                 score_changed: &mut self.state.score_changed,
-                packet_in: &mut packet_in,
+                packet_in: &mut self.state.packet_loopback,
                 dt,
             }) {
                 warn!("entity tick failed: {e}")
             }
         }
-        for p in packet_in.drain(..) {
-            let _ = self.packet_in(p, &mut vec![], packet_out);
+
+        while let Some(p) = self.state.packet_loopback.pop_front() {
+            if let Err(e) = self.packet_in(p, &mut vec![], packet_out) {
+                warn!("internal packet errored: {e}");
+            }
         }
 
         let now = Instant::now();