《Magicraft》核心设计知识图谱

发射器: 散射 (5发)
弹道: 火球
效果: 无

发射器: 单发
弹道: 火球
效果: 追踪 + 爆炸

发射器: 单发
弹道: 闪电
效果: 链式传导 (最多5个敌人)

发射器: 环形 (8发)
弹道: 冰锥
效果: 减速 + 冻结

发射器: 波浪
弹道: 毒液
效果: 持续伤害 (5秒)

发射器: 单发
弹道: 火球
效果: 分裂 (3个) + 追踪

发射器: 单发
弹道: 火球
效果: 穿透 + 爆炸

发射器: 散射 (5发)
弹道: 冰锥
效果: 冻结

发射器: 环形 (8发)
弹道: 闪电
效果: 链式传导

// 武器零件基类
public abstract class WeaponPart : ScriptableObject {
    public string partName;
    public PartRarity rarity;
    public Sprite icon;
}

// 零件稀有度
public enum PartRarity {
    Common,    // 普通
    Rare,      // 稀有
    Epic,      // 史诗
    Legendary  // 传说
}

// 发射器零件
[CreateAssetMenu(fileName = "Emitter", menuName = "Weapon/Emitter")]
public class EmitterPart : WeaponPart {
    public EmitterType type;
    public int projectileCount;  // 发射数量
    public float spreadAngle;    // 散布角度
}

public enum EmitterType {
    Single,   // 单发
    Spread,   // 散射
    Ring,     // 环形
    Wave      // 波浪
}

// 弹道零件
[CreateAssetMenu(fileName = "Projectile", menuName = "Weapon/Projectile")]
public class ProjectilePart : WeaponPart {
    public ProjectileType type;
    public GameObject prefab;
    public int baseDamage;
    public float speed;
}

public enum ProjectileType {
    Fireball,   // 火球
    Lightning,  // 闪电
    IceShard,   // 冰锥
    Poison      // 毒液
}

// 效果器零件
[CreateAssetMenu(fileName = "Effect", menuName = "Weapon/Effect")]
public class EffectPart : WeaponPart {
    public EffectType type;
    public float effectValue;  // 效果数值（范围/数量等）
}

public enum EffectType {
    Explosion,  // 爆炸
    Split,      // 分裂
    Homing,     // 追踪
    Pierce      // 穿透
}

// 武器组装器
[System.Serializable]
public class WeaponAssembly {
    public EmitterPart emitter;
    public ProjectilePart projectile;
    public List<EffectPart> effects = new List<EffectPart>();  // 可以有多个效果
    
    // 计算总伤害
    public int CalculateDamage() {
        int baseDmg = projectile.baseDamage;
        
        // 发射器倍率
        float emitterMult = emitter.projectileCount;
        
        // 效果倍率
        float effectMult = 1.0f;
        foreach (var effect in effects) {
            if (effect.type == EffectType.Explosion) effectMult *= 2.0f;
            if (effect.type == EffectType.Split) effectMult *= 1.5f;
        }
        
        // 稀有度加成
        float rarityBonus = GetRarityBonus();
        
        return Mathf.RoundToInt(baseDmg * emitterMult * effectMult * rarityBonus);
    }
    
    // 稀有度加成
    private float GetRarityBonus() {
        float bonus = 1.0f;
        if (emitter.rarity == PartRarity.Legendary) bonus += 2.0f;
        if (projectile.rarity == PartRarity.Legendary) bonus += 2.0f;
        foreach (var effect in effects) {
            if (effect.rarity == PartRarity.Legendary) bonus += 2.0f;
        }
        return bonus;
    }
}

public class WeaponShooter : MonoBehaviour {
    public WeaponAssembly currentWeapon;
    
    public void Fire() {
        if (currentWeapon == null) return;
        
        // 根据发射器类型决定发射方式
        switch (currentWeapon.emitter.type) {
            case EmitterType.Single:
                FireSingle();
                break;
            case EmitterType.Spread:
                FireSpread();
                break;
            case EmitterType.Ring:
                FireRing();
                break;
            case EmitterType.Wave:
                FireWave();
                break;
        }
    }
    
    void FireSingle() {
        SpawnProjectile(transform.forward);
    }
    
    void FireSpread() {
        int count = currentWeapon.emitter.projectileCount;
        float angle = currentWeapon.emitter.spreadAngle;
        
        for (int i = 0; i < count; i++) {
            float currentAngle = angle * (i - count / 2);
            Vector3 direction = Quaternion.Euler(0, currentAngle, 0) * transform.forward;
            SpawnProjectile(direction);
        }
    }
    
    void FireRing() {
        int count = currentWeapon.emitter.projectileCount;
        float angleStep = 360f / count;
        
        for (int i = 0; i < count; i++) {
            float currentAngle = angleStep * i;
            Vector3 direction = Quaternion.Euler(0, currentAngle, 0) * transform.forward;
            SpawnProjectile(direction);
        }
    }
    
    void FireWave() {
        // 生成一道波浪（使用粒子系统或特殊碰撞体）
        GameObject wave = Instantiate(currentWeapon.projectile.prefab);
        wave.transform.position = transform.position;
        wave.transform.forward = transform.forward;
    }
    
    void SpawnProjectile(Vector3 direction) {
        GameObject proj = Instantiate(currentWeapon.projectile.prefab);
        proj.transform.position = transform.position;
        
        Projectile projScript = proj.GetComponent<Projectile>();
        projScript.damage = currentWeapon.CalculateDamage();
        projScript.effects = currentWeapon.effects;
        projScript.Launch(direction);
    }
}

// 弹药脚本
public class Projectile : MonoBehaviour {
    public int damage;
    public List<EffectPart> effects;
    
    public void Launch(Vector3 direction) {
        GetComponent<Rigidbody>().velocity = direction * 10f;
        
        // 检查是否有追踪效果
        foreach (var effect in effects) {
            if (effect.type == EffectType.Homing) {
                gameObject.AddComponent<HomingBehavior>();
            }
        }
    }
    
    void OnTriggerEnter(Collider other) {
        if (other.CompareTag("Enemy")) {
            Enemy enemy = other.GetComponent<Enemy>();
            enemy.TakeDamage(damage);
            
            // 应用效果
            ApplyEffects(other.transform.position);
            
            Destroy(gameObject);
        }
    }
    
    void ApplyEffects(Vector3 hitPosition) {
        foreach (var effect in effects) {
            switch (effect.type) {
                case EffectType.Explosion:
                    CreateExplosion(hitPosition, effect.effectValue);
                    break;
                case EffectType.Split:
                    SplitProjectile(hitPosition, (int)effect.effectValue);
                    break;
                case EffectType.Pierce:
                    // 穿透逻辑（不销毁弹药）
                    break;
            }
        }
    }
    
    void CreateExplosion(Vector3 position, float radius) {
        Collider[] enemies = Physics.OverlapSphere(position, radius);
        foreach (var col in enemies) {
            if (col.CompareTag("Enemy")) {
                col.GetComponent<Enemy>().TakeDamage(damage / 2);
            }
        }
    }
    
    void SplitProjectile(Vector3 position, int count) {
        for (int i = 0; i < count; i++) {
            float angle = (360f / count) * i;
            Vector3 direction = Quaternion.Euler(0, angle, 0) * Vector3.forward;
            
            GameObject subProj = Instantiate(gameObject);
            subProj.transform.position = position;
            subProj.GetComponent<Projectile>().Launch(direction);
        }
    }
}

发射器: 单发
弹道: 火球
效果: 爆炸 (传说) + 分裂 (史诗)

发射器: 单发 (传说，射速 +200%)
弹道: 闪电
效果: 穿透

发射器: 环形 (8发)
弹道: 冰锥
效果: 冻结 + 减速