Struct weasel::power::InvokePower

pub struct InvokePower<R: BattleRules> { /* fields omitted */ }

Event to make a team invoke a power.

A team can invoke a power in between actor turns or during turns of actors that belongs to itself.

Examples

use weasel::{
    battle_rules, rules::empty::*, Battle, BattleRules, CreateTeam, EntityId,
    EventTrigger, InvokePower, Server,
};

battle_rules! {}

let battle = Battle::builder(CustomRules::new()).build();
let mut server = Server::builder(battle).build();

let team_id = 1;
CreateTeam::trigger(&mut server, team_id).fire().unwrap();

let power_id = 99;
let result = InvokePower::trigger(&mut server, team_id, power_id).fire();
// We get an error because the team doesn't possess this power.
// The team's powers must defined in 'TeamRules'.
assert!(result.is_err());

Implementations

impl<R: BattleRules> InvokePower<R>

pub fn trigger<P: EventProcessor<R>>(
    processor: &mut P,
    team_id: TeamId<R>,
    power_id: PowerId<R>
) -> InvokePowerTrigger<'_, R, P>

Returns a trigger for this event.

pub fn team_id(&self) -> &TeamId<R>

Returns the id of the team that is invoking the power.

pub fn power_id(&self) -> &PowerId<R>

Returns the id of the power to be invoked.

pub fn invocation(&self) -> &Option<Invocation<R>>

Returns the invocation profile for the power.

Trait Implementations

impl<R: BattleRules> Clone for InvokePower<R>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: BattleRules> Debug for InvokePower<R>

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

Formats the value using the given formatter.

impl<'de, R: BattleRules> Deserialize<'de> for InvokePower<R> where
    TeamId<R>: Deserialize<'de>,
    PowerId<R>: Deserialize<'de>,
    Option<Invocation<R>>: Deserialize<'de>, 

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

Deserialize this value from the given Serde deserializer.

impl<R: BattleRules + 'static> Event<R> for InvokePower<R>

fn verify(&self, battle: &Battle<R>) -> WeaselResult<(), R>

Verifies if this event can be applied to the world.

fn apply(&self, battle: &mut Battle<R>, event_queue: &mut Option<EventQueue<R>>)

Applies this event to the world. This method is called only if verify succeeded.

fn kind(&self) -> EventKind

Returns the kind of this event.

fn box_clone(&self) -> Box<dyn Event<R> + Send>

Clones this event as a trait object.

fn as_any(&self) -> &dyn Any

Returns an Any reference this event.

fn rights<'a>(&'a self, _: &'a Battle<R>) -> EventRights<'a, R>

Returns the access rights required by this event.

impl<R: BattleRules> Serialize for InvokePower<R> where
    TeamId<R>: Serialize,
    PowerId<R>: Serialize,
    Option<Invocation<R>>: Serialize, 

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

Serialize this value into the given Serde serializer.