Наследование: Codebreak.Service.World.Network.MessageDispatcher, IDisposable
        /// <summary>
        /// 
        /// </summary>
        /// <param name="actor"></param>
        /// <param name="guid"></param>
        /// <param name="quantity"></param>
        /// <param name="price"></param>
        /// <returns></returns>
        public override int AddItem(AbstractEntity actor, long guid, int quantity, long price = -1)
        {
            if (price < 1)
                return 0;

            ItemDAO item = null;
            if (quantity > 0)
                item = Character.Inventory.RemoveItem(guid, quantity);
            else
                item = Character.PersonalShop.GetItem(guid);

            if(item == null)
            {
                base.Dispatch(WorldMessage.BASIC_NO_OPERATION());
                return 0;
            }

            item.MerchantPrice = price;

            if (quantity > 0)
            {
                Character.PersonalShop.AddItem(item, false);
                Character.RefreshPersonalShopTaxe();
            }

            SendItemsList();

            return item.Quantity;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="actor"></param>
        /// <param name="guid"></param>
        /// <param name="quantity"></param>
        /// <param name="price"></param>
        public override int AddItem(AbstractEntity actor, long guid, int quantity, long price = -1)
        {
            switch(Npc.AuctionHouse.TryAdd(Character, guid, quantity, price))
            {
                case AuctionAddResultEnum.INVALID_PRICE:
                    Character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.ERROR, InformationEnum.ERROR_INVALID_PRICE));
                    break;

                case AuctionAddResultEnum.INVALID_TYPE:
                    Character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.INFO, InformationEnum.INFO_AUCTION_ADD_INVALID_TYPE));
                    break;

                case AuctionAddResultEnum.ERROR:
                case AuctionAddResultEnum.INVALID_FLOOR:
                case AuctionAddResultEnum.INVALID_ITEM:
                case AuctionAddResultEnum.INVALID_QUANTITY:
                case AuctionAddResultEnum.TOO_HIGH_LEVEL:
                    Character.Dispatch(WorldMessage.OBJECT_MOVE_ERROR());
                    break;

                case AuctionAddResultEnum.TOO_MANY_ENTRIES:
                    Character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.ERROR, InformationEnum.ERROR_AUCTION_HOUSE_TOO_MANY_ITEMS));
                    break;

                case AuctionAddResultEnum.NOT_ENOUGH_KAMAS_FOR_TAXE:
                    Character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.ERROR, InformationEnum.ERROR_NOT_ENOUGH_KAMAS_FOR_TAXE));
                    break;
            }

            return 0;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="actor"></param>
        /// <param name="quantity"></param>
        /// <returns></returns>
        public override long MoveKamas(AbstractEntity actor, long quantity)
        {
            // Can only remove kamas
            if (quantity > 0)
                return 0;

            return base.MoveKamas(actor, quantity);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="actor"></param>
        /// <param name="guid"></param>
        /// <param name="quantity"></param>
        /// <param name="price"></param>
        /// <returns></returns>
        public override int AddItem(AbstractEntity actor, long guid, int quantity, long price = -1)
        {
            var item = Character.Inventory.RemoveItem(guid, quantity);
            if (item == null)
                return 0;

            Storage.AddItem(item);

            return item.Quantity;
        }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="exchange"></param>
 /// <param name="localEntity"></param>
 /// <param name="distantEntity"></param>
 public AbstractGameExchangeAction(AbstractExchange exchange, AbstractEntity localEntity, AbstractEntity distantEntity = null)
     : base(GameActionTypeEnum.EXCHANGE, localEntity)
 {
     DistantEntity = distantEntity;
     Exchange = exchange;
     Exchange.AddHandler(Entity.Dispatch);
     if(DistantEntity != null)
         Exchange.AddHandler(DistantEntity.Dispatch);
     Entity.AddUpdatable(Exchange);
 }
Пример #6
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="entity"></param>
 public void SendInformations(AbstractEntity entity)
 {
     var guildName = string.Empty;
     var guildEmblem = string.Empty;
     if(Guild != null)
     {
         guildName = Guild.Name;
         guildEmblem = Guild.Emblem;
     }
     // Map -2 to 0
     var guildId = GuildId == -2 ? 0 : GuildId;
     entity.Dispatch(WorldMessage.PADDOCK_INFORMATIONS(guildId, Price, MountPlace, ItemPlace, guildName, guildEmblem));
 }
Пример #7
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="guid"></param>
        /// <param name="quantity"></param>
        /// <param name="price"></param>
        public override int AddItem(AbstractEntity entity, long guid, int quantity, long price = -1)
        {
            var added = base.AddItem(entity, guid, quantity, price);
            if(added > 0)
            {
                var invItem = Character.Inventory.GetItem(guid);
                if (invItem == null)
                    return 0;
                if (!m_templateQuantity.ContainsKey(invItem.TemplateId))
                    m_templateQuantity.Add(invItem.TemplateId, 0);
                m_templateQuantity[invItem.TemplateId] += quantity;

                CheckRewards();

                return added;
            }

            return 0;
        }
Пример #8
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="actor"></param>
        /// <param name="templateId"></param>
        /// <param name="quantity"></param>
        public override void BuyItem(AbstractEntity entity, long templateId, int quantity)
        {
            if (quantity < 1)
            {
                Logger.Debug("ShopExchange unable to buy, quantity < 0 : " + entity.Name);
                Character.Dispatch(WorldMessage.EXCHANGE_BUY_ERROR());
                return;
            }

            var template = Npc.ShopItems.Find(x => x.Id == templateId);
            if (template == null)
            {
                Logger.Debug("ShopExchange unable to buy null template : " + entity.Name);
                Character.Dispatch(WorldMessage.EXCHANGE_BUY_ERROR());
                return;
            }

            var price = template.Price * quantity;

            if (Character.Inventory.Kamas < price)
            {
                Logger.Debug("ShopExchange no enought kamas to buy item : " + entity.Name);
                Character.Dispatch(WorldMessage.EXCHANGE_BUY_ERROR());
                return;
            }

            var instance = template.Create(quantity);
            if (instance == null)
            {
                Logger.Debug("ShopExchange error while creating object : " + entity.Name);
                Character.Dispatch(WorldMessage.EXCHANGE_BUY_ERROR());
                return;
            }

            Character.CachedBuffer = true;
            Character.Inventory.SubKamas(price);
            Character.Inventory.AddItem(instance);
            Character.CachedBuffer = false;

            Npc.OnBuyTrade(Character);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="actor"></param>
        /// <param name="templateId"></param>
        /// <param name="quantity"></param>
        public override void BuyItem(AbstractEntity actor, long itemId, int quantity)
        {
            if(!Merchant.HasGameAction(Action.GameActionTypeEnum.MAP))
            {
                Character.Dispatch(WorldMessage.EXCHANGE_BUY_ERROR());
                return;
            }

            var item = Merchant.PersonalShop.GetItem(itemId);
            if(item == null || quantity > item.Quantity)
            {
                Character.CachedBuffer = true;
                Character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.INFO, InformationEnum.INFO_ITEM_ALREADY_SOLD));
                SendItemsList();
                Character.CachedBuffer = false;
                return;
            }

            var price = item.MerchantPrice * quantity;
            if(Character.Inventory.Kamas < price)
            {
                Character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.ERROR, InformationEnum.ERROR_NOT_ENOUGH_KAMAS, price));
                return;
            }

            var removedItem = Merchant.PersonalShop.RemoveItem(itemId, (int)quantity);
            removedItem.MerchantPrice = -1;
            Merchant.Inventory.AddKamas(price);

            Character.CachedBuffer = true;
            Character.Inventory.SubKamas(price);
            Character.Inventory.AddItem(removedItem);
            SendItemsList();
            Character.CachedBuffer = false;

            if(Merchant.PersonalShop.Items.Count == 0)
            {
                EntityManager.Instance.RemoveMerchant(Merchant);
            }
        }
Пример #10
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="actor"></param>
        /// <param name="guid"></param>
        /// <param name="quantity"></param>
        public override void SellItem(AbstractEntity entity, long guid, int quantity, long price = -1)
        {
            if (quantity < 1)
            {
                Logger.Debug("ShopExchange unable to sell, quantity < 1 : " + entity.Name);
                entity.Dispatch(WorldMessage.EXCHANGE_SELL_ERROR());
                return;
            }

            var item = entity.Inventory.Items.Find(entry => entry.Id == guid);

            if (item == null)
            {
                Logger.Debug("ShopExchange unable to sell null item : " + entity.Name);
                entity.Dispatch(WorldMessage.EXCHANGE_SELL_ERROR());
                return;
            }

            if (quantity > item.Quantity)
                quantity = item.Quantity;

            var sellPrice = (item.Template.Price / 10) * quantity;

            entity.Inventory.RemoveItem(guid, quantity);
            entity.Inventory.AddKamas(sellPrice);
        }
Пример #11
0
 /// <summary>
 /// 
 /// </summary>
 public void SendMapFightInfos(AbstractEntity entity)
 {
     if (State == FightStateEnum.STATE_PLACEMENT)
     {
         entity.Dispatch(WorldMessage.FIGHT_FLAG_DISPLAY(this));
         Team0.SendMapFightInfos(entity);
         Team1.SendMapFightInfos(entity);
     }
 }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public bool Validate(AbstractEntity entity)
        {
            Character.CachedBuffer = true;

            foreach (var item in m_caseItems)
            {
                var templateId = Character.Inventory.RemoveItem(item.Key, item.Value).TemplateId;
                m_templateQuantity[templateId] -= item.Value;
            }

            if (m_craftItem != null)
            {
                var chance = Job.CraftSuccessPercent(m_caseItems.Count);
                var success = Util.Next(0, 100) < chance;

                if(success)
                {
                    var item = m_craftItem.Create();
                    Character.Inventory.AddItem(item);
                    item = Character.Inventory.Items.Find(entry => entry.TemplateId == m_craftItem.Id);

                    Character.Dispatch(WorldMessage.EXCHANGE_DISTANT_MOVEMENT(
                        ExchangeMoveEnum.MOVE_OBJECT,
                        OperatorEnum.OPERATOR_ADD,
                        item.Id + "|1|" + m_craftItem.Id + "|" + item.StringEffects));
                    Character.Dispatch(WorldMessage.CRAFT_TEMPLATE_CREATED(item.TemplateId));
                    if(m_loopTimer == null)
                        Character.Map.Dispatch(WorldMessage.CRAFT_INTERACTIVE_SUCCESS(Character.Id, item.TemplateId));
                }
                else
                {
                    Character.Dispatch(WorldMessage.CRAFT_TEMPLATE_FAILED(m_craftItem.Id));
                    if (m_loopTimer == null)
                        Character.Map.Dispatch(WorldMessage.CRAFT_INTERACTIVE_FAILED(Character.Id, m_craftItem.Id));
                }

                Character.CharacterJobs.AddExperience(Job, Job.CraftExperience(m_templateQuantity.Count));
            }
            else
            {
                Character.Dispatch(WorldMessage.CRAFT_NO_RESULT());
                if (m_loopTimer == null)
                    Character.Map.Dispatch(WorldMessage.CRAFT_INTERACTIVE_NOTHING(Character.Id));
            }

            Character.CachedBuffer = false;

            m_lastCaseItems = m_caseItems;
            m_caseItems = new Dictionary<long, int>();

            return false;
        }
Пример #13
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="cellId"></param>
        /// <param name="path"></param>
        /// <returns></returns>
        public void Move(AbstractEntity entity, int cellId, string path)
        {
            AddMessage(() =>
            {
                if (LoopState != FightLoopStateEnum.STATE_WAIT_TURN)
                {
                    Logger.Debug("Fight::Move trying to move withouth being in turn wait phase : " + entity.Name);
                    return;
                }

                if (entity != CurrentFighter)
                {
                    Logger.Debug("Fight::Move not his turn : " + entity.Name);
                    return;
                }

                var fighter = (AbstractFighter)entity;
                var movementPath = Pathfinding.IsValidPath(this, fighter, fighter.Cell.Id, path);

                //
                if (movementPath == null)
                {
                    Logger.Debug("Fight::Move null movement path : " + entity.Name);
                    return;
                }

                // Pas assez de point de mouvement
                if (movementPath.MovementLength > fighter.MP)
                {
                    Logger.Debug("Fight::Move no enought mp to move : " + entity.Name);
                    return;
                }

                var tacledChance = Pathfinding.TryTacle(fighter);

                // Si tacle
                if (tacledChance != -1 && !CurrentFighter.StateManager.HasState(FighterStateEnum.STATE_ROOTED))
                {
                    CachedBuffer = true;

                    // XX A été taclé
                    Dispatch(WorldMessage.GAME_ACTION(GameActionTypeEnum.FIGHT_TACLE, fighter.Id));

                    // perte d'ap
                    var lostAP = (fighter.AP * tacledChance / 100) - 1;

                    if (lostAP < 0)
                        lostAP = 1;

                    if (lostAP > fighter.AP)
                        lostAP = fighter.AP;

                    fighter.UsedAP += lostAP;

                    Dispatch(WorldMessage.GAME_ACTION(GameActionTypeEnum.FIGHT_PA_LOST, fighter.Id, fighter.Id + ",-" + lostAP));

                    var lostMP = fighter.MP;

                    if (lostMP < 0)
                        lostMP = 1;

                    if (lostMP > fighter.MP)
                        lostMP = fighter.MP;

                    fighter.UsedMP += lostMP;

                    Dispatch(WorldMessage.GAME_ACTION(GameActionTypeEnum.FIGHT_PM_LOST, fighter.Id, fighter.Id + ",-" + lostMP));
                    CachedBuffer = false;

                    return;
                }

                LoopState = FightLoopStateEnum.STATE_WAIT_ACTION;

                Dispatch(WorldMessage.FIGHT_ACTION_START(CurrentFighter.Id));

                CurrentFighter.Team.CheckMovement(fighter, fighter.Cell.Id, movementPath.EndCell, movementPath.MovementLength);

                fighter.Move(movementPath);
            });
        }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="actor"></param>
 /// <param name="guid"></param>
 /// <param name="quantity"></param>
 /// <param name="price"></param>
 public virtual int AddItem(AbstractEntity actor, long guid, int quantity, long price = -1)
 {
     return 0;
 }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="actor"></param>
 /// <param name="id"></param>
 /// <param name="quantity"></param>
 public virtual void BuyItem(AbstractEntity actor, long id, int quantity)
 {
 }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="actor"></param>
 /// <param name="guid"></param>
 /// <param name="quantity"></param>
 public virtual int RemoveItem(AbstractEntity actor, long guid, int quantity)
 {
     return 0;
 }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="actor"></param>
 /// <param name="id"></param>
 /// <param name="quantity"></param>
 /// <param name="price"></param>
 public virtual void SellItem(AbstractEntity actor, long id, int quantity, long price = -1)
 {
 }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="actor"></param>
 /// <param name="quantity"></param>
 public virtual long MoveKamas(AbstractEntity actor, long quantity)
 {
     return 0;
 }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="entity"></param>
 /// <param name="mapId"></param>
 /// <param name="cellId"></param>
 public GameMapTeleportAction(AbstractEntity entity, int mapId, int cellId)
     : base(GameActionTypeEnum.MAP_TELEPORT, entity)
 {
     MapId = mapId;
     CellId = cellId;
 }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="entity"></param>
 /// <param name="path"></param>
 public GameMapMovementAction(AbstractEntity entity, MovementPath path)
     : base(GameActionTypeEnum.MAP_MOVEMENT, entity, (long)path.MovementTime)
 {
     Path = path;
     SkillId = -1;
 }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="guid"></param>
        /// <param name="quantity"></param>
        /// <param name="price"></param>
        public override int AddItem(AbstractEntity entity, long guid, int quantity, long price = -1)
        {
            var item = Character.Inventory.GetItem(guid);
            if (item == null)
                return 0;

            if (quantity > item.Quantity)
                quantity = item.Quantity;

            if (item != null && item.Slot == ItemSlotEnum.SLOT_INVENTORY)
            {
                var alreadyExchangedQuantity = GetQuantity(guid);
                if (alreadyExchangedQuantity > 0)
                {
                    var realQuantity = item.Quantity - alreadyExchangedQuantity;
                    if (quantity > realQuantity)
                        quantity = realQuantity;
                }

                if (!m_templateQuantity.ContainsKey(item.TemplateId))
                    m_templateQuantity.Add(item.TemplateId, 0);
                m_templateQuantity[item.TemplateId] += quantity;
                m_caseItems[guid] += quantity;

                Character.Dispatch(WorldMessage.EXCHANGE_LOCAL_MOVEMENT(ExchangeMoveEnum.MOVE_OBJECT, OperatorEnum.OPERATOR_ADD, item.Id.ToString() + '|' + m_caseItems[guid]));

                CheckCraftable();

                return quantity;
            }

            return 0;
        }
Пример #22
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="movementPath"></param>
        /// <param name="cellId"></param>
        public void MovementFinish(AbstractEntity entity, MovementPath movementPath, int cellId)
        {
            var fighter = (AbstractFighter)entity;

            fighter.UsedMP += movementPath.MovementLength;

            Dispatch(WorldMessage.GAME_ACTION(GameActionTypeEnum.FIGHT_PM_LOST, fighter.Id, fighter.Id + ",-" + movementPath.MovementLength));

            fighter.Orientation = movementPath.GetDirection(movementPath.LastStep);
            fighter.SetCell(GetCell(cellId));
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="guid"></param>
        /// <param name="quantity"></param>
        public override int RemoveItem(AbstractEntity entity, long guid, int quantity)
        {
            if (m_caseItems.ContainsKey(guid))
            {
                var item = entity.Inventory.Items.Find(entry => entry.Id == guid);
                if (quantity >= m_caseItems[guid])
                {
                    quantity = m_caseItems[guid];
                    m_caseItems.Remove(guid);
                }
                else
                {
                    m_caseItems[guid] -= quantity;
                }
                m_templateQuantity[item.TemplateId] -= quantity;
                if (m_templateQuantity[item.TemplateId] == 0)
                    m_templateQuantity.Remove(item.TemplateId);

                CheckCraftable();

                var exists = m_caseItems.ContainsKey(guid);
                Character.Dispatch(WorldMessage.EXCHANGE_LOCAL_MOVEMENT(ExchangeMoveEnum.MOVE_OBJECT, OperatorEnum.OPERATOR_REMOVE, item.Id.ToString()));
                if (exists)
                    Character.Dispatch(WorldMessage.EXCHANGE_LOCAL_MOVEMENT(ExchangeMoveEnum.MOVE_OBJECT, OperatorEnum.OPERATOR_ADD, item.Id.ToString() + '|' + m_caseItems[guid]));

                return quantity;
            }
            return 0;
        }
Пример #24
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="quantity"></param>
        /// <returns></returns>
        public override long MoveKamas(AbstractEntity entity, long quantity)
        {
            var moved = base.MoveKamas(entity, quantity);

            CheckRewards();

            return moved;
        }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="actor"></param>
 /// <param name="guid"></param>
 /// <param name="quantity"></param>
 /// <param name="price"></param>
 /// <returns></returns>
 public override int AddItem(AbstractEntity actor, long guid, int quantity, long price = -1)
 {
     return 0; // should not be able to add an item
 }
Пример #26
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="guid"></param>
        /// <param name="quantity"></param>
        public override int RemoveItem(AbstractEntity entity, long guid, int quantity)
        {
            var removed = base.RemoveItem(entity, guid, quantity);
            if (removed > 0)
            {
                var invItem = Character.Inventory.GetItem(guid);
                if (invItem == null)
                    return 0;
                m_templateQuantity[invItem.TemplateId] -= quantity;
                if (m_templateQuantity[invItem.TemplateId] == 0)
                    m_templateQuantity.Remove(invItem.TemplateId);

                CheckRewards();

                return removed;
            }
            return 0;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="actor"></param>
        /// <param name="guid"></param>
        /// <param name="quantity"></param>
        /// <returns></returns>
        public override int RemoveItem(AbstractEntity actor, long guid, int quantity)
        {
            var item = Storage.GetItem(guid);
            if(item == null)
                return 0;

            var templateId = item.TemplateId;

            quantity = base.RemoveItem(actor, guid, quantity);

            if(quantity > 0)
            {
                if (!TaxCollector.FarmedItems.ContainsKey(templateId))
                    TaxCollector.FarmedItems.Add(templateId, 0);
                TaxCollector.FarmedItems[templateId] += quantity;
            }
            return quantity;
        }
Пример #28
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public override bool Validate(AbstractEntity entity)
        {
            if(m_reward != null)
            {
                Character.CachedBuffer = true;
                Character.Inventory.SubKamas(m_exchangedKamas[Character.Id]);
                foreach (var item in m_exchangedItems[Character.Id])
                    Character.Inventory.RemoveItem(item.Key, item.Value);
                Character.Inventory.AddKamas(m_reward.RewardedKamas);
                foreach(var item in m_reward.RewardedItems)
                    Character.Inventory.AddItem(item.Template.Create(item.Quantity));
                Character.CachedBuffer = false;
                return true;
            }

            Character.AddMessage(() => Character.AbortAction(GameActionTypeEnum.EXCHANGE));
            return false;
        }
Пример #29
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="entity"></param>
 public void SendMapFightInfos(AbstractEntity entity)
 {
     entity.Dispatch(WorldMessage.FIGHT_FLAG_UPDATE(OperatorEnum.OPERATOR_ADD, LeaderId, Fighters.ToArray()));
     foreach (var option in m_blockedOption)
         entity.Dispatch(WorldMessage.FIGHT_OPTION(option.Key, option.Value, LeaderId));
 }
Пример #30
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="actor"></param>
        /// <param name="quantity"></param>
        /// <returns></returns>
        public override long MoveKamas(AbstractEntity actor, long quantity)
        {
            Character.CachedBuffer = true;

            if(quantity < 0)
            {
                quantity = Math.Abs(quantity);
                if (quantity > Storage.Kamas)
                    quantity = Storage.Kamas;

                Storage.SubKamas(quantity);
                Character.Inventory.AddKamas(quantity);
            }
            else
            {
                if (quantity > Character.Inventory.Kamas)
                    quantity = Character.Inventory.Kamas;

                Storage.AddKamas(quantity);
                Character.Inventory.SubKamas(quantity);
            }
            Character.CachedBuffer = false;

            return quantity;
        }