Example #1
0
        public void RemoveForbiddenItems() /// TEMPORARY
        {
            foreach (var item in GetItems())
            {
                if (item.HasEffect <EffectMination>())
                {
                    EffectMination effect = item.FirstEffect <EffectMination>();

                    if (effect != null)
                    {
                        if (MinationLoot.CantBeEquiped(effect.MonsterId))
                        {
                            if (item.IsEquiped())
                            {
                                UnequipItem(item, item.Quantity);
                            }
                            RemoveItem(item, item.Quantity);
                            return;
                        }
                    }
                }
            }
        }
Example #2
0
        /// <summary>
        /// Permet de définir la nouvelle position d'un item
        /// </summary>
        /// <param name="uid"></param>
        /// <param name="position"></param>
        /// <param name="quantity"></param>
        public void SetItemPosition(uint uid, CharacterInventoryPositionEnum position, uint quantity)
        {
            var item = GetItem(uid);

            if (item != null)
            {
                if (position != CharacterInventoryPositionEnum.INVENTORY_POSITION_NOT_EQUIPED)
                {
                    if (Character.Level < item.Template.Level)
                    {
                        OnError(ObjectErrorEnum.LEVEL_TOO_LOW);
                        return;
                    }

                    if (!CriteriaProvider.EvaluateCriterias(Character.Client, item.Template.Criteria))
                    {
                        OnError(ObjectErrorEnum.CRITERIONS);
                        return;
                    }

                    if (DofusPositions.Contains((CharacterInventoryPositionEnum)item.Position) && DofusPositions.Contains(position))
                    {
                        return;
                    }

                    if (CheckStacks(item, position, RingPositions) && item.Template.HasSet)
                    {
                        OnError(ObjectErrorEnum.CANNOT_EQUIP_HERE);
                        return;
                    }

                    if (CheckStacks(item, position, DofusPositions))
                    {
                        OnError(ObjectErrorEnum.CANNOT_EQUIP_HERE);
                        return;
                    }

                    if (item.PositionEnum != CharacterInventoryPositionEnum.INVENTORY_POSITION_NOT_EQUIPED)
                    {
                        OnError(ObjectErrorEnum.CANNOT_EQUIP_HERE);
                        return;
                    }

                    if (item.Template.TypeEnum == ItemTypeEnum.OBJET_VIVANT)
                    {
                        ItemTypeEnum livingObjectCategory = (ItemTypeEnum)(item.FirstEffect <EffectInteger>(EffectsEnum.Effect_LivingObjectCategory).Value);

                        var targeted = GetEquipedItem(position);

                        if (targeted == null)
                        {
                            OnLivingObjectEquipedDirectly();
                            return;
                        }

                        if (targeted.Template.TypeEnum != livingObjectCategory)
                        {
                            OnError(ObjectErrorEnum.SYMBIOTIC_OBJECT_ERROR);
                            return;
                        }

                        if (targeted.IsAssociated)
                        {
                            OnError(ObjectErrorEnum.SYMBIOTIC_OBJECT_ERROR);
                            return;
                        }

                        if (item.Quantity > 1)
                        {
                            CharacterItemRecord newItem = item.Cut(1, CharacterInventoryPositionEnum.INVENTORY_POSITION_NOT_EQUIPED);
                            this.AssociateLiving(item, targeted);
                            AddItem(newItem);
                            UpdateItemQuantity(item);
                        }
                        else
                        {
                            this.AssociateLiving(item, targeted);
                        }

                        return;
                    }

                    if (item.Template.TypeEnum == ItemTypeEnum.OBJET_D_APPARAT)
                    {
                        var targeted = GetEquipedItem(position);

                        if (targeted == null)
                        {
                            OnError(ObjectErrorEnum.CANNOT_EQUIP_HERE);
                            return;
                        }

                        if (targeted.Template.TypeId != item.FirstEffect <EffectInteger>(EffectsEnum.Effect_Associate).Value)
                        {
                            return;
                        }

                        if (targeted.IsAssociated)
                        {
                            OnError(ObjectErrorEnum.SYMBIOTIC_OBJECT_ERROR);
                            return;
                        }

                        if (item.Quantity > 1)
                        {
                            CharacterItemRecord newItem = item.Cut(1, CharacterInventoryPositionEnum.INVENTORY_POSITION_NOT_EQUIPED);
                            this.AssociateCompatibility(item, targeted);
                            AddItem(newItem);
                            UpdateItemQuantity(item);
                        }
                        else
                        {
                            this.AssociateCompatibility(item, targeted);
                        }

                        return;
                    }

                    if (item.HasEffect <EffectMination>())
                    {
                        EffectMination effect = item.FirstEffect <EffectMination>();

                        var monster = effect.GetTemplate();


                        var level = monster.GetGrade(effect.GradeId).Level;
                        level = (ushort)(level > 200 ? 200 : level);

                        if (level > Character.Level)
                        {
                            Character.Reply("Vous devez être niveau " + level + " pour équiper cette pierre.");
                            return;
                        }

                        if (monster.IsBoss && Character.Level < 180)
                        {
                            Character.Reply("Vous devez être niveau 180 pour équiper un boss de donjon.");
                            return;
                        }

                        if (monster.IsMiniBoss && Character.Level < 150)
                        {
                            Character.Reply("Vous devez être niveau 150 pour équiper un miniboss.");
                            return;
                        }

                        Character.SpellAnim(6021);
                    }

                    if (item.Template.TypeEnum == ItemTypeEnum.MONTILIER || item.Template.TypeEnum == ItemTypeEnum.FAMILIER)
                    {
                        if (HasMountEquiped && Mount.Toggled)
                        {
                            ToggleMount();
                        }
                    }

                    this.CheckTwoHandeds(position, item);

                    EquipItem(item, position, quantity);
                }
                else
                {
                    if (item.PositionEnum == CharacterInventoryPositionEnum.INVENTORY_POSITION_NOT_EQUIPED)
                    {
                        OnError(ObjectErrorEnum.CANNOT_EQUIP_HERE);
                        return;
                    }
                    else
                    {
                        UnequipItem(item, quantity);
                    }
                }

                OnObjectMoved(item, position);
                RefreshWeight();
                Character.RefreshActorOnMap();
                Character.RefreshStats();
            }
        }