#[cfg(not(target_arch = "wasm32"))] use crate::comp::Body; use crate::{uid::Uid, DamageSource}; use serde::{Deserialize, Serialize}; #[cfg(not(target_arch = "wasm32"))] use specs::{Component, DerefFlaggedStorage}; #[cfg(not(target_arch = "wasm32"))] use specs_idvs::IdvStorage; /// Specifies what and how much changed current health #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)] pub struct HealthChange { pub amount: i32, pub cause: HealthSource, } #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)] pub enum HealthSource { Damage { kind: DamageSource, by: Option }, Heal { by: Option }, //Attack { by: Uid }, // TODO: Implement weapon //Projectile { owner: Option }, //Explosion { owner: Option }, //Energy { owner: Option }, //Buff { owner: Option }, Suicide, World, Revive, Command, LevelUp, Item, //Healing { by: Option }, Unknown, } #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)] pub struct Health { current: u32, base_max: u32, maximum: u32, pub last_change: (f64, HealthChange), pub is_dead: bool, } impl Health { #[cfg(not(target_arch = "wasm32"))] pub fn new(body: Body, level: u16) -> Self { let mut health = Health::empty(); health.update_max_hp(Some(body), level); health.set_to(health.maximum(), HealthSource::Revive); health } pub fn empty() -> Self { Health { current: 0, base_max: 0, maximum: 0, last_change: (0.0, HealthChange { amount: 0, cause: HealthSource::Revive, }), is_dead: false, } } pub fn current(&self) -> u32 { self.current } pub fn maximum(&self) -> u32 { self.maximum } pub fn base_max(&self) -> u32 { self.base_max } #[cfg(not(target_arch = "wasm32"))] pub fn set_to(&mut self, amount: u32, cause: HealthSource) { let amount = amount.min(self.maximum); self.last_change = (0.0, HealthChange { amount: amount as i32 - self.current as i32, cause, }); self.current = amount; } #[cfg(not(target_arch = "wasm32"))] pub fn change_by(&mut self, change: HealthChange) { self.current = ((self.current as i32 + change.amount).max(0) as u32).min(self.maximum); self.last_change = (0.0, change); } // This function changes the modified max health value, not the base health // value. The modified health value takes into account buffs and other temporary // changes to max health. pub fn set_maximum(&mut self, amount: u32) { self.maximum = amount; self.current = self.current.min(self.maximum); } // Scales the temporary max health by a modifier. pub fn scale_maximum(&mut self, scaled: f32) { let scaled_max = (self.base_max as f32 * scaled) as u32; self.set_maximum(scaled_max); } // This is private because max hp is based on the level #[cfg(not(target_arch = "wasm32"))] fn set_base_max(&mut self, amount: u32) { self.base_max = amount; self.current = self.current.min(self.maximum); } pub fn should_die(&self) -> bool { self.current == 0 } #[cfg(not(target_arch = "wasm32"))] pub fn revive(&mut self) { self.set_to(self.maximum(), HealthSource::Revive); self.is_dead = false; } // TODO: Delete this once stat points will be a thing #[cfg(not(target_arch = "wasm32"))] pub fn update_max_hp(&mut self, body: Option, level: u16) { if let Some(body) = body { self.set_base_max(body.base_health() + body.base_health_increase() * level as u32); self.set_maximum(body.base_health() + body.base_health_increase() * level as u32); self.change_by(HealthChange { amount: body.base_health_increase() as i32, cause: HealthSource::LevelUp, }); } } /// Returns the fraction of health an entity has remaining pub fn fraction(&self) -> f32 { self.current as f32 / self.maximum.max(1) as f32 } } #[cfg(not(target_arch = "wasm32"))] impl Component for Health { type Storage = DerefFlaggedStorage>; } #[derive(Copy, Clone, Debug, Serialize, Deserialize)] pub struct Dead { pub cause: HealthSource, } #[cfg(not(target_arch = "wasm32"))] impl Component for Dead { type Storage = IdvStorage; }