@musashishao/agent-kit 1.9.0 → 1.9.1

package/.agent/skills/game-development/inventory-quest/SKILL.md

@@ -0,0 +1,747 @@
+---
+name: inventory-quest
+description: RPG systems. Inventory management, equipment, quest systems, crafting, loot tables, and dialogue integration.
+allowed-tools: Read, Write, Edit, Bash, Grep, WebSearch
+---
+
+# Inventory & Quest Systems Skill
+
+> Build complete RPG progression systems.
+
+---
+
+## When to Use
+
+- Implementing inventory systems
+- Building equipment/gear systems  
+- Creating quest trackers
+- Designing crafting systems
+- Setting up loot tables
+
+---
+
+## Inventory System
+
+### Item Definition
+
+```csharp
+[CreateAssetMenu(fileName = "New Item", menuName = "RPG/Item")]
+public class ItemData : ScriptableObject
+{
+    [Header("Basic Info")]
+    public string Id;
+    public string DisplayName;
+    [TextArea] public string Description;
+    public Sprite Icon;
+    public ItemRarity Rarity;
+    public ItemType Type;
+    
+    [Header("Stacking")]
+    public bool IsStackable = true;
+    public int MaxStackSize = 99;
+    
+    [Header("Value")]
+    public int BuyPrice;
+    public int SellPrice;
+    
+    [Header("Usage")]
+    public bool IsUsable;
+    public bool IsEquippable;
+    public bool IsDroppable = true;
+    
+    public virtual void Use(Character character) { }
+    public virtual void Equip(Character character) { }
+    public virtual void Unequip(Character character) { }
+}
+
+public enum ItemRarity
+{
+    Common,
+    Uncommon,
+    Rare,
+    Epic,
+    Legendary
+}
+
+public enum ItemType
+{
+    Consumable,
+    Equipment,
+    Material,
+    Quest,
+    Currency,
+    Key
+}
+
+// Specific item types
+[CreateAssetMenu(fileName = "New Weapon", menuName = "RPG/Items/Weapon")]
+public class WeaponData : ItemData
+{
+    public int BaseDamage;
+    public float AttackSpeed;
+    public DamageType DamageType;
+    public WeaponType WeaponType;
+    
+    public override void Equip(Character character)
+    {
+        character.Stats.AddModifier(StatType.Attack, BaseDamage);
+    }
+    
+    public override void Unequip(Character character)
+    {
+        character.Stats.RemoveModifier(StatType.Attack, BaseDamage);
+    }
+}
+
+[CreateAssetMenu(fileName = "New Consumable", menuName = "RPG/Items/Consumable")]
+public class ConsumableData : ItemData
+{
+    public ConsumableType ConsumableType;
+    public float Value;
+    public float Duration;
+    public StatusEffectType EffectType;
+    
+    public override void Use(Character character)
+    {
+        switch (ConsumableType)
+        {
+            case ConsumableType.HealthPotion:
+                character.Health.Heal(Value);
+                break;
+            case ConsumableType.ManaPotion:
+                character.Mana.Restore(Value);
+                break;
+            case ConsumableType.Buff:
+                character.StatusEffects.ApplyEffect(EffectType, Duration, Value);
+                break;
+        }
+    }
+}
+```
+
+### Inventory Manager
+
+```csharp
+public class Inventory : MonoBehaviour
+{
+    [SerializeField] private int maxSlots = 40;
+    
+    private List<InventorySlot> _slots = new();
+    
+    public event Action<InventorySlot> OnSlotChanged;
+    public event Action OnInventoryChanged;
+    
+    public IReadOnlyList<InventorySlot> Slots => _slots;
+    public int MaxSlots => maxSlots;
+    public int UsedSlots => _slots.Count(s => !s.IsEmpty);
+    
+    void Awake()
+    {
+        // Initialize empty slots
+        for (int i = 0; i < maxSlots; i++)
+        {
+            _slots.Add(new InventorySlot(i));
+        }
+    }
+    
+    public bool AddItem(ItemData item, int quantity = 1)
+    {
+        if (item == null || quantity <= 0) return false;
+        
+        int remaining = quantity;
+        
+        // Try to stack with existing items first
+        if (item.IsStackable)
+        {
+            foreach (var slot in _slots.Where(s => s.Item == item && s.Quantity < item.MaxStackSize))
+            {
+                int canAdd = Mathf.Min(remaining, item.MaxStackSize - slot.Quantity);
+                slot.Quantity += canAdd;
+                remaining -= canAdd;
+                
+                OnSlotChanged?.Invoke(slot);
+                
+                if (remaining <= 0) break;
+            }
+        }
+        
+        // Add to empty slots
+        while (remaining > 0)
+        {
+            var emptySlot = _slots.FirstOrDefault(s => s.IsEmpty);
+            if (emptySlot == null)
+            {
+                Debug.Log("Inventory full!");
+                return remaining < quantity; // Partial success
+            }
+            
+            int toAdd = item.IsStackable ? Mathf.Min(remaining, item.MaxStackSize) : 1;
+            emptySlot.SetItem(item, toAdd);
+            remaining -= toAdd;
+            
+            OnSlotChanged?.Invoke(emptySlot);
+        }
+        
+        OnInventoryChanged?.Invoke();
+        return true;
+    }
+    
+    public bool RemoveItem(ItemData item, int quantity = 1)
+    {
+        int remaining = quantity;
+        
+        foreach (var slot in _slots.Where(s => s.Item == item).OrderBy(s => s.Quantity))
+        {
+            int toRemove = Mathf.Min(remaining, slot.Quantity);
+            slot.Quantity -= toRemove;
+            remaining -= toRemove;
+            
+            if (slot.Quantity <= 0)
+            {
+                slot.Clear();
+            }
+            
+            OnSlotChanged?.Invoke(slot);
+            
+            if (remaining <= 0) break;
+        }
+        
+        OnInventoryChanged?.Invoke();
+        return remaining <= 0;
+    }
+    
+    public int GetItemCount(ItemData item)
+    {
+        return _slots.Where(s => s.Item == item).Sum(s => s.Quantity);
+    }
+    
+    public bool HasItem(ItemData item, int quantity = 1)
+    {
+        return GetItemCount(item) >= quantity;
+    }
+    
+    public void SwapSlots(int indexA, int indexB)
+    {
+        if (indexA < 0 || indexA >= maxSlots || indexB < 0 || indexB >= maxSlots) return;
+        
+        var slotA = _slots[indexA];
+        var slotB = _slots[indexB];
+        
+        // Can we stack?
+        if (slotA.Item == slotB.Item && slotA.Item != null && slotA.Item.IsStackable)
+        {
+            int total = slotA.Quantity + slotB.Quantity;
+            if (total <= slotA.Item.MaxStackSize)
+            {
+                slotB.Quantity = total;
+                slotA.Clear();
+            }
+            else
+            {
+                slotB.Quantity = slotB.Item.MaxStackSize;
+                slotA.Quantity = total - slotB.Item.MaxStackSize;
+            }
+        }
+        else
+        {
+            // Swap
+            var tempItem = slotA.Item;
+            var tempQty = slotA.Quantity;
+            
+            slotA.SetItem(slotB.Item, slotB.Quantity);
+            slotB.SetItem(tempItem, tempQty);
+        }
+        
+        OnSlotChanged?.Invoke(slotA);
+        OnSlotChanged?.Invoke(slotB);
+    }
+    
+    public List<string> GetItemIds()
+    {
+        return _slots
+            .Where(s => !s.IsEmpty)
+            .SelectMany(s => Enumerable.Repeat(s.Item.Id, s.Quantity))
+            .ToList();
+    }
+    
+    public void LoadItems(List<string> itemIds)
+    {
+        // Clear first
+        foreach (var slot in _slots) slot.Clear();
+        
+        foreach (var id in itemIds)
+        {
+            var item = ItemDatabase.GetItem(id);
+            if (item != null)
+            {
+                AddItem(item, 1);
+            }
+        }
+    }
+}
+
+[System.Serializable]
+public class InventorySlot
+{
+    public int Index { get; private set; }
+    public ItemData Item { get; private set; }
+    public int Quantity { get; set; }
+    
+    public bool IsEmpty => Item == null || Quantity <= 0;
+    
+    public InventorySlot(int index)
+    {
+        Index = index;
+    }
+    
+    public void SetItem(ItemData item, int quantity)
+    {
+        Item = item;
+        Quantity = quantity;
+    }
+    
+    public void Clear()
+    {
+        Item = null;
+        Quantity = 0;
+    }
+}
+```
+
+---
+
+## Equipment System
+
+```csharp
+public class EquipmentManager : MonoBehaviour
+{
+    [SerializeField] private EquipmentSlotType[] slotTypes;
+    
+    private Dictionary<EquipmentSlotType, ItemData> _equipped = new();
+    
+    public event Action<EquipmentSlotType, ItemData> OnEquipmentChanged;
+    
+    private Character _character;
+    private Inventory _inventory;
+    
+    void Awake()
+    {
+        _character = GetComponent<Character>();
+        _inventory = GetComponent<Inventory>();
+        
+        // Initialize slots
+        foreach (var type in slotTypes)
+        {
+            _equipped[type] = null;
+        }
+    }
+    
+    public bool Equip(ItemData item, EquipmentSlotType slot)
+    {
+        if (item == null || !item.IsEquippable) return false;
+        
+        // Unequip current
+        if (_equipped[slot] != null)
+        {
+            Unequip(slot);
+        }
+        
+        // Remove from inventory
+        _inventory.RemoveItem(item, 1);
+        
+        // Equip
+        _equipped[slot] = item;
+        item.Equip(_character);
+        
+        OnEquipmentChanged?.Invoke(slot, item);
+        return true;
+    }
+    
+    public void Unequip(EquipmentSlotType slot)
+    {
+        var item = _equipped[slot];
+        if (item == null) return;
+        
+        item.Unequip(_character);
+        _inventory.AddItem(item, 1);
+        _equipped[slot] = null;
+        
+        OnEquipmentChanged?.Invoke(slot, null);
+    }
+    
+    public ItemData GetEquipped(EquipmentSlotType slot)
+    {
+        return _equipped.GetValueOrDefault(slot);
+    }
+}
+
+public enum EquipmentSlotType
+{
+    Head,
+    Chest,
+    Legs,
+    Feet,
+    Hands,
+    MainHand,
+    OffHand,
+    Ring1,
+    Ring2,
+    Necklace
+}
+```
+
+---
+
+## Quest System
+
+### Quest Data
+
+```csharp
+[CreateAssetMenu(fileName = "New Quest", menuName = "RPG/Quest")]
+public class QuestData : ScriptableObject
+{
+    [Header("Info")]
+    public string Id;
+    public string Title;
+    [TextArea] public string Description;
+    public QuestType Type;
+    
+    [Header("Requirements")]
+    public int RequiredLevel;
+    public QuestData[] Prerequisites;
+    
+    [Header("Objectives")]
+    public QuestObjective[] Objectives;
+    
+    [Header("Rewards")]
+    public int ExperienceReward;
+    public int CurrencyReward;
+    public ItemReward[] ItemRewards;
+    
+    [Header("Dialogue")]
+    public string StartDialogueId;
+    public string CompleteDialogueId;
+    public string ProgressDialogueId;
+}
+
+[System.Serializable]
+public class QuestObjective
+{
+    public string Description;
+    public ObjectiveType Type;
+    public string TargetId; // Enemy type, item type, location, etc.
+    public int RequiredCount;
+}
+
+[System.Serializable]
+public class ItemReward
+{
+    public ItemData Item;
+    public int Quantity;
+}
+
+public enum QuestType
+{
+    MainStory,
+    Side,
+    Daily,
+    Repeatable
+}
+
+public enum ObjectiveType
+{
+    Kill,
+    Collect,
+    Talk,
+    Reach,
+    Escort,
+    Defend
+}
+```
+
+### Quest Manager
+
+```csharp
+public class QuestManager : MonoBehaviour
+{
+    public static QuestManager Instance { get; private set; }
+    
+    private Dictionary<string, QuestProgress> _activeQuests = new();
+    private HashSet<string> _completedQuests = new();
+    
+    public event Action<QuestData> OnQuestStarted;
+    public event Action<QuestData, QuestObjective> OnObjectiveProgress;
+    public event Action<QuestData> OnQuestCompleted;
+    
+    public IReadOnlyDictionary<string, QuestProgress> ActiveQuests => _activeQuests;
+    
+    void Awake()
+    {
+        Instance = this;
+    }
+    
+    public bool CanStartQuest(QuestData quest)
+    {
+        // Already active or completed
+        if (_activeQuests.ContainsKey(quest.Id)) return false;
+        if (_completedQuests.Contains(quest.Id) && quest.Type != QuestType.Repeatable) return false;
+        
+        // Level requirement
+        if (PlayerManager.Instance.Level < quest.RequiredLevel) return false;
+        
+        // Prerequisites
+        foreach (var prereq in quest.Prerequisites)
+        {
+            if (!_completedQuests.Contains(prereq.Id)) return false;
+        }
+        
+        return true;
+    }
+    
+    public void StartQuest(QuestData quest)
+    {
+        if (!CanStartQuest(quest)) return;
+        
+        var progress = new QuestProgress(quest);
+        _activeQuests[quest.Id] = progress;
+        
+        OnQuestStarted?.Invoke(quest);
+        Debug.Log($"Quest started: {quest.Title}");
+    }
+    
+    public void UpdateObjective(ObjectiveType type, string targetId, int count = 1)
+    {
+        foreach (var kvp in _activeQuests)
+        {
+            var progress = kvp.Value;
+            
+            for (int i = 0; i < progress.Quest.Objectives.Length; i++)
+            {
+                var objective = progress.Quest.Objectives[i];
+                
+                if (objective.Type == type && objective.TargetId == targetId)
+                {
+                    progress.ObjectiveProgress[i] += count;
+                    
+                    OnObjectiveProgress?.Invoke(progress.Quest, objective);
+                    
+                    // Check completion
+                    if (IsQuestComplete(progress))
+                    {
+                        CompleteQuest(progress.Quest);
+                    }
+                }
+            }
+        }
+    }
+    
+    private bool IsQuestComplete(QuestProgress progress)
+    {
+        for (int i = 0; i < progress.Quest.Objectives.Length; i++)
+        {
+            if (progress.ObjectiveProgress[i] < progress.Quest.Objectives[i].RequiredCount)
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    private void CompleteQuest(QuestData quest)
+    {
+        if (!_activeQuests.ContainsKey(quest.Id)) return;
+        
+        _activeQuests.Remove(quest.Id);
+        _completedQuests.Add(quest.Id);
+        
+        // Give rewards
+        PlayerManager.Instance.AddExperience(quest.ExperienceReward);
+        PlayerManager.Instance.AddCurrency(quest.CurrencyReward);
+        
+        foreach (var reward in quest.ItemRewards)
+        {
+            PlayerManager.Instance.Inventory.AddItem(reward.Item, reward.Quantity);
+        }
+        
+        OnQuestCompleted?.Invoke(quest);
+        Debug.Log($"Quest completed: {quest.Title}");
+    }
+    
+    public List<string> GetCompletedQuestIds() => _completedQuests.ToList();
+    
+    public void RestoreCompletedQuests(List<string> ids)
+    {
+        _completedQuests = new HashSet<string>(ids);
+    }
+}
+
+public class QuestProgress
+{
+    public QuestData Quest { get; private set; }
+    public int[] ObjectiveProgress { get; private set; }
+    
+    public QuestProgress(QuestData quest)
+    {
+        Quest = quest;
+        ObjectiveProgress = new int[quest.Objectives.Length];
+    }
+}
+```
+
+---
+
+## Loot Tables
+
+```csharp
+[CreateAssetMenu(fileName = "New Loot Table", menuName = "RPG/Loot Table")]
+public class LootTable : ScriptableObject
+{
+    [System.Serializable]
+    public class LootEntry
+    {
+        public ItemData Item;
+        [Range(0, 100)] public float DropChance;
+        public int MinQuantity = 1;
+        public int MaxQuantity = 1;
+    }
+    
+    public LootEntry[] Entries;
+    public int GuaranteedDrops = 1;
+    public int MaxDrops = 5;
+    
+    public List<(ItemData item, int quantity)> Roll()
+    {
+        var drops = new List<(ItemData, int)>();
+        var sortedEntries = Entries.OrderByDescending(e => e.DropChance).ToList();
+        
+        // Guaranteed drops (highest chance items)
+        for (int i = 0; i < GuaranteedDrops && i < sortedEntries.Count; i++)
+        {
+            var entry = sortedEntries[i];
+            int qty = Random.Range(entry.MinQuantity, entry.MaxQuantity + 1);
+            drops.Add((entry.Item, qty));
+        }
+        
+        // Chance drops
+        foreach (var entry in Entries)
+        {
+            if (drops.Count >= MaxDrops) break;
+            if (drops.Any(d => d.item == entry.Item)) continue;
+            
+            if (Random.Range(0f, 100f) <= entry.DropChance)
+            {
+                int qty = Random.Range(entry.MinQuantity, entry.MaxQuantity + 1);
+                drops.Add((entry.Item, qty));
+            }
+        }
+        
+        return drops;
+    }
+}
+
+// Usage
+public class Enemy : MonoBehaviour
+{
+    [SerializeField] private LootTable lootTable;
+    
+    void OnDeath()
+    {
+        var drops = lootTable.Roll();
+        
+        foreach (var (item, quantity) in drops)
+        {
+            SpawnLootDrop(item, quantity);
+        }
+    }
+    
+    private void SpawnLootDrop(ItemData item, int quantity)
+    {
+        // Spawn pickup in world or add directly
+    }
+}
+```
+
+---
+
+## Crafting System
+
+```csharp
+[CreateAssetMenu(fileName = "New Recipe", menuName = "RPG/Recipe")]
+public class CraftingRecipe : ScriptableObject
+{
+    [System.Serializable]
+    public class Ingredient
+    {
+        public ItemData Item;
+        public int Quantity;
+    }
+    
+    public string RecipeId;
+    public string RecipeName;
+    public Ingredient[] Ingredients;
+    public ItemData Result;
+    public int ResultQuantity = 1;
+    public float CraftTime = 1f;
+    public int RequiredLevel;
+}
+
+public class CraftingManager : MonoBehaviour
+{
+    [SerializeField] private CraftingRecipe[] knownRecipes;
+    
+    private Inventory _inventory;
+    
+    void Awake()
+    {
+        _inventory = GetComponent<Inventory>();
+    }
+    
+    public bool CanCraft(CraftingRecipe recipe)
+    {
+        foreach (var ingredient in recipe.Ingredients)
+        {
+            if (!_inventory.HasItem(ingredient.Item, ingredient.Quantity))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    public bool Craft(CraftingRecipe recipe)
+    {
+        if (!CanCraft(recipe)) return false;
+        
+        // Consume ingredients
+        foreach (var ingredient in recipe.Ingredients)
+        {
+            _inventory.RemoveItem(ingredient.Item, ingredient.Quantity);
+        }
+        
+        // Add result
+        _inventory.AddItem(recipe.Result, recipe.ResultQuantity);
+        
+        return true;
+    }
+    
+    public List<CraftingRecipe> GetAvailableRecipes()
+    {
+        return knownRecipes.Where(CanCraft).ToList();
+    }
+}
+```
+
+---
+
+## Anti-Patterns
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Store items as strings | Use ScriptableObjects |
+| Hard-coded quest logic | Data-driven quests |
+| No item stacking | Support stacking |
+| Instant crafting | Show progress feedback |
+
+---
+
+> **Remember:** Players love collecting and progressing. Make it satisfying.