flatland_client_lib/

navigation.rs

//! Client-side pathfinding and auto-navigation toward a map target.

use flatland_pathfinding::{
    circles_from_placed_containers, circles_from_views, snap_nav_goal, NavWorld, PathMode,
    PathSession, PathSteer,
};

#[cfg(test)]
use flatland_pathfinding::{find_path_with_goal_z, PATH_CLEARANCE_M, PLAYER_RADIUS_M};

use crate::client_config::ClientConfig;
use crate::game::GameState;

fn nav_world_from_state(state: &GameState) -> NavWorld {
    let mut circles = circles_from_views(&state.resource_nodes, &state.npcs);
    circles.extend(circles_from_placed_containers(&state.placed_containers));
    let mut kind_nav = flatland_pathfinding::TerrainNavTable::default();
    for row in &state.terrain_kind_nav {
        kind_nav.set(
            row.kind,
            flatland_pathfinding::TerrainKindNavParams {
                move_speed_mult: row.move_speed_mult,
                impassable: row.impassable,
            },
        );
    }
    // Older servers / missed snapshot fields leave an empty table → every cell
    // costs the same and water/bog look walkable. Fall back to content defaults.
    if state.terrain_kind_nav.is_empty() {
        kind_nav = flatland_pathfinding::TerrainNavTable::unit_test_defaults();
    }
    NavWorld::new(
        state.world_width_m,
        state.world_height_m,
        state.terrain_zones.clone(),
        state.z_platforms.clone(),
        state.z_transitions.clone(),
        state.buildings.clone(),
        state.doors.clone(),
        circles,
        kind_nav,
    )
}

fn client_path_mode() -> PathMode {
    ClientConfig::load().auto_nav_path_mode()
}

#[derive(Debug, Clone)]
pub struct AutoNavigator {
    inner: PathSession,
}

impl AutoNavigator {
    pub fn plan(state: &GameState, goal_x: f32, goal_y: f32) -> Option<Self> {
        let world = nav_world_from_state(state);
        let (goal_x, goal_y) = snap_nav_goal(&world, goal_x, goal_y);
        let (px, py, pz) = state.player_position_with_z();
        let mode = client_path_mode();
        PathSession::plan(&world, px, py, pz, goal_x, goal_y, mode).map(|inner| Self { inner })
    }

    pub fn active(&self) -> bool {
        self.inner.active()
    }

    pub fn replan(&mut self, state: &GameState) -> bool {
        let world = nav_world_from_state(state);
        let (px, py, pz) = state.player_position_with_z();
        // Prefer live setting if the player flipped Fastest/Direct mid-route.
        self.inner.mode = client_path_mode();
        self.inner.replan(&world, px, py, pz)
    }

    pub fn note_progress(&mut self, px: f32, py: f32) -> bool {
        self.inner.note_progress(px, py)
    }

    pub fn steer(
        &mut self,
        px: f32,
        py: f32,
        pz: f32,
        state: &GameState,
    ) -> Option<(f32, f32, f32, bool)> {
        let world = nav_world_from_state(state);
        self.inner
            .steer(px, py, pz, &world)
            .map(|s: PathSteer| (s.forward, s.strafe, s.vertical, s.sprint))
    }

    pub fn goal_x(&self) -> f32 {
        self.inner.goal_x
    }

    pub fn goal_y(&self) -> f32 {
        self.inner.goal_y
    }

    pub fn goal_z(&self) -> f32 {
        self.inner.goal_z
    }

    pub fn mode(&self) -> PathMode {
        self.inner.mode
    }
}

#[cfg(test)]
fn find_path(
    state: &GameState,
    from_x: f32,
    from_y: f32,
    from_z: f32,
    to_x: f32,
    to_y: f32,
    to_z: f32,
) -> Option<Vec<(f32, f32)>> {
    let world = nav_world_from_state(state);
    find_path_with_goal_z(
        &world,
        from_x,
        from_y,
        from_z,
        to_x,
        to_y,
        to_z,
        PathMode::Fastest,
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use flatland_protocol::{EntityState, ResourceNodeState, Transform, Velocity2D, WorldCoord};

    fn empty_state() -> GameState {
        GameState {
            session_id: Default::default(),
            entity_id: 1,
            character_id: None,
            tick: 0,
            chunk_rev: 0,
            content_rev: 0,
            publish_rev: 0,
            entities: vec![],
            player: Some(EntityState {
                id: 1,
                transform: Transform {
                    position: WorldCoord::surface(10.0, 10.0),
                    yaw: 0.0,
                    velocity: Velocity2D { vx: 0.0, vy: 0.0 },
                },
                label: "p".into(),
                vitals: None,
                attributes: None,
                skills: None,
                inside_building: None,
                tile_id: None,
                paperdoll_ref: None,
                draw_scale: 1.0,
                presentation_state: None,
                sprite_mode: None,
                progression_xp: None,
                combat_cues: vec![],
                statuses: vec![],
            }),
            resource_nodes: vec![],
            ground_drops: vec![],
            placed_containers: vec![],
            buildings: vec![],
            doors: vec![],
            interior_map: None,
            npcs: vec![],
            blueprints: vec![],
            building_materials: vec![],
            world_width_m: 64.0,
            world_height_m: 64.0,
            world_x0: 0.0,
            world_y0: 0.0,
            terrain_zones: vec![],
            z_platforms: vec![],
            z_transitions: vec![],
            z_bands_outdoor_backup: None,
            world_clock: Default::default(),
            inventory: Default::default(),
            inventory_hints: Default::default(),
            logs: Default::default(),
            intents_sent: 0,
            ticks_received: 0,
            connected: true,
            disconnect_reason: None,
            show_stats: false,
            hud_log_hidden: false,
            show_equip_menu: false,
            equip_menu_index: 0,
            show_craft_menu: false,
            show_plot_build_menu: false,
            plot_build_focus_wall: true,
            plot_build_wall_index: 0,
            plot_build_roof_index: 0,
            craft_menu_index: 0,
            craft_batch_quantity: 1,
            show_shop_menu: false,
            shop_catalog: None,
            bank_panel: None,
            bank_menu_index: 0,
            bank_ui_mode: crate::game::BankUiMode::Menu,
            storage_panel: None,
            market_panel: None,
            market_menu_index: 0,
            market_filter: String::new(),
            market_filter_focused: false,
            market_category_filter: None,
            market_buy_confirm: None,
            market_ui_mode: crate::game::MarketUiMode::Browse,
            storage_menu_index: 0,
            storage_ui_mode: crate::game::StorageUiMode::Menu,
            shop_tab: crate::game::ShopTab::default(),
            shop_menu_index: 0,
            shop_quantity: 1,
            shop_trade_log: std::collections::VecDeque::new(),
            show_npc_verb_menu: false,
            npc_verb_target: None,
            npc_verb_index: 0,
            player_verbs: Default::default(),
            social_chat: Default::default(),
            trade_ui: Default::default(),
            whisper_pouch_ui: Default::default(),
            show_npc_chat: false,
            npc_chat: None,
            show_inventory_menu: false,
            inventory_menu_index: 0,
            inventory_tab: crate::game::InventoryTab::OnPerson,
            inventory_filter: String::new(),
            inventory_filter_focused: false,
            show_move_picker: false,
            show_rename_prompt: false,
            rename_plot_id: None,
            highlighted_plot_id: None,
            show_worker_rename: false,
            rename_buffer: String::new(),
            move_picker_index: 0,
            move_picker: None,
            show_grant_picker: false,
            grant_picker_index: 0,
            grant_picker: None,
            show_destroy_picker: false,
            destroy_confirm_pending: false,
            destroy_picker: None,
            combat_target: None,
            combat_target_label: None,
            ground_target: None,
            combat_fx: Vec::new(),
            ground_hazards: Vec::new(),
            property_zones: Vec::new(),
            tax_zones: Vec::new(),
            growth_zones: Vec::new(),
            biome_zones: Vec::new(),
            terrain_kind_nav: Vec::new(),
            property_plots: Vec::new(),
            property_plot_settings: None,
            claim_mode: None,
            relocate_mode: None,
            sell_plot_confirm: None,
            sell_plot_armed_at: None,
            show_plant_menu: false,
            plant_menu_index: 0,
            show_farm_access: false,
            farm_access_name_draft: String::new(),
            farm_access_discount_bps: 0,
            farm_access_index: 0,
            plant_quantity: 1,
            in_combat: false,
            auto_attack: false,
            combat_has_los: false,
            attack_cd_ticks: 0,
            gcd_ticks: 0,
            weapon_ability_id: String::new(),
            mainhand_template_id: None,
            mainhand_label: None,
            mainhand_instance_id: None,
            offhand_template_id: None,
            offhand_label: None,
            offhand_instance_id: None,
            mainhand_hand_slots: 1,
            defense: None,
            worn: std::collections::BTreeMap::new(),
            carry_mass: 0.0,
            carry_mass_max: 0.0,
            encumbrance: flatland_protocol::EncumbranceState::Light,
            inventory_stacks: Vec::new(),
            keychain_stacks: Vec::new(),
            whisper_pouch_stacks: Vec::new(),
            combat_target_detail: None,
            statuses: Vec::new(),
            cast_progress: None,
            timed_channel: None,
            plot_build_offer: None,
            ability_cooldowns: vec![],
            blocking_active: false,
            max_target_slots: 1,
            combat_slots: vec![],
            rotation_presets: vec![],
            known_abilities: Vec::new(),
            ability_meta: std::collections::HashMap::new(),
            ability_mastery: std::collections::HashMap::new(),
            hotbar: vec![None; 9],
            max_abilities_per_rotation: 0,
            show_loadout_menu: false,
            show_keychain_menu: false,
            keychain_menu_index: 0,
            show_rotation_editor: false,
            loadout_menu_index: 0,
            loadout_hotbar_slot: 1,
            loadout_ability_index: 0,
            loadout_focus_presets: false,
            rotation_editor: Default::default(),
            harvest_in_progress: false,
            harvest_started_at: None,
            pending_craft_ack: None,
            pending_worker_job_ack: None,
            attending_worker_instance_id: None,
            quest_log: Vec::new(),
            interactables: Vec::new(),
            ledger: None,
            career: None,
            character_sheet_tab: crate::CharacterSheetTab::Character,
            ledger_period: crate::LedgerPeriod::Day,
            show_quest_offer: false,
            pending_quest_offer: None,
            show_quest_menu: false,
            quest_menu_index: 0,
            quest_withdraw_confirm: false,
            hired_workers: Vec::new(),
            show_workers_menu: false,
            workers_menu_index: 0,
            worker_dismiss_confirmation: None,
            workers_menu_compact: false,
            worker_step_display: std::collections::BTreeMap::new(),
            worker_error_display: std::collections::BTreeMap::new(),
            worker_health_ring_until: std::collections::BTreeMap::new(),
            show_worker_give_picker: false,
            worker_give_picker_index: 0,
            worker_give_picker: None,
            show_worker_give_target_picker: false,
            worker_give_target_picker_index: 0,
            worker_give_target_picker: None,
            show_worker_take_picker: false,
            worker_take_picker_index: 0,
            worker_take_picker: None,
            show_worker_teach_picker: false,
            worker_teach_picker_index: 0,
            worker_teach_picker: None,
            worker_route_editor: None,
            progression_curve: None,
        }
    }

    #[test]
    fn path_on_open_field() {
        let state = empty_state();
        let path = find_path(&state, 10.0, 10.0, 0.0, 20.0, 15.0, 0.0).expect("path");
        assert!(!path.is_empty());
        let last = *path.last().unwrap();
        assert!((last.0 - 20.5).abs() < 1.0);
        assert!((last.1 - 15.5).abs() < 1.0);
    }

    #[test]
    fn path_routes_around_blocking_tree() {
        let mut state = empty_state();
        state
            .resource_nodes
            .push(flatland_protocol::ResourceNodeView {
                id: "oak".into(),
                label: "Oak".into(),
                x: 15.0,
                y: 12.0,
                z: 0.0,
                item_template: "oak_log".into(),
                state: ResourceNodeState::Available,
                blocking: true,
                blocking_radius_m: 0.8,
                harvest_off: false,
                tile_id: None,
                yaw: 0.0,
                pitch: 0.0,
                roll: 0.0,
                draw_scale: 1.0,
                sprite_mode: None,
                growth_progress: None,
                presentation_state: None,
                channel_start_tick: None,
                channel_end_tick: None,
                harvest_drop_templates: vec![],
            });
        let path = find_path(&state, 10.0, 12.0, 0.0, 20.0, 12.0, 0.0).expect("path around tree");
        for (x, y) in &path {
            let near_tree = (*x - 15.0).abs() < 1.0 && (*y - 12.0).abs() < 1.0;
            assert!(!near_tree, "path should not cut through tree at ({x},{y})");
        }
    }

    #[test]
    fn path_routes_around_building_with_clearance() {
        let mut state = empty_state();
        state.buildings.push(flatland_protocol::BuildingView {
            id: "hut".into(),
            label: "Hut".into(),
            x: 20.0,
            y: 20.0,
            width_m: 6.0,
            depth_m: 6.0,
            interior_blueprint: None,
            tags: vec![],
            market_boundary_zone_ids: vec![],
            market_max_volume: None,
            wall_set: None,
            roof_set: None,
        });
        let path =
            find_path(&state, 10.0, 20.0, 0.0, 30.0, 20.0, 0.0).expect("path around building");
        assert!(!path.is_empty());
        let pad = PLAYER_RADIUS_M + PATH_CLEARANCE_M;
        let x0 = 20.0 - 3.0 - pad;
        let x1 = 20.0 + 3.0 + pad;
        let y0 = 20.0 - 3.0 - pad;
        let y1 = 20.0 + 3.0 + pad;
        for (x, y) in &path {
            let inside = *x >= x0 && *x <= x1 && *y >= y0 && *y <= y1;
            assert!(
                !inside,
                "path waypoint ({x},{y}) intersects inflated building footprint"
            );
        }
        let last = *path.last().unwrap();
        assert!((last.0 - 30.0).abs() < 2.0, "should reach far side");
    }

    #[test]
    fn path_routes_around_placed_chest() {
        let mut state = empty_state();
        state
            .placed_containers
            .push(flatland_protocol::PlacedContainerView {
                id: "chest-1".into(),
                template_id: "wooden_chest_small".into(),
                display_name: "Chest".into(),
                x: 15.0,
                y: 12.0,
                z: 0.0,
                locked: false,
                accessible: true,
                owner_character_id: None,
                contents: vec![],
                lock_id: None,
                capacity_volume: None,
                item_instance_id: None,
                tile_id: None,
                worker_lodging_capacity: None,
                blocking: true,
                blocking_radius_m: 0.8,
                building_id: None,
            });
        let path = find_path(&state, 10.0, 12.0, 0.0, 20.0, 12.0, 0.0).expect("path around chest");
        for (x, y) in &path {
            let near = (*x - 15.0).hypot(*y - 12.0);
            assert!(
                near >= 1.0,
                "path should not cut through chest pad at ({x},{y}) dist={near}"
            );
        }
    }

    #[test]
    fn auto_navigator_finishes_near_goal() {
        let state = empty_state();
        let mut nav = AutoNavigator::plan(&state, 14.0, 12.0).expect("plan");
        let (fx, fy, fz) = state.player_position_with_z();
        let steer = nav.steer(fx, fy, fz, &state).expect("steer");
        assert!(steer.0.abs() + steer.1.abs() + steer.2.abs() > 0.0);
    }
}