示例#1
0
        public void CMagicAttack(GSSession session, CMagicAttack message)
        {
            var @char  = session.Player.Character;
            var target = message.Target;

            MuEmu.Data.SpellInfo spell;
            Spells  spells  = null;
            Monster monster = null;
            Player  player  = null;
            Point   pos;
            int     defense = 0;

            if ([email protected](message.MagicNumber))
            {
                Logger.Error("Invalid Magic, user don't own this spell {0}", message.MagicNumber);
                return;
            }

            spell = @char.Spells.SpellDictionary[message.MagicNumber];
            int eDmg = 0;

            try
            {
                if (target >= MonstersMng.MonsterStartIndex) // Is Monster
                {
                    monster = MonstersMng.Instance.GetMonster(target);
                    spells  = monster.Spells;
                    defense = monster.Defense;
                    pos     = monster.Position;
                    eDmg    = @char.PentagramAttack(monster).Result;
                }
                else
                {
                    player  = Program.server.Clients.First(x => x.ID == target).Player;
                    spells  = player.Character.Spells;
                    defense = player.Character.Defense;
                    pos     = player.Character.Position;
                    eDmg    = @char.PentagramAttack(player.Character).Result;
                }
            }
            catch (Exception)
            {
                Logger.Error("MagicAttack: Invalid target");
                return;
            }

            var mana = @char.Mana - spell.Mana;
            var bp   = @char.Stamina;

            if (mana >= 0 && bp >= 0)
            {
                switch (spell.Number)
                {
                case Spell.Poison:
                    @char.Spells.AttackSend(spell.Number, message.Target, false);
                    spells.SetBuff(SkillStates.Poison, TimeSpan.FromSeconds(60), @char);
                    break;

                case Spell.Ice:
                    @char.Spells.AttackSend(spell.Number, message.Target, false);
                    spells.SetBuff(SkillStates.Ice, TimeSpan.FromSeconds(60), @char);
                    break;

                case Spell.InfinityArrow:
                    if (@char.BaseClass != HeroClass.FaryElf)
                    {
                        return;
                    }
                    spells.SetBuff(SkillStates.InfinityArrow, TimeSpan.FromSeconds(1800), @char);
                    @char.Spells.AttackSend(spell.Number, message.Target, true);
                    break;

                case Spell.Heal:
                case Spell.Heal1:
                case Spell.Heal2:
                case Spell.Heal3:
                case Spell.Heal4:
                case Spell.Heal5:
                    if (@char.BaseClass != HeroClass.FaryElf)
                    {
                        return;
                    }

                    var addLife = @char.EnergyTotal / 5;

                    if (spells.Character == null)
                    {
                        return;
                    }

                    spells.Character.Health += addLife;
                    @char.Spells.AttackSend(spell.Number, message.Target, true);
                    break;

                case Spell.GreaterDefense:
                case Spell.GreaterDefense1:
                case Spell.GreaterDefense2:
                case Spell.GreaterDefense3:
                case Spell.GreaterDefense4:
                case Spell.GreaterDefense5:
                    if (@char.BaseClass != HeroClass.FaryElf)
                    {
                        return;
                    }

                    spells.SetBuff(SkillStates.Defense, TimeSpan.FromSeconds(1800), @char);
                    @char.Spells.AttackSend(spell.Number, message.Target, true);
                    break;

                case Spell.GreaterDamage:
                case Spell.GreaterDamage1:
                case Spell.GreaterDamage2:
                case Spell.GreaterDamage3:
                case Spell.GreaterDamage4:
                case Spell.GreaterDamage5:
                    if (@char.BaseClass != HeroClass.FaryElf)
                    {
                        return;
                    }

                    spells.SetBuff(SkillStates.Attack, TimeSpan.FromSeconds(1800), @char);
                    @char.Spells.AttackSend(spell.Number, message.Target, true);
                    break;

                case Spell.SoulBarrier:
                case Spell.SoulBarrier1:
                case Spell.SoulBarrier2:
                case Spell.SoulBarrier3:
                case Spell.SoulBarrier4:
                case Spell.SoulBarrier5:
                    spells.SetBuff(SkillStates.SoulBarrier, TimeSpan.FromSeconds(60 + @char.EnergyTotal / 40), @char);
                    @char.Spells.AttackSend(spell.Number, message.Target, true);
                    break;

                case Spell.GreaterFortitude:
                case Spell.GreatFortitude1:
                case Spell.GreatFortitude2:
                case Spell.GreatFortitude3:
                case Spell.GreatFortitude4:
                case Spell.GreatFortitude5:
                    spells.SetBuff(SkillStates.SwellLife, TimeSpan.FromSeconds(60 + @char.EnergyTotal / 10), @char);
                    if (@char.Party != null)
                    {
                        foreach (var a in @char.Party.Members)
                        {
                            a.Character.Spells.SetBuff(SkillStates.SwellLife, TimeSpan.FromSeconds(60 + @char.EnergyTotal / 10), @char);
                        }
                    }
                    @char.Spells.AttackSend(spell.Number, message.Target, true);
                    break;

                case Spell.Reflex:
                    spells.SetBuff(SkillStates.SkillDamageDeflection, TimeSpan.FromSeconds(60 + @char.EnergyTotal / 40), @char);
                    @char.Spells.AttackSend(spell.Number, message.Target, true);
                    break;

                case Spell.Sleep:
                    spells.SetBuff(SkillStates.SkillSleep, TimeSpan.FromSeconds(30 + @char.EnergyTotal / 25), @char);
                    @char.Spells.AttackSend(spell.Number, message.Target, true);
                    break;

                default:
                    @char.Spells.AttackSend(spell.Number, message.Target, false);
                    break;
                }

                @char.Mana = mana;
                DamageType type   = DamageType.Regular;
                var        attack = 0.0f;
                switch (spell.Number)
                {
                case Spell.Falling_Slash:
                case Spell.Lunge:
                case Spell.Uppercut:
                case Spell.Cyclone:
                case Spell.Slash:
                case Spell.TwistingSlash:
                case Spell.TwistingSlash1:
                case Spell.TwistingSlash2:
                case Spell.TwistingSlash3:
                case Spell.TwistingSlash4:
                case Spell.TwistingSlash5:
                case Spell.RagefulBlow:
                case Spell.RagefulBlow1:
                case Spell.RagefulBlow2:
                case Spell.RagefulBlow3:
                case Spell.RagefulBlow4:
                case Spell.RagefulBlow5:
                case Spell.DeathStab:
                case Spell.DeathStab1:
                case Spell.DeathStab2:
                case Spell.DeathStab3:
                case Spell.DeathStab4:
                case Spell.DeathStab5:
                case Spell.CrescentMoonSlash:
                case Spell.Impale:
                case Spell.FireBreath:
                    attack = @char.SkillAttack(spell, defense, out type);
                    //else
                    //    @char.SkillAttack(spell, player, out type);
                    break;

                case Spell.Heal:
                case Spell.Heal1:
                case Spell.Heal2:
                case Spell.Heal3:
                case Spell.Heal4:
                case Spell.Heal5:
                case Spell.GreaterDamage:
                case Spell.GreaterDamage1:
                case Spell.GreaterDamage2:
                case Spell.GreaterDamage3:
                case Spell.GreaterDamage4:
                case Spell.GreaterDamage5:
                case Spell.GreaterDefense:
                case Spell.GreaterDefense1:
                case Spell.GreaterDefense2:
                case Spell.GreaterDefense3:
                case Spell.GreaterDefense4:
                case Spell.GreaterDefense5:
                case Spell.GreaterFortitude:
                case Spell.GreatFortitude1:
                case Spell.GreatFortitude2:
                case Spell.GreatFortitude3:
                case Spell.GreatFortitude4:
                case Spell.GreatFortitude5:
                case Spell.SoulBarrier:
                case Spell.SoulBarrier1:
                case Spell.SoulBarrier2:
                case Spell.SoulBarrier3:
                case Spell.SoulBarrier4:
                case Spell.SoulBarrier5:
                case Spell.Teleport:
                case Spell.InfinityArrow:
                    return;

                default:
                    if (spell.IsDamage == 0)
                    {
                        return;
                    }

                    if (@char.BaseClass == HeroClass.Summoner || @char.BaseClass == HeroClass.DarkWizard || @char.BaseClass == HeroClass.MagicGladiator)
                    {
                        attack = @char.MagicAttack(spell, defense, out type);
                    }
                    else
                    {
                        attack = @char.SkillAttack(spell, defense, out type);
                    }

                    if (attack <= 0)
                    {
                        attack = 0;
                        type   = DamageType.Miss;
                    }
                    break;
                }

                if (@char.Spells.CheckCombo(spell.Number))
                {
                    attack += (@char.StrengthTotal + @char.AgilityTotal + @char.EnergyTotal) / 2.0f;
                    @char.Spells.AttackSend(Spell.Combo, target, true);
                }

                player?.Character.GetAttacked((ushort)@char.Player.Session.ID, @char.Direction, 0, (int)attack, type, spell.Number, eDmg);
                monster?.GetAttackedDelayed(@char.Player, (int)attack, type, TimeSpan.FromMilliseconds(500));
            }
        }
示例#2
0
        public void CMagicAttack(GSSession session, CMagicAttack message)
        {
            var @char  = session.Player.Character;
            var target = message.Target;

            MuEmu.Data.SpellInfo spell;
            Spells  spells  = null;
            Monster monster = null;
            Player  player  = null;

            if ([email protected](message.MagicNumber))
            {
                Logger.Error("Invalid Magic, user don't own this spell {0}", message.MagicNumber);
                return;
            }

            spell = @char.Spells.SpellDictionary[message.MagicNumber];

            try
            {
                if (target >= MonstersMng.MonsterStartIndex) // Is Monster
                {
                    monster = MonstersMng.Instance.GetMonster(target);
                    spells  = monster.Spells;
                }
                else
                {
                    player = Program.server.Clients.First(x => x.ID == target).Player;
                    spells = player.Character.Spells;
                }
            }catch (Exception)
            {
                Logger.Error("MagicAttack: Invalid target");
                return;
            }

            var mana = @char.Mana - spell.Mana;
            var bp   = @char.Stamina;

            if (mana >= 0 && bp >= 0)
            {
                switch (spell.Number)
                {
                case Spell.Poison:
                    @char.Spells.AttackSend(spell.Number, message.Target, false);
                    spells.SetBuff(SkillStates.Poison, TimeSpan.FromSeconds(60), @char);
                    break;

                case Spell.Heal:
                    if (@char.BaseClass != HeroClass.FaryElf)
                    {
                        return;
                    }

                    var addLife = @char.EnergyTotal / 5;

                    if (spells.Character == null)
                    {
                        return;
                    }

                    spells.Character.Health += addLife;
                    @char.Spells.AttackSend(spell.Number, message.Target, true);
                    break;

                case Spell.GreaterDefense:
                    if (@char.BaseClass != HeroClass.FaryElf)
                    {
                        return;
                    }

                    spells.SetBuff(SkillStates.Defense, TimeSpan.FromSeconds(60), @char);
                    @char.Spells.AttackSend(spell.Number, message.Target, true);
                    break;

                case Spell.GreaterDamage:
                    if (@char.BaseClass != HeroClass.FaryElf)
                    {
                        return;
                    }

                    spells.SetBuff(SkillStates.Attack, TimeSpan.FromSeconds(60), @char);
                    @char.Spells.AttackSend(spell.Number, message.Target, true);
                    break;

                case Spell.SoulBarrier:
                    spells.SetBuff(SkillStates.SoulBarrier, TimeSpan.FromSeconds(60 + @char.EnergyTotal / 40), @char);
                    @char.Spells.AttackSend(spell.Number, message.Target, true);
                    break;

                case Spell.GreaterFortitude:
                    spells.SetBuff(SkillStates.SwellLife, TimeSpan.FromSeconds(60 + @char.EnergyTotal / 10), @char);
                    @char.Spells.AttackSend(spell.Number, message.Target, true);
                    break;

                default:
                    @char.Spells.AttackSend(spell.Number, message.Target, false);
                    break;
                }

                @char.Mana = mana;
                DamageType type   = DamageType.Regular;
                var        attack = 0.0f;

                switch (spell.Number)
                {
                case Spell.Falling_Slash:
                case Spell.Lunge:
                case Spell.Uppercut:
                case Spell.Cyclone:
                case Spell.Slash:
                case Spell.TwistingSlash:
                case Spell.RagefulBlow:
                case Spell.DeathStab:
                case Spell.CrescentMoonSlash:
                case Spell.Impale:
                case Spell.FireBreath:
                    if (monster != null)
                    {
                        attack = @char.SkillAttack(spell, monster, out type);
                    }
                    //else
                    //    @char.SkillAttack(spell, player, out type);
                    break;

                default:
                    if (@char.BaseClass == HeroClass.Summoner || @char.BaseClass == HeroClass.DarkWizard || @char.BaseClass == HeroClass.MagicGladiator)
                    {
                        if (monster != null)
                        {
                            attack = @char.MagicAttack(spell, monster, out type);
                        }
                    }
                    else
                    {
                        if (monster != null)
                        {
                            attack = @char.SkillAttack(spell, monster, out type);
                        }
                    }
                    break;
                }

                monster?.GetAttackedDelayed(@char.Player, (int)attack, type, TimeSpan.FromMilliseconds(500));
            }
        }