Overview

This genre pack targets survival / crafting games in the Rust / The Forest / Don’t Starve / Valheim mould: a survivor kept alive against a clock of needs — hunger, thirst, stamina, and body temperature that all drain over time — who stays in the world by gathering raw materials, crafting tools, and building shelter, all while an inventory weight limit (encumbrance) pushes back against hoarding.

The signature mechanic is a needs / vitals decay loop: each need is a Period`ic, `Infinite Effect that drains its Attribute every tick, and when a need bottoms out an engine-detected threshold fires a cascading penalty — starvation, dehydration, or hypothermia that drains Health. This persistent decay-and-cascade loop is what makes the genre distinct: where an action or shooter character is defined by what they do in a fight, a survivor is defined by a background simulation that is always running them down.

The taxonomy (see the Survival & Crafting family) places this family beside Action and Simulation, and it overlaps both heavily — a survival game has real-time action and it models systems with fidelity. What this pack keeps as the distinct core is neither the combat nor the simulation breadth but the needs loop: the ever-present pressure of hunger, thirst, cold, and load. The pack prioritization ranks Survival / Crafting fourth, as a high-engagement, fast-growing category.

The core specification ships no dedicated survival case study, so this pack is designed from first principles. It still leans entirely on core constructs: periodic Effects (core spec §9.3) for the decay loop, the modifier Channel mechanism (§5.3) for stacking movement penalties, attribute Clamping with a comfort window (§5.4) for body temperature, effect-granted tags (§9.7) for the survival state machine, and an optional ExecutionCalculation (§9.5) for the aggregated-penalty seam.

Relationship to the core specification

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

  • It MUST NOT redefine, override, or contradict any concept in the core spec.

  • All entities in entities/ validate against the same schemas/*.json as the core.

  • It reuses the core lifecycle tags (State.Alive, State.Dead) by reference — the worked survivor in entities/gameplay_controller.yaml owns State.Alive — and adds survival-specific states (Survival.State.Starving, Survival.State.Cold, …) granted by Effects (§9.7), never written directly by abilities.

  • The decay loop is the core periodic Effect (§9.3); the movement penalties stack through the core modifier Channel mechanism (§5.3); the body-temperature comfort window is core attribute Clamping (§5.4) — exactly the technique the Racing pack uses for TireTemperature. None of these is a new construct.

Genre Attributes

Defined in entities/attribute_set.yaml as the SurvivorVitalsSet set. The base values describe a rested, fed survivor at a comfortable temperature carrying nothing, so the set is playable as shipped: every need starts full and the decay loop drains it from there.

Attribute Category Role

MaxHealth / Health

Statistic / Resource

Health is clamped to [0, MaxHealth]; the sink that the starvation, dehydration, and hypothermia cascades drain.

MaxHunger / Hunger

Statistic / Resource

Hunger is clamped to [0, MaxHunger]; drained by GE_HungerDecay. At 0 the engine grants Survival.State.Starving.

MaxThirst / Thirst

Statistic / Resource

Thirst is clamped to [0, MaxThirst]; drained by GE_ThirstDecay. At 0 the engine grants Survival.State.Dehydrated.

MaxStamina / Stamina

Statistic / Resource

Stamina is clamped to [0, MaxStamina]; spent by sprinting, regenerated by GE_StaminaRegen. At 0 the engine grants Survival.State.Exhausted.

BodyTemperature

Statistic

Core temperature (°C), clamped to the survivable [25, 43]; the comfort window is 36–38. Below it the engine grants Survival.State.Cold, above it Survival.State.Hot.

MoveSpeed

Statistic

Ground movement speed; cut by the Encumbrance and Cold channels.

MaxCarryWeight / CarryWeight

Statistic / Resource

CarryWeight (kg) is clamped to ≥ 0; raised by gathering. When it exceeds MaxCarryWeight the engine grants Survival.State.Overencumbered.

Materials

Resource

Generic harvested crafting materials; spent by GA_Craft / GA_Build.

WarmthRating, VitalsDrainRate

Meta

Runtime telemetry: aggregated insulation (Warmth channel) and the combined per-tick Health delta written by ExecCalc_SurvivalTick.

The body-temperature comfort window is the direct analogue of the Racing pack’s TireTemperature, which clamps to [20, 150] with grip peaking in an 80–100 window: here BodyTemperature clamps to [25, 43] and the survivor is comfortable in 36–38. Drifting out of the window is what turns exposure into a cascading penalty (see The needs / vitals decay loop (the core survival mechanic)).

The needs / vitals decay loop (the core survival mechanic)

A survival game’s tension is a clock, and in UGAS that clock is a handful of periodic infinite Effects draining Attributes, plus threshold detectors that turn an emptied need into a cascading penalty. The split between the two is the pack’s central design seam.

Decay — periodic infinite Effects

Each need is a DurationPolicy: Infinite Effect with a Period, applied once at spawn and never removed. Per core spec §9.3 a periodic Effect "behaves like repeated Instant Effects within a duration container", so each tick is a clean instant subtraction from the need’s Base Value (§5.2):

  • GE_HungerDecay (entities/effect_hunger_decay.yaml) — Period: { Period: 1.0 }, -0.5 Hunger/tick.

  • GE_ThirstDecay (entities/effect_thirst_decay.yaml) — -0.8 Thirst/tick (people dehydrate before they starve).

  • GE_StaminaRegen (entities/effect_stamina_regen.yaml) — the inverse: +5.0 Stamina/tick, outpaced by the -3.0/tick GE_Sprinting drain while a sprint is held, so net stamina falls during a sprint and recovers after.

This is the showcase for periodic Effects, exactly the shape of the core spec’s GE_Poison example — the difference is only that survival needs run for the whole session rather than a few seconds.

Cascade — threshold-triggered penalties

When a need hits its clamp floor, an engine threshold detector applies a second Effect that drains Health for as long as the survivor stays in the bad state, and removes it once they recover. Each penalty grants its own state tag (§9.7):

Trigger (engine-detected) Grants Penalty Effect

Hunger == 0

Survival.State.Starving

GE_Starvation — Infinite + Period, -2.0 Health/tick

Thirst == 0

Survival.State.Dehydrated

GE_Dehydration — Infinite + Period, -3.0 Health/tick

BodyTemperature below the 36–38 window

Survival.State.Cold

GE_Hypothermia — Infinite + Period, -1.0 Health/tick and -25% MoveSpeed (Cold channel)

CarryWeight > MaxCarryWeight

Survival.State.Overencumbered

GE_Overencumbered — Infinite, -40% MoveSpeed (Encumbrance channel)

Body temperature separates push from consequence, one Effect each. GE_Exposure_Cold (entities/effect_exposure_cold.yaml) is the cold push — a periodic -0.4 BodyTemperature/tick from a snow biome or night air, clamped by §5.4 to the survivable floor of 25; its desert mirror GE_Exposure_Heat pushes the other way toward the 43 ceiling and grants Survival.State.Hot. Once temperature leaves the comfort window, GE_Hypothermia is the cold-side consequence — the Health drain and slowdown — with a symmetric heatstroke Effect on the high side. Insulation (clothing, shelter, a campfire) counters the cold push by adding to the Warmth channel and granting Survival.State.Sheltered.

The documented engine seam. Threshold detection — Hunger == 0, BodyTemperature outside the [36, 38] window, CarryWeight > MaxCarryWeight — is engine logic, because UGAS activation tags gate on tags, not on attribute comparisons (the same reason the shooter pack evaluates "only reload when not full" in activation logic). Everything downstream of the detector — the decay Effects, the penalty Effects, the granted states — is pure data. An adopter implements a small attribute-change watcher that applies/removes the penalty Effects at the thresholds; the balance lives entirely in the Effect YAML.

Worked example (entities/gameplay_controller.yaml)

A survivor caught out at night in a snow biome — cold and starving and overencumbered — shows both halves of the loop at once. The Health drains are the cascade; the MoveSpeed cut is the modifier pipeline aggregating two channels (§5.3), just like the shooter’s two-channel Spread:

  • Health drain/tick: \((-2.0)_{\text{Starvation}} + (-1.0)_{\text{Hypothermia}} = -3.0\) (recorded in the VitalsDrainRate Meta attribute).

  • MoveSpeed: \(300 \times \underbrace{(1 - 0.40)}_{\text{Encumbrance}} \times \underbrace{(1 - 0.25)}_{\text{Cold}} = 300 \times 0.60 \times 0.75 = 135.0\).

  • BodyTemperature: pushed by GE_Exposure_Cold to \(34.0\)°C — below the 36–38 comfort window, above the 25 clamp floor.

Because the decay/penalty Effects mutate Base Values over time, Hunger reads 0, Thirst 30, and Health 40 as a mid-event snapshot, while the Statistic MoveSpeed shows the 135.0 CurrentValue from the two active multiply channels. These are exactly the values recorded for the example survivor.

Optional aggregated seam. A game that prefers one coupled penalty over three independent drains can run GE_SurvivalTick (entities/effect_survival_tick.yaml) instead, a single periodic Effect whose ExecCalc_SurvivalTick couples every deficit — how far each need is below its threshold, how far BodyTemperature is outside the window, offset by WarmthRating — into one Health delta and writes VitalsDrainRate. This is the survival analogue of the Racing pack’s ExecCalc_VehicleTraction and the shooter pack’s ExecCalc_HitResolution. Use either the individual penalty Effects or this single calc, not both. An AttributeBased magnitude (§9.4) can express the simpler couplings — e.g. scaling a penalty by CarryWeight — without custom code.

The gather → craft economy

Staying alive means refilling needs and improving the survivor, which the pack models as a small loop of Abilities over the Materials and CarryWeight resources:

  • GA_Gather (entities/ability_gather.yaml) — enters Survival.State.Gathering (GE_Gathering), waits the harvest window (WaitDelay), then applies the GE_GatherResource payload: +5 Materials and +5 CarryWeight. That second modifier is the link between gathering and encumbrance — hauling loot is what eventually trips Survival.State.Overencumbered.

  • GA_Craft (entities/ability_craft.yaml) — gated by its Cost (GE_CraftCost: -20 Materials); because an ability cannot activate if it cannot pay its cost, this is exactly what stops crafting without enough materials — no resource-check tag needed, the same convention the shooter pack uses for GE_FireCost. It enters Survival.State.Crafting, waits, then applies GE_CraftedTool (an infinite buff: +25 MaxCarryWeight, granting Item.Type.Tool).

  • GA_ConsumeFood / GA_Drink (entities/ability_consume_food.yaml, entities/ability_drink.yaml) — require a carried Item.Type.Food / Item.Type.Water, wait briefly, then apply the instant GE_EatFood (+40 Hunger) / GE_DrinkWater (+50 Thirst). Because the restores are Instant they lift the need’s Base Value off 0, which is what lets the engine clear the matching cascade.

  • GA_Sprint (entities/ability_sprint.yaml) — the hold-then-WaitInputRelease shape shared with the shooter’s GA_Aim and the racing pack’s GA_Drift: applies GE_Sprinting on press, removes it on release. Blocked while Survival.State.Exhausted or Survival.State.Overencumbered.

  • GA_Build (entities/ability_build.yaml) — like GA_Craft, gated by a Cost (GE_BuildCost: -10 Materials); the structure spawn itself is engine logic keyed off the ability completing.

GE_CraftCost and GE_BuildCost are trivial flat resource costs referenced by name rather than shipped as files, the same convention the Racing pack uses for its nitro cost/cooldown.

Genre Tags

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

  • Survival states — Survival.State.Starving|Dehydrated|Exhausted|Cold|Hot|Overencumbered|Sheltered, each granted by its penalty/relief Effect.

  • Activity states — Survival.State.Gathering|Crafting|Sprinting, granted for the duration of the matching activity.

  • Items & resources — Item.Type.Food|Water|Material|Tool, and resource nodes Resource.Node.Tree|Rock|Bush|Water.

  • Ability types — Ability.Type.Gather|Craft|Consume|Build|Movement.

  • Biome & environment — Biome.Temperate|Snow|Desert and Environment.TimeOfDay.Night, granted by area volumes and the day/night cycle to drive temperature exposure.

Genre Abilities

  • entities/ability_gather.yaml — GA_Gather: harvest a node into the inventory.

  • entities/ability_craft.yaml — GA_Craft: spend materials to craft a tool.

  • entities/ability_build.yaml — GA_Build: spend materials to place a structure.

  • entities/ability_consume_food.yaml — GA_ConsumeFood: eat to restore Hunger.

  • entities/ability_drink.yaml — GA_Drink: drink to restore Thirst.

  • entities/ability_sprint.yaml — GA_Sprint: hold to sprint, draining Stamina.

Genre Effects

  • entities/effect_hunger_decay.yaml — GE_HungerDecay: periodic infinite Hunger drain.

  • entities/effect_thirst_decay.yaml — GE_ThirstDecay: periodic infinite Thirst drain.

  • entities/effect_stamina_regen.yaml — GE_StaminaRegen: periodic infinite Stamina regen.

  • entities/effect_starvation.yaml — GE_Starvation: periodic Health drain; grants Survival.State.Starving.

  • entities/effect_dehydration.yaml — GE_Dehydration: periodic Health drain; grants Survival.State.Dehydrated.

  • entities/effect_exposure_cold.yaml — GE_Exposure_Cold: periodic BodyTemperature push down; grants Survival.State.Cold.

  • entities/effect_exposure_heat.yaml — GE_Exposure_Heat: periodic BodyTemperature push up; grants Survival.State.Hot.

  • entities/effect_hypothermia.yaml — GE_Hypothermia: periodic Health drain + Cold-channel MoveSpeed cut; grants Survival.State.Cold.

  • entities/effect_overencumbered.yaml — GE_Overencumbered: Encumbrance-channel MoveSpeed cut; grants Survival.State.Overencumbered.

  • entities/effect_exhaustion.yaml — GE_Exhaustion: gating-only state; grants Survival.State.Exhausted (blocks GA_Sprint).

  • entities/effect_eat_food.yaml — GE_EatFood: instant +Hunger.

  • entities/effect_drink_water.yaml — GE_DrinkWater: instant +Thirst.

  • entities/effect_gather_resource.yaml — GE_GatherResource: instant +Materials and +CarryWeight.

  • entities/effect_gathering.yaml / effect_crafting.yaml — GE_Gathering / GE_Crafting: timed activity states.

  • entities/effect_sprinting.yaml — GE_Sprinting: timed + periodic Stamina drain; grants Survival.State.Sprinting.

  • entities/effect_crafted_tool.yaml — GE_CraftedTool: infinite +MaxCarryWeight buff; grants Item.Type.Tool.

  • entities/effect_survival_tick.yaml — GE_SurvivalTick: optional periodic ExecutionCalculation coupling all deficits into one Health delta.

Using this pack

  1. Copy genres/survival-crafting/ into your project (or load entities/ directly via the ugas-schema-author skill).

  2. Tune the decay rates in the GE_*Decay Effects and the penalty magnitudes in GE_Starvation / GE_Dehydration / GE_Hypothermia first — they set the pace of the whole survival clock — then add biomes as area Effects, recipes as GE_Crafted* Effects, and resource nodes as Resource.Node.* tags.

  3. Implement the threshold detectors (need == 0, BodyTemperature outside the comfort window, CarryWeight > MaxCarryWeight) that apply and remove the penalty Effects — this is the one engine seam the loop requires. Optionally wire ExecCalc_SurvivalTick if you prefer one coupled penalty Effect over three independent drains; everything else is data.

  4. Add new states as Survival.State.* tags granted by Effects (never mutate tags directly), and new survival mechanics as Effects + Abilities.

  5. Validate with python scripts/validate_schema_examples.py before committing.