Beispiel #1
0
    void ApplyToTile(int tile, Effect effect)
    {
        // Get list of valid tiles
        List <int> targetTiles;

        if (areaOfEffect)
        {
            targetTiles = Battleground.Instance.GetTilesFromShape(targetArea, tile);
        }
        else
        {
            targetTiles = new List <int> {
                tile
            }
        };

        Debug.Log("tiles number: " + targetTiles.Count);
        switch (effect.effectType)
        {
        case EffectType.Miasma:


            // Spawn miasma on tiles
            foreach (int t in targetTiles)
            {
                MiasmaFieldEffect miasma = new MiasmaFieldEffect(effect.effectValue, effect.duration, owner, t);
                Battleground.Instance.AddFieldEffect(t, miasma);
            }
            break;

        case EffectType.Damage:
            float mult = 1.00f;
            for (int i = owner.Statuses.Count - 1; i >= 0; i--)
            {
                BaseStatus status = owner.Statuses[i];
                if (status.GetType() == typeof(DamageMultiplierStatus))
                {
                    mult += status.Multiplier;

                    // Remove multiplier status
                    // TODO change if the status can have more than 1 use
                }
            }
            foreach (int t in targetTiles)
            {
                BaseUnit target = Battleground.Instance.GetUnitOnTile(t);

                if (target == null)
                {
                    continue;
                }
                if (ParseTargetType(TargetType.Enemy, target.IsPlayer()))
                {
                    int damage = (int)Math.Round(effect.effectValue * mult);
                    target.DealDamage(damage, owner);

                    owner.RemoveStatusOfType(typeof(DamageMultiplierStatus));
                    owner.UpdateUI();

                    // Add threat to player units
                    if (owner.IsPlayer())
                    {
                        PartyManager.Instance.ChangeThreat(owner, damage * 0.01f);
                    }
                }
            }
            break;
        }
    }

    void ApplyToTargets(BaseUnit[] targets, Effect effect)
    {
        Debug.Log("Applying effects");

        // Apply effects to specifically targeted units (dragged card onto or put AoE targeter on).
        switch (effect.effectType)
        {
        case EffectType.Damage:
            foreach (BaseUnit target in targets)
            {
                if (ParseTargetType(effect.targetType, target.IsPlayer()))
                {
                    float mult = 1.00f;
                    for (int i = owner.Statuses.Count - 1; i >= 0; i--)
                    {
                        BaseStatus status = owner.Statuses[i];
                        if (status.GetType() == typeof(DamageMultiplierStatus))
                        {
                            mult += status.Multiplier;

                            // Remove multiplier status
                            // TODO change if the status can have more than 1 use
                            owner.RemoveStatusOfType(status.GetType());
                            owner.UpdateUI();
                        }
                    }

                    int damage = (int)Math.Round(effect.effectValue * mult);
                    target.DealDamage(damage, owner);

                    // Add threat to player units
                    if (owner.IsPlayer())
                    {
                        PartyManager.Instance.ChangeThreat(owner, damage * 0.01f);
                    }
                }
            }
            break;

        case EffectType.Block:
            foreach (BaseUnit target in targets)
            {
                if (ParseTargetType(effect.targetType, target.IsPlayer()))
                {
                    BlockStatus blockStatus = new BlockStatus(effect.effectValue, effect.duration, owner, owner);
                    target.AddStatus(blockStatus);
                }
            }
            break;

        case EffectType.Taunt:
            foreach (BaseUnit target in targets)
            {
                if (ParseTargetType(effect.targetType, target.IsPlayer()))
                {
                    TauntStatus taunt = new TauntStatus(effect.duration, owner, target);
                    target.AddStatus(taunt);
                }
            }
            break;

        case EffectType.Stun:
            foreach (BaseUnit target in targets)
            {
                if (ParseTargetType(effect.targetType, target.IsPlayer()))
                {
                    StunStatus stun = new StunStatus(effect.duration, owner, target);
                    target.AddStatus(stun);
                }
            }
            break;

        case EffectType.Push:
            foreach (BaseUnit target in targets)
            {
                if (ParseTargetType(effect.targetType, target.IsPlayer()))
                {
                    // check if not on last col
                    List <int> pushTiles = Battleground.Instance.FindEmptyTileNear(target.GetGridPosition());
                    if (pushTiles.Count < 1)
                    {
                        return;
                    }
                    int nextPos = pushTiles[UnityEngine.Random.Range(0, pushTiles.Count)];
                    target.MoveToTile(nextPos);

                    if (owner.IsPlayer())
                    {
                        PartyManager.Instance.ChangeThreat(owner, 0.05f);
                    }
                }
            }
            break;

        case EffectType.SummonVoodoo:
            foreach (BaseUnit target in targets)
            {
                if (ParseTargetType(effect.targetType, target.IsPlayer()))
                {
                    // Create voodoo unit
                    GameObject voodooPrefab = Resources.Load <GameObject>("Prefabs/Units/Voodoo");
                    Debug.Log(voodooPrefab);
                    BaseUnit   voodoo      = Instantiate(voodooPrefab).GetComponent <BaseUnit>();
                    List <int> voodooTiles = Battleground.Instance.FindEmptyTileNear(target.GetGridPosition());
                    int        voodooPos   = voodooTiles[UnityEngine.Random.Range(0, voodooTiles.Count)];
                    Battleground.Instance.PlaceUnitAt(voodoo, voodooPos);

                    // Add status to transfer damage
                    HealthLinkStatus healthLinkstatus = new HealthLinkStatus(1.0f, owner, target);
                    voodoo.AddStatus(healthLinkstatus);
                }
            }
            break;

        case EffectType.Weakness:
            foreach (BaseUnit target in targets)
            {
                if (ParseTargetType(effect.targetType, target.IsPlayer()))
                {
                    WeaknessStatus weaknessStatus = new WeaknessStatus(0.01f * effect.effectValue, effect.duration, owner, target);
                    target.AddStatus(weaknessStatus);
                }
            }
            break;
        }
    }
Beispiel #2
0
    /// <summary>
    /// 创建状态
    /// </summary>
    /// <param name="Core">雷达拥有者的核心信息</param>
    /// <param name="f">雷达拥有视野</param>
    public static StatusM Create(int SceneID, int ResalseSceneID, int SkillID, SkillStatusInfo Info)
    {
        if (Info == null)
        {
            return(null);
        }
        StatusType s      = (StatusType)Info.m_type;
        StatusM    status = null;

        switch (s)
        {
        case StatusType.AddAttr:
            status = new AddAttrStatus();
            break;

        case StatusType.Vertigo:
            status = new VertigoStatus();
            break;

        case StatusType.Silence:
            status = new SilenceStatus();
            break;

        case StatusType.Vampire:
            status = new VampireStatus();
            break;

        case StatusType.Rebound:
            status = new ReboundStatus();
            break;

        case StatusType.Invisible:
            status = new InvisibleStatus();
            break;

        case StatusType.Invincible:
            status = new InvincibleStatus();
            break;

        case StatusType.Transfiguration:
            status = new TransfigurationStatus();
            break;

        case StatusType.Summon:
            status = new SummonStatus();
            break;

        case StatusType.ClickFly:
            status = new ClickFlyStatus();
            break;

        case StatusType.AbsorbDamage:
            status = new AbsorbDamageStatus();
            break;

        case StatusType.Virtual:
            status = new VirtualStatus();
            break;

        case StatusType.Shield:
            status = new ShieldStatus();
            break;

        case StatusType.Sputtering:
            status = new SputteringStatus();
            break;

        case StatusType.Damnation:
            status = new DamnationStatus();
            break;

        case StatusType.ImmunePhysical:
            status = new ImmunePhysicalStatus();
            break;

        case StatusType.ImmunityMagic:
            status = new ImmunityMagicStatus();
            break;

        case StatusType.IceBuild:
            status = new IceBuildStatus();
            break;

        case StatusType.Ring:
            status = new RingStatus();
            break;

        case StatusType.Taunt:
            status = new TauntStatus();
            break;

        case StatusType.StaticElec:
            status = new StaticElecStatus();
            break;

        case StatusType.Still:
            status = new StillStatus();
            break;

        case StatusType.Squash:
            status = new SquashStatus();
            break;

        case StatusType.Sauna:
            status = new SaunaStatus();
            break;

        case StatusType.KTV:
            status = new KTVStatus();
            break;

        case StatusType.ImmuneState:
            status = new ImmuneState();
            break;

        case StatusType.NoSquash:
            status = new NoSquashStatus();
            break;

        case StatusType.paralysis:
            status = new ParalysisStatus();
            break;

        case StatusType.PhyAnitInterrupt:
            status = new PhyAnitInterruptStatus();
            break;

        case StatusType.MagAnitInterrupt:
            status = new MagAnitInterruptStatus();
            break;

        case StatusType.Cleanse:
            status = new CleanseStatus();
            break;

        case StatusType.Charm:
            status = new CharmStatus();
            break;

        case StatusType.BuildDestory:
            status = new BuildDestoryStatus();
            break;

        case StatusType.Mark:
            status = new MarkStatus();
            break;

        case StatusType.RunAway:
            status = new RunAwayStaus();
            break;

        case StatusType.FakeTaunt:
            status = new FakeTauntStatus();
            break;

        case StatusType.Die:
            status = new DieStatus();
            break;

        case StatusType.Turn:
            status = new TurnStatus();
            break;

        case StatusType.WetBody:
            status = new WetBodyStatus();
            break;

        case StatusType.Berserker:
            status = new BerserkerStatus();
            break;

        case StatusType.Paralyze:
            status = new ParalyzeStatus();
            break;

        case StatusType.DieMark:
            status = new DieMarkStatus();
            break;

        case StatusType.Sleep:
            status = new SleepStatus();
            break;

        case StatusType.TearOfMermaid:
            status = new TearOfMermaidStatus();
            break;

        case StatusType.Trapped:
            status = new TrapedStatus();
            break;

        case StatusType.KickedBack:
            status = new KickedBackStatus();
            break;

        case StatusType.WhipCorpse:
            status = new WhipCorpseStatus();
            break;

        case StatusType.FireShield:
            status = new FireShieldStatus();
            break;

        default:
            break;
        }
        return(status);
    }