{
  "metadata": {
    "description": "Reasoning Lab task bank — hard architectural problems that force decomposition, planning, and edge-case thinking. Each task exercises the reason() pipeline before code generation.",
    "difficulty_scale": "1-5 (1=straightforward, 3=multi-system, 5=architectural nightmare)"
  },
  "tasks": [
    {
      "id": 1,
      "name": "State Machine Framework",
      "lang": "csharp",
      "difficulty": 2,
      "category": "architecture",
      "prompt": "Design and implement a generic hierarchical state machine framework for Unity. Must support: nested sub-states, transition conditions with guards, OnEnter/OnExit/OnUpdate callbacks, state history for undo, and serializable state definitions via ScriptableObject. Namespace: SevenDTD.Core. No MonoBehaviour dependency in the core FSM — it should be pure C# that a MonoBehaviour wrapper can drive."
    },
    {
      "id": 2,
      "name": "Object Pool with Warmup",
      "lang": "csharp",
      "difficulty": 2,
      "category": "performance",
      "prompt": "Build a generic object pool system for Unity that supports: configurable warm-up count, automatic expansion when exhausted, shrink-back to baseline after cooldown period, per-pool statistics (borrows, returns, expansions, peak usage), thread-safe borrow/return for use with Jobs, and IPoolable interface with OnBorrow/OnReturn callbacks. Namespace: SevenDTD.Core. Must work with any Component type via generics."
    },
    {
      "id": 3,
      "name": "Event Bus with Priorities",
      "lang": "csharp",
      "difficulty": 3,
      "category": "architecture",
      "prompt": "Implement a decoupled event bus system for a Unity MMO. Requirements: generic typed events (publish EventType, subscribe to EventType), priority ordering for listeners, one-shot subscriptions that auto-unsubscribe after first fire, event queuing with configurable flush-per-frame limit to avoid spikes, weak references to prevent memory leaks from destroyed GameObjects, and debug mode that logs all events with subscriber counts. Namespace: SevenDTD.Core. Pure C# singleton — no MonoBehaviour."
    },
    {
      "id": 4,
      "name": "Dynamic Loot Table System",
      "lang": "csharp",
      "difficulty": 3,
      "category": "game_systems",
      "prompt": "Build a loot drop system for an MMO. Must support: rarity tiers (Common/Uncommon/Rare/Epic/Legendary) with configurable weight curves, loot tables defined as ScriptableObjects with nested sub-tables, pity system that increases rare drop chance after N drops without one, level-scaled drops where item stats scale to player level, guaranteed drops vs random drops in the same table, and world-event modifiers that temporarily alter drop rates globally. Namespace: SevenDTD.MMO."
    },
    {
      "id": 5,
      "name": "Skill Tree with Prerequisites",
      "lang": "csharp",
      "difficulty": 4,
      "category": "game_systems",
      "prompt": "Architect a skill tree system for an MMO where: skills form a directed acyclic graph with multiple prerequisite paths, each skill has level tiers (1-5) with scaling effects, skills can have cooldowns and resource costs (mana, stamina, rage — polymorphic), passive skills apply permanent stat modifiers, active skills have cast times and can be interrupted, skill synergies give bonuses when specific combinations are unlocked, and the entire tree is serializable for save/load. Namespace: SevenDTD.MMO. Must handle circular dependency detection at edit-time."
    },
    {
      "id": 6,
      "name": "Chunk-Based World Streaming",
      "lang": "csharp",
      "difficulty": 4,
      "category": "architecture",
      "prompt": "Design a chunk-based world streaming system for a networked MMO in Unity. Requirements: world divided into chunks on a 2D grid, chunks load/unload based on player proximity with configurable view distance, async loading using Addressables or Resources.LoadAsync, chunk state persistence (modified blocks, placed objects) to disk, server-authoritative chunk ownership (only server decides what loads), client receives chunk data via Netcode NetworkVariable or custom messages, LOD system where distant chunks use simplified meshes, and neighbor-stitching to prevent seams at chunk borders. Namespace: SevenDTD.MMO."
    },
    {
      "id": 7,
      "name": "Dynamic Economy System",
      "lang": "csharp",
      "difficulty": 5,
      "category": "game_systems",
      "prompt": "Build a player-driven economy system for an MMO. Must handle: item prices that fluctuate based on supply/demand across all connected players, auction house with bidding and buyout, price history tracking (last 24h, 7d, 30d) for UI graphs, anti-manipulation safeguards (detect price spiking, wash trading), NPC vendors with dynamic restock that responds to player purchasing patterns, crafting cost calculation that factors in material market prices, tax system configurable per transaction type, and currency sinks to prevent inflation. Namespace: SevenDTD.MMO. Server-authoritative — all price calculations on server."
    },
    {
      "id": 8,
      "name": "Ability Combo System",
      "lang": "csharp",
      "difficulty": 3,
      "category": "game_systems",
      "prompt": "Implement a combo system for an action MMO where: abilities can chain into follow-up abilities within a timing window, combo trees are data-driven (ScriptableObject definitions), each node in the combo tree has: animation trigger, damage multiplier, stamina cost, hit timing window for next link, combo finishers deal bonus damage based on chain length, input buffering so the next ability queues during current animation, and network-synchronized so other players see the combo animations. Namespace: SevenDTD.MMO. Must work with Unity.Netcode."
    },
    {
      "id": 9,
      "name": "Pathfinding with Dynamic Obstacles",
      "lang": "csharp",
      "difficulty": 4,
      "category": "ai",
      "prompt": "Build an A* pathfinding system for NPCs in a Unity MMO that handles: grid-based navigation with variable node costs, dynamic obstacle avoidance (obstacles that appear/disappear at runtime), path smoothing to remove jagged corners, hierarchical pathfinding (coarse grid for long distances, fine grid near destination), partial path return when full path is impossible (get as close as possible), multi-agent coordination to prevent NPCs from overlapping, and configurable heuristics (Manhattan, Euclidean, Octile). Namespace: SevenDTD.AI. Must not use Unity's NavMesh — pure custom implementation."
    },
    {
      "id": 10,
      "name": "Quest System with Branching",
      "lang": "csharp",
      "difficulty": 5,
      "category": "game_systems",
      "prompt": "Architect a quest system for an MMO that supports: branching quest lines where player choices affect future quest availability, multiple objective types (kill N, collect N, escort NPC, reach location, interact with object, talk to NPC, craft item), objectives that can be AND or OR combined (complete all vs complete any), timed objectives with fail conditions, quest sharing in a party where progress syncs for shared objectives, reputation rewards that unlock new quest givers, quest log with tracking and waypoint markers, and prerequisite chains (must complete quest A before quest B unlocks). Namespace: SevenDTD.MMO. All quest data defined in ScriptableObjects — zero hardcoded quest logic."
    },
    {
      "id": 11,
      "name": "ECS-Style Component Registry",
      "lang": "csharp",
      "difficulty": 4,
      "category": "architecture",
      "prompt": "Implement a lightweight Entity-Component-System pattern in pure C# for Unity (not using Unity DOTS). Requirements: entities are just integer IDs, components are plain structs stored in contiguous arrays per type, systems iterate over entities that have specific component combinations (archetype queries), support add/remove components at runtime with structural change buffering, observer pattern for component lifecycle (OnAdd, OnRemove), serialize/deserialize entire world state to byte array, and a simple query API like world.Query<Position, Velocity>() that returns matching entity sets. Namespace: SevenDTD.Core."
    },
    {
      "id": 12,
      "name": "Dialogue System with Conditions",
      "lang": "csharp",
      "difficulty": 3,
      "category": "game_systems",
      "prompt": "Build a dialogue system for an MMO where: dialogue trees are ScriptableObject-based with nodes and edges, each dialogue choice can have conditions (check quest state, reputation, inventory items, player level), dialogue can trigger actions (give item, start quest, change reputation, teleport player), support for branching based on player stats or prior choices, localization-ready with string keys instead of hardcoded text, NPC mood/disposition that changes based on player interactions, and a simple runtime API: StartDialogue(npcId), ChooseOption(index), GetCurrentNode(). Namespace: SevenDTD.MMO."
    },
    {
      "id": 13,
      "name": "Replay System",
      "lang": "csharp",
      "difficulty": 5,
      "category": "architecture",
      "prompt": "Design a gameplay replay system for a networked game that: records all player inputs and game state snapshots at configurable intervals, supports playback at variable speed (0.25x to 4x) with pause/seek, uses delta compression — only store what changed between snapshots, handles entity spawn/despawn during replay, can export replay to a binary file and reimport it, supports camera modes during playback (follow player, free cam, overview), and synchronizes replay across multiple spectators via network. Namespace: SevenDTD.Core. Must handle 60+ entities with position/rotation/state."
    },
    {
      "id": 14,
      "name": "Procedural Dungeon Generator",
      "lang": "csharp",
      "difficulty": 4,
      "category": "procedural",
      "prompt": "Build a procedural dungeon generator that: uses BSP (Binary Space Partitioning) to create room layouts, connects rooms with corridors ensuring full connectivity, places doors between rooms and corridors, supports room templates (boss room, treasure room, trap room) with weighted selection, generates spawn points for enemies scaled by room size and distance from entrance, places loot containers with rarity scaling by depth, ensures a valid path from entrance to boss room exists, and outputs a 2D tile grid that a separate renderer can consume. Namespace: SevenDTD.Procedural. Pure C# — no Unity dependencies in the generator."
    },
    {
      "id": 15,
      "name": "Networked Crafting System",
      "lang": "csharp",
      "difficulty": 3,
      "category": "game_systems",
      "prompt": "Implement a crafting system for a networked MMO. Requirements: recipes defined in ScriptableObjects with ingredient lists and quantities, crafting takes real time with a progress bar (not instant), server validates all crafting requests (client can't cheat), crafting stations — different stations unlock different recipe categories, recipe discovery — players learn recipes by finding recipe items or leveling crafting skill, quality system where higher crafting skill produces higher quality items with better stats, batch crafting — queue multiple of the same recipe, and crafting interruption — taking damage cancels active crafting. Namespace: SevenDTD.MMO. Must use Unity.Netcode RPCs for client-server communication."
    }
  ]
}