public ComparisonCalculationRetribution()
 {
     Equipped = false;
     ItemInstance = null;
     Item = null;
     SubPoints = new float[] { 0f };
     OverallPoints = 0f;
 }
Exemplo n.º 2
0
        private void FixGemCountVisibilities(ItemInstance itemInstance) {
            Name_Gem1.Visibility = Image_Gem1.Visibility = Border_Gem1.Visibility = Visibility.Collapsed;
            Name_Gem2.Visibility = Image_Gem2.Visibility = Border_Gem2.Visibility = Visibility.Collapsed;
            Name_Gem3.Visibility = Image_Gem3.Visibility = Border_Gem3.Visibility = Visibility.Collapsed;

            if (itemInstance.Item.SocketColor1 != ItemSlot.None || itemInstance.Gem1 != null) { Name_Gem1.Visibility = Image_Gem1.Visibility = Border_Gem1.Visibility = Visibility.Visible; }
            if (itemInstance.Item.SocketColor2 != ItemSlot.None || itemInstance.Gem2 != null) { Name_Gem2.Visibility = Image_Gem2.Visibility = Border_Gem2.Visibility = Visibility.Visible; }
            if (itemInstance.Item.SocketColor3 != ItemSlot.None || itemInstance.Gem3 != null) { Name_Gem3.Visibility = Image_Gem3.Visibility = Border_Gem3.Visibility = Visibility.Visible; }
        }
Exemplo n.º 3
0
    void UpdatePlayerData(ItemInstance item)
    {
        UpdateUserDataRequest request = new UpdateUserDataRequest();
        Dictionary<string, string> playerData = new Dictionary<string,string>();
        playerData.Add(item.ItemClass, item.ItemId);
        request.Data = playerData;
        request.Permission = UserDataPermission.Public;

        PlayFabClientAPI.UpdateUserData(request, OnAddDataSuccess, OnAddDataError);
    }
        public CustomItemInstance(Character character, ItemInstance baseInstance)
        {
            InitializeComponent();

#if !SILVERLIGHT
            this.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterOwner;
            this.WindowState = System.Windows.WindowState.Normal;
#endif

            Character = character;
            CustomInstance = baseInstance.Clone();
        }
Exemplo n.º 5
0
 private void reportItemDifferences(StringBuilder sb)
 {
     Enchant noEnchant = Enchant.FindEnchant(0, ItemSlot.None, _before);
     Item noItem = new Item();
     noItem.Name = "No item equipped";
     Item noGem = new Item();
     ItemInstance noItemInstance = new ItemInstance();
     ItemInstance[] beforeItems = _before.GetItems();
     ItemInstance[] afterItems = _after.GetItems();
     int changes = 0;
     for (int i = 1; i < Character.SlotCount; i++)
     {
         CharacterSlot slot = (CharacterSlot)i;
         if (slot != CharacterSlot.Shirt && slot != CharacterSlot.Tabard)
         {
             ItemInstance before = beforeItems[i] ?? noItemInstance;
             ItemInstance after = afterItems[i] ?? noItemInstance;
             bool swappedRingTrinket = false;
             if (slot == CharacterSlot.Finger1 || slot == CharacterSlot.Trinket1)
             {
                 ItemInstance after2 = afterItems[i+1] ?? noItemInstance;
                 if (before != noItemInstance && after2 != noItemInstance && before.Equals(after2))
                 {
                     swappedRingTrinket = true;
                     i++; // force skip over finger2 and trinket2.
                 }
             }
             if (!(before == noItemInstance && after == noItemInstance) && !before.Equals(after) && !swappedRingTrinket)
             {
                 string itemname = (before.Item ?? noItem).Name;
                 string gem1name = before.Gem1 == null ? "" : "with " + before.Gem1.Name;
                 string gem2name = before.Gem2 == null ? "" : ", " + before.Gem2.Name;
                 string gem3name = before.Gem3 == null ? "" : ", " + before.Gem3.Name;
                 string enchantname = before.Enchant == null ? "" : ", " + before.Enchant.Name;
                 string reforgename = before.Reforging == null ? "" : ", " + before.Reforging.ToString();
                 sb.AppendFormat("{0}: Changed {1} {2}{3}{4}{5}{6}", slot, itemname, gem1name, gem2name, gem3name, enchantname, reforgename);
                 sb.AppendLine();
                 itemname = (after.Item ?? noItem).Name;
                 gem1name = after.Gem1 == null ? "" : "with " + after.Gem1.Name;
                 gem2name = after.Gem2 == null ? "" : ", " + after.Gem2.Name;
                 gem3name = after.Gem3 == null ? "" : ", " + after.Gem3.Name;
                 enchantname = after.Enchant == null ? "" : ", " + after.Enchant.Name;
                 reforgename = after.Reforging == null ? "" : ", " + after.Reforging.ToString();
                 sb.AppendFormat("               to {0} {1}{2}{3}{4}{5}", itemname, gem1name, gem2name, gem3name, enchantname, reforgename);
                 sb.AppendLine();
                 changes++;
             }
         }
     }
     if (changes == 0)
         sb.AppendLine("No item changes found");
 }
Exemplo n.º 6
0
    ItemEquipment GetItemEquipmentByInstance(ItemInstance instance)
    {
        ItemEquipmentInstance equipInstance = new ItemEquipmentInstance()
        {
            id = instance.id,
            bagType = instance.bagType,
            bindingType = instance.bindingType,
            stack = instance.stack,
            templeId = instance.templeId,
            gridIndex = instance.gridIndex,
            sourceKey = instance.sourceKey,
            sourceValue = instance.sourceValue,
        };
        if (instance.extendInfo != null)
        {
            //Mogo.Util.LoggerHelper.Debug("instance.extendInfo:" + instance.extendInfo);
            if (instance.extendInfo.ContainsKey(0))
            {
                //Mogo.Util.LoggerHelper.Debug("instance.extendInfo:" + instance.extendInfo["lock"]);
                equipInstance.locked = (instance.extendInfo[0] == 0 ? false : true);
            }

            if (instance.extendInfo.ContainsKey(1))
            {
                //Mogo.Util.LoggerHelper.Debug("instance.extendInfo:" + instance.extendInfo["lock"]);
                equipInstance.isActive = (instance.extendInfo[1] == 0 ? false : true);
            }
        }


        //slot表示格式转换,dic->list
        equipInstance.jewelSlots = new List<int>();
        LoggerHelper.Debug("instance.templeId:" + instance.templeId);
        ItemEquipmentData equip = ItemEquipmentData.dataMap[instance.templeId];
        if (equip.jewelSlot != null && equip.jewelSlot.Count > 0)
        {
            if (equip.jewelSlot[0] != -1)
            {
                for (int i = 0; i < equip.jewelSlot.Count; i++)
                {
                    equipInstance.jewelSlots.Add(-1);
                }
            }
        }

        if (instance.jewelSlots != null)
        {
            foreach (KeyValuePair<int, int> pair in instance.jewelSlots)
            {
                equipInstance.jewelSlots[pair.Key - 1] = pair.Value;
            }
        }



        return new ItemEquipment(equipInstance);
    }
Exemplo n.º 7
0
 public MobContainer(String visual, String focusName, ItemInstance[] items, int[] amounts, bool isLocked, ItemInstance keyInstance, String pickLockString, bool cdDyn, bool cdStatic)
     : this(visual, focusName, items, amounts, isLocked, keyInstance, pickLockString, null, null, cdDyn, cdStatic)
 {
 }
Exemplo n.º 8
0
 private void onItemEquipped(CharacterInstance character, ItemInstance itemInstance, ItemInstance replacedItemInstance)
 {
     character.OwningPlayer.Notifiers.markItemNotificationsAsInspected(itemInstance);
     this.onRefresh();
 }
Exemplo n.º 9
0
 /// <summary>
 /// For each character in BatchCharacterList replaces equipped unavailable gear with the closest available one.
 /// </summary>
 public void ReplaceUnavailableGear()
 {
     foreach (BatchCharacter character in BatchCharacterList)
     {
         if (character.Character != null)
         {
             for (int slot = 0; slot < 19; slot++)
             {
                 ItemInstance item = character.Character[(CharacterSlot)slot];
                 if (item != null)
                 {
                     string id = item.Id.ToString();
                     string anyGem = id + ".*.*.*";
                     string onlyGemmedId = string.Format("{0}.{1}.{2}.{3}", item.Id, item.Gem1Id, item.Gem2Id, item.Gem3Id);
                     string anyEnchant = string.Format("{0}.{1}.{2}.{3}.*", item.Id, item.Gem1Id, item.Gem2Id, item.Gem3Id);
                     List<string> list = character.Character.AvailableItems.FindAll(x => x.StartsWith(id, StringComparison.Ordinal));
                     List<string> sublist;
                     if (list.Contains(onlyGemmedId + ".*"))
                     {
                         // available
                     }
                     else if ((sublist = list.FindAll(x => x.StartsWith(onlyGemmedId, StringComparison.Ordinal))).Count > 0)
                     {
                         if (sublist.Contains(item.GemmedId))
                         {
                             // available
                         }
                         else
                         {
                             // have to replace enchant
                             string s = sublist[0];
                             character.Character.SetEnchantBySlot((CharacterSlot)slot, Enchant.FindEnchant(int.Parse(s.Substring(s.LastIndexOf('.') + 1)), item.Slot, character.Character));
                             character.UnsavedChanges = true;
                         }
                     }
                     else if (list.Contains(id))
                     {
                         // available
                     }
                     else if ((sublist = list.FindAll(x => x.StartsWith(anyGem, StringComparison.Ordinal))).Count > 0)
                     {
                         if (sublist.Contains(anyGem + "." + item.EnchantId))
                         {
                             // available
                         }
                         else
                         {
                             // have to replace enchant
                             string s = sublist[0];
                             character.Character.SetEnchantBySlot((CharacterSlot)slot, Enchant.FindEnchant(int.Parse(s.Substring(s.LastIndexOf('.') + 1)), item.Slot, character.Character));
                             character.UnsavedChanges = true;
                         }
                     }
                     else if (list.Count > 0)
                     {
                         string s = list[0];
                         if (s.EndsWith("*"))
                         {
                             s = s.TrimEnd('*') + item.EnchantId;
                         }
                         item = new ItemInstance(s);
                         character.Character[(CharacterSlot)slot] = item;
                         character.UnsavedChanges = true;
                     }
                     else
                     {
                         foreach (string s in character.Character.AvailableItems)
                         {
                             ItemInstance newItem = null;
                             if (s.IndexOf('.') < 0)
                             {
                                 if (!s.StartsWith("-", StringComparison.Ordinal))
                                 {
                                     newItem = item.Clone();
                                     newItem.Id = int.Parse(s);
                                     if (newItem.Item.SocketColor1 == ItemSlot.None) newItem.Gem1 = null;
                                     if (newItem.Item.SocketColor2 == ItemSlot.None) newItem.Gem2 = null;
                                     if (newItem.Item.SocketColor3 == ItemSlot.None) newItem.Gem3 = null;
                                 }
                             }
                             else
                             {
                                 string[] slist = s.Split('.');
                                 if (slist[1] == "*")
                                 {
                                     newItem = item.Clone();
                                     newItem.Id = int.Parse(slist[0]);
                                     if (newItem.Item.SocketColor1 == ItemSlot.None) newItem.Gem1 = null;
                                     if (newItem.Item.SocketColor2 == ItemSlot.None) newItem.Gem2 = null;
                                     if (newItem.Item.SocketColor3 == ItemSlot.None) newItem.Gem3 = null;
                                 }
                                 else
                                 {
                                     newItem = item.Clone();
                                     newItem.Id = int.Parse(slist[0]);
                                     newItem.Gem1Id = int.Parse(slist[1]);
                                     newItem.Gem2Id = int.Parse(slist[2]);
                                     newItem.Gem3Id = int.Parse(slist[3]);
                                 }
                             }
                             if (newItem != null && newItem.Item.FitsInSlot((CharacterSlot)slot, character.Character))
                             {
                                 character.Character[(CharacterSlot)slot] = newItem;
                                 string se = s.Substring(s.LastIndexOf('.') + 1);
                                 if (se != "*")
                                 {
                                     character.Character.SetEnchantBySlot((CharacterSlot)slot, Enchant.FindEnchant(int.Parse(se), item.Slot, character.Character));
                                 }
                                 character.UnsavedChanges = true;
                                 break;
                             }
                         }
                     }
                 }
             }
         }
     }
 }
Exemplo n.º 10
0
 public void AddItemToInventory(ItemInstance item)
 {
     items.Add(item);
     //OnInventoryChange?.Invoke();
 }
Exemplo n.º 11
0
        public List <ItemInstance> TryEquipItem(ItemInstance i, bool force = false)
        {
            List <ItemInstance> markedForRemoval = new List <ItemInstance>();

            foreach (var a in EquippedItems.Where(b => b.Value != null).Select(b => b.Value).Distinct())
            {
                var equip = a.item.EquipmentRef;
                foreach (var slot in i.item.EquipmentRef.OccupiesSlots)
                {
                    if (equip.OccupiesSlots.Contains(slot))
                    {
                        if (!force)
                        {
                            var result = new ScriptWrapper(equip.OnUnequip)
                            {
                                ItemBase = a
                            }.Execute();
                            if (result != false)
                            {
                                markedForRemoval.Add(a);
                            }
                            else
                            {
                                MainViewModel.WriteText("Unable to equip " + i.CurrentName + " because " + a.CurrentName + " could not be removed!", null);
                                return(new List <ItemInstance>());
                            }
                        }
                        else
                        {
                            markedForRemoval.Add(a);
                        }
                    }
                    if (!force && equip.CoversSlots.Contains(slot))
                    {
                        var result = new ScriptWrapper(equip.OnUnequip)
                        {
                            ItemBase = a
                        }.Execute();
                        if (result == false)
                        {
                            MainViewModel.WriteText("Unable to equip " + i.CurrentName + " because " + a.CurrentName + " is covering it and could not be removed!", null);
                            return(new List <ItemInstance>());
                        }
                    }
                }
            }
            {
                var result = new ScriptWrapper(i.item.EquipmentRef.OnEquip)
                {
                    ItemBase = i
                }.Execute();
                if (result == false)
                {
                    MainViewModel.WriteText("Unable to unequip " + i.CurrentName + " because it is currently unable to be equipped!", null);
                    return(new List <ItemInstance>());
                }
            }
            foreach (var a in markedForRemoval)
            {
                foreach (var slot in a.item.EquipmentRef.OccupiesSlots)
                {
                    EquippedItems[slot] = null;
                }
            }
            foreach (var slot in i.item.EquipmentRef.OccupiesSlots)
            {
                EquippedItems[slot] = i;
            }
            if (PlayerInventory.Contains(i))
            {
                PlayerInventory.Remove(i);
            }
            return(markedForRemoval);
        }
Exemplo n.º 12
0
 public bool IsEquipped(ItemInstance itemToBeChecked)
 {
     CharacterSlot slot = Character.GetCharacterSlotByItemSlot(itemToBeChecked.Slot);
     if (slot == CharacterSlot.Finger1)
         return IsEquipped(itemToBeChecked, CharacterSlot.Finger1) || IsEquipped(itemToBeChecked, CharacterSlot.Finger2);
     else if (itemToBeChecked.Slot == Rawr.ItemSlot.OneHand)
         return IsEquipped(itemToBeChecked, CharacterSlot.MainHand) || IsEquipped(itemToBeChecked, CharacterSlot.OffHand);
     else if (itemToBeChecked.Slot == Rawr.ItemSlot.Trinket)
         return IsEquipped(itemToBeChecked, CharacterSlot.Trinket1) || IsEquipped(itemToBeChecked, CharacterSlot.Trinket2);
     else
         return IsEquipped(itemToBeChecked, slot);
 }
Exemplo n.º 13
0
 public void Consume(ItemInstance item)
 {
     //Consume item
     items.Remove(item);
     OnInventoryChange?.Invoke();
 }
Exemplo n.º 14
0
 public void SetItems(ItemInstance[] items, bool invalidate)
 {
     int max = Math.Min(OptimizableSlotCount, items.Length);
     for (int slot = 0; slot < max; slot++)
     {
         _item[slot] = items[slot] == null ? null : items[slot].Clone();
     }
     // when called from optimizer we never want to invalidate since that causes creation of new item instances
     // and causes us to lose stats cache
     if (invalidate) { OnCalculationsInvalidated(); }
 }
Exemplo n.º 15
0
 public List<ItemInstance> GetRelevantItemInstances(CharacterSlot slot, bool forceAll=false)
 {
     bool blacksmithingSocket = false;
     if ((slot == CharacterSlot.Waist && WaistBlacksmithingSocketEnabled)
         || (slot == CharacterSlot.Hands && HandsBlacksmithingSocketEnabled)
         || (slot == CharacterSlot.Wrist && WristBlacksmithingSocketEnabled))
     {
         blacksmithingSocket = true;
     }
     List<ItemInstance> items;
     if (!_relevantItemInstances.TryGetValue(slot, out items))
     {
         Dictionary<int, bool> itemChecked = new Dictionary<int, bool>();
         items = new List<ItemInstance>();
         foreach (Item item in (forceAll ? ItemCache.AllItems : ItemCache.RelevantItems))
         {
             if (item.FitsInSlot(slot, this) && item.FitsFaction(Race))
             {
                 itemChecked[item.Id] = true;
                 List<int> suffixList;
                 if (item.AllowedRandomSuffixes == null || item.AllowedRandomSuffixes.Count == 0) {
                     suffixList = zeroSuffixList;
                 } else {
                     suffixList = item.AllowedRandomSuffixes;
                 }
                 foreach (int randomSuffix in suffixList)
                 {
                     foreach (Reforging reforging in CurrentCalculations.GetReforgingOptions(item, randomSuffix))
                     {
                         List<Tinkering> t = CurrentCalculations.GetTinkeringOptions(item, this);
                         foreach (Tinkering tinkering in t)
                         {
                             List<Enchant> e = CurrentCalculations.GetEnchantingOptions(item, this);
                             foreach (Enchant enchant in e)
                             {
                                 List<ItemInstance> itemInstances = new List<ItemInstance>();
                                 // Built in Gemming Templates
                                 foreach (GemmingTemplate template in CurrentGemmingTemplates)
                                 {
                                     if (template.Enabled)
                                     {
                                         ItemInstance instance = template.GetItemInstance(item, randomSuffix, enchant/*GetEnchantBySlot(slot)*/, reforging, tinkering/*GetTinkeringBySlot(slot)*/, blacksmithingSocket);
                                         if (!itemInstances.Contains(instance)) itemInstances.Add(instance);
                                     }
                                 }
                                 // Gemming Templates the User added
                                 foreach (GemmingTemplate template in CustomGemmingTemplates)
                                 {
                                     if (template.Enabled && template.Model == CurrentModel)
                                     {
                                         ItemInstance instance = template.GetItemInstance(item, randomSuffix, enchant/*GetEnchantBySlot(slot)*/, reforging, tinkering/*GetTinkeringBySlot(slot)*/, blacksmithingSocket);
                                         if (!itemInstances.Contains(instance)) itemInstances.Add(instance);
                                     }
                                 }
                                 items.AddRange(itemInstances);
                             }
                         }
                     }
                 }
             }
         }
         // add custom instances
         foreach (ItemInstance item in CustomItemInstances)
         {
             if (item.Item != null && item.Item.FitsInSlot(slot, this)) // item.Item can be null if you're loading character with custom items that are not present on this install
             {
                 // if it's already in make sure to set force visible to true
                 int index = items.IndexOf(item);
                 if (index >= 0)
                 {
                     items[index] = item;
                 }
                 else
                 {
                     items.Add(item);
                 }
             }
         }
         // add available instances (green diamonds)
         foreach (string availableItem in AvailableItems)
         {
             string[] ids = availableItem.Split('.');
             if (ids.Length <= 2)
             {
                 // we have an available item that might be filtered out
                 Item item = ItemCache.FindItemById(int.Parse(ids[0], System.Globalization.CultureInfo.InvariantCulture));
                 if (item != null)
                 {
                     if (item.FitsInSlot(slot, this))
                     {
                         if (itemChecked.ContainsKey(item.Id))
                         {
                             // we've already processed this one
                             continue;
                         }
                         Enchant enchant = GetEnchantBySlot(slot);
                         Tinkering tinkering = GetTinkeringBySlot(slot);
                         List<ItemInstance> itemInstances = new List<ItemInstance>();
                         int randomSuffix = ids.Length < 2 ? 0 : int.Parse(ids[1], System.Globalization.CultureInfo.InvariantCulture);
                         foreach (Reforging reforging in CurrentCalculations.GetReforgingOptions(item, randomSuffix))
                         {
                             foreach (GemmingTemplate template in CurrentGemmingTemplates)
                             {
                                 if (template.Enabled)
                                 {
                                     ItemInstance instance = template.GetItemInstance(item, randomSuffix, GetEnchantBySlot(slot), reforging, GetTinkeringBySlot(slot), blacksmithingSocket);
                                     if (!itemInstances.Contains(instance)) itemInstances.Add(instance);
                                 }
                             }
                             foreach (GemmingTemplate template in CustomGemmingTemplates)
                             {
                                 if (template.Enabled && template.Model == CurrentModel)
                                 {
                                     ItemInstance instance = template.GetItemInstance(item, randomSuffix, GetEnchantBySlot(slot), reforging, GetTinkeringBySlot(slot), blacksmithingSocket);
                                     if (!itemInstances.Contains(instance)) itemInstances.Add(instance);
                                 }
                             }
                         }
                         items.AddRange(itemInstances);
                     }
                     itemChecked[item.Id] = true;
                 }
             }
         }
         // add available instances (blue diamonds)
         foreach (string availableItem in AvailableItems)
         {
             string[] ids = availableItem.Split('.');
             if (ids.Length == 8) // only support new format with random suffixes
             {
                 Item item = ItemCache.FindItemById(int.Parse(ids[0], System.Globalization.CultureInfo.InvariantCulture));
                 if (item.FitsInSlot(slot, this))
                 {
                     ItemInstance instance = new ItemInstance(availableItem);
                     instance.ForceDisplay = true;
                     // we want to force display even if it's already present (might be lower than top N)
                     int index = items.IndexOf(instance);
                     if (index < 0)
                     {
                         items.Add(instance);
                     }
                     else
                     {
                         items[index] = instance;
                     }
                 }
             }
         } 
         _relevantItemInstances[slot] = items;
     }
     return items;
 }
Exemplo n.º 16
0
 public void SetItems(ItemInstance[] items) { SetItems(items, true); }
Exemplo n.º 17
0
        public void ToggleItemAvailability(ItemInstance item, bool regemmingAllowed)
        {
            string id = item.Id.ToString();
            if (item.RandomSuffixId != 0)
            {
                id += "." + item.RandomSuffixId;
            }
            ItemAvailability newItemAvailability = ItemAvailability.NotAvailable;

            if (id.StartsWith("-", StringComparison.Ordinal) || regemmingAllowed)
            {
                // all enabled toggle
                if (_availableItems.Contains(id))
                {
                    _availableItems.Remove(id);
                    newItemAvailability = ItemAvailability.NotAvailable;
                }
                else
                {
                    _availableItems.Add(id);
                    newItemAvailability = ItemAvailability.RegemmingAllowed;
                }
            }
            else
            {
                Predicate<string> p = (x =>
                {
                    return x == item.GemmedId;
                });
                // enabled toggle
                if (_availableItems.FindIndex(p) >= 0)
                {
                    _availableItems.RemoveAll(p);
                    newItemAvailability = ItemAvailability.NotAvailable;
                }
                else
                {
                    _availableItems.Add(item.GemmedId);
                    newItemAvailability = ItemAvailability.Available;
                }
            }
            OnAvailableItemsChanged(id, newItemAvailability);
        }
Exemplo n.º 18
0
 public ItemAvailability GetItemAvailability(ItemInstance itemInstance)
 {
     return GetItemAvailability(itemInstance.Id.ToString(), string.Format("{0}.{1}", itemInstance.Id, itemInstance.RandomSuffixId), itemInstance.GemmedId);
 }
Exemplo n.º 19
0
 public MobContainer(String visual, String focusName, ItemInstance[] items, int[] amounts, bool isLocked, ItemInstance keyInstance, String pickLockString, ItemInstance useWithItem, String triggerTarget, bool cdDyn, bool cdStatic)
     : this(new GUC.WorldObjects.Mobs.MobContainer(), visual, focusName, items, amounts, isLocked, keyInstance, pickLockString, useWithItem, triggerTarget, cdDyn, cdStatic, true)
 {
 }
Exemplo n.º 20
0
 public bool IsEquipped(ItemInstance itemToBeChecked, CharacterSlot slot)
 {
     return itemToBeChecked == this[slot];
 }
Exemplo n.º 21
0
        public override void Handle(NecClient client, NecPacket packet)
        {
            ItemZoneType   zone      = (ItemZoneType)packet.data.ReadByte();
            byte           bag       = packet.data.ReadByte();
            short          slot      = packet.data.ReadInt16();
            ItemEquipSlots equipSlot = (ItemEquipSlots)packet.data.ReadInt32();

            _Logger.Debug($"storageType:{zone} bagId:{bag} bagSlotIndex:{slot} equipBit:{equipSlot}");

            ItemLocation location    = new ItemLocation(zone, bag, slot);
            ItemService  itemService = new ItemService(client.character);
            int          error       = 0;

            try
            {
                if (equipSlot.HasFlag(ItemEquipSlots.LeftHand | ItemEquipSlots.RightHand)) //two handed weapon replaces 1h weapon and shield
                {
                    ItemInstance itemRight = itemService.CheckAlreadyEquipped(ItemEquipSlots.RightHand);
                    if (itemRight != null)
                    {
                        itemRight = itemService.Unequip(itemRight.currentEquipSlot);
                        itemRight.currentEquipSlot = ItemEquipSlots.None;
                        RecvItemUpdateEqMask recvItemUpdateEqMaskCurr = new RecvItemUpdateEqMask(client, itemRight);
                        router.Send(recvItemUpdateEqMaskCurr, client);
                    }

                    ItemInstance itemLeft = itemService.CheckAlreadyEquipped(ItemEquipSlots.LeftHand);
                    if (itemLeft != null)
                    {
                        itemLeft = itemService.Unequip(itemLeft.currentEquipSlot);
                        itemLeft.currentEquipSlot = ItemEquipSlots.None;
                        RecvItemUpdateEqMask recvItemUpdateEqMaskCurr = new RecvItemUpdateEqMask(client, itemLeft);
                        router.Send(recvItemUpdateEqMaskCurr, client);
                    }
                }
                else //everything else besides 2h weapons.
                {
                    //update the equipment array
                    ItemInstance equippedItem = itemService.CheckAlreadyEquipped(equipSlot);
                    if (equippedItem != null)
                    {
                        equippedItem = itemService.Unequip(equippedItem.currentEquipSlot);
                        equippedItem.currentEquipSlot = ItemEquipSlots.None;
                        RecvItemUpdateEqMask recvItemUpdateEqMaskCurr = new RecvItemUpdateEqMask(client, equippedItem);
                        router.Send(recvItemUpdateEqMaskCurr, client);
                    }
                }

                //update the equipment array
                ItemInstance newEquippedItem = itemService.Equip(location, equipSlot);

                //Tell the client to move the icons to equipment slots
                RecvItemUpdateEqMask recvItemUpdateEqMask = new RecvItemUpdateEqMask(client, newEquippedItem);
                router.Send(client, recvItemUpdateEqMask.ToPacket());

                //notify other players of your new look
                RecvDataNotifyCharaData myCharacterData = new RecvDataNotifyCharaData(client.character, client.soul.name);
                router.Send(client.map, myCharacterData, client);
            }
            catch (ItemException e)
            {
                error = (int)e.type;
            }

            //tell the send if everything went well or not.  notify the client chat of any errors
            RecvItemEquip recvItemEquip = new RecvItemEquip(client, error);

            router.Send(recvItemEquip);

            //Re-do all your stats
            router.Send(client, itemService.CalculateBattleStats(client));
        }
Exemplo n.º 22
0
 private int GetItemGemIdCount(ItemInstance item, int id)
 {
     int count = 0;
     if ((object)item != null)
     {
         if (item.Gem1 != null && item.Gem1.Id == id) count++;
         if (item.Gem2 != null && item.Gem2.Id == id) count++;
         if (item.Gem3 != null && item.Gem3.Id == id) count++;
     }
     return count;
 }
Exemplo n.º 23
0
 // Not even items!
 public override void isHitByItem(ItemInstance item, State expectedHitState)
 {
     // base.isHitByItem(item, expectedHitState);
 }
Exemplo n.º 24
0
 public CharacterSlot[] GetEquippedSlots(ItemInstance item)
 {
     List<CharacterSlot> listSlots = new List<CharacterSlot>();
     foreach (CharacterSlot slot in CharacterSlots)
         if (this[slot] == item)
             listSlots.Add(slot);
     return listSlots.ToArray();
 }
Exemplo n.º 25
0
        /// <summary>
        /// c_reg packet
        /// </summary>
        /// <param name="cRegPacket"></param>
        public void SellBazaar(CRegPacket cRegPacket)
        {
            SpinWait.SpinUntil(() => !ServerManager.Instance.InBazaarRefreshMode);
            StaticBonusDTO medal = Session.Character.StaticBonusList.FirstOrDefault(s => s.StaticBonusType == StaticBonusType.BazaarMedalGold || s.StaticBonusType == StaticBonusType.BazaarMedalSilver);

            long price   = cRegPacket.Price * cRegPacket.Amount;
            long taxmax  = price > 100000 ? price / 200 : 500;
            long taxmin  = price >= 4000 ? (60 + (price - 4000) / 2000 * 30 > 10000 ? 10000 : 60 + (price - 4000) / 2000 * 30) : 50;
            long tax     = medal == null ? taxmax : taxmin;
            long maxGold = ServerManager.Instance.MaxGold;

            if (Session.Character.Gold < tax || cRegPacket.Amount <= 0 || Session.Character.ExchangeInfo != null && Session.Character.ExchangeInfo.ExchangeList.Any() || Session.Character.IsShopping)
            {
                return;
            }
            ItemInstance it = Session.Character.Inventory.LoadBySlotAndType(cRegPacket.Slot, cRegPacket.Inventory == 4 ? 0 : (InventoryType)cRegPacket.Inventory);

            if (it == null || !it.Item.IsSoldable || it.IsBound)
            {
                return;
            }
            if (Session.Character.Inventory.CountItemInAnInventory(InventoryType.Bazaar) > 10 * (medal == null ? 1 : 10))
            {
                Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("LIMIT_EXCEEDED"), 0));
                return;
            }
            if (price >= (medal == null ? 1000000 : maxGold))
            {
                Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("PRICE_EXCEEDED"), 0));
                return;
            }
            if (cRegPacket.Price < 0)
            {
                return;
            }
            ItemInstance bazar = Session.Character.Inventory.AddIntoBazaarInventory(cRegPacket.Inventory == 4 ? 0 : (InventoryType)cRegPacket.Inventory, cRegPacket.Slot, cRegPacket.Amount);

            if (bazar == null)
            {
                return;
            }
            short duration;

            switch (cRegPacket.Durability)
            {
            case 1:
                duration = 24;
                break;

            case 2:
                duration = 168;
                break;

            case 3:
                duration = 360;
                break;

            case 4:
                duration = 720;
                break;

            default:
                return;
            }

            DAOFactory.IteminstanceDAO.InsertOrUpdate(bazar);

            BazaarItemDTO bazaarItem = new BazaarItemDTO
            {
                Amount         = bazar.Amount,
                DateStart      = DateTime.Now,
                Duration       = duration,
                IsPackage      = cRegPacket.IsPackage != 0,
                MedalUsed      = medal != null,
                Price          = cRegPacket.Price,
                SellerId       = Session.Character.CharacterId,
                ItemInstanceId = bazar.Id
            };

            DAOFactory.BazaarItemDAO.InsertOrUpdate(ref bazaarItem);
            ServerManager.Instance.BazaarRefresh(bazaarItem.BazaarItemId);

            Session.Character.Gold -= tax;
            Session.SendPacket(Session.Character.GenerateGold());

            Session.SendPacket(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("OBJECT_IN_BAZAAR"), 10));
            Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("OBJECT_IN_BAZAAR"), 0));

            Session.SendPacket("rc_reg 1");
        }
Exemplo n.º 26
0
 public Character(string name, string realm, CharacterRegion region, CharacterRace race, BossOptions boss,
     ItemInstance head, ItemInstance neck, ItemInstance shoulders, ItemInstance back, ItemInstance chest, ItemInstance shirt, ItemInstance tabard,
         ItemInstance wrist, ItemInstance hands, ItemInstance waist, ItemInstance legs, ItemInstance feet, ItemInstance finger1, ItemInstance finger2,
     ItemInstance trinket1, ItemInstance trinket2, ItemInstance mainHand, ItemInstance offHand, ItemInstance ranged, ItemInstance projectile,
     ItemInstance projectileBag)
 {
     Initialize();
     //_trackEquippedItemChanges = trackEquippedItemChanges;
     IsLoading = true;
     _name = name;
     _realm = realm;
     _region = region;
     _race = race;
     Head = head;
     Neck = neck;
     Shoulders = shoulders;
     Back = back;
     Chest = chest;
     Shirt = shirt;
     Tabard = tabard;
     Wrist = wrist;
     Hands = hands;
     Waist = waist;
     Legs = legs;
     Feet = feet;
     Finger1 = finger1;
     Finger2 = finger2;
     Trinket1 = trinket1;
     Trinket2 = trinket2;
     MainHand = mainHand;
     OffHand = offHand;
     Ranged = ranged;
     Projectile = projectile;
     ProjectileBag = projectileBag;
     _activeBuffs = new List<Buff>();
     SetFaction();
     IsLoading = false;
     RecalculateSetBonuses();
     BossOptions = boss.Clone();
 }
Exemplo n.º 27
0
 // Remove the item from the slot, and destroy the associated gameobject.
 public void RemoveItem()
 {
     this.itemInstance = null;
     Destroy(this.prefabInstance);
     this.prefabInstance = null;
 }
Exemplo n.º 28
0
        // The following are special contructors used by optimizer, they assume the cached items/enchant are always used, and the underlying gemmedid/enchantid are never used
        public Character(string name, string realm, CharacterRegion region, CharacterRace race, BossOptions boss,
            ItemInstance head, ItemInstance neck, ItemInstance shoulders, ItemInstance back, ItemInstance chest, ItemInstance shirt, ItemInstance tabard,
                ItemInstance wrist, ItemInstance hands, ItemInstance waist, ItemInstance legs, ItemInstance feet, ItemInstance finger1, ItemInstance finger2, 
            ItemInstance trinket1, ItemInstance trinket2, ItemInstance mainHand, ItemInstance offHand, ItemInstance ranged, ItemInstance projectile,
            ItemInstance projectileBag, List<Buff> activeBuffs, string model)
        {
            Initialize();
            IsLoading = true;
            _name = name;
            _realm = realm;
            _region = region;
            _race = race;
            _item[(int)CharacterSlot.Head] = head;
            _item[(int)CharacterSlot.Neck] = neck;
            _item[(int)CharacterSlot.Shoulders] = shoulders;
            _item[(int)CharacterSlot.Back] = back;
            _item[(int)CharacterSlot.Chest] = chest;
            _item[(int)CharacterSlot.Shirt] = shirt;
            _item[(int)CharacterSlot.Tabard] = tabard;
            _item[(int)CharacterSlot.Wrist] = wrist;
            _item[(int)CharacterSlot.Hands] = hands;
            _item[(int)CharacterSlot.Waist] = waist;
            _item[(int)CharacterSlot.Legs] = legs;
            _item[(int)CharacterSlot.Feet] = feet;
            _item[(int)CharacterSlot.Finger1] = finger1;
            _item[(int)CharacterSlot.Finger2] = finger2;
            _item[(int)CharacterSlot.Trinket1] = trinket1;
            _item[(int)CharacterSlot.Trinket2] = trinket2;
            _item[(int)CharacterSlot.MainHand] = mainHand;
            _item[(int)CharacterSlot.OffHand] = offHand;
            _item[(int)CharacterSlot.Ranged] = ranged;
            _item[(int)CharacterSlot.Projectile] = projectile;
            _item[(int)CharacterSlot.ProjectileBag] = projectileBag;
            IsLoading = false;
            ActiveBuffs = new List<Buff>(activeBuffs);
            SetFaction();
            CurrentModel = model;
            RecalculateSetBonuses();

            BossOptions = boss.Clone();
        }
Exemplo n.º 29
0
        private void bwParseCharacter_DoWork(object sender, DoWorkEventArgs e)
        {
            XDocument xdoc = e.Argument as XDocument;
            Character character = new Character() { IsLoading = false };
            try
            {
                XElement xchar = xdoc.Root.Element("character");
                character.Region = (CharacterRegion)Enum.Parse(typeof(CharacterRegion), xchar.Attribute("region").Value, true);
                character.Realm = xchar.Attribute("realm").Value;
                character.Name = xchar.Attribute("name").Value;
                character.ClassIndex = int.Parse(xchar.Attribute("class_id").Value);
                character.RaceIndex = int.Parse(xchar.Attribute("race_id").Value);
                character.WaistBlacksmithingSocketEnabled = true;

                Dictionary<CharacterSlot, ItemInstance> items = new Dictionary<CharacterSlot, ItemInstance>();
                foreach (XElement xequipment in xchar.Element("equipInfo").Elements("equipment"))
                {
                    ItemInstance item = new ItemInstance(string.Format("{0}.{1}.{2}.{3}.{4}",
                        (xequipment.Attribute("item_id") ?? new XAttribute("item_id", "0")).Value,
                        (xequipment.Attribute("gem1_id") ?? new XAttribute("gem1_id", "0")).Value,
                        (xequipment.Attribute("gem2_id") ?? new XAttribute("gem2_id", "0")).Value,
                        (xequipment.Attribute("gem3_id") ?? new XAttribute("gem3_id", "0")).Value,
                        (xequipment.Attribute("enchant_id") ?? new XAttribute("enchant_id", "0")).Value));
                    items[Character.GetCharacterSlotFromId(int.Parse(xequipment.Attribute("slot").Value) + 1)] = item;
                }

                foreach (XElement xtalent in xchar.Element("talentInfo").Elements("talent"))
                {
                    if (xtalent.Attribute("active").Value == "1")
                    {
                        string talentCode = xtalent.Attribute("value").Value;
                        switch (character.Class)
                        {
                            case CharacterClass.Warrior:
                                character.WarriorTalents = new WarriorTalents(talentCode);
                                if (character.WarriorTalents.Devastate > 0) character.CurrentModel = "ProtWarr";
                                else character.CurrentModel = "DPSWarr";
                                break;
                            case CharacterClass.Paladin:
                                character.PaladinTalents = new PaladinTalents(talentCode);
                                if (character.PaladinTalents.HolyShield > 0) character.CurrentModel = "ProtPaladin";
                                else if (character.PaladinTalents.Zealotry > 0) character.CurrentModel = "Retribution";
                                else character.CurrentModel = "Healadin";
                                break;
                            case CharacterClass.Hunter:
                                character.HunterTalents = new HunterTalents(talentCode);
                                character.CurrentModel = "Hunter";
                                break;
                            case CharacterClass.Rogue:
                                character.RogueTalents = new RogueTalents(talentCode);
                                character.CurrentModel = "Rogue";
                                break;
                            case CharacterClass.Priest:
                                character.PriestTalents = new PriestTalents(talentCode);
                                if (character.PriestTalents.Shadowform > 0) character.CurrentModel = "ShadowPriest";
                                else character.CurrentModel = "HealPriest";
                                break;
                            case CharacterClass.Shaman:
                                character.ShamanTalents = new ShamanTalents(talentCode);
                                if (character.ShamanTalents.ElementalMastery > 0) character.CurrentModel = "Elemental";
                                else if (character.ShamanTalents.Stormstrike > 0) character.CurrentModel = "Enhance";
                                else character.CurrentModel = "RestoSham";
                                break;
                            case CharacterClass.Mage:
                                character.MageTalents = new MageTalents(talentCode);
                                character.CurrentModel = "Mage";
                                break;
                            case CharacterClass.Warlock:
                                character.WarlockTalents = new WarlockTalents(talentCode);
                                character.CurrentModel = "Warlock";
                                break;
                            case CharacterClass.Druid:
                                character.DruidTalents = new DruidTalents(talentCode);
                                if (character.DruidTalents.NaturalReaction > 0) character.CurrentModel = "Bear";
                                else if (character.DruidTalents.LeaderOfThePack > 0) character.CurrentModel = "Cat";
                                else if (character.DruidTalents.MoonkinForm > 0) character.CurrentModel = "Moonkin";
                                else character.CurrentModel = "Tree";
                                break;
                            case CharacterClass.DeathKnight:
                                character.DeathKnightTalents = new DeathKnightTalents(talentCode);
                                if (character.DeathKnightTalents.HighestTree == 0) character.CurrentModel = "TankDK";
                                else character.CurrentModel = "DPSDK";
                                break;
                            default:
                                break;
                        }

                        TalentsBase talents = character.CurrentTalents;
                        Dictionary<string, PropertyInfo> glyphProperties = new Dictionary<string, PropertyInfo>();
                        foreach (PropertyInfo pi in talents.GetType().GetProperties())
                        {
                            GlyphDataAttribute[] glyphDatas = pi.GetCustomAttributes(typeof(GlyphDataAttribute), true) as GlyphDataAttribute[];
                            if (glyphDatas.Length > 0)
                            {
                                GlyphDataAttribute glyphData = glyphDatas[0];
                                glyphProperties[glyphData.Name] = pi;
                            }
                        }

                        foreach (XElement glyph in xtalent.Element("glyphInfo").Elements("glyph"))
                        {
                            PropertyInfo pi;
                            if (glyphProperties.TryGetValue(glyph.Attribute("name").Value, out pi))
                            {
                                pi.SetValue(talents, true, null);
                            }
                        }
                    }
                }

                //TODO: Implement pet talent info parsing
                if (character.Class == CharacterClass.Hunter)
                {
                    List<ArmoryPet> pets = new List<ArmoryPet>();
                    // Pull Pet(s) Info if you are a Hunter
                    foreach (XElement xtalent in xchar.Element("petTalentInfo").Elements("talent"))
                    {
                        string petname  = xtalent.Attribute("name").Value;
                        string fam      = xtalent.Attribute("family_id").Value;
                        string SpecKey  = "";// xtalent.Attribute("key").Value;
                        string spec     = xtalent.Attribute("value").Value;
                        //
                        bool processed = false;
                        foreach (ArmoryPet a in pets) {
                            if (a.Name == petname) { processed = true; break; } // This one has already been done
                        }
                        if (!processed) { pets.Add(new ArmoryPet(fam, petname, SpecKey, spec)); }
                    }
                    if (pets.Count > 0) { character.ArmoryPets = pets; }
                }

                foreach (XElement xprofession in xchar.Element("professionInfo").Elements("profession"))
                {
                    Profession profession = (Profession)(int.Parse(xprofession.Attribute("id").Value));
                    if (character.PrimaryProfession == Profession.None)
                        character.PrimaryProfession = profession;
                    else
                        character.SecondaryProfession = profession;

                    switch (profession)
                    {
                        case Profession.Mining:
                            character.ActiveBuffs.Add(Buff.GetBuffByName("Toughness"));
                            break;
                        case Profession.Skinning:
                            character.ActiveBuffs.Add(Buff.GetBuffByName("Master of Anatomy"));
                            break;
                        case Profession.Blacksmithing:
                            character.WristBlacksmithingSocketEnabled = true;
                            character.HandsBlacksmithingSocketEnabled = true;
                            break;
                    }
                }

                var calc = character.CurrentCalculations;
                calc.UpdateProfessions(character);
                calc.SetDefaults(character);

                e.Result = new KeyValuePair<Character, Dictionary<CharacterSlot, ItemInstance>>(character, items);
            }
            catch (Exception ex)
            {
                (sender as BackgroundWorker).ReportProgress(0, ex.Message + "|" + ex.StackTrace);
            }
        }
Exemplo n.º 30
0
        public Character(string name, string realm, CharacterRegion region, CharacterRace race, BossOptions boss,
            ItemInstance[] items, List<Buff> activeBuffs, string model)
        {
            Initialize();
            IsLoading = true;
            _name = name;
            _realm = realm;
            _region = region;
            _race = race;
            Array.Copy(items, _item, items.Length);

            IsLoading = false;
            ActiveBuffs = new List<Buff>(activeBuffs);
            SetFaction();
            CurrentModel = model;
            RecalculateSetBonuses();

            BossOptions = boss.Clone();
        }
Exemplo n.º 31
0
        internal static void GenerateTalentArena()
        {
            CommunicationServiceClient.Instance.SendMessageToCharacter(new SCSCharacterMessage
            {
                DestinationCharacterId = null,
                SourceCharacterId      = 0,
                SourceWorldId          = ServerManager.Instance.WorldId,
                Message = "L'arene des talents est ouverte !",
                Type    = MessageType.Shout
            });
            long        groupid = 0;
            int         seconds = 0;
            IDisposable obs     = Observable.Interval(TimeSpan.FromSeconds(1)).Subscribe(start2 =>
            {
                ServerManager.Instance.ArenaMembers.Where(s => s.ArenaType == EventType.TALENTARENA).ToList().ForEach(s =>
                {
                    s.Time -= 1;
                    List <long> groupids = new List <long>();
                    ServerManager.Instance.ArenaMembers.Where(o => o.GroupId != null).ToList().ForEach(o =>
                    {
                        if (ServerManager.Instance.ArenaMembers.Count(g => g.GroupId == o.GroupId) != 3)
                        {
                            return;
                        }
                        if (o.GroupId != null)
                        {
                            groupids.Add(o.GroupId.Value);
                        }
                    });

                    if (s.Time > 0)
                    {
                        if (s.GroupId == null)
                        {
                            List <ArenaMember> members = ServerManager.Instance.ArenaMembers
                                                         .Where(e => e.Session != s.Session && e.ArenaType == EventType.TALENTARENA && e.Session.Character.Level <= s.Session.Character.Level + 5 &&
                                                                e.Session.Character.Level >= s.Session.Character.Level - 5).ToList();
                            members.RemoveAll(o => o.GroupId != null && groupids.Contains(o.GroupId.Value));
                            ArenaMember member = members.FirstOrDefault();
                            if (member == null)
                            {
                                return;
                            }
                            {
                                if (member.GroupId == null)
                                {
                                    groupid++;
                                    member.GroupId = groupid;
                                }
                                s.GroupId = member.GroupId;
                                ServerManager.Instance.ArenaMembers.Where(e => e.ArenaType == EventType.TALENTARENA && e.GroupId == member.GroupId).ToList().ForEach(o =>
                                {
                                    o.Session.SendPacket(o.Session.Character.GenerateBsInfo(1, 2, -1, 6));
                                    o.Session.SendPacket(o.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("ARENA_TEAM_FOUND"), 10));
                                    Observable.Timer(TimeSpan.FromSeconds(1)).Subscribe(time =>
                                    {
                                        s.Time = 300;
                                        if (ServerManager.Instance.ArenaMembers.Count(g => g.GroupId == s.GroupId) < 3)
                                        {
                                            o.Session.SendPacket(o.Session.Character.GenerateBsInfo(0, 2, s.Time, 8));
                                            o.Session.SendPacket(o.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SEARCH_ARENA_TEAM"), 10));
                                        }
                                        else
                                        {
                                            o.Session.SendPacket(o.Session.Character.GenerateBsInfo(0, 2, s.Time, 1));
                                            o.Session.SendPacket(o.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SEARCH_RIVAL_ARENA_TEAM"), 10));
                                        }
                                    });
                                });
                            }
                        }
                        else
                        {
                            if (ServerManager.Instance.ArenaMembers.Count(g => g.GroupId == s.GroupId) != 3)
                            {
                                return;
                            }
                            ArenaMember member =
                                ServerManager.Instance.ArenaMembers.FirstOrDefault(o => o.GroupId != null && o.GroupId != s.GroupId && groupids.Contains(o.GroupId.Value) &&
                                                                                   o.Session.Character.Level <= s.Session.Character.Level + 5 &&
                                                                                   o.Session.Character.Level >= s.Session.Character.Level - 5);
                            if (member == null)
                            {
                                return;
                            }

                            MapInstance map = ServerManager.Instance.GenerateMapInstance(2015, MapInstanceType.TalentArenaMapInstance, new InstanceBag());
                            ConcurrentBag <ArenaTeamMember> arenaTeam = new ConcurrentBag <ArenaTeamMember>();
                            ServerManager.Instance.ArenaTeams.Add(arenaTeam);

                            ArenaMember[] arenamembers = ServerManager.Instance.ArenaMembers.Where(o => o.GroupId == member.GroupId || o.GroupId == s.GroupId).OrderBy(o => o.GroupId)
                                                         .ToArray();
                            for (int i = 0; i < 6; i++)
                            {
                                ItemInstance item = Inventory.InstantiateItemInstance((short)(4433 + (i > 2 ? 5 - i : i)), member.Session.Character.CharacterId);
                                item.Design       = (short)(4433 + (i > 2 ? 5 - i : i));
                                map.MapDesignObjects.Add(new MapDesignObject
                                {
                                    ItemInstance   = item,
                                    ItemInstanceId = item.Id,
                                    CharacterId    = member.Session.Character.CharacterId,
                                    MapX           = (short)(i > 2 ? 120 : 19),
                                    MapY           = (short)(i > 2 ? 35 + i % 3 * 4 : 36 + i % 3 * 4)
                                });
                            }
                            map.InstanceBag.Clock.BasesSecondRemaining = 60;
                            map.InstanceBag.Clock.DeciSecondRemaining  = 600;
                            map.InstanceBag.Clock.StartClock();
                            IDisposable obs4 = null;
                            IDisposable obs2 = null;
                            IDisposable obs3 = null;
                            IDisposable obs6 = null;
                            Observable.Timer(TimeSpan.FromSeconds(5)).Subscribe(time2 =>
                            {
                                obs3 = Observable.Interval(TimeSpan.FromSeconds(5)).Subscribe(effect =>
                                {
                                    arenamembers.ToList().ForEach(o => map.Broadcast(o.Session.Character.GenerateEff(o.GroupId == s.GroupId ? 3012 : 3013)));
                                });
                            });
                            IDisposable obs5 = Observable.Interval(TimeSpan.FromMilliseconds(500)).Subscribe(start3 =>
                            {
                                map.Broadcast(arenamembers.FirstOrDefault(o => o.Session != null)?.Session.Character.GenerateTaPs());
                                List <ArenaTeamMember> erenia = arenaTeam.Replace(team => team.ArenaTeamType == ArenaTeamType.ERENIA).ToList();
                                List <ArenaTeamMember> zenas  = arenaTeam.Replace(team => team.ArenaTeamType == ArenaTeamType.ZENAS).ToList();
                                BuffTeam(erenia);
                                BuffTeam(zenas);
                            });
                            arenamembers.ToList().ForEach(o =>
                            {
                                o.Session.SendPacket(o.Session.Character.GenerateBsInfo(0, 2, s.Time, 2));
                                o.Session.SendPacket(o.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("RIVAL_ARENA_TEAM_FOUND"), 10));

                                Observable.Timer(TimeSpan.FromSeconds(1)).Subscribe(time =>
                                {
                                    o.Session.SendPacket("ta_close");
                                    Observable.Timer(TimeSpan.FromSeconds(5)).Subscribe(time2 =>
                                    {
                                        o.Session.Character.Mates.Where(m => m.IsTeamMember).ToList().ForEach(m => m.IsTeamMember = false);
                                        o.Session.Character.GeneralLogs.Add(new GeneralLogDTO
                                        {
                                            AccountId   = o.Session.Account.AccountId,
                                            CharacterId = o.Session.Character.CharacterId,
                                            IpAddress   = o.Session.IpAddress,
                                            LogData     = "Entry",
                                            LogType     = "TalentArena",
                                            Timestamp   = DateTime.Now
                                        });
                                        List <BuffType> bufftodisable = new List <BuffType> {
                                            BuffType.Bad, BuffType.Good, BuffType.Neutral
                                        };
                                        o.Session.Character.DisableBuffs(bufftodisable);
                                        int i = Array.IndexOf(arenamembers, o) + 1;
                                        o.Session.Character.Hp = (int)o.Session.Character.HpLoad();
                                        o.Session.Character.Mp = (int)o.Session.Character.MpLoad();
                                        ServerManager.Instance.ChangeMapInstance(o.Session.Character.CharacterId, map.MapInstanceId, o.GroupId == member.GroupId ? 125 : 14,
                                                                                 (o.GroupId == member.GroupId ? 37 : 38) + i % 3 * 2);
                                        o.Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("SELECT_ORDER_ARENA_TIME"), 0));
                                        o.Session.SendPacket(o.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SELECT_ORDER_ARENA_TIME"), 10));
                                        o.Session.SendPacket(o.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SELECT_ORDER_ARENA"), 10));
                                        o.Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("SELECT_ORDER_ARENA"), 0));
                                        o.Session.SendPacket(o.Session.Character.GenerateTaM(0));
                                        o.Session.SendPacket("ta_sv 0");
                                        o.Session.SendPacket(UserInterfaceHelper.Instance.GenerateTaSt(TalentArenaOptionType.Watch));
                                        o.Session.SendPacket(o.Session.Character.GenerateTaM(3));


                                        o.Session.SendPacket(o.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey(o.GroupId == s.GroupId ? "ZENAS" : "ERENIA"), 10));
                                        arenaTeam.Add(new ArenaTeamMember(o.Session, o.GroupId == s.GroupId ? ArenaTeamType.ZENAS : ArenaTeamType.ERENIA, null));
                                        o.Session.SendPacket(o.Session.Character.GenerateTaP(0, false));

                                        obs2 = Observable.Interval(TimeSpan.FromMilliseconds(100)).Subscribe(start3 =>
                                        {
                                            bool resettap = false;
                                            map.MapDesignObjects.ToList().ForEach(e =>
                                            {
                                                if (e.ItemInstance.Design >= 4433 && e.ItemInstance.Design <= 4435)
                                                {
                                                    Character chara = map.GetCharactersInRange(e.MapX, e.MapY, 0).FirstOrDefault();
                                                    if (chara != null)
                                                    {
                                                        resettap = true;
                                                        ArenaTeamMember teammember = arenaTeam.FirstOrDefault(at => at.Session == chara.Session);
                                                        if (teammember != null &&
                                                            !arenaTeam.Any(at => at.Order == (e.ItemInstance.ItemVNum - 4433) &&
                                                                           at.ArenaTeamType == (e.MapX == 120 ? ArenaTeamType.ERENIA : ArenaTeamType.ZENAS)))
                                                        {
                                                            if (teammember.Order != null)
                                                            {
                                                                MapDesignObject obj =
                                                                    map.MapDesignObjects.FirstOrDefault(mapobj => mapobj.ItemInstance.ItemVNum == e.ItemInstance.ItemVNum &&
                                                                                                        e.MapX == (teammember.ArenaTeamType == ArenaTeamType.ERENIA ? 120 : 19));
                                                                if (obj != null)
                                                                {
                                                                    obj.ItemInstance.Design = obj.ItemInstance.ItemVNum;
                                                                }
                                                            }
                                                            teammember.Order = (byte)(e.ItemInstance.ItemVNum - 4433);
                                                        }
                                                    }
                                                }
                                                else if (e.ItemInstance.Design == 4436)
                                                {
                                                    if (!map.GetCharactersInRange(e.MapX, e.MapY, 0).Any())
                                                    {
                                                        resettap = true;
                                                        ArenaTeamMember teammember = arenaTeam.FirstOrDefault(at =>
                                                                                                              at.Order == (e.ItemInstance.ItemVNum - 4433) && at.ArenaTeamType == (e.MapX == 120 ? ArenaTeamType.ERENIA : ArenaTeamType.ZENAS));
                                                        if (teammember != null)
                                                        {
                                                            teammember.Order = null;
                                                        }
                                                    }
                                                }
                                                if (!arenaTeam.Any(at => at.Order == (e.ItemInstance.ItemVNum - 4433) && at.ArenaTeamType == (e.MapX == 120 ? ArenaTeamType.ERENIA : ArenaTeamType.ZENAS)))
                                                {
                                                    if (e.ItemInstance.Design != 4436)
                                                    {
                                                        return;
                                                    }
                                                    e.ItemInstance.Design = e.ItemInstance.ItemVNum;
                                                    map.Broadcast(e.GenerateEffect(false));
                                                }
                                                else if (e.ItemInstance.Design != 4436)
                                                {
                                                    e.ItemInstance.Design = 4436;
                                                    map.Broadcast(e.GenerateEffect(false));
                                                }
                                            });

                                            if (resettap)
                                            {
                                                arenaTeam.ToList().ForEach(arenauser => { arenauser.Session.SendPacket(arenauser.Session.Character.GenerateTaP(2, false)); });
                                            }
                                        });

                                        Observable.Timer(TimeSpan.FromSeconds(map.InstanceBag.Clock.BasesSecondRemaining)).Subscribe(start =>
                                        {
                                            obs2.Dispose();
                                            arenaTeam.ToList().ForEach(arenauser =>
                                            {
                                                if (arenauser.Order == null)
                                                {
                                                    for (byte x = 0; x < 3; x++)
                                                    {
                                                        if (!arenaTeam.Any(at => at.ArenaTeamType == arenauser.ArenaTeamType && at.Order == x))
                                                        {
                                                            arenauser.Order = x;
                                                        }
                                                    }
                                                }
                                                arenauser.Session.SendPacket($"ta_pn {arenauser.Order + 1}");
                                                arenauser.Session.SendPacket(arenauser.Session.Character.GenerateTaP(2, true));
                                            });
                                            map.MapDesignObjects.ToList().ForEach(md => map.Broadcast(md.GenerateEffect(true)));
                                            map.MapDesignObjects.Clear();
                                        });
                                    });
                                });
                            });
                            Observable.Timer(TimeSpan.FromSeconds(map.InstanceBag.Clock.BasesSecondRemaining)).Subscribe(start =>
                            {
                                bool newround1   = true;
                                bool newround2   = true;
                                int count1       = 0;
                                int count2       = 0;
                                IDisposable obs7 = obs4;
                                obs4             = Observable.Interval(TimeSpan.FromMilliseconds(500)).Subscribe(start3 =>
                                {
                                    int ereniacount = arenaTeam.Count(at => at.Dead && at.ArenaTeamType == ArenaTeamType.ERENIA);
                                    int zenascount  = arenaTeam.Count(at => at.Dead && at.ArenaTeamType == ArenaTeamType.ZENAS);
                                    if (count1 != ereniacount || count2 != zenascount)
                                    {
                                        if (count1 != ereniacount)
                                        {
                                            newround1 = true;
                                        }
                                        if (count2 != zenascount)
                                        {
                                            newround2 = true;
                                        }
                                        count1 = ereniacount;
                                        count2 = zenascount;
                                    }

                                    ArenaTeamMember tm  = arenaTeam.OrderBy(tm3 => tm3.Order).FirstOrDefault(tm3 => tm3.ArenaTeamType == ArenaTeamType.ERENIA && !tm3.Dead);
                                    ArenaTeamMember tm2 = arenaTeam.OrderBy(tm3 => tm3.Order).FirstOrDefault(tm3 => tm3.ArenaTeamType == ArenaTeamType.ZENAS && !tm3.Dead);

                                    if (!newround1 && !newround2)
                                    {
                                        return;
                                    }
                                    map.InstanceBag.Clock.BasesSecondRemaining = 300;
                                    map.InstanceBag.Clock.DeciSecondRemaining  = 3000;
                                    arenaTeam.ToList().ForEach(friends =>
                                    {
                                        friends.Session.SendPacket(friends.Session.Character.GenerateTaM(2));
                                        friends.Session.SendPacket(friends.Session.Character.GenerateTaM(3));
                                    });
                                    map.Sessions.Except(arenaTeam.Select(ss => ss.Session)).ToList().ForEach(o =>
                                    {
                                        o.SendPacket(tm2?.Session.Character.GenerateTaM(2));
                                        o.SendPacket(tm2?.Session.Character.GenerateTaM(3));
                                    });

                                    obs6?.Dispose();
                                    obs6 = Observable.Timer(TimeSpan.FromSeconds(map.InstanceBag.Clock.BasesSecondRemaining)).Subscribe(start4 =>
                                    {
                                        if (tm2 != null && tm != null)
                                        {
                                            tm.Dead  = true;
                                            tm2.Dead = true;
                                            tm.Session.Character.PositionX  = 120;
                                            tm.Session.Character.PositionY  = 39;
                                            tm2.Session.Character.PositionX = 19;
                                            tm2.Session.Character.PositionY = 40;
                                            map.Broadcast(tm2.Session, tm.Session.Character.GenerateTp());
                                            map.Broadcast(tm2.Session, tm2.Session.Character.GenerateTp());
                                            tm.Session.SendPacket(UserInterfaceHelper.Instance.GenerateTaSt(TalentArenaOptionType.Watch));
                                            tm2.Session.SendPacket(UserInterfaceHelper.Instance.GenerateTaSt(TalentArenaOptionType.Watch));
                                            arenaTeam.Replace(friends => friends.ArenaTeamType == tm.ArenaTeamType).ToList().ForEach(friends =>
                                            {
                                                friends.Session.SendPacket(friends.Session.Character.GenerateTaFc(0));
                                            });
                                        }
                                        newround1 = true;
                                        newround2 = true;
                                        arenaTeam.ToList().ForEach(arenauser => { arenauser.Session.SendPacket(arenauser.Session.Character.GenerateTaP(2, true)); });
                                    });

                                    if (tm != null && tm2 != null)
                                    {
                                        map.IsPvp = false;
                                        arenaTeam.Replace(at => at.LastSummoned != null).ToList().ForEach(at =>
                                        {
                                            at.LastSummoned = null;
                                            at.Session.Character.PositionX = at.ArenaTeamType == ArenaTeamType.ERENIA ? (short)120 : (short)19;
                                            at.Session.Character.PositionY = at.ArenaTeamType == ArenaTeamType.ERENIA ? (short)39 : (short)40;
                                            at.Session.CurrentMapInstance.Broadcast(at.Session.Character.GenerateTp());
                                            at.Session.SendPacket(UserInterfaceHelper.Instance.GenerateTaSt(TalentArenaOptionType.Watch));
                                        });
                                        if (newround1)
                                        {
                                            map.Broadcast(tm.Session.Character.GenerateTaFc(1));
                                            tm.Session.Character.PositionX = 87;
                                            tm.Session.Character.PositionY = 39;
                                            map.Broadcast(tm.Session, tm.Session.Character.GenerateTp());
                                        }

                                        if (newround2)
                                        {
                                            tm2.Session.Character.PositionX = 56;
                                            tm2.Session.Character.PositionY = 40;
                                            map.Broadcast(tm2.Session, tm2.Session.Character.GenerateTp());
                                        }

                                        arenaTeam.ToList().ForEach(friends =>
                                        {
                                            friends.Session.SendPacket(friends.ArenaTeamType == ArenaTeamType.ERENIA
                                                ? tm.Session.Character.GenerateTaFc(0)
                                                : tm2.Session.Character.GenerateTaFc(0));
                                        });

                                        map.Sessions.Except(arenaTeam.Select(ss => ss.Session)).ToList().ForEach(ss =>
                                        {
                                            ss.SendPacket(tm.Session.Character.GenerateTaFc(0));
                                            ss.SendPacket(tm2.Session.Character.GenerateTaFc(1));
                                        });

                                        tm.Session.SendPacket(UserInterfaceHelper.Instance.GenerateTaSt(TalentArenaOptionType.Call));
                                        tm2.Session.SendPacket(UserInterfaceHelper.Instance.GenerateTaSt(TalentArenaOptionType.Call));

                                        map.Broadcast("ta_s");
                                        Observable.Timer(TimeSpan.FromSeconds(5)).Subscribe(start4 => { map.IsPvp = true; });
                                    }
                                    else
                                    {
                                        switch (tm)
                                        {
                                        case null when tm2 == null:
                                            map.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("EQUALITY"), 0));
                                            arenaTeam.ToList().ForEach(arenauser =>
                                            {
                                                arenauser.Session.SendPacket(arenauser.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("EQUALITY"), 10));
                                                arenauser.Session.SendPacket(arenauser.Session.Character.GenerateTaF(3));
                                            });
                                            map.Sessions.Except(arenamembers.Select(x => x.Session)).ToList().ForEach(
                                                x =>
                                            {
                                                ArenaTeamMember arenauser = arenaTeam.FirstOrDefault(se => se.Session != null);
                                                if (arenauser == null)
                                                {
                                                    return;
                                                }
                                                x.SendPacket(arenauser.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("EQUALITY"), 10));
                                                x.SendPacket(arenauser.Session.Character.GenerateTaF(0));
                                            }
                                                );
                                            arenaTeam.Clear();
                                            ServerManager.Instance.ArenaTeams.Remove(arenaTeam);
                                            break;

                                        case null:
                                            map.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("VICTORIOUS_ZENAS"), 0));

                                            arenaTeam.ToList().ForEach(arenauser =>
                                            {
                                                SendRewards(arenauser, arenauser.ArenaTeamType == ArenaTeamType.ZENAS);
                                            });
                                            map.Sessions.Except(arenamembers.Select(x => x.Session)).ToList().ForEach(x =>
                                            {
                                                ArenaTeamMember arenauser = arenaTeam.FirstOrDefault(se => se.Session != null);
                                                if (arenauser == null)
                                                {
                                                    return;
                                                }
                                                x.SendPacket(arenauser.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("VICTORIOUS_ZENAS"), 10));
                                                x.SendPacket(arenauser.Session.Character.GenerateTaF(1));
                                            });
                                            arenaTeam.Clear();
                                            ServerManager.Instance.ArenaTeams.Remove(arenaTeam);
                                            break;

                                        default:
                                            map.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("VICTORIOUS_ERENIA"), 0));
                                            arenaTeam.ToList().ForEach(arenauser =>
                                            {
                                                SendRewards(arenauser, arenauser.ArenaTeamType == ArenaTeamType.ERENIA);
                                            });
                                            map.Sessions.Except(arenamembers.Select(x => x.Session)).ToList().ForEach(
                                                x =>
                                            {
                                                ArenaTeamMember arenauser = arenaTeam.FirstOrDefault(se => se.Session != null);
                                                if (arenauser == null)
                                                {
                                                    return;
                                                }
                                                x.SendPacket(arenauser.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("VICTORIOUS_ERENIA"), 10));
                                                x.SendPacket(arenauser.Session.Character.GenerateTaF(2));
                                            }
                                                );
                                            arenaTeam.Clear();
                                            ServerManager.Instance.ArenaTeams.Remove(arenaTeam);
                                            break;
                                        }
                                        obs3.Dispose();
                                        obs2.Dispose();
                                        obs7?.Dispose();
                                        obs5.Dispose();
                                        Observable.Timer(TimeSpan.FromSeconds(30)).Subscribe(start4 =>
                                        {
                                            map.Dispose();
                                            arenaTeam.ToList().ForEach(o =>
                                            {
                                                if (o.Session?.CurrentMapInstance?.MapInstanceType == MapInstanceType.TalentArenaMapInstance)
                                                {
                                                    ServerManager.Instance.TeleportOnRandomPlaceInMap(o.Session, ServerManager.Instance.ArenaInstance.MapInstanceId);
                                                }
                                            });
                                        });
                                    }
                                    newround1 = false;
                                    newround2 = false;
                                });
                            });
                            ServerManager.Instance.ArenaMembers.Where(o => o.GroupId == member.GroupId || o.GroupId == s.GroupId).ToList()
                            .ForEach(se => { se.Session.SendPacket(se.Session.Character.GenerateBsInfo(2, 2, 0, 0)); });

                            ServerManager.Instance.ArenaMembers.RemoveAll(o => o.GroupId == member.GroupId || o.GroupId == s.GroupId);
                        }
                    }
                    else
                    {
                        if (s.GroupId == null)
                        {
                            if (s.Time != -1)
                            {
                                s.Session.SendPacket(s.Session.Character.GenerateBsInfo(1, 2, s.Time, 7));
                                s.Session.SendPacket(s.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NO_TEAM_ARENA"), 10));
                            }
                            s.Time = 300;
                            s.Session.SendPacket(s.Session.Character.GenerateBsInfo(1, 2, s.Time, 5));
                            s.Session.SendPacket(s.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SEARCH_ARENA_TEAM"), 10));
                        }
                        else if (ServerManager.Instance.ArenaMembers.Count(g => g.GroupId == s.GroupId) < 3)
                        {
                            s.Session.SendPacket(s.Session.Character.GenerateBsInfo(1, 2, -1, 4));
                            Observable.Timer(TimeSpan.FromSeconds(1)).Subscribe(time =>
                            {
                                s.Time = 300;
                                s.Session.SendPacket(s.Session.Character.GenerateBsInfo(1, 2, s.Time, 8));
                                s.Session.SendPacket(s.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("RETRY_SEARCH_ARENA_TEAM"), 10));
                            });
                        }
                        else
                        {
                            s.Session.SendPacket(s.Session.Character.GenerateBsInfo(0, 2, -1, 3));
                            Observable.Timer(TimeSpan.FromSeconds(1)).Subscribe(time =>
                            {
                                s.Time = 300;
                                s.Session.SendPacket(s.Session.Character.GenerateBsInfo(0, 2, s.Time, 1));
                                s.Session.SendPacket(s.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SEARCH_RIVAL_ARENA_TEAM"), 10));
                            });
                        }
                    }
                });
                seconds++;
            });

            Observable.Timer(TimeSpan.FromHours(7)).Subscribe(start2 =>
            {
                ServerManager.Instance.StartedEvents.Remove(EventType.TALENTARENA);
                obs.Dispose();
            });
        }
Exemplo n.º 32
0
 public Character Clone()
 {
     ItemInstance[] clonedItemInstances = new ItemInstance[SlotCount];
     for (int i = 0; i < clonedItemInstances.Length; i++)
     {
         ItemInstance itemInstance = _item[i];
         if (itemInstance != null) clonedItemInstances[i] = itemInstance.Clone();
     }
     Character clone = new Character(this.Name, this.Realm, this.Region, this.Race, this.BossOptions.Clone(),
         clonedItemInstances, ActiveBuffs, CurrentModel);
     clone.CalculationOptions = this.CalculationOptions;
     clone.itemSetList = this.itemSetList;
     clone.Class = this.Class;
     clone.AssignAllTalentsFromCharacter(this, true);
     clone.PrimaryProfession = this.PrimaryProfession;
     clone.SecondaryProfession = this.SecondaryProfession;
     clone.WaistBlacksmithingSocketEnabled = this.WaistBlacksmithingSocketEnabled;
     clone.WristBlacksmithingSocketEnabled = this.WristBlacksmithingSocketEnabled;
     clone.HandsBlacksmithingSocketEnabled = this.HandsBlacksmithingSocketEnabled;
     clone.OptimizationRequirements = this.OptimizationRequirements;
     clone.CalculationToOptimize = this.CalculationToOptimize;
     clone.BossOptions = this.BossOptions.Clone();
     return clone;
 }
Exemplo n.º 33
0
    ItemParent AddItem(ItemInstance instance)
    {
        ItemParent item = null;
        LoggerHelper.Debug("AddItem:" + instance.bagType + ",index:" + instance.gridIndex);
        switch (instance.bagType)
        {
            case ITEM_TYPE_EQUIPMENT:
                if (ItemEquipmentData.dataMap.ContainsKey(instance.templeId))
                {
                    item = GetItemEquipmentByInstance(instance);
                }
                else
                {
                    ItemParentInstance toolInstance = new ItemParentInstance()
                    {
                        id = instance.id,
                        bagType = instance.bagType,
                        stack = instance.stack,
                        templeId = instance.templeId,
                        gridIndex = instance.gridIndex,
                    };
                    item = new ItemMaterial(toolInstance);
                }

                m_itemsInBag[ITEM_TYPE_EQUIPMENT][item.gridIndex] = item;
                break;

            case ITEM_TYPE_JEWEL:
                ItemJewelInstance jewelInstance = new ItemJewelInstance()
                {
                    id = instance.id,
                    bagType = instance.bagType,
                    bindingType = instance.bindingType,
                    stack = instance.stack,
                    templeId = instance.templeId,
                    gridIndex = instance.gridIndex,
                };
                item = new ItemJewel(jewelInstance);
                m_itemsInBag[ITEM_TYPE_JEWEL][item.gridIndex] = item;
                break;
            case ITEM_TYPE_ONEQUIP:
                item = GetItemEquipmentByInstance(instance);
                //Mogo.Util.LoggerHelper.Debug("item.gridIndex:" + item.gridIndex + "!!!!!!!!!!!");
                m_itemsOnEquip[item.gridIndex + 1] = (ItemEquipment)item;
                //Mogo.Util.LoggerHelper.Debug("inventroy equip:" + item.templateId);
                myself.Equip(item.templateId);
                break;
            case ITEM_TYPE_MATERIAL:
                ItemParentInstance materialInstance = new ItemParentInstance()
                {
                    id = instance.id,
                    bagType = instance.bagType,
                    stack = instance.stack,
                    templeId = instance.templeId,
                    gridIndex = instance.gridIndex,
                };
                item = new ItemMaterial(materialInstance);
                m_itemsInBag[ITEM_TYPE_MATERIAL][item.gridIndex] = item;
                break;

        }
        return item;
    }
Exemplo n.º 34
0
 /// <summary>
 /// A Function to take an item in it's Gemmed string form and set character's slot to that.
 /// </summary>
 /// <param name="slot">The Slot to set</param>
 /// <param name="gemmedId">The string gemmed id to put into the slot</param>
 private void SetGemmedId(CharacterSlot slot, string gemmedId)
 {
     if (string.IsNullOrEmpty(gemmedId)) _item[(int)slot] = null;
     else _item[(int)slot] = new ItemInstance(gemmedId); // don't call invalidations all the time while loading character
 }
Exemplo n.º 35
0
 public MobContainer(String visual, String focusName, ItemInstance[] items, int[] amounts, bool isLocked, ItemInstance keyInstance, String pickLockString, ItemInstance useWithItem, String triggerTarget)
     : this(visual, focusName, items, amounts, isLocked, keyInstance, pickLockString, useWithItem, triggerTarget, true, true)
 {
 }
Exemplo n.º 36
0
        public void character_CalculationsInvalidated(object sender, EventArgs e)
        {
            if (character != null)
            {
                TheItem = character[Slot];
                if (TheItem == null || TheItem.Item == null)
                {
                    IconImage.Source      = null;
                    EnchantButton.Content = "";
                    TinkerButton.Content  = "";
                    gear = null;
                    IconImageGem1.Source = null; GemButton1.IsEnabled = false; SetSocketColor(GemButton1, ItemSlot.None);
                    IconImageGem2.Source = null; GemButton2.IsEnabled = false; SetSocketColor(GemButton2, ItemSlot.None);
                    IconImageGem3.Source = null; GemButton3.IsEnabled = false; SetSocketColor(GemButton3, ItemSlot.None);
                }
                else
                {
                    IconImage.Source      = Icons.AnIcon(TheItem.Item.IconPath);
                    EnchantButton.Content = TheItem.Enchant.ShortName;
                    ReforgeButton.Content = TheItem.Reforging != null ? TheItem.Reforging.VeryShortName : "NR";
                    TinkerButton.Content  = TheItem.Tinkering.ShortName;
                    gear = TheItem;

                    Item eItem = new Item();
                    if (TheItem.Enchant != null)
                    {
                        eItem.Name    = TheItem.Enchant.Name;
                        eItem.Quality = ItemQuality.Temp;
                        eItem.Stats   = TheItem.Enchant.Stats;
                    }
                    enchant = eItem;

                    Item tItem = new Item();
                    if (TheItem.Tinkering != null)
                    {
                        tItem.Name    = TheItem.Tinkering.Name;
                        tItem.Quality = ItemQuality.Temp;
                        tItem.Stats   = TheItem.Tinkering.Stats;
                    }
                    tinkering = tItem;

                    Item rItem = new Item();
                    if (TheItem.Reforging != null)
                    {
                        rItem.Name    = TheItem.Reforging.ToString();
                        rItem.Quality = ItemQuality.Temp;
                    }
                    reforge = rItem;

                    // There are several special sockets, we need to account for them
                    int nonBSSocketCount = (TheItem.Item.SocketColor1 != ItemSlot.None ? 1 : 0)
                                           + (TheItem.Item.SocketColor2 != ItemSlot.None ? 1 : 0)
                                           + (TheItem.Item.SocketColor3 != ItemSlot.None ? 1 : 0);
                    bool BSSlot_Wrist = Slot == CharacterSlot.Wrist && Character.WristBlacksmithingSocketEnabled && (Character.PrimaryProfession == Profession.Blacksmithing || Character.SecondaryProfession == Profession.Blacksmithing);
                    bool BSSlot_Glove = Slot == CharacterSlot.Hands && Character.HandsBlacksmithingSocketEnabled && (Character.PrimaryProfession == Profession.Blacksmithing || Character.SecondaryProfession == Profession.Blacksmithing);
                    bool BSSlot_Waist = Slot == CharacterSlot.Waist && Character.WaistBlacksmithingSocketEnabled;
                    // If there is no gem socket there, hide the selector
                    GemButton1.IsEnabled = TheItem.Item.SocketColor1 != ItemSlot.None || (nonBSSocketCount == 0 && (BSSlot_Wrist || BSSlot_Glove || BSSlot_Waist));
                    GemButton2.IsEnabled = TheItem.Item.SocketColor2 != ItemSlot.None || (nonBSSocketCount == 1 && (BSSlot_Wrist || BSSlot_Glove || BSSlot_Waist));
                    GemButton3.IsEnabled = TheItem.Item.SocketColor3 != ItemSlot.None || (nonBSSocketCount == 2 && (BSSlot_Wrist || BSSlot_Glove || BSSlot_Waist));
                    // Use the Gem's image if it exists
                    IconImageGem1.Source = TheItem.Gem1 != null?Icons.AnIcon(TheItem.Gem1.IconPath) : null;

                    IconImageGem2.Source = TheItem.Gem2 != null?Icons.AnIcon(TheItem.Gem2.IconPath) : null;

                    IconImageGem3.Source = TheItem.Gem3 != null?Icons.AnIcon(TheItem.Gem3.IconPath) : null;

                    // Remove any previously registered Events that can be fired
                    ComparisonItemListGem1.SelectedItemsGemChanged -= new EventHandler(ComparisonItemListGem1_SelectedItemsGemChanged);
                    ComparisonItemListGem2.SelectedItemsGemChanged -= new EventHandler(ComparisonItemListGem2_SelectedItemsGemChanged);
                    ComparisonItemListGem3.SelectedItemsGemChanged -= new EventHandler(ComparisonItemListGem3_SelectedItemsGemChanged);
                    // Set up the selector so that it uses the right slot type
                    ComparisonItemListGem1.GemIndex = 1;
                    ComparisonItemListGem2.GemIndex = 2;
                    ComparisonItemListGem3.GemIndex = 3;
                    ComparisonItemListGem1.GemSlot  = GetProperGemSlot(TheItem.Item.SocketColor1);
                    ComparisonItemListGem2.GemSlot  = GetProperGemSlot(TheItem.Item.SocketColor2);
                    ComparisonItemListGem3.GemSlot  = GetProperGemSlot(TheItem.Item.SocketColor3);
                    // Update the socket colors
                    SetSocketColors();
                    // Set the Gem lists' selected items to the core item's gems
                    ComparisonItemListGem1.SelectedItem = TheItem.Gem1;
                    ComparisonItemListGem2.SelectedItem = TheItem.Gem2;
                    ComparisonItemListGem3.SelectedItem = TheItem.Gem3;
                    // Let the comp lists know they need to behave differently from a normal list
                    ComparisonItemListGem1.IsAnItemsGem = true;
                    ComparisonItemListGem2.IsAnItemsGem = true;
                    ComparisonItemListGem3.IsAnItemsGem = true;
                    // Register the Events that can be fired
                    ComparisonItemListGem1.SelectedItemsGemChanged += new EventHandler(ComparisonItemListGem1_SelectedItemsGemChanged);
                    ComparisonItemListGem2.SelectedItemsGemChanged += new EventHandler(ComparisonItemListGem2_SelectedItemsGemChanged);
                    ComparisonItemListGem3.SelectedItemsGemChanged += new EventHandler(ComparisonItemListGem3_SelectedItemsGemChanged);
                }
            }
        }
Exemplo n.º 37
0
        internal MobContainer(GUC.WorldObjects.Mobs.MobContainer mobInter, String visual, String focusName, ItemInstance[] items, int[] amounts, bool isLocked, ItemInstance keyInstance, String pickLockString, ItemInstance useWithItem, String triggerTarget, bool cdDyn, bool cdStatic, bool useCreate)
            : base(mobInter, visual, focusName, isLocked, keyInstance, pickLockString, useWithItem, triggerTarget, cdDyn, cdStatic)
        {
            if (items != null && amounts != null)
            {
                for (int i = 0; i < items.Length; i++)
                {
                    addItem(items[i], amounts[i]);
                }
            }

            if (useCreate)
            {
                CreateVob();
            }
        }
Exemplo n.º 38
0
 public void SetupItem(string itemName, Sprite icon, int itemAmt, float weight, float value, InventoryUI inventoryUIRef, ItemInstance itemInstance)
 {
     nameText.SetText(itemName);
     itemIcon.sprite = icon;
     amountText.SetText(itemAmt.ToString());
     weightText.SetText(weight.ToString());
     valueText.SetText(value.ToString());
     this.inventoryUIRef = inventoryUIRef;
     itemInstanceRef     = itemInstance;
 }
Exemplo n.º 39
0
        private void ExecuteHandler(ClientSession session)
        {
            if (session.Character.LastSkillUse.AddSeconds(1) > DateTime.UtcNow ||
                (session.Character.IsVehicled &&
                 session.CurrentMapInstance?.MapInstanceType != MapInstanceType.EventGameInstance) ||
                !session.HasCurrentMapInstance)
            {
                return;
            }

            if (TransportId < 100000)
            {
                MapButton button = session.CurrentMapInstance.Buttons.Find(s => s.MapButtonId == TransportId);
                if (button != null)
                {
                    session.SendPacket(UserInterfaceHelper.GenerateDelay(2000, 1, $"#git^{button.MapButtonId}"));
                }
            }
            else
            {
                if (!session.CurrentMapInstance.DroppedList.ContainsKey(TransportId))
                {
                    return;
                }

                MapItem mapItem = session.CurrentMapInstance.DroppedList[TransportId];

                if (mapItem != null)
                {
                    bool canpick = false;
                    switch (PickerType)
                    {
                    case 1:
                        canpick = session.Character.IsInRange(mapItem.PositionX, mapItem.PositionY, 8);
                        break;

                    case 2:
                        Mate mate = session.Character.Mates.Find(s =>
                                                                 s.MateTransportId == PickerId && s.CanPickUp);
                        if (mate != null)
                        {
                            canpick = mate.IsInRange(mapItem.PositionX, mapItem.PositionY, 8);
                        }

                        break;
                    }

                    if (canpick && session.HasCurrentMapInstance)
                    {
                        if (mapItem is MonsterMapItem item)
                        {
                            MonsterMapItem monsterMapItem = item;
                            if (session.CurrentMapInstance.MapInstanceType != MapInstanceType.LodInstance &&
                                monsterMapItem.OwnerId.HasValue && monsterMapItem.OwnerId.Value != -1)
                            {
                                Group group = ServerManager.Instance.Groups.Find(g =>
                                                                                 g.IsMemberOfGroup(monsterMapItem.OwnerId.Value) &&
                                                                                 g.IsMemberOfGroup(session.Character.CharacterId));
                                if (item.CreatedDate.AddSeconds(30) > DateTime.UtcNow &&
                                    !(monsterMapItem.OwnerId == session.Character.CharacterId ||
                                      (group?.SharingMode == (byte)GroupSharingType.Everyone)))
                                {
                                    session.SendPacket(
                                        session.Character.GenerateSay(
                                            Language.Instance.GetMessageFromKey("NOT_YOUR_ITEM"), 10));
                                    return;
                                }
                            }

                            // initialize and rarify
                            item.Rarify(null);
                        }

                        if (mapItem.ItemVNum != 1046)
                        {
                            ItemInstance mapItemInstance = mapItem.GetItemInstance();
                            if (mapItemInstance.Item.ItemType == ItemType.Map)
                            {
                                if (mapItemInstance.Item.Effect == 71)
                                {
                                    session.Character.SpPoint += mapItem.GetItemInstance().Item.EffectValue;
                                    if (session.Character.SpPoint > 10000)
                                    {
                                        session.Character.SpPoint = 10000;
                                    }

                                    session.SendPacket(UserInterfaceHelper.GenerateMsg(
                                                           string.Format(Language.Instance.GetMessageFromKey("SP_POINTSADDED"),
                                                                         mapItem.GetItemInstance().Item.EffectValue), 0));
                                    session.SendPacket(session.Character.GenerateSpPoint());
                                }

                                if (ServerManager.Instance.QuestModelList.FirstOrDefault(s =>
                                                                                         s.QuestGiver.QuestGiverId == mapItemInstance.Item.VNum &&
                                                                                         s.QuestGiver.Type == QuestGiverType.ItemLoot) is QuestModel model)
                                {
                                    session.Character.QuestManager.AddQuest(model.QuestId);
                                }

                                session.CurrentMapInstance.DroppedList.Remove(TransportId);
                                session.CurrentMapInstance?.Broadcast(
                                    session.Character.GenerateGet(PickerId, TransportId));
                            }
                            else
                            {
                                lock (session.Character.Inventory)
                                {
                                    short        amount = mapItem.Amount;
                                    ItemInstance inv    = session.Character.Inventory.AddToInventory(mapItemInstance)
                                                          .FirstOrDefault();
                                    if (inv != null)
                                    {
                                        session.CurrentMapInstance.DroppedList.Remove(TransportId);
                                        session.CurrentMapInstance?.Broadcast(
                                            session.Character.GenerateGet(PickerId, TransportId));
                                        if (PickerType == 2)
                                        {
                                            Mate mate = session.Character.Mates.FirstOrDefault(s => s.MateTransportId == PickerId && s.CanPickUp);
                                            if (mate != null)
                                            {
                                                session.SendPacket(session.Character.GenerateIcon(1, 1, inv.ItemVNum));
                                                mate.Owner?.Session.CurrentMapInstance?.Broadcast(StaticPacketHelper.GenerateEff(UserType.Npc, mate.MateTransportId, 5004), mate.PositionX, mate.PositionY);
                                            }
                                            else
                                            {
                                                return;
                                            }
                                        }

                                        session.SendPacket(session.Character.GenerateSay(
                                                               $"{Language.Instance.GetMessageFromKey("ITEM_ACQUIRED")}: {inv.Item.Name} x {amount}",
                                                               12));
                                        if (session.CurrentMapInstance.MapInstanceType == MapInstanceType.LodInstance)
                                        {
                                            session.CurrentMapInstance?.Broadcast(
                                                session.Character.GenerateSay(
                                                    $"{string.Format(Language.Instance.GetMessageFromKey("ITEM_ACQUIRED_LOD"), session.Character.Name)}: {inv.Item.Name} x {mapItem.Amount}",
                                                    10));
                                        }

                                        session.Character.OnPickupItem(new PickupItemEventArgs(inv.Item));
                                    }
                                    else
                                    {
                                        session.SendPacket(UserInterfaceHelper.GenerateMsg(
                                                               Language.Instance.GetMessageFromKey("NOT_ENOUGH_PLACE"), 0));
                                    }
                                }
                            }
                        }
                        else
                        {
                            // handle gold drop
                            long   maxGold    = ServerManager.Instance.Configuration.MaxGold;
                            double multiplier =
                                1 + (session.Character.GetBuff(BCardType.CardType.Item,
                                                               (byte)AdditionalTypes.Item.IncreaseEarnedGold)[0] / 100D);
                            multiplier +=
                                (session.Character.ShellEffectMain.FirstOrDefault(s =>
                                                                                  s.Effect == (byte)ShellWeaponEffectType.GainMoreGold)?.Value ?? 0) / 100D;
                            if (mapItem is MonsterMapItem droppedGold)
                            {
                                if (session.Character.Gold + (droppedGold.GoldAmount * multiplier) <= maxGold)
                                {
                                    if (PickerType == 2)
                                    {
                                        session.SendPacket(session.Character.GenerateIcon(1, 1, 1046));
                                    }

                                    session.Character.Gold += (int)(droppedGold.GoldAmount * multiplier);
                                    GameLogger.Instance.LogPickupGold(ServerManager.Instance.ChannelId,
                                                                      session.Character.Name, session.Character.CharacterId,
                                                                      (int)(droppedGold.GoldAmount * multiplier), false);
                                    session.SendPacket(session.Character.GenerateSay(
                                                           $"{Language.Instance.GetMessageFromKey("ITEM_ACQUIRED")}: {mapItem.GetItemInstance().Item.Name} x {droppedGold.GoldAmount}{(multiplier > 1 ? $" + {(int) (droppedGold.GoldAmount * multiplier) - droppedGold.GoldAmount}" : string.Empty)}",
                                                           12));
                                }
                                else
                                {
                                    session.Character.Gold = maxGold;
                                    GameLogger.Instance.LogPickupGold(ServerManager.Instance.ChannelId,
                                                                      session.Character.Name, session.Character.CharacterId,
                                                                      (int)(droppedGold.GoldAmount * multiplier), true);
                                    session.SendPacket(
                                        UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("MAX_GOLD"),
                                                                        0));
                                }
                            }

                            session.SendPacket(session.Character.GenerateGold());
                            session.CurrentMapInstance.DroppedList.Remove(TransportId);
                            session.CurrentMapInstance?.Broadcast(session.Character.GenerateGet(PickerId, TransportId));
                        }
                    }
                }
            }
        }
Exemplo n.º 40
0
        public void CreateItem(CreateItemPacket createItemPacket)
        {
            if (createItemPacket != null)
            {
                var   vnum = createItemPacket.VNum;
                sbyte rare = 0;
                short boxEffect = 999;
                byte  upgrade = 0, design = 0;
                short amount = 1;
                if (vnum == 1046)
                {
                    return; // cannot create gold as item, use $Gold instead
                }
                var iteminfo = ServerManager.Instance.Items.Find(item => item.VNum == vnum);
                if (iteminfo != null)
                {
                    if (iteminfo.IsColored || iteminfo.Effect == boxEffect)
                    {
                        if (createItemPacket.DesignOrAmount.HasValue)
                        {
                            design = (byte)createItemPacket.DesignOrAmount.Value;
                        }
                        rare = createItemPacket.Upgrade.HasValue && iteminfo.Effect == boxEffect ? (sbyte)createItemPacket.Upgrade.Value : rare;
                    }
                    else if (iteminfo.Type == PocketType.Equipment)
                    {
                        if (createItemPacket.Upgrade.HasValue)
                        {
                            if (iteminfo.EquipmentSlot != EquipmentType.Sp)
                            {
                                upgrade = createItemPacket.Upgrade.Value;
                            }
                            else
                            {
                                design = createItemPacket.Upgrade.Value;
                            }
                            if (iteminfo.EquipmentSlot != EquipmentType.Sp && upgrade == 0 && iteminfo.BasicUpgrade != 0)
                            {
                                upgrade = iteminfo.BasicUpgrade;
                            }
                        }
                        if (createItemPacket.DesignOrAmount.HasValue)
                        {
                            if (iteminfo.EquipmentSlot == EquipmentType.Sp)
                            {
                                upgrade = (byte)createItemPacket.DesignOrAmount.Value;
                            }
                            else
                            {
                                rare = (sbyte)createItemPacket.DesignOrAmount.Value;
                            }
                        }
                    }
                    if (createItemPacket.DesignOrAmount.HasValue && !createItemPacket.Upgrade.HasValue)
                    {
                        amount = createItemPacket.DesignOrAmount.Value > _worldConfiguration.MaxItemAmount ? _worldConfiguration.MaxItemAmount : createItemPacket.DesignOrAmount.Value;
                    }

                    var inv = Session.Character.Inventory.AddItemToPocket(ItemInstance.Create(vnum, Session.Character.CharacterId, amount: amount, rare: rare, upgrade: upgrade, design: design));

                    if (inv.Count > 0)
                    {
                        Session.SendPacket(inv.GeneratePocketChange());
                        var firstItem = inv.First();
                        var wearable  = Session.Character.Inventory.LoadBySlotAndType <WearableInstance>(firstItem.Slot, firstItem.Type);
                        if (wearable != null)
                        {
                            switch (wearable.Item.EquipmentSlot)
                            {
                            case EquipmentType.Armor:
                            case EquipmentType.MainWeapon:
                            case EquipmentType.SecondaryWeapon:
                                wearable.SetRarityPoint();
                                break;

                            case EquipmentType.Boots:
                            case EquipmentType.Gloves:
                                wearable.FireResistance  = (short)(wearable.Item.FireResistance * upgrade);
                                wearable.DarkResistance  = (short)(wearable.Item.DarkResistance * upgrade);
                                wearable.LightResistance = (short)(wearable.Item.LightResistance * upgrade);
                                wearable.WaterResistance = (short)(wearable.Item.WaterResistance * upgrade);
                                break;
                            }
                        }

                        Session.SendPacket(Session.Character.GenerateSay($"{Language.Instance.GetMessageFromKey(LanguageKey.ITEM_ACQUIRED, Session.Account.Language)}: {iteminfo.Name} x {amount}", SayColorType.Green));
                    }
                    else
                    {
                        Session.SendPacket(new MsgPacket()
                        {
                            Message = Language.Instance.GetMessageFromKey(LanguageKey.NOT_ENOUGH_PLACE, Session.Account.Language), Type = 0
                        });
                    }
                }
                else
                {
                    Session.SendPacket(new MsgPacket()
                    {
                        Message = Language.Instance.GetMessageFromKey(LanguageKey.NO_ITEM, Session.Account.Language), Type = 0
                    });
                }
            }
            else
            {
                Session.SendPacket(Session.Character.GenerateSay(CreateItemPacket.ReturnHelp(), SayColorType.Yellow));
            }
        }
Exemplo n.º 41
0
 public MFUpdateEquipment(string slot, ItemInstance itemInstance)
 {
     Slot         = slot;
     ItemInstance = itemInstance;
 }
Exemplo n.º 42
0
        public override void Use(ClientSession session, ref ItemInstance inv, byte option = 0,
                                 string[] packetsplit = null)
        {
            switch (Effect)
            {
            default:
                bool delay = false;
                if (option == 255)
                {
                    delay  = true;
                    option = 0;
                }

                Mate mate = null;
                if (option != 0)
                {
                    if (session.Character.Mates.Count(s => s.MateType == MateType.Partner) == 1 && option == 2)
                    {
                        option = 1;
                    }
                    mate = session.Character.Mates.FirstOrDefault(s =>
                                                                  s.MateType == MateType.Partner && s.PetId == (option - 1));
                }

                short slot      = inv.Slot;
                var   equipment = InventoryType.Wear;
                switch (option)
                {
                case 1:
                    equipment = InventoryType.FirstPartnerInventory;
                    break;

                case 2:
                    equipment = InventoryType.SecondPartnerInventory;
                    break;

                case 3:
                    equipment = InventoryType.ThirdPartnerInventory;
                    break;
                }

                InventoryType itemToWearType = inv.Type;

                if (inv == null)
                {
                    return;
                }

                if (ItemValidTime > 0 && !inv.IsBound)
                {
                    inv.ItemDeleteTime = DateTime.Now.AddSeconds(ItemValidTime);
                }

                if (!inv.IsBound)
                {
                    switch (inv.Item.Effect)
                    {
                    case 790:         // Tarot
                    case 932:         // Attack amulet
                    case 933:         // defense amulet
                        inv.BoundCharacterId = session.Character.CharacterId;
                        break;
                    }

                    if (!delay &&
                        (EquipmentSlot == EquipmentType.Fairy && (MaxElementRate == 70 || MaxElementRate == 80) ||
                         EquipmentSlot == EquipmentType.CostumeHat || EquipmentSlot == EquipmentType.CostumeSuit ||
                         EquipmentSlot == EquipmentType.WeaponSkin))
                    {
                        session.SendPacket(
                            $"qna #u_i^1^{session.Character.CharacterId}^{(byte)itemToWearType}^{slot}^1 {Language.Instance.GetMessageFromKey("ASK_BIND")}");
                        return;
                    }

                    if (delay)
                    {
                        inv.BoundCharacterId = session.Character.CharacterId;
                    }
                }

                double timeSpanSinceLastSpUsage =
                    (DateTime.Now - Process.GetCurrentProcess().StartTime.AddSeconds(-50)).TotalSeconds -
                    session.Character.LastSp;

                if (EquipmentSlot == EquipmentType.Sp && inv.Rare == -2)
                {
                    session.SendPacket(
                        UserInterfaceHelper.Instance.GenerateMsg(
                            Language.Instance.GetMessageFromKey("CANT_EQUIP_DESTROYED_SP"), 0));
                    return;
                }

                if (option == 0)
                {
                    if (EquipmentSlot == EquipmentType.Sp &&
                        timeSpanSinceLastSpUsage <= session.Character.SpCooldown &&
                        session.Character.Inventory.LoadBySlotAndType <SpecialistInstance>((byte)EquipmentType.Sp,
                                                                                           InventoryType.Specialist) != null)
                    {
                        session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(
                                               string.Format(Language.Instance.GetMessageFromKey("SP_INLOADING"),
                                                             session.Character.SpCooldown - (int)Math.Round(timeSpanSinceLastSpUsage)), 0));
                        return;
                    }

                    if (ItemType != ItemType.Weapon && ItemType != ItemType.Armor && ItemType != ItemType.Fashion &&
                        ItemType != ItemType.Jewelery && ItemType != ItemType.Specialist ||
                        LevelMinimum > (IsHeroic ? session.Character.HeroLevel : session.Character.Level) ||
                        Sex != 0 && Sex != ((byte)session.Character.Gender + 1) ||
                        ItemType != ItemType.Jewelery && EquipmentSlot != EquipmentType.Boots &&
                        EquipmentSlot != EquipmentType.Gloves && (Class >> (byte)session.Character.Class & 1) != 1)
                    {
                        session.SendPacket(
                            session.Character.GenerateSay(Language.Instance.GetMessageFromKey("BAD_EQUIPMENT"),
                                                          10));
                        return;
                    }

                    if (session.Character.UseSp)
                    {
                        var sp =
                            session.Character.Inventory.LoadBySlotAndType <SpecialistInstance>(
                                (byte)EquipmentType.Sp, equipment);

                        if (sp != null && sp.Item.Element != 0 && EquipmentSlot == EquipmentType.Fairy &&
                            Element != sp.Item.Element && Element != sp.Item.SecondaryElement)
                        {
                            session.SendPacket(
                                UserInterfaceHelper.Instance.GenerateMsg(
                                    Language.Instance.GetMessageFromKey("BAD_FAIRY"), 0));
                            return;
                        }
                    }

                    if (ItemType == ItemType.Weapon || ItemType == ItemType.Armor)
                    {
                        if (inv.BoundCharacterId.HasValue &&
                            inv.BoundCharacterId.Value != session.Character.CharacterId)
                        {
                            session.SendPacket(
                                session.Character.GenerateSay(Language.Instance.GetMessageFromKey("BAD_EQUIPMENT"),
                                                              10));
                            return;
                        }
                    }

                    if (session.Character.UseSp && EquipmentSlot == EquipmentType.Sp)
                    {
                        session.SendPacket(
                            session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SP_BLOCKED"), 10));
                        return;
                    }

                    if (session.Character.JobLevel < LevelJobMinimum)
                    {
                        session.SendPacket(
                            session.Character.GenerateSay(Language.Instance.GetMessageFromKey("LOW_JOB_LVL"), 10));
                        return;
                    }
                }
                else if (mate != null)
                {
                    if (mate.Level < LevelMinimum)
                    {
                        session.SendPacket(
                            session.Character.GenerateSay(Language.Instance.GetMessageFromKey("BAD_EQUIPMENT"),
                                                          10));
                        return;
                    }

                    switch (EquipmentSlot)
                    {
                    case EquipmentType.Armor:
                        if (ItemSubType == 4)
                        {
                            if (MateHelper.Instance.CanWearItem(inv.ItemVNum, mate.Monster.NpcMonsterVNum, session))
                            {
                                mate.ArmorInstance = inv;
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }
                        else
                        {
                            goto default;
                        }

                    case EquipmentType.MainWeapon:
                        if (ItemSubType == 12)
                        {
                            if (MateHelper.Instance.CanWearItem(inv.ItemVNum, mate.Monster.NpcMonsterVNum, session))
                            {
                                mate.WeaponInstance = inv;
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }
                        else
                        {
                            goto default;
                        }

                    case EquipmentType.Gloves:
                        mate.GlovesInstance = inv;
                        break;

                    case EquipmentType.Boots:
                        mate.BootsInstance = inv;
                        break;

                    case EquipmentType.Sp:
                        if (ItemSubType == 4)
                        {
                            if (MateHelper.Instance.CanWearItem(inv.ItemVNum, mate.Monster.NpcMonsterVNum, session))
                            {
                                mate.SpInstance = (SpecialistInstance)inv;
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }
                        else
                        {
                            goto default;
                        }

                    default:
                        session.SendPacket(
                            session.Character.GenerateSay(Language.Instance.GetMessageFromKey("BAD_EQUIPMENT"),
                                                          10));
                        return;
                    }
                }

                ItemInstance currentlyEquippedItem =
                    session.Character.Inventory.LoadBySlotAndType((short)EquipmentSlot, equipment);

                if (currentlyEquippedItem == null)
                {
                    // move from equipment to wear
                    session.Character.Inventory.MoveInInventory(inv.Slot, itemToWearType, equipment);
                    session.SendPacket(UserInterfaceHelper.Instance.GenerateInventoryRemove(itemToWearType, slot));
                }
                else
                {
                    // move from wear to equipment and back
                    session.Character.Inventory.MoveInInventory(currentlyEquippedItem.Slot, equipment,
                                                                itemToWearType, inv.Slot);
                    session.SendPacket(currentlyEquippedItem.GenerateInventoryAdd());
                    session.Character.BattleEntity.StaticBcards.RemoveWhere(
                        o => o.ItemVNum != currentlyEquippedItem.ItemVNum, out ConcurrentBag <BCard> eqBcards);
                    session.Character.BattleEntity.StaticBcards = eqBcards;
                }

                if (inv.Item.ItemType != ItemType.Fashion)
                {
                    inv.Item.BCards.ForEach(s => session.Character.BattleEntity.StaticBcards.Add(s));
                }

                if (inv is WearableInstance wearableInstance)
                {
                    var specialistInstance =
                        session.Character.Inventory.LoadBySlotAndType <SpecialistInstance>((byte)EquipmentType.Sp,
                                                                                           InventoryType.Wear);

                    if (wearableInstance.EquipmentOptions != null)
                    {
                        switch (wearableInstance.Item.ItemType)
                        {
                        case ItemType.Armor:
                        case ItemType.Weapon:
                        case ItemType.Jewelery:
                        case ItemType.Fashion:
                            switch (wearableInstance.Slot)
                            {
                            case (byte)EquipmentType.CostumeHat:
                                session.Character.BattleEntity.CostumeHatBcards.Clear();

                                foreach (BCard bc in wearableInstance.Item.BCards)
                                {
                                    session.Character.BattleEntity.CostumeHatBcards.Add(bc);
                                }
                                break;

                            case (byte)EquipmentType.CostumeSuit:
                                session.Character.BattleEntity.CostumeSuitBcards.Clear();

                                foreach (BCard bc in wearableInstance.Item.BCards)
                                {
                                    session.Character.BattleEntity.CostumeSuitBcards.Add(bc);
                                }
                                break;

                            case (byte)EquipmentType.Armor:
                                session.Character.Inventory.Armor = wearableInstance;
                                session.Character.ShellOptionArmor.Clear();

                                foreach (EquipmentOptionDTO dto in DaoFactory.EquipmentOptionDao.GetOptionsByWearableInstanceId(inv.Id))
                                {
                                    session.Character.ShellOptionArmor.Add(dto);
                                }
                                EquipmentOptionHelper.Instance
                                .ShellToBCards(wearableInstance.EquipmentOptions,
                                               wearableInstance.ItemVNum)
                                .ForEach(s => session.Character.BattleEntity.StaticBcards.Add(s));
                                break;

                            case (byte)EquipmentType.MainWeapon:
                                session.Character.ShellOptionsMain.Clear();

                                foreach (EquipmentOptionDTO dto in DaoFactory.EquipmentOptionDao.GetOptionsByWearableInstanceId(inv.Id))
                                {
                                    session.Character.ShellOptionsMain.Add(dto);
                                }
                                session.Character.Inventory.PrimaryWeapon = wearableInstance;
                                EquipmentOptionHelper.Instance
                                .ShellToBCards(wearableInstance.EquipmentOptions,
                                               wearableInstance.ItemVNum)
                                .ForEach(s => session.Character.BattleEntity.StaticBcards.Add(s));
                                specialistInstance?.RestorePoints(session, specialistInstance);
                                break;

                            case (byte)EquipmentType.SecondaryWeapon:
                                session.Character.ShellOptionsSecondary.Clear();

                                foreach (EquipmentOptionDTO dto in DaoFactory.EquipmentOptionDao.GetOptionsByWearableInstanceId(inv.Id))
                                {
                                    session.Character.ShellOptionsSecondary.Add(dto);
                                }
                                session.Character.Inventory.SecondaryWeapon = wearableInstance;
                                EquipmentOptionHelper.Instance
                                .ShellToBCards(wearableInstance.EquipmentOptions,
                                               wearableInstance.ItemVNum)
                                .ForEach(s => session.Character.BattleEntity.StaticBcards.Add(s));
                                specialistInstance?.RestorePoints(session, specialistInstance);
                                break;

                            case (byte)EquipmentType.Ring:
                            case (byte)EquipmentType.Necklace:
                            case (byte)EquipmentType.Bracelet:
                                EquipmentOptionHelper.Instance
                                .CellonToBCards(wearableInstance.EquipmentOptions,
                                                wearableInstance.ItemVNum)
                                .ForEach(s => session.Character.BattleEntity.StaticBcards.Add(s));
                                session.Character.BattleEntity.CellonOptions.Clear();
                                WearableInstance ring     = session.Character.Inventory.LoadBySlotAndType <WearableInstance>((byte)EquipmentType.Ring, InventoryType.Wear);
                                WearableInstance bracelet = session.Character.Inventory.LoadBySlotAndType <WearableInstance>((byte)EquipmentType.Bracelet, InventoryType.Wear);
                                WearableInstance necklace = session.Character.Inventory.LoadBySlotAndType <WearableInstance>((byte)EquipmentType.Necklace, InventoryType.Wear);
                                if (ring?.EquipmentOptions != null)
                                {
                                    session.Character.BattleEntity.CellonOptions.AddRange(ring?.EquipmentOptions);
                                }

                                if (bracelet?.EquipmentOptions != null)
                                {
                                    session.Character.BattleEntity.CellonOptions.AddRange(bracelet?.EquipmentOptions);
                                }

                                if (necklace?.EquipmentOptions != null)
                                {
                                    session.Character.BattleEntity.CellonOptions.AddRange(necklace?.EquipmentOptions);
                                }
                                break;
                            }

                            break;
                        }
                    }
                }

                if (option == 0)
                {
                    session.SendPacket(session.Character.GenerateStatChar());
                    session.CurrentMapInstance?.Broadcast(session.Character.GenerateEq());
                    session.SendPacket(session.Character.GenerateEquipment());
                    session.CurrentMapInstance?.Broadcast(session.Character.GeneratePairy());

                    switch (EquipmentSlot)
                    {
                    case EquipmentType.Fairy:
                        var fairy =
                            session.Character.Inventory.LoadBySlotAndType <WearableInstance>(
                                (byte)EquipmentType.Fairy, equipment);
                        session.SendPacket(session.Character.GenerateSay(
                                               string.Format(Language.Instance.GetMessageFromKey("FAIRYSTATS"), fairy.XP,
                                                             CharacterHelper.LoadFairyXpData(fairy.ElementRate + fairy.Item.ElementRate)),
                                               10));
                        break;

                    case EquipmentType.Amulet:
                        session.SendPacket(session.Character.GenerateEff(39));
                        break;
                    }
                }
                else if (mate != null)
                {
                    session.SendPacket(mate.GenerateScPacket());
                }

                break;
            }
        }
Exemplo n.º 43
0
 public void Consume(ItemInstance item)
 {
     //Consume item
     items.Remove(item);
     OnItemUsed?.Invoke();
 }
Exemplo n.º 44
0
        public OptimizerResults(Character oldCharacter, Character newCharacter, bool cancelOptimization)
        {
            InitializeComponent();

#if !SILVERLIGHT
            this.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterOwner;
            this.WindowState           = System.Windows.WindowState.Normal;
#endif

            if (cancelOptimization)
            {
                CancelButton.Content = "Cancel";
                BT_StoreIt.Content   = "Continue";
            }

            CurrentCharacter = oldCharacter;
            BestCharacter    = newCharacter;

            int rows = ItemGrid.RowDefinitions.Count;
            for (int i = 0; i < Character.OptimizableSlotCount; i++)
            {
                CharacterSlot slot = (CharacterSlot)i;
                if ((oldCharacter[slot] == null && newCharacter[slot] != null) ||
                    (oldCharacter[slot] != null && !oldCharacter[slot].Equals(newCharacter[slot])))
                {
                    // Testing if the ring/trinket items were just swapped and not actually different
                    if (slot == CharacterSlot.Finger1 || slot == CharacterSlot.Finger2)
                    {
                        ItemInstance old1 = oldCharacter[CharacterSlot.Finger1];
                        ItemInstance old2 = oldCharacter[CharacterSlot.Finger2];
                        ItemInstance new1 = newCharacter[CharacterSlot.Finger1];
                        ItemInstance new2 = newCharacter[CharacterSlot.Finger2];
                        if (((old1 == null && new2 == null) || (old1 != null && old1.Equals(new2))) &&
                            ((old2 == null && new1 == null) || (old2 != null && old2.Equals(new1))))
                        {
                            continue;
                        }
                    }
                    else if (slot == CharacterSlot.Trinket1 || slot == CharacterSlot.Trinket2)
                    {
                        ItemInstance old1 = oldCharacter[CharacterSlot.Trinket1];
                        ItemInstance old2 = oldCharacter[CharacterSlot.Trinket2];
                        ItemInstance new1 = newCharacter[CharacterSlot.Trinket1];
                        ItemInstance new2 = newCharacter[CharacterSlot.Trinket2];
                        if (((old1 == null && new2 == null) || (old1 != null && old1.Equals(new2))) &&
                            ((old2 == null && new1 == null) || (old2 != null && old2.Equals(new1))))
                        {
                            continue;
                        }
                    }
                    ItemGrid.RowDefinitions.Add(new RowDefinition()
                    {
                        Height = GridLength.Auto
                    });

                    if (oldCharacter[slot] != null)
                    {
                        ItemDisplay oldItem = new ItemDisplay(oldCharacter[slot]);
                        oldItem.Style = Resources["ItemDisplayStyle"] as Style;
                        ItemGrid.Children.Add(oldItem);
                        Grid.SetRow(oldItem, rows);
                        Grid.SetColumn(oldItem, 0);
                    }

                    if (newCharacter[slot] != null)
                    {
                        ItemDisplay newItem = new ItemDisplay(newCharacter[slot]);
                        newItem.Style = Resources["ItemDisplayStyle"] as Style;
                        ItemGrid.Children.Add(newItem);
                        Grid.SetRow(newItem, rows);
                        Grid.SetColumn(newItem, 1);
                    }

                    rows++;
                }
            }

            currentCalc = oldCharacter.CurrentCalculations.GetCharacterCalculations(oldCharacter, null, false, true, true);
            var oldValue = Optimizer.ItemInstanceOptimizer.GetOptimizationValue(oldCharacter, currentCalc);
            CurrentScoreLabel.Text = string.Format("Current: {0}", oldValue);
            CurrentCalculations.SetCalculations(currentCalc.GetCharacterDisplayCalculationValues());
            CurrentTalents.Character = oldCharacter; //CurrentTalents.IsEnabled = false;
            CurrentBuffs.Character   = oldCharacter; //CurrentBuffs.IsEnabled = false;

            optimizedCalc = newCharacter.CurrentCalculations.GetCharacterCalculations(newCharacter, null, false, true, true);
            var newValue = Optimizer.ItemInstanceOptimizer.GetOptimizationValue(newCharacter, optimizedCalc);
            OptimizedScoreLabel.Text = string.Format("Optimized: {0} ({1:P} change)", newValue, (newValue - oldValue) / oldValue);
            OptimizedCalculations.SetCalculations(optimizedCalc.GetCharacterDisplayCalculationValues());
            OptimizedTalents.Character = newCharacter; //OptimizedTalents.IsEnabled = false;
            OptimizedBuffs.Character   = newCharacter; //OptimizedBuffs.IsEnabled = false;

            CharName1.Text = CharName2.Text = CharName1.Text = oldCharacter.Name;
        }
Exemplo n.º 45
0
 public void UpdateEquipment(string slot, ItemInstance item) => Equipment.EquipItem(slot, item);
Exemplo n.º 46
0
        public BattleEntity(Character character, Skill skill)
        {
            Session          = character.Session;
            HPMax            = character.HPMax;
            MPMax            = character.MPMax;
            Buffs            = character.Buff.GetAllItems();
            BCards           = character.EquipmentBCards.GetAllItems();
            Level            = character.Level;
            EntityType       = EntityType.Player;
            DamageMinimum    = character.MinHit;
            DamageMaximum    = character.MaxHit;
            Hitrate          = character.HitRate;
            CritChance       = character.HitCriticalRate;
            CritRate         = character.HitCritical;
            Morale           = character.Level;
            FireResistance   = character.FireResistance;
            WaterResistance  = character.WaterResistance;
            LightResistance  = character.LightResistance;
            ShadowResistance = character.DarkResistance;
            PositionX        = character.PositionX;
            PositionY        = character.PositionY;

            ItemInstance weapon = null;

            if (skill != null)
            {
                switch (skill.Type)
                {
                case 0:
                    AttackType = AttackType.Melee;
                    if (character.Class == ClassType.Archer)
                    {
                        DamageMinimum = character.MinDistance;
                        DamageMaximum = character.MaxDistance;
                        Hitrate       = character.DistanceRate;
                        CritChance    = character.DistanceCriticalRate;
                        CritRate      = character.DistanceCritical;
                        weapon        = character.Inventory.LoadBySlotAndType((byte)EquipmentType.SecondaryWeapon, InventoryType.Wear);
                    }
                    else
                    {
                        weapon = character.Inventory.LoadBySlotAndType((byte)EquipmentType.MainWeapon, InventoryType.Wear);
                    }
                    break;

                case 1:
                    AttackType = AttackType.Range;
                    if (character.Class == ClassType.Adventurer || character.Class == ClassType.Swordman || character.Class == ClassType.Magician || character.Class == ClassType.Fighter)
                    {
                        DamageMinimum = character.MinDistance;
                        DamageMaximum = character.MaxDistance;
                        Hitrate       = character.DistanceRate;
                        CritChance    = character.DistanceCriticalRate;
                        CritRate      = character.DistanceCritical;
                        weapon        = character.Inventory.LoadBySlotAndType((byte)EquipmentType.SecondaryWeapon, InventoryType.Wear);
                    }
                    else
                    {
                        weapon = character.Inventory.LoadBySlotAndType((byte)EquipmentType.MainWeapon, InventoryType.Wear);
                    }
                    break;

                case 2:
                    AttackType = AttackType.Magical;
                    weapon     = character.Inventory.LoadBySlotAndType((byte)EquipmentType.MainWeapon, InventoryType.Wear);
                    break;

                case 3:
                    weapon = character.Inventory.LoadBySlotAndType((byte)EquipmentType.MainWeapon, InventoryType.Wear);
                    switch (character.Class)
                    {
                    case ClassType.Adventurer:
                    case ClassType.Fighter:
                    case ClassType.Swordman:
                        AttackType = AttackType.Melee;
                        break;

                    case ClassType.Archer:
                        AttackType = AttackType.Range;
                        break;

                    case ClassType.Magician:
                        AttackType = AttackType.Magical;
                        break;
                    }
                    break;

                case 5:
                    AttackType = AttackType.Melee;
                    switch (character.Class)
                    {
                    case ClassType.Adventurer:
                    case ClassType.Swordman:
                    case ClassType.Fighter:
                    case ClassType.Magician:
                        weapon = character.Inventory.LoadBySlotAndType((byte)EquipmentType.MainWeapon, InventoryType.Wear);
                        break;

                    case ClassType.Archer:
                        weapon = character.Inventory.LoadBySlotAndType((byte)EquipmentType.SecondaryWeapon, InventoryType.Wear);
                        break;
                    }
                    break;
                }
            }
            else
            {
                weapon = character.Inventory.LoadBySlotAndType((byte)EquipmentType.SecondaryWeapon, InventoryType.Wear);
                switch (character.Class)
                {
                case ClassType.Adventurer:
                case ClassType.Fighter:
                case ClassType.Swordman:
                    AttackType = AttackType.Melee;
                    break;

                case ClassType.Archer:
                    AttackType = AttackType.Range;
                    break;

                case ClassType.Magician:
                    AttackType = AttackType.Magical;
                    break;
                }
            }

            if (weapon != null)
            {
                AttackUpgrade       = weapon.Upgrade;
                WeaponDamageMinimum = weapon.DamageMinimum + weapon.Item.DamageMinimum;
                WeaponDamageMaximum = weapon.DamageMaximum + weapon.Item.DamageMinimum;

                ShellWeaponEffects = new List <ShellEffectDTO>(weapon.ShellEffects);
            }

            ItemInstance armor = character.Inventory.LoadBySlotAndType((byte)EquipmentType.Armor, InventoryType.Wear);

            if (armor != null)
            {
                DefenseUpgrade      = armor.Upgrade;
                ArmorMeleeDefense   = armor.CloseDefence + armor.Item.CloseDefence;
                ArmorRangeDefense   = armor.DistanceDefence + armor.Item.DistanceDefence;
                ArmorMagicalDefense = armor.MagicDefence + armor.Item.MagicDefence;

                ShellArmorEffects = new List <ShellEffectDTO>(armor.ShellEffects);
            }

            CellonOptions = Session.Character.CellonOptions.GetAllItems();

            MeleeDefense      = character.Defence;
            MeleeDefenseDodge = character.DefenceRate;
            RangeDefense      = character.DistanceDefence;
            RangeDefenseDodge = character.DistanceDefenceRate;
            MagicalDefense    = character.MagicalDefence;
            Element           = character.Element;
            ElementRate       = character.ElementRate + character.ElementRateSP;
        }
Exemplo n.º 47
0
        /// <summary>
        /// c_buy packet
        /// </summary>
        /// <param name="cBuyPacket"></param>
        public void BuyBazaar(CBuyPacket cBuyPacket)
        {
            BazaarItemDTO bz = DAOFactory.BazaarItemDAO.LoadAll().FirstOrDefault(s => s.BazaarItemId == cBuyPacket.BazaarId);

            if (bz != null && cBuyPacket.Amount > 0)
            {
                long price = cBuyPacket.Amount * bz.Price;

                if (Session.Character.Gold >= price)
                {
                    BazaarItemLink bzcree = new BazaarItemLink {
                        BazaarItem = bz
                    };
                    if (DAOFactory.CharacterDAO.LoadById(bz.SellerId) != null)
                    {
                        bzcree.Owner = DAOFactory.CharacterDAO.LoadById(bz.SellerId)?.Name;
                        bzcree.Item  = (ItemInstance)DAOFactory.IteminstanceDAO.LoadById(bz.ItemInstanceId);
                    }
                    if (cBuyPacket.Amount <= bzcree.Item.Amount)
                    {
                        if (!Session.Character.Inventory.CanAddItem(bzcree.Item.ItemVNum))
                        {
                            Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("NOT_ENOUGH_PLACE"), 0));
                            return;
                        }

                        if (bzcree.Item != null)
                        {
                            if (bz.IsPackage && cBuyPacket.Amount != bz.Amount)
                            {
                                return;
                            }
                            ItemInstanceDTO bzitemdto = DAOFactory.IteminstanceDAO.LoadById(bzcree.BazaarItem.ItemInstanceId);
                            if (bzitemdto.Amount < cBuyPacket.Amount)
                            {
                                return;
                            }
                            bzitemdto.Amount       -= cBuyPacket.Amount;
                            Session.Character.Gold -= price;
                            Session.SendPacket(Session.Character.GenerateGold());
                            DAOFactory.IteminstanceDAO.InsertOrUpdate(bzitemdto);
                            ServerManager.Instance.BazaarRefresh(bzcree.BazaarItem.BazaarItemId);
                            Session.SendPacket($"rc_buy 1 {bzcree.Item.Item.VNum} {bzcree.Owner} {cBuyPacket.Amount} {cBuyPacket.Price} 0 0 0");
                            ItemInstance newBz = bzcree.Item.DeepCopy();
                            newBz.Id     = Guid.NewGuid();
                            newBz.Amount = cBuyPacket.Amount;
                            newBz.Type   = newBz.Item.Type;

                            List <ItemInstance> newInv = Session.Character.Inventory.AddToInventory(newBz);
                            if (newInv.Any())
                            {
                                Session.SendPacket(Session.Character.GenerateSay($"{Language.Instance.GetMessageFromKey("ITEM_ACQUIRED")}: { bzcree.Item.Item.Name} x {cBuyPacket.Amount}", 10));
                            }
                        }
                    }
                    else
                    {
                        Session.SendPacket(UserInterfaceHelper.Instance.GenerateModal(Language.Instance.GetMessageFromKey("STATE_CHANGED"), 1));
                    }
                }
                else
                {
                    Session.SendPacket(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NOT_ENOUGH_MONEY"), 10));
                    Session.SendPacket(UserInterfaceHelper.Instance.GenerateModal(Language.Instance.GetMessageFromKey("NOT_ENOUGH_MONEY"), 1));
                }
            }
            else
            {
                Session.SendPacket(UserInterfaceHelper.Instance.GenerateModal(Language.Instance.GetMessageFromKey("STATE_CHANGED"), 1));
            }
        }
 public ItemData(ItemTemplate template, ItemInstance instance)
 {
     this.Template = template;
     this.Instance = instance;
 }
Exemplo n.º 49
0
    public GameObject prefabInstance = null;    // Inventory frontend representation.

    // TODO: it would be better if we used SetActive() etc rather than Instantiate/Destroy.
    // Use this method to set a slot's item.
    // The slot will automatically instantiate the gameobject associated with the item.
    public void SetItem(ItemInstance instance)
    {
        this.itemInstance   = instance;
        this.prefabInstance = Instantiate(instance.item.physicalRepresentation, transform);
    }
Exemplo n.º 50
0
 public float GetUptime(ItemInstance item)
 {
     float uptime = 0;
     if (item != null)
         foreach (SpecialEffect effect in item.GetTotalStats().SpecialEffects())
         {
             SetTriggerChanceAndSpeed(effect);
             uptime = effect.GetAverageUptime(trigger, chance, unhastedAttackSpeed);
         }
     return uptime;
 }
Exemplo n.º 51
0
 public QuestRewardItemInstance(ItemInstance item)
 {
     _item = item;
 }
Exemplo n.º 52
0
        private void UpdateGraphAvailable(string subgraph)
        {
            SetGraphControl(ComparisonGraph);
            CGL_Legend.LegendItems = Calculations.SubPointNameColors;
            ComparisonGraph.LegendItems = Calculations.SubPointNameColors;
            ComparisonGraph.Mode = ComparisonGraph.DisplayMode.Subpoints;
            List<ComparisonCalculationBase> itemCalculations = new List<ComparisonCalculationBase>();

            List<ItemInstance> availableGear = new List<ItemInstance>();
            List<Item> availableEnchants = new List<Item>();
            List<Item> availableTinkerings = new List<Item>();

            foreach (string availableItem in Character.AvailableItems)
            {
                ItemInstance ii = null;
                if ((ii = new ItemInstance(availableItem)) != null) {
                    if (ii.Id > 0 && (subgraph == "Gear" || subgraph == "All")) {
                        availableGear.Add(ii);
                    } else if (ii.Id < -1000000 && (subgraph == "Tinkerings" || subgraph == "All")) {
                        ii.Id *= -1;
                        int slot = int.Parse(ii.Id.ToString().Substring(0, 2));
                        if (slot > (int)ItemSlot.Ranged) slot /= 10;
                        ii.Id -= slot * (int)AvailableItemIDModifiers.Tinkerings;
                        Tinkering temp = Tinkering.FindTinkering(ii.Id, (ItemSlot)slot, Character);

                        Item tink = new Item(string.Format("{0} ({1})", temp.Name, (ItemSlot)slot), ItemQuality.Temp, ItemType.None,
                            -1 * (temp.Id + ((int)AvailableItemIDModifiers.Tinkerings * (int)temp.Slot)), null, ItemSlot.None, null,
                            false, temp.Stats, null, ItemSlot.None, ItemSlot.None, ItemSlot.None,
                            0, 0, ItemDamageType.Physical, 0, null);

                        availableTinkerings.Add(tink);
                    } else if (ii.Id < 0 && (subgraph == "Enchants" || subgraph == "All")) {
                        ii.Id *= -1;
                        int slot = int.Parse(ii.Id.ToString().Substring(0, 2));
                        if (slot > (int)ItemSlot.Ranged) slot /= 10;
                        ii.Id -= slot * (int)AvailableItemIDModifiers.Enchants;
                        Enchant temp = Enchant.FindEnchant(ii.Id, (ItemSlot)slot, Character);

                        Item ench = new Item(string.Format("{0} ({1})", temp.Name, (ItemSlot)slot), ItemQuality.Temp, ItemType.None,
                            -1 * (temp.Id + ((int)AvailableItemIDModifiers.Enchants * (int)temp.Slot)), null, ItemSlot.None, null,
                            false, temp.Stats, null, ItemSlot.None, ItemSlot.None, ItemSlot.None,
                            0, 0, ItemDamageType.Physical, 0, null);

                        availableEnchants.Add(ench);
                    }
                }
            }

            if (subgraph == "Gear" || subgraph == "All")
            {
                CharacterSlot[] slots = new CharacterSlot[]
                {
                     CharacterSlot.Back, CharacterSlot.Chest, CharacterSlot.Feet, CharacterSlot.Finger1,
                     CharacterSlot.Finger2, CharacterSlot.Hands, CharacterSlot.Head, CharacterSlot.Legs,
                     CharacterSlot.MainHand, CharacterSlot.Neck, CharacterSlot.OffHand, /*CharacterSlot.Projectile,
                     CharacterSlot.ProjectileBag,*/ CharacterSlot.Ranged, CharacterSlot.Shoulders,
                     CharacterSlot.Trinket1, CharacterSlot.Trinket2, CharacterSlot.Waist, CharacterSlot.Wrist
                };
                foreach (ItemInstance item in availableGear)
                {
                    if (item != null)
                    {
                        itemCalculations.Add(Calculations.GetItemCalculations(item, Character, Character.GetCharacterSlotByItemSlot(item.Slot)));

                        ItemSlot islot = item.Slot;
                        CharacterSlot PriSlot = Character.GetCharacterSlotByItemSlot(islot), AltSlot;
                        if (islot == ItemSlot.Finger ) { AltSlot = CharacterSlot.Finger2; }
                        else if (islot == ItemSlot.Trinket) { AltSlot = CharacterSlot.Trinket2; }
                        else if (islot == ItemSlot.TwoHand) { AltSlot = CharacterSlot.OffHand; }
                        else if (islot == ItemSlot.OneHand) { AltSlot = CharacterSlot.OffHand; }
                        else { AltSlot = PriSlot; }

                        if      (                      Character[PriSlot] != null && Character[PriSlot].Id == item.Id) { itemCalculations[itemCalculations.Count - 1].PartEquipped = true; }
                        else if (AltSlot != PriSlot && Character[AltSlot] != null && Character[AltSlot].Id == item.Id) { itemCalculations[itemCalculations.Count - 1].PartEquipped = true; }
                    }
                }
            }
            if (subgraph == "Enchants" || subgraph == "All")
            {
                ItemSlot[] slots = new ItemSlot[]
                {
                     ItemSlot.Back, ItemSlot.Chest, ItemSlot.Feet, ItemSlot.Finger,
                     ItemSlot.Hands, ItemSlot.Head, ItemSlot.Legs,
                     ItemSlot.MainHand, ItemSlot.OffHand, ItemSlot.Ranged, ItemSlot.Shoulders,
                     ItemSlot.Waist, ItemSlot.Wrist
                };
                foreach (ItemSlot slot in slots)
                {
                    foreach (ComparisonCalculationBase calc in Calculations.GetEnchantCalculations(slot, Character, Calculations.GetCharacterCalculations(Character), false, true))
                    {
                        foreach(Item item in availableEnchants) {
                            if (calc.Item.Id == item.Id) {
                                itemCalculations.Add(calc);
                                break;
                            }
                        }
                    }
                }
            }
            if (subgraph == "Tinkerings" || subgraph == "All")
            {
                ItemSlot[] slots = new ItemSlot[]
                {
                     ItemSlot.Back, ItemSlot.Hands, ItemSlot.Waist,
                };
                foreach (ItemSlot slot in slots)
                {
                    foreach (ComparisonCalculationBase calc in Calculations.GetTinkeringCalculations(slot, Character, Calculations.GetCharacterCalculations(Character), false, true))
                    {
                        foreach (Item item in availableTinkerings)
                        {
                            if (calc.Item.Id == item.Id)
                            {
                                itemCalculations.Add(calc);
                                break;
                            }
                        }
                    }
                }
            }
            // Now Push the results to the screen
            ComparisonGraph.DisplayCalcs(_itemCalculations = itemCalculations.ToArray());
        }
Exemplo n.º 53
0
 private void onItemInspected(ItemInstance itemInstance)
 {
     this.onRefresh();
 }
Exemplo n.º 54
0
        public virtual void isHitByItem(ItemInstance item, State expectedHitState)
        {
            player.CurrentHealth -= item.damage;

            if(player.CurrentHealth <= 0 || player.state is StateJump)
                player.state.ChangeState(new StateKnockedDown(player, item.moveDirection, true));
            else
                player.state.ChangeState(expectedHitState);
        }
        public override void Execute(IExecutionEntity execution)
        {
            BpmnModel               bpmnModel   = ProcessDefinitionUtil.GetBpmnModel(execution.ProcessDefinitionId);
            FlowElement             flowElement = execution.CurrentFlowElement;
            IOSpecification         ioSpecification;
            string                  operationRef;
            IList <DataAssociation> dataInputAssociations;
            IList <DataAssociation> dataOutputAssociations;

            if (flowElement is SendTask sendTask)
            {
                ioSpecification        = sendTask.IoSpecification;
                operationRef           = sendTask.OperationRef;
                dataInputAssociations  = sendTask.DataInputAssociations;
                dataOutputAssociations = sendTask.DataOutputAssociations;
            }
            else if (flowElement is ServiceTask serviceTask)
            {
                ioSpecification        = serviceTask.IoSpecification;
                operationRef           = serviceTask.OperationRef;
                dataInputAssociations  = serviceTask.DataInputAssociations;
                dataOutputAssociations = serviceTask.DataOutputAssociations;
            }
            else
            {
                throw new ActivitiException("Unsupported flow element type " + flowElement);
            }

            MessageInstance message = null;

            FillDefinitionMaps(bpmnModel);

            Webservice.Operation operation = operationMap[operationRef];

            try
            {
                if (ioSpecification != null)
                {
                    InitializeIoSpecification(ioSpecification, execution, bpmnModel);
                    if (ioSpecification.DataInputRefs.Count > 0)
                    {
                        string       firstDataInputName = ioSpecification.DataInputRefs[0];
                        ItemInstance inputItem          = (ItemInstance)execution.GetVariable(firstDataInputName);
                        message = new MessageInstance(operation.InMessage, inputItem);
                    }
                }
                else
                {
                    message = operation.InMessage.CreateInstance();
                }

                execution.SetVariable(CURRENT_MESSAGE, message);

                FillMessage(dataInputAssociations, execution);

                ProcessEngineConfigurationImpl processEngineConfig = Context.ProcessEngineConfiguration;
                MessageInstance receivedMessage = operation.SendMessage(message, processEngineConfig.WsOverridenEndpointAddresses);

                execution.SetVariable(CURRENT_MESSAGE, receivedMessage);

                if (ioSpecification != null && ioSpecification.DataOutputRefs.Count > 0)
                {
                    string firstDataOutputName = ioSpecification.DataOutputRefs[0];
                    if (firstDataOutputName is object)
                    {
                        ItemInstance outputItem = (ItemInstance)execution.GetVariable(firstDataOutputName);
                        outputItem.StructureInstance.LoadFrom(receivedMessage.StructureInstance.ToArray());
                    }
                }

                ReturnMessage(dataOutputAssociations, execution);

                execution.SetVariable(CURRENT_MESSAGE, null);
                Leave(execution);
            }
            catch (Exception exc)
            {
                Exception cause = exc;
                BpmnError error = null;
                while (cause != null)
                {
                    if (cause is BpmnError)
                    {
                        error = (BpmnError)cause;
                        break;
                    }
                    cause = cause.InnerException;
                }

                if (error != null)
                {
                    ErrorPropagation.PropagateError(error, execution);
                }
                else if (exc is Exception)
                {
                    throw (Exception)exc;
                }
            }
        }
Exemplo n.º 56
0
 void _optimizer_ComputeUpgradesCompleted(object sender, ComputeUpgradesCompletedEventArgs e)
 {
     switch (currentOperation)
     {
         case AsyncOperation.BuildUpgradeList:
             if (e.Cancelled || e.Error != null)
             {
                 currentOperation = AsyncOperation.None;
                 UpdateStatusLabel();
                 if (OperationCompleted != null)
                 {
                     OperationCompleted(this, EventArgs.Empty);
                 }
                 break;
             }
             if (upgradeListPhase == 0)
             {
                 foreach (KeyValuePair<CharacterSlot, List<ComparisonCalculationUpgrades>> kvp in e.Upgrades)
                 {
                     Dictionary<string, UpgradeEntry> map;
                     if (!upgradeList.TryGetValue(kvp.Key, out map))
                     {
                         map = new Dictionary<string, UpgradeEntry>();
                         upgradeList[kvp.Key] = map;
                     }
                     foreach (ComparisonCalculationBase comp in kvp.Value)
                     {
                         string key = comp.ItemInstance.GemmedId;
                         UpgradeEntry upgradeEntry;
                         if (!map.TryGetValue(key, out upgradeEntry))
                         {
                             upgradeEntry = new UpgradeEntry();
                             upgradeEntry.Item = comp.ItemInstance;
                             map[key] = upgradeEntry;
                         }
                     }
                 }
                 do
                 {
                     batchIndex++;
                 } while (batchIndex < BatchCharacterList.Count && CurrentBatchCharacter.Character == null);
                 if (batchIndex < BatchCharacterList.Count)
                 {
                     ComputeUpgradesCurrentBatchCharacter();
                 }
                 else
                 {
                     upgradeListPhase = 1;
                     batchIndex = 0;
                     upgradeListEnumerator = GetUpgradeListEnumerator();
                     if (upgradeListEnumerator.MoveNext())
                     {
                         EvaluateUpgradeCurrentBatchCharacter(true);
                     }
                     else
                     {
                         // upgrade list is empty, abort
                         currentOperation = AsyncOperation.None;
                         UpdateStatusLabel();
                         if (OperationCompleted != null)
                         {
                             OperationCompleted(this, EventArgs.Empty);
                         }
                         break;
                     }
                 }
             }
             break;
         case AsyncOperation.BuildProgressiveUpgradeList:
             {
                 if (e.Cancelled || e.Error != null)
                 {
                     currentOperation = AsyncOperation.None;
                     UpdateStatusLabel();
                     if (OperationCompleted != null)
                     {
                         OperationCompleted(this, EventArgs.Empty);
                     }
                     break;
                 }
                 ComparisonCalculationUpgrades bestComp = null;
                 foreach (KeyValuePair<CharacterSlot, List<ComparisonCalculationUpgrades>> kvp in e.Upgrades)
                 {
                     if (kvp.Value.Count > 0 && kvp.Value[0].OverallPoints > (bestComp != null ? bestComp.OverallPoints : 0))
                     {
                         bestComp = kvp.Value[0];
                     }
                 }
                 SuffixItem item = itemList[itemIndex];
                 CharacterSlot slot = Character.GetCharacterSlotByItemSlot(item.Item.Slot);
                 Dictionary<string, UpgradeEntry> map;
                 if (!upgradeList.TryGetValue(slot, out map))
                 {
                     map = new Dictionary<string, UpgradeEntry>();
                     upgradeList[slot] = map;
                 }
                 string key = item.SuffixId;
                 UpgradeEntry upgradeEntry;
                 if (!map.TryGetValue(key, out upgradeEntry))
                 {
                     upgradeEntry = new UpgradeEntry();
                     map[key] = upgradeEntry;
                 }
                 if (bestComp != null)
                 {
                     upgradeListPhase = 1; // item was used, from now on we do evaluate upgrade on specific item instance only
                     optimizedItemInstance = bestComp.ItemInstance;
                     // make item restrictions based on best character
                     itemGenerator.AddItemRestrictions(bestComp.CharacterItems, workingCharacter.CurrentCalculations.IncludeOffHandInCalculations(workingCharacter));
                     upgradeEntry.Item = bestComp.ItemInstance;
                     upgradeEntry.Value += bestComp.OverallPoints * CurrentBatchCharacter.Weight;
                     upgradeEntry.ValueList.Add(bestComp.OverallPoints);
                 }
                 else
                 {
                     // make item restrictions based on best character without using the item
                     itemGenerator.AddItemRestrictions(workingCharacter);
                     // with the addition of support for multiples of the same item the semantics of this changes
                     // we now treat the upgrade as completely separate item, so no need to restrict to it if it is used
                     // as that one is a separate instance
                     if (upgradeListPhase == 1)
                     {
                         upgradeEntry.Item = optimizedItemInstance;
                     }
                     upgradeEntry.ValueList.Add(0.0f);
                 }
                 // move to next character
                 do
                 {
                     batchIndex++;
                 } while (batchIndex < BatchCharacterList.Count && CurrentBatchCharacter.Character == null);
                 if (batchIndex < BatchCharacterList.Count)
                 {
                     if (upgradeListPhase == 0)
                     {
                         // so far we haven't made any changes yet
                         // we're working under assumption that the starting batch is valid i.e. an item will have the same gemming in all characters
                         int _thoroughness = Thoroughness;
                         workingCharacter = CurrentBatchCharacter.Character;
                         optimizer.InitializeItemCache(workingCharacter, CurrentBatchCharacter.Model, itemGenerator);
                         optimizer.ComputeUpgradesAsync(workingCharacter, _thoroughness, itemList[itemIndex]);
                     }
                     else
                     {
                         // we made item restrictions, first we have to optimize character without the item
                         int _thoroughness = Thoroughness;
                         workingCharacter = CurrentBatchCharacter.Character.Clone();
                         // regularize character with current item restrictions
                         itemGenerator.RegularizeCharacter(workingCharacter);
                         optimizer.InitializeItemCache(workingCharacter, CurrentBatchCharacter.Model, itemGenerator);
                         if (ConsiderMultipleNewItems)
                         {
                             optimizer.ComputeUpgradesAsync(workingCharacter, _thoroughness, itemList[itemIndex]);
                         }
                         else
                         {
                             optimizer.OptimizeCharacterAsync(workingCharacter, _thoroughness, true);
                         }
                     }
                 }
                 else
                 {
                     // we finished all characters for this item
                     // move to next item
                     itemIndex++;
                     if (itemIndex < itemList.Length)
                     {
                         batchIndex = 0;
                         upgradeListPhase = 0;
                         int _thoroughness = Thoroughness;
                         // we have to reinitialize item generator because of the restrictions we made
                         //CreateBatchItemGenerator();
                         itemGenerator.RestoreAvailabilityInformation();
                         optimizer.InitializeItemCache(CurrentBatchCharacter.Character, CurrentBatchCharacter.Model, itemGenerator);
                         workingCharacter = CurrentBatchCharacter.Character;
                         optimizer.ComputeUpgradesAsync(CurrentBatchCharacter.Character, _thoroughness, itemList[itemIndex]);
                     }
                     else
                     {
                         // we're done
                         WrapUpProgressiveUpgradeList();
                     }
                 }
             }
             break;
     }
 }
Exemplo n.º 57
0
        public override void isHitByItem(ItemInstance item, State expectedHitState)
        {
            if (timer <= 0)
            {
                // well timed? Duck and weave!
                if (dodgeTimer > 0)
                {
                    ChangeState(new StateDodge(player));
                    //attackingPlayer.state.wasDodged();
                }
                else
                {
                    hitCounter++;
                    PlaySound(player.soundEffects["Hit"]); // play the sound effect!

                }
                timer = time;
            }

            if (hitCounter >= 1)
            {
                ChangeState(new StateKnockedDown(player, item.moveDirection, true));
                player.CurrentHealth -= 20;
            }

            //base.isHitByItem(item, expectedHitState);
        }
Exemplo n.º 58
0
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            ItemSlot gemType = ItemSlot.None;

            if (value is Item)
            {
                Item item = value as Item;
                if (parameter.ToString() == "1")
                {
                    gemType = item.SocketColor1;
                }
                else if (parameter.ToString() == "2")
                {
                    gemType = item.SocketColor2;
                }
                else if (parameter.ToString() == "3")
                {
                    gemType = item.SocketColor3;
                }
            }
            else if (value is ItemInstance)
            {
                ItemInstance instance = value as ItemInstance;
                Item         item     = instance.Item;
                if (parameter.ToString() == "1")
                {
                    if (instance.Gem1Id > 0)
                    {
                        if (item.SocketColor1 == ItemSlot.None)
                        {
                            gemType = ItemSlot.Prismatic;
                        }
                        else
                        {
                            gemType = item.SocketColor1;
                        }
                    }
                }
                else if (parameter.ToString() == "2")
                {
                    if (instance.Gem2Id > 0)
                    {
                        if (item.SocketColor2 == ItemSlot.None)
                        {
                            gemType = ItemSlot.Prismatic;
                        }
                        else
                        {
                            gemType = item.SocketColor2;
                        }
                    }
                }
                else if (parameter.ToString() == "3")
                {
                    if (instance.Gem3Id > 0)
                    {
                        if (item.SocketColor3 == ItemSlot.None)
                        {
                            gemType = ItemSlot.Prismatic;
                        }
                        else
                        {
                            gemType = item.SocketColor3;
                        }
                    }
                }
            }

            switch (gemType)
            {
            case ItemSlot.Red:
                return(new SolidColorBrush(Colors.Red));

            case ItemSlot.Yellow:
                return(new SolidColorBrush(Colors.Yellow));

            case ItemSlot.Blue:
                return(new SolidColorBrush(Colors.Blue));

            case ItemSlot.Orange:
                return(new SolidColorBrush(Colors.Orange));

            case ItemSlot.Purple:
                return(new SolidColorBrush(Colors.Purple));

            case ItemSlot.Green:
                return(new SolidColorBrush(Colors.Green));

            case ItemSlot.Prismatic:
                return(new SolidColorBrush(Colors.LightGray));

            case ItemSlot.Meta:
                return(new SolidColorBrush(Colors.Gray));

            default:
                return(new SolidColorBrush(Colors.Transparent));
            }
        }
Exemplo n.º 59
0
 private bool SearchPredicate(string searchText, ItemInstance source1, ComparisonCalculationBase source2) {
     if (CK_UseRegex.IsChecked.GetValueOrDefault(false)) {
         Regex regex = new Regex(searchText);
         if (source1 != null)  {
             if (regex.Match(source1.Name).Success) return true;
             if (!string.IsNullOrEmpty(source1.Item.SetName) && regex.Match(source1.Item.SetName).Success) return true;
             if (regex.Match(source1.Id.ToString()).Success) return true;
             if (regex.Match(source1.Item.GetFullLocationDesc).Success) return true;
         } else {
             if (regex.Match(source2.Name).Success) return true;
             if (!string.IsNullOrEmpty(source2.Item.SetName) && regex.Match(source2.Item.SetName).Success) return true;
             if (regex.Match(source2.Item.Id.ToString()).Success) return true;
             if (regex.Match(source2.Item.GetFullLocationDesc).Success) return true;
         }
     } else {
         if (source1 != null)  {
             if (source1.Name.Contains(searchText)) return true;
             if (!string.IsNullOrEmpty(source1.Item.SetName) && source1.Item.SetName.Contains(searchText)) return true;
             if (source1.Id.ToString().Contains(searchText)) return true;
             if (source1.Item.GetFullLocationDesc.Contains(searchText)) return true;
         } else {
             if (source2.Name.Contains(searchText)) return true;
             if (!string.IsNullOrEmpty(source2.Item.SetName) && source2.Item.SetName.Contains(searchText)) return true;
             if (source2.Item.Id.ToString().Contains(searchText)) return true;
             if (source2.Item.GetFullLocationDesc.Contains(searchText)) return true;
         }
     }
     // Return false because it didn't pass any of the above checks
     return false;
 }
Exemplo n.º 60
0
 // Not even items!
 public override void  isHitByItem(ItemInstance item, State expectedHitState)
 {
     // base.isHitByItem(item, expectedHitState);
 }