예제 #1
0
 public Buff(short id, byte level = 10, bool isPermaBuff = false)
 {
     Card        = ServerManager.GetCard(id);
     Level       = level;
     IsPermaBuff = isPermaBuff;
 }
예제 #2
0
        public override void Use(ClientSession session, ref ItemInstance inv, byte Option = 0, string[] packetsplit = null)
        {
            switch (Effect)
            {
            case 10:
            {
                switch (EffectValue)
                {
                case 1:
                    if (session.Character.Inventory.CountItem(1036) < 1 || session.Character.Inventory.CountItem(1013) < 1)
                    {
                        return;
                    }
                    session.Character.Inventory.RemoveItemAmount(1036);
                    session.Character.Inventory.RemoveItemAmount(1013);
                    if (ServerManager.RandomNumber() < 25)
                    {
                        switch (ServerManager.RandomNumber(0, 2))
                        {
                        case 0:
                            session.Character.GiftAdd(1015, 1);
                            break;

                        case 1:
                            session.Character.GiftAdd(1016, 1);
                            break;
                        }
                    }
                    break;

                case 2:
                    if (session.Character.Inventory.CountItem(1038) < 1 || session.Character.Inventory.CountItem(1013) < 1)
                    {
                        return;
                    }
                    session.Character.Inventory.RemoveItemAmount(1038);
                    session.Character.Inventory.RemoveItemAmount(1013);
                    if (ServerManager.RandomNumber() < 25)
                    {
                        switch (ServerManager.RandomNumber(0, 4))
                        {
                        case 0:
                            session.Character.GiftAdd(1031, 1);
                            break;

                        case 1:
                            session.Character.GiftAdd(1032, 1);
                            break;

                        case 2:
                            session.Character.GiftAdd(1033, 1);
                            break;

                        case 3:
                            session.Character.GiftAdd(1034, 1);
                            break;
                        }
                    }
                    break;

                case 3:
                    if (session.Character.Inventory.CountItem(1037) < 1 || session.Character.Inventory.CountItem(1013) < 1)
                    {
                        return;
                    }
                    session.Character.Inventory.RemoveItemAmount(1037);
                    session.Character.Inventory.RemoveItemAmount(1013);
                    if (ServerManager.RandomNumber() < 25)
                    {
                        switch (ServerManager.RandomNumber(0, 17))
                        {
                        case 0:
                        case 1:
                        case 2:
                        case 3:
                        case 4:
                            session.Character.GiftAdd(1017, 1);
                            break;

                        case 5:
                        case 6:
                        case 7:
                        case 8:
                            session.Character.GiftAdd(1018, 1);
                            break;

                        case 9:
                        case 10:
                        case 11:
                            session.Character.GiftAdd(1019, 1);
                            break;

                        case 12:
                        case 13:
                            session.Character.GiftAdd(1020, 1);
                            break;

                        case 14:
                            session.Character.GiftAdd(1021, 1);
                            break;

                        case 15:
                            session.Character.GiftAdd(1022, 1);
                            break;

                        case 16:
                            session.Character.GiftAdd(1023, 1);
                            break;
                        }
                    }
                    break;
                }

                session.Character.GiftAdd(1014, (byte)ServerManager.RandomNumber(5, 11));
            }
            break;

            default:
                Logger.Warn(string.Format(Language.Instance.GetMessageFromKey("NO_HANDLER_ITEM"), GetType(), VNum, Effect, EffectValue));
                break;
            }
        }
예제 #3
0
        public override void Use(ClientSession session, ref ItemInstance inv, byte Option = 0, string[] packetsplit = null)
        {
            switch (Effect)
            {
            // Shell
            case 0:
                if (inv.Item.ItemType == ItemType.Shell)
                {
                    if (inv.ShellEffects.Count != 0 && packetsplit?.Length > 9 && byte.TryParse(packetsplit[9], out byte islot))
                    {
                        ItemInstance wearable = session.Character.Inventory.LoadBySlotAndType <ItemInstance>(islot, InventoryType.Equipment);
                        if (wearable != null && (wearable.Item.ItemType == ItemType.Weapon || wearable.Item.ItemType == ItemType.Armor) && wearable.Item.LevelMinimum >= inv.Upgrade && wearable.Rare >= inv.Rare && !wearable.Item.IsHeroic)
                        {
                            bool weapon = false;
                            if ((inv.ItemVNum >= 565 && inv.ItemVNum <= 576) || (inv.ItemVNum >= 589 && inv.ItemVNum <= 598))
                            {
                                weapon = true;
                            }
                            else if ((inv.ItemVNum >= 577 && inv.ItemVNum <= 588) || (inv.ItemVNum >= 656 && inv.ItemVNum <= 664) || inv.ItemVNum == 599)
                            {
                                weapon = false;
                            }
                            else
                            {
                                return;
                            }
                            if ((wearable.Item.ItemType == ItemType.Weapon && weapon) || (wearable.Item.ItemType == ItemType.Armor && !weapon))
                            {
                                if (inv.ShellEffects.Count > 0 && ServerManager.RandomNumber() < 50)
                                {
                                    session.Character.DeleteItemByItemInstanceId(inv.Id);
                                    session.SendPacket(UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("OPTION_APPLY_FAIL"), 0));
                                    return;
                                }
                                wearable.ShellEffects.Clear();
                                DAOFactory.ShellEffectDAO.DeleteByEquipmentSerialId(wearable.EquipmentSerialId);
                                wearable.ShellEffects.AddRange(inv.ShellEffects);
                                if (wearable.EquipmentSerialId == Guid.Empty)
                                {
                                    wearable.EquipmentSerialId = Guid.NewGuid();
                                }
                                DAOFactory.ShellEffectDAO.InsertOrUpdateFromList(wearable.ShellEffects, wearable.EquipmentSerialId);

                                session.Character.DeleteItemByItemInstanceId(inv.Id);
                                session.SendPacket(UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("OPTION_APPLY_SUCCESS"), 0));
                            }
                        }
                    }
                    return;
                }

                if (ItemType == ItemType.Event)
                {
                    session.CurrentMapInstance?.Broadcast(StaticPacketHelper.GenerateEff(UserType.Player, session.Character.CharacterId, EffectValue));
                    if (MappingHelper.GuriItemEffects.ContainsKey(EffectValue))
                    {
                        session.CurrentMapInstance?.Broadcast(UserInterfaceHelper.GenerateGuri(19, 1, session.Character.CharacterId, MappingHelper.GuriItemEffects[EffectValue]), session.Character.MapX, session.Character.MapY);
                    }
                    session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                }
                break;

            //Bank
            case 10066:
                if (session.Character.MapInstance.MapInstanceType != MapInstanceType.BaseMapInstance)
                {
                    return;
                }

                session.Character.OpenBank();
                session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                return;

            case 10541:
                if (ItemType == ItemType.Event)
                {
                    session.CurrentMapInstance?.Broadcast(StaticPacketHelper.GenerateEff(UserType.Player, session.Character.CharacterId, EffectValue));
                    if (MappingHelper.GuriItemEffects.ContainsKey(EffectValue))
                    {
                        session.CurrentMapInstance?.Broadcast(UserInterfaceHelper.GenerateGuri(19, 1, session.Character.CharacterId, MappingHelper.GuriItemEffects[EffectValue]), session.Character.MapX, session.Character.MapY);
                    }

                    session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                }

                break;


            //respawn objects
            case 1:
                if (session.Character.MapInstance.MapInstanceType != MapInstanceType.BaseMapInstance || ServerManager.Instance.ChannelId == 51)
                {
                    session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("CANT_USE_THAT"), 10));
                    return;
                }

                if (inv.Item.VNum == 2188 /* LoD Teleport Scroll */)
                {
                    session.Character.Inventory.RemoveItemAmount(inv.Item.VNum);
                    ServerManager.Instance.ChangeMap(session.Character.CharacterId, 98, (short)ServerManager.RandomNumber(12, 18), (short)ServerManager.RandomNumber(18, 24));
                    return;
                }

                int type, secondaryType, inventoryType, slot;
                if (packetsplit != null && int.TryParse(packetsplit[2], out type) && int.TryParse(packetsplit[3], out secondaryType) && int.TryParse(packetsplit[4], out inventoryType) && int.TryParse(packetsplit[5], out slot))
                {
                    int packetType;
                    switch (EffectValue)
                    {
                    case 0:
                        if (Option == 0)
                        {
                            session.SendPacket(UserInterfaceHelper.GenerateDialog($"#u_i^{type}^{secondaryType}^{inventoryType}^{slot}^1 #u_i^{type}^{secondaryType}^{inventoryType}^{slot}^2 {Language.Instance.GetMessageFromKey("WANT_TO_SAVE_POSITION")}"));
                        }
                        else if (int.TryParse(packetsplit[6], out packetType))
                        {
                            switch (packetType)
                            {
                            case 1:
                                session.SendPacket(UserInterfaceHelper.GenerateDelay(5000, 7, $"#u_i^{type}^{secondaryType}^{inventoryType}^{slot}^3"));
                                break;

                            case 2:
                                session.SendPacket(UserInterfaceHelper.GenerateDelay(5000, 7, $"#u_i^{type}^{secondaryType}^{inventoryType}^{slot}^4"));
                                break;

                            case 3:
                                session.Character.SetReturnPoint(session.Character.MapId, session.Character.MapX, session.Character.MapY);
                                RespawnMapTypeDTO respawn = session.Character.Respawn;
                                if (respawn.DefaultX != 0 && respawn.DefaultY != 0 && respawn.DefaultMapId != 0)
                                {
                                    ServerManager.Instance.ChangeMap(session.Character.CharacterId, respawn.DefaultMapId, (short)(respawn.DefaultX + ServerManager.RandomNumber(-5, 5)), (short)(respawn.DefaultY + ServerManager.RandomNumber(-5, 5)));
                                }
                                session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                                break;

                            case 4:
                                RespawnMapTypeDTO respawnObj = session.Character.Respawn;
                                if (respawnObj.DefaultX != 0 && respawnObj.DefaultY != 0 && respawnObj.DefaultMapId != 0)
                                {
                                    ServerManager.Instance.ChangeMap(session.Character.CharacterId, respawnObj.DefaultMapId, (short)(respawnObj.DefaultX + ServerManager.RandomNumber(-5, 5)), (short)(respawnObj.DefaultY + ServerManager.RandomNumber(-5, 5)));
                                }
                                session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                                break;
                            }
                        }
                        break;



                    case 1:
                        if (int.TryParse(packetsplit[6], out packetType))
                        {
                            RespawnMapTypeDTO respawn = session.Character.Return;
                            switch (packetType)
                            {
                            case 0:
                                if (respawn.DefaultX != 0 && respawn.DefaultY != 0 && respawn.DefaultMapId != 0)
                                {
                                    session.SendPacket(UserInterfaceHelper.GenerateRp(respawn.DefaultMapId, respawn.DefaultX, respawn.DefaultY, $"#u_i^{type}^{secondaryType}^{inventoryType}^{slot}^1"));
                                }
                                break;

                            case 1:
                                session.SendPacket(UserInterfaceHelper.GenerateDelay(5000, 7, $"#u_i^{type}^{secondaryType}^{inventoryType}^{slot}^2"));
                                break;

                            case 2:
                                if (respawn.DefaultX != 0 && respawn.DefaultY != 0 && respawn.DefaultMapId != 0)
                                {
                                    ServerManager.Instance.ChangeMap(session.Character.CharacterId, respawn.DefaultMapId, respawn.DefaultX, respawn.DefaultY);
                                }
                                session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                                break;
                            }
                        }
                        break;

                    case 2:
                        if (Option == 0)
                        {
                            session.SendPacket(UserInterfaceHelper.GenerateDelay(5000, 7, $"#u_i^{type}^{secondaryType}^{inventoryType}^{slot}^1"));
                        }
                        else
                        {
                            ServerManager.Instance.JoinMiniland(session, session);
                            session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                        }
                        break;
                    }
                }
                break;

            // dyes or waxes
            case 10:
            case 11:
                if (!session.Character.IsVehicled)
                {
                    if (Effect == 10)
                    {
                        if (EffectValue == 99)
                        {
                            byte nextValue = (byte)ServerManager.RandomNumber(0, 127);
                            session.Character.HairColor = Enum.IsDefined(typeof(HairColorType), nextValue) ? (HairColorType)nextValue : 0;
                        }
                        else
                        {
                            session.Character.HairColor = Enum.IsDefined(typeof(HairColorType), (byte)EffectValue) ? (HairColorType)EffectValue : 0;
                        }
                    }
                    else
                    {
                        if (session.Character.Class == (byte)ClassType.Adventurer && EffectValue > 1)
                        {
                            session.SendPacket(UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("ADVENTURERS_CANT_USE"), 10));
                            return;
                        }
                        session.Character.HairStyle = Enum.IsDefined(typeof(HairStyleType), (byte)EffectValue) ? (HairStyleType)EffectValue : 0;
                    }
                    session.SendPacket(session.Character.GenerateEq());
                    session.CurrentMapInstance?.Broadcast(session, session.Character.GenerateIn());
                    session.CurrentMapInstance?.Broadcast(session, session.Character.GenerateGidx());
                    session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                }
                break;

            // dignity restoration
            case 14:
                if ((EffectValue == 100 || EffectValue == 200) && session.Character.Dignity < 100 && !session.Character.IsVehicled)
                {
                    session.Character.Dignity += EffectValue;
                    if (session.Character.Dignity > 100)
                    {
                        session.Character.Dignity = 100;
                    }
                    session.SendPacket(session.Character.GenerateFd());
                    session.SendPacket(StaticPacketHelper.GenerateEff(UserType.Player, session.Character.CharacterId, 50 - (byte)session.Character.Faction));
                    session.CurrentMapInstance?.Broadcast(session, session.Character.GenerateIn(), ReceiverType.AllExceptMe);
                    session.CurrentMapInstance?.Broadcast(session, session.Character.GenerateGidx(), ReceiverType.AllExceptMe);
                    session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                }
                else if (EffectValue == 2000 && session.Character.Dignity < 100 && !session.Character.IsVehicled)
                {
                    session.Character.Dignity = 100;
                    session.SendPacket(session.Character.GenerateFd());
                    session.SendPacket(StaticPacketHelper.GenerateEff(UserType.Player, session.Character.CharacterId, 50 - (byte)session.Character.Faction));
                    session.CurrentMapInstance?.Broadcast(session, session.Character.GenerateIn(), ReceiverType.AllExceptMe);
                    session.CurrentMapInstance?.Broadcast(session, session.Character.GenerateGidx(), ReceiverType.AllExceptMe);
                    session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                }
                break;

            // speakers
            case 15:
                if (!session.Character.IsVehicled && Option == 0)
                {
                    session.SendPacket(UserInterfaceHelper.GenerateGuri(10, 3, session.Character.CharacterId, 1));
                }
                break;

            // bubbles
            case 16:
                if (!session.Character.IsVehicled && Option == 0)
                {
                    session.SendPacket(UserInterfaceHelper.GenerateGuri(10, 4, session.Character.CharacterId, 1));
                    session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                }
                break;

            // wigs
            case 30:
                if (!session.Character.IsVehicled)
                {
                    ItemInstance wig = session.Character.Inventory.LoadBySlotAndType((byte)EquipmentType.Hat, InventoryType.Wear);
                    if (wig != null)
                    {
                        wig.Design = (byte)ServerManager.RandomNumber(0, 15);
                        session.SendPacket(session.Character.GenerateEq());
                        session.SendPacket(session.Character.GenerateEquipment());
                        session.CurrentMapInstance?.Broadcast(session, session.Character.GenerateIn());
                        session.CurrentMapInstance?.Broadcast(session, session.Character.GenerateGidx());
                        session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                    }
                    else
                    {
                        session.SendPacket(UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("NO_WIG"), 0));
                    }
                }
                break;

            //Fresh dye
            case 31:
                if (!session.Character.IsVehicled && session.Character.HairStyle == HairStyleType.Hair7)
                {
                    session.Character.HairStyle = HairStyleType.Hair8;
                    session.SendPacket(session.Character.GenerateEq());
                    session.CurrentMapInstance?.Broadcast(session, session.Character.GenerateIn());
                    session.CurrentMapInstance?.Broadcast(session, session.Character.GenerateGidx());
                    session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                    // idk how it works yet but seems like all characters with this hairstyle have DarkPurple hair
                    session.Character.HairColor = HairColorType.DarkPurple;
                }
                break;

            case 300:
                if (session.Character.Group != null && session.Character.Group.GroupType != GroupType.Group && session.Character.Group.IsLeader(session) && session.CurrentMapInstance.Portals.Any(s => s.Type == (short)PortalType.Raid))
                {
                    int delay = 0;
                    foreach (ClientSession sess in session.Character.Group.Characters.GetAllItems())
                    {
                        Observable.Timer(TimeSpan.FromMilliseconds(delay)).Subscribe(o =>
                        {
                            if (sess?.Character != null && session?.CurrentMapInstance != null && session?.Character != null)
                            {
                                ServerManager.Instance.ChangeMapInstance(sess.Character.CharacterId, session.CurrentMapInstance.MapInstanceId, session.Character.PositionX, session.Character.PositionY);
                            }
                        });
                        delay += 100;
                    }
                    session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                }
                break;

            //Speedbooster
            case 9011:
                if (!session.Character.Buff.ContainsKey(336))
                {
                    session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                    session.Character.AddStaticBuff(new StaticBuffDTO {
                        CardId = 336
                    });
                }
                else
                {
                    session.SendPacket(UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("ITEM_IN_USE"), 0));
                }
                break;

            //Teleport Vip shop
            case 9016:
                if (Option == 0)
                {
                    session.SendPacket($"qna #u_i^1^{session.Character.CharacterId}^{(byte)inv.Type}^{inv.Slot}^3 {Language.Instance.GetMessageFromKey("ASK_USE_EC_KEY")}");
                }
                else
                {
                    ServerManager.Instance.ChangeMap(session.Character.CharacterId, 4200, 7, 13);
                    session.SendPacket(
                        session.Character.GenerateSay(
                            Language.Instance.GetMessageFromKey("WELCOME_VIP_SHOP_MAP"), 0));
                }
                break;

            //Haar Fix
            case 9021:
                session.Character.HairStyle = HairStyleType.Hair7;
                session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                ServerManager.Instance.ChangeMapInstance(session.Character.CharacterId,
                                                         session.Character.MapInstanceId, session.Character.PositionX, session.Character.PositionY,
                                                         true);
                break;

            //Haar Fix
            case 9022:
                session.Character.HairStyle = HairStyleType.Hair6;
                session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                ServerManager.Instance.ChangeMapInstance(session.Character.CharacterId,
                                                         session.Character.MapInstanceId, session.Character.PositionX, session.Character.PositionY,
                                                         true);
                break;

            //Pes Item ID: 2457
            case 9030:
                session.SendPacket("wopen 41");
                break;

            //Luinia
            case 9041:
                if (Option == 0)
                {
                    session.SendPacket($"qna #u_i^1^{session.Character.CharacterId}^{(byte)inv.Type}^{inv.Slot}^3 {Language.Instance.GetMessageFromKey("ASK_USE_LUINIA")}");
                }
                else
                {
                    session.CurrentMapInstance?.Broadcast(
                        StaticPacketHelper.GenerateEff(UserType.Player, session.Character.CharacterId,
                                                       647), session.Character.PositionX, session.Character.PositionY);
                    Buff buff = new Buff(35, 10);
                    session.Character.AddBuff(buff, true);
                    session.SendPacket(session.Character.GenerateSay("Luinia la restauración fue utilizada.", 12));
                    session.Character.Inventory.RemoveItemFromInventory(inv.Id);
                }
                break;

            default:
                Logger.Warn(string.Format(Language.Instance.GetMessageFromKey("NO_HANDLER_ITEM"), GetType()));
                break;
            }
        }
예제 #4
0
 public Buff(short id, int level)
 {
     Card  = ServerManager.GetCard(id);
     Level = level;
 }
예제 #5
0
파일: Character.cs 프로젝트: aerzy/OpenNos
        public string GenerateIn()
        {
            int       Color = HairColor;
            Inventory head  = EquipmentList.LoadBySlotAndType((short)EquipmentType.Hat, (short)InventoryType.Equipment);

            if (head != null && ServerManager.GetItem(head.InventoryItem.ItemVNum).Colored)
            {
                Color = head.InventoryItem.Color;
            }
            Inventory fairy = EquipmentList.LoadBySlotAndType((short)EquipmentType.Fairy, (short)InventoryType.Equipment);


            return(String.Format("in 1 {0} - {1} {2} {3} {4} {5} {6} {7} {8} {9} {17} {10} {11} {12} -1 {25} {22} 0 {23} 0 {19} {18} -1 - {13} {16} {20} 0 {21} {14} 0 {15} 0 {24}", Name, CharacterId, MapX, MapY, Direction, (Authority == 2 ? 2 : 0), Gender, HairStyle, Color, Class, (int)((Hp / HPLoad()) * 100), (int)((Mp / MPLoad()) * 100), _rested, (GetDigniteIco() == 1) ? GetReputIco() : -GetDigniteIco(), 0, ArenaWinner, _invisible, generateEqListForPacket(), generateEqRareUpgradeForPacket(), (UseSp == true ? Morph : 0), (UseSp == true ? MorphUpgrade : 0), (UseSp == true ? MorphUpgrade2 : 0), fairy != null ? ServerManager.GetItem(fairy.InventoryItem.ItemVNum).Element : 0, fairy != null ? ServerManager.GetItem(fairy.InventoryItem.ItemVNum).Morph : 0, Size, fairy != null ? 2 : 0));
        }
예제 #6
0
파일: Character.cs 프로젝트: aerzy/OpenNos
        public string GeneratePairy()
        {
            Inventory fairy = EquipmentList.LoadBySlotAndType((short)EquipmentType.Fairy, (short)InventoryType.Equipment);

            if (fairy != null)
            {
                return(String.Format("pairy 1 {0} 4 {1} {2} {3}", CharacterId, ServerManager.GetItem(fairy.InventoryItem.ItemVNum).Element, fairy.InventoryItem.ElementRate, ServerManager.GetItem(fairy.InventoryItem.ItemVNum).Morph));
            }
            else
            {
                return(String.Format("pairy 1 {0} 0 0 0 40", CharacterId));
            }
        }
예제 #7
0
파일: Character.cs 프로젝트: aerzy/OpenNos
        public void LoadInventory()
        {
            IEnumerable <InventoryDTO> inventorysDTO = DAOFactory.InventoryDAO.LoadByCharacterId(CharacterId);

            InventoryList = new InventoryList();
            EquipmentList = new InventoryList();
            foreach (InventoryDTO inventory in inventorysDTO)
            {
                InventoryItemDTO inventoryItemDTO = DAOFactory.InventoryItemDAO.LoadById(inventory.InventoryItemId);
                Item             item             = ServerManager.GetItem(inventoryItemDTO.ItemVNum);

                if (inventory.Type != (short)InventoryType.Equipment)
                {
                    InventoryList.Inventory.Add(new GameObject.Inventory()
                    {
                        CharacterId     = inventory.CharacterId,
                        Slot            = inventory.Slot,
                        InventoryId     = inventory.InventoryId,
                        Type            = inventory.Type,
                        InventoryItemId = inventory.InventoryItemId,
                        InventoryItem   = new InventoryItem
                        {
                            Amount      = inventoryItemDTO.Amount,
                            ElementRate = inventoryItemDTO.ElementRate
                            ,
                            HitRate          = inventoryItemDTO.HitRate,
                            Color            = inventoryItemDTO.Color,
                            Concentrate      = inventoryItemDTO.Concentrate,
                            CriticalLuckRate = inventoryItemDTO.CriticalLuckRate,
                            CriticalRate     = inventoryItemDTO.CriticalRate,
                            DamageMaximum    = inventoryItemDTO.DamageMaximum,
                            DamageMinimum    = inventoryItemDTO.DamageMinimum,
                            DarkElement      = inventoryItemDTO.DarkElement,
                            DistanceDefence  = inventoryItemDTO.DistanceDefence,
                            Dodge            = inventoryItemDTO.Dodge,
                            FireElement      = inventoryItemDTO.FireElement,
                            InventoryItemId  = inventoryItemDTO.InventoryItemId,
                            ItemVNum         = inventoryItemDTO.ItemVNum,
                            LightElement     = inventoryItemDTO.LightElement,
                            MagicDefence     = inventoryItemDTO.MagicDefence,
                            RangeDefence     = inventoryItemDTO.RangeDefence,
                            Rare             = inventoryItemDTO.Rare,
                            SpXp             = inventoryItemDTO.SpXp,
                            SpLevel          = inventoryItemDTO.SpLevel,
                            SlDefence        = inventoryItemDTO.SlDefence,
                            SlElement        = inventoryItemDTO.SlElement,
                            SlHit            = inventoryItemDTO.SlHit,
                            SlHP             = inventoryItemDTO.SlHP,
                            Upgrade          = inventoryItemDTO.Upgrade,
                            WaterElement     = inventoryItemDTO.WaterElement,
                        }
                    });
                }
                else
                {
                    EquipmentList.Inventory.Add(new GameObject.Inventory()
                    {
                        CharacterId     = inventory.CharacterId,
                        Slot            = inventory.Slot,
                        InventoryId     = inventory.InventoryId,
                        Type            = inventory.Type,
                        InventoryItemId = inventory.InventoryItemId,
                    });
                }
            }
        }
예제 #8
0
파일: Character.cs 프로젝트: aerzy/OpenNos
        public string GenerateReqInfo()
        {
            Inventory Fairy   = EquipmentList.LoadBySlotAndType((short)EquipmentType.Fairy, (short)InventoryType.Equipment);
            Inventory Armor   = EquipmentList.LoadBySlotAndType((short)EquipmentType.Armor, (short)InventoryType.Equipment);
            Inventory Weapon2 = EquipmentList.LoadBySlotAndType((short)EquipmentType.SecondaryWeapon, (short)InventoryType.Equipment);
            Inventory Weapon  = EquipmentList.LoadBySlotAndType((short)EquipmentType.MainWeapon, (short)InventoryType.Equipment);

            return(String.Format("tc_info {0} {1} {2} {3} {4} {9} 0 {8} {5} {6} {10} {11} {12} {13} {14} {15} {16} {17} {18} 0 0 0 0 0 0 {19} 0 0 0 0 0 0 0 0 0 0 {7}", Level, Name, Fairy != null ? ServerManager.GetItem(Fairy.InventoryItem.ItemVNum).Element : 0, Fairy != null ? Fairy.InventoryItem.ElementRate : 0, Class, GetReputIco(), GetDigniteIco(),
                                 Language.Instance.GetMessageFromKey("NO_PREZ_MESSAGE"), Language.Instance.GetMessageFromKey("NO_FAMILY"),
                                 Gender, Weapon != null ? 1 : 0, Weapon != null ? Weapon.InventoryItem.Rare : 0, Weapon != null ? Weapon.InventoryItem.Upgrade : 0,
                                 Weapon2 != null ? 1 : 0, Weapon2 != null ? Weapon2.InventoryItem.Rare : 0, Weapon2 != null ? Weapon2.InventoryItem.Upgrade : 0,
                                 Armor != null ? 1 : 0, Armor != null ? Armor.InventoryItem.Rare : 0, Armor != null ? Armor.InventoryItem.Upgrade : 0, UseSp ? Morph : 0));
        }
예제 #9
0
        public void UpgradeSp(ClientSession Session, UpgradeProtection protect)
        {
            short[] upsuccess = { 100, 100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 30 };
            short[] upfail    = { 20, 25, 25, 30, 35, 40, 40, 40, 40, 40, 45, 43, 40, 37, 29 };

            int[]   goldprice       = { 200000, 200000, 200000, 200000, 200000, 500000, 500000, 500000, 500000, 500000, 1000000, 1000000, 1000000, 1000000, 1000000 };
            short[] feather         = { 3, 5, 8, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70 };
            short[] fullmoon        = { 1, 3, 5, 7, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30 };
            short[] soul            = { 2, 4, 6, 8, 10, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5 };
            short   featherVnum     = 2282;
            short   fullmoonVnum    = 1030;
            short   greenSoulVnum   = 2283;
            short   redSoulVnum     = 2284;
            short   blueSoulVnum    = 2285;
            short   dragonSkinVnum  = 2511;
            short   dragonBloodVnum = 2512;
            short   dragonHeartVnum = 2513;

            if (this.IsFixed)
            {
                return;
            }
            if (Session.Character.Gold < goldprice[this.Upgrade])
            {
                return;
            }
            if (Session.Character.InventoryList.CountItem(fullmoonVnum) < fullmoon[this.Upgrade])
            {
                return;
            }
            if (Session.Character.InventoryList.CountItem(featherVnum) < feather[this.Upgrade])
            {
                return;
            }

            if (this.Upgrade < 5)
            {
                if (this.SpLevel > 20)
                {
                    if (ServerManager.GetItem(this.ItemVNum).Morph <= 15)
                    {
                        if (Session.Character.InventoryList.CountItem(greenSoulVnum) < soul[this.Upgrade])
                        {
                            return;
                        }
                        Session.Character.InventoryList.RemoveItemAmount(greenSoulVnum, (soul[this.Upgrade]));
                    }
                    else
                    {
                        if (Session.Character.InventoryList.CountItem(dragonSkinVnum) < soul[this.Upgrade])
                        {
                            return;
                        }
                        Session.Character.InventoryList.RemoveItemAmount(dragonSkinVnum, (soul[this.Upgrade]));
                    }
                }
                else
                {
                    Session.Client.SendPacket(Session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("LVL_REQUIRED"), 21), 11));
                    return;
                }
            }
            else if (this.Upgrade < 10)
            {
                if (this.SpLevel > 40)
                {
                    if (ServerManager.GetItem(this.ItemVNum).Morph <= 15)
                    {
                        if (Session.Character.InventoryList.CountItem(redSoulVnum) < soul[this.Upgrade])
                        {
                            return;
                        }
                        Session.Character.InventoryList.RemoveItemAmount(redSoulVnum, (soul[this.Upgrade]));
                    }
                    else
                    {
                        if (Session.Character.InventoryList.CountItem(dragonBloodVnum) < soul[this.Upgrade])
                        {
                            return;
                        }
                        Session.Character.InventoryList.RemoveItemAmount(dragonBloodVnum, (soul[this.Upgrade]));
                    }
                }
                else
                {
                    Session.Client.SendPacket(Session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("LVL_REQUIRED"), 41), 11));
                    return;
                }
            }
            else
            {
                if (this.SpLevel > 50)
                {
                    if (ServerManager.GetItem(this.ItemVNum).Morph <= 15)
                    {
                        if (Session.Character.InventoryList.CountItem(blueSoulVnum) < soul[this.Upgrade])
                        {
                            return;
                        }
                        Session.Character.InventoryList.RemoveItemAmount(blueSoulVnum, (soul[this.Upgrade]));
                    }
                    else
                    {
                        if (Session.Character.InventoryList.CountItem(dragonHeartVnum) < soul[this.Upgrade])
                        {
                            return;
                        }
                        Session.Character.InventoryList.RemoveItemAmount(dragonHeartVnum, (soul[this.Upgrade]));
                    }
                }
                else
                {
                    Session.Client.SendPacket(Session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("LVL_REQUIRED"), 51), 11));

                    return;
                }
            }
            Random r   = new Random();
            int    rnd = r.Next(100);

            if (rnd <= upfail[this.Upgrade])
            {
                if (protect == UpgradeProtection.Protected)
                {
                    ServerManager.Instance.Broadcast(Session, Session.Character.GenerateEff(3004), ReceiverType.All);
                }
                Session.Client.SendPacket(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("UPGRADESP_FAILED"), 11));
                Session.Client.SendPacket(Session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("UPGRADESP_FAILED"), 0));
            }
            else if (rnd <= upsuccess[this.Upgrade])
            {
                if (protect == UpgradeProtection.Protected)
                {
                    ServerManager.Instance.Broadcast(Session, Session.Character.GenerateEff(3004), ReceiverType.All);
                }
                ServerManager.Instance.Broadcast(Session, Session.Character.GenerateEff(3005), ReceiverType.All);
                Session.Client.SendPacket(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("UPGRADESP_SUCCESS"), 12));
                Session.Client.SendPacket(Session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("UPGRADESP_SUCCESS"), 0));
                Session.Character.InventoryList.LoadByItemInstance <WearableInstance>(this.ItemInstanceId).Upgrade++;
            }
            else
            {
                if (protect == UpgradeProtection.Protected)
                {
                    ServerManager.Instance.Broadcast(Session, Session.Character.GenerateEff(3004), ReceiverType.All);
                    Session.Character.InventoryList.LoadByItemInstance <WearableInstance>(this.ItemInstanceId).IsFixed = true;
                    Session.Client.SendPacket(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("UPGRADESP_FAILED_SAVED"), 11));
                    Session.Client.SendPacket(Session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("UPGRADESP_FAILED_SAVED"), 0));
                }
                else
                {
                    Session.Character.InventoryList.LoadByItemInstance <WearableInstance>(this.ItemInstanceId).Rare = (sbyte)-2;
                    Session.Client.SendPacket(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("UPGRADESP_DESTROYED"), 11));
                    Session.Client.SendPacket(Session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("UPGRADESP_DESTROYED"), 0));
                }
            }
            Session.Character.Gold = Session.Character.Gold - goldprice[this.Upgrade];
            Session.Client.SendPacket(Session.Character.GenerateGold());
            Session.Client.SendPacket(Session.Character.GenerateEq());
            Session.Character.InventoryList.RemoveItemAmount(featherVnum, (feather[this.Upgrade]));
            Session.Character.InventoryList.RemoveItemAmount(fullmoonVnum, (fullmoon[this.Upgrade]));
            Session.Character.GenerateStartupInventory();
            Session.Client.SendPacket("shop_end 1");
        }
예제 #10
0
        public void PerfectSP(ClientSession Session, UpgradeProtection protect)
        {
            short[] upsuccess = { 50, 40, 30, 20, 10 };

            int[]   goldprice  = { 5000, 10000, 20000, 50000, 100000 };
            short[] stoneprice = { 1, 2, 3, 4, 5 };
            short   stonevnum;
            byte    upmode = 1;

            switch (ServerManager.GetItem(this.ItemVNum).Morph)
            {
            case 2:
                stonevnum = 2514;
                break;

            case 6:
                stonevnum = 2514;
                break;

            case 9:
                stonevnum = 2514;
                break;

            case 12:
                stonevnum = 2514;
                break;

            case 3:
                stonevnum = 2515;
                break;

            case 4:
                stonevnum = 2515;
                break;

            case 14:
                stonevnum = 2515;
                break;

            case 5:
                stonevnum = 2516;
                break;

            case 11:
                stonevnum = 2516;
                break;

            case 15:
                stonevnum = 2516;
                break;

            case 10:
                stonevnum = 2517;
                break;

            case 13:
                stonevnum = 2517;
                break;

            case 7:
                stonevnum = 2517;
                break;

            case 17:
                stonevnum = 2518;
                break;

            case 18:
                stonevnum = 2518;
                break;

            case 19:
                stonevnum = 2518;
                break;

            case 20:
                stonevnum = 2519;
                break;

            case 21:
                stonevnum = 2519;
                break;

            case 22:
                stonevnum = 2519;
                break;

            case 23:
                stonevnum = 2520;
                break;

            case 24:
                stonevnum = 2520;
                break;

            case 25:
                stonevnum = 2520;
                break;

            case 26:
                stonevnum = 2521;
                break;

            case 27:
                stonevnum = 2521;
                break;

            case 28:
                stonevnum = 2521;
                break;

            default:
                return;
            }
            if (this.SpStoneUpgrade > 99)
            {
                return;
            }
            else if (this.SpStoneUpgrade > 80)
            {
                upmode = 5;
            }
            else if (this.SpStoneUpgrade > 60)
            {
                upmode = 4;
            }
            else if (this.SpStoneUpgrade > 40)
            {
                upmode = 3;
            }
            else if (this.SpStoneUpgrade > 20)
            {
                upmode = 2;
            }

            if (this.IsFixed)
            {
                return;
            }
            if (Session.Character.Gold < goldprice[upmode - 1])
            {
                return;
            }
            if (Session.Character.InventoryList.CountItem(stonevnum) < stoneprice[upmode - 1])
            {
                return;
            }

            Random r   = new Random();
            int    rnd = r.Next(100);

            if (rnd <= upsuccess[upmode - 1])
            {
                byte type = (byte)r.Next(16), count = 1;
                if (upmode == 4)
                {
                    count = 2;
                }
                if (upmode == 5)
                {
                    count = (byte)r.Next(3, 6);
                }

                ServerManager.Instance.Broadcast(Session, Session.Character.GenerateEff(3005), ReceiverType.All);

                if (type < 3)
                {
                    Session.Character.InventoryList.LoadByItemInstance <SpecialistInstance>(this.ItemInstanceId).SpDamage += count;
                    Session.Client.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_ATTACK"), count), 12));
                    Session.Client.SendPacket(Session.Character.GenerateMsg(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_ATTACK"), count), 0));
                }
                else if (type < 6)
                {
                    Session.Character.InventoryList.LoadByItemInstance <SpecialistInstance>(this.ItemInstanceId).SpDefence += count;
                    Session.Client.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_DEFENSE"), count), 12));
                    Session.Client.SendPacket(Session.Character.GenerateMsg(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_DEFENSE"), count), 0));
                }
                else if (type < 9)
                {
                    Session.Character.InventoryList.LoadByItemInstance <SpecialistInstance>(this.ItemInstanceId).SpElement += count;
                    Session.Client.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_ELEMENT"), count), 12));
                    Session.Client.SendPacket(Session.Character.GenerateMsg(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_ELEMENT"), count), 0));
                }
                else if (type < 12)
                {
                    Session.Character.InventoryList.LoadByItemInstance <SpecialistInstance>(this.ItemInstanceId).SpHP += count;
                    Session.Client.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_HPMP"), count), 12));
                    Session.Client.SendPacket(Session.Character.GenerateMsg(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_HPMP"), count), 0));
                }
                else if (type == 12)
                {
                    Session.Character.InventoryList.LoadByItemInstance <SpecialistInstance>(this.ItemInstanceId).SpFire += count;
                    Session.Client.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_FIRE"), count), 12));
                    Session.Client.SendPacket(Session.Character.GenerateMsg(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_FIRE"), count), 0));
                }
                else if (type == 13)
                {
                    Session.Character.InventoryList.LoadByItemInstance <SpecialistInstance>(this.ItemInstanceId).SpWater += count;
                    Session.Client.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_WATER"), count), 12));
                    Session.Client.SendPacket(Session.Character.GenerateMsg(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_WATER"), count), 0));
                }
                else if (type == 14)
                {
                    Session.Character.InventoryList.LoadByItemInstance <SpecialistInstance>(this.ItemInstanceId).SpLight += count;
                    Session.Client.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_LIGHT"), count), 12));
                    Session.Client.SendPacket(Session.Character.GenerateMsg(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_LIGHT"), count), 0));
                }
                else if (type == 15)
                {
                    Session.Character.InventoryList.LoadByItemInstance <SpecialistInstance>(this.ItemInstanceId).SpDark += count;
                    Session.Client.SendPacket(Session.Character.GenerateSay(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_SHADOW"), count), 12));
                    Session.Client.SendPacket(Session.Character.GenerateMsg(String.Format(Language.Instance.GetMessageFromKey("PERFECTSP_SUCCESS"), Language.Instance.GetMessageFromKey("PERFECTSP_SHADOW"), count), 0));
                }
                Session.Character.InventoryList.LoadByItemInstance <SpecialistInstance>(this.ItemInstanceId).SpStoneUpgrade++;
            }
            else
            {
                Session.Client.SendPacket(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("PERFECTSP_FAILURE"), 11));
                Session.Client.SendPacket(Session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("PERFECTSP_FAILURE"), 0));
            }
            Session.Character.Gold = Session.Character.Gold - goldprice[upmode - 1];
            Session.Client.SendPacket(Session.Character.GenerateGold());
            Session.Character.InventoryList.RemoveItemAmount(stonevnum, stoneprice[upmode - 1]);
            Session.Character.GenerateStartupInventory();
            Session.Client.SendPacket("shop_end 1");
        }
예제 #11
0
        public void UpgradeItem(ClientSession session, UpgradeMode mode, UpgradeProtection protection, bool isCommand = false)
        {
            if (!session.HasCurrentMapInstance)
            {
                return;
            }
            if (Upgrade < 10)
            {
                short[] upsuccess;
                short[] upfix;
                int[]   goldprice;
                short[] cella;
                short[] gem;

                if (Rare == 8)
                {
                    upsuccess = new short[] { 50, 50, 45, 30, 20, 10, 5, 3, 2, 1 };
                    upfix     = new short[] { 0, 0, 10, 15, 20, 20, 20, 20, 15, 10 };
                    goldprice = new[] { 5000, 15000, 30000, 100000, 300000, 800000, 1500000, 4000000, 7000000, 10000000 };
                    cella     = new short[] { 40, 100, 160, 240, 320, 440, 560, 760, 960, 1200 };
                    gem       = new short[] { 2, 2, 4, 4, 6, 2, 2, 4, 4, 6 };
                }
                else
                {
                    upsuccess = new short[] { 100, 100, 100, 95, 80, 60, 40, 30, 20, 11 };
                    upfix     = new short[] { 0, 0, 10, 15, 20, 20, 20, 20, 15, 10 };
                    goldprice = new[] { 500, 1500, 3000, 10000, 30000, 80000, 150000, 400000, 700000, 1000000 };
                    cella     = new short[] { 20, 50, 80, 120, 160, 220, 280, 380, 480, 600 };
                    gem       = new short[] { 1, 1, 2, 2, 3, 1, 1, 2, 2, 3 };
                }

                const short  cellaVnum          = 1014;
                const short  gemVnum            = 1015;
                const short  gemFullVnum        = 1016;
                const double reducedpricefactor = 0.5;
                const short  normalScrollVnum   = 1218;
                const short  goldScrollVnum     = 5369;

                if (IsFixed)
                {
                    session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("ITEM_IS_FIXED"), 10));
                    session.SendPacket("shop_end 1");
                    return;
                }
                switch (mode)
                {
                case UpgradeMode.Free:
                    break;

                case UpgradeMode.Reduced:

                    // TODO: Reduced Item Amount
                    if (session.Character.Gold < (long)(goldprice[Upgrade] * reducedpricefactor))
                    {
                        session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NOT_ENOUGH_MONEY"), 10));
                        return;
                    }
                    if (session.Character.Inventory.CountItem(cellaVnum) < cella[Upgrade] * reducedpricefactor)
                    {
                        session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("NOT_ENOUGH_ITEMS"), ServerManager.GetItem(cellaVnum).Name, cella[Upgrade] * reducedpricefactor), 10));
                        return;
                    }
                    if (protection == UpgradeProtection.Protected && !isCommand && session.Character.Inventory.CountItem(goldScrollVnum) < 1)
                    {
                        session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("NOT_ENOUGH_ITEMS"), ServerManager.GetItem(goldScrollVnum).Name, cella[Upgrade] * reducedpricefactor), 10));
                        return;
                    }
                    if (Upgrade < 5)
                    {
                        if (session.Character.Inventory.CountItem(gemVnum) < gem[Upgrade])
                        {
                            session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("NOT_ENOUGH_ITEMS"), ServerManager.GetItem(gemVnum).Name, gem[Upgrade]), 10));
                            return;
                        }
                        session.Character.Inventory.RemoveItemAmount(gemVnum, gem[Upgrade]);
                    }
                    else
                    {
                        if (session.Character.Inventory.CountItem(gemFullVnum) < gem[Upgrade])
                        {
                            session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("NOT_ENOUGH_ITEMS"), ServerManager.GetItem(gemFullVnum).Name, gem[Upgrade]), 10));
                            return;
                        }
                        session.Character.Inventory.RemoveItemAmount(gemFullVnum, gem[Upgrade]);
                    }
                    if (protection == UpgradeProtection.Protected && !isCommand)
                    {
                        session.Character.Inventory.RemoveItemAmount(goldScrollVnum);
                        session.SendPacket("shop_end 2");
                    }
                    session.Character.Gold -= (long)(goldprice[Upgrade] * reducedpricefactor);
                    session.Character.Inventory.RemoveItemAmount(cellaVnum, (int)(cella[Upgrade] * reducedpricefactor));
                    session.SendPacket(session.Character.GenerateGold());
                    break;

                case UpgradeMode.Normal:

                    // TODO: Normal Item Amount
                    if (session.Character.Inventory.CountItem(cellaVnum) < cella[Upgrade])
                    {
                        return;
                    }
                    if (session.Character.Gold < goldprice[Upgrade])
                    {
                        session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NOT_ENOUGH_MONEY"), 10));
                        return;
                    }
                    if (protection == UpgradeProtection.Protected && !isCommand && session.Character.Inventory.CountItem(normalScrollVnum) < 1)
                    {
                        session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("NOT_ENOUGH_ITEMS"), ServerManager.GetItem(normalScrollVnum).Name, 1), 10));
                        return;
                    }
                    if (Upgrade < 5)
                    {
                        if (session.Character.Inventory.CountItem(gemVnum) < gem[Upgrade])
                        {
                            session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("NOT_ENOUGH_ITEMS"), ServerManager.GetItem(gemVnum).Name, gem[Upgrade]), 10));
                            return;
                        }
                        session.Character.Inventory.RemoveItemAmount(gemVnum, gem[Upgrade]);
                    }
                    else
                    {
                        if (session.Character.Inventory.CountItem(gemFullVnum) < gem[Upgrade])
                        {
                            session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("NOT_ENOUGH_ITEMS"), ServerManager.GetItem(gemFullVnum).Name, gem[Upgrade]), 10));
                            return;
                        }
                        session.Character.Inventory.RemoveItemAmount(gemFullVnum, gem[Upgrade]);
                    }
                    if (protection == UpgradeProtection.Protected && !isCommand)
                    {
                        session.Character.Inventory.RemoveItemAmount(normalScrollVnum);
                        session.SendPacket("shop_end 2");
                    }
                    session.Character.Inventory.RemoveItemAmount(cellaVnum, cella[Upgrade]);
                    session.Character.Gold -= goldprice[Upgrade];
                    session.SendPacket(session.Character.GenerateGold());
                    break;
                }
                WearableInstance wearable  = session.Character.Inventory.LoadByItemInstance <WearableInstance>(Id);
                ItemInstance     inventory = session.Character.Inventory.GetItemInstanceById(Id);

                int rnd = ServerManager.RandomNumber();

                if (Rare == 8)
                {
                    if (rnd <= upsuccess[Upgrade])
                    {
                        session.CurrentMapInstance.Broadcast(session.Character.GenerateEff(3005), session.Character.MapX, session.Character.MapY);
                        session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("UPGRADE_SUCCESS"), 12));
                        session.SendPacket(session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("UPGRADE_SUCCESS"), 0));
                        wearable.Upgrade++;
                        if (session.Character.Family != null)
                        {
                            session.Character.Family.InsertFamilyLog(FamilyLogType.Upgrade, session.Character.Name, "", "", "", 0, 0, wearable.ItemVNum, wearable.Upgrade, 0);
                        }
                        session.SendPacket(session.Character.GenerateInventoryAdd(ItemVNum, 1, inventory.Type, inventory.Slot, wearable.Rare, 0, wearable.Upgrade, 0));
                    }
                    else if (rnd <= upfix[Upgrade])
                    {
                        session.CurrentMapInstance.Broadcast(session.Character.GenerateEff(3004), session.Character.MapX, session.Character.MapY);
                        wearable.IsFixed = true;
                        session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("UPGRADE_FIXED"), 11));
                        session.SendPacket(session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("UPGRADE_FIXED"), 0));
                    }
                    else
                    {
                        if (protection == UpgradeProtection.None)
                        {
                            session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("UPGRADE_FAILED"), 11));
                            session.SendPacket(session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("UPGRADE_FAILED"), 0));
                            session.Character.DeleteItemByItemInstanceId(Id);
                        }
                        else
                        {
                            session.CurrentMapInstance.Broadcast(session.Character.GenerateEff(3004), session.Character.MapX, session.Character.MapY);
                            session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SCROLL_PROTECT_USED"), 11));
                            session.SendPacket(session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("UPGRADE_FAILED_ITEM_SAVED"), 0));
                        }
                    }
                }
                else
                {
                    if (rnd <= upfix[Upgrade])
                    {
                        session.CurrentMapInstance.Broadcast(session.Character.GenerateEff(3004), session.Character.MapX, session.Character.MapY);
                        wearable.IsFixed = true;
                        session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("UPGRADE_FIXED"), 11));
                        session.SendPacket(session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("UPGRADE_FIXED"), 0));
                    }
                    else if (rnd <= upsuccess[Upgrade])
                    {
                        session.CurrentMapInstance.Broadcast(session.Character.GenerateEff(3005), session.Character.MapX, session.Character.MapY);
                        session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("UPGRADE_SUCCESS"), 12));
                        session.SendPacket(session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("UPGRADE_SUCCESS"), 0));
                        wearable.Upgrade++;
                        if (session.Character.Family != null)
                        {
                            session.Character.Family.InsertFamilyLog(FamilyLogType.Upgrade, session.Character.Name, "", "", "", 0, 0, wearable.ItemVNum, wearable.Upgrade, 0);
                        }
                        session.SendPacket(session.Character.GenerateInventoryAdd(ItemVNum, 1, inventory.Type, inventory.Slot, wearable.Rare, 0, wearable.Upgrade, 0));
                    }
                    else
                    {
                        if (protection == UpgradeProtection.None)
                        {
                            session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("UPGRADE_FAILED"), 11));
                            session.SendPacket(session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("UPGRADE_FAILED"), 0));
                            session.Character.DeleteItemByItemInstanceId(Id);
                        }
                        else
                        {
                            session.CurrentMapInstance.Broadcast(session.Character.GenerateEff(3004), session.Character.MapX, session.Character.MapY);
                            session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SCROLL_PROTECT_USED"), 11));
                            session.SendPacket(session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("UPGRADE_FAILED_ITEM_SAVED"), 0));
                        }
                    }
                }
            }
            else
            {
                session.CurrentMapInstance.Broadcast(session.Character.GenerateEff(3004), session.Character.MapX, session.Character.MapY);
                session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SCROLL_PROTECT_USED"), 11));
                session.SendPacket(session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("UPGRADE_FAILED_ITEM_SAVED"), 0));
            }
            session.SendPacket("shop_end 1");
        }
예제 #12
0
        public void SetRarityPoint()
        {
            switch (Item.EquipmentSlot)
            {
            case EquipmentType.MainWeapon:
            case EquipmentType.SecondaryWeapon:
            {
                int point = CharacterHelper.RarityPoint(Rare, Item.IsHeroic ? (short)(95 + Item.LevelMinimum) : Item.LevelMinimum);
                Concentrate   = 0;
                HitRate       = 0;
                DamageMinimum = 0;
                DamageMaximum = 0;
                if (Rare >= 0)
                {
                    for (int i = 0; i < point; i++)
                    {
                        int rndn = ServerManager.RandomNumber(0, 3);
                        if (rndn == 0)
                        {
                            Concentrate++;
                            HitRate++;
                        }
                        else
                        {
                            DamageMinimum++;
                            DamageMaximum++;
                        }
                    }
                }
                else
                {
                    for (int i = 0; i > point; i--)
                    {
                        int rndn = ServerManager.RandomNumber(0, 3);
                        if (rndn == 0)
                        {
                            Concentrate--;
                            HitRate--;
                        }
                        else
                        {
                            DamageMinimum--;
                            DamageMaximum--;
                        }
                    }
                }
            }
            break;

            case EquipmentType.Armor:
            {
                int point = CharacterHelper.RarityPoint(Rare, Item.IsHeroic ? (short)(95 + Item.LevelMinimum) : Item.LevelMinimum);
                DefenceDodge         = 0;
                DistanceDefenceDodge = 0;
                DistanceDefence      = 0;
                MagicDefence         = 0;
                CloseDefence         = 0;
                if (Rare >= 0)
                {
                    for (int i = 0; i < point; i++)
                    {
                        int rndn = ServerManager.RandomNumber(0, 3);
                        if (rndn == 0)
                        {
                            DefenceDodge++;
                            DistanceDefenceDodge++;
                        }
                        else
                        {
                            DistanceDefence++;
                            MagicDefence++;
                            CloseDefence++;
                        }
                    }
                }
                else
                {
                    for (int i = 0; i > point; i--)
                    {
                        int rndn = ServerManager.RandomNumber(0, 3);
                        if (rndn == 0)
                        {
                            DefenceDodge--;
                            DistanceDefenceDodge--;
                        }
                        else
                        {
                            DistanceDefence--;
                            MagicDefence--;
                            CloseDefence--;
                        }
                    }
                }
            }
            break;
            }
        }
예제 #13
0
        public void RarifyItem(ClientSession session, RarifyMode mode, RarifyProtection protection,
                               bool isCommand = false)
        {
            double       raren2              = 80;
            double       raren1              = 70;
            double       rare0               = 60;
            double       rare1               = 40;
            double       rare2               = 30;
            double       rare3               = 15;
            double       rare4               = 10;
            double       rare5               = 5;
            double       rare6               = 3;
            double       rare7               = 2;
            double       rare8               = 1;
            const short  goldprice           = 500;
            const double reducedpricefactor  = 0.5;
            const double reducedchancefactor = 1.1;
            const byte   cella               = 5;
            const int    cellaVnum           = 1014;
            const int    scrollVnum          = 1218;
            int          rnd;

            if (session != null && !session.HasCurrentMapInstance)
            {
                return;
            }
            if (mode != RarifyMode.Drop || Item.ItemType == ItemType.Shell)
            {
                raren2 = 0;
                raren1 = 0;
                rare0  = 0;
                rnd    = ServerManager.RandomNumber(0, 80);
            }
            else
            {
                rnd = ServerManager.RandomNumber();
            }
            if (protection == RarifyProtection.RedAmulet)
            {
                raren2 = raren1 * reducedchancefactor;
                raren1 = raren1 * reducedchancefactor;
                rare0  = rare0 * reducedchancefactor;
                rare1  = rare1 * reducedchancefactor;
                rare2  = rare2 * reducedchancefactor;
                rare3  = rare3 * reducedchancefactor;
                rare4  = rare4 * reducedchancefactor;
                rare5  = rare5 * reducedchancefactor;
                rare6  = rare6 * reducedchancefactor;
                rare7  = rare7 * reducedchancefactor;
                rare8  = rare8 * reducedchancefactor;

                // rare8 = rare8 * reducedchancefactor;
            }
            if (session != null)
            {
                switch (mode)
                {
                case RarifyMode.Free:
                    break;

                case RarifyMode.Reduced:

                    // TODO: Reduced Item Amount
                    if (session.Character.Gold < (long)(goldprice * reducedpricefactor))
                    {
                        return;
                    }
                    if (session.Character.Inventory.CountItem(cellaVnum) < cella * reducedpricefactor)
                    {
                        return;
                    }
                    session.Character.Inventory.RemoveItemAmount(cellaVnum, (int)(cella * reducedpricefactor));
                    session.Character.Gold -= (long)(goldprice * reducedpricefactor);
                    session.SendPacket(session.Character.GenerateGold());
                    break;

                case RarifyMode.Normal:

                    // TODO: Normal Item Amount
                    if (session.Character.Gold < goldprice)
                    {
                        return;
                    }
                    if (session.Character.Inventory.CountItem(cellaVnum) < cella)
                    {
                        return;
                    }
                    if (protection == RarifyProtection.Scroll && !isCommand &&
                        session.Character.Inventory.CountItem(scrollVnum) < 1)
                    {
                        return;
                    }

                    if (protection == RarifyProtection.Scroll && !isCommand)
                    {
                        session.Character.Inventory.RemoveItemAmount(scrollVnum);
                        session.SendPacket("shop_end 2");
                    }
                    session.Character.Gold -= goldprice;
                    session.Character.Inventory.RemoveItemAmount(cellaVnum, cella);
                    session.SendPacket(session.Character.GenerateGold());
                    break;
                }
            }
            if (Item.IsHeroic && protection == RarifyProtection.Scroll)
            {
                if (rnd <= rare8 && !(protection == RarifyProtection.Scroll && Rare >= 8))
                {
                    if (mode != RarifyMode.Drop)
                    {
                        session?.Character.NotifyRarifyResult(8);
                    }

                    Rare = 8;
                    SetRarityPoint();
                    ItemInstance inventory = session?.Character.Inventory.GetItemInstanceById(Id);
                    if (inventory != null)
                    {
                        session.SendPacket(session.Character.GenerateInventoryAdd(ItemVNum, 1, inventory.Type, inventory.Slot, inventory.Rare, 0, inventory.Upgrade, 0));
                    }
                    return;
                }
            }
            if (rnd <= rare7 && !(protection == RarifyProtection.Scroll && Rare >= 7))
            {
                if (mode != RarifyMode.Drop)
                {
                    session?.Character.NotifyRarifyResult(7);
                }

                Rare = 7;
                SetRarityPoint();
            }
            else if (rnd <= rare6 && !(protection == RarifyProtection.Scroll && Rare >= 6))
            {
                if (mode != RarifyMode.Drop)
                {
                    session?.Character.NotifyRarifyResult(6);
                }
                Rare = 6;
                SetRarityPoint();
            }
            else if (rnd <= rare5 && !(protection == RarifyProtection.Scroll && Rare >= 5))
            {
                if (mode != RarifyMode.Drop)
                {
                    session?.Character.NotifyRarifyResult(5);
                }
                Rare = 5;
                SetRarityPoint();
            }
            else if (rnd <= rare4 && !(protection == RarifyProtection.Scroll && Rare >= 4))
            {
                if (mode != RarifyMode.Drop)
                {
                    session?.Character.NotifyRarifyResult(4);
                }
                Rare = 4;
                SetRarityPoint();
            }
            else if (rnd <= rare3 && !(protection == RarifyProtection.Scroll && Rare >= 3))
            {
                if (mode != RarifyMode.Drop)
                {
                    session?.Character.NotifyRarifyResult(3);
                }
                Rare = 3;
                SetRarityPoint();
            }
            else if (rnd <= rare2 && !(protection == RarifyProtection.Scroll && Rare >= 2))
            {
                if (mode != RarifyMode.Drop)
                {
                    session?.Character.NotifyRarifyResult(2);
                }
                Rare = 2;
                SetRarityPoint();
            }
            else if (rnd <= rare1 && !(protection == RarifyProtection.Scroll && Rare >= 1))
            {
                if (mode != RarifyMode.Drop)
                {
                    session?.Character.NotifyRarifyResult(1);
                }
                Rare = 1;
                SetRarityPoint();
            }
            else if (rnd <= rare0 && !(protection == RarifyProtection.Scroll && Rare >= 0))
            {
                if (mode != RarifyMode.Drop)
                {
                    session?.Character.NotifyRarifyResult(0);
                }
                Rare = 0;
                SetRarityPoint();
            }
            else if (rnd <= raren1 && !(protection == RarifyProtection.Scroll && Rare >= -1))
            {
                if (mode != RarifyMode.Drop)
                {
                    session?.Character.NotifyRarifyResult(-1);
                }
                Rare = -1;
                SetRarityPoint();
            }
            else if (rnd <= raren2 && !(protection == RarifyProtection.Scroll && Rare >= -2))
            {
                if (mode != RarifyMode.Drop)
                {
                    session?.Character.NotifyRarifyResult(-2);
                }
                Rare = -2;
                SetRarityPoint();
            }
            else
            {
                if (mode != RarifyMode.Drop && session != null)
                {
                    if (protection == RarifyProtection.None)
                    {
                        session.Character.DeleteItemByItemInstanceId(Id);
                        session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("RARIFY_FAILED"), 11));
                        session.SendPacket(session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("RARIFY_FAILED"), 0));
                    }
                    else
                    {
                        session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("RARIFY_FAILED_ITEM_SAVED"), 11));
                        session.SendPacket(session.Character.GenerateMsg(Language.Instance.GetMessageFromKey("RARIFY_FAILED_ITEM_SAVED"), 0));
                        session.CurrentMapInstance.Broadcast(session.Character.GenerateEff(3004), session.Character.MapX, session.Character.MapY);
                    }
                }
            }

            // don't place under else.
            if (mode != RarifyMode.Drop && session != null)
            {
                ItemInstance inventory = session.Character.Inventory.GetItemInstanceById(Id);
                if (inventory != null)
                {
                    session.SendPacket(session.Character.GenerateInventoryAdd(ItemVNum, 1, inventory.Type, inventory.Slot, inventory.Rare, 0, inventory.Upgrade, 0));
                }
            }
        }