Struct RegenerateAbilities 

pub struct RegenerateAbilities<R: BattleRules> { /* private fields */ }

An event to regenerate the abilities of an actor.

A new set of abilities is created from a seed.\

• Abilities already known by the actor won’t be modified.
• Abilities that the actor didn’t have before will be added.
• Current actor’s abilities that are not present in the new set will be removed from the actor.

Examples

use weasel::{
    battle_rules, rules::empty::*, Battle, BattleController, BattleRules, CreateCreature,
    CreateTeam, EntityId, EventKind, EventTrigger, RegenerateAbilities, 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 creature_id = 1;
let position = ();
CreateCreature::trigger(&mut server, creature_id, team_id, position)
    .fire()
    .unwrap();

RegenerateAbilities::trigger(&mut server, EntityId::Creature(creature_id))
    .fire()
    .unwrap();
assert_eq!(
    server.battle().history().events().iter().last().unwrap().kind(),
    EventKind::RegenerateAbilities
);

Implementations

impl<R: BattleRules> RegenerateAbilities<R>

pub fn trigger<P: EventProcessor<R>>( processor: &mut P, id: EntityId<R>, ) -> RegenerateAbilitiesTrigger<'_, R, P>

Returns a trigger for this event.

pub fn id(&self) -> &EntityId<R>

Returns the actor’s entity id.

pub fn seed(&self) -> &Option<AbilitiesSeed<R>>

Returns the seed to regenerate the actor’s abilities.

Trait Implementations

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<'de, R: BattleRules> Deserialize<'de> for RegenerateAbilities<R>

where EntityId<R>: Deserialize<'de>, Option<AbilitiesSeed<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 RegenerateAbilities<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>, _: &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, _battle: &'a Battle<R>) -> EventRights<'a, R>

Returns the access rights required by this event.

impl<R: BattleRules> Serialize for RegenerateAbilities<R>

where EntityId<R>: Serialize, Option<AbilitiesSeed<R>>: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.