skills-and-advancement

Skills and Advancement Skill

You are helping work with the Oxidus skill and advancement systems. Follow the lpc-coding-style skill for all LPC formatting.

Architecture Overview

skills.lpc (std/living/skills.lpc)           — nested skill tree, use-based improvement
advancement.lpc (std/living/advancement.lpc) — per-living XP/level state
advance.lpc (adm/daemons/advance.lpc)        — TNL formula, kill_xp, earn_xp
attributes.lpc (std/living/attributes.lpc)   — STR/DEX/CON/INT/WIS/CHA
boon.lpc (std/living/boon.lpc)               — buff/debuff modifiers on skills and vitals

All of these are inherited by STD_BODY and apply to both players and NPCs.

Skill System — std/living/skills.lpc

Storage Structure

Skills are a nested tree, not a flat mapping:

skills = ([
    "combat": ([
        "level": 3.47,
        "subskills": ([
            "melee": ([
                "level": 2.15,
                "subskills": ([
                    "slashing": ([ "level": 4.82, "subskills": ([]) ]),
                    "piercing": ([ "level": 1.03, "subskills": ([]) ]),
                    "bludgeoning": ([ "level": 2.60, "subskills": ([]) ]),
                    "unarmed": ([ "level": 1.55, "subskills": ([]) ]),
                ]),
            ]),
            "defence": ([
                "level": 1.90,
                "subskills": ([
                    "dodge": ([ "level": 3.21, "subskills": ([]) ]),
                    "parry": ([ "level": 1.10, "subskills": ([]) ]),
                ]),
            ]),
        ]),
    ]),
])

Dot notation addresses nodes: "combat.melee.slashing" navigates the tree.

The integer part of the level is the effective skill level. The fractional part is progress toward the next level (0-99%).

A private find_skill_node(string skill) helper walks the dot-path and returns the live node mapping (or 0). Every read/leaf-mutate function delegates to it — add_skill and remove_skill keep their own walks because they need creation / parent-ref semantics.

Default Skill Tree (from config)

The tree lives under SKILLS.learnable in adm/etc/default.lpml:

combat
  defence: dodge, parry
  melee: attack, bludgeoning, piercing, slashing, unarmed
social: barter, charm, intimidate, persuade
general: appraise, hide, jump, listen, search, spot, swim

Full dot-path examples: "combat.melee.slashing", "combat.defence.dodge", "social.barter", "general.swim".

"combat.defence.evade" is used by combat but is not in the learnable tree — it is created on first use by assure_skill().

Improvement Tuning Knobs (config)

The rest of the SKILLS block holds the numbers use_skill reads on every call:

COMBAT.NPC_SKILL_MULTIPLIER is the matching knob for NPC skill levels.

Read the current values from adm/etc/default.lpml, and never restate them in code, comments, or a call site. They are tuning knobs and they move; a literal copied out of that file is wrong the next time it is turned. Everything below describes the shape of the maths, not the numbers going into it.

Key Functions

Use-Based Improvement

Players improve skills transparently by using them — no skill points or manual allocation.

use_skill() is the only entry point, and it is player-only — the first thing it does after validating its argument is pcp(), and a non-player returns 0 without touching the tree. An unknown skill is created and then rolled in the same call:

varargs int use_skill(string skill, mixed improvement, mixed improvement_chance) {
    // not a player  -> return 0, nothing happens
    // unknown skill -> assure_skill() at 1.0, then carry on
    // then          -> pick a node, roll against THAT node, clamp, improve
}

The node is drawn before the roll, and the chance is read from the drawn node's level, not the named skill's. That is what lets an under-trained ancestor climb at its own rate instead of being throttled by the child that was actually used.

The chance is not flat, and it falls as the skill rises. Absent an improvement_chance argument it is improve_chance.floor + (improve_chance.ceiling - dim_hyperbolic(raw, improve_chance.ceiling)), where raw is query_raw_skill() of the drawn node and dim_hyperbolic(v, s) == (s * v) / (s + v).

The hyperbolic term is the portion of the ceiling bonus that skill has already worn away, so the chance starts at floor + ceiling, has shed half the bonus by the time the raw skill reaches ceiling, and approaches the floor asymptotically without ever reaching it. A novice trains quickly, a veteran slowly, and no skill ever stops improving outright — the cap does that.

The erosion is deliberately gentle: it is hyperbolic rather than exponential, so the rate decays over the whole skill range instead of collapsing in the first few levels. Roughly, with the current config:

Read SKILLS.improve_chance for the live numbers; the shape is what matters here. If a future tuning pass wants a sharper falloff, swap dim_hyperbolic for dim_exponential_decay on the same subtraction — that is the knob, not the config values.

use_skill() is called throughout the codebase:

• Combat: attacker trains weapon skill after each swing, defender trains defence skill on every hit attempt.
• Any system can call use_skill("general.swim") etc. to trigger organic improvement.

improvement replaces the SKILLS.default_gain bound for this call. It is a bound, not an award — improve_skill applies random_float() of it.

improvement_chance replaces the whole computed chance for this call, as a flat percentage rolled against random_float(100.0). Pass it when a call site needs a rate that does not track the skill's own level — a guaranteed tick at 100.0, or a deliberately rare one. Omit it everywhere else, because the level-scaled default is what keeps advancement curves consistent across the lib.

Omit it unless the call site genuinely wants to advance at a different rate from everything else, and if you do pass one, read SKILLS.default_gain before choosing the literal — the argument is an absolute bound, not a multiplier, so whether a given number speeds a call site up or slows it down depends entirely on where the default currently sits. Existing spell and ability sites pass literals (`victim-

Content truncated.