# jgengine-gameplay — capability index Reach for these before hand-rolling. Each row is *the thing you need* → *the primitive that already does it*. ## achievements — track achievement/trophy unlocks over counter goals and boolean flags, with score, completion, an onUnlock seam, and serializable snapshot/restore - `createAchievementTracker` (function) · `import { createAchievementTracker } from "@jgengine/core/gameplay"` ## advance-ledger — settle due scheduled transactions through a policy pipeline - `advanceLedger` (function) · `import { advanceLedger } from "@jgengine/core/gameplay"` ## affix-roller — roll randomized gear (guns, armor, loot) with rarity tiers, stat scaling and prefix/suffix affixes from a seed - `createAffixRoller` (function) · `import { createAffixRoller } from "@jgengine/core/gameplay"` ## agent-schedule — an authored per-agent day plan with a work beat and off-hours behaviour - `createAgentSchedule` (function) · `import { createAgentSchedule } from "@jgengine/core/agents/schedule"` ## agents — a needs, thought, action and mood loop an agent runs on the world clock - `createAgent` (function) · `import { createAgent } from "@jgengine/core/agents/agent"` ## auction-book — timed bid auctions with escrowed bids, buyout, anti-snipe close extension, and collection-box settlement - `createAuctionBook` (function) · `import { createAuctionBook } from "@jgengine/core/gameplay"` ## best-record — persist personal-best times/scores with safe storage fallback - `createRecordBook` (function) · `import { createRecordBook } from "@jgengine/core/gameplay"` ## build — a serializable directed/undirected pair key that resists delimiter collisions - `createPairKeyCodec` (function) · `import { createPairKeyCodec } from "@jgengine/core/gameplay"` ## cancel-scheduled-rule — remove a scheduled rule and its cursor entirely - `cancelRule` (function) · `import { cancelRule } from "@jgengine/core/gameplay"` ## cancel-work — remove a job and compute its refund from reservation and progress - `cancelJob` (function) · `import { cancelJob } from "@jgengine/core/gameplay"` ## career-bank — persistent career money with a run haul that can be banked or lost - `createCareerBank` (function) · `import { createCareerBank } from "@jgengine/core/progression/careerBank"` ## carry-encumbrance — gate a pickup against the carrier's remaining capacity - `canCarry` (function) · `import { canCarry } from "@jgengine/core/inventory/carryLoad"` - `characterLoad` (function) · `import { characterLoad } from "@jgengine/core/inventory/carryLoad"` - `resolveEncumbrance` (function) · `import { resolveEncumbrance } from "@jgengine/core/inventory/encumbrance"` ## carry-load — read carried stacks out of one or more inventories for a weight query - `carriedEntries` (function) · `import { carriedEntries } from "@jgengine/core/inventory/carryLoad"` - `totalLoad` (function) · `import { totalLoad } from "@jgengine/core/inventory/encumbrance"` ## cell-grid — immutable 2D board of cells with row clears, gravity collapse, and match runs - `createCellGrid` (function) · `import { createCellGrid } from "@jgengine/core/puzzle/cellGrid"` ## clip-roles — map a rigged asset's pack-specific clip name to its semantic animation role - `classifyClip` (function) · `import { classifyClip } from "@jgengine/core/game/clipRoles"` - `defaultAnimationForClips` (function) · `import { defaultAnimationForClips } from "@jgengine/core/game/clipRoles"` ## codex — codex/bestiary/lorebook of defined entries with discovery tracking, categories, secret masking, completion, an onDiscover seam, and serializable state - `createCodex` (function) · `import { createCodex } from "@jgengine/core/gameplay"` ## compose-game-loop — fold composable systems into the game loop without a manual tick fan-out - `composeGameLoop` (function) · `import { composeGameLoop } from "@jgengine/core/gameplay"` ## consumables — use/consume items with cooldowns and effects - `createItemUse` (function) · `import { createItemUse } from "@jgengine/core/gameplay"` ## content-progression-validation — diagnose unavailable sources and blocked cross-content progression under explicit game-owned rules without rejecting intentional seeded cycles - `validateContentProgression` (function) · `import { validateContentProgression } from "@jgengine/core/game/contentValidation"` ## content-reference-validation — locate duplicate content ids and broken references across game-owned catalog namespaces with repair guidance - `validateContentReferences` (function) · `import { validateContentReferences } from "@jgengine/core/game/contentValidation"` ## control-suspension — Suspend player input across overlapping menus without stopping shared simulation. - `suspendPlayControls` (function) · `import { suspendPlayControls } from "@jgengine/core/game/controlGate"` ## cosmetics — equip cosmetic skins and customizations by slot - `createCosmetics` (function) · `import { createCosmetics } from "@jgengine/core/gameplay"` ## creature-breeding — deterministic stat inheritance, mutation, and lineage genetics for taming games - `breedOffspring` (function) · `import { breedOffspring } from "@jgengine/core/game/breeding"` ## currency-major-units — convert safe minor-unit integers into currency amounts - `fromMinorUnits` (function) · `import { fromMinorUnits } from "@jgengine/core/economy/currency"` ## currency-minor-units — round decimal currency into safe integer minor units - `toMinorUnits` (function) · `import { toMinorUnits } from "@jgengine/core/economy/currency"` ## currency-precision-format — display a currency using its declared decimal precision - `formatCurrency` (function) · `import { formatCurrency } from "@jgengine/core/economy/currency"` ## decay-meter — survival meters that drain/refill over game time (hunger, water, oxygen, stamina) - `createDecayMeterSet` (function) · `import { createDecayMeterSet } from "@jgengine/core/gameplay"` - `decayMeterMoodles` (function) · `import { decayMeterMoodles } from "@jgengine/core/gameplay"` - `decayMeterSnapshot` (function) · `import { decayMeterSnapshot } from "@jgengine/core/gameplay"` - `decayMeterState` (function) · `import { decayMeterState } from "@jgengine/core/gameplay"` - `decayMeters` (function) · `import { decayMeters } from "@jgengine/core/gameplay"` - `initDecayMeters` (function) · `import { initDecayMeters } from "@jgengine/core/gameplay"` - `refillMeter` (function) · `import { refillMeter } from "@jgengine/core/gameplay"` ## declarative-predicate — serializable data-driven conditions with no callbacks in saved content - `evaluatePredicate` (function) · `import { evaluatePredicate } from "@jgengine/core/gameplay"` - `readPath` (function) · `import { readPath } from "@jgengine/core/gameplay"` ## define-system — composable game behavior — pure data + hooks the engine schedules; pass via `defineGame({ systems })` - `defineSystem` (function) · `import { defineSystem } from "@jgengine/core/gameplay"` ## detect — fire-once threshold/milestone/tier crossings when a value moves - `crossThresholds` (function) · `import { crossThresholds } from "@jgengine/core/gameplay"` ## dialogue-bridge — open/close the talkable→DialogueBox flow with no per-game store or command glue - `createGameDialogue` (function) · `import { createGameDialogue } from "@jgengine/core/gameplay"` ## dialogue-graph-validation — diagnose duplicate ids, broken branches, unreachable dialogue, and nodes without a route to an ending before play - `validateDialogueGraph` (function) · `import { validateDialogueGraph } from "@jgengine/core/game/dialogueGraph"` ## dialogue-graph-view — select a conversation node's render-ready view (speaker, line, branching choices) from a serializable dialogue graph - `selectDialogueView` (function) · `import { selectDialogueView } from "@jgengine/core/gameplay"` ## dialogue-run — walk a serializable branching dialogue graph — current node view, choose-to-advance traversal, visited history, snapshot/restore - `createDialogueRun` (function) · `import { createDialogueRun } from "@jgengine/core/gameplay"` ## durability — track item wear, breakage, and repair - `applyWear` (function) · `import { applyWear } from "@jgengine/core/gameplay"` ## encumbrance-move-curve — progressive move-speed multiplier from a carry-load fraction - `encumbranceMoveMultiplier` (function) · `import { encumbranceMoveMultiplier } from "@jgengine/core/inventory/encumbrance"` ## enqueue-work — reserve inputs and add a timed job, honoring capacity and validation policy - `enqueue` (function) · `import { enqueue } from "@jgengine/core/gameplay"` ## equipment-slot-inventory — wear gear by slot with item-kind rules, two-handed blocking and replace-on-equip - `createEquipment` (function) · `import { createEquipment } from "@jgengine/core/inventory/equipment"` ## event-bus — typed publish/subscribe bus for gameplay events - `createGameEvents` (function) · `import { createGameEvents } from "@jgengine/core/gameplay"` ## event-feed — a rolling feed of recent gameplay events for a HUD ticker or killfeed - `createGameFeed` (function) · `import { createGameFeed } from "@jgengine/core/gameplay"` ## event-ticker — rolling capped, timed-fade event/kill-feed ticker of free-string entries over the feed helpers — push/recent-with-fade, snapshot/restore - `createEventTicker` (function) · `import { createEventTicker } from "@jgengine/core/gameplay"` ## expedition-dispatch — dispatch a saveable timed away mission with finite supplies and a seeded RNG cursor - `dispatchExpedition` (function) · `import { dispatchExpedition } from "@jgengine/core/gameplay"` ## expedition-recall — begin a safe fractional-time return after settling the pending expedition frontier - `recallExpedition` (function) · `import { recallExpedition } from "@jgengine/core/gameplay"` ## expedition-return — complete an authorized instant return without skipping unsettled ticks or reviving death - `returnExpeditionNow` (function) · `import { returnExpeditionNow } from "@jgengine/core/gameplay"` ## expedition-settle — settle bounded offline expedition ticks without losing supplies rewards or RNG continuity - `settleExpedition` (function) · `import { settleExpedition } from "@jgengine/core/gameplay"` ## fire-input — bind a key or mouse button to a named action that runs the same-named command with the aim; repeatMs auto-fires while held - `ActionCodesMap` (type) · `import { ActionCodesMap } from "@jgengine/core/gameplay"` ## game-save — one versioned save document with per-system sections, named slots, caller-policy autosave, migration and a state digest - `createGameSave` (function) · `import { createGameSave } from "@jgengine/core/gameplay"` - `createSaveStore` (function) · `import { createSaveStore } from "@jgengine/core/gameplay"` ## game-save-digest — hash a save document's state for a determinism test or a diff - `gameSaveDigest` (function) · `import { gameSaveDigest } from "@jgengine/core/gameplay"` ## game-system — declare a composable capability with its own schedule and lifecycle - `SystemDefinition` (interface) · `import { SystemDefinition } from "@jgengine/core/gameplay"` ## gear-score — score a loadout from stat weights, level, rarity and slot coverage - `gearScore` (function) · `import { gearScore } from "@jgengine/core/gameplay"` ## group-credits — turn a flat list of credited things into ordered credit sections - `groupCredits` (function) · `import { groupCredits } from "@jgengine/core/game/credits"` ## imprint-bonus — apply imprint stat and handler bonuses at an imprint fraction - `applyImprintBonus` (function) · `import { applyImprintBonus } from "@jgengine/core/game/breeding"` ## imprint-increment — per-care-request imprint gain across a maturation schedule - `imprintIncrementPerRequest` (function) · `import { imprintIncrementPerRequest } from "@jgengine/core/game/breeding"` ## incubation-tick — advance egg incubation health inside/outside its temperature range - `tickIncubation` (function) · `import { tickIncubation } from "@jgengine/core/game/breeding"` ## incubation-viability — test whether an egg incubation still has health to hatch - `incubationViable` (function) · `import { incubationViable } from "@jgengine/core/game/breeding"` ## inventory-grid — a bag of stackable items with add, remove, and move - `createEmptyInventory` (function) · `import { createEmptyInventory } from "@jgengine/core/inventory/inventoryModel"` ## inventory-split — split a stack into a target or first-empty slot, honoring a stack limit - `splitStack` (function) · `import { splitStack } from "@jgengine/core/inventory/inventoryModel"` ## item-comparison — show per-stat deltas and a weighted verdict for a drop against equipped gear - `compareToEquipped` (function) · `import { compareToEquipped } from "@jgengine/core/loot/drop"` ## item-generation — compose constraints, weighted pools, transforms, and provenance into a deterministic generated item - `generate` (function) · `import { generate } from "@jgengine/core/gameplay"` ## item-identity — resolve which match/set bonuses an item qualifies for - `activeSetBonuses` (function) · `import { activeSetBonuses } from "@jgengine/core/gameplay"` - `applySetBonuses` (function) · `import { applySetBonuses } from "@jgengine/core/gameplay"` - `candidateViolatesForbid` (function) · `import { candidateViolatesForbid } from "@jgengine/core/gameplay"` - `captureProvenance` (function) · `import { captureProvenance } from "@jgengine/core/gameplay"` - `countSetMembers` (function) · `import { countSetMembers } from "@jgengine/core/gameplay"` - `identityOf` (function) · `import { identityOf } from "@jgengine/core/gameplay"` - `isIdentityValid` (function) · `import { isIdentityValid } from "@jgengine/core/gameplay"` - `matchesQuery` (function) · `import { matchesQuery } from "@jgengine/core/gameplay"` - `validateIdentity` (function) · `import { validateIdentity } from "@jgengine/core/gameplay"` ## item-instance-registry — a runtime store for procedurally generated item instances - `createItemInstanceRegistry` (function) · `import { createItemInstanceRegistry } from "@jgengine/core/gameplay"` - `proceduralLootEntry` (function) · `import { proceduralLootEntry } from "@jgengine/core/gameplay"` ## item-ledger — track which rolled item instances are still owned, salvaged or sold - `createItemLedger` (function) · `import { createItemLedger } from "@jgengine/core/loot/salvage"` ## item-roll — roll one deterministic, level-gated item from a seed - `rollDrop` (function) · `import { rollDrop } from "@jgengine/core/loot/drop"` ## item-run-haul — carry loot with a weight gate, bank it into a persistent stash, or lose it when the run fails - `createRunHaul` (function) · `import { createRunHaul } from "@jgengine/core/loot/haul"` ## item-salvage — break an item down for the currency its level and rarity say, once - `salvageItem` (function) · `import { salvageItem } from "@jgengine/core/loot/salvage"` ## item-salvage-value — compute the currency an item of a level and rarity breaks down into - `salvageValue` (function) · `import { salvageValue } from "@jgengine/core/loot/salvage"` ## item-use-composition — compose pluggable, ordered item use-behaviors from serializable references - `createUseBehaviorRegistry` (function) · `import { createUseBehaviorRegistry } from "@jgengine/core/gameplay"` ## item-vendor — stock a vendor with rolled items priced through the shared economy - `stockVendor` (function) · `import { stockVendor } from "@jgengine/core/loot/vendor"` ## item-vendor-price — price an item from its level and rarity through the economy's currency - `itemPrice` (function) · `import { itemPrice } from "@jgengine/core/loot/vendor"` ## item-vendor-rotation — decide when a vendor's shelf is due for a restock - `createVendorRotation` (function) · `import { createVendorRotation } from "@jgengine/core/loot/vendor"` ## item-weight — read a rolled item's mass for a carry check - `itemMass` (function) · `import { itemMass } from "@jgengine/core/loot/drop"` ## key-rebinding — conflict-aware key-remap session over the action-binding model — capture/reassign, conflict detection, reset-to-defaults, persist overrides, snapshot/restore - `createRebindSession` (function) · `import { createRebindSession } from "@jgengine/core/gameplay"` ## lap-splits — per-lap durations from a cumulative split book - `lapDurations` (function) · `import { lapDurations } from "@jgengine/core/gameplay"` - `parDelta` (function) · `import { parDelta } from "@jgengine/core/gameplay"` - `splitSegments` (function) · `import { splitSegments } from "@jgengine/core/gameplay"` ## lap-timer — wall-clock current/last/best lap timing with splits - `createLapTimer` (function) · `import { createLapTimer } from "@jgengine/core/gameplay"` ## leaderboard — ranked score tracking across global, server, and per-profile scopes - `createLeaderboard` (function) · `import { createLeaderboard } from "@jgengine/core/gameplay"` ## leveling-track — grant XP, resolve level-ups against a curve, and write level+xp stats back through a stat adapter - `leveling` (function) · `import { leveling } from "@jgengine/core/gameplay"` ## lifecycle — declarative start/restart run flow — the engine owns the command glue and phase sync, the game supplies pure state transitions - `LifecycleConfig` (interface) · `import { LifecycleConfig } from "@jgengine/core/gameplay"` ## limb-health — per-body-part/region health tracked separately - `createMultiRegionHealth` (function) · `import { createMultiRegionHealth } from "@jgengine/core/gameplay"` ## listing-book — player-driven marketplace listings with a house cut, expiry sweep, and seller collection box - `createListingBook` (function) · `import { createListingBook } from "@jgengine/core/gameplay"` ## loadouts — save and swap named equipment loadouts - `createLoadouts` (function) · `import { createLoadouts } from "@jgengine/core/gameplay"` ## loan-schedule — build a loan's interest and principal repayment schedule in integer minor units - `buildLoanSchedule` (function) · `import { buildLoanSchedule } from "@jgengine/core/gameplay"` ## loans — draw, schedule, service and default a loan with interest, posted to a ledger - `createLoanBook` (function) · `import { createLoanBook } from "@jgengine/core/gameplay"` ## local-save — persist a game to on-device localStorage (offline) - `localSaveBackend` (function) · `import { localSaveBackend } from "@jgengine/core/gameplay"` ## loot-beams — rarity-colored loot beams and labels on dropped items via defineGame({ worldItem: { rarityStyle, beamHeight } }) - `RarityStyle` (interface) · `import { RarityStyle } from "@jgengine/core/gameplay"` ## loot-comparison — compare two rolled items with per-stat deltas and a weighted score - `compareLootItems` (function) · `import { compareLootItems } from "@jgengine/core/gameplay"` ## loot-filter — filter and highlight drops by rarity/name rules - `evaluateLootFilter` (function) · `import { evaluateLootFilter } from "@jgengine/core/gameplay"` ## loot-generation — roll a named item from bases, parts, affixes, rarity weights, manufacturer personalities and level scaling - `rollLoot` (function) · `import { rollLoot } from "@jgengine/core/gameplay"` ## loot-pipeline — compose ordered loot pools with fallbacks, roll modifiers, and provenance - `createLootPipeline` (function) · `import { createLootPipeline } from "@jgengine/core/gameplay"` - `defineLootPipeline` (function) · `import { defineLootPipeline } from "@jgengine/core/gameplay"` ## loot-roller — roll items from one validated catalog while counting drops per rarity for a debug probe - `createLootRoller` (function) · `import { createLootRoller } from "@jgengine/core/gameplay"` ## loot-score — split one stat block into per-stat weighted contributions - `lootStatContributions` (function) · `import { lootStatContributions } from "@jgengine/core/gameplay"` - `scoreLootStats` (function) · `import { scoreLootStats } from "@jgengine/core/gameplay"` ## loot-table — register loot tables and roll weighted randomized drops - `createLootRegistry` (function) · `import { createLootRegistry } from "@jgengine/core/gameplay"` - `lootTable` (function) · `import { lootTable } from "@jgengine/core/gameplay"` ## loot-validation — check a rolled item against its catalog and report each defect with its code - `validateLootItem` (function) · `import { validateLootItem } from "@jgengine/core/gameplay"` ## loot-weapon — feed a rolled item into a weapon definition so generated gear fires through the weapon system - `lootWeaponDefinition` (function) · `import { lootWeaponDefinition } from "@jgengine/core/gameplay"` ## maturation-stage — resolve the baby/juvenile/adolescent/adult stage from elapsed maturation - `maturationStage` (function) · `import { maturationStage } from "@jgengine/core/game/breeding"` ## merge-credits — fold generated and hand-authored credit documents into one, deduped by entry - `mergeCredits` (function) · `import { mergeCredits } from "@jgengine/core/game/credits"` ## mission-compositions — build escort, chase and defend missions from the shared objective kinds - `chaseMission` (function) · `import { chaseMission } from "@jgengine/core/gameplay"` - `defendMission` (function) · `import { defendMission } from "@jgengine/core/gameplay"` - `escortMission` (function) · `import { escortMission } from "@jgengine/core/gameplay"` ## mission-events — count constrained kills and fail a mission on a matching world event - `MissionWorldEvent` (interface) · `import { MissionWorldEvent } from "@jgengine/core/gameplay"` ## mission-rewards — pay mission rewards through the quest appliers and the loot registry - `applyMissionRewards` (function) · `import { applyMissionRewards } from "@jgengine/core/gameplay"` ## mission-runtime — missions as a data-driven objective state machine with fail states, timers, branches and rewards - `createMissionRuntime` (function) · `import { createMissionRuntime } from "@jgengine/core/gameplay"` ## mission-triggers — start, advance and fail a mission from authored scene markers - `MISSION_TRIGGER_ACTIONS` (const) · `import { MISSION_TRIGGER_ACTIONS } from "@jgengine/core/gameplay"` - `createMissionTriggerBridge` (function) · `import { createMissionTriggerBridge } from "@jgengine/core/gameplay"` - `missionMarkers` (function) · `import { missionMarkers } from "@jgengine/core/gameplay"` - `registerMissionTriggerActions` (function) · `import { registerMissionTriggerActions } from "@jgengine/core/gameplay"` ## mission-validation — tell whether an objective kind completes from a counter alone - `isCounterObjective` (function) · `import { isCounterObjective } from "@jgengine/core/gameplay"` - `validateMissionCatalog` (function) · `import { validateMissionCatalog } from "@jgengine/core/gameplay"` ## modular-item — attach parts into item mount slots to compute combined stats - `slotAccepts` (function) · `import { slotAccepts } from "@jgengine/core/gameplay"` ## mood — a mood derived from how satisfied an agent's needs are - `createMoodReader` (function) · `import { createMoodReader } from "@jgengine/core/agents/mood"` - `moodTierOf` (function) · `import { moodTierOf } from "@jgengine/core/agents/mood"` - `readMood` (function) · `import { readMood } from "@jgengine/core/agents/mood"` ## move — a keyed value toward a target by a bounded step - `towardValue` (function) · `import { towardValue } from "@jgengine/core/gameplay"` ## name-generator — generate procedural names from templates and word banks - `createNameGenerator` (function) · `import { createNameGenerator } from "@jgengine/core/gameplay"` ## narrative-batch-validation — locate stale canon, oversized batches, explicit character/fact/chronology contradictions and dialogue graph issues for bounded repair - `validateNarrativeBatch` (function) · `import { validateNarrativeBatch } from "@jgengine/core/game/narrativeAuthoring"` ## narrative-canon — freeze caller-reviewed character ids, facts and chronology for a narrative authoring revision - `freezeNarrativeCanon` (function) · `import { freezeNarrativeCanon } from "@jgengine/core/game/narrativeAuthoring"` ## near-agents — nav crowd plus per-agent needs and utility brains for on-screen residents - `createNearAgents` (function) · `import { createNearAgents } from "@jgengine/core/gameplay"` ## needs — decaying needs an agent reads by index to decide what it wants next - `createNeedSet` (function) · `import { createNeedSet } from "@jgengine/core/gameplay"` ## notice-feed — serializable tone-tagged notice/event feed bounded by count and age (toasts, life events, killfeed) - `appendFeed` (function) · `import { appendFeed } from "@jgengine/core/gameplay"` - `createNoticeFeed` (function) · `import { createNoticeFeed } from "@jgengine/core/game/notices"` - `pruneFeed` (function) · `import { pruneFeed } from "@jgengine/core/gameplay"` ## notification-center — persistent, read-tracked notification log (newest-first, capped, serializable) behind an unread badge — the durable counterpart to transient toasts - `createNotificationCenter` (function) · `import { createNotificationCenter } from "@jgengine/core/gameplay"` ## objectives — check progress of a threshold objective against a live metric - `evaluateObjective` (function) · `import { evaluateObjective } from "@jgengine/core/gameplay"` ## offscreen-world — schedules agents near the player as real state and far ones as cheap state - `createOffScreenWorld` (function) · `import { createOffScreenWorld } from "@jgengine/core/gameplay"` ## param-layers — register parameter layers by stable id and resolve serialized selections - `createLayerRegistry` (function) · `import { createLayerRegistry } from "@jgengine/core/gameplay"` - `diffParams` (function) · `import { diffParams } from "@jgengine/core/gameplay"` - `orderLayers` (function) · `import { orderLayers } from "@jgengine/core/gameplay"` - `resolveParams` (function) · `import { resolveParams } from "@jgengine/core/gameplay"` - `resolveSelection` (function) · `import { resolveSelection } from "@jgengine/core/gameplay"` - `validateLayers` (function) · `import { validateLayers } from "@jgengine/core/gameplay"` ## part-motion — sample the root bob/sway/squash/flinch/death pose for a rig-less part-composed character - `sampleBodyPose` (function) · `import { sampleBodyPose } from "@jgengine/core/game/partAnimation"` - `samplePartPose` (function) · `import { samplePartPose } from "@jgengine/core/game/partAnimation"` ## pause-scheduled-rule — stop a scheduled rule from firing while retaining its cursor - `pauseRule` (function) · `import { pauseRule } from "@jgengine/core/gameplay"` ## pause-work — pause a queued or active job in place, retaining its progress - `pauseJob` (function) · `import { pauseJob } from "@jgengine/core/gameplay"` ## ping-wheel — contextual ping/marker communication between teammates - `createPingSystem` (function) · `import { createPingSystem } from "@jgengine/core/gameplay"` ## pointer-commands — click an entity or the ground to run a command (click-to-target, click-to-move, grab loot, marquee select) - `PointerConfig` (interface) · `import { PointerConfig } from "@jgengine/core/gameplay"` ## policy-annotate — tag a scheduled transaction's provenance without changing its value - `annotate` (function) · `import { annotate } from "@jgengine/core/gameplay"` ## policy-cap — cap a scheduled transaction amount by context - `capAmount` (function) · `import { capAmount } from "@jgengine/core/gameplay"` ## policy-curve — scale a transaction by a curve over context - `curveScale` (function) · `import { curveScale } from "@jgengine/core/gameplay"` ## policy-redirect — redirect a scheduled transaction's source or recipient - `redirect` (function) · `import { redirect } from "@jgengine/core/gameplay"` ## policy-reject — reject scheduled transactions by predicate - `rejectWhen` (function) · `import { rejectWhen } from "@jgengine/core/gameplay"` ## policy-tax — split off a fraction of a transaction as tax or transfer - `taxFraction` (function) · `import { taxFraction } from "@jgengine/core/gameplay"` ## policy-threshold — scale a transaction by a context threshold band - `thresholdScale` (function) · `import { thresholdScale } from "@jgengine/core/gameplay"` ## price-history — rolling per-item sale records aggregated into market price stats - `createPriceHistory` (function) · `import { createPriceHistory } from "@jgengine/core/gameplay"` ## production-building — a factory building converting inputs to outputs over time - `createProductionState` (function) · `import { createProductionState } from "@jgengine/core/gameplay"` ## progression-curve — evaluate a level/rank curve (const, linear, power, geometric, steps, piecewise) at a point - `evalCurve` (function) · `import { evalCurve } from "@jgengine/core/gameplay"` ## quest-catalog-validation — diagnose authored quest ids, prerequisite and reward references, quantities, and blocked dependencies with caller-declared external unlocks - `validateQuestCatalog` (function) · `import { validateQuestCatalog } from "@jgengine/core/game/questCatalog"` ## quest-log — track accepted quests and their per-objective progress - `createQuestJournal` (function) · `import { createQuestJournal } from "@jgengine/core/gameplay"` ## quest-tracker-view — join a QuestDef + live QuestInstance into a flat labelled view for a quest/objective HUD tracker - `describeTrackedQuest` (function) · `import { describeTrackedQuest } from "@jgengine/core/gameplay"` ## race-placements — look up one racer's place + win/lose within a finish order - `placementOf` (function) · `import { placementOf } from "@jgengine/core/gameplay"` - `racePlacements` (function) · `import { racePlacements } from "@jgengine/core/gameplay"` ## race-session — pure idle→countdown→racing→finished clock every racer wraps around its state - `idleRaceSession` (function) · `import { idleRaceSession } from "@jgengine/core/gameplay"` ## race-track — a checkpoint race with laps, standings, splits, and win conditions - `createRaceState` (function) · `import { createRaceState } from "@jgengine/core/gameplay"` ## recipe-catalog-validation — locate broken crafting item/station/unlock references, duplicate inputs and invalid authored quantities with repair guidance - `validateRecipeCatalog` (function) · `import { validateRecipeCatalog } from "@jgengine/core/crafting/recipeCatalog"` ## refusal-feedback — surface a refused command's player-facing message in the notice feed automatically - `attachRefusalNotices` (function) · `import { attachRefusalNotices } from "@jgengine/core/game/notices"` ## relationships — familiarity and opinion between agents, with a bond that changes behaviour - `createRelationshipBook` (function) · `import { createRelationshipBook } from "@jgengine/core/agents/relationships"` ## resolve — the current tier/band label for a keyed or scalar value - `tierAt` (function) · `import { tierAt } from "@jgengine/core/gameplay"` ## resolve-rng — resolve an optional injected RNG, warning once per site when it falls back to `Math.random` - `resolveRng` (function) · `import { resolveRng } from "@jgengine/core/random/resolveRng"` ## resource-ledger — schedule recurring resource transactions with policy transforms - `createResourceLedger` (function) · `import { createResourceLedger } from "@jgengine/core/gameplay"` ## resume-scheduled-rule — resume a paused scheduled rule, deferring missed cycles to its catch-up policy - `resumeRule` (function) · `import { resumeRule } from "@jgengine/core/gameplay"` ## resume-work — resume a paused job back into the queue's slot competition - `resumeJob` (function) · `import { resumeJob } from "@jgengine/core/gameplay"` ## retained-vfx — create/update/stop long-lived dynamic visual effects (beam, tether, zone, target line) by stable id - `createVfxInstanceStore` (function) · `import { createVfxInstanceStore } from "@jgengine/core/gameplay"` ## ride-appeal — how much one guest likes one ride, from its ratings and their taste - `rideAppeal` (function) · `import { rideAppeal } from "@jgengine/core/gameplay"` ## ride-choice — guests pick rides by taste and queue tolerance through the utility brain - `createRideChooser` (function) · `import { createRideChooser } from "@jgengine/core/gameplay"` - `rideChoiceCandidates` (function) · `import { rideChoiceCandidates } from "@jgengine/core/gameplay"` - `rideChoiceOptions` (function) · `import { rideChoiceOptions } from "@jgengine/core/gameplay"` - `rideQueueCostWeight` (function) · `import { rideQueueCostWeight } from "@jgengine/core/gameplay"` ## ride-sim — rides with capacity, cycles, queues, ratings, breakdowns and maintenance - `createRideSystem` (function) · `import { createRideSystem } from "@jgengine/core/gameplay"` ## routine-timeline — authored daily routines (home, work, meal) resolved against the world clock - `resolveRoutine` (function) · `import { resolveRoutine } from "@jgengine/core/gameplay"` ## rule-selection — register rules and bridge a selection to its contributed parameter layers - `createRuleRegistry` (function) · `import { createRuleRegistry } from "@jgengine/core/gameplay"` - `rerollRules` (function) · `import { rerollRules } from "@jgengine/core/gameplay"` - `selectRules` (function) · `import { selectRules } from "@jgengine/core/gameplay"` ## run-modifiers — a roguelike run built from stacking drafted modifier picks - `createRunDraft` (function) · `import { createRunDraft } from "@jgengine/core/gameplay"` ## save-slot-index — refresh a save-select index from the game's save documents - `refreshSaveSlots` (function) · `import { refreshSaveSlots } from "@jgengine/core/game/saveSlotIndex"` ## save-slot-meta — project a save document onto save-select display metadata - `saveSlotMeta` (function) · `import { saveSlotMeta } from "@jgengine/core/game/saveSlotIndex"` ## save-slots — serializable save-slot / profile metadata index — write/clear/rename/mostRecent over free-string per-slot meta, powering New/Continue/Load/Delete menus, with snapshot/restore - `createSaveSlots` (function) · `import { createSaveSlots } from "@jgengine/core/gameplay"` ## scoreboard — pure tie-aware ranking selector over the leaderboard model — standard/dense ranks, local-entry highlight, top-N, medal tokens for a reskinnable table - `rankLeaderboard` (function) · `import { rankLeaderboard } from "@jgengine/core/gameplay"` ## seeded-random — injected deterministic randomness for game logic — never `Math.random` in a simulation - `seededRng` (function) · `import { seededRng } from "@jgengine/core/gameplay"` ## set — a bounded keyed value in a caller-owned serializable record - `setValue` (function) · `import { setValue } from "@jgengine/core/gameplay"` ## shaped-grid — a serializable inventory board with arbitrary cell footprints, rotation, overlap checks, and immutable placement - `canPlace` (function) · `import { canPlace } from "@jgengine/core/inventory/shapedGrid"` - `createShapedGrid` (function) · `import { createShapedGrid } from "@jgengine/core/inventory/shapedGrid"` - `moveShaped` (function) · `import { moveShaped } from "@jgengine/core/inventory/shapedGrid"` - `placeShaped` (function) · `import { placeShaped } from "@jgengine/core/inventory/shapedGrid"` - `removeShaped` (function) · `import { removeShaped } from "@jgengine/core/inventory/shapedGrid"` ## shaped-placement — find a shaped inventory item's first fit with ordered rotations, row-major placement, and an explicit search budget - `findShapedPlacement` (function) · `import { findShapedPlacement } from "@jgengine/core/inventory/shapedGrid"` - `fitShapedItem` (function) · `import { fitShapedItem } from "@jgengine/core/inventory/shapedGrid"` ## shop-grid — serializable vendor/shop stock with buy/sell over a caller-owned wallet — finite/unlimited qty, sell-back, restock/setPrice, snapshot/restore - `createShopStock` (function) · `import { createShopStock } from "@jgengine/core/gameplay"` ## skill-tree — spend, refuse and refund points over an authored tree with passives, actives and synergies - `createSkillTree` (function) · `import { createSkillTree } from "@jgengine/core/gameplay"` ## social-emotes — emotes and social interactions between nearby players - `createSocial` (function) · `import { createSocial } from "@jgengine/core/gameplay"` ## spawn-points — register spawn locations and pick where entities respawn - `createSpawnPoints` (function) · `import { createSpawnPoints } from "@jgengine/core/gameplay"` ## split-screen — Split the screen into one viewport per local seat, each with its own follow camera. - `splitViewports` (function) · `import { splitViewports } from "@jgengine/core/game/viewports"` ## staffed-station-rate — turn bounded caller-owned worker stats and efficiency into a production rate - `stationOutputRate` (function) · `import { stationOutputRate } from "@jgengine/core/gameplay"` ## standing — per-track standing moved by authored outcomes, with tiers and one snapshot - `createStanding` (function) · `import { createStanding } from "@jgengine/core/progression/standing"` ## stat-graph — derive game-defined stats from named inputs with provenance and preview - `createStatGraph` (function) · `import { createStatGraph } from "@jgengine/core/gameplay"` ## stat-graph-bridge — feed an existing StatModifierSet into a stat-graph source - `statModifierContributions` (function) · `import { statModifierContributions } from "@jgengine/core/gameplay"` ## supply-demand-pricing — price goods from finite stock and live demand on a stated curve - `createMarket` (function) · `import { createMarket } from "@jgengine/core/gameplay"` ## system-schedule — compile fixed/frame/interval system ticks into deterministic ordered stages - `compileSystemSchedule` (function) · `import { compileSystemSchedule } from "@jgengine/core/gameplay"` ## talent-tree-view — flatten a talent tree into a placed, per-node render view — branch/tier layout, learned/available/locked/maxed state, prerequisite edges - `talentTreeView` (function) · `import { talentTreeView } from "@jgengine/core/gameplay"` ## talent-tree-view-from — build a placed talent/upgrade-tree render view from any per-node unlock rule (points, currency, level, flag) — branch/tier layout, learned/available/locked/maxed state, prerequisite edges - `talentTreeViewFrom` (function) · `import { talentTreeViewFrom } from "@jgengine/core/gameplay"` ## tick-work — advance jobs over time, completing work and emitting typed lifecycle events - `tick` (function) · `import { tick } from "@jgengine/core/gameplay"` ## time-scaled-loot — shape loot odds by elapsed hours with caller-authored curves and pipeline provenance - `timeScaledRarity` (function) · `import { timeScaledRarity } from "@jgengine/core/gameplay"` ## toast-feed — queue of transient self-expiring on-screen messages (toasts, announcer, kill-feed) - `appendToast` (function) · `import { appendToast } from "@jgengine/core/gameplay"` - `createToastQueue` (function) · `import { createToastQueue } from "@jgengine/core/gameplay"` ## touch-controls — switch the on-screen touch control set when gameplay context changes (enter/exit vehicle, mount, build mode) - `setTouchControlsMode` (function) · `import { setTouchControlsMode } from "@jgengine/core/gameplay"` - `touchButtonShape` (function) · `import { touchButtonShape } from "@jgengine/core/gameplay"` ## transaction-ledger — record every money movement with its reason over per-account integer minor-unit balances - `createTransactionLedger` (function) · `import { createTransactionLedger } from "@jgengine/core/gameplay"` ## tribe-group — shared-ownership group (tribe/guild/clan) with ranked permissions, group vs personal assets, alliances, and a bounded event log - `createTribe` (function) · `import { createTribe } from "@jgengine/core/game/tribe"` ## tribe-registry — registry of tribes with mutual alliances and cross-tribe relation lookup - `createTribeRegistry` (function) · `import { createTribeRegistry } from "@jgengine/core/game/tribe"` ## triggered-rules — event-conditioned effects with declarative predicates, lifetimes, and stacking - `createTriggeredRuleEngine` (function) · `import { createTriggeredRuleEngine } from "@jgengine/core/gameplay"` - `getRuleEffect` (function) · `import { getRuleEffect } from "@jgengine/core/gameplay"` - `listRuleEffects` (function) · `import { listRuleEffects } from "@jgengine/core/gameplay"` - `registerRuleEffect` (function) · `import { registerRuleEffect } from "@jgengine/core/gameplay"` ## typed-keyed-store — a cast-free typed handle onto a per-owner keyed family of reactive game-store slots, replayable and host-authoritative - `defineKeyedStore` (function) · `import { defineKeyedStore } from "@jgengine/core/store/defineKeyedStore"` ## typed-store — a cast-free typed handle onto one reactive game-store slot, replayable and host-authoritative - `defineStore` (function) · `import { defineStore } from "@jgengine/core/store/defineStore"` ## unit-training — compose a timed work queue that trains catalog units into spawn orders - `unitTrainingConfig` (function) · `import { unitTrainingConfig } from "@jgengine/core/gameplay"` ## unlock-gates — milestones gated by standing or money, validated against the content they grant - `createGateSet` (function) · `import { createGateSet } from "@jgengine/core/progression/gates"` ## unlock-points — spendable point pool earned per level and spent to unlock nodes, with refund and respec - `createUnlockPoints` (function) · `import { createUnlockPoints } from "@jgengine/core/economy/unlockPoints"` ## unlockables — gate content behind unlock conditions the player earns - `createUnlockCatalog` (function) · `import { createUnlockCatalog } from "@jgengine/core/gameplay"` ## upgrade-tree — ranked upgrades priced by a cost curve, gated by prerequisites and standing - `createUpgradeTree` (function) · `import { createUpgradeTree } from "@jgengine/core/progression/upgrades"` ## visitor-population — a crowd whose on-site and daily counts are the bodies the game made - `createVisitorPopulation` (function) · `import { createVisitorPopulation } from "@jgengine/core/gameplay"` ## wait-queue — a real line whose wait estimate comes from its own measured throughput - `createWaitQueue` (function) · `import { createWaitQueue } from "@jgengine/core/gameplay"` ## wallet — hold currency balances with charge and affordability checks - `createEmptyWallet` (function) · `import { createEmptyWallet } from "@jgengine/core/gameplay"` ## weapon-stats — resolve per-weapon stat values for combat math - `createWeaponStats` (function) · `import { createWeaponStats } from "@jgengine/core/gameplay"` ## weighted-pick — pick one item from a set with an injected random source - `pickUniform` (function) · `import { pickUniform } from "@jgengine/core/gameplay"` ## work-active-jobs — list jobs currently progressing in a work queue - `activeJobs` (function) · `import { activeJobs } from "@jgengine/core/gameplay"` ## work-job-by-id — look up a queued job by id - `jobById` (function) · `import { jobById } from "@jgengine/core/gameplay"` ## work-job-progress — compute a job's fractional progress - `jobProgress` (function) · `import { jobProgress } from "@jgengine/core/gameplay"` ## work-order-fifo — order queued jobs by enqueue sequence - `fifoOrdering` (function) · `import { fifoOrdering } from "@jgengine/core/gameplay"` ## work-order-priority — order queued jobs by priority, then FIFO within equal priority - `priorityOrdering` (function) · `import { priorityOrdering } from "@jgengine/core/gameplay"` ## work-queue — a serializable timed job queue with reservation, cancellation, completion, and output routing - `createWorkQueue` (function) · `import { createWorkQueue } from "@jgengine/core/gameplay"` ## work-queue-size — count non-terminal jobs in a work queue - `queueSize` (function) · `import { queueSize } from "@jgengine/core/gameplay"` ## work-queued-jobs — list jobs waiting for a slot, in selection order - `queuedJobs` (function) · `import { queuedJobs } from "@jgengine/core/gameplay"` ## xp-curve — resolve an authored xp growth rule into per-level thresholds, totals and a level cap - `defineXpCurve` (function) · `import { defineXpCurve } from "@jgengine/core/gameplay"`