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": ([]) ]),
                ]),
            ]),
            "defense": ([
                "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)

combat
  defense: 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.defense.dodge", "social.barter", "general.swim".

Key Functions

Use-Based Improvement

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

varargs int use_skill(string skill, mixed mod_adjust) {
    if(has_skill(skill)) {
        if(random_float(100.0) < 20.0)          // 20% chance per use
            improve_skill(skill, mod_adjust);
    } else {
        assure_skill(skill);                     // auto-create at level 1.0
    }
}

use_skill() is called throughout the codebase:

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

mod_adjust raises the per-call progress cap above the 0.01 default. Use it for low-frequency call sites (specific spells, niche abilities) where the default would feel painfully slow. Pattern: tp->use_skill("combat.spell.light", 0.15);. Hot paths (combat swings, defense checks) should omit it. All nodes on the path share the same cap — the bubble-up doesn't tighten it, so pick mod_adjust values that are reasonable for parents too.

Improvement Algorithm

improve_skill(string skill, mixed potential_progress):

1. Coerces potential_progress to a float — accepts omitted/null (defaults to 0.01 via FluffOS's (: 0.01 :) default-closure syntax, resolved at the call boundary), float (as-is), int (promoted), or a closure (evaluated against this_object()).
2. Builds the dot-path's chances mapping: each node's weight is (depth+1)*3. For a 3-segment path: leaf 50%, middle 33%, root 17%.
3. Picks one node via element_of_weighted(chances).
4. Applies random_float(progress) to that node's level.
5. If the floored level rises, notifies the player: "You have improved your X skill."

This means using "combat.melee.slashing" can also improve "combat.melee" or "combat" — but with lower probability. Parent skills grow organically as their children are used, but more slowly because they are picked less often. Every node on the path uses the same cap; bubble-up balance lives entirely in the pick weights — that's the lever to tune if balance ever feels off.

Query API Grid

Four query functions form an orthogonal grid over two axes: floored vs raw float, and with-boon vs without-boon.

Pick by what the call site actually wants:

• Hit/damage formulas → query_skill_level(). Combat math.
• Proc rolls / scaling on fractional progress → query_raw_skill() (e.g. multi-strike in swing()) or query_skill() if buffs should help.
• Existence check → has_skill(s) — returns 1 or 0. Do not use nullp(query_raw_skill(...)) for this.

All four functions return null if the skill is not found. NPCs and players read the same storage — there is no NPC shortcut. NPCs are seeded at level * 3.0 at setup time so the storage is honest for both through the same code path.

Boon Integration

The query_skill and query_skill_level variants add the effective boon modifier:

// query_skill_level
return floor(level) + query_effective_boon("skill", skill);
// query_skill
return level + query_effective_boon("skill", skill);

Where query_effective_boon("skill", "combat.melee.slashing") = sum of boons minus sum of curses for that skill class+type. See the buff-system skill for details on applying boons. Use the query_raw_* variants when you explicitly want to bypass boons (e.g. introspection commands, raw progression UI).

Skills Used by the Combat System

XP and Advancement

Per-Living State — std/living/advancement.lpc

Functions

Content truncated.