Example #1
0
 protected void PerformAttack()
 {
     character.CurLife -= Damage;
     if (character.CurLife <= 0)
     {
         character.Death();
         PerformExp();
         character = null;
     }
 }
Example #2
0
    /// <summary>
    /// 使う全般
    /// </summary>
    public bool CommonUseItemCustom(ManageDungeon dun, BaseCharacter center, BaseCharacter player)
    {
        //サウンドを鳴らす
        SoundInformation.Sound.Play(SoundInformation.SoundType.Recover);

        //範囲拡大がついているとき
        int   plus;
        float cf;
        int   dist = 0;

        if (CommonFunction.HasOptionType(this.Options, OptionType.Wildfire, out plus, out cf) == true)
        {
            dist = plus;
        }
        dun.SetUpCharacterMap();
        List <BaseCharacter> targets = dun.GetNearCharacters(center.CurrentPoint, dist, true);

        foreach (BaseCharacter target in targets)
        {
            //満腹度の回復
            if (SatRecoverPoint > 0)
            {
                if (typeof(PlayerCharacter) == target.GetType())
                {
                    float satRecoverPoint = SatRecoverPoint;

                    //効果増幅があったら
                    if (CommonFunction.HasOptionType(this.Options, OptionType.EffectUp, out plus, out cf) == true)
                    {
                        satRecoverPoint = satRecoverPoint + plus * cf;
                    }
                    if (CommonFunction.HasOptionType(this.Options, OptionType.EffectDown, out plus, out cf) == true)
                    {
                        satRecoverPoint = satRecoverPoint - plus * cf;
                    }
                    //ダメージ増減30%
                    float rand = 0.3f;
                    if (CommonFunction.HasOptionType(this.Options, OptionType.EffectStabile, out plus, out cf) == true)
                    {
                        rand -= cf * plus;
                    }
                    else if (CommonFunction.HasOptionType(this.Options, OptionType.EffectNotStabile, out plus, out cf) == true)
                    {
                        rand += cf * plus;
                    }
                    satRecoverPoint += Mathf.CeilToInt(UnityEngine.Random.Range(-rand * satRecoverPoint, rand * satRecoverPoint));


                    //減少判定の時
                    if (CommonFunction.HasOptionType(this.Options, OptionType.ReverceDamage) == true)
                    {
                        ((PlayerCharacter)target).ReduceSatiety(satRecoverPoint);
                        DisplayInformation.Info.AddMessage(
                            string.Format(CommonConst.Message.TrapCroquette2, target.DisplayNameInMessage));
                    }
                    //通常回復判定のとき
                    else
                    {
                        ((PlayerCharacter)target).AddSatiety(satRecoverPoint);
                        if (((PlayerCharacter)target).IsSatietyMax == true)
                        {
                            DisplayInformation.Info.AddMessage(
                                string.Format(CommonConst.Message.RecoverSatietyMax));
                        }
                        else
                        {
                            DisplayInformation.Info.AddMessage(
                                string.Format(CommonConst.Message.RecoverSatiety));
                        }
                    }
                }
            }
            //HPの回復
            if (HpRecoverPoint > 0)
            {
                //ダメージ追加
                int damage = Mathf.FloorToInt(HpRecoverPoint / (center.CurrentPoint.DistanceAbs(target.CurrentPoint) + 1));

                //効果増幅があったら
                if (CommonFunction.HasOptionType(this.Options, OptionType.EffectUp, out plus, out cf) == true)
                {
                    damage = damage + plus * (int)cf;
                }
                if (CommonFunction.HasOptionType(this.Options, OptionType.EffectDown, out plus, out cf) == true)
                {
                    damage = damage - plus * (int)cf;
                }
                //ダメージ増減30%
                float rand = 0.3f;
                if (CommonFunction.HasOptionType(this.Options, OptionType.EffectStabile, out plus, out cf) == true)
                {
                    rand -= cf * plus;
                }
                else if (CommonFunction.HasOptionType(this.Options, OptionType.EffectNotStabile, out plus, out cf) == true)
                {
                    rand += cf * plus;
                }
                damage += Mathf.CeilToInt(UnityEngine.Random.Range(-rand * damage, rand * damage));


                //減少判定の時
                if (CommonFunction.HasOptionType(this.Options, OptionType.ReverceDamage) == true)
                {
                    AttackState atState = target.AddDamage(damage);

                    //ダメージエフェクト
                    EffectDamage d = EffectDamage.CreateObject(target);
                    d.SetText(damage.ToString(), AttackState.Hit);
                    d.Play();

                    //ヒットメッセージ
                    DisplayInformation.Info.AddMessage(
                        target.GetMessageAttackHit(damage));

                    //対象が死亡したら
                    if (atState == AttackState.Death)
                    {
                        DisplayInformation.Info.AddMessage(
                            target.GetMessageDeath(target.HaveExperience));
                        if (target.Type == ObjectType.Player)
                        {
                            ScoreInformation.Info.CauseDeath =
                                string.Format(CommonConst.DeathMessage.Item, this.DisplayNameNormal);

                            ScoreInformation.Info.CauseDeathType = DeathCouseType.Item;

                            target.Death();
                        }
                        else
                        {
                            player.Death(target, player.AttackInfo);
                        }
                        target.DeathAction(dun);
                    }
                }
                //通常回復判定のとき
                else
                {
                    target.RecoverHp(HpRecoverPoint);

                    DisplayInformation.Info.AddMessage(
                        string.Format(CommonConst.Message.RecoverHp, target.DisplayNameInMessage));

                    //回復エフェクト
                    EffectDamage d = EffectDamage.CreateObject(target);
                    d.SetText(HpRecoverPoint.ToString(), AttackState.Heal);
                    d.Play();
                }
            }

            //Power回復
            if (CommonFunction.HasOptionType(this.Options, OptionType.RecoverPower) == true)
            {
                if (target.RecoverPowerNotMaxup(1) == true)
                {
                    DisplayInformation.Info.AddMessage(
                        string.Format(CommonConst.Message.RecoverPower, target.DisplayNameInMessage));
                }
            }
        }
        //状態異常の付与
        EffectAbnormal(targets);

        return(true);
    }
Example #3
0
    public bool Invocate(ManageDungeon dun)
    {
        if (IsInvocation == false)
        {
            return(false);
        }
        IsActive     = true;
        IsInvocation = false;
        int bresult;

        //オプションによるトラップ回避
        float t = 0;

        foreach (BaseOption o in Target.Options)
        {
            t += o.DexTrap();
        }

        if (CommonFunction.IsRandom(t) == true)
        {
            DisplayInformation.Info.AddMessage(CommonConst.Message.DexTrap);
            Target = null;
            return(false);
        }

        //スコア値の更新
        DungeonHistoryInformation.Info.iTrapInvokeCount++;

        //サウンドを鳴らす
        if (Target.Type == ObjectType.Player)
        {
            VoiceInformation.Voice.Play(PlayerInformation.Info.PType, VoiceInformation.Voice.PlayRandomDefence());
        }

        bool result = false;

        //効果発動
        switch (TType)
        {
        case TrapType.Bomb:

            //サウンドを鳴らす
            SoundInformation.Sound.Play(SoundInformation.SoundType.Bomb);

            //エフェクトの発動
            EffectBigBang.CreateObject(this).Play();

            //ダメージ処理
            int         damage  = Mathf.CeilToInt(Target.CurrentHp / PerPlayerDamage);
            AttackState atState = Target.AddDamage(damage);

            //プレイヤーが死亡したら
            if (atState == AttackState.Death)
            {
                DisplayInformation.Info.AddMessage(
                    Target.GetMessageDeath(Target.HaveExperience));

                ScoreInformation.Info.CauseDeath =
                    string.Format(CommonConst.DeathMessage.Trap, DisplayNameNormal);
                ScoreInformation.Info.CauseDeathType = DeathCouseType.Trap;

                Target.Death();
                Target.DeathAction(dun);
            }


            //ダメージエフェクト
            EffectDamage d = EffectDamage.CreateObject(Target);
            d.SetText(damage.ToString(), AttackState.Hit);
            d.Play();

            //ヒットメッセージ
            DisplayInformation.Info.AddMessage(
                Target.GetMessageAttackHit(damage));

            //周辺キャラのダメージ処理
            dun.SetUpCharacterMap();
            List <BaseCharacter> list = dun.GetNearCharacters(this.CurrentPoint, 1);
            foreach (BaseCharacter c in list)
            {
                atState = c.AddDamage(CommonNumber);
                EffectDamage d2 = EffectDamage.CreateObject(c);
                d2.SetText(CommonNumber.ToString(), AttackState.Hit);
                d2.Play();

                //対象が死亡したら
                if (atState == AttackState.Death)
                {
                    DisplayInformation.Info.AddMessage(
                        string.Format(CommonConst.Message.DeathCommon, c.DisplayNameInMessage));

                    c.Death();
                    c.DeathAction(dun);
                }
            }
            result = true;
            break;

        case TrapType.ColorMonitor:

            //サウンドを鳴らす
            SoundInformation.Sound.Play(SoundInformation.SoundType.Smoke);

            //エフェクトの発動
            EffectColorMonitor.CreateObject(this).Play();

            //効果
            bresult = Target.AddStateAbnormal((int)StateAbnormal.StiffShoulder);
            //対象が異常になったらメッセージを表示
            if (bresult != 0)
            {
                DisplayInformation.Info.AddMessage(
                    CommonFunction.GetAbnormalMessage(StateAbnormal.StiffShoulder, Target));
            }
            result = true;
            break;

        case TrapType.Cyclone:

            //サウンドを鳴らす
            SoundInformation.Sound.Play(SoundInformation.SoundType.Cyclone);

            //エフェクトの発動
            EffectCyclone.CreateObject(Target).Play();

            //メッセージの出力
            DisplayInformation.Info.AddMessage(
                string.Format(CommonConst.Message.TrapCyclone2, Target.DisplayNameInMessage));

            //効果

            result = true;
            break;

        case TrapType.Electric:

            //サウンドを鳴らす
            SoundInformation.Sound.Play(SoundInformation.SoundType.ElectricTrap);

            //エフェクトの発動
            EffectThunder.CreateObject(Target).Play();

            BaseItem[] equips = PlayerCharacter.ItemList.FindAll(i => i.IsEquip == true).ToArray();

            if (equips.Length > 0)
            {
                foreach (BaseItem i in equips)
                {
                    i.ForceRemoveEquip(Target);
                }

                DisplayInformation.Info.AddMessage(
                    string.Format(CommonConst.Message.TrapEquipRemove, Target.DisplayNameInMessage));
            }

            result = true;
            break;

        case TrapType.Mud:

            //サウンドを鳴らす
            SoundInformation.Sound.Play(SoundInformation.SoundType.Smoke);

            //エフェクトの発動
            EffectBadSmoke.CreateObject(Target).Play();

            //効果
            bresult = Target.AddStateAbnormal((int)StateAbnormal.Slow);
            //対象が異常になったらメッセージを表示
            if (bresult != 0)
            {
                DisplayInformation.Info.AddMessage(
                    CommonFunction.GetAbnormalMessage(StateAbnormal.Slow, Target));
            }
            result = true;
            break;

        case TrapType.Palalysis:

            //サウンドを鳴らす
            SoundInformation.Sound.Play(SoundInformation.SoundType.Smoke);

            //エフェクトの発動
            EffectBadSmoke.CreateObject(Target).Play();

            //効果
            bresult = Target.AddStateAbnormal((int)StateAbnormal.Palalysis);
            //対象が異常になったらメッセージを表示
            if (bresult != 0)
            {
                DisplayInformation.Info.AddMessage(
                    CommonFunction.GetAbnormalMessage(StateAbnormal.Palalysis, Target));
            }
            result = true;
            break;

        case TrapType.Photo:
            if (Target.Type == ObjectType.Player)
            {
                //サウンドを鳴らす
                SoundInformation.Sound.Play(SoundInformation.SoundType.Smoke);

                //エフェクトの発動
                EffectBadSmoke.CreateObject(Target).Play();

                //メッセージの出力
                DisplayInformation.Info.AddMessage(
                    string.Format(CommonConst.Message.TrapCroquette2, Target.DisplayNameInMessage));

                ((PlayerCharacter)Target).ReduceSatiety(CommonNumber);
                result = true;
            }
            break;

        case TrapType.Poison:

            //サウンドを鳴らす
            SoundInformation.Sound.Play(SoundInformation.SoundType.Smoke);

            //エフェクトの発動
            EffectBadSmoke.CreateObject(Target).Play();

            //効果
            bresult = Target.AddStateAbnormal((int)StateAbnormal.Poison);
            //対象が異常になったらメッセージを表示
            if (bresult != 0)
            {
                DisplayInformation.Info.AddMessage(
                    CommonFunction.GetAbnormalMessage(StateAbnormal.Poison, Target));
            }

            result = true;
            break;

        case TrapType.DeadlyPoison:

            //サウンドを鳴らす
            SoundInformation.Sound.Play(SoundInformation.SoundType.Smoke);

            //エフェクトの発動
            EffectBadSmoke.CreateObject(Target).Play();

            //効果
            bresult = Target.AddStateAbnormal((int)StateAbnormal.DeadlyPoison);
            //対象が異常になったらメッセージを表示
            if (bresult != 0)
            {
                DisplayInformation.Info.AddMessage(
                    CommonFunction.GetAbnormalMessage(StateAbnormal.DeadlyPoison, Target));
            }

            result = true;
            break;

        case TrapType.Rotation:

            //サウンドを鳴らす
            SoundInformation.Sound.Play(SoundInformation.SoundType.Rotation);

            //エフェクトの発動
            EffectRotation.CreateObject(Target).Play();

            //効果
            bresult = Target.AddStateAbnormal((int)StateAbnormal.Confusion);
            //対象が異常になったらメッセージを表示
            if (bresult != 0)
            {
                EffectSmoke.CreateObject(Target);
                DisplayInformation.Info.AddMessage(
                    CommonFunction.GetAbnormalMessage(StateAbnormal.Confusion, Target));
            }


            result = true;
            break;

        case TrapType.SandStorm:

            //サウンドを鳴らす
            SoundInformation.Sound.Play(SoundInformation.SoundType.Cyclone);

            //エフェクトの発動
            EffectSandStorm.CreateObject(Target).Play();

            //効果
            bresult = Target.AddStateAbnormal((int)StateAbnormal.Dark);
            //対象が異常になったらメッセージを表示
            if (bresult != 0)
            {
                DisplayInformation.Info.AddMessage(
                    CommonFunction.GetAbnormalMessage(StateAbnormal.Dark, Target));
            }
            result = true;
            break;

        case TrapType.Song:

            //サウンドを鳴らす
            SoundInformation.Sound.Play(SoundInformation.SoundType.Smoke);

            //エフェクトの発動
            EffectBadSmoke.CreateObject(Target).Play();

            //効果
            bresult = Target.AddStateAbnormal((int)StateAbnormal.Sleep);
            //対象が異常になったらメッセージを表示
            if (bresult != 0)
            {
                DisplayInformation.Info.AddMessage(
                    CommonFunction.GetAbnormalMessage(StateAbnormal.Sleep, Target));
            }
            result = true;
            break;

        case TrapType.Summon:

            //サウンドを鳴らす
            SoundInformation.Sound.Play(SoundInformation.SoundType.Summon);

            //エフェクトの発動
            EffectSummon.CreateObject(Target).Play();

            int cnt = CommonFunction.ConvergenceRandom(CountStart, ProbStart, ProbReduce);

            for (int i = 0; i < cnt; i++)
            {
                dun.SetUpCharacterMap();
                //敵の出現地点を取得
                MapPoint mp = dun.GetCharacterEmptyTarget(Target.CurrentPoint);
                if (CommonFunction.IsNull(mp) == true)
                {
                    break;
                }

                int  enemytype           = TableEnemyMap.GetValue(dun.DungeonObjNo, DisplayInformation.Info.Floor);
                uint rand                = CommonFunction.GetRandomUInt32();
                BaseEnemyCharacter enemy = TableEnemyIncidence.GetEnemy(enemytype, rand, DisplayInformation.Info.Floor);

                enemy.SetCharacterDisplayObject(mp.X, mp.Y);
                dun.AddNewCharacter(enemy);
            }
            DisplayInformation.Info.AddMessage(
                CommonConst.Message.TrapSummon);

            result = true;
            break;

        case TrapType.TheFly:

            if (Target.Type == ObjectType.Player)
            {
                //サウンドを鳴らす
                SoundInformation.Sound.Play(SoundInformation.SoundType.Smoke);

                //エフェクトの発動
                EffectBadSmoke.CreateObject(Target).Play();

                BaseItem[] foods = PlayerCharacter.ItemList.FindAll(i => i.IType == ItemType.Food).ToArray();

                if (foods.Length > 0)
                {
                    foreach (BaseItem i in foods)
                    {
                        PlayerCharacter.RemoveItem(i);
                        ((PlayerCharacter)Target).AddItem(TableFood.GetItem(CommonConst.ObjNo.FlyCroquette), i.SortNo);
                    }

                    //メッセージの出力
                    DisplayInformation.Info.AddMessage(
                        string.Format(CommonConst.Message.TrapFly2));
                }

                result = true;
            }
            break;

        case TrapType.WaterBucket:

            //サウンドを鳴らす
            SoundInformation.Sound.Play(SoundInformation.SoundType.BucketFall);

            //エフェクトの発動
            EffectWaterBucket.CreateObject(Target).Play();

            //効果
            bresult = Target.AddStateAbnormal((int)StateAbnormal.Reticent);
            //対象が異常になったらメッセージを表示
            if (bresult != 0)
            {
                DisplayInformation.Info.AddMessage(
                    CommonFunction.GetAbnormalMessage(StateAbnormal.Reticent, Target));
            }

            result = true;
            break;

        //花粉
        case TrapType.Pollen:

            //サウンドを鳴らす
            SoundInformation.Sound.Play(SoundInformation.SoundType.Smoke);

            //エフェクトの発動
            EffectSmoke d3 = EffectSmoke.CreateObject(Target);
            d3.SetColor(Color.yellow);
            d3.Play();

            //力減少
            Target.ReducePower((ushort)CommonNumber);

            //メッセージの出力
            DisplayInformation.Info.AddMessage(
                string.Format(CommonConst.Message.TrapPllen2, Target.DisplayNameInMessage));

            result = true;
            break;

        case TrapType.Ember:

            //ダメージ処理
            int damage2 = CommonNumber;

            //通常ダメージの場合
            if (CommonFunction.HasOptionType(this.Options, OptionType.ReverceDamage) == false)
            {
                AttackState atState2 = Target.AddDamage(damage2);

                //ダメージエフェクト
                EffectDamage d4 = EffectDamage.CreateObject(Target);
                d4.SetText(damage2.ToString(), AttackState.Hit);
                d4.Play();

                DisplayInformation.Info.AddMessage(
                    string.Format(CommonConst.Message.TrapDamage, Target.DisplayNameInMessage, this.DisplayNameInMessage, damage2));

                //対象が死亡したら
                if (atState2 == AttackState.Death)
                {
                    DisplayInformation.Info.AddMessage(
                        Target.GetMessageDeath(Target.HaveExperience));

                    if (Target.Type == ObjectType.Player)
                    {
                        ScoreInformation.Info.CauseDeath =
                            string.Format(CommonConst.DeathMessage.Trap, DisplayNameNormal);
                        ScoreInformation.Info.CauseDeathType = DeathCouseType.Trap;
                    }
                    Target.Death();
                    Target.DeathAction(dun);
                }
            }
            //反転回復の場合
            else
            {
                Target.RecoverHp(damage2);

                //ダメージエフェクト
                EffectDamage d4 = EffectDamage.CreateObject(Target);
                d4.SetText(damage2.ToString(), AttackState.Heal);
                d4.Play();


                DisplayInformation.Info.AddMessage(
                    string.Format(CommonConst.Message.TrapRecover, Target.DisplayNameInMessage, this.DisplayNameInMessage, damage2));
            }
            break;
        }
        Target = null;

        return(result);
    }