tribunal-kit 3.0.0 → 4.0.0

package/.agent/skills/game-design-expert/SKILL.md

@@ -1,105 +1,79 @@
----
-name: game-design-expert
-description: Game Design, UX, and Flow State mastery. Replaces fragmented legacy skills. Core gameplay loop design, 3Cs (Character, Camera, Controls), input buffering, coyote time, juice (game feel), telemetry tracking, narrative alignment, and audio spatialization integration. Use when crafting player experience, progression arcs, or systemic balance.
-allowed-tools: Read, Write, Edit, Glob, Grep
-version: 2.0.0
-last-updated: 2026-04-02
-applies-to-model: gemini-2.5-pro, claude-3-7-sonnet
----
-
-# Game Design Expert — Player Experience & Flow Mastery
-
-> A game is not a list of features. It is a psychological loop.
-> Perfect code evaluating a boring gameplay loop is a failed product.
-
----
-
-## 1. The 3Cs (Character, Camera, Controls)
-
-Before designing enemies, levels, or UI, the foundation of the player's interaction MUST feel flawless. If the player cannot intrinsically trust the controls, the entire system collapses.
-
-### Input Buffering
-Humans cannot click buttons flawlessly on the exact required frame.
-If a player presses "Jump" 3 frames *before* they hit the ground, a naïve engine ignores it. A designed engine *buffers* the input in memory for 150ms and instantly executes the jump the millisecond the character's feet touch the dirt.
-
-### Coyote Time
-Named after Wile E. Coyote hovering off a cliff.
-If a player runs off a ledge, a rigid physics engine drops them instantly.
-A forgiving design allows the player to still press 'Jump' for exactly ~100ms *after* walking off the ledge. It prevents extreme frustration on close platforming jumps.
-
----
-
-## 2. The Core Gameplay Loop
-
-Every action a player takes must feed into a reinforcing psychological loop. 
-
-**The Macro Loop (e.g., Destiny, Monster Hunter)**
-1. **Action:** Fight complex monsters.
-2. **Reward:** Collect physical parts and resources.
-3. **Pacing:** Return to base.
-4. **Upgrade:** Convert parts into stronger weapons.
-5. **Goal:** Fight stronger, unkillable monsters (Back to Step 1).
-
-*If step 4 (Upgrading) does not heavily alter step 1 (Fights are now faster, visually different, mechanically superior), the loop is broken and players churn.*
-
----
-
-## 3. "Juice" and Game Feel 
-
-"Juice" is the non-functional audiovisual feedback that makes an interaction feel heavy and satisfying.
-
-1. **Screen Shake:** A minor, mathematically decaying camera displacement when heavy impacts occur. (Needs toggles for accessibility).
-2. **Hitstop (Sleep Frames):** When a sword hits an enemy, freeze the entire game engine for exactly 3 frames (50ms). This creates an immense perceptual illusion of resistance and friction.
-3. **Squash and Stretch:** A character jumping should stretch vertically. A character landing should squash horizontally. It breaks rigidity and infuses life.
-4. **Particle Explosions:** Simple box collisions must be masked by explosive localized particle systems (dust kicks, sparks).
-
----
-
-## 4. Narrative & Audio Synergies
-
-Game design is not segregated from Audio. Audio is the primary vector for temporal feedback.
-
-1. **Spatialization (HRTF):** Sound objects emit audio localized strictly to 3D space, heavily attenuated by environmental occlusions (muffled behind walls).
-2. **Telegraphing State:** If an enemy swings a heavy axe, it MUST have a 300ms audio "wind-up" queue. The player relies on audio rhythm far faster than visual recognition to dodge.
-3. **Dynamic Mixing (Ducking):** Essential dialogue or UI pings must automatically compress (lower the volume of) ambient music underneath to prevent cognitive overload.
-
----
-
-## 5. Telemetry & Analytics Deficiencies
-
-Design is hypotheses. Playtests are the reality.
-
-Never rely on developers "feeling" the game. You must systematically log death coordinates (heatmaps). If 80% of players die at Level 2 Trap B, your design intent (teaching the mechanic) has failed. 
-
----
-
-## 🤖 LLM-Specific Traps (Game Design)
-
-1. **Ignoring Input Buffers:** The AI writes raw `if (Input.GetKeyDown() && isGrounded)` logic. This creates notoriously stiff, frustrating, and unresponsive controls.
-2. **Feature Soup:** A user asks for game ideas, and the AI suggests a survival crafting multiplayer battle-royale with RPG skill trees. This is un-shippable scope creep. Force brutal constraint down to one core mechanic.
-3. **Rigid Math Realism:** Dictating jump metrics strictly conforming to 9.8m/s² real-world gravity. Mario falls 3x faster than he jumps. Realism destroys game feel.
-4. **Punishing Precision:** Missing Coyote Time implementations entirely, punishing the player for 10-millisecond execution errors rather than rewarding the intent.
-5. **No Telegraphing:** AI designs boss attack patterns that instantly execute damage vectors simultaneously with the animation frame, making the attack literally impossible for a human reaction-time algorithm (200ms) to evade.
-6. **The Linear Number Grind:** Proposing "Upgrades" that solely increment numbers (`+5% damage`) instead of altering the fundamental mechanical verbs (`Sword now shoots fireballs horizontally`). Number grinds fail retention tests.
-7. **Dead UI Feedback:** Proposing UI UIs that simply flip variables to green, entirely omitting the requirement for scaling twin-interpolated bouncy animations that provide satisfying interaction juice.
-8. **Constant Intensity Tiring:** Failing to design Pacing. Recommending non-stop constant action loops without enforcing quiet, ambient "Return to Base" reset periods. The human brain numbs to constant intensity within 20 minutes.
-9. **Sound Sourcing Fallacies:** Treating Audio as a global 2D `Play()` function instead of enforcing 3D positional transforms anchored to the exact entity creating the disruption.
-10. **The Wall of Text:** AI proposes delivering lore via explicit text-box dumps at the start of a level, rather than environmental design (blood stains leading to a locked door). Show, do not dump text.
-
----
-
-## 🏛️ Tribunal Integration
-
-### ✅ Pre-Flight Self-Audit
-```
-✅ Are critical player actions protected significantly via Input Buffering and Coyote Time tolerances?
-✅ Does the 'Juice' architecture implement Hitstop, Screen Shake, and impact framing safely?
-✅ Are enemy damage sequences heavily telegraphed visually and auditorily BEFORE execution?
-✅ Is the gameplay loop tightly bound (Action -> Reward -> Meaningful Upgrade -> Action)?
-✅ Has scope creep been aggressively slashed to favor extreme polishing of the single Core Loop?
-✅ Is gravity manipulated artificially (custom fast-fall modifiers) to improve character weight mechanics?
-✅ Have rewards been mapped to change mechanical player verbs, rather than simple stat additions?
-✅ Does the pacing explicitly enforce quiet, non-lethal downtime intervals?
-✅ Is audio spatialized explicitly to the 3D entity geometry rather than firing globally?
-✅ Are narrative/tutorial deliveries handled environmentally or organically instead of monolithic text walls?
-```
+---
+name: game-design-expert
+description: Game Design, UX, and Flow State mastery. Replaces fragmented legacy skills. Core gameplay loop design, 3Cs (Character, Camera, Controls), input buffering, coyote time, juice (game feel), telemetry tracking, narrative alignment, and audio spatialization integration. Use when crafting player experience, progression arcs, or systemic balance.
+allowed-tools: Read, Write, Edit, Glob, Grep
+version: 2.0.0
+last-updated: 2026-04-02
+applies-to-model: gemini-2.5-pro, claude-3-7-sonnet
+---
+
+## Hallucination Traps (Read First)
+- ❌ Designing reward systems without testing for compulsion loops -> ✅ Playtesting must verify engagement without addiction patterns
+- ❌ Assuming all players have the same skill level -> ✅ Design difficulty curves that adapt or offer accessibility options
+- ❌ Adding mechanics without testing the core loop first -> ✅ Core loop must be fun in isolation before adding complexity
+
+---
+
+
+# Game Design Expert — Player Experience & Flow Mastery
+
+---
+
+## 1. The 3Cs (Character, Camera, Controls)
+
+Before designing enemies, levels, or UI, the foundation of the player's interaction MUST feel flawless. If the player cannot intrinsically trust the controls, the entire system collapses.
+
+### Input Buffering
+Humans cannot click buttons flawlessly on the exact required frame.
+If a player presses "Jump" 3 frames *before* they hit the ground, a naïve engine ignores it. A designed engine *buffers* the input in memory for 150ms and instantly executes the jump the millisecond the character's feet touch the dirt.
+
+### Coyote Time
+Named after Wile E. Coyote hovering off a cliff.
+If a player runs off a ledge, a rigid physics engine drops them instantly.
+A forgiving design allows the player to still press 'Jump' for exactly ~100ms *after* walking off the ledge. It prevents extreme frustration on close platforming jumps.
+
+---
+
+## 2. The Core Gameplay Loop
+
+Every action a player takes must feed into a reinforcing psychological loop. 
+
+**The Macro Loop (e.g., Destiny, Monster Hunter)**
+1. **Action:** Fight complex monsters.
+2. **Reward:** Collect physical parts and resources.
+3. **Pacing:** Return to base.
+4. **Upgrade:** Convert parts into stronger weapons.
+5. **Goal:** Fight stronger, unkillable monsters (Back to Step 1).
+
+*If step 4 (Upgrading) does not heavily alter step 1 (Fights are now faster, visually different, mechanically superior), the loop is broken and players churn.*
+
+---
+
+## 3. "Juice" and Game Feel 
+
+"Juice" is the non-functional audiovisual feedback that makes an interaction feel heavy and satisfying.
+
+1. **Screen Shake:** A minor, mathematically decaying camera displacement when heavy impacts occur. (Needs toggles for accessibility).
+2. **Hitstop (Sleep Frames):** When a sword hits an enemy, freeze the entire game engine for exactly 3 frames (50ms). This creates an immense perceptual illusion of resistance and friction.
+3. **Squash and Stretch:** A character jumping should stretch vertically. A character landing should squash horizontally. It breaks rigidity and infuses life.
+4. **Particle Explosions:** Simple box collisions must be masked by explosive localized particle systems (dust kicks, sparks).
+
+---
+
+## 4. Narrative & Audio Synergies
+
+Game design is not segregated from Audio. Audio is the primary vector for temporal feedback.
+
+1. **Spatialization (HRTF):** Sound objects emit audio localized strictly to 3D space, heavily attenuated by environmental occlusions (muffled behind walls).
+2. **Telegraphing State:** If an enemy swings a heavy axe, it MUST have a 300ms audio "wind-up" queue. The player relies on audio rhythm far faster than visual recognition to dodge.
+3. **Dynamic Mixing (Ducking):** Essential dialogue or UI pings must automatically compress (lower the volume of) ambient music underneath to prevent cognitive overload.
+
+---
+
+## 5. Telemetry & Analytics Deficiencies
+
+Design is hypotheses. Playtests are the reality.
+
+Never rely on developers "feeling" the game. You must systematically log death coordinates (heatmaps). If 80% of players die at Level 2 Trap B, your design intent (teaching the mechanic) has failed. 
+
+---

package/.agent/skills/game-engineering-expert/SKILL.md

@@ -1,122 +1,96 @@
----
-name: game-engineering-expert
-description: Game Engineering and Systems Architecture mastery. Replaces fragmented legacy skills. Entity Component Systems (ECS), Unity (C#) / Godot (GDScript) integration, physics calculations, deterministic engine state, WebGL memory management, multiplayer sync architectures (deterministic lockstep vs traditional authoritative), spatial partitioning, and rendering pipelines.
-allowed-tools: Read, Write, Edit, Glob, Grep
-version: 2.0.0
-last-updated: 2026-04-02
-applies-to-model: gemini-2.5-pro, claude-3-7-sonnet
----
-
-# Game Engineering Expert — Performance & State Mastery
-
-> A web server processes requests asynchronously. A game engine processes reality 60 times a second.
-> Memory allocation inside the update loop is a death sentence for frame rates.
-
----
-
-## 1. Frame Rate Architecture (The Update Loop)
-
-In web development, we await Promises. In game development, we calculate Delta Time continuously.
-
-```csharp
-// ❌ BAD: Frame-rate dependent logic
-// If the game runs at 120 FPS, the character moves twice as fast as on 60 FPS
-void Update() {
-    transform.position += currentSpeed; 
-}
-
-// ✅ GOOD: Frame-independent physics (Unity C# Example)
-void Update() {
-    // DeltaTime is the time elapsed since the last frame
-    transform.position += currentVelocity * Time.deltaTime; 
-}
-```
-
-### FixedUpdate vs Update (The Physics Boundary)
-- `Update()` fires as fast as the GPU/CPU can draw. Used for User Input and visual animation interpolations.
-- `FixedUpdate()` fires at absolute strict mathematical intervals (e.g., 50 times a second exactly). ALL Physics interactions (`AddForce()`, collision sweeps) MUST live here to prevent tearing and tunneling.
-
----
-
-## 2. Memory Pooling (Garbage Collection Death)
-
-In Node.js, V8 cleans up objects eventually. In Game Engines, allocating memory creates "Garbage", which forces the Garbage Collector (GC) to pause the entire game to clean up, causing massive micro-stutters.
-
-```csharp
-// ❌ FATAL (in Update loops): Creating new objects 60x a second
-void Update() {
-    Instantiate(bulletPrefab, gun.position, gun.rotation); // Kills the CPU
-}
-
-// ✅ EFFICIENT: Object Pooling
-// Pre-allocate 100 bullets during the Loading Screen.
-// Then simply toggle their active state natively.
-void Fire() {
-    Bullet b = bulletPool.GetDisabledBullet();
-    b.transform.position = gun.position;
-    b.gameObject.SetActive(true);
-}
-```
-
----
-
-## 3. Entity Component Systems (ECS)
-
-Traditional Object-Oriented Programming (OOP) inheritance hierarchies break down in game engines.
-(e.g., `Enemy` inherits from `Character` which inherits from `Renderable`). What happens when you want a `Renderable` that isn't a `Character` but acts like an `Enemy` (like a deadly spike trap)?
-
-**Use ECS.**
-1. **Entities:** Just a meaningless ID (e.g., `Entity 304`).
-2. **Components:** Pure localized data structs attached to an ID (e.g., `Position {x: 5, y: 10}`, `Health {hp: 100}`).
-3. **Systems:** Logic that maps continuously over structs (e.g., `MovementSystem` iterates over ALL Entities that specifically have both a `Position` AND `Velocity` component).
-
----
-
-## 4. Multiplayer Architectures
-
-Never trust the client. A multiplayer architecture dictates latency fundamentally.
-
-1. **Deterministic Lockstep (RTS / Fighting Games):**
-   - Transmits absolute ZERO game state (coordinates).
-   - Only transmits *inputs* (Player A clicked Coordinate X).
-   - Both machines run the identical physics frame simultaneously.
-   - Extremely bandwidth efficient, but requires identical CPU math output (impossible in JS floating point Math).
-
-2. **Server Authoritative with Client Prediction (Modern FPS/Action):**
-   - The Server runs the "Real" game.
-   - The Client tells the server "I fired."
-   - Because Ping takes 50ms, the Client *predicts* the shot landing locally (optimistic UI) so the player doesn't feel lag.
-   - If the server eventually disagrees, the Client aggressively rewinds and snaps the state to match the Server reality (Rubber-banding).
-
----
-
-## 🤖 LLM-Specific Traps (Game Engineering)
-
-1. **Await Inside Update:** AI suggests `await Task.Delay()` inside a Unity `Update()` loop instead of yielding inside a proper Coroutine, causing thousands of tasks to stack and crash the engine memory instantaneously.
-2. **Missing DeltaTime:** The AI forgets to multiply positional vectors by `Time.deltaTime` (or Godot's `delta`), making games function optimally on developer PCs but hyper-speed glitch on high refresh rate monitors.
-3. **Direct String Lookups:** Executing `GameObject.Find("Player")` inside an `Update()` loop. This forces a recursive string-matching crawl across the entire scene hierarchy 60 times a second. Architect via localized caching/Singleton pattern on boot.
-4. **Trusting the Client State:** Architecting a multiplayer route as `emit('playerDead', { id: targetId })`. An exploiter can forge this payload and kill anyone. The client must emit `('fireWeapon', { aimVector })` and the server decides if targetId dies.
-5. **Physics Tunneling:** The AI moves objects by altering `.position` directly instead of manipulating `RigidBody` velocities. If moved directly, the physics engine cannot calculate intermediate collision sweeps, causing bullets to phase through thin walls blindly.
-6. **OOP Hierarchy Hell:** The AI generating deep, brittle C++ inheritance trees for enemies instead of favoring flat Component composition.
-7. **Allocating In Rendering Loops:** Instantiating new Vector3 structs (`new Vector3()`) continuously inside tight algorithmic loops instead of utilizing strict global allocations or structural re-assignment.
-8. **WebGL Threading Illusions:** Suggesting complex C# multi-threading (System.Threading.Tasks) for a Unity WebGL web-game build. WebGL fundamentally executes single-threaded; multi-threading must be emulated or bypassed entirely via Job Systems.
-9. **Event Spillage (Memory Leaks):** Subscribing to strict engine C# Action events ( `GameManager.OnDeath += Explode;` ) but entirely failing to unsubscribe in the `OnDestroy()` hierarchy, creating immortal zombie objects in RAM forever.
-10. **The Canvas Rebuild:** Altering a single Text element in a massive UI grouping, causing Unity to expensively re-rasterize and bake the entire UI canvas mesh. Segment UI into static and dynamic distinct canvases.
-
----
-
-## 🏛️ Tribunal Integration
-
-### ✅ Pre-Flight Self-Audit
-```
-✅ Are positional equations multiplied universally by `deltaTime` for frame independence?
-✅ Have physics/collision mutations been explicitly restricted to the `FixedUpdate` engine cycles?
-✅ Are memory pools implemented to completely eliminate runtime garbage collection stutter?
-✅ Does the networking architecture explicitly forbid the client from dictating authoritative game state?
-✅ Have `.Find()` string query loops been eliminated from continuous execution pathways?
-✅ Did I rely on Component composition rather than deep, brittle inheritance trees?
-✅ Are `RigidBody` velocities manipulated instead of raw `.position` to prevent quantum wall tunneling?
-✅ Have all event subscriptions (`+=`) been rigidly paired with localized destruction unsubscribe (`-=`) methods?
-✅ Were multi-threading paradigms avoided/recalculated if targeting web browser execution formats?
-✅ Is the UI strictly architected to prevent global canvas rebuilds across minor localized visual changes?
-```
+---
+name: game-engineering-expert
+description: Game Engineering and Systems Architecture mastery. Replaces fragmented legacy skills. Entity Component Systems (ECS), Unity (C#) / Godot (GDScript) integration, physics calculations, deterministic engine state, WebGL memory management, multiplayer sync architectures (deterministic lockstep vs traditional authoritative), spatial partitioning, and rendering pipelines.
+allowed-tools: Read, Write, Edit, Glob, Grep
+version: 2.0.0
+last-updated: 2026-04-02
+applies-to-model: gemini-2.5-pro, claude-3-7-sonnet
+---
+
+## Hallucination Traps (Read First)
+- ❌ Using deltaTime without clamping -> ✅ Unclamped deltaTime causes physics explosions on frame spikes; clamp to max 0.05s
+- ❌ Allocating memory in the game loop (new objects, arrays) -> ✅ Pre-allocate and pool objects to avoid GC pauses during gameplay
+- ❌ Using floating-point equality checks for game state -> ✅ Use epsilon comparisons or integer-based fixed-point for deterministic logic
+
+---
+
+
+# Game Engineering Expert — Performance & State Mastery
+
+---
+
+## 1. Frame Rate Architecture (The Update Loop)
+
+In web development, we await Promises. In game development, we calculate Delta Time continuously.
+
+```csharp
+// ❌ BAD: Frame-rate dependent logic
+// If the game runs at 120 FPS, the character moves twice as fast as on 60 FPS
+void Update() {
+    transform.position += currentSpeed; 
+}
+
+// ✅ GOOD: Frame-independent physics (Unity C# Example)
+void Update() {
+    // DeltaTime is the time elapsed since the last frame
+    transform.position += currentVelocity * Time.deltaTime; 
+}
+```
+
+### FixedUpdate vs Update (The Physics Boundary)
+- `Update()` fires as fast as the GPU/CPU can draw. Used for User Input and visual animation interpolations.
+- `FixedUpdate()` fires at absolute strict mathematical intervals (e.g., 50 times a second exactly). ALL Physics interactions (`AddForce()`, collision sweeps) MUST live here to prevent tearing and tunneling.
+
+---
+
+## 2. Memory Pooling (Garbage Collection Death)
+
+In Node.js, V8 cleans up objects eventually. In Game Engines, allocating memory creates "Garbage", which forces the Garbage Collector (GC) to pause the entire game to clean up, causing massive micro-stutters.
+
+```csharp
+// ❌ FATAL (in Update loops): Creating new objects 60x a second
+void Update() {
+    Instantiate(bulletPrefab, gun.position, gun.rotation); // Kills the CPU
+}
+
+// ✅ EFFICIENT: Object Pooling
+// Pre-allocate 100 bullets during the Loading Screen.
+// Then simply toggle their active state natively.
+void Fire() {
+    Bullet b = bulletPool.GetDisabledBullet();
+    b.transform.position = gun.position;
+    b.gameObject.SetActive(true);
+}
+```
+
+---
+
+## 3. Entity Component Systems (ECS)
+
+Traditional Object-Oriented Programming (OOP) inheritance hierarchies break down in game engines.
+(e.g., `Enemy` inherits from `Character` which inherits from `Renderable`). What happens when you want a `Renderable` that isn't a `Character` but acts like an `Enemy` (like a deadly spike trap)?
+
+**Use ECS.**
+1. **Entities:** Just a meaningless ID (e.g., `Entity 304`).
+2. **Components:** Pure localized data structs attached to an ID (e.g., `Position {x: 5, y: 10}`, `Health {hp: 100}`).
+3. **Systems:** Logic that maps continuously over structs (e.g., `MovementSystem` iterates over ALL Entities that specifically have both a `Position` AND `Velocity` component).
+
+---
+
+## 4. Multiplayer Architectures
+
+Never trust the client. A multiplayer architecture dictates latency fundamentally.
+
+1. **Deterministic Lockstep (RTS / Fighting Games):**
+   - Transmits absolute ZERO game state (coordinates).
+   - Only transmits *inputs* (Player A clicked Coordinate X).
+   - Both machines run the identical physics frame simultaneously.
+   - Extremely bandwidth efficient, but requires identical CPU math output (impossible in JS floating point Math).
+
+2. **Server Authoritative with Client Prediction (Modern FPS/Action):**
+   - The Server runs the "Real" game.
+   - The Client tells the server "I fired."
+   - Because Ping takes 50ms, the Client *predicts* the shot landing locally (optimistic UI) so the player doesn't feel lag.
+   - If the server eventually disagrees, the Client aggressively rewinds and snaps the state to match the Server reality (Rubber-banding).
+
+---