Virtual Object Creation

Architecture

VIRTUAL_D (adm/daemons/virtual.c)
    │
    ├── Extension routing: .food → modules/virtual/food.c
    ├── Extension routing: .loot → modules/virtual/loot.c
    ├── Extension routing: .mob  → modules/virtual/mob.c
    │
    └── Directory routing: /d/ → modules/virtual/d.c (zones)
                           /player/ → modules/virtual/player.c
                           etc.

Core Files

Data File Format (LPML)

Virtual objects use LPML files (see the lpml skill for full syntax). Key points:

• LPML is a superset of JSON5 — use {} for objects, [] for arrays
• Keys don't need quotes (but can have them)
• Supports "spacey keys" like additional ids, weapon name
• String concatenation with adjacent strings
• Comments with //

// obj/food/cheese.lpml

{
  id: ["cheese"],
  additional ids: ["food", "snack"],
  adj: ["small"],
  name: "cheese",
  short: "a small piece of cheese",
  long: "This is a small, round piece of cheese. It looks tasty and would"
        "make a good snack.",
  mass: 10,
  value: 15,
  uses: 1,
  properties: {
    edible: true,
  },
}

Existing Virtual Object Types

Food (.food)

Data file location: obj/food/{name}.lpml Base class: obj/food/food.c (inherits STD_FOOD) Compile module: adm/daemons/modules/virtual/food.c (inherits ob.c)

Loot (.loot)

Data file location: obj/loot/{name}.lpml Base class: obj/loot/loot.c (inherits STD_ITEM) Compile module: adm/daemons/modules/virtual/loot.c (inherits ob.c)

Example (obj/loot/rabbit_fur.lpml):

{
  id: ["fur", "patch"],
  adj: ["rabbit"],
  name: "rabbit fur",
  short: "a patch of soft rabbit fur",
  long: "This is a small patch of soft, fluffy fur.",
  mass: 10,
  material: ["fur"],
  properties: {
    autovalue: true,
    crafting material: true,
  },
}

Mobs (.mob)

Data file location: d/mobs/{name}.lpml Base class: std/mobs/{type}.c (e.g., std/mobs/mammal.c inherits std/mobs/monster.c) Compile module: adm/daemons/modules/virtual/mob.c

The type field in the LPML determines which mob base class is used.

Example (d/mobs/waste_rat.lpml):

{
  type: "mammal",
  name: "waste rat",
  short: "waste rat",
  long: "A scrappy waste rat scurries through the debris, searching for "
        "scraps to eat.",
  id: ["waste rat", "rat"],
  weapon name: "teeth",
  weapon type: "piercing",
  level: [1, 3],
  gender: ["male", "female"],
  race: "mammal",
  loot: [
    "/obj/food/rat_meat.food",
    "/obj/loot/rat_fur.loot",
  ],
  loot chance: 70.0,
  coins: {
    copper: [1, 20.0],
  },
}

How the Compile Module Works

The base compile module (ob.c) follows this pattern:

1. Extracts the object name from the file path
2. Constructs the LPML file path: /obj/{module}/{name}.lpml
3. Reads and decodes the LPML: lpml_decode(read_file(lpml_file))
4. Creates the object: new("/obj/{module}/{module}.c", data)
5. The data mapping is passed as a constructor argument

The base class receives this data in virtual_setup():

varargs void virtual_setup(mixed args...) {
    mapping data;
    if(!args || !mapp(args[0])) return;
    data = args[0];

    if(!nullp(data["id"])) set_id(data["id"]);
    if(!nullp(data["name"])) set_name(data["name"]);
    if(!nullp(data["short"])) set_short(data["short"]);
    if(!nullp(data["long"])) set_long(data["long"]);
    if(!nullp(data["mass"])) set_mass(data["mass"]);
    if(!nullp(data["value"])) set_value(data["value"]);
    // ... type-specific properties
}

Referencing Virtual Objects in Code

// Clone a virtual food item
object cheese = new("/obj/food/cheese.food");

// Clone a mob
object rat = new("/d/mobs/waste_rat.mob");

// Add to loot tables, room inventory, etc.
add_inventory("/obj/loot/rabbit_fur.loot");

No registration needed — the virtual system handles compilation automatically based on file extension.

Creating a New Virtual Object Type

To add an entirely new type (e.g., .potion):

1. Create the base class

obj/potion/potion.c:

inherit STD_ITEM;

varargs void virtual_setup(mixed args...) {
    mapping data;
    if(!args || !mapp(args[0])) return;
    data = args[0];

    if(!nullp(data["id"])) set_id(data["id"]);
    if(!nullp(data["name"])) set_name(data["name"]);
    if(!nullp(data["short"])) set_short(data["short"]);
    if(!nullp(data["long"])) set_long(data["long"]);
    if(!nullp(data["mass"])) set_mass(data["mass"]);
    if(!nullp(data["value"])) set_value(data["value"]);
    // ... potion-specific setup
}

2. Create the compile module

adm/daemons/modules/virtual/potion.c:

inherit __DIR__ "ob";

That's it — inheriting from ob.c gives you the standard compile flow that reads /obj/potion/{name}.lpml and creates /obj/potion/potion.c with the data.

3. Create LPML data files

obj/potion/healing.lpml:

{
  id: ["potion", "vial"],
  adj: ["healing"],
  name: "healing potion",
  short: "a vial of {{CC0000}}healing potion{{res}}",
  long: "A small glass vial filled with a glowing red liquid.",
  mass: 5,
  value: 50,
  properties: {
    hp restore: 25,
  },
}

4. Use it

object potion = new("/obj/potion/healing.potion");

Routing Fallbacks

If no extension module matches, VIRTUAL_D tries:

1. Directory name concatenation: /player/gesslar → modules/virtual/player.c
2. Top-level directory: /d/forest/5,10,0 → modules/virtual/d.c

This is how non-extension-based virtual objects (players, ghosts, zones) are routed.

Common Pitfalls

• File extension mismatch: the .food extension routes to food.c module, which reads .lpml files. The extension in the path (cheese.food) is different from the data file (cheese.lpml).
• LPML not LPC: data files use LPML syntax ({}, [], unquoted keys, spacey keys) not raw LPC mapping syntax (([, ({).
• Mob type field: the type property must match a file in std/mobs/ (e.g., "mammal" → std/mobs/mammal.c).
• virtual_setup not setup: data processing happens in virtual_setup(), which runs after the normal setup chain.
• New module inherits ob.c: for standard item types, just inherit __DIR__ "ob" — the base module handles LPML reading, path construction, and object creation.