skills

skills.txt is the largest schema in the game data — every active ability, passive, aura, mastery, and engine-internal pseudo-skill lives here, with the columns describing how the ability behaves on the server, how it renders on the client, what missiles it spawns, what state it applies, what damage it deals (physical and elemental, with per-level scaling), what mana it costs, what it requires, and which class it belongs to. Other tables consult this table for skill IDs, costs, prerequisites, and item-mod scaling.

429 rows, 322 columns. The 8 player classes contribute exactly 30 skills each (240 total class skills); the remaining 189 rows are monster skills, hireling skills, item-effect skills (the proc skills used by Properties.txt), summon skills, and engine-internal pseudo-skills (SwapWeapons, Map, ShowItems, RunToggle — 4 rows are flagged InGame=blank, treated as control inputs rather than combat abilities).

The 322 columns are wide because each row carries the full configuration for both the server-side and client-side execution paths, plus the visual / audio overlay set, the aura system, the passive system, the summoning system, the progressive-charge system, the item-triggered variants, and ten generic numeric calc fields and twenty generic Param fields used as inputs to the skill-specific functions.

Architecture: function pointers + numeric inputs

Skills are not described declaratively in this table. Instead, each row points to a numbered C function in the engine (one for the server-side start, one for the server-side do, one for the client-side mirror, etc.) and provides the numeric inputs those functions consume. The pattern is consistent throughout the schema:

• Function-pointer columns (srvstfunc, srvdofunc, cltstfunc, cltdofunc, etc.) hold a numeric ID corresponding to a hard-coded engine routine. The same routine may serve dozens of skills with different parameter values.
• Generic input columns (calc1–calc10, Param1–Param20) hold the numeric values those functions consume. Each generic column is paired with a sibling comment column (*calc1 desc, *Param1 Description) so authors can remember what a particular skill is using each slot for. The * prefix marks it as a comment field the engine ignores.
• Specialized columns (mana, requirements, damage scaling, missile pointers, target flags) configure the framework around the function call.

This means understanding a skill row requires looking at three layers: which function it dispatches to, which generic inputs that function reads, and which framework columns gate when the function runs. The function-code tables below are large because they enumerate the entire dispatch space — but a typical row uses only a handful of codes and fills only a few calc / Param slots.

What's in a row

The 322 columns split into the following functional groups.

Identity

Server-side execution: start / do / stop

The runtime executes a skill in three phases. Each phase has a function-pointer column and an optional progressive-charge variant.

Missiles

Aura system

A large block of columns implements skills that apply ongoing state effects within a radius. Auras are skills with aura = 1 that periodically run their server function (every perdelay frames) while active.

Passive system

For skills with passive = 1. 30 of 429 rows are passive — Mastery skills, Iron Skin, Natural Resistance, all the +X-to-stat skills that take effect on level-up rather than on cast.

Summon system

For skills that create pets (Raise Skeleton, Valkyrie, Iron Golem, Shadow Master, Hydra, etc.).

Sounds and overlays

Client-side execution

Mirrors the server-side execution structure for client-only effects (visual missiles, sound effects, animation timing). The client side is what other players see.

Skill behavior flags

Item-type filters

Up to two parallel sets of item-type include / exclude filters. Each set has 3 includes and 2 excludes, so a skill can require, for example, "axe or sword, but not a two-handed sword."

Animation and sequences

Targeting and validation

Item-triggered execution

For the proc-skill system: when a Properties.txt mod fires a skill (e.g. "10% chance to cast level 5 Frost Nova when struck"), the engine uses these columns instead of the normal start/do functions, because the trigger context is different (no mana cost, no weapon check, possibly different target).

Skill points and requirements

State restriction

Casting timing

Mana cost

Behavior modifiers

Generic calculation slots

Damage (physical)

Damage (elemental)

The elemental block parallels the physical block — a base + 5 per-level-bracket scaling fields, plus a duration field if the elemental type has one (Cold, Burn, Poison, Freeze).

AI and gold cost

Row terminator

Worked example: Sorceress Fire Ball

A standard tier-2 caster skill — single missile, no aura, no progressive charges, requires a prerequisite skill, scales physical-free elemental damage per level.

Notice what's not populated: no srvstfunc or srvdofunc (the missile carries the behavior), no MinDam/MaxDam (no physical damage), no aura columns, no passive columns, no summon columns, no progressive columns. Most of the 322 columns are blank for a typical caster missile — they exist for the rare skills that need them.

Worked example: Paladin Concentration aura

A passive-style aura that auto-runs while active.

All 16 Paladin auras share perdelay = 50 and the same overall structure — they differ in aurastate, aurastat1–aurastat6 (which stats they grant), and the calc formulas controlling those stats' values.

Cross-references

• SkillDesc.txt — skilldesc references this table for tooltip strings, icons, skill-tree positions, and synergy descriptions.
• Missiles.txt — srvmissile / srvmissile[abc] and cltmissile / cltmissile[abcd] reference missile rows here for projectile behavior, damage, and visual.
• States.txt — aurastate, auratargetstate, passivestate, State1–State3 reference state codes here.
• Properties.txt — proc-skill and class-skill mods reference skills here by *Id or by skill name; gold-cost calculations use this table's cost mult / cost add.
• itemstatcost.txt — aurastat1–aurastat6 and passivestat1–passivestat14 reference stat names here; Encode = 1/2/3 stats consult cost mult / cost add.
• monstats.txt — monster skills (the rows where charclass is blank and the skill is referenced as a monster's Skill1–Skill8) bind monsters to skills defined here.
• PetType.txt — pettype references this table for pet-summon shared properties.
• MonStats2.txt — many srvdofunc codes consult MonStats2.txt flags (e.g. soft, large, small) to branch behavior.
• PlrMode.txt / MonMode.txt — anim / monanim reference player and monster animation modes.
• PlayerClass.txt — charclass references this table.
• itemtypes.txt — itypea1–itypea3, etypea1–etypea2, itypeb1–itypeb3, etypeb1–etypeb2, and passiveitype reference item-type codes here.
• Sounds.txt, Overlay.txt, Events.txt — sound, overlay, and event hooks throughout the schema reference these tables.
• CharStats.txt — Mana per Magic, Life per Vitality, Stamina per Vitality are consulted indirectly via itemstatcost op functions when stats granted by skills/auras are calculated.