flatland_client_lib/

use_world.rs

//! Probe what `f` / [`crate::GameClient::use_nearest`] would do — shared by gfx highlights.

use crate::game::{GameState, CONTAINER_RANGE_M};

const INTERACTION_RADIUS_M: f32 = 1.5;
const DOOR_INTERACTION_RADIUS_M: f32 = 2.0;
const QUEST_BOARD_INTERACTION_RADIUS_M: f32 = 3.0;
/// Hired workers on a latch yield `f` so the player can still open/enter.
const DOOR_WORKER_YIELD_M: f32 = 2.5;
/// Extra door reach when a worker occupies the approach (standoff is ~0.9 m).
const DOOR_WORKER_APPROACH_M: f32 = 3.0;
const CHEST_PICKUP_RANGE_M: f32 = 2.0;
const HARVEST_RANGE_M: f32 = 1.5;
/// Candidates beyond this are omitted from the probe list.
pub const USE_WORLD_NEARBY_SCAN_M: f32 = 5.0;
/// Max distance from cursor to a point entity for hover label pick (gfx).
pub const WORLD_HOVER_PICK_M: f32 = 1.75;

fn distance(ax: f32, ay: f32, bx: f32, by: f32) -> f32 {
    (ax - bx).hypot(ay - by)
}

/// What kind of world-use target this is (drives tint + verb).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum UseWorldKind {
    Player,
    Npc,
    HiredWorker,
    QuestBoard,
    ExitDoor,
    EnterDoor,
    /// Player-building exterior: open closed latch.
    OpenDoor,
    /// Player-building exterior: close open latch.
    CloseDoor,
    Loot,
    ChestPickup,
    Harvest,
}

impl UseWorldKind {
    pub fn verb(self) -> &'static str {
        match self {
            Self::Player => "Whisper/Trade",
            Self::Npc => "Talk/Trade",
            Self::HiredWorker => "Manage",
            Self::QuestBoard => "Read board",
            Self::ExitDoor => "Exit",
            Self::EnterDoor => "Enter",
            Self::OpenDoor => "Open",
            Self::CloseDoor => "Close",
            Self::Loot => "Pick up",
            Self::ChestPickup => "Pick up chest",
            Self::Harvest => "Harvest",
        }
    }

    /// Sort key within a target class (lower = preferred).
    pub fn interact_priority(self) -> u8 {
        match self {
            Self::Harvest => 0,
            Self::EnterDoor | Self::OpenDoor | Self::CloseDoor => 1,
            Self::ExitDoor => 2,
            Self::QuestBoard => 3,
            Self::Player | Self::Npc => 4,
            Self::HiredWorker => 5,
            Self::Loot => 10,
            Self::ChestPickup => 11,
        }
    }

    /// Class for F-hint / interact ranking. Lower wins even when farther (still in range).
    /// Harvest → enter/open doors → boards → players/NPCs → exit doors → hired workers.
    /// Exit stays below town NPCs so interior spawn can still Talk; exits still beat companions.
    pub fn f_target_class(self) -> u8 {
        match self {
            Self::Harvest => 0,
            Self::EnterDoor | Self::OpenDoor | Self::CloseDoor => 1,
            Self::QuestBoard => 2,
            Self::Player | Self::Npc => 3,
            Self::ExitDoor => 4,
            Self::HiredWorker => 5,
            Self::Loot => 10,
            Self::ChestPickup => 11,
        }
    }

    /// Cascade stage for `use_nearest` after loot-first
    /// (0 = interact/doors, then loot, chest/lodging, harvest).
    pub fn cascade_stage(self) -> u8 {
        match self {
            Self::Player
            | Self::Npc
            | Self::HiredWorker
            | Self::QuestBoard
            | Self::ExitDoor
            | Self::EnterDoor
            | Self::OpenDoor
            | Self::CloseDoor => 0,
            Self::Loot => 1,
            Self::ChestPickup => 2,
            Self::Harvest => 3,
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct UseWorldCandidate {
    pub id: String,
    pub kind: UseWorldKind,
    pub label: String,
    pub x: f32,
    pub y: f32,
    pub distance_m: f32,
    pub range_m: f32,
    /// True when within the range `f` would accept for this kind.
    pub in_range: bool,
}

impl UseWorldCandidate {
    pub fn hint_line(&self) -> String {
        let base = if self.label.trim().is_empty() {
            format!("f → {} ({:.1}m)", self.kind.verb(), self.distance_m)
        } else {
            format!(
                "f → {} {} ({:.1}m)",
                self.kind.verb(),
                self.label,
                self.distance_m
            )
        };
        match self.kind {
            UseWorldKind::OpenDoor => format!("{base} · Enter pass · l lock"),
            UseWorldKind::CloseDoor => format!("{base} · Enter pass · l lock"),
            _ => base,
        }
    }
}

/// Prefer friendly labels; never surface raw identity stamps to the player.
fn friendly_or_id(label: &str, id: &str) -> String {
    let trimmed = label.trim();
    if !trimmed.is_empty() && !looks_like_raw_id(trimmed) {
        return trimmed.to_string();
    }
    if !looks_like_raw_id(id) {
        return id.to_string();
    }
    "House".into()
}

fn looks_like_raw_id(s: &str) -> bool {
    let t = s.trim();
    if t.is_empty() {
        return true;
    }
    if uuid::Uuid::parse_str(t).is_ok() {
        return true;
    }
    let lower = t.to_ascii_lowercase();
    if lower.starts_with("property_")
        || lower.starts_with("player-plot-")
        || lower.starts_with("building_")
        || lower.starts_with("bldg_")
    {
        return true;
    }
    if let Some(rest) = t
        .strip_prefix("House — ")
        .or_else(|| t.strip_prefix("House - "))
    {
        return looks_like_raw_id(rest);
    }
    false
}

fn door_use_label(state: &GameState, door: &flatland_protocol::DoorView, is_exit: bool) -> String {
    if is_exit {
        return "outdoors".into();
    }
    if let Some(map) = &state.interior_map {
        if let Some(rd) = map.room_doors.iter().find(|d| d.id == door.id) {
            let room_name = |room_id: &str| {
                map.rooms
                    .iter()
                    .find(|r| r.id == room_id)
                    .map(|r| friendly_or_id(&r.label, room_id))
                    .unwrap_or_else(|| "Room".into())
            };
            return format!("{} ↔ {}", room_name(&rd.room_a), room_name(&rd.room_b));
        }
    }
    let building = state.buildings.iter().find(|b| b.id == door.building_id);
    if let Some(b) = building {
        let name = friendly_or_id(&b.label, &b.id);
        if door_is_player_built(state, door) && looks_like_raw_id(&name) {
            return "House".into();
        }
        return name;
    }
    if door_is_player_built(state, door) {
        "House".into()
    } else {
        "Building".into()
    }
}

fn door_is_player_built(state: &GameState, door: &flatland_protocol::DoorView) -> bool {
    state
        .buildings
        .iter()
        .find(|b| b.id == door.building_id)
        .is_some_and(|b| b.tags.iter().any(|t| t == "player_built"))
}

fn outdoor_door_kind(state: &GameState, door: &flatland_protocol::DoorView) -> UseWorldKind {
    if door_is_player_built(state, door) {
        if door.open {
            return UseWorldKind::CloseDoor;
        }
        return UseWorldKind::OpenDoor;
    }
    UseWorldKind::EnterDoor
}

/// Walk the same door set `f` uses (current interior vs outdoor latches).
fn for_each_interact_door(
    state: &GameState,
    mut visit: impl FnMut(&flatland_protocol::DoorView, f32),
) {
    let inside = state.effective_inside_building();
    for door in &state.doors {
        if let Some(ref bid) = inside {
            if door.building_id != *bid {
                continue;
            }
            let is_portal = door.portal.is_some();
            let range = if is_portal {
                INTERACTION_RADIUS_M
            } else {
                DOOR_INTERACTION_RADIUS_M
            };
            visit(door, range);
            continue;
        }
        visit(door, DOOR_INTERACTION_RADIUS_M);
    }
}

fn door_has_nearby_hired_worker(state: &GameState, door: &flatland_protocol::DoorView) -> bool {
    state
        .hired_workers
        .iter()
        .any(|w| distance(w.x, w.y, door.x, door.y) <= DOOR_WORKER_YIELD_M)
}

/// Widen door `f` range when a hired worker is camped on the latch/approach.
pub(crate) fn interact_door_range_m(
    state: &GameState,
    door: &flatland_protocol::DoorView,
    base_range: f32,
) -> f32 {
    if door_has_nearby_hired_worker(state, door) {
        base_range.max(DOOR_WORKER_APPROACH_M)
    } else {
        base_range
    }
}

/// True when this worker should not steal `f` from a door the player is approaching.
pub(crate) fn hired_worker_yields_to_door(
    state: &GameState,
    px: f32,
    py: f32,
    worker_x: f32,
    worker_y: f32,
) -> bool {
    let mut yields = false;
    for_each_interact_door(state, |door, _range| {
        if yields {
            return;
        }
        if distance(px, py, door.x, door.y) > DOOR_WORKER_APPROACH_M {
            return;
        }
        if distance(worker_x, worker_y, door.x, door.y) <= DOOR_WORKER_YIELD_M {
            yields = true;
        }
    });
    yields
}

#[derive(Debug, Clone, PartialEq, Default)]
pub struct UseWorldProbe {
    /// What `f` will actually do right now (if anything).
    pub primary: Option<UseWorldCandidate>,
    /// All AOI candidates within [`USE_WORLD_NEARBY_SCAN_M`], for dim rings.
    pub candidates: Vec<UseWorldCandidate>,
}

impl UseWorldProbe {
    pub fn hint_line(&self) -> String {
        match &self.primary {
            Some(c) => c.hint_line(),
            None => "f → nothing in range".into(),
        }
    }
}

impl GameState {
    /// Analyze AOI for `f` presentation (rings, HUD hint). Does not submit intents.
    pub fn probe_use_world(&self) -> UseWorldProbe {
        let (px, py) = self.player_position();
        self.probe_use_world_at(px, py)
    }

    /// Same as [`probe_use_world`] but distances are from `(wx, wy)` (e.g. mouse on map).
    pub fn probe_use_world_at(&self, wx: f32, wy: f32) -> UseWorldProbe {
        let inside = self.effective_inside_building();
        let mut candidates: Vec<UseWorldCandidate> = Vec::new();

        let push = |list: &mut Vec<UseWorldCandidate>,
                    id: String,
                    kind: UseWorldKind,
                    label: String,
                    x: f32,
                    y: f32,
                    range_m: f32| {
            let distance_m = distance(wx, wy, x, y);
            if distance_m > USE_WORLD_NEARBY_SCAN_M {
                return;
            }
            list.push(UseWorldCandidate {
                id,
                kind,
                label,
                x,
                y,
                distance_m,
                range_m,
                in_range: distance_m <= range_m,
            });
        };

        for npc in &self.npcs {
            push(
                &mut candidates,
                npc.id.clone(),
                UseWorldKind::Npc,
                npc.label.clone(),
                npc.x,
                npc.y,
                INTERACTION_RADIUS_M,
            );
        }

        for worker in &self.hired_workers {
            if hired_worker_yields_to_door(self, wx, wy, worker.x, worker.y) {
                continue;
            }
            push(
                &mut candidates,
                worker.instance_id.clone(),
                UseWorldKind::HiredWorker,
                worker.label.clone(),
                worker.x,
                worker.y,
                INTERACTION_RADIUS_M,
            );
        }

        for entity in &self.entities {
            if entity.id == self.entity_id {
                continue;
            }
            // Other players: have a label and are not wildlife/NPC (NPCs live in `npcs`).
            // Agents/hired workers may appear in entities — prefer those with vitals + label.
            if entity.label.trim().is_empty() {
                continue;
            }
            if self.npcs.iter().any(|n| n.id == entity.id.to_string()) {
                continue;
            }
            // Hired workers use the workers menu / NPC dialogue — not Whisper/Trade.
            if self.hired_workers.iter().any(|w| w.entity_id == entity.id) {
                continue;
            }
            // Skip if this looks like a wildlife/NPC entity already covered — players have vitals.
            if entity.vitals.is_none() {
                continue;
            }
            let x = entity.transform.position.x;
            let y = entity.transform.position.y;
            push(
                &mut candidates,
                entity.id.to_string(),
                UseWorldKind::Player,
                entity.label.clone(),
                x,
                y,
                INTERACTION_RADIUS_M,
            );
        }

        for door in &self.doors {
            if let Some(ref bid) = inside {
                if door.building_id != *bid {
                    continue;
                }
                let is_portal = door.portal.is_some();
                let (kind, range) = if is_portal && door_is_player_built(self, door) {
                    // House exterior latch from inside: f open/close (Enter exits freely).
                    (outdoor_door_kind(self, door), INTERACTION_RADIUS_M)
                } else if is_portal {
                    (UseWorldKind::ExitDoor, INTERACTION_RADIUS_M)
                } else {
                    (UseWorldKind::EnterDoor, DOOR_INTERACTION_RADIUS_M)
                };
                let label = if is_portal && door_is_player_built(self, door) {
                    door_use_label(self, door, false)
                } else {
                    door_use_label(self, door, is_portal)
                };
                push(
                    &mut candidates,
                    door.id.clone(),
                    kind,
                    label,
                    door.x,
                    door.y,
                    interact_door_range_m(self, door, range),
                );
                continue;
            }
            push(
                &mut candidates,
                door.id.clone(),
                outdoor_door_kind(self, door),
                door_use_label(self, door, false),
                door.x,
                door.y,
                interact_door_range_m(self, door, DOOR_INTERACTION_RADIUS_M),
            );
        }

        if inside.is_none() {
            for inter in &self.interactables {
                if inter.kind == "quest_board" {
                    push(
                        &mut candidates,
                        inter.id.clone(),
                        UseWorldKind::QuestBoard,
                        inter.label.clone(),
                        inter.x,
                        inter.y,
                        QUEST_BOARD_INTERACTION_RADIUS_M,
                    );
                }
            }
        }

        for drop in &self.ground_drops {
            let display = drop
                .display_name
                .as_deref()
                .filter(|s| !s.is_empty())
                .unwrap_or(&drop.template_id);
            let label = if drop.quantity > 1 {
                format!("{} ×{}", display, drop.quantity)
            } else {
                display.to_string()
            };
            push(
                &mut candidates,
                drop.id.clone(),
                UseWorldKind::Loot,
                label,
                drop.x,
                drop.y,
                INTERACTION_RADIUS_M,
            );
        }

        for chest in &self.placed_containers {
            if !self.placed_container_in_current_space(chest) {
                continue;
            }
            let _browse = CONTAINER_RANGE_M;
            let mut label = chest.display_name.clone();
            if let Some(who) = self.lodging_occupancy_label(&chest.id) {
                label = format!("{label} ({who})");
            }
            push(
                &mut candidates,
                chest.id.clone(),
                UseWorldKind::ChestPickup,
                label,
                chest.x,
                chest.y,
                CHEST_PICKUP_RANGE_M,
            );
        }

        for node in &self.resource_nodes {
            if node.id.starts_with("preview:") {
                continue;
            }
            if node.harvest_off {
                continue;
            }
            if !matches!(
                node.state,
                flatland_protocol::ResourceNodeState::Available
                    | flatland_protocol::ResourceNodeState::Harvesting
            ) {
                continue;
            }
            push(
                &mut candidates,
                node.id.clone(),
                UseWorldKind::Harvest,
                node.label.clone(),
                node.x,
                node.y,
                HARVEST_RANGE_M,
            );
        }

        let primary = pick_primary(&candidates);

        UseWorldProbe {
            primary,
            candidates,
        }
    }

    /// True when `f` can harvest a resource node (same filters as `harvest_nearest`).
    pub fn harvestable_node_in_range(&self) -> bool {
        let (px, py) = self.player_position();
        self.resource_nodes.iter().any(|node| {
            if node.id.starts_with("preview:") || node.harvest_off {
                return false;
            }
            if node.state != flatland_protocol::ResourceNodeState::Available {
                return false;
            }
            distance(px, py, node.x, node.y) <= HARVEST_RANGE_M
        })
    }

    /// Short label for gfx map hover (nearest entity under cursor).
    pub fn hover_hint_at(&self, wx: f32, wy: f32) -> Option<String> {
        self.hover_hint_at_respecting(wx, wy, |_| true)
    }

    /// Like [`hover_hint_at`], but skips candidates whose kind fails `include_kind`.
    pub fn hover_hint_at_respecting(
        &self,
        wx: f32,
        wy: f32,
        include_kind: impl Fn(UseWorldKind) -> bool,
    ) -> Option<String> {
        let mut best_d = WORLD_HOVER_PICK_M;
        let mut best: Option<String> = None;

        for b in &self.buildings {
            let hw = b.width_m * 0.5;
            let hd = b.depth_m * 0.5;
            if wx < b.x - hw || wx > b.x + hw || wy < b.y - hd || wy > b.y + hd {
                continue;
            }
            let d = distance(wx, wy, b.x, b.y);
            if d <= best_d {
                best_d = d;
                best = Some(friendly_or_id(&b.label, &b.id));
            }
        }

        let probe = self.probe_use_world_at(wx, wy);
        for c in &probe.candidates {
            if !include_kind(c.kind) {
                continue;
            }
            let d = distance(wx, wy, c.x, c.y);
            if d > WORLD_HOVER_PICK_M {
                continue;
            }
            if d <= best_d {
                best_d = d;
                best = Some(hover_label_for_candidate(c));
            }
        }
        best
    }
}

fn hover_label_for_candidate(c: &UseWorldCandidate) -> String {
    let name = friendly_or_id(&c.label, &c.id);
    match c.kind {
        UseWorldKind::Npc
        | UseWorldKind::HiredWorker
        | UseWorldKind::Player
        | UseWorldKind::Harvest
        | UseWorldKind::Loot
        | UseWorldKind::ChestPickup
        | UseWorldKind::QuestBoard => name,
        UseWorldKind::EnterDoor | UseWorldKind::OpenDoor | UseWorldKind::CloseDoor => {
            format!("Door: {name}")
        }
        UseWorldKind::ExitDoor => name,
    }
}

fn pick_primary(candidates: &[UseWorldCandidate]) -> Option<UseWorldCandidate> {
    let in_range: Vec<&UseWorldCandidate> = candidates.iter().filter(|c| c.in_range).collect();
    if in_range.is_empty() {
        return None;
    }

    let mut best: Option<&UseWorldCandidate> = None;
    for c in in_range {
        let replace = match best {
            None => true,
            Some(b) if c.kind.f_target_class() < b.kind.f_target_class() => true,
            Some(b)
                if c.kind.f_target_class() == b.kind.f_target_class()
                    && c.distance_m < b.distance_m - 0.05 =>
            {
                true
            }
            Some(b)
                if c.kind.f_target_class() == b.kind.f_target_class()
                    && (c.distance_m - b.distance_m).abs() <= 0.05
                    && c.kind.interact_priority() < b.kind.interact_priority() =>
            {
                true
            }
            _ => false,
        };
        if replace {
            best = Some(c);
        }
    }
    best.cloned()
}