UGAS Genre Pack: Strategy

This genre pack targets strategy games in the StarCraft / Age of Empires / Command & Conquer / tower-defense mould: planning, economy, and tactical decision-making rather than reflex. A unit is defined by combat attributes (health, armor, attack, range, speed) and a production cost; a player runs a resource economy that grows over time; and combat is decided by a rock-paper-scissors matrix of damage types against armor classes layered on top of flat armor. It is broad enough to seed an RTS, a 4X game (the same economy and tech scale to per-turn income and research trees), a real-time-tactics skirmish, or a tower-defense map (the slow debuff and area strike are the tower-defense flavour).

The genre’s two signature mechanics are:

Both lean entirely on core constructs. Unlike the Platformer, Racing, and ARPG packs, the core specification ships no dedicated strategy case study, so this pack is designed from first principles — but it reuses the periodic-effect machinery (core spec §9.3), the modifier Channel mechanism (§5.3) for stacking tech upgrades, custom Executions (§9.5) for the mitigation matrix, and effect-granted tags (§7.5) for the unit state machine. The core spec Gameplay Controller (§4) is the unit (or the player’s commander).

This document is additive. It defines genre-specific Attributes, Tags, Abilities, and Effects on top of the core Universal Gameplay Ability System specification.

Defined in entities/attribute_set.yaml as the UnitStatsSet set. The base values describe a default mechanical assault unit, so the set is playable as shipped. Armor class and damage type are deliberately not attributes — they are tags (Armor.Class., DamageType.) read by the mitigation calc.

The economy resources are commander-scoped: in a real game they live on a per-player commander GC that owns no combat stats, while combat units leave them at base. They are grouped into the one set so the pack ships self-contained and playable; the worked unit only populates its combat attributes.

A strategy game is paced by income over time, and UGAS expresses that directly with a periodic infinite effect (§9.3): an effect whose DurationPolicy is Infinite and that carries a Period re-runs its modifiers on that cadence for as long as it is active.

GE_MineralIncome (entities/effect_mineral_income.yaml) is the showcase: Infinite duration, Period: { Period: 1.0 }, and a single Add of \(+5\) to Minerals. One instance is applied to the commander GC per working harvester, so income scales with how many harvesters a player commits — no per-frame polling, no custom code. With \(n\) harvesters active, the commander’s mineral rate is:

so over a \(t\)-second window the income is \(5 n t\) minerals. ExecuteOnApplication is false, so the first payout lands one full second after a harvester starts rather than instantly. GE_EnergyRegen reuses the identical pattern at a 2-second cadence to refill a caster unit’s Energy, proving the construct is not economy-only.

Spending is the mirror image: each production ability names a trivial cost effect — GE_BuildCost, GE_TrainCost, GE_AreaStrikeCost — that subtracts the resource. Because an ability cannot activate if it cannot pay its cost (§8.5), an under-resourced player simply cannot start the action, with no explicit "enough minerals" tag needed (these trivial cost effects are referenced by name rather than shipped as files, the convention the Racing and Shooter packs use).

Permanent, faction-wide research is a declarative stack on the modifier pipeline. Spread was the Shooter pack’s channel showcase; here it is AttackDamage. Modifiers in the same Channel are additive within; channels multiply across (§5.3), so a tech that has been researched twice stacks without any custom code:

A Siege Tank with two weapon-upgrade ranks and one armor-upgrade rank researched:

These are exactly the CurrentValue entries recorded for the example tank. The Debuffs channel used by GE_Slow multiplies against Upgrades, so a slow never simply cancels a movement upgrade — the two compose.

Strategy combat is not a single subtraction. Every weapon carries a DamageType. tag and every target an Armor.Class. tag; the pairing selects a rock-paper-scissors multiplier, and only then is flat Armor removed. That coupling is non-linear in the tag pair, so it lives in a custom ExecutionCalculation (§9.5) rather than a channel.

GE_UnitDamage (entities/effect_unit_damage.yaml) is the payload GA_AutoAttack applies to the target. It delegates to ExecCalc_ArmorMitigation, which (1) reads the attacker’s DamageType. tag and the target’s Armor.Class. tag, (2) looks up the multiplier in the matrix below, (3) multiplies the attacker’s aggregated AttackDamage, (4) subtracts the target’s flat Armor (floored at a small chip value so a hit is never fully negated), (5) writes the result to Health and records it in the EffectiveDamage Meta attribute for telemetry/UI. This is the strategy analogue of the Shooter pack’s hit-resolution calc and the Racing pack’s traction calc — the seam where the genre’s signature math plugs into UGAS.

Read it as rock-paper-scissors: Piercing shreds Light infantry but glances off Fortified structures; Siege cracks Fortified but is poor against Heavy vehicles and Shielded units; Magic melts Shielded units but underperforms elsewhere; Normal is the safe all-rounder that is never penalised below baseline (except against Fortified).

The example Siege Tank (aggregated AttackDamage \(= 39\), DamageType.Siege) fires at two different targets:

Same attacker, same AttackDamage: the matrix alone turns a \(46.75\)-damage hit into a \(25.25\)-damage one purely from the target’s armor class — which is exactly the tactical decision (what to build against what) that defines the genre.

Defined in entities/tag_registry.yaml (additive only):

The core lifecycle tags State.Alive / State.Dead are referenced, not re-declared.

The pack ships the canonical RTS point-and-click scheme. entities/input_actions.yaml defines Select, AttackMove (the contextual move/attack order), Build, Train, CastAbility, and the CameraPan axis; entities/input_action_set_command.yaml groups them into the Command set (active while State.Alive); entities/input_mapping_command_pc.yaml binds them to keyboard + mouse (left-click select, right-click order, B/T/Q hotkeys, WASD camera); and entities/input_modifiers.yaml provides the camera-feel modifiers. The worked unit’s GA_AutoAttack is bound to the AttackMove action and GA_AreaStrike to CastAbility via their `InputID`s.