Enum Position 

pub enum Position {
    N {
        condition: ItemCondition,
        targets: usize,
        random: bool,
        exact_n_targets: bool,
    },
    Any(ItemCondition),
    All(ItemCondition),
    OnSelf,
    TriggerAffected(Option<Box<Position>>),
    TriggerAfflicting(Option<Box<Position>>),
    First,
    Last,
    Opposite,
    Ahead,
    Range(RangeInclusive<isize>),
    Relative(isize),
    Nearest(isize),
    Multiple(Vec<Position>),
    Adjacent,
    FrontToBack(FrontToBackCondition),
    None,
}

Positions to select pets by.

Variants

N

Some number of Pets based on a given ItemCondition.

Note: These positions are non-overlapping.

Fields

condition: ItemCondition

ItemConditions to select pets by.

targets: usize

Number of pets to select.

random: bool

Shuffle any found pets.

exact_n_targets: bool

Must be exact number of targets.

Any(ItemCondition)

Any Pet that matches a given ItemCondition.

All(ItemCondition)

All Pets that match a given ItemCondition.

OnSelf

Position of self.

TriggerAffected(Option<Box<Position>>)

Pet affected in Outcome trigger.

1. Optional position relative to pet.

Same pet.

let curr_pet = saptest::Position::TriggerAffected(None);

Two pets ahead of the trigger pet that are nearest.

let curr_pet = saptest::Position::TriggerAfflicting(Some(Box::new(saptest::Position::Nearest(2))));

TriggerAfflicting(Option<Box<Position>>)

Pet causing in Outcome trigger.

1. Optional position relative to pet.

Same pet.

let curr_pet = saptest::Position::TriggerAfflicting(None);

Pet behind trigger pet.

let curr_pet = saptest::Position::TriggerAfflicting(Some(Box::new(saptest::Position::Relative(-1))));

First

First pet on Team.

Last

Last pet on Team.

Opposite

Opposite team’s pet at the current pet index.

Ahead

All Pets ahead of current pet.

Range(RangeInclusive<isize>)

A specified range on a Team.

Relative(isize)

A Pet relative to current Pet.

• Note: Empty slots are taken into consideration.

Nearest(isize)

Nearest pet(s) ahead or behind from current Pet.

• Negative values check pets behind.
• Positive values check pets ahead.

Multiple(Vec<Position>)

Multiple Positions.

Adjacent

All Pet’s adjacent to current index.

FrontToBack(FrontToBackCondition)

Select pets front-to-back based on a given condition.

None

No position.

Implementations

impl Position

pub fn is_non_specific(&self) -> bool

Check if position is a non-specific to current pet.

• Position::Any
• Position::All
• Position::Nearest
• Position::Relative
• Position::Ahead
• Position::None

Trait Implementations

impl Clone for Position

fn clone(&self) -> Position

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Position

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

Formats the value using the given formatter.

impl Default for Position

fn default() -> Position

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Position

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Position

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Position