Ejemplo n.º 1
0
        private void ExecuteHandler(ClientSession session)
        {
            ItemInstance specialistInstance =
                session.Character.Inventory.LoadBySlotAndType((byte)EquipmentType.Sp, InventoryType.Wear);

            if (Type == 10)
            {
                short specialistDamage     = SpecialistDamage,
                      specialistDefense    = SpecialistDefense,
                      specialistElement    = SpecialistElement,
                      specialistHealpoints = SpecialistHP;
                int transportId            = TransportId;
                if (!session.Character.UseSp || specialistInstance == null ||
                    transportId != specialistInstance.TransportId)
                {
                    session.SendPacket(
                        UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("SPUSE_NEEDED"), 0));
                    return;
                }

                if (CharacterHelper.SpPoint(specialistInstance.SpLevel, specialistInstance.Upgrade)
                    - specialistInstance.SlDamage - specialistInstance.SlHP - specialistInstance.SlElement
                    - specialistInstance.SlDefence - specialistDamage - specialistDefense - specialistElement
                    - specialistHealpoints < 0)
                {
                    return;
                }

                if (specialistDamage < 0 || specialistDefense < 0 || specialistElement < 0 ||
                    specialistHealpoints < 0)
                {
                    return;
                }

                specialistInstance.SlDamage  += specialistDamage;
                specialistInstance.SlDefence += specialistDefense;
                specialistInstance.SlElement += specialistElement;
                specialistInstance.SlHP      += specialistHealpoints;

                ItemInstance mainWeapon =
                    session.Character.Inventory.LoadBySlotAndType((byte)EquipmentType.MainWeapon,
                                                                  InventoryType.Wear);
                ItemInstance secondaryWeapon =
                    session.Character.Inventory.LoadBySlotAndType((byte)EquipmentType.MainWeapon,
                                                                  InventoryType.Wear);
                List <ShellEffectDTO> effects = new List <ShellEffectDTO>();
                if (mainWeapon?.ShellEffects != null)
                {
                    effects.AddRange(mainWeapon.ShellEffects);
                }

                if (secondaryWeapon?.ShellEffects != null)
                {
                    effects.AddRange(secondaryWeapon.ShellEffects);
                }

                int GetShellWeaponEffectValue(ShellWeaponEffectType effectType)
                {
                    return(effects.Where(s => s.Effect == (byte)effectType).OrderByDescending(s => s.Value)
                           .FirstOrDefault()?.Value ?? 0);
                }

                int slElement = CharacterHelper.SlPoint(specialistInstance.SlElement, 2)
                                + GetShellWeaponEffectValue(ShellWeaponEffectType.SlElement)
                                + GetShellWeaponEffectValue(ShellWeaponEffectType.SlGlobal);
                int slHp = CharacterHelper.SlPoint(specialistInstance.SlHP, 3)
                           + GetShellWeaponEffectValue(ShellWeaponEffectType.Slhp)
                           + GetShellWeaponEffectValue(ShellWeaponEffectType.SlGlobal);
                int slDefence = CharacterHelper.SlPoint(specialistInstance.SlDefence, 1)
                                + GetShellWeaponEffectValue(ShellWeaponEffectType.SlDefence)
                                + GetShellWeaponEffectValue(ShellWeaponEffectType.SlGlobal);
                int slHit = CharacterHelper.SlPoint(specialistInstance.SlDamage, 0)
                            + GetShellWeaponEffectValue(ShellWeaponEffectType.SlDamage)
                            + GetShellWeaponEffectValue(ShellWeaponEffectType.SlGlobal);

                #region slHit

                specialistInstance.DamageMinimum        = 0;
                specialistInstance.DamageMaximum        = 0;
                specialistInstance.HitRate              = 0;
                specialistInstance.CriticalLuckRate     = 0;
                specialistInstance.CriticalRate         = 0;
                specialistInstance.DefenceDodge         = 0;
                specialistInstance.DistanceDefenceDodge = 0;
                specialistInstance.ElementRate          = 0;
                specialistInstance.DarkResistance       = 0;
                specialistInstance.LightResistance      = 0;
                specialistInstance.FireResistance       = 0;
                specialistInstance.WaterResistance      = 0;
                specialistInstance.CriticalDodge        = 0;
                specialistInstance.CloseDefence         = 0;
                specialistInstance.DistanceDefence      = 0;
                specialistInstance.MagicDefence         = 0;
                specialistInstance.HP = 0;
                specialistInstance.MP = 0;

                if (slHit >= 1)
                {
                    specialistInstance.DamageMinimum += 5;
                    specialistInstance.DamageMaximum += 5;
                }

                if (slHit >= 10)
                {
                    specialistInstance.HitRate += 10;
                }

                if (slHit >= 20)
                {
                    specialistInstance.CriticalLuckRate += 2;
                }

                if (slHit >= 30)
                {
                    specialistInstance.DamageMinimum += 5;
                    specialistInstance.DamageMaximum += 5;
                    specialistInstance.HitRate       += 10;
                }

                if (slHit >= 40)
                {
                    specialistInstance.CriticalRate += 10;
                }

                if (slHit >= 50)
                {
                    specialistInstance.HP += 200;
                    specialistInstance.MP += 200;
                }

                if (slHit >= 60)
                {
                    specialistInstance.HitRate += 15;
                }

                if (slHit >= 70)
                {
                    specialistInstance.HitRate       += 15;
                    specialistInstance.DamageMinimum += 5;
                    specialistInstance.DamageMaximum += 5;
                }

                if (slHit >= 80)
                {
                    specialistInstance.CriticalLuckRate += 3;
                }

                if (slHit >= 90)
                {
                    specialistInstance.CriticalRate += 20;
                }

                if (slHit >= 100)
                {
                    specialistInstance.CriticalLuckRate += 3;
                    specialistInstance.CriticalRate     += 20;
                    specialistInstance.HP            += 200;
                    specialistInstance.MP            += 200;
                    specialistInstance.DamageMinimum += 5;
                    specialistInstance.DamageMaximum += 5;
                    specialistInstance.HitRate       += 20;
                }

                #endregion

                #region slDefence

                if (slDefence >= 10)
                {
                    specialistInstance.DefenceDodge         += 5;
                    specialistInstance.DistanceDefenceDodge += 5;
                }

                if (slDefence >= 20)
                {
                    specialistInstance.CriticalDodge += 2;
                }

                if (slDefence >= 30)
                {
                    specialistInstance.HP += 100;
                }

                if (slDefence >= 40)
                {
                    specialistInstance.CriticalDodge += 2;
                }

                if (slDefence >= 50)
                {
                    specialistInstance.DefenceDodge         += 5;
                    specialistInstance.DistanceDefenceDodge += 5;
                }

                if (slDefence >= 60)
                {
                    specialistInstance.HP += 200;
                }

                if (slDefence >= 70)
                {
                    specialistInstance.CriticalDodge += 3;
                }

                if (slDefence >= 75)
                {
                    specialistInstance.FireResistance  += 2;
                    specialistInstance.WaterResistance += 2;
                    specialistInstance.LightResistance += 2;
                    specialistInstance.DarkResistance  += 2;
                }

                if (slDefence >= 80)
                {
                    specialistInstance.DefenceDodge         += 10;
                    specialistInstance.DistanceDefenceDodge += 10;
                    specialistInstance.CriticalDodge        += 3;
                }

                if (slDefence >= 90)
                {
                    specialistInstance.FireResistance  += 3;
                    specialistInstance.WaterResistance += 3;
                    specialistInstance.LightResistance += 3;
                    specialistInstance.DarkResistance  += 3;
                }

                if (slDefence >= 95)
                {
                    specialistInstance.HP += 300;
                }

                if (slDefence >= 100)
                {
                    specialistInstance.DefenceDodge         += 20;
                    specialistInstance.DistanceDefenceDodge += 20;
                    specialistInstance.FireResistance       += 5;
                    specialistInstance.WaterResistance      += 5;
                    specialistInstance.LightResistance      += 5;
                    specialistInstance.DarkResistance       += 5;
                }

                #endregion

                #region slHp

                if (slHp >= 5)
                {
                    specialistInstance.DamageMinimum += 5;
                    specialistInstance.DamageMaximum += 5;
                }

                if (slHp >= 10)
                {
                    specialistInstance.DamageMinimum += 5;
                    specialistInstance.DamageMaximum += 5;
                }

                if (slHp >= 15)
                {
                    specialistInstance.DamageMinimum += 5;
                    specialistInstance.DamageMaximum += 5;
                }

                if (slHp >= 20)
                {
                    specialistInstance.DamageMinimum   += 5;
                    specialistInstance.DamageMaximum   += 5;
                    specialistInstance.CloseDefence    += 10;
                    specialistInstance.DistanceDefence += 10;
                    specialistInstance.MagicDefence    += 10;
                }

                if (slHp >= 25)
                {
                    specialistInstance.DamageMinimum += 5;
                    specialistInstance.DamageMaximum += 5;
                }

                if (slHp >= 30)
                {
                    specialistInstance.DamageMinimum += 5;
                    specialistInstance.DamageMaximum += 5;
                }

                if (slHp >= 35)
                {
                    specialistInstance.DamageMinimum += 5;
                    specialistInstance.DamageMaximum += 5;
                }

                if (slHp >= 40)
                {
                    specialistInstance.DamageMinimum   += 5;
                    specialistInstance.DamageMaximum   += 5;
                    specialistInstance.CloseDefence    += 15;
                    specialistInstance.DistanceDefence += 15;
                    specialistInstance.MagicDefence    += 15;
                }

                if (slHp >= 45)
                {
                    specialistInstance.DamageMinimum += 10;
                    specialistInstance.DamageMaximum += 10;
                }

                if (slHp >= 50)
                {
                    specialistInstance.DamageMinimum   += 10;
                    specialistInstance.DamageMaximum   += 10;
                    specialistInstance.FireResistance  += 2;
                    specialistInstance.WaterResistance += 2;
                    specialistInstance.LightResistance += 2;
                    specialistInstance.DarkResistance  += 2;
                }

                if (slHp >= 55)
                {
                    specialistInstance.DamageMinimum += 10;
                    specialistInstance.DamageMaximum += 10;
                }

                if (slHp >= 60)
                {
                    specialistInstance.DamageMinimum += 10;
                    specialistInstance.DamageMaximum += 10;
                }

                if (slHp >= 65)
                {
                    specialistInstance.DamageMinimum += 10;
                    specialistInstance.DamageMaximum += 10;
                }

                if (slHp >= 70)
                {
                    specialistInstance.DamageMinimum   += 10;
                    specialistInstance.DamageMaximum   += 10;
                    specialistInstance.CloseDefence    += 20;
                    specialistInstance.DistanceDefence += 20;
                    specialistInstance.MagicDefence    += 20;
                }

                if (slHp >= 75)
                {
                    specialistInstance.DamageMinimum += 15;
                    specialistInstance.DamageMaximum += 15;
                }

                if (slHp >= 80)
                {
                    specialistInstance.DamageMinimum += 15;
                    specialistInstance.DamageMaximum += 15;
                }

                if (slHp >= 85)
                {
                    specialistInstance.DamageMinimum += 15;
                    specialistInstance.DamageMaximum += 15;
                    specialistInstance.CriticalDodge++;
                }

                if (slHp >= 86)
                {
                    specialistInstance.CriticalDodge++;
                }

                if (slHp >= 87)
                {
                    specialistInstance.CriticalDodge++;
                }

                if (slHp >= 88)
                {
                    specialistInstance.CriticalDodge++;
                }

                if (slHp >= 90)
                {
                    specialistInstance.DamageMinimum   += 15;
                    specialistInstance.DamageMaximum   += 15;
                    specialistInstance.CloseDefence    += 25;
                    specialistInstance.DistanceDefence += 25;
                    specialistInstance.MagicDefence    += 25;
                }

                if (slHp >= 91)
                {
                    specialistInstance.DefenceDodge         += 2;
                    specialistInstance.DistanceDefenceDodge += 2;
                }

                if (slHp >= 92)
                {
                    specialistInstance.DefenceDodge         += 2;
                    specialistInstance.DistanceDefenceDodge += 2;
                }

                if (slHp >= 93)
                {
                    specialistInstance.DefenceDodge         += 2;
                    specialistInstance.DistanceDefenceDodge += 2;
                }

                if (slHp >= 94)
                {
                    specialistInstance.DefenceDodge         += 2;
                    specialistInstance.DistanceDefenceDodge += 2;
                }

                if (slHp >= 95)
                {
                    specialistInstance.DamageMinimum        += 20;
                    specialistInstance.DamageMaximum        += 20;
                    specialistInstance.DefenceDodge         += 2;
                    specialistInstance.DistanceDefenceDodge += 2;
                }

                if (slHp >= 96)
                {
                    specialistInstance.DefenceDodge         += 2;
                    specialistInstance.DistanceDefenceDodge += 2;
                }

                if (slHp >= 97)
                {
                    specialistInstance.DefenceDodge         += 2;
                    specialistInstance.DistanceDefenceDodge += 2;
                }

                if (slHp >= 98)
                {
                    specialistInstance.DefenceDodge         += 2;
                    specialistInstance.DistanceDefenceDodge += 2;
                }

                if (slHp >= 99)
                {
                    specialistInstance.DefenceDodge         += 2;
                    specialistInstance.DistanceDefenceDodge += 2;
                }

                if (slHp >= 100)
                {
                    specialistInstance.FireResistance       += 3;
                    specialistInstance.WaterResistance      += 3;
                    specialistInstance.LightResistance      += 3;
                    specialistInstance.DarkResistance       += 3;
                    specialistInstance.CloseDefence         += 30;
                    specialistInstance.DistanceDefence      += 30;
                    specialistInstance.MagicDefence         += 30;
                    specialistInstance.DamageMinimum        += 20;
                    specialistInstance.DamageMaximum        += 20;
                    specialistInstance.DefenceDodge         += 2;
                    specialistInstance.DistanceDefenceDodge += 2;
                    specialistInstance.CriticalDodge++;
                }

                #endregion

                #region slElement

                if (slElement >= 1)
                {
                    specialistInstance.ElementRate += 2;
                }

                if (slElement >= 10)
                {
                    specialistInstance.MP += 100;
                }

                if (slElement >= 20)
                {
                    specialistInstance.MagicDefence += 5;
                }

                if (slElement >= 30)
                {
                    specialistInstance.FireResistance  += 2;
                    specialistInstance.WaterResistance += 2;
                    specialistInstance.LightResistance += 2;
                    specialistInstance.DarkResistance  += 2;
                    specialistInstance.ElementRate     += 2;
                }

                if (slElement >= 40)
                {
                    specialistInstance.MP += 100;
                }

                if (slElement >= 50)
                {
                    specialistInstance.MagicDefence += 5;
                }

                if (slElement >= 60)
                {
                    specialistInstance.FireResistance  += 3;
                    specialistInstance.WaterResistance += 3;
                    specialistInstance.LightResistance += 3;
                    specialistInstance.DarkResistance  += 3;
                    specialistInstance.ElementRate     += 2;
                }

                if (slElement >= 70)
                {
                    specialistInstance.MP += 100;
                }

                if (slElement >= 80)
                {
                    specialistInstance.MagicDefence += 5;
                }

                if (slElement >= 90)
                {
                    specialistInstance.FireResistance  += 4;
                    specialistInstance.WaterResistance += 4;
                    specialistInstance.LightResistance += 4;
                    specialistInstance.DarkResistance  += 4;
                    specialistInstance.ElementRate     += 2;
                }

                if (slElement >= 100)
                {
                    specialistInstance.FireResistance  += 6;
                    specialistInstance.WaterResistance += 6;
                    specialistInstance.LightResistance += 6;
                    specialistInstance.DarkResistance  += 6;
                    specialistInstance.MagicDefence    += 5;
                    specialistInstance.MP          += 200;
                    specialistInstance.ElementRate += 2;
                }

                #endregion

                session.SendPacket(session.Character.GenerateStatChar());
                session.SendPacket(session.Character.GenerateStat());
                session.SendPacket(specialistInstance.GenerateSlInfo());
                session.SendPacket(
                    UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("POINTS_SET"), 0));
            }
            else if (!session.Character.IsSitting)
            {
                if (session.Character.Skills.Any(s => !s.CanBeUsed()))
                {
                    session.SendPacket(
                        UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("SKILLS_IN_LOADING"),
                                                        0));
                    return;
                }

                if (specialistInstance == null)
                {
                    session.SendPacket(UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("NO_SP"),
                                                                       0));
                    return;
                }

                if (session.Character.IsVehicled)
                {
                    session.SendPacket(
                        UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("REMOVE_VEHICLE"), 0));
                    return;
                }

                double currentRunningSeconds =
                    (DateTime.UtcNow - Process.GetCurrentProcess().StartTime.AddHours(-2).AddSeconds(-50)).TotalSeconds;

                if (session.Character.UseSp)
                {
                    session.Character.LastSp = currentRunningSeconds;
                    session.RemoveSp(specialistInstance.ItemVNum);
                }
                else
                {
                    if (session.Character.LastMove.AddSeconds(1) >= DateTime.UtcNow ||
                        session.Character.LastSkillUse.AddSeconds(2) >= DateTime.UtcNow)
                    {
                        return;
                    }

                    if (session.Character.SpPoint == 0 && session.Character.SpAdditionPoint == 0)
                    {
                        session.SendPacket(
                            UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("SP_NOPOINTS"), 0));
                    }

                    double timeSpanSinceLastSpUsage = currentRunningSeconds - session.Character.LastSp;
                    if (timeSpanSinceLastSpUsage >= session.Character.SpCooldown)
                    {
                        if (Type == 1)
                        {
                            if (session.Character.Buff.Any(s => s.Card.BuffType == BuffType.Bad))
                            {
                                session.SendPacket(
                                    UserInterfaceHelper.GenerateMsg(
                                        Language.Instance.GetMessageFromKey("UNDER_BAD_BUFF"), 0));
                                return;
                            }
                            DateTime delay = DateTime.UtcNow.AddSeconds(-6);
                            if (session.Character.LastDelay > delay &&
                                session.Character.LastDelay < delay.AddSeconds(2))
                            {
                                session.ChangeSp();
                            }
                        }
                        else
                        {
                            session.Character.LastDelay = DateTime.UtcNow;
                            session.SendPacket(UserInterfaceHelper.GenerateDelay(5000, 3, "#sl^1"));
                            session.CurrentMapInstance?.Broadcast(
                                UserInterfaceHelper.GenerateGuri(2, 1, session.Character.CharacterId),
                                session.Character.PositionX, session.Character.PositionY);
                        }
                    }
                    else
                    {
                        session.SendPacket(UserInterfaceHelper.GenerateMsg(
                                               string.Format(Language.Instance.GetMessageFromKey("SP_INLOADING"),
                                                             session.Character.SpCooldown - (int)Math.Round(timeSpanSinceLastSpUsage, 0)), 0));
                    }
                }
            }
        }
Ejemplo n.º 2
0
        private void ExecuteHandler(ClientSession session)
        {
            if (session.Account.IsVerified || Type == 4 && Argument == 11)
            {
                if (Data.HasValue && Type == 10 && Data.Value >= 973 &&
                    Data.Value <= 999 && !session.Character.EmoticonsBlocked)
                {
                    if (Parameter == session.Character.CharacterId)
                    {
                        session.CurrentMapInstance?.Broadcast(session,
                                                              StaticPacketHelper.GenerateEff(UserType.Player, session.Character.CharacterId,
                                                                                             Data.Value + 4099), ReceiverType.AllNoEmoBlocked);
                    }
                    else if (Parameter.TryCastToInt(out int mateTransportId))
                    {
                        Mate mate = session.Character.Mates.Find(s => s.MateTransportId == mateTransportId);
                        if (mate != null)
                        {
                            session.CurrentMapInstance?.Broadcast(session,
                                                                  StaticPacketHelper.GenerateEff(UserType.Npc, mate.MateTransportId,
                                                                                                 Data.Value + 4099), ReceiverType.AllNoEmoBlocked);
                        }
                    }
                }
                else if (Type == 204)
                {
                    if (Argument == 0 && short.TryParse(Parameter.ToString(), out short slot))
                    {
                        ItemInstance shell =
                            session.Character.Inventory.LoadBySlotAndType(slot, InventoryType.Equipment);
                        if (shell?.ShellEffects.Count == 0 && shell.Upgrade > 0 && shell.Rare > 0 &&
                            session.Character.Inventory.CountItem(1429) >= ((shell.Upgrade / 10) + shell.Rare))
                        {
                            shell.SetShellEffects();
                            session.SendPacket(
                                UserInterfaceHelper.GenerateMsg(
                                    Language.Instance.GetMessageFromKey("OPTION_IDENTIFIED"), 0));
                            session.SendPacket(StaticPacketHelper.GenerateEff(UserType.Player,
                                                                              session.Character.CharacterId, 3006));
                            session.Character.Inventory.RemoveItemAmount(1429, (shell.Upgrade / 10) + shell.Rare);
                        }
                    }
                }
                else if (Type == 205)
                {
                    if (Parameter.TryCastToShort(out short slot))
                    {
                        ItemInstance inv = session.Character.Inventory.LoadBySlotAndType(slot, InventoryType.Equipment);
                        if (inv.Rare < 1 || inv.Rare > 8 || inv.Item.LevelMinimum > 99 ||
                            inv.BoundCharacterId == null)
                        {
                            return;
                        }

                        short[][] parfumeReq =
                        {
                            new short[] { 0, 0,  0,  0,  0,   5,  10,  10,  20 },
                            new short[] { 0, 0,  0,  0,  5,  10,  10,  20,  40 },
                            new short[] { 0, 0,  0,  5, 10,  10,  20,  40,  80 },
                            new short[] { 0, 0,  5,  5, 10,  20,  40,  80, 120 },
                            new short[] { 0, 0,  5, 10, 20,  40,  80, 120, 160 },
                            new short[] { 0, 0,  5, 20, 40,  80, 120, 160, 200 },
                            new short[] { 0, 0, 10, 40, 80, 120, 160, 200, 300 },
                            new short[] { 0, 0, 10, 40, 80, 120, 160, 200, 400 }
                        };
                        int[] goldReq =
                        {
                            1000,
                            2000,
                            5000,
                            8000,
                            10000,
                            12500,
                            15000,
                            17500,
                            20000,
                            30000
                        };

                        if (session.Character.Inventory.CountItem(1428)
                            >= parfumeReq[inv.Rare - 1][(inv.Item.LevelMinimum / 10) - 1] &&
                            session.Character.Gold >= goldReq[(inv.Item.LevelMinimum / 10) - 1])
                        {
                            session.Character.Inventory.RemoveItemAmount(1428,
                                                                         parfumeReq[inv.Rare - 1][(inv.Item.LevelMinimum / 10) - 1]);
                            session.Character.Gold -= goldReq[(inv.Item.LevelMinimum / 10) - 1];
                            session.SendPacket(session.Character.GenerateGold());
                            inv.BoundCharacterId = session.Character.CharacterId;
                            session.SendPacket(
                                UserInterfaceHelper.GenerateMsg(
                                    Language.Instance.GetMessageFromKey("SHELL_PERFUMED"), 0));
                        }
                    }
                }
                else if (Type == 300)
                {
                    if (Argument == 8023 && Parameter.TryCastToShort(out short slot))
                    {
                        ItemInstance box = session.Character.Inventory.LoadBySlotAndType(slot, InventoryType.Equipment);
                        if (box != null)
                        {
                            box.Item.Use(session, ref box, 1, new[] { Data?.ToString() ?? string.Empty });
                        }
                    }
                }
                else if (Type == 506)
                {
                    session.Character.IsWaitingForEvent |= ServerManager.Instance.EventInWaiting;
                }
                else if (Type == 199 && Argument == 2)
                {
                    short[] listWingOfFriendship = { 2160, 2312, 10048 };
                    short   vnumToUse            = -1;
                    foreach (short vnum in listWingOfFriendship)
                    {
                        if (session.Character.Inventory.CountItem(vnum) > 0)
                        {
                            vnumToUse = vnum;
                        }
                    }

                    if (vnumToUse != -1 || session.Character.IsSpouseOfCharacter(Parameter))
                    {
                        ClientSession sess = ServerManager.Instance.GetSessionByCharacterId(Parameter);
                        if (sess != null)
                        {
                            if (session.Character.IsFriendOfCharacter(Parameter))
                            {
                                if (sess.CurrentMapInstance?.MapInstanceType == MapInstanceType.BaseMapInstance)
                                {
                                    if (session.Character.MapInstance.MapInstanceType
                                        != MapInstanceType.BaseMapInstance ||
                                        (ServerManager.Instance.ChannelId == 51 &&
                                         session.Character.Faction != sess.Character.Faction))
                                    {
                                        session.SendPacket(
                                            session.Character.GenerateSay(
                                                Language.Instance.GetMessageFromKey("CANT_USE_THAT"), 10));
                                        return;
                                    }

                                    short mapy  = sess.Character.PositionY;
                                    short mapx  = sess.Character.PositionX;
                                    short mapId = sess.Character.MapInstance.Map.MapId;

                                    ServerManager.Instance.ChangeMap(session.Character.CharacterId, mapId, mapx, mapy);
                                    if (!session.Character.IsSpouseOfCharacter(Parameter))
                                    {
                                        session.Character.Inventory.RemoveItemAmount(vnumToUse);
                                    }
                                }
                                else
                                {
                                    session.SendPacket(
                                        UserInterfaceHelper.GenerateMsg(
                                            Language.Instance.GetMessageFromKey("USER_ON_INSTANCEMAP"), 0));
                                }
                            }
                        }
                        else
                        {
                            session.SendPacket(
                                UserInterfaceHelper.GenerateMsg(
                                    Language.Instance.GetMessageFromKey("USER_NOT_CONNECTED"), 0));
                        }
                    }
                    else
                    {
                        session.SendPacket(
                            session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NO_WINGS"), 10));
                    }
                }
                else if (Type == 400)
                {
                    if (!session.HasCurrentMapInstance)
                    {
                        return;
                    }

                    MapNpc npc = session.CurrentMapInstance.Npcs.Find(n => n.MapNpcId.Equals(Argument));
                    if (npc != null)
                    {
                        NpcMonster mapobject = ServerManager.GetNpcMonster(npc.NpcVNum);

                        int rateDrop = ServerManager.Instance.Configuration.RateDrop;
                        int delay    = (int)Math.Round(
                            (3 + (mapobject.RespawnTime / 1000d)) * session.Character.TimesUsed);
                        delay = delay > 11 ? 8 : delay;
                        if (session.Character.LastMapObject.AddSeconds(delay) < DateTime.UtcNow)
                        {
                            if (mapobject.Drops.Any(s => s.MonsterVNum != null) && mapobject.VNumRequired > 10 &&
                                session.Character.Inventory
                                .CountItem(mapobject.VNumRequired)
                                < mapobject.AmountRequired)
                            {
                                session.SendPacket(
                                    UserInterfaceHelper.GenerateMsg(
                                        Language.Instance.GetMessageFromKey("NOT_ENOUGH_ITEM"), 0));
                                return;
                            }

                            Random  random       = new Random();
                            double  randomAmount = ServerManager.RandomNumber() * random.NextDouble();
                            DropDTO drop         = mapobject.Drops.Find(s => s.MonsterVNum == npc.NpcVNum);
                            if (drop != null)
                            {
                                int dropChance = drop.DropChance;
                                if (randomAmount <= (double)dropChance * rateDrop / 5000.000)
                                {
                                    short        vnum   = drop.ItemVNum;
                                    ItemInstance newInv = session.Character.Inventory.AddNewToInventory(vnum)
                                                          .FirstOrDefault();
                                    session.Character.LastMapObject = DateTime.UtcNow;
                                    session.Character.TimesUsed++;
                                    if (session.Character.TimesUsed >= 4)
                                    {
                                        session.Character.TimesUsed = 0;
                                    }

                                    if (newInv != null)
                                    {
                                        session.SendPacket(UserInterfaceHelper.GenerateMsg(
                                                               string.Format(Language.Instance.GetMessageFromKey("RECEIVED_ITEM"),
                                                                             newInv.Item.Name), 0));
                                        session.SendPacket(session.Character.GenerateSay(
                                                               string.Format(Language.Instance.GetMessageFromKey("RECEIVED_ITEM"),
                                                                             newInv.Item.Name), 11));
                                    }
                                    else
                                    {
                                        session.SendPacket(UserInterfaceHelper.GenerateMsg(
                                                               Language.Instance.GetMessageFromKey("NOT_ENOUGH_PLACE"), 0));
                                    }
                                }
                                else
                                {
                                    session.SendPacket(
                                        UserInterfaceHelper.GenerateMsg(
                                            Language.Instance.GetMessageFromKey("TRY_FAILED"), 0));
                                }
                            }
                        }
                        else
                        {
                            session.SendPacket(UserInterfaceHelper.GenerateMsg(
                                                   string.Format(Language.Instance.GetMessageFromKey("TRY_FAILED_WAIT"),
                                                                 (int)(session.Character.LastMapObject.AddSeconds(delay) - DateTime.UtcNow)
                                                                 .TotalSeconds), 0));
                        }
                    }
                }
                else if (Type == 710)
                {
                    if (Value != null)
                    {
                        // TODO: MAP TELEPORTER
                    }
                }
                else if (Type == 750)
                {
                    const short baseVnum = 1623;
                    if (Argument.TryCastToByte(out byte faction) &&
                        (Enum.IsDefined(typeof(FactionType), faction) ||
                         Enum.IsDefined(typeof(FactionType), (byte)(faction / 2))) &&
                        session.Character.Inventory.CountItem(baseVnum + faction) > 0)
                    {
                        if (faction < 3)
                        {
                            if (session.Character.Family != null)
                            {
                                session.SendPacket(
                                    UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("IN_FAMILY"),
                                                                    0));
                                return;
                            }

                            session.Character.Faction = (FactionType)faction;
                            session.Character.Inventory.RemoveItemAmount(baseVnum + faction);
                            session.SendPacket("scr 0 0 0 0 0 0 0");
                            session.SendPacket(session.Character.GenerateFaction());
                            session.SendPacket(StaticPacketHelper.GenerateEff(UserType.Player,
                                                                              session.Character.CharacterId, 4799 + faction));
                            session.SendPacket(UserInterfaceHelper.GenerateMsg(
                                                   Language.Instance.GetMessageFromKey($"GET_PROTECTION_POWER_{faction}"), 0));
                        }
                        else
                        {
                            if (session.Character.Family == null || session.Character.Family.FamilyCharacters
                                .Find(s => s.Authority.Equals(FamilyAuthority.Head))?.CharacterId
                                .Equals(session.Character.CharacterId) != true)
                            {
                                session.SendPacket(
                                    UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("NO_FAMILY"),
                                                                    0));
                                return;
                            }

                            if (session.Character.Family.LastFactionChange > DateTime.UtcNow.AddDays(-1).Ticks)
                            {
                                session.SendPacket(UserInterfaceHelper.GenerateMsg(
                                                       Language.Instance.GetMessageFromKey("CHANGE_NOT PERMITTED"), 0));
                                return;
                            }

                            session.Character.Faction = (FactionType)(faction / 2);
                            session.Character.Inventory.RemoveItemAmount(baseVnum + faction);
                            session.SendPacket("scr 0 0 0 0 0 0 0");
                            session.SendPacket(session.Character.GenerateFaction());
                            session.SendPacket(StaticPacketHelper.GenerateEff(UserType.Player,
                                                                              session.Character.CharacterId, 4799 + (faction / 2)));
                            session.SendPacket(UserInterfaceHelper.GenerateMsg(
                                                   Language.Instance.GetMessageFromKey($"GET_PROTECTION_POWER_{faction / 2}"), 0));
                            session.Character.Family.LastFactionChange = DateTime.UtcNow.Ticks;
                            session.Character.Save();
                            ServerManager.Instance.FamilyRefresh(session.Character.Family.FamilyId);
                            CommunicationServiceClient.Instance.SendMessageToCharacter(new ScsCharacterMessage
                            {
                                DestinationCharacterId = session.Character.Family.FamilyId,
                                SourceCharacterId      = 0,
                                SourceWorldId          = ServerManager.Instance.WorldId,
                                Message = "fhis_stc",
                                Type    = MessageType.Family
                            });
                        }
                    }
                }
                else if (Type == 2)
                {
                    session.CurrentMapInstance?.Broadcast(
                        UserInterfaceHelper.GenerateGuri(2, 1, session.Character.CharacterId),
                        session.Character.PositionX, session.Character.PositionY);
                }
                else if (Type == 4)
                {
                    const int speakerVNum = 2173;
                    const int petnameVNum = 2157;
                    if (Argument == 1 && Data.HasValue)
                    {
                        Mate mate = session.Character.Mates.Find(s => s.MateTransportId == Data.Value);
                        if (mate != null && session.Character.Inventory.CountItem(petnameVNum) > 0)
                        {
                            mate.Name = Value.Truncate(16);
                            session.CurrentMapInstance?.Broadcast(mate.GenerateOut(), ReceiverType.AllExceptMe);
                            session.CurrentMapInstance?.Broadcast(mate.GenerateIn());
                            session.SendPacket(mate.GenerateCond());
                            session.SendPacket(
                                UserInterfaceHelper.GenerateInfo(Language.Instance.GetMessageFromKey("NEW_NAME_PET")));
                            session.SendPacket(session.Character.GeneratePinit());
                            session.SendPackets(session.Character.GeneratePst());
                            session.SendPackets(session.Character.GenerateScP());
                            session.Character.Inventory.RemoveItemAmount(petnameVNum);
                        }
                    }

                    // presentation message
                    if (Argument == 2)
                    {
                        int presentationVNum = session.Character.Inventory.CountItem(1117) > 0
                            ? 1117
                            : (session.Character.Inventory.CountItem(9013) > 0 ? 9013 : -1);
                        if (presentationVNum != -1)
                        {
                            string   message    = string.Empty;
                            string[] valuesplit = Value?.Split(' ');
                            if (valuesplit == null)
                            {
                                return;
                            }

                            for (int i = 0; i < valuesplit.Length; i++)
                            {
                                message += valuesplit[i] + "^";
                            }

                            message = message.Substring(0, message.Length - 1); // Remove the last ^
                            message = message.Trim();
                            if (message.Length > 60)
                            {
                                message = message.Substring(0, 60);
                            }

                            session.Character.Biography = message;
                            session.SendPacket(
                                session.Character.GenerateSay(Language.Instance.GetMessageFromKey("INTRODUCTION_SET"),
                                                              10));
                            session.Character.Inventory.RemoveItemAmount(presentationVNum);
                        }
                    }

                    // Speaker
                    if (Argument == 3 && session.Character.Inventory.CountItem(speakerVNum) > 0)
                    {
                        string message =
                            $"[{session.Character.Name}]:";
                        int      baseLength = message.Length;
                        string[] valuesplit = Value?.Split(' ');
                        if (valuesplit == null)
                        {
                            return;
                        }

                        for (int i = 0; i < valuesplit.Length; i++)
                        {
                            message += valuesplit[i] + " ";
                        }

                        if (message.Length > 120 + baseLength)
                        {
                            message = message.Substring(0, 120 + baseLength);
                        }

                        message = message.Replace("\n", string.Empty).Replace("\r", string.Empty)
                                  .Replace($"<{Language.Instance.GetMessageFromKey("SPEAKER")}>", string.Empty).Trim();
                        message = $"<{Language.Instance.GetMessageFromKey("SPEAKER")}> {message}";
                        if (session.Character.IsMuted())
                        {
                            session.SendPacket(
                                session.Character.GenerateSay(
                                    Language.Instance.GetMessageFromKey("SPEAKER_CANT_BE_USED"), 10));
                            return;
                        }

                        session.Character.Inventory.RemoveItemAmount(speakerVNum);
                        ServerManager.Instance.Broadcast(session.Character.GenerateSay(message, 13));

                        if (ServerManager.Instance.Configuration.UseChatLogService)
                        {
                            ChatLogServiceClient.Instance.LogChatMessage(new ChatLogEntry
                            {
                                Sender      = session.Character.Name,
                                SenderId    = session.Character.CharacterId,
                                Receiver    = null,
                                ReceiverId  = null,
                                MessageType = ChatLogType.Speaker,
                                Message     = message
                            });
                        }
                    }

                    if (Argument == 11 && !string.IsNullOrWhiteSpace(Value) &&
                        !string.IsNullOrWhiteSpace(session.Account.TotpSecret))
                    {
                        Totp totp = new Totp(Base32Encoding.ToBytes(session.Account.TotpSecret));
                        if (totp.VerifyTotp(Value, out long _, VerificationWindow.RfcSpecifiedNetworkDelay))
                        {
                            session.Character.GeneralLogs.Add(new GeneralLogDTO
                            {
                                AccountId = session.Account.AccountId,
                                IpAddress = session.IpAddress,
                                LogType   = GeneralLogType.TOTP.ToString(),
                                LogData   = "SUCCESS",
                                Timestamp = DateTime.UtcNow
                            });
                            session.Account.IsVerified = true;
                            session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("TOTP_VERIFIED"), 12));
                        }
                        else
                        {
                            session.Character.GeneralLogs.Add(new GeneralLogDTO
                            {
                                AccountId = session.Account.AccountId,
                                IpAddress = session.IpAddress,
                                LogType   = GeneralLogType.TOTP.ToString(),
                                LogData   = "FAIL",
                                Timestamp = DateTime.UtcNow
                            });
                            session.Disconnect();
                        }
                    }
                }
                else if (Type == 199 && Argument == 1)
                {
                    if (!session.Character.IsFriendOfCharacter(Parameter))
                    {
                        session.SendPacket(Language.Instance.GetMessageFromKey("CHARACTER_NOT_IN_FRIENDLIST"));
                        return;
                    }

                    session.SendPacket(UserInterfaceHelper.GenerateDelay(3000, 4, $"#guri^199^2^{Parameter}"));
                }
                else if (Type == 201)
                {
                    if (session.Character.StaticBonusList.Any(s => s.StaticBonusType == StaticBonusType.PetBasket))
                    {
                        session.SendPacket(session.Character.GenerateStashAll());
                    }
                }
                else if (Type == 202)
                {
                    session.SendPacket(
                        session.Character.GenerateSay(Language.Instance.GetMessageFromKey("PARTNER_BACKPACK"), 10));
                    session.SendPacket(session.Character.GeneratePStashAll());
                }
                else if (Type == 208 && Argument == 0)
                {
                    if (short.TryParse(Value, out short mountSlot) &&
                        Parameter.TryCastToShort(out short pearlSlot))
                    {
                        ItemInstance mount =
                            session.Character.Inventory.LoadBySlotAndType <ItemInstance>(mountSlot, InventoryType.Main);
                        ItemInstance pearl =
                            session.Character.Inventory.LoadBySlotAndType(pearlSlot, InventoryType.Equipment);
                        if (mount != null && pearl != null)
                        {
                            pearl.HoldingVNum = mount.ItemVNum;
                            session.Character.Inventory.RemoveItemFromInventory(mount.Id);
                        }
                    }
                }
                else if (Type == 209 && Argument == 0)
                {
                    if (short.TryParse(Value, out short mountSlot) &&
                        Parameter.TryCastToShort(out short pearlSlot))
                    {
                        ItemInstance fairy =
                            session.Character.Inventory.LoadBySlotAndType(mountSlot, InventoryType.Equipment);
                        ItemInstance pearl =
                            session.Character.Inventory.LoadBySlotAndType(pearlSlot, InventoryType.Equipment);
                        if (fairy != null && pearl != null)
                        {
                            pearl.HoldingVNum = fairy.ItemVNum;
                            pearl.ElementRate = fairy.ElementRate;
                            session.Character.Inventory.RemoveItemFromInventory(fairy.Id);
                        }
                    }
                }
                else if (Type == 203 && Argument == 0)
                {
                    // SP points initialization
                    int[] listPotionResetVNums = { 1366, 1427, 5115, 9040 };
                    int   vnumToUse            = -1;
                    foreach (int vnum in listPotionResetVNums)
                    {
                        if (session.Character.Inventory.CountItem(vnum) > 0)
                        {
                            vnumToUse = vnum;
                        }
                    }

                    if (vnumToUse != -1)
                    {
                        if (session.Character.UseSp)
                        {
                            ItemInstance specialistInstance =
                                session.Character.Inventory.LoadBySlotAndType((byte)EquipmentType.Sp,
                                                                              InventoryType.Wear);
                            if (specialistInstance != null)
                            {
                                specialistInstance.SlDamage  = 0;
                                specialistInstance.SlDefence = 0;
                                specialistInstance.SlElement = 0;
                                specialistInstance.SlHP      = 0;

                                specialistInstance.DamageMinimum        = 0;
                                specialistInstance.DamageMaximum        = 0;
                                specialistInstance.HitRate              = 0;
                                specialistInstance.CriticalLuckRate     = 0;
                                specialistInstance.CriticalRate         = 0;
                                specialistInstance.DefenceDodge         = 0;
                                specialistInstance.DistanceDefenceDodge = 0;
                                specialistInstance.ElementRate          = 0;
                                specialistInstance.DarkResistance       = 0;
                                specialistInstance.LightResistance      = 0;
                                specialistInstance.FireResistance       = 0;
                                specialistInstance.WaterResistance      = 0;
                                specialistInstance.CriticalDodge        = 0;
                                specialistInstance.CloseDefence         = 0;
                                specialistInstance.DistanceDefence      = 0;
                                specialistInstance.MagicDefence         = 0;
                                specialistInstance.HP = 0;
                                specialistInstance.MP = 0;

                                session.Character.Inventory.RemoveItemAmount(vnumToUse);
                                session.Character.Inventory.DeleteFromSlotAndType((byte)EquipmentType.Sp,
                                                                                  InventoryType.Wear);
                                session.Character.Inventory.AddToInventoryWithSlotAndType(specialistInstance,
                                                                                          InventoryType.Wear, (byte)EquipmentType.Sp);
                                session.SendPacket(session.Character.GenerateCond());
                                session.SendPacket(specialistInstance.GenerateSlInfo());
                                session.SendPacket(session.Character.GenerateLev());
                                session.SendPacket(session.Character.GenerateStatChar());
                                session.SendPacket(
                                    UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("POINTS_RESET"),
                                                                    0));
                            }
                        }
                        else
                        {
                            session.SendPacket(
                                session.Character.GenerateSay(
                                    Language.Instance.GetMessageFromKey("TRANSFORMATION_NEEDED"), 10));
                        }
                    }
                    else
                    {
                        session.SendPacket(
                            session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NOT_ENOUGH_POINTS"),
                                                          10));
                    }
                }
            }