Struct OriginSink

pub struct OriginSink<'a> { /* private fields */ }

Sink decorator that stamps the provenance of everything a producer emits, and refuses whatever it cannot stamp.

The fight primitives below always build CombatEventOrigin::Core and know nothing about modifiers. A modifier runs its work against OriginSink::proc(real_sink) instead, so everything it emits — directly or through a nested primitive — comes out Proc without any call site threading the marker.

Casts and runs are carried, not refused: push_attack / push_run write the scope’s provenance into the queued cast, which reaches essences::entity::ActionWithDeadline, so the damage it lands ticks later still resolves under this scope’s mark.

The sink fails closed for events it cannot mark: a non-Core scope may only emit events OverlordEvent::set_origin accepts. CastEffectFromEvent has no field of its own to stamp and SpawnEntity would hand a producer a combatant fighting with its own Core actions, so both are refused. A Core scope is unrestricted — Core is what every emit site already builds.

Implementations

impl<'a> OriginSink<'a>

pub fn new(inner: &'a mut dyn FightSink, origin: CombatEventOrigin) -> Self

Wraps inner so that every event it receives is stamped with origin.

pub fn proc(inner: &'a mut dyn FightSink) -> Self

The modifier scope: everything emitted through this sink is Proc.

Trait Implementations

impl FightSink for OriginSink<'_>

fn claim_once(&mut self, slot: OnceSlot, armed: i64) -> i64

Forwarded, not re-latched: the budget belongs to the dispatch, and a producer scope running inside one is part of that same dispatch.

fn push_event(&mut self, event: OverlordEvent) -> Result<(), Error>

fn push_attack( &mut self, delay: u64, duration: u64, target: Uuid, origin: CombatEventOrigin, ) -> Result<(), Error>

fn push_run( &mut self, coords: Coordinates, duration: u64, origin: CombatEventOrigin, ) -> Result<(), Error>