Enum Normal

pub enum Normal {
    None,
    HP,
    MP,
    XP,
    GP,
    Burn,
    Poison,
    Freeze,
    Sick,
    Sap,
    Bless,
    Heal,
    Stuck,
    Bound,
    Blocked,
    Locked,
}

Variants

None

no effect aka a player or something else that should not have an effect, like a key

HP

add or remove HP based on the attack/item/special’s HP

MP

add or remove MP based on the attack/item/special’s MP

XP

add or remove XP. enemies all have this effect

GP

add or remove GP.

Burn

These next five continously drain HP/MP until remedy, or duration runs out

hp drain

Poison

hp drain, very minor mp drain

Freeze

minor hp drain, very minor mp drain, no movement

Sick

hp drain, minor mp drain

Sap

mp drain

Bless

These next two continuously add HP/MP

mp add

Heal

hp add

Stuck

Blocker/locker effects

no movement

Bound

no attack

Blocked

no mana attack

Locked

a lock to prevent access

Trait Implementations

impl Clone for Normal

fn clone(&self) -> Normal

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Normal

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Normal

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Normal

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Normal

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Normal

fn eq(&self, other: &Normal) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Random for Normal

type Type = Normal

fn random_type(&self) -> Self::Type

fn random_rate(&self, value: u32) -> u32

fn random(&self, min: f64, max: f64) -> f64

fn half(&self) -> bool

fn usually(&self) -> bool

fn often(&self) -> bool

fn hardly(&self) -> bool

fn barely(&self) -> bool

impl Serialize for Normal

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Normal

impl Eq for Normal

impl StructuralPartialEq for Normal