Struct game_library::Attribute

pub struct Attribute {
    pub max: u32,
    pub current: u32,
}

Attribute component. This is a simple integer representing the attribute of an entity. Has properties like max_attribute and current_attribute. We support operations with integers, floats, and other Attribute components.

We use positive integers for attribute, and negative integers for damage. There’s no reason to support negative attribute and negative max_attribute, so we don’t. We also won’t allow current_attribute to be greater than max_attribute.

Because we use integers, we can’t represent fractional attribute. It’s a bit of a tradeoff, but it’s a design decision (and I guess it can be changed later at great effort).

All operations that are performed directly between a Attribute component and another value will use the current_attribute value. For example, if you add a Attribute component with current_attribute of 10 to a Attribute component with current_attribute of 20, the result will be a Attribute component with current_attribute of 30. This holds true for all operations (addition, subtraction, multiplication, division, etc.).

What is supported:

• Affecting (adding/subtracting) attribute with integers, floats, and other Attribute components.
• Scaling the current attribute with integers, floats, and other Attribute components
• Scaling the max attribute with integers, floats, and other Attribute components
• Scaling the current attribute by a percentage of the max attribute (with integers, floats, and other Attribute components)
• Comparing attribute with integers, floats, and other Attribute components.
• Getting the percentage of attribute remaining (as a rounded integer between 0 and 100 OR a precise float between 0 and 1).
• Check is_empty to see if the entity is dead (i.e. current_attribute is 0).
• Check is_full to see if the entity is at full attribute (i.e. current_attribute is equal to max_attribute).

Fields

max: u32

The maximum value for the attribute of the entity

current: u32

The current value for the attribute of the entity

Implementations

impl Attribute

pub const MIN: u32 = 0u32

Minimum value is 0

pub const fn is_empty(&self) -> bool

Returns true if the current attribute is equal to 0

Examples

use game_library::Attribute;

let mut attribute = Attribute::new(10_u32);
assert_eq!(attribute.is_empty(), false);

attribute.set(0_u32);
assert_eq!(attribute.is_empty(), true);

pub const fn is_full(&self) -> bool

Returns true if the current attribute is equal to the max attribute.

Note

If max attribute is 0, this will always return true (because current attribute will always be 0 if max attribute is 0)

Examples

use game_library::Attribute;

let mut attribute = Attribute::new(10_u32);
assert_eq!(attribute.is_full(), true);

attribute.set(0_u32);
assert_eq!(attribute.is_full(), false);

attribute.set_max(0_u32);
assert_eq!(attribute.is_full(), true);

pub fn remaining(&self) -> f32

Returns the percentage of attribute remaining as a float between 0.00 and 1.00

Note

This will always return 1.00 if max attribute is 0 (because current attribute will always be 0 if max attribute is 0)

Examples

use game_library::Attribute;

let mut attribute = Attribute::new(10_u32);
assert_eq!(attribute.remaining(), 1.0);

attribute.set(5_u32);
assert_eq!(attribute.remaining(), 0.5);

attribute.set(0_u32);
assert_eq!(attribute.remaining(), 0.0);

attribute.set_max(0_u32);
assert_eq!(attribute.remaining(), 1.0);

pub fn percentage_remaining(&self) -> u32

Returns the percentage of attribute remaining as an integer between 0% and 100%

Note

This will always return 100% if max attribute is 0 (because current attribute will always be 0 if max attribute is 0)

Examples

use game_library::Attribute;

let mut attribute = Attribute::new(10_u32);
assert_eq!(attribute.percentage_remaining(), 100);

attribute.set(5_u32);
assert_eq!(attribute.percentage_remaining(), 50);

attribute.set(0_u32);
assert_eq!(attribute.percentage_remaining(), 0);

attribute.set_max(0_u32);
assert_eq!(attribute.percentage_remaining(), 100);

pub fn new(max_attribute: impl Into<u32>) -> Self

Creates a new Attribute component with the given max_attribute and current_attribute.

Arguments

• max_attribute - The maximum attribute of the entity. This will be converted into a u32 and clamped

Returns

• Self - The new Attribute component

Examples

use game_library::Attribute;

let attribute = Attribute::new(10_u32);

pub fn new_with_current( current_attribute: impl Into<u32>, max_attribute: impl Into<u32> ) -> Self

Creates a new Attribute component with the given max_attribute and current_attribute.

Arguments

• current_attribute - The current attribute of the entity. This will be converted into a u32 and clamped
• max_attribute - The maximum attribute of the entity. This will be converted into a u32 and clamped

Returns

• Self - The new Attribute component

Examples

use game_library::Attribute;

let attribute = Attribute::new_with_current(5_u32, 10_u32);

assert_eq!(attribute.current, 5_u32);
assert_eq!(attribute.max, 10_u32);

pub fn add_to_max(&mut self, amount: impl Into<i64>)

Adds the given amount to the max attribute, while clamping max attribute within acceptable bounds. Also ensures that current_attribute is not greater than max_attribute (in cases where a negative amount is added here).

Arguments

• amount - The amount to add to the max attribute. This can be a positive or negative number, which will increase or decrease the max attribute respectively.

Examples

use game_library::Attribute;

let mut attribute = Attribute::new(10_u32);

attribute.add_to_max(5);
assert_eq!(attribute.max, 15_u32);
assert_eq!(attribute.current, 10_u32);

attribute.add_to_max(-5);
assert_eq!(attribute.max, 10_u32);
assert_eq!(attribute.current, 10_u32);

attribute.set(15_u32);
attribute.add_to_max(25);
assert_eq!(attribute.max, 35_u32);
assert_eq!(attribute.current, 10_u32);

pub fn scale_max(&mut self, amount: impl Into<f64> + PartialOrd<f64>)

Scales the max attribute by the given amount, while clamping max attribute within acceptable bounds. Also ensures that current_attribute is not greater than max_attribute (in cases where the scale value is less than 1; i.e. the max attribute is decreased).

Arguments

• amount - The amount to scale the max attribute by. This should be a positive number. See the sister function scale_max_attribute_by_percentage for a function that takes a percentage (integer value).

Note

• Really large numbers will just cause max attribute to be set to Attribute::MAX.
• Negative numbers will cause max attribute to be set to 0.
• This is a sister function to scale_max_attribute_by_percentage which takes a percentage value instead

Examples

use game_library::Attribute;

let mut attribute = Attribute::new(10_u32);

attribute.scale_max(2.0);
assert_eq!(attribute.max, 20_u32);
assert_eq!(attribute.current, 10_u32);

attribute.scale_max(0.5);
assert_eq!(attribute.max, 10_u32);
assert_eq!(attribute.current, 10_u32);

pub fn scale_max_by_percentage(&mut self, amount: impl Into<i32>)

Scales the max attribute by the given percentage, while clamping max attribute within acceptable bounds. Also ensures that current_attribute is not greater than max_attribute (in cases where the scale value is less than 100; i.e. the max attribute is decreased).

Arguments

• amount - The percentage to scale the max attribute by. This should be a positive number. Really large numbers will just cause max attribute to be set to u32::MAX.

Note

• Really large numbers will just cause max attribute to be set to Attribute::MAX.
• Negative numbers will cause max attribute to be set to 0.
• This is a sister function to scale_max_attribute which takes a float value instead of a percentage.

Examples

use game_library::Attribute;

let mut attribute = Attribute::new(10_u32);

attribute.scale_max_by_percentage(200);
assert_eq!(attribute.max, 20_u32);
assert_eq!(attribute.current, 10_u32);

attribute.scale_max_by_percentage(50);
assert_eq!(attribute.max, 10_u32);
assert_eq!(attribute.current, 10_u32);

pub fn add_to_current(&mut self, amount: impl Into<i64>)

Adds the given amount to the current attribute, while clamping current attribute within acceptable bounds. (i.e. between 0 and max_attribute). This will not affect max_attribute.

Arguments

• amount - The amount to add to the current attribute. This can be a positive or negative number, which will increase or decrease the current attribute respectively.

Examples

use game_library::Attribute;

let mut attribute = Attribute::new_with_current(5_u32, 10_u32);

assert_eq!(attribute.current, 5_u32);

attribute.add_to_current(5);

assert_eq!(attribute.current, 10_u32);

pub fn scale_current(&mut self, amount: impl Into<f64> + PartialOrd<f64>)

Scales the current attribute by the given amount, while clamping current attribute within acceptable bounds. (i.e. between 0 and max_attribute). This will not affect max_attribute. This takes a float value; e.g., 0.5 will scale the current attribute by 50% (i.e. half the current attribute), while 2.0 will scale the current attribute by 200% (i.e. double the current attribute).

There’s a similar function add_to_current_attribute_by_scale_max_attribute which applies the same logic but uses the max_attribute as the scale value to arrive at an amount to change the current attribute by.

Arguments

• amount - The amount to scale the current attribute by. This should be a positive number. See the sister function scale_current_attribute_by_percentage for a function that takes a percentage (integer value).

Examples

use game_library::Attribute;

let mut attribute = Attribute::new_with_current(5_u32, 10_u32);

assert_eq!(attribute.current, 5_u32);

attribute.scale_current(2.0);

assert_eq!(attribute.current, 10_u32);

pub fn scale_current_by_percentage(&mut self, amount: impl Into<i32>)

Scales the current attribute by the given percentage, while clamping current attribute within acceptable bounds.

There’s a similar function add_to_current_attribute_by_scale_max_attribute_percentage which applies the same logic but uses the max_attribute as the scale value to arrive at an amount to change the current attribute by.

Arguments

• amount - The percentage to scale the current attribute by. This should be a positive number. Really large numbers will just cause current attribute to be set to u32::MAX.

Examples

use game_library::Attribute;

let mut attribute = Attribute::new_with_current(5_u32, 10_u32);

assert_eq!(attribute.current, 5_u32);

attribute.scale_current_by_percentage(200);

assert_eq!(attribute.current, 10_u32);

pub fn add_to_current_by_scale_max( &mut self, amount: impl Into<f64> + PartialOrd<f64> )

Adds to current attribute by scaling the max_attribute by the given amount, while clamping current attribute within acceptable bounds. (i.e. between 0 and max_attribute). This will not affect max_attribute. This takes a float and expects negatives to be used to decrease the current attribute, and positives to be used to increase the current attribute.

There’s a similar function scale_current_attribute_by_scale_max_attribute_percentage which applies the same logic but expects a percentage value (e.g. 50) instead of a float (e.g. 0.5).

Arguments

• amount - The amount to scale the max attribute by. If this is positive, the current attribute will increase. If this is negative, the current attribute will decrease.

Examples

use game_library::Attribute;

let mut attribute = Attribute::new_with_current(5_u32, 100_u32);

assert_eq!(attribute.current, 5_u32);
assert_eq!(attribute.max, 100_u32);

attribute.add_to_current_by_scale_max(0.05);

assert_eq!(attribute.current, 10_u32);
assert_eq!(attribute.max, 100_u32);

pub fn add_to_current_by_scale_max_percentage(&mut self, amount: impl Into<i32>)

Adds to current attribute by scaling the max_attribute by the given percentage, while clamping current attribute within acceptable bounds. (i.e. between 0 and max_attribute). This will not affect max_attribute. This takes a percentage and expects negatives to be used to decrease the current attribute, and positives to be used to increase the current attribute.

There’s a similar function add_to_current_attribute_by_scale_max_attribute which applies the same logic but expects a float value (e.g. 0.5) instead of a percentage (e.g. 50).

Arguments

• amount - The percentage to scale the max attribute by. If this is positive, the current attribute will increase. If this is negative, the current attribute will decrease.

Examples

use game_library::Attribute;

let mut attribute = Attribute::new_with_current(5_u32, 100_u32);

assert_eq!(attribute.current, 5_u32);
assert_eq!(attribute.max, 100_u32);

attribute.add_to_current_by_scale_max_percentage(20);

assert_eq!(attribute.current, 25_u32);
assert_eq!(attribute.max, 100_u32);

pub fn set(&mut self, value: impl Into<u32>)

Set the current value directly.

Arguments

• value - The value to set the current attribute to. This will be clamped between 0 and max_attribute.

Examples

use game_library::Attribute;

let mut attribute = Attribute::new(10_u32);

assert_eq!(attribute.current, 10_u32);
assert_eq!(attribute.max, 10_u32);

attribute.set(5_u32);
assert_eq!(attribute.current, 5_u32);
assert_eq!(attribute.max, 10_u32);

pub fn set_max(&mut self, value: impl Into<u32>)

Set the max value directly.

Arguments

• value - The value to set the max attribute to. This will be clamped between 0 and u32::MAX.

Examples

use game_library::Attribute;

let mut attribute = Attribute::new(10_u32);

assert_eq!(attribute.current, 10_u32);
assert_eq!(attribute.max, 10_u32);

attribute.set_max(5_u32);

assert_eq!(attribute.current, 5_u32);
assert_eq!(attribute.max, 5_u32);

attribute.set_max(10_u32);

assert_eq!(attribute.current, 5_u32);
assert_eq!(attribute.max, 10_u32);

Trait Implementations

impl AddAssign<f32> for Attribute

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

impl AddAssign<f64> for Attribute

fn add_assign(&mut self, rhs: f64)

Performs the += operation.

impl AddAssign<i32> for Attribute

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl AddAssign<u32> for Attribute

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl AddAssign for Attribute

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Attribute

fn clone(&self) -> Attribute

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for Attribute

where Self: Send + Sync + 'static,

type Storage = TableStorage

A marker type indicating the storage type used for this component. This must be either [TableStorage] or [SparseStorage].

impl Debug for Attribute

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

Formats the value using the given formatter.

impl Default for Attribute

fn default() -> Attribute

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Attribute

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Attribute

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

Formats the value using the given formatter.

impl DivAssign<f32> for Attribute

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl DivAssign<f64> for Attribute

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

impl DivAssign<i32> for Attribute

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl DivAssign<u32> for Attribute

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl DivAssign for Attribute

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl From<Attribute> for f32

fn from(value: Attribute) -> Self

Converts to this type from the input type.

impl From<Attribute> for f64

fn from(value: Attribute) -> Self

Converts to this type from the input type.

impl From<Attribute> for i16

fn from(value: Attribute) -> Self

Converts to this type from the input type.

impl From<Attribute> for i32

fn from(value: Attribute) -> Self

Converts to this type from the input type.

impl From<Attribute> for i64

fn from(value: Attribute) -> Self

Converts to this type from the input type.

impl From<Attribute> for i8

fn from(value: Attribute) -> Self

Converts to this type from the input type.

impl From<Attribute> for u16

fn from(value: Attribute) -> Self

Converts to this type from the input type.

impl From<Attribute> for u32

fn from(value: Attribute) -> Self

Converts to this type from the input type.

impl From<Attribute> for u64

fn from(value: Attribute) -> Self

Converts to this type from the input type.

impl From<Attribute> for u8

fn from(value: Attribute) -> Self

Converts to this type from the input type.

impl From<f32> for Attribute

fn from(value: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Attribute

fn from(value: f64) -> Self

Converts to this type from the input type.

impl From<i16> for Attribute

fn from(value: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Attribute

fn from(value: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Attribute

fn from(value: i64) -> Self

Converts to this type from the input type.

impl From<i8> for Attribute

fn from(value: i8) -> Self

Converts to this type from the input type.

impl From<u16> for Attribute

fn from(value: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Attribute

fn from(value: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Attribute

fn from(value: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Attribute

fn from(value: u8) -> Self

Converts to this type from the input type.

impl FromReflect for Attribute

where u32: FromReflect + TypePath,

fn from_reflect(reflect: &dyn Reflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn Reflect> ) -> Result<Self, Box<dyn Reflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl FromType<Attribute> for InspectorOptions

fn from_type() -> Self

impl GetTypeRegistration for Attribute

where u32: FromReflect + TypePath,

fn get_type_registration() -> TypeRegistration

impl MulAssign<f32> for Attribute

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl MulAssign<f64> for Attribute

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl MulAssign<i32> for Attribute

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl MulAssign<u32> for Attribute

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl MulAssign for Attribute

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Ord for Attribute

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq<u32> for Attribute

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for Attribute

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Attribute

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Percentage for Attribute

fn percentage(&self) -> f32

Returns the percentage of the value to draw.

impl Reflect for Attribute

where u32: FromReflect + TypePath,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the [TypeInfo] of the type represented by this value.

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable reflected value.

fn clone_value(&self) -> Box<dyn Reflect>

Clones the value as a Reflect trait object.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

fn apply(&mut self, value: &dyn Reflect)

Applies a reflected value to this value.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool>

Returns a “partial equality” comparison result.

fn type_name(&self) -> &str

👎Deprecated since 0.12.0: view the method documentation to find alternatives to this method.

Returns the type path of the underlying type.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

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

Debug formatter for the value.

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Serialize for Attribute

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Struct for Attribute

where u32: FromReflect + TypePath,

fn field(&self, name: &str) -> Option<&dyn Reflect>

Returns a reference to the value of the field named name as a &dyn Reflect.

fn field_mut(&mut self, name: &str) -> Option<&mut dyn Reflect>

Returns a mutable reference to the value of the field named name as a &mut dyn Reflect.

fn field_at(&self, index: usize) -> Option<&dyn Reflect>

Returns a reference to the value of the field with index index as a &dyn Reflect.

fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect>

Returns a mutable reference to the value of the field with index index as a &mut dyn Reflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a [DynamicStruct].

impl SubAssign<f32> for Attribute

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

impl SubAssign<f64> for Attribute

fn sub_assign(&mut self, rhs: f64)

Performs the -= operation.

impl SubAssign<i32> for Attribute

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl SubAssign<u32> for Attribute

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl SubAssign for Attribute

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl TypePath for Attribute

where u32: FromReflect + TypePath,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for Attribute

where u32: FromReflect + TypePath,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for Attribute

impl Eq for Attribute

impl Resource for Attribute

where Self: Send + Sync + 'static,