Struct weasel::round::EndRound

pub struct EndRound<R> { /* fields omitted */ }

Event to trigger the end of the current round.

A round is a logical separator between turns and it can contain any number of these.
Managing rounds is optional and not required in order to start or end turns.

The first round is implicitly started at the beginning of the battle.

Examples

use weasel::{
    battle_rules, rules::empty::*, Battle, BattleController, BattleRules, EndRound,
    EventTrigger, Server,
};

battle_rules! {}

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

EndRound::trigger(&mut server).fire().unwrap();
assert_eq!(
    server.battle().rounds().completed_rounds(),
    1
);

Implementations

impl<R: BattleRules> EndRound<R>

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

Returns a trigger for this event.

Trait Implementations

impl<R> Clone for EndRound<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> Debug for EndRound<R>

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

Formats the value using the given formatter.

impl<'de, R> Deserialize<'de> for EndRound<R>

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 EndRound<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> Serialize for EndRound<R>

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

Serialize this value into the given Serde serializer.