Esempio n. 1
0
 private void SoulAttack()
 {
     if (this.hp > this.hpmax / 2)
     {
         return;
     }
     this.soul.attack = true;
 }
Esempio n. 2
0
        protected override void Moving()
        {
            this.neutlal = this.Motion == NaviBase.MOTION.neutral;
            switch (this.Motion)
            {
            case NaviBase.MOTION.neutral:
                if (this.moveflame)
                {
                    ++this.waittime;
                }
                if (this.moveflame)
                {
                    this.animationpoint = this.AnimeNeutral(this.waittime);
                    if (this.waittime >= 16 / version || this.atack)
                    {
                        this.waittime = 0;
                        ++this.roopneutral;
                        if (this.roopneutral >= 1 && this.parent.nowscene != SceneBattle.BATTLESCENE.end)
                        {
                            this.roopneutral = 0;
                            if (this.roopmove > this.moveroop && !this.badstatus[4])
                            {
                                this.roopmove = this.version > 3 ? this.Random.Next(-1, 1) : 0;
                                ++this.atackroop;
                                if (this.parent.player.invincibility || this.parent.player.barrierType != CharacterBase.BARRIER.None || this.parent.player.nohit)
                                {
                                    this.atack = true;
                                }
                                if (!this.atack)
                                {
                                    this.attack = (Youmu.ATTACK) this.pattern[this.action];
                                    if (this.attack == Youmu.ATTACK.RoukanRenzan)
                                    {
                                        this.powerPlus = this.powers[this.pattern[this.action]] - this.power;
                                    }
                                    else
                                    {
                                        this.powerPlus = this.powers[this.pattern[this.action]];
                                    }
                                    ++this.action;
                                    if (this.action >= this.pattern.Length)
                                    {
                                        this.action = 0;
                                    }
                                    this.attackProcess = 0;
                                }
                                else
                                {
                                    this.attack    = Youmu.ATTACK.Hakurouken;
                                    this.powerPlus = this.powers[(int)this.attack];
                                    this.atack     = false;
                                }
                                this.waittime = 0;
                                this.Motion   = NaviBase.MOTION.attack;
                            }
                            else
                            {
                                this.waittime = 0;
                                if (this.atack)
                                {
                                    this.roopmove = this.moveroop + 1;
                                }
                                this.Motion = NaviBase.MOTION.move;
                            }
                        }
                    }
                    break;
                }
                break;

            case NaviBase.MOTION.attack:
                if (this.moveflame)
                {
                    ++this.waittime;
                    if (this.moveflame)
                    {
                        switch (this.attack)
                        {
                        case Youmu.ATTACK.RoukanRenzan:
                            switch (this.attackProcess)
                            {
                            case 0:
                                this.animationpoint = this.AnimeSlashUP(0);
                                switch (this.waittime)
                                {
                                case 1:
                                    this.target = this.RandomTarget(this.union);
                                    this.parent.attacks.Add(new Dummy(this.sound, this.parent, this.target.X, this.target.Y - 1, this.union, new Point(0, 2), 30, true));
                                    break;

                                case 4:
                                    this.counterTiming = true;
                                    break;

                                case 8:
                                    ++this.attackProcess;
                                    this.waittime = 0;
                                    break;
                                }
                                break;

                            case 1:
                                this.animationpoint = this.AnimeSlashUP(this.waittime);
                                switch (this.waittime)
                                {
                                case 2:
                                    this.sound.PlaySE(SoundEffect.sword);
                                    SwordAttack swordAttack1 = new SwordAttack(this.sound, this.parent, this.target.X, this.target.Y, this.union, this.Power, 2, ChipBase.ELEMENT.normal, true, true)
                                    {
                                        invincibility = false
                                    };
                                    this.parent.attacks.Add(swordAttack1);
                                    this.target = this.RandomTarget(this.union);
                                    this.parent.attacks.Add(new Dummy(this.sound, this.parent, this.target.X, this.target.Y - 1, this.union, new Point(0, 2), 30, true));
                                    break;

                                case 4:
                                    this.counterTiming = false;
                                    break;

                                case 8:
                                    ++this.attackProcess;
                                    this.waittime = 0;
                                    break;
                                }
                                break;

                            case 2:
                                this.animationpoint = this.AnimeSlashDOWN(this.waittime);
                                switch (this.waittime)
                                {
                                case 2:
                                    this.sound.PlaySE(SoundEffect.sword);
                                    SwordAttack swordAttack2 = new SwordAttack(this.sound, this.parent, this.target.X, this.target.Y, this.union, this.Power, 2, ChipBase.ELEMENT.normal, true, true)
                                    {
                                        invincibility = false
                                    };
                                    this.parent.attacks.Add(swordAttack2);
                                    if (this.version > 1)
                                    {
                                        this.target = this.RandomTarget(this.union);
                                        this.parent.attacks.Add(new Dummy(this.sound, this.parent, this.target.X, this.target.Y - 1, this.union, new Point(0, 2), 30, true));
                                        break;
                                    }
                                    break;

                                case 8:
                                    if (this.version > 1)
                                    {
                                        ++this.attackProcess;
                                        this.waittime = 0;
                                        break;
                                    }
                                    this.speed = this.nspeed;
                                    this.SoulAttack();
                                    this.motion   = NaviBase.MOTION.move;
                                    this.waittime = 0;
                                    break;
                                }
                                break;

                            case 3:
                                this.animationpoint = this.AnimeSlashUP(this.waittime);
                                switch (this.waittime)
                                {
                                case 2:
                                    this.sound.PlaySE(SoundEffect.sword);
                                    SwordAttack swordAttack3 = new SwordAttack(this.sound, this.parent, this.target.X, this.target.Y, this.union, this.Power, 2, ChipBase.ELEMENT.normal, true, true)
                                    {
                                        invincibility = false
                                    };
                                    this.parent.attacks.Add(swordAttack3);
                                    break;

                                case 5:
                                    this.speed = this.nspeed;
                                    this.SoulAttack();
                                    this.motion   = NaviBase.MOTION.move;
                                    this.waittime = 0;
                                    break;
                                }
                                break;
                            }
                            break;

                        case Youmu.ATTACK.NishinIttaiken:
                            this.animationpoint = this.AnimeSlashNishin(this.waittime);
                            switch (this.waittime)
                            {
                            case 1:
                                this.soul.LostFlag(true);
                                this.guard         = CharacterBase.GUARD.none;
                                this.counterTiming = true;
                                this.speed        += 2;
                                this.sound.PlaySE(SoundEffect.charge);
                                break;

                            case 10:
                                this.counterTiming = false;
                                this.sound.PlaySE(SoundEffect.sword);
                                int        s           = 4;
                                AttackBase attackBase1 = new BombWave(this.sound, this.parent, this.position.X + this.UnionRebirth(this.union), 0, this.union, this.Power, s, this.element);
                                attackBase1.invincibility = false;
                                this.parent.attacks.Add(attackBase1);
                                AttackBase attackBase2 = new BombWave(this.sound, this.parent, this.position.X + this.UnionRebirth(this.union), 1, this.union, this.Power, s, this.element);
                                attackBase2.invincibility = false;
                                this.parent.attacks.Add(attackBase2);
                                AttackBase attackBase3 = new BombWave(this.sound, this.parent, this.position.X + this.UnionRebirth(this.union), 2, this.union, this.Power, s, this.element);
                                attackBase3.invincibility = false;
                                this.parent.attacks.Add(attackBase3);
                                break;

                            case 25:
                                this.speed    = this.nspeed;
                                this.guard    = CharacterBase.GUARD.noDamage;
                                this.motion   = NaviBase.MOTION.move;
                                this.waittime = 0;
                                this.soul.LostFlag(false);
                                break;
                            }
                            break;

                        case Youmu.ATTACK.IaiJuujizan:
                            if (this.attackProcess == 0)
                            {
                                this.animationpoint = this.AnimeIai(this.waittime);
                                switch (this.waittime)
                                {
                                case 1:
                                    this.counterTiming = true;
                                    this.parent.effects.Add(new Flash(this.sound, this.parent, this.positionDirect, this.position));
                                    this.sound.PlaySE(SoundEffect.pikin);
                                    this.speed += 2;
                                    break;

                                case 2:
                                    this.target           = this.RandomTarget(this.union);
                                    this.effecting        = true;
                                    this.positionReserved = this.position;
                                    this.positionre       = new Point(this.union == Panel.COLOR.blue ? 0 : 5, this.target.Y);
                                    this.position         = this.positionre;
                                    this.PositionDirectSet();
                                    break;

                                case 6:
                                    this.counterTiming = false;
                                    this.sound.PlaySE(SoundEffect.sword);
                                    SwordCloss swordCloss = new SwordCloss(this.sound, this.parent, this.target.X, this.target.Y, this.union, this.Power, 2, ChipBase.ELEMENT.normal, true)
                                    {
                                        invincibility = false
                                    };
                                    this.parent.attacks.Add(swordCloss);
                                    break;

                                case 25:
                                    this.positionReserved = null;
                                    this.speed            = this.nspeed;
                                    this.motion           = NaviBase.MOTION.move;
                                    this.effecting        = false;
                                    this.speed            = this.nspeed;
                                    this.waittime         = 0;
                                    break;
                                }
                            }
                            break;

                        case Youmu.ATTACK.Hakurouken:
                            this.animationpoint = this.AnimeSlashHakurou(this.waittime);
                            switch (this.waittime)
                            {
                            case 1:
                                this.counterTiming = true;
                                break;

                            case 2:
                                this.sound.PlaySE(SoundEffect.sword);
                                foreach (CharacterBase characterBase in this.parent.AllChara())
                                {
                                    if (characterBase.union == this.UnionEnemy && (characterBase.guard != CharacterBase.GUARD.none || characterBase.invincibilitytime > 0 || characterBase.nohit || (uint)characterBase.barrierType > 0U))
                                    {
                                        characterBase.Hp -= this.Power;
                                        characterBase.invincibilitytime = 0;
                                        characterBase.barrierType       = CharacterBase.BARRIER.None;
                                        this.sound.PlaySE(SoundEffect.damageenemy);
                                    }
                                }
                                break;

                            case 4:
                                this.counterTiming = false;
                                break;

                            case 8:
                                this.speed    = this.nspeed;
                                this.motion   = NaviBase.MOTION.move;
                                this.waittime = 0;
                                break;
                            }
                            break;
                        }
                    }
                    break;
                }
                break;

            case NaviBase.MOTION.move:
                this.animationpoint = this.AnimeMove(this.waittime);
                if (this.moveflame)
                {
                    switch (this.waittime)
                    {
                    case 0:
                        this.MoveRandom(false, false);
                        if (this.position == this.positionre)
                        {
                            this.Motion      = NaviBase.MOTION.neutral;
                            this.frame       = 0;
                            this.roopneutral = 0;
                            ++this.roopmove;
                            break;
                        }
                        break;

                    case 3:
                        this.position = this.positionre;
                        this.PositionDirectSet();
                        break;

                    case 5:
                        this.Motion      = NaviBase.MOTION.neutral;
                        this.frame       = 0;
                        this.roopneutral = 0;
                        ++this.roopmove;
                        break;
                    }
                    ++this.waittime;
                    break;
                }
                break;

            case NaviBase.MOTION.knockback:
                switch (this.waittime)
                {
                case 2:
                    this.guard = CharacterBase.GUARD.noDamage;
                    if (this.soul.motion == HalfSoul.MOTION.lost)
                    {
                        this.soul.LostFlag(false);
                    }
                    this.NockMotion();
                    this.counterTiming = false;
                    this.effecting     = false;
                    this.PositionDirectSet();
                    break;

                case 3:
                    this.NockMotion();
                    break;

                case 15:
                    this.animationpoint = new Point(0, 1);
                    this.PositionDirectSet();
                    break;

                case 21:
                    this.animationpoint = new Point(0, 0);
                    this.waittime       = 0;
                    this.Motion         = NaviBase.MOTION.neutral;
                    break;
                }
                if (this.waittime >= 2 && this.waittime <= 6)
                {
                    this.positionDirect.X -= this.UnionRebirth(this.union);
                }
                ++this.waittime;
                break;
            }
            if (this.effecting)
            {
                this.AttackMake(this.Power, 0, 0);
            }
            this.FlameControl();
            this.MoveAftar();
        }