3 files changed, 340 insertions, 0 deletions
diff --git a/server/src/customer/mod.rs b/server/src/customer/mod.rs
new file mode 100644
index 00000000..ab3accdd
--- /dev/null
+++ b/server/src/customer/mod.rs
@@ -0,0 +1,201 @@
+pub mod movement;
+mod pathfinding;
+
+use crate::{
+    data::Gamedata,
+    game::Game,
+    protocol::{ItemIndex, Message, PacketC, PacketS, PlayerID},
+};
+use glam::{IVec2, Vec2};
+use log::{debug, error};
+use movement::MovementBase;
+use pathfinding::{find_path, Path};
+use rand::thread_rng;
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
+    time::Duration,
+};
+use tokio::{
+    sync::{broadcast, RwLock},
+    time::interval,
+};
+
+struct DemandState {
+    data: Gamedata,
+    walkable: HashSet<IVec2>,
+    chairs: HashMap<IVec2, bool>,
+    items: HashMap<IVec2, ItemIndex>,
+    customers: HashMap<PlayerID, Customer>,
+}
+
+enum CustomerState {
+    WalkingToChair { path: Path, chair: IVec2 },
+    Waiting { chair: IVec2, demand: ItemIndex },
+    Exiting { path: Path },
+}
+
+struct Customer {
+    movement: MovementBase,
+    state: CustomerState,
+}
+
+pub async fn customer(game: Arc<RwLock<Game>>, mut grx: broadcast::Receiver<PacketC>) {
+    let mut state = DemandState {
+        walkable: Default::default(),
+        chairs: Default::default(),
+        items: Default::default(),
+        customers: Default::default(),
+        data: Gamedata::default(),
+    };
+    let initial = game.write().await.prime_client(-1);
+    for p in initial {
+        match p {
+            PacketC::Init { data, .. } => {
+                state.data = data;
+            }
+            PacketC::UpdateMap { pos, tile, .. } => {
+                let tilename = &state.data.tile_names[tile];
+                if tilename == "floor" || tilename == "door" || tilename == "chair" {
+                    state.walkable.insert(pos);
+                }
+                if tilename == "chair" {
+                    state.chairs.insert(pos, true);
+                }
+            }
+            _ => (),
+        }
+    }
+
+    let mut interval = interval(Duration::from_millis(40));
+    let mut packets_out = Vec::new();
+    loop {
+        tokio::select! {
+            packet = grx.recv() => {
+                match packet.unwrap() {
+                    PacketC::PutItem { .. }
+                    | PacketC::TakeItem { .. }
+                    | PacketC::ProduceItem { .. }
+                    | PacketC::ConsumeItem { .. } => {
+                        let g = game.read().await;
+                        update_items(&mut state, &g)
+                    },
+                    _ => ()
+                }
+            }
+            _ = interval.tick() => {
+                state.tick(&mut packets_out, 0.04);
+                for (player,packet) in packets_out.drain(..) {
+                    if let Err(e) = game.write().await.packet_in(player, packet) {
+                        error!("customer misbehaved: {e}")
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn update_items(state: &mut DemandState, game: &Game) {
+    state.items.clear();
+    for (&pos, tile) in game.tiles() {
+        if let Some(item) = &tile.item {
+            state.items.insert(pos, item.kind);
+        }
+    }
+}
+
+impl DemandState {
+    pub fn tick(&mut self, packets_out: &mut Vec<(PlayerID, PacketS)>, dt: f32) {
+        if self.customers.is_empty() {
+            let id = -1;
+            packets_out.push((
+                id,
+                PacketS::Join {
+                    name: "George".to_string(),
+                    character: 0,
+                },
+            ));
+            let chair = select_chair(&mut self.chairs);
+            let path = find_path(&self.walkable, self.data.customer_spawn.as_ivec2(), chair)
+                .expect("no path");
+            self.customers.insert(
+                id,
+                Customer {
+                    movement: MovementBase {
+                        position: self.data.customer_spawn,
+                        facing: Vec2::X,
+                        vel: Vec2::ZERO,
+                    },
+                    state: CustomerState::WalkingToChair { path, chair },
+                },
+            );
+        }
+        let mut customers_to_remove = Vec::new();
+        for (&id, p) in &mut self.customers {
+            match &mut p.state {
+                CustomerState::WalkingToChair { path, chair } => {
+                    packets_out.push((id, path.execute_tick(&mut p.movement, &self.walkable, dt)));
+                    if path.is_done() {
+                        let demand = self.data.get_item("tomato").unwrap();
+                        packets_out.push((
+                            id,
+                            PacketS::Communicate {
+                                message: Some(Message::Item(demand)),
+                            },
+                        ));
+                        p.state = CustomerState::Waiting {
+                            chair: *chair,
+                            demand,
+                        };
+                    }
+                }
+                CustomerState::Waiting { chair, demand } => {
+                    let demand_pos = [IVec2::NEG_X, IVec2::NEG_Y, IVec2::X, IVec2::Y]
+                        .into_iter()
+                        .find_map(|off| {
+                            let pos = *chair + off;
+                            if self.items.get(&pos) == Some(demand) {
+                                Some(pos)
+                            } else {
+                                None
+                            }
+                        });
+                    if let Some(pos) = demand_pos {
+                        if self.items.get(&pos) == Some(demand) {
+                            packets_out.push((id, PacketS::Communicate { message: None }));
+                            let path = find_path(
+                                &self.walkable,
+                                p.movement.position.as_ivec2(),
+                                self.data.customer_spawn.as_ivec2(),
+                            )
+                            .expect("no path to exit");
+                            p.state = CustomerState::Exiting { path }
+                        }
+                    }
+                    debug!("waiting")
+                }
+                CustomerState::Exiting { path } => {
+                    packets_out.push((id, path.execute_tick(&mut p.movement, &self.walkable, dt)));
+                    if path.is_done() {
+                        packets_out.push((id, PacketS::Leave));
+                        customers_to_remove.push(id);
+                    }
+                }
+            }
+        }
+        for c in customers_to_remove {
+            self.customers.remove(&c).unwrap();
+        }
+    }
+}
+
+pub fn select_chair(chairs: &mut HashMap<IVec2, bool>) -> IVec2 {
+    use rand::seq::IteratorRandom;
+    let (chosen, free) = chairs
+        .iter_mut()
+        .filter(|(_p, free)| **free)
+        .choose(&mut thread_rng())
+        .unwrap();
+    *free = false;
+    *chosen
+}
diff --git a/server/src/customer/movement.rs b/server/src/customer/movement.rs
new file mode 100644
index 00000000..0ddabd0b
--- /dev/null
+++ b/server/src/customer/movement.rs
@@ -0,0 +1,56 @@
+use crate::protocol::PacketS;
+use glam::{IVec2, Vec2};
+use std::collections::HashSet;
+
+pub struct MovementBase {
+    pub position: Vec2,
+    pub facing: Vec2,
+    pub vel: Vec2,
+}
+
+impl MovementBase {
+    pub fn update(&mut self, map: &HashSet<IVec2>, direction: Vec2, dt: f32) -> PacketS {
+        let direction = direction.normalize_or_zero();
+        if direction.length() > 0.1 {
+            self.facing = direction + (self.facing - direction) * (-dt * 10.).exp();
+        }
+        let rot = self.facing.x.atan2(self.facing.y);
+        self.vel += direction * dt * 0.5;
+        self.position += self.vel;
+        self.vel = self.vel * (-dt * 5.).exp();
+        collide_player(self, map);
+        PacketS::Position {
+            pos: self.position,
+            rot,
+        }
+    }
+}
+
+const PLAYER_SIZE: f32 = 0.4;
+pub fn collide_player(p: &mut MovementBase, map: &HashSet<IVec2>) {
+    for xo in -1..=1 {
+        for yo in -1..=1 {
+            let tile = IVec2::new(xo, yo) + p.position.as_ivec2();
+            if map.contains(&tile) {
+                continue;
+            }
+            let tile = tile.as_vec2();
+            let d = aabb_circle_distance(tile, tile + Vec2::ONE, p.position);
+            if d > PLAYER_SIZE {
+                continue;
+            }
+            let h = 0.01;
+            let d_sample_x =
+                aabb_circle_distance(tile, tile + Vec2::ONE, p.position + Vec2::new(h, 0.));
+            let d_sample_y =
+                aabb_circle_distance(tile, tile + Vec2::ONE, p.position + Vec2::new(0., h));
+            let grad = (Vec2::new(d_sample_x, d_sample_y) - d) / h;
+
+            p.position += (PLAYER_SIZE - d) * grad;
+            p.vel -= grad * grad.dot(p.vel);
+        }
+    }
+}
+pub fn aabb_circle_distance(min: Vec2, max: Vec2, p: Vec2) -> f32 {
+    (p - p.clamp(min, max)).length()
+}
diff --git a/server/src/customer/pathfinding.rs b/server/src/customer/pathfinding.rs
new file mode 100644
index 00000000..d25c6913
--- /dev/null
+++ b/server/src/customer/pathfinding.rs
@@ -0,0 +1,83 @@
+use super::movement::MovementBase;
+use crate::protocol::PacketS;
+use glam::{IVec2, Vec2};
+use log::debug;
+use std::{
+    cmp::Ordering,
+    collections::{BinaryHeap, HashMap, HashSet},
+};
+
+pub struct Path(Vec<Vec2>);
+
+impl Path {
+    pub fn execute_tick(
+        &mut self,
+        customer: &mut MovementBase,
+        walkable: &HashSet<IVec2>,
+        dt: f32,
+    ) -> PacketS {
+        if let Some(next) = self.0.last().copied() {
+            debug!("next {next}");
+            if next.distance(customer.position) < if self.0.len() == 1 { 0.1 } else { 0.6 } {
+                self.0.pop();
+            }
+            customer.update(&walkable, next - customer.position, dt)
+        } else {
+            customer.update(&walkable, Vec2::ZERO, dt)
+        }
+    }
+    pub fn is_done(&self) -> bool {
+        self.0.is_empty()
+    }
+}
+
+pub fn find_path(map: &HashSet<IVec2>, from: IVec2, to: IVec2) -> Option<Path> {
+    #[derive(Debug, PartialEq, Eq)]
+    struct Open(i32, IVec2, IVec2);
+    impl PartialOrd for Open {
+        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+            self.0.partial_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));
+
+    loop {
+        let Some(Open(_, p, f)) = open.pop() else {
+            eprintln!("{visited:?}");
+            return None;
+        };
+        if visited.contains_key(&p) {
+            continue;
+        }
+        visited.insert(p, f);
+        if p == to {
+            break;
+        }
+        for d in [IVec2::NEG_X, IVec2::NEG_Y, IVec2::X, IVec2::Y] {
+            let n = p + d;
+            if map.contains(&n) {
+                open.push(Open(-d.distance_squared(to), n, p));
+            }
+        }
+    }
+
+    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))
+}