紫气球 (Purple Bloon): 免疫能量、魔法、等离子
铅气球 (Lead Bloon):   免疫锐利、能量
斑马气球 (Zebra):     免疫爆炸、冰冻
彩虹气球 (Rainbow):   无特殊免疫
陶瓷气球 (Ceramic):   无特殊免疫
MOAB级:              免疫冰冻、击退
DDT:                 紫+铅+黑+迷彩属性
BAD:                 几乎无免疫

遇到免疫气球 → 困惑/失败 → 学习新知识 → 尝试新策略 → 成功过关
     ↑                                              ↓
   长期留存 ←  深度策略体验 ←  建造多样性 ←  解锁新塔

using UnityEngine;

[System.Flags]
public enum BloonProperties
{
    None = 0,
    Black = 1 << 0,      // 免疫爆炸
    White = 1 << 1,     // 免疫冰冻
    Purple = 1 << 2,   // 免疫能量、魔法、等离子
    Lead = 1 << 3,      // 免疫锐利、能量
    Camo = 1 << 4,      // 需要迷彩侦测
    Regrow = 1 << 5,    // 会再生
    Fortified = 1 << 6, // 强化装甲
    MoabClass = 1 << 7  // MOAB级别
}

public enum DamageType
{
    Sharp,      // 锐利
    Explosion,  // 爆炸
    Energy,     // 能量
    Magic,      // 魔法
    Fire,       // 火焰
    Plasma,     // 等离子
    Projectile, // 弹丸
    Impact,     // 撞击
    Normal      // 普通
}

public class DamageInfo
{
    public DamageType damageType;
    public float amount;
    public bool canHitCamo;
    public bool canHitLead;

    public DamageInfo(DamageType type, float amount)
    {
        this.damageType = type;
        this.amount = amount;
        this.canHitCamo = false;
        this.canHitLead = false;
    }
}

public class Bloon : MonoBehaviour
{
    [SerializeField] private BloonProperties properties;
    [SerializeField] private float health = 1.0f;
    [SerializeField] private GameObject[] childrenPrefabs; // 子气球预制体

    private static readonly Dictionary<DamageType, BloonProperties> immunityMatrix =
        new Dictionary<DamageType, BloonProperties>()
    {
        { DamageType.Explosion, BloonProperties.Black },
        { DamageType.Energy, BloonProperties.Lead | BloonProperties.Purple },
        { DamageType.Magic, BloonProperties.Purple },
        { DamageType.Plasma, BloonProperties.Purple },
        { DamageType.Sharp, BloonProperties.Lead }
    };

    public void TakeDamage(DamageInfo damageInfo)
    {
        // 检查免疫关系
        if (IsImmuneTo(damageInfo.damageType))
        {
            ShowImmuneEffect(damageInfo.damageType);
            return; // 0伤害！
        }

        // 检查迷彩侦测
        if (HasProperty(BloonProperties.Camo) && !damageInfo.canHitCamo)
        {
            ShowMissEffect(); // 未命中迷彩气球
            return;
        }

        // 应用伤害
        health -= damageInfo.amount;
        ShowDamageEffect(damageInfo.amount);

        if (health <= 0)
        {
            PopBloon();
        }
    }

    private bool IsImmuneTo(DamageType damageType)
    {
        if (immunityMatrix.ContainsKey(damageType))
        {
            BloonProperties requiredImmunity = immunityMatrix[damageType];
            return (properties & requiredImmunity) != 0;
        }
        return false;
    }

    private bool HasProperty(BloonProperties property)
    {
        return (properties & property) != 0;
    }

    private void ShowImmuneEffect(DamageType damageType)
    {
        // 显示免疫特效
        // 播放"叮"的音效
        // 显示"0"伤害数字
        Debug.Log($"{name} 免疫了 {damageType} 伤害！");

        // 视觉反馈：显示免疫图标
        ShowFloatingIcon(GetImmunityIcon(damageType));
    }

    private void ShowFloatingIcon(Sprite icon)
    {
        // 在气球上方显示免疫图标
        // 使用DOTween上浮渐隐
    }

    private Sprite GetImmunityIcon(DamageType damageType)
    {
        // 根据伤害类型返回对应的免疫图标
        return null; // 实际项目中加载对应图标
    }

    private void PopBloon()
    {
        // 播放爆破音效
        // 显示爆破特效
        // 生成子气球（如果有）
        SpawnChildren();

        // 奖励金钱
        GameManager.Instance.AddMoney(GetRewardAmount());

        // 销毁当前气球
        Destroy(gameObject);
    }

    private void SpawnChildren()
    {
        if (childrenPrefabs != null && childrenPrefabs.Length > 0)
        {
            foreach (GameObject childPrefab in childrenPrefabs)
            {
                // 随机位置生成子气球
                Vector3 randomOffset = new Vector3(
                    Random.Range(-0.5f, 0.5f),
                    0,
                    Random.Range(-0.5f, 0.5f)
                );

                Instantiate(childPrefab, transform.position + randomOffset, Quaternion.identity);
            }
        }
    }

    private int GetRewardAmount()
    {
        // 根据气球类型返回奖励金额
        return 1; // 基础奖励
    }
}

public abstract class Tower : MonoBehaviour
{
    [SerializeField] protected DamageInfo baseDamageInfo;
    [SerializeField] protected float attackRange = 30f;
    [SerializeField] protected float attackSpeed = 1f;

    protected virtual void Attack(Bloon target)
    {
        // 创建伤害信息副本（允许升级修改）
        DamageInfo damage = new DamageInfo(
            baseDamageInfo.damageType,
            baseDamageInfo.amount
        );

        // 应用塔的升级效果
        ApplyUpgrades(ref damage);

        // 造成伤害
        target.TakeDamage(damage);

        // 播放攻击动画和音效
        PlayAttackEffects();
    }

    protected virtual void ApplyUpgrades(ref DamageInfo damage)
    {
        // 基础塔没有升级，子类重写此方法
    }

    protected virtual bool CanTargetBloon(Bloon bloon)
    {
        // 检查是否能攻击迷彩气球
        if (bloon.HasProperty(BloonProperties.Camo) && !damageInfo.canHitCamo)
        {
            return false;
        }

        // 检查是否在射程内
        float distance = Vector3.Distance(transform.position, bloon.transform.position);
        return distance <= attackRange;
    }
}

// 具体塔实现示例：炸弹塔
public class BombTower : Tower
{
    [SerializeField] private float explosionRadius = 15f;
    [SerializeField] private GameObject explosionEffect;

    protected override void Awake()
    {
        base.Awake();
        // 炸弹塔造成爆炸伤害
        baseDamageInfo = new DamageInfo(DamageType.Explosion, 2.0f);
        baseDamageInfo.canHitCamo = false; // 初始不能攻击迷彩
        baseDamageInfo.canHitLead = true;  // 可以击破铅气球
    }

    protected override void Attack(Bloon target)
    {
        // 炸弹塔造成范围伤害
        Collider[] hitColliders = Physics.OverlapSphere(
            target.transform.position,
            explosionRadius,
            LayerMask.GetMask("Bloons")
        );

        foreach (Collider hitCollider in hitColliders)
        {
            Bloon bloon = hitCollider.GetComponent<Bloon>();
            if (bloon != null && CanTargetBloon(bloon))
            {
                bloon.TakeDamage(baseDamageInfo);
            }
        }

        // 显示爆炸效果
        ShowExplosionEffect(target.transform.position);
    }

    private void ShowExplosionEffect(Vector3 position)
    {
        if (explosionEffect != null)
        {
            GameObject effect = Instantiate(explosionEffect, position, Quaternion.identity);
            Destroy(effect, 2f); // 2秒后销毁特效
        }
    }
}

物理伤害: 锐利、撞击、弹丸 → 受护甲减免
元素伤害: 火焰、冰霜、闪电 → 受抗性减免
混沌伤害: 特殊机制 → 无视防御

主角武器附魔 → 为附近塔提供额外伤害类型
塔的特殊效果 → 为主角创造攻击机会
人塔配合 → 突破单一伤害类型限制

词缀系统: "你的攻击额外造成火焰伤害"
突破机制: "无视敌人50%火焰抗性"
策略深度: 根据敌人类型调整Build方向

=IF(AND(B$1="铅气球", $A2="锐利"), "免疫",
   IF(AND(B$1="紫气球", OR($A2="能量", $A2="魔法", $A2="等离子")), "免疫",
   IF(AND(B$1="黑气球", $A2="爆炸"), "免疫", "有效")))

#if UNITY_EDITOR
[CustomEditor(typeof(Bloon))]
public class BloonEditor : Editor
{
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();

        Bloon bloon = (Bloon)target;

        EditorGUILayout.Space();
        EditorGUILayout.LabelField("免疫分析", EditorStyles.boldLabel);

        DamageType[] allDamageTypes = (DamageType[])System.Enum.GetValues(typeof(DamageType));

        foreach (DamageType damageType in allDamageTypes)
        {
            bool isImmune = bloon.IsImmuneTo(damageType);
            EditorGUILayout.LabelField($"{damageType}: {(isImmune ? "❌ 免疫" : "✅ 有效")}");
        }
    }
}
#endif