hvz/

zombie.rs

use crate::establish_connection;
use crate::interactions::Interaction;
use crate::player::Player;
use crate::player::PlayerState;
use crate::schema::players;
use crate::time::CustomDateTime;
use chrono::Datelike;
use chrono::NaiveDateTime;
use chrono::Utc;
use diesel::ExpressionMethods;
use diesel::QueryDsl;
use diesel::RunQueryDsl;
use log::{info, trace};
use std::time::Duration;
use tokio::time::interval;

/// Represents a zombie player.
pub type Zombie = Player;

impl Zombie {
    /// Calculates the next feeding time for a zombie player.
    ///
    /// Returns `None` if the player is not a zombie.
    ///
    /// # Errors
    /// Returns an error if the player is not a zombie.
    pub async fn get_next_feeding(&self) -> Result<Option<CustomDateTime>, String> {
        Ok(self.next_feeding)
    }

    /// Gets the starvation status of all the zombies.
    ///
    /// # Returns
    /// A vector of tuples containing the player's alias and their next feeding time.
    ///
    /// # Errors
    /// Returns an error if the player is not a zombie.
    pub async fn starvation(&self) -> Result<Vec<(String, Option<CustomDateTime>)>, String> {
        let connection = &mut establish_connection();

        let starvation_all = players::table
            .select((players::alias, players::state, players::next_feeding))
            .filter(players::state.eq(PlayerState::Zombie))
            .or_filter(players::state.eq(PlayerState::Zombie0))
            .order(players::next_feeding.asc())
            .load::<(String, PlayerState, Option<CustomDateTime>)>(connection)
            .map_err(|e| format!("Failed to load starvation: {}", e))?;

        let mut seen_z0 = false;
        let mut starvation = Vec::new();
        for (alias, state, next_feeding) in starvation_all {
            if state == PlayerState::Zombie0 {
                if !seen_z0 {
                    starvation.push(("Z0".to_owned(), next_feeding));
                    seen_z0 = true;
                }
            } else {
                starvation.push((alias, next_feeding));
            }
        }

        Ok(starvation)
    }

    /// Hunt a player and feed two other players.
    ///
    /// # Arguments
    /// * `target` - The player to hunt.
    /// * `feed1` - The first player to feed.
    /// * `feed2` - The second player to feed.
    ///
    /// # Errors
    /// Returns an error if the player is not a zombie.
    pub async fn hunt(
        &self,
        target: &Player,
        feed1: Option<&Player>,
        feed2: Option<&Player>,
    ) -> Result<(), String> {
        target.zombify().await?;
        self.feed(None).await?;
        target.feed(None).await?;
        if let Some(zombie_feed1) = feed1 {
            zombie_feed1.feed(None).await?;
        }
        if let Some(zombie_feed2) = feed2 {
            zombie_feed2.feed(None).await?;
        }

        Interaction::save_hunt_interaction(self, target, feed1, feed2).await?;

        Ok(())
    }

    /// Zombify a player
    ///
    /// # Arguments
    /// * `self` - The player to zombify.
    ///
    /// # Errors
    /// Returns an error if the player is not a zombie.
    pub async fn zombify(&self) -> Result<(), String> {
        let connection = &mut establish_connection();

        diesel::update(players::table.filter(players::id.eq(self.id.clone())))
            .set(players::state.eq(PlayerState::Zombie))
            .execute(connection)
            .expect("Failed to zombify player.");

        info!("Player {:?} hunted", self.name);

        Ok(())
    }

    /// Feed a player.
    ///
    /// # Arguments
    /// * `amount` - The amount of time to feed the player in hours.
    ///
    /// # Errors
    /// Returns an error if the player is not a zombie.
    pub async fn feed(&self, amount: Option<i64>) -> Result<Option<CustomDateTime>, String> {
        let connection = &mut establish_connection();

        let mut new_feeding_time: CustomDateTime = Self::feeding_time_calc()?;
        if let Some(amount) = amount {
            new_feeding_time = CustomDateTime::now() + chrono::Duration::hours(amount);
            let weekday = new_feeding_time.weekday().num_days_from_monday();
            if weekday == 5 || weekday == 6 {
                new_feeding_time += chrono::Duration::days(2);
            }
        }

        diesel::update(players::table.filter(players::id.eq(self.id.clone())))
            .set(players::next_feeding.eq(new_feeding_time))
            .execute(connection)
            .expect("Failed to update player next feeding");
        return Ok(Some(new_feeding_time));
    }

    /// Calculates the next feeding time for a zombie.
    ///
    /// # Returns
    /// The next feeding time as a NaiveDateTime.
    pub fn feeding_time_calc() -> Result<CustomDateTime, String> {
        let day_of_the_week = chrono::Local::now().weekday().num_days_from_monday();

        let next_feeding_time = match day_of_the_week {
            0 | 1 => CustomDateTime::now() + chrono::Duration::days(3),
            2 | 3 | 4 => CustomDateTime::now() + chrono::Duration::days(5),
            5 => CustomDateTime::now() + chrono::Duration::days(4),
            6 => CustomDateTime::now() + chrono::Duration::days(3),
            _ => return Err("Invalid day of the week".to_string()),
        };

        Ok(next_feeding_time)
    }

    /// Monitors the zombie death and updates the player state accordingly.
    ///
    /// Every minute, it checks if the player's next feeding time has passed.
    /// If so, it updates the player's state to Corpse and sets the next feeding time to None.
    ///
    /// # Errors
    /// Returns an error if the player is not a zombie.
    pub async fn monitor_zombie_death() -> ! {
        let connection = &mut establish_connection();
        let mut interval = interval(Duration::from_secs(60)); // 1 minute
        let date_none: Option<NaiveDateTime> = None;
        loop {
            interval.tick().await;
            trace!("Checking zombie death... Current time: {}", Utc::now());
            diesel::update(players::table.filter(players::next_feeding.lt(CustomDateTime::now())))
                .set((
                    players::state.eq(PlayerState::Corpse),
                    players::next_feeding.eq(date_none),
                ))
                .execute(connection)
                .expect("Failed to update player state");
        }
    }
}