oxidus-mudlib

Review standard for Oxidus changes — what qualifies as a finding, how scope is bounded, the evidence required before asserting a failure mode, and the LPC/FluffOS semantics most often mistaken for defects. Consult before reviewing, critiquing, or reporting findings on any LPC change, diff, or pull request.

LPC coding style and formatting conventions for this project. Consult when writing or modifying any LPC code — covers spacing, indentation, braces, naming, control flow, and idiomatic patterns.

LPCDoc comment block generation guide. Consult when writing or updating documentation headers for LPC functions, classes, and modules.

Create and modify daemons for Oxidus. Covers inheriting STD_DAEMON, the setup chain, persistence (setPersistent/saveData/restore_data), preloading, SWAP_D for reload-safe data, logging with EXT_LOG, and the teardown chain.

LPML (LPC Markup Language) specification reference. Consult when reading, writing, editing, or validating .lpml files. Covers syntax, data types, string concatenation, spacey keys, file includes, multiline folding, and all extensions over JSON5.

Create and modify NPCs and monsters for Oxidus. Covers code-based NPCs (STD_NPC), data-driven monsters (virtual_setup, LPML), set_level, race modules, body parts, heartbeat optimization, combat memory, loot/coin tables, utility-AI decisions, and the virtual compile flow.

Understand and work with the boon/curse (buff/debuff) system in Oxidus. Covers boon and curse application, class/type structure, stacking, expiration, querying effective values, and integration with attributes, vitals, and skills.

Understand and work with the equipment system in Oxidus. Covers weapons (hands, damage coefficient, damage type), armour (AC, defense mappings), clothing, body slots, the equip/unequip dispatch, combat integration, and creating new equipment items.

Understand and work with the skill tree and advancement systems in Oxidus. Covers the nested skill tree, dot-path addressing, use-based improvement, the query_skill / query_raw_skill / query_skill_level / query_raw_skill_level API grid, has_skill existence checks, boon integration, XP, TNL formula, leveling, attributes, and how skills interact with combat and NPCs.

Understand and work with the combat system in Oxidus. Covers the attack loop, hit-chance formula, damage pipeline, threat tracking, defense/AC, procs, vitals/regen, death sequence, XP/advancement, NPC combat behavior, and combat memory.

Create and modify commands for Oxidus. Covers file naming, inheritance hierarchy (STD_CMD, STD_ACT, STD_ABILITY, STD_SPELL), entry points, return value handling, help text, verb rules, and command directory structure.

Understand and work with the database (SQLite3) system in Oxidus. Covers the DB_D daemon, .tbl table-definition files, REST-style query interface, direct/lazy query APIs, schema creation and extension, and maintenance.

Create new help files for Oxidus. Covers file location, plain text format, search paths, command-based help via query_help(), and the autodoc system.

Understand and work with the MUD configuration system for Oxidus. Covers the CONFIG_D daemon, cascading LPML config files (default.lpml and config.lpml), the mud_config() simul_efun with dot-path lookups, available configuration keys, adding new keys, the mudconfig command, and rehashing configuration at runtime.

Connect to the running Oxidus MUD via telnet to test in-game functionality, reload objects with update, run developer/admin commands, and verify colour rendering. Use when a task requires in-game verification or execution.

Understand and use the object-finding simul_efuns for Oxidus. Covers find_target, find_targets, find_ob, get_object, present_livings, present_players, present_npcs, present_clones, clones, top_environment, same_env_check, accessible_objects, this_body, and this_caller.

Write and run unit tests for Oxidus. Covers the STD_TEST framework, test file layout under /tests/, area runners (STD_TEST_RUNNER), the runtests developer command, assertion macros, deep-equality via same(), sad-path testing via master test-mode suppression, pending() tests for known-broken boundaries, the @lpc-nocheck directive, and LPC quirks that bite tests (0 vs undefined, lambda capture limits, loose array compare).

Understand and extend the signal (event) system for Oxidus. Covers the signal daemon (SIGNAL_D), the simul_efun API (slot, emit, unslot), all signal categories and constants, persistence via SWAP_D, error handling, and every producer/consumer in the codebase.

Understand and write action messages with automatic verb conjugation, pronoun handling, and perspective-based delivery. Covers all $-tokens ($N, $v, $t, $o, $p, $r, $b), all action functions, article handling, reflexives, and common pitfalls.

Oxidus true colour system reference. Consult when writing or modifying output strings that use colour codes, or when choosing colours for new content.

Understand and work with the consumable system in Oxidus. Covers the EXT_USES base module, EXT_EDIBLE (food/eat/nibble), EXT_POTABLE (drink/sip), STD_FOOD, STD_DRINK, action message customization, and creating food and drink items.

Understand and work with the currency, wealth, transaction, shop, bank, coin, and loot-value systems in Oxidus. Covers the currency daemon, wealth tracking, transaction math, inventory-based shops (EXT_SHOP), menu-based shops (EXT_SHOP_MENU), the bank daemon, coin objects, and item values.

Document driver efun overrides in Oxidus that change default FluffOS behavior. Covers exec, shutdown, set_privs, userp, query_num, ctime, element_of, debug_message, this_body, and this_caller — what they change and why, to prevent wrong assumptions about driver behavior.

Understand and extend the incoming GMCP system for Oxidus. Covers message reception, parsing via ClassGMCP, submodule routing, supported packages from clients, cooldown limiting, and how to add new incoming handlers.

Understand and extend the outgoing GMCP system for Oxidus. Covers the GMCP daemon, send_gmcp routing, all outgoing package modules (Char, Core, Comm, Client, Room), data formats, calling patterns from game code, and how to add new outgoing packages.

Create HTTP client daemons for Oxidus. Covers inheriting STD_HTTP_CLIENT, making requests (GET/POST/PUT/DELETE etc.), the callback lifecycle, redirect handling, TLS/HTTPS, response processing, and the HTTPC_D fetch wrapper.

Create HTTP server daemons for Oxidus. Covers inheriting STD_HTTP_SERVER, listening on ports, handling incoming requests, sending responses, TLS, deflate compression, and connection management.

Understand and work with the identification and description systems in Oxidus. Covers IDs, adjectives, automatic pluralization, adjective+ID combinations, parse_command integration, short/long descriptions, extra descriptions, names, and how the look command displays objects.

Understand and work with the mass, capacity, and container systems in Oxidus. Covers mass tracking and propagation, container capacity/fill, open/close/lock states, opacity, key IDs, the transactional move system, and GMCP integration.

Understand and use the messaging system for Oxidus. Covers tell functions (tell, tell_up, tell_down, tell_all, tell_me, tell_them), the containment hierarchy, message reception and processing (EXT_MESSAGING), action messages (simple_action, targetted_action, etc.), system feedback (_ok, _error, _warn, _info), message type flags, and color/accessibility handling.

Understand and work with the persistence system in Oxidus. Covers save_var() variable marking, save_to_string/load_from_string serialization, the persist_data module (setPersistent/saveData/restore_data), the PERSIST_D daemon, and recursive inventory persistence.

Create rooms for Oxidus. Covers the setup chain, exits, descriptions, items, doors, terrain, zones, room metadata, and monster spawning.

Create virtual (procedurally generated) areas for Oxidus. Covers zone daemons, virtual servers, room templates, map daemons, description daemons, and coordinate-based room generation.

Create virtual (data-driven) items and mobs for Oxidus. Covers LPML data files, extension-based routing, virtual compile modules, base classes, and how to add new virtual object types.

Create WebSocket client daemons for Oxidus. Covers inheriting STD_WS_CLIENT, connecting, the handshake lifecycle, sending/receiving text and binary frames, ping/pong, graceful close, TLS/WSS, and subprotocols.

Guidelines for writing Oxidus wiki pages in Starlight (Markdown/MDX). Covers Canadian English spelling, file locations, frontmatter, code blocks, and available components.