Struct TimedGate 

pub struct TimedGate {
    pub id: TimedGateId,
    pub gate: AnchorId,
    pub open_ticks: u32,
    pub closed_ticks: u32,
    pub phase: u32,
    pub crush: bool,
    pub disarm: Option<TimedGateDisarm>,
}

A stage-5 timed gate (spec-0016 §4): a gate region driven by a deterministic open/close clock, so passage is a timing read rather than a permanent state.

The proof is deliberately NOT all-phase passability — a gate that punishes bad timing is the entire point. What the compiler requires is that the gate is readable: the set of entry phases from which a walking player clears the span before it shuts must cover ≥ 20% of the cycle (DW0378). Below that it is a coin flip, not a skill, and no amount of learning the level makes it fair.

Fields

id: TimedGateId

Unique timed-gate id (timed-gate/<kebab>).

gate: AnchorId

The gate anchor the clock drives. Its prefab metadata must declare a fill block (DW0343), the same requirement close-gate and shortcut have.

open_ticks: u32

Ticks the gate stays OPEN each cycle (> 0).

closed_ticks: u32

Ticks the gate stays CLOSED each cycle (> 0).

phase: u32

Ticks after world init before the first open window begins (default 0) — how two gates in the same room are put out of step with each other. Must be less than the full cycle.

crush: bool

Whether the gate kills a player caught inside its region when it shuts (spec-0016 §4 addendum). A portcullis that merely shoves you aside teaches nothing; mistiming the crossing is supposed to be a death you learn from, which is the whole point of §4’s ≥20%-of-cycle window proof — the window is fair, so the penalty can be absolute.

This is a real judgement issued by command on the closing tick, not suffocation: vanilla’s in-wall damage is slow, gear-dependent and escapable, so it would make the portcullis a suggestion. damage at the closing edge is exact and unarguable.

Defaults to false, so every campaign authored before this field existed compiles byte-identically; a delve opts its portcullis in.

disarm: Option<TimedGateDisarm>

Optional disarm affordance (souls dossier §5.2): the third rung of the hazard ladder — readable, avoidable, and finally disable-able. The real games’ best timed hazards can be removed for good (Smouldering Lake’s ballista, the Fringefolk chariot); a clock the party can only ever dance with is one rung short of the vocabulary.

Interacting with the affordance suppresses the clock permanently, with the gate resting OPEN — a jammed portcullis stays up. Permanence is structural exactly as a shortcut’s is: no emitted function ever re-arms the clock, and DW0389 refuses a campaign that spells a re-seal.

Defaults to absent, so every campaign authored before this field existed compiles byte-identically; a delve opts its portcullis in.

Trait Implementations

impl Clone for TimedGate

fn clone(&self) -> TimedGate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TimedGate

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TimedGate

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for TimedGate

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

The name of the generated JSON Schema.

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

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for TimedGate

fn eq(&self, other: &TimedGate) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for TimedGate

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TimedGate