Struct Actor 

pub struct Actor {
    pub id: ActorId,
    pub entity: String,
    pub name: Option<String>,
    pub skin: Option<NpcSkin>,
    pub anchor: AnchorId,
    pub facing: Option<Facing>,
    pub vulnerable: bool,
    pub equipment: Option<MobEquipment>,
    pub attributes: Option<MobAttributes>,
    pub tier: Option<EncounterTier>,
    pub drops: Vec<MobDrop>,
    pub traversal: Option<BodyTraversal>,
}

A scripted stage actor (DSL v0.6, spec-0014): a NoAI/Silent/no-loot puppet, distinct from a stage-2 Npc (no dialogue, any mob type). Emitted with tag dw_actor_<id>, Invulnerable unless vulnerable (a damageable puppet stays knockback-immune — the tower-defense creep). skin re-dresses it as a minecraft:mannequin, exactly as a stage-2 NPC skin. The puppet is summoned by a spawn-actor effect (not at load), moved by move-actor, and can be replaced by a real-AI twin with unleash-actor.

Fields

id: ActorId

Unique actor id (actor/<kebab>).

entity: String

The vanilla entity to puppet, e.g. minecraft:warden. Validated against the pinned 1.21.11 entity registry (DW0173).

name: Option<String>

Optional custom name shown above the puppet.

skin: Option<NpcSkin>

Optional player-model skin (mannequin), as a stage-2 NPC (DW0190).

anchor: AnchorId

The anchor the puppet is summoned on (resolved across areas, like an open-gate / move-npc destination).

facing: Option<Facing>

Initial facing (default south). The puppet spawns yawed this way.

vulnerable: bool

If true, the puppet is damageable (a tower-defense creep) but stays knockback-immune; default false (fully Invulnerable).

equipment: Option<MobEquipment>

Gear the actor wears and holds, in the same shape a wave mob uses (MobEquipment). Emitted into BOTH the staged puppet and the unleashed twin, so the dormant elite the player has been circling is visibly the same armoured thing that stands up. Drop chances are zero — wave gear and actor gear are never farmable (no-grind constitution).

attributes: Option<MobAttributes>

Attribute overrides, in the same shape a wave mob uses (MobAttributes, the v0.4 surface — one type, one rule set, so the two surfaces cannot drift). Emitted into BOTH the staged puppet and the unleashed twin, so the elite the party fights is the elite the author tuned; without it an actor was stuck at vanilla base values while every wave mob could be tuned, which is what blocked elite authoring. A vulnerable actor’s knockback-immunity is emitted first and is not authorable.

tier: Option<EncounterTier>

How hard this actor’s fight is meant to be (DSL v0.8, spec-0023) — the same EncounterTier vocabulary a Wave declares. Absent = EncounterTier::Ordinary, byte-identical to every pre-0.8 campaign.

A wave is not the only shape an elite takes. The set-piece souls fight — the armoured thing kneeling among the graves that stands up when you hit it — is an actor: staged by spawn-actor, given AI by unleash-actor, killed by hand rather than by a kill objective. Before this field the validation ladder’s inverted floor gate could only see waves[].tier, so such a boss was structurally invisible to it and an empty finding list read as a pass while covering nothing.

Like the wave field this is a declaration, not a knob: the compiler never scales an actor from it, and emission is unchanged whichever tier is declared. What it buys is scrutiny — the actor enters validation/combat-plan.json, and the compiler states, per tiered actor, whether the floor gate can measure it and why not when it cannot (DW0477).

drops: Vec<MobDrop>

What this actor leaves behind when a player kills it. Only an elite/boss actor may declare it (DW0491). Emitted into BOTH the staged puppet and the unleashed twin, exactly as equipment is — the drop belongs to the body, not to one of its two lifecycles. A despawn-actor strips the declaration off the body before removing it, so re-caging an elite (a souls re-seat) never scatters its axe.

traversal: Option<BodyTraversal>

What this body can do when it moves (DSL v0.11, spec-0034) — the same BodyTraversal a stage-2 Npc carries, because traversal belongs to the body and not to the stage that declares it. Absent = the class the compiler derives from entity (or from minecraft:mannequin when skin is set).

Trait Implementations

impl Clone for Actor

fn clone(&self) -> Actor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Actor

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Actor

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Actor

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 Actor

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Actor

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 Actor