tavern_keeper/src/person.rs

use std::{rc::Rc, fmt::Display};
use rand::seq::SliceRandom;
use rand::prelude::*;

use crate::{time::Time, world::Town, generators::PersonNameGenerator, state::GameState};

pub enum Profession {
    Peasant,
    Adventurer,
    Blacksmith,
}

pub enum Agenda {
    Idle,
    Traveling([usize; 2]),
}

pub struct Person {
    pub name: String,
    pub birth_date: Time,
    pub birth_location: Rc<Town>,
    pub profession: Profession,
    pub location: [usize; 2],
    pub agenda: Agenda,
}

impl Person {
    pub fn new(birth_date: Time, birth_location: Rc<Town>, location: [usize; 2]) -> Person {
        Person {
            name: PersonNameGenerator::name(),
            birth_date: birth_date,
            birth_location: birth_location,
            profession: Profession::Peasant,
            location: [0, 0],
            agenda: Agenda::Idle,
        }
    }

    pub fn step(&mut self, state: &mut GameState) {
        match &self.agenda {
            Agenda::Idle => {
                // do nothing
                // pick random destination
                let mut rng = rand::thread_rng();
                let dest = state.world.structures.keys().choose(&mut rng);
                self.agenda = Agenda::Traveling(*dest.unwrap());
            },
            Agenda::Traveling(destination) => {
                // TDOO: A* pathfinding with terrain costs
                // move towards destination
                if self.location[0] < destination[0] {
                    self.location[0] += 1;
                } else if self.location[0] > destination[0] {
                    self.location[0] -= 1;
                }
                if self.location[1] < destination[1] {
                    self.location[1] += 1;
                } else if self.location[1] > destination[1] {
                    self.location[1] -= 1;
                }
                if self.location == *destination {
                    self.agenda = Agenda::Idle;
                }
            },
        }
    }
}

impl Display for Person {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}