Enum CombatEvent 

pub enum CombatEvent {
    Created {
        name: String,
        campaign: String,
    },
    CombatantAdded {
        combatant: Combatant,
    },
    CombatantRemoved {
        combatant: Uuid,
    },
    InitiativeRolled {
        combatant: Uuid,
        roll: u8,
        modifier: i8,
        total: i16,
    },
    InitiativeSet {
        combatant: Uuid,
        total: i16,
    },
    Started,
    RoundStarted {
        round: u32,
    },
    TurnStarted {
        combatant: Uuid,
    },
    Damaged {
        combatant: Uuid,
        amount: u32,
        hit_points: HitPoints,
    },
    Healed {
        combatant: Uuid,
        amount: u32,
        hit_points: HitPoints,
    },
    TemporaryHitPointsSet {
        combatant: Uuid,
        hit_points: HitPoints,
    },
    EffectAdded {
        effect: Effect,
    },
    EffectEnded {
        effect: Uuid,
        reason: EffectEndReason,
    },
    SpellCast {
        caster: Uuid,
        spell: String,
        slot: Option<SpellSlot>,
        targets: Vec<Uuid>,
    },
    FeatureUsed {
        combatant: Uuid,
        feature: String,
        amount: u16,
    },
    Paused,
    Resumed,
    Ended,
    Undone {
        command: Uuid,
    },
    CombatantRestored {
        combatant: Combatant,
    },
    EffectRestored {
        effect: Effect,
    },
    ProgressRestored {
        status: CombatStatus,
        round: u32,
        current_turn: Option<Uuid>,
    },
}

Something that happened in a combat. Events are facts: they carry outcomes (the rolled number, the resulting HP) so replaying the log never needs to re-roll or re-decide anything.

Variants

Created

Fields

name: String

campaign: String

CombatantAdded

Fields

combatant: Combatant

CombatantRemoved

Fields

combatant: Uuid

InitiativeRolled

Fields

combatant: Uuid

roll: u8

modifier: i8

total: i16

InitiativeSet

Fields

combatant: Uuid

total: i16

Started

RoundStarted

Fields

round: u32

TurnStarted

Fields

combatant: Uuid

Damaged

Fields

combatant: Uuid

amount: u32

hit_points: HitPoints

Healed

Fields

combatant: Uuid

amount: u32

hit_points: HitPoints

TemporaryHitPointsSet

Fields

combatant: Uuid

hit_points: HitPoints

EffectAdded

Fields

effect: Effect

EffectEnded

Fields

effect: Uuid

reason: EffectEndReason

SpellCast

A record only: the slot was spent on the caster’s sheet.

Fields

caster: Uuid

spell: String

slot: Option<SpellSlot>

targets: Vec<Uuid>

FeatureUsed

A record; the combat service spends the use on the character’s sheet before logging it.

Fields

combatant: Uuid

feature: String

amount: u16

Paused

Resumed

Ended

Undone

The command command was undone. The events after it, from the same undo, put back what that command changed.

Fields

command: Uuid

CombatantRestored

A combatant put back as they were (or with their own command’s change reverted), joining again if they had left.

Fields

combatant: Combatant

EffectRestored

An effect put back, in play again if it had ended.

Fields

effect: Effect

ProgressRestored

Status, round and turn set back.

Fields

status: CombatStatus

round: u32

current_turn: Option<Uuid>

Implementations

impl CombatEvent

pub fn sheet_cost(&self) -> Option<(Uuid, SheetCost)>

What the command that logged this event cost a sheet: what undoing it gives back.

Trait Implementations

impl Clone for CombatEvent

fn clone(&self) -> CombatEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComposeSchema for CombatEvent

fn compose(generics: Vec<RefOr<Schema>>) -> RefOr<Schema>

impl Debug for CombatEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CombatEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CombatEvent

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToSchema for CombatEvent

fn name() -> Cow<'static, str>

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference [utoipa::openapi::schema::Schema]s for this type.

impl Eq for CombatEvent

impl StructuralPartialEq for CombatEvent