Enum veloren_common_net::synced_components::inner::body::humanoid::Species

#[repr(u32)]
pub enum Species {
    Danari = 0,
    Dwarf = 1,
    Elf = 2,
    Human = 3,
    Orc = 4,
    Draugr = 5,
}

Variants

Danari = 0

Dwarf = 1

Elf = 2

Human = 3

Orc = 4

Draugr = 5

Implementations

impl Species

pub fn elim<'a, Elim, Context, S, Type>( &'a self, elim: Elim, context: Context, ) -> (Type, S)

where Elim: Typed<((&'a Species,), Context), Type, S>,

pub fn elim_case_pure<'a, Type>( &self, cases: &'a ElimCase<Cases<Pure<Type>>>, ) -> &'a Type

pub fn elim_case_weak<'a, 'b, Type>( &'a self, cases: &'b <WeakHead<Species, Type> as SynthTyped<((Species,), ()), Type>>::Expr, ) -> &'b Type

where WeakHead<Pure<Type>, Type>: SynthTyped<(), Type>, &'b <WeakHead<Species, Type> as SynthTyped<((Species,), ()), Type>>::Expr: Typed<((&'a Species,), ()), &'b Type, ()>,

impl Species

pub fn num_hair_colors(self) -> u8

FIXME: This is a hack! The only reason we need to do this is because hair colors are currently just indices into an array, not enum variants. Once we have proper variants for hair colors, we won’t need to do this anymore, since we will use locally defined arrays to represent per-species stuff (or have some other solution for validity).

pub fn skin_color(self, val: u8) -> Skin

pub fn num_skin_colors(self) -> u8

pub fn eye_color(self, val: u8) -> EyeColor

pub fn num_eye_colors(self) -> u8

pub fn num_hair_styles(self, body_type: BodyType) -> u8

pub fn num_accessories(self, body_type: BodyType) -> u8

pub fn num_eyebrows(self, _body_type: BodyType) -> u8

pub fn num_eyes(self, body_type: BodyType) -> u8

pub fn num_beards(self, body_type: BodyType) -> u8

Trait Implementations

impl Clone for Species

fn clone(&self) -> Species

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Species

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Species

fn deserialize<__D>( __deserializer: __D, ) -> Result<Species, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Species

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, SpeciesMeta> Index<&'a Species> for AllSpecies<SpeciesMeta>

type Output = SpeciesMeta

The returned type after indexing.

fn index( &self, _: &'a Species, ) -> &<AllSpecies<SpeciesMeta> as Index<&'a Species>>::Output

Performs the indexing (container[index]) operation.

impl Ord for Species

fn cmp(&self, other: &Species) -> 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<Target> PackedElim for WeakHead<Species, Target>

where WeakHead<Pure<Target>, Target>: SynthTyped<(), Target>,

type Danari = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Dwarf = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Elf = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Human = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Orc = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Draugr = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

impl PartialEq for Species

fn eq(&self, other: &Species) -> 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 Species

fn partial_cmp(&self, other: &Species) -> 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 Serialize for Species

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Species

impl Eq for Species

impl StructuralPartialEq for Species