object

Interactable things in the world — the atoms of adventure

⭐4stars🔀1forks📁View on GitHub🕐Updated Jan 11, 2026⬇️1downloads

When & Why to Use This Skill

This Claude skill implements a sophisticated framework for creating interactive objects within simulated environments, based on 'The Sims' and 'Self' architectural patterns. It enables objects to function as 'atoms of adventure' by managing their own internal state, advertising available actions to agents, and executing self-healing simulation loops that bridge natural language descriptions with executable code.

Use Cases

  • Game Development: Designing complex interactive items like chests, lamps, or machinery with autonomous logic, state transitions, and environmental triggers.
  • Agentic Simulations: Creating world elements that 'advertise' their capabilities to AI agents, allowing for dynamic interaction without hardcoded character behaviors.
  • Interactive Narrative Design: Building modular 'atoms' for text-based adventures where objects inherit properties from prototypes and respond to player input through a structured protocol.
  • System Prototyping: Modeling self-healing systems where individual components manage their own lifecycle, recover from corrupted states, and interact via defined methods.
nameobject
descriptionInteractable things in the world — the atoms of adventure
tier1
protocolSIMANTICS
tags[moollm, object, interaction, game, sims]
related[room, advertisement, inventory, buff]
adversaryabstraction

Object

"Everything is an object. Objects have slots. Slots hold data OR behavior." — Dave Ungar, Self: The Power of Simplicity


What Is It?

An Object is anything you can interact with in the adventure world. Keys, lamps, chests, furniture, food, tools — all objects.

Objects are the atoms of the adventure. They:

  • Have an identity (id, name, description)
  • Advertise their actions (The Sims style)
  • Contain state (lit, fuel, uses)
  • Inherit from prototypes (Self style)

The Sims Architecture

From Will Wright's SimAntics:

"The intelligence is in the objects, not the characters."

Objects advertise what they can do:

advertisements:
  LIGHT:
    description: "Light the lamp"
    score: 80
    guard: "lamp has fuel"
    effect: "Darkness retreats"

The character picks from what's advertised. No hardcoded behavior.


Self-Style Prototypes

Objects inherit from prototypes:

inherits:
  - skills/objects/light-source.yml
  - skills/objects/takeable.yml

A lamp inherits "light-source" behaviors without copying them.


Object Properties

Property Purpose
id Unique identifier
name Display name
type Category (item, furniture, tool)
description What player sees
examine Detailed look
takeable Can be picked up
container Can hold things
contains What's inside
state Mutable properties
advertisements Available actions
inherits Prototype chain

State

Objects have mutable state:

state:
  lit: false
  fuel: 100
  uses_remaining: 3

State changes are tracked in YAML. The adventure is the save game.


Simulate — Object Update Loops

THE SIMS INSIGHT: Objects manage their own simulation!

Every object can have a simulate property — a natural language description of what happens each turn. The compiler generates a closure that receives world.

simulate: |
  if lit:
    consume_fuel(1)
    if fuel <= 0:
      extinguish()
      emit("The lamp sputters and dies!")

This compiles to:

simulate_js: (world) => {
  if (world.object.state.lit) {
    world.consume_fuel(1);
    if (world.object.state.fuel <= 0) {
      world.extinguish();
      world.emit("The lamp sputters and dies!");
    }
  }
}

Resilience — The SimCity Zone Pattern

WILL WRIGHT INSIGHT:

"SimCity zones are self-healing. If one tile burns but the center survives, the zone will eventually rebuild."

Simulation functions should be:

1. Robust — Handle Missing Data

// BAD: crashes if state is undefined
if (world.object.state.fuel > 0) { ... }

// GOOD: defensive access
if ((world.object.state?.fuel ?? 0) > 0) { ... }

2. Self-Initializing — Create Default State

simulate: |
  first ensure state.lit exists (default false)
  ensure state.fuel exists (default 100)
  then proceed with normal simulation

The compiled code initializes missing state:

simulate_js: (world) => {
  const state = world.object.state ??= {};
  state.lit ??= false;
  state.fuel ??= 100;
  // Now safe to proceed...
}

3. Self-Healing — Recover from Corruption

simulate: |
  if fuel is somehow negative, reset to 0
  if lit but fuel is 0, extinguish (inconsistent state!)
  if broken flag is set but durability is full, clear broken

The compiled code heals invalid states:

simulate_js: (world) => {
  const state = world.object.state;
  // Heal negative values
  state.fuel = Math.max(0, state.fuel);
  // Heal inconsistency
  if (state.lit && state.fuel <= 0) {
    state.lit = false;  // Self-heal
    world.emit("The lamp was somehow lit without fuel — fixed.");
  }
}

The defaults Field

Objects can declare their default state values:

object:
  id: brass-lantern
  defaults:
    lit: false
    fuel: 100
    durability: 100
  simulate: |
    ensure all defaults are initialized
    ...

The runtime merges defaults into state before simulation.


Methods — Named Behaviors

Objects can define named methods that simulate or advertisements can call. Natural language → compiled closures. 1:1 mapping!

methods:
  consume_fuel: "reduce fuel by amount, minimum 0"
  extinguish: "set lit to false, emit darkness event"
  ignite: "set lit to true if fuel > 0"

Compiles to:

methods_js: {
  consume_fuel: (world, amount) => { 
    world.object.state.fuel = Math.max(0, world.object.state.fuel - amount); 
  },
  extinguish: (world) => { 
    world.object.state.lit = false; 
    world.emit('DARKNESS'); 
  },
  ignite: (world) => { 
    if (world.object.state.fuel > 0) world.object.state.lit = true; 
  }
}

The Power of 1:1 Methods

  • Method name in natural language = method name in JS/PY
  • consume_fuel(1) in YAML → world.consume_fuel(1) in JS
  • Methods compose — extinguish() can call other methods
  • Advertisements can call methods in their effect

The Complete Pattern

Object
├── state         (mutable data)
├── simulate      (per-turn update)
├── methods       (named behaviors)
└── advertisements (player actions)

Advertisements call methods. Simulate calls methods. Methods update state.

Everything flows through compiled closures over world.


Advertisements (Actions)

Each advertisement can have:

LIGHT:
  description: "Light the lamp"           # What it does
  score: 80                               # Base attractiveness
  score_if: "player is in dark room"      # When to boost
  guard: "lamp has fuel"                  # Can you do it?
  effect: "Lamp is now lit"               # What happens

Natural language fields (score_if, guard, effect) are compiled to JS/PY.


Containers

Containers hold other objects:

container: true
contains:
  - brass-key
  - old-map
capacity: 10
locked: true

Examples

Simple Item

object:
  id: brass-key
  name: "Brass Key"
  emoji: "🔑"
  description: "A heavy brass key."
  takeable: true

Lamp with State

object:
  id: oil-lamp
  name: "Oil Lamp"
  emoji: "🪔"
  state:
    lit: false
    fuel: 100
  advertisements:
    LIGHT:
      guard: "fuel > 0 AND not lit"
      effect: "The lamp flickers to life."

Locked Chest

object:
  id: treasure-chest
  name: "Treasure Chest"
  container: true
  locked: true
  contains:
    - gold-coins
    - magic-ring
  advertisements:
    UNLOCK:
      guard: "player has chest-key"
      effect: "The lock clicks open."


Protocol Symbol

SIMANTICS — The Sims behavioral architecture