@musashishao/agent-kit 1.9.0 → 1.9.1

package/.agent/skills/game-development/cultivation-progression/SKILL.md

@@ -0,0 +1,520 @@
+---
+name: cultivation-progression
+description: Cultivation/Xianxia game systems. Realm advancement, breakthrough mechanics, cultivation techniques, sect/faction systems, spiritual roots, and power scaling for Unity.
+---
+
+# Cultivation Progression Skill
+
+> **Purpose**: Build cultivation/Xianxia games with deep progression systems.
+
+## When to Use
+- Building cultivation/Xianxia games
+- Implementing realm-based progression
+- Creating sect/faction systems
+- Designing spiritual power mechanics
+
+---
+
+## 1. Cultivation Realm System
+
+### Realm Data Structure
+```csharp
+[CreateAssetMenu(fileName = "CultivationRealm", menuName = "Game/Cultivation/Realm")]
+public class CultivationRealm : ScriptableObject
+{
+    public string realmName;
+    public string realmNameChinese; // 炼气期
+    public int realmIndex;
+    
+    [Header("Sub-Stages")]
+    public int subStages = 9; // Early, Mid, Late, Peak (or 1-9)
+    
+    [Header("Requirements")]
+    public long qiRequired;
+    public int levelRequired;
+    public CultivationRealm previousRealm;
+    
+    [Header("Breakthrough")]
+    public float baseBreakthroughChance = 0.5f;
+    public ItemData[] requiredPills;
+    public float tribulationDifficulty = 1f;
+    
+    [Header("Bonuses")]
+    public float healthMultiplier = 1f;
+    public float qiCapacityMultiplier = 1f;
+    public float attackMultiplier = 1f;
+    public float lifespanYears = 100f;
+    
+    [Header("Unlock")]
+    public TechniqueData[] unlockedTechniques;
+    public string[] unlockedAbilities;
+}
+```
+
+### Realm Definitions Example
+```csharp
+// Common Xianxia Realms:
+// 1. Qi Condensation (炼气期) - Stages 1-9
+// 2. Foundation Establishment (筑基期) - Early, Mid, Late, Peak
+// 3. Core Formation (结丹期)
+// 4. Nascent Soul (元婴期)
+// 5. Spirit Severing (化神期)
+// 6. Dao Seeking (合道期)
+// 7. Immortal Ascension (渡劫期)
+
+public static class RealmConstants
+{
+    public static readonly string[] RealmNames = {
+        "Qi Condensation",
+        "Foundation Establishment", 
+        "Core Formation",
+        "Nascent Soul",
+        "Spirit Severing",
+        "Dao Seeking",
+        "Immortal Ascension"
+    };
+    
+    public static readonly long[] QiRequirements = {
+        1000,       // Qi Condensation
+        10000,      // Foundation
+        100000,     // Core Formation
+        1000000,    // Nascent Soul
+        10000000,   // Spirit Severing
+        100000000,  // Dao Seeking
+        1000000000  // Immortal
+    };
+}
+```
+
+---
+
+## 2. Cultivation Manager
+
+### Core System
+```csharp
+public class CultivationManager : MonoBehaviour
+{
+    [SerializeField] private CultivationRealm[] _allRealms;
+    [SerializeField] private CultivationConfig _config;
+    
+    // Current State
+    public CultivationRealm CurrentRealm { get; private set; }
+    public int CurrentSubStage { get; private set; } = 1;
+    public long CurrentQi { get; private set; }
+    public long MaxQi => CalculateMaxQi();
+    
+    // Spiritual Root (talent)
+    public SpiritualRoot SpiritualRoot { get; private set; }
+    
+    // Events
+    public event Action<CultivationRealm, int> OnRealmChanged;
+    public event Action<long> OnQiChanged;
+    public event Action<bool> OnBreakthroughAttempt;
+    
+    public void GainQi(long amount)
+    {
+        // Apply spiritual root bonus
+        float multiplier = SpiritualRoot.qiGainMultiplier;
+        long actualGain = (long)(amount * multiplier);
+        
+        CurrentQi = Mathf.Min(CurrentQi + actualGain, MaxQi);
+        OnQiChanged?.Invoke(CurrentQi);
+        
+        // Check for natural breakthrough trigger
+        if (CurrentQi >= MaxQi && CanAttemptBreakthrough())
+        {
+            GameEvents.OnBreakthroughAvailable?.Invoke(GetNextTarget());
+        }
+    }
+    
+    public bool AttemptBreakthrough(BreakthroughType type)
+    {
+        if (!CanAttemptBreakthrough()) return false;
+        
+        float chance = CalculateBreakthroughChance();
+        bool success = Random.value < chance;
+        
+        OnBreakthroughAttempt?.Invoke(success);
+        
+        if (success)
+        {
+            AdvanceCultivation();
+            return true;
+        }
+        else
+        {
+            // Failure consequences
+            ApplyBreakthroughFailure();
+            return false;
+        }
+    }
+    
+    private void AdvanceCultivation()
+    {
+        if (CurrentSubStage < CurrentRealm.subStages)
+        {
+            CurrentSubStage++;
+        }
+        else
+        {
+            // Advance to next realm
+            int nextIndex = CurrentRealm.realmIndex + 1;
+            if (nextIndex < _allRealms.Length)
+            {
+                CurrentRealm = _allRealms[nextIndex];
+                CurrentSubStage = 1;
+                CurrentQi = 0; // Reset Qi for new realm
+                
+                // Unlock new techniques
+                UnlockRealmTechniques(CurrentRealm);
+            }
+        }
+        
+        OnRealmChanged?.Invoke(CurrentRealm, CurrentSubStage);
+        GameEvents.OnCultivationAdvanced?.Invoke(CurrentRealm, CurrentSubStage);
+    }
+    
+    private float CalculateBreakthroughChance()
+    {
+        float baseChance = CurrentRealm.baseBreakthroughChance;
+        
+        // Modifiers
+        float qiBonus = (float)CurrentQi / MaxQi * 0.2f; // Up to 20% from Qi
+        float pillBonus = GetPillBonus(); // From breakthrough pills
+        float rootBonus = SpiritualRoot.breakthroughBonus;
+        float locationBonus = GetLocationBonus(); // Sacred grounds
+        
+        return Mathf.Clamp01(baseChance + qiBonus + pillBonus + rootBonus + locationBonus);
+    }
+    
+    private void ApplyBreakthroughFailure()
+    {
+        // Lose some Qi
+        CurrentQi = (long)(CurrentQi * 0.5f);
+        
+        // Possible cultivation deviation (走火入魔)
+        if (Random.value < 0.1f)
+        {
+            GameEvents.OnCultivationDeviation?.Invoke();
+        }
+    }
+}
+```
+
+---
+
+## 3. Spiritual Root System
+
+### Talent System
+```csharp
+[CreateAssetMenu(fileName = "SpiritualRoot", menuName = "Game/Cultivation/SpiritualRoot")]
+public class SpiritualRoot : ScriptableObject
+{
+    public string rootName;
+    public RootQuality quality;
+    public ElementType[] affinities;
+    
+    [Header("Bonuses")]
+    public float qiGainMultiplier = 1f;
+    public float breakthroughBonus = 0f;
+    public float techniqueLearnSpeed = 1f;
+    
+    [Header("Limits")]
+    public CultivationRealm maxRealmWithoutTreasure;
+}
+
+public enum RootQuality
+{
+    Waste,      // 废材 - Cannot cultivate normally
+    Inferior,   // 下等 - Very slow
+    Common,     // 普通 - Normal speed
+    Superior,   // 上等 - Fast
+    Heavenly,   // 天灵根 - Very fast
+    Chaos       // 混沌根 - Legendary, all elements
+}
+
+public enum ElementType
+{
+    Metal,  // 金
+    Wood,   // 木
+    Water,  // 水
+    Fire,   // 火
+    Earth,  // 土
+    Lightning,
+    Ice,
+    Wind,
+    Dark,
+    Light
+}
+```
+
+### Root Generation
+```csharp
+public class SpiritualRootGenerator
+{
+    private static readonly float[] QualityWeights = {
+        0.10f,  // Waste
+        0.30f,  // Inferior
+        0.40f,  // Common
+        0.15f,  // Superior
+        0.04f,  // Heavenly
+        0.01f   // Chaos
+    };
+    
+    public static SpiritualRoot GenerateRandom()
+    {
+        // Roll quality
+        RootQuality quality = RollQuality();
+        
+        // Roll elements based on quality
+        int elementCount = quality switch
+        {
+            RootQuality.Waste => 0,
+            RootQuality.Inferior => 1,
+            RootQuality.Common => Random.Range(1, 3),
+            RootQuality.Superior => Random.Range(2, 4),
+            RootQuality.Heavenly => 1, // Single pure element
+            RootQuality.Chaos => 5,    // All five basic
+            _ => 1
+        };
+        
+        // Create spiritual root
+        var root = ScriptableObject.CreateInstance<SpiritualRoot>();
+        root.quality = quality;
+        root.affinities = RollElements(elementCount);
+        root.qiGainMultiplier = GetQualityMultiplier(quality);
+        
+        return root;
+    }
+}
+```
+
+---
+
+## 4. Cultivation Techniques
+
+### Technique System
+```csharp
+[CreateAssetMenu(fileName = "Technique", menuName = "Game/Cultivation/Technique")]
+public class TechniqueData : ScriptableObject
+{
+    public string techniqueName;
+    public string chineseName;
+    public TechniqueType type;
+    public TechniqueGrade grade;
+    
+    [Header("Requirements")]
+    public CultivationRealm minRealm;
+    public ElementType[] requiredAffinities;
+    
+    [Header("Levels")]
+    public int maxLevel = 10;
+    public long[] levelUpQiCost;
+    
+    [Header("Effects Per Level")]
+    public TechniqueEffect[] effects;
+    
+    [Header("Learning")]
+    public float baseLearningTime = 3600f; // seconds
+    public float comprehensionDifficulty = 1f;
+}
+
+public enum TechniqueType
+{
+    Body,           // 体修功法
+    Qi,             // 气修功法
+    Soul,           // 魂修功法
+    Sword,          // 剑修功法
+    Formation,      // 阵法
+    Alchemy,        // 炼丹术
+    Artifact,       // 炼器术
+    Movement,       // 身法
+    Attack,         // 攻击秘术
+    Defense         // 防御秘术
+}
+
+public enum TechniqueGrade
+{
+    Mortal,         // 凡级
+    Yellow,         // 黄级
+    Profound,       // 玄级
+    Earth,          // 地级
+    Heaven,         // 天级
+    Saint,          // 圣级
+    Divine          // 神级
+}
+```
+
+---
+
+## 5. Sect/Faction System
+
+### Sect Structure
+```csharp
+[CreateAssetMenu(fileName = "Sect", menuName = "Game/Cultivation/Sect")]
+public class SectData : ScriptableObject
+{
+    public string sectName;
+    public SectType type;
+    public ElementType primaryElement;
+    
+    [Header("Hierarchy")]
+    public SectRank[] ranks;
+    
+    [Header("Benefits")]
+    public float qiGainBonus = 0.1f;
+    public TechniqueData[] sectTechniques;
+    public ItemData[] monthlyRewards;
+    
+    [Header("Requirements")]
+    public int minAgeToJoin = 12;
+    public int maxAgeToJoin = 20;
+    public RootQuality minRootQuality = RootQuality.Common;
+}
+
+[System.Serializable]
+public class SectRank
+{
+    public string rankName;      // Outer Disciple, Inner Disciple, Core Disciple, Elder
+    public int contributionRequired;
+    public int realmRequired;
+    public float resourceMultiplier;
+}
+
+public enum SectType
+{
+    Righteous,  // 正道
+    Demonic,    // 魔道
+    Neutral,    // 中立
+    Hidden      // 隐世
+}
+```
+
+### Sect Manager
+```csharp
+public class SectManager : MonoBehaviour
+{
+    public SectData CurrentSect { get; private set; }
+    public SectRank CurrentRank { get; private set; }
+    public int Contribution { get; private set; }
+    public int Reputation { get; private set; }
+    
+    public event Action<SectData> OnJoinedSect;
+    public event Action<SectRank> OnRankPromoted;
+    
+    public bool TryJoinSect(SectData sect)
+    {
+        if (CurrentSect != null) return false;
+        if (!MeetsRequirements(sect)) return false;
+        
+        CurrentSect = sect;
+        CurrentRank = sect.ranks[0]; // Start as Outer Disciple
+        
+        OnJoinedSect?.Invoke(sect);
+        return true;
+    }
+    
+    public void AddContribution(int amount)
+    {
+        Contribution += amount;
+        CheckForPromotion();
+    }
+    
+    public void CompleteSectMission(SectMission mission)
+    {
+        AddContribution(mission.contributionReward);
+        Reputation += mission.reputationReward;
+        
+        GameEvents.OnSectMissionCompleted?.Invoke(mission);
+    }
+    
+    private void CheckForPromotion()
+    {
+        int currentIndex = Array.IndexOf(CurrentSect.ranks, CurrentRank);
+        if (currentIndex < CurrentSect.ranks.Length - 1)
+        {
+            var nextRank = CurrentSect.ranks[currentIndex + 1];
+            if (Contribution >= nextRank.contributionRequired)
+            {
+                CurrentRank = nextRank;
+                OnRankPromoted?.Invoke(nextRank);
+            }
+        }
+    }
+}
+```
+
+---
+
+## 6. Tribulation System
+
+### Heavenly Tribulation
+```csharp
+public class TribulationManager : MonoBehaviour
+{
+    [SerializeField] private TribulationConfig _config;
+    
+    public bool IsUnderTribulation { get; private set; }
+    public int CurrentWave { get; private set; }
+    public int TotalWaves { get; private set; }
+    
+    public event Action OnTribulationStarted;
+    public event Action<bool> OnTribulationEnded;
+    
+    public void TriggerTribulation(CultivationRealm targetRealm)
+    {
+        IsUnderTribulation = true;
+        TotalWaves = CalculateWaves(targetRealm);
+        CurrentWave = 0;
+        
+        OnTribulationStarted?.Invoke();
+        StartCoroutine(RunTribulation(targetRealm));
+    }
+    
+    private IEnumerator RunTribulation(CultivationRealm realm)
+    {
+        for (int i = 0; i < TotalWaves; i++)
+        {
+            CurrentWave = i + 1;
+            
+            // Spawn lightning strike
+            float damage = CalculateLightningDamage(realm, i);
+            yield return SpawnLightningStrike(damage);
+            
+            // Wait between waves
+            yield return new WaitForSeconds(_config.waveCooldown);
+            
+            // Check if player survived
+            if (PlayerManager.Instance.IsDead)
+            {
+                OnTribulationEnded?.Invoke(false);
+                yield break;
+            }
+        }
+        
+        // Survived all waves
+        IsUnderTribulation = false;
+        OnTribulationEnded?.Invoke(true);
+        GameEvents.OnTribulationSurvived?.Invoke(realm);
+    }
+}
+```
+
+---
+
+## Anti-Patterns
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Linear power scaling | Exponential scaling (10x per realm) |
+| Guaranteed breakthroughs | RNG with failure consequences |
+| Single progression path | Multiple cultivation methods |
+| Ignore Chinese terminology | Include both English and Chinese names |
+| Static techniques | Leveled techniques with mastery |
+
+---
+
+## Related Skills
+- `game-development/game-economy-designer` - Resource balancing
+- `game-development/combat-system` - Cultivation combat
+- `game-development/narrative-branching` - Sect storylines