@musashishao/agent-kit 1.9.0 → 1.9.1

package/.agent/skills/game-development/spec-ecosystem/templates/TASKS-template.md

@@ -0,0 +1,156 @@
+# TASKS Template for Game Projects
+
+> Executable task list generated from PLAN. Track progress with checkboxes.
+
+---
+
+## 📋 Project Info
+
+**Game:** [Game Name]
+**Based on:** `PLAN-{game-slug}.md`
+**Started:** [Date]
+**Target Completion:** [Date]
+
+---
+
+## 📊 Progress Overview
+
+| Phase | Status | Progress |
+|-------|--------|----------|
+| Phase 1: Core Systems | 🔄 | 0/X tasks |
+| Phase 2: Gameplay | ⏳ | 0/X tasks |
+| Phase 3: UI & Polish | ⏳ | 0/X tasks |
+| Phase 4: Audio & Effects | ⏳ | 0/X tasks |
+| Phase X: Verification | ⏳ | 0/X checks |
+
+**Legend:** ✅ Done | 🔄 In Progress | ⏳ Waiting | ❌ Blocked
+
+---
+
+## Phase 1: Core Systems
+
+### 1.1 [Task Name]
+- [ ] **Task:** [Description]
+- **Agent:** `[agent-name]`
+- **Input:** [What's needed]
+- **Output:** [What's produced]
+- **Verify:** [How to check done]
+- **Notes:** [Any additional context]
+
+### 1.2 [Task Name]
+- [ ] **Task:** [Description]
+- **Agent:** `[agent-name]`
+- **Depends on:** 1.1
+- **Input:** [What's needed]
+- **Output:** [What's produced]
+- **Verify:** [How to check done]
+
+---
+
+## Phase 2: Gameplay
+
+### 2.1 [Task Name]
+- [ ] **Task:** [Description]
+- **Agent:** `[agent-name]`
+- **Depends on:** Phase 1
+- **Input:** [What's needed]
+- **Output:** [What's produced]
+- **Verify:** [How to check done]
+
+### 2.2 [Task Name]
+- [ ] **Task:** [Description]
+- **Agent:** `[agent-name]`
+- **Depends on:** 2.1
+- **Input:** [What's needed]
+- **Output:** [What's produced]
+- **Verify:** [How to check done]
+
+---
+
+## Phase 3: UI & Polish
+
+### 3.1 [Task Name]
+- [ ] **Task:** [Description]
+- **Agent:** `[agent-name]`
+- **Depends on:** Phase 2
+- **Input:** [What's needed]
+- **Output:** [What's produced]
+- **Verify:** [How to check done]
+
+---
+
+## Phase 4: Audio & Effects
+
+### 4.1 [Task Name]
+- [ ] **Task:** [Description]
+- **Agent:** `[agent-name]`
+- **Depends on:** None (parallel)
+- **Input:** [What's needed]
+- **Output:** [What's produced]
+- **Verify:** [How to check done]
+
+---
+
+## Phase X: Verification
+
+### Build Verification
+- [ ] **Build compiles without errors**
+  - Command: `[build command]`
+  - Expected: Build artifact created
+
+- [ ] **Build size acceptable**
+  - Target: < [X] MB
+  - Actual: [X] MB
+
+### Performance Verification
+- [ ] **Frame rate stable**
+  - Target: 60 FPS on [device]
+  - Test: Play for 5 minutes
+
+- [ ] **Memory usage acceptable**
+  - Target: < [X] MB peak
+  - Test: Profile for 10 minutes
+
+### Feature Verification
+- [ ] **Core loop works**
+  - Test: [Action] → [Reward] → [Progression]
+
+- [ ] **All AC from SPEC met**
+  - [ ] AC1: [criterion]
+  - [ ] AC2: [criterion]
+  - [ ] AC3: [criterion]
+
+### Quality Verification
+- [ ] **No critical bugs**
+- [ ] **Audio plays correctly**
+- [ ] **Save/Load works**
+- [ ] **UI responsive on all supported devices**
+
+---
+
+## 📝 Session Log
+
+### [Date] - Session 1
+**Completed:**
+- [x] Task 1.1
+- [x] Task 1.2
+
+**Blockers:**
+- [None / Description of blocker]
+
+**Next Session:**
+- [ ] Task 2.1
+
+---
+
+## ✅ Completion
+
+> [!NOTE]
+> Đánh dấu khi TOÀN BỘ tasks và Phase X hoàn thành.
+
+- [ ] **All tasks completed**
+- [ ] **Phase X verification passed**
+- [ ] **CHANGELOG updated**
+
+**Completed on:** [Date]
+**Total time:** [X hours/days]

package/.agent/skills/game-development/survival-systems/SKILL.md

@@ -0,0 +1,493 @@
+---
+name: survival-systems
+description: Comprehensive survival game mechanics. Crafting systems, hunger/thirst/stamina, base building, resource gathering, day-night cycles, weather systems, and environmental hazards for Unity.
+---
+
+# Survival Systems Skill
+
+> **Purpose**: Build immersive survival games with interconnected systems.
+
+## When to Use
+- Building survival/crafting games
+- Implementing resource management
+- Creating base building mechanics
+- Designing environmental systems
+
+---
+
+## 1. Core Survival Stats
+
+### Stat Architecture
+```csharp
+[CreateAssetMenu(fileName = "SurvivalConfig", menuName = "Game/Survival/Config")]
+public class SurvivalConfig : ScriptableObject
+{
+    [Header("Hunger")]
+    public float maxHunger = 100f;
+    public float hungerDecayRate = 1f; // per minute
+    public float starvingDamageRate = 5f; // HP per minute when hunger = 0
+    
+    [Header("Thirst")]
+    public float maxThirst = 100f;
+    public float thirstDecayRate = 1.5f;
+    public float dehydrationDamageRate = 8f;
+    
+    [Header("Stamina")]
+    public float maxStamina = 100f;
+    public float staminaRegenRate = 10f;
+    public float sprintStaminaCost = 15f;
+    
+    [Header("Temperature")]
+    public float optimalTemp = 20f;
+    public float tempTolerance = 10f; // ±10 degrees comfortable
+    public float freezingDamageRate = 3f;
+    public float heatstrokeDamageRate = 3f;
+}
+```
+
+### Survival Manager
+```csharp
+public class SurvivalManager : MonoBehaviour
+{
+    [SerializeField] private SurvivalConfig _config;
+    
+    public float Hunger { get; private set; }
+    public float Thirst { get; private set; }
+    public float Stamina { get; private set; }
+    public float BodyTemperature { get; private set; }
+    
+    // Events for UI binding
+    public event Action<float> OnHungerChanged;
+    public event Action<float> OnThirstChanged;
+    public event Action<float> OnStaminaChanged;
+    public event Action<float> OnTemperatureChanged;
+    
+    private void Start()
+    {
+        Hunger = _config.maxHunger;
+        Thirst = _config.maxThirst;
+        Stamina = _config.maxStamina;
+        BodyTemperature = _config.optimalTemp;
+    }
+    
+    private void Update()
+    {
+        float dt = Time.deltaTime / 60f; // Convert to per-minute
+        
+        // Decay stats
+        ModifyHunger(-_config.hungerDecayRate * dt);
+        ModifyThirst(-_config.thirstDecayRate * dt);
+        
+        // Apply damage at zero
+        if (Hunger <= 0) ApplyStarvingDamage(dt);
+        if (Thirst <= 0) ApplyDehydrationDamage(dt);
+        
+        // Regenerate stamina
+        if (!IsSprinting) ModifyStamina(_config.staminaRegenRate * Time.deltaTime);
+    }
+    
+    public void Eat(FoodItem food)
+    {
+        ModifyHunger(food.hungerRestore);
+        ModifyThirst(food.thirstRestore);
+        GameEvents.OnPlayerAte?.Invoke(food);
+    }
+    
+    public void Drink(float amount)
+    {
+        ModifyThirst(amount);
+        GameEvents.OnPlayerDrank?.Invoke(amount);
+    }
+}
+```
+
+---
+
+## 2. Crafting System
+
+### Recipe Data Structure
+```csharp
+[CreateAssetMenu(fileName = "Recipe", menuName = "Game/Crafting/Recipe")]
+public class CraftingRecipe : ScriptableObject
+{
+    public string recipeName;
+    public Sprite icon;
+    
+    [Header("Ingredients")]
+    public IngredientSlot[] ingredients;
+    
+    [Header("Output")]
+    public ItemData outputItem;
+    public int outputQuantity = 1;
+    
+    [Header("Requirements")]
+    public CraftingStation requiredStation;
+    public float craftingTime = 2f;
+    public int requiredLevel = 1;
+    
+    [Header("Discovery")]
+    public bool startsUnlocked = false;
+    public string[] unlockConditions; // "kill_boss_1", "find_blueprint"
+}
+
+[System.Serializable]
+public struct IngredientSlot
+{
+    public ItemData item;
+    public int quantity;
+}
+
+public enum CraftingStation
+{
+    Hand,           // No station needed
+    Workbench,
+    Forge,
+    ChemistryTable,
+    Kitchen
+}
+```
+
+### Crafting Manager
+```csharp
+public class CraftingManager : MonoBehaviour
+{
+    [SerializeField] private CraftingRecipe[] _allRecipes;
+    
+    private HashSet<string> _unlockedRecipes = new();
+    private InventoryManager _inventory;
+    
+    public bool CanCraft(CraftingRecipe recipe)
+    {
+        // Check if unlocked
+        if (!recipe.startsUnlocked && !_unlockedRecipes.Contains(recipe.name))
+            return false;
+        
+        // Check ingredients
+        foreach (var ingredient in recipe.ingredients)
+        {
+            if (!_inventory.HasItem(ingredient.item, ingredient.quantity))
+                return false;
+        }
+        
+        // Check station
+        if (!HasAccessToStation(recipe.requiredStation))
+            return false;
+        
+        return true;
+    }
+    
+    public IEnumerator Craft(CraftingRecipe recipe, Action onComplete)
+    {
+        if (!CanCraft(recipe)) yield break;
+        
+        // Consume ingredients
+        foreach (var ingredient in recipe.ingredients)
+        {
+            _inventory.RemoveItem(ingredient.item, ingredient.quantity);
+        }
+        
+        // Crafting time
+        GameEvents.OnCraftingStarted?.Invoke(recipe);
+        yield return new WaitForSeconds(recipe.craftingTime);
+        
+        // Add output
+        _inventory.AddItem(recipe.outputItem, recipe.outputQuantity);
+        GameEvents.OnItemCrafted?.Invoke(recipe.outputItem, recipe.outputQuantity);
+        
+        onComplete?.Invoke();
+    }
+    
+    public void UnlockRecipe(string recipeName)
+    {
+        _unlockedRecipes.Add(recipeName);
+        GameEvents.OnRecipeUnlocked?.Invoke(recipeName);
+    }
+}
+```
+
+---
+
+## 3. Base Building
+
+### Building Piece System
+```csharp
+[CreateAssetMenu(fileName = "BuildingPiece", menuName = "Game/Building/Piece")]
+public class BuildingPiece : ScriptableObject
+{
+    public string pieceName;
+    public GameObject prefab;
+    public GameObject ghostPrefab; // Transparent preview
+    
+    [Header("Placement")]
+    public PieceCategory category;
+    public Vector3 gridSize = Vector3.one;
+    public bool requiresFoundation = false;
+    public bool canStack = true;
+    
+    [Header("Stats")]
+    public float maxHealth = 100f;
+    public float repairCostMultiplier = 0.5f;
+    
+    [Header("Cost")]
+    public IngredientSlot[] buildCost;
+}
+
+public enum PieceCategory
+{
+    Foundation,
+    Wall,
+    Floor,
+    Roof,
+    Door,
+    Window,
+    Furniture,
+    Workstation,
+    Storage,
+    Defense
+}
+```
+
+### Placement System
+```csharp
+public class BuildingPlacer : MonoBehaviour
+{
+    [SerializeField] private LayerMask _groundLayer;
+    [SerializeField] private LayerMask _snapLayer;
+    [SerializeField] private Material _validPlacementMat;
+    [SerializeField] private Material _invalidPlacementMat;
+    
+    private BuildingPiece _currentPiece;
+    private GameObject _ghostInstance;
+    private bool _canPlace;
+    
+    public void StartPlacing(BuildingPiece piece)
+    {
+        _currentPiece = piece;
+        _ghostInstance = Instantiate(piece.ghostPrefab);
+    }
+    
+    private void Update()
+    {
+        if (_ghostInstance == null) return;
+        
+        // Raycast for position
+        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
+        if (Physics.Raycast(ray, out RaycastHit hit, 100f, _groundLayer | _snapLayer))
+        {
+            Vector3 position = SnapToGrid(hit.point);
+            _ghostInstance.transform.position = position;
+            
+            // Check validity
+            _canPlace = CheckPlacementValid(position);
+            UpdateGhostMaterial(_canPlace);
+        }
+        
+        // Rotate
+        if (Input.GetKeyDown(KeyCode.R))
+        {
+            _ghostInstance.transform.Rotate(0, 90, 0);
+        }
+        
+        // Place
+        if (Input.GetMouseButtonDown(0) && _canPlace)
+        {
+            PlacePiece();
+        }
+        
+        // Cancel
+        if (Input.GetMouseButtonDown(1))
+        {
+            CancelPlacing();
+        }
+    }
+    
+    private Vector3 SnapToGrid(Vector3 position)
+    {
+        float gridSize = _currentPiece.gridSize.x;
+        return new Vector3(
+            Mathf.Round(position.x / gridSize) * gridSize,
+            position.y,
+            Mathf.Round(position.z / gridSize) * gridSize
+        );
+    }
+}
+```
+
+---
+
+## 4. Day-Night Cycle
+
+### Time System
+```csharp
+public class DayNightCycle : MonoBehaviour
+{
+    [Header("Time Settings")]
+    [SerializeField] private float _dayLengthMinutes = 20f; // Real minutes per game day
+    [SerializeField] private float _startTime = 6f; // 6 AM
+    
+    [Header("Lighting")]
+    [SerializeField] private Light _sunLight;
+    [SerializeField] private Gradient _skyColorGradient;
+    [SerializeField] private AnimationCurve _sunIntensityCurve;
+    
+    public float CurrentHour { get; private set; }
+    public int CurrentDay { get; private set; } = 1;
+    public bool IsNight => CurrentHour < 6f || CurrentHour >= 20f;
+    
+    public event Action<int> OnNewDay;
+    public event Action OnNightStarted;
+    public event Action OnDayStarted;
+    
+    private float _timeScale;
+    private bool _wasNight;
+    
+    private void Start()
+    {
+        CurrentHour = _startTime;
+        _timeScale = 24f / (_dayLengthMinutes * 60f); // Hours per real second
+    }
+    
+    private void Update()
+    {
+        // Advance time
+        CurrentHour += _timeScale * Time.deltaTime;
+        
+        // New day
+        if (CurrentHour >= 24f)
+        {
+            CurrentHour -= 24f;
+            CurrentDay++;
+            OnNewDay?.Invoke(CurrentDay);
+        }
+        
+        // Day/Night transitions
+        bool isNightNow = IsNight;
+        if (isNightNow && !_wasNight)
+        {
+            OnNightStarted?.Invoke();
+            GameEvents.OnNightStarted?.Invoke();
+        }
+        else if (!isNightNow && _wasNight)
+        {
+            OnDayStarted?.Invoke();
+            GameEvents.OnDayStarted?.Invoke();
+        }
+        _wasNight = isNightNow;
+        
+        // Update lighting
+        UpdateLighting();
+    }
+    
+    private void UpdateLighting()
+    {
+        float t = CurrentHour / 24f;
+        
+        // Rotate sun
+        _sunLight.transform.rotation = Quaternion.Euler((t * 360f) - 90f, 170f, 0);
+        
+        // Intensity
+        _sunLight.intensity = _sunIntensityCurve.Evaluate(t);
+        
+        // Sky color
+        RenderSettings.ambientSkyColor = _skyColorGradient.Evaluate(t);
+    }
+}
+```
+
+---
+
+## 5. Resource Nodes
+
+### Harvestable Resources
+```csharp
+[CreateAssetMenu(fileName = "ResourceNode", menuName = "Game/Survival/ResourceNode")]
+public class ResourceNodeData : ScriptableObject
+{
+    public string nodeName;
+    public ResourceType type;
+    
+    [Header("Harvesting")]
+    public ToolType requiredTool;
+    public int minToolTier = 0;
+    public int hitsToHarvest = 3;
+    
+    [Header("Drops")]
+    public LootDrop[] drops;
+    
+    [Header("Respawn")]
+    public float respawnTimeSeconds = 300f;
+    public bool canRespawn = true;
+}
+
+public enum ResourceType { Tree, Rock, Ore, Bush, Animal, Fish }
+public enum ToolType { None, Axe, Pickaxe, Shovel, FishingRod }
+
+public class ResourceNode : MonoBehaviour, IDamageable
+{
+    [SerializeField] private ResourceNodeData _data;
+    
+    private int _remainingHits;
+    private bool _depleted;
+    
+    public void TakeDamage(DamageInfo damage)
+    {
+        // Check tool requirement
+        if (!HasCorrectTool(damage.toolType, damage.toolTier))
+        {
+            GameEvents.OnWrongTool?.Invoke(_data.requiredTool);
+            return;
+        }
+        
+        _remainingHits--;
+        PlayHitEffect();
+        
+        if (_remainingHits <= 0)
+        {
+            Harvest();
+        }
+    }
+    
+    private void Harvest()
+    {
+        // Spawn drops
+        foreach (var drop in _data.drops)
+        {
+            int quantity = Random.Range(drop.minQuantity, drop.maxQuantity + 1);
+            SpawnDrop(drop.item, quantity);
+        }
+        
+        _depleted = true;
+        
+        if (_data.canRespawn)
+        {
+            StartCoroutine(RespawnAfterDelay());
+        }
+        else
+        {
+            Destroy(gameObject);
+        }
+    }
+}
+```
+
+---
+
+## Anti-Patterns
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Hardcode decay rates | Use ScriptableObject configs |
+| Tick every frame | Use time-based intervals |
+| Complex nested if-else | Use state machines |
+| Ignore player feedback | Show clear UI indicators |
+| One giant manager | Separate concerns (Hunger, Thirst, etc.) |
+
+---
+
+## Related Skills
+- `game-development/inventory-quest` - Inventory system
+- `game-development/game-state-manager` - Save/Load
+- `game-development/game-economy-designer` - Resource balancing
+
+## Related Workflows
+- `/game-hybrid` - Development workflow