Ejemplo n.º 1
0
 public override void Update()
 {
     Ped player = Game.Player.Character;
     NearestPed = World.GetNearbyPeds(player, 3).FirstOrDefault();
     NearbyLoot = PlayerMethods.GetNearbyLoot(2.5f).FirstOrDefault();
     IsWideScreen = Function.Call<bool>(Hash.GET_IS_WIDESCREEN);
     Wait(400);
 }
Ejemplo n.º 2
0
        public static void SendStartRoll(Loot loot, LootItem item, IEnumerable <LooterEntry> looters, MapId mapid)
        {
            using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_LOOT_START_ROLL))
            {
                packet.Write(loot.Lootable.EntityId);
                packet.WriteUInt((uint)mapid);             // TODO: actually use this
                packet.Write(item.Index);
                packet.Write(item.Template.Id);
                packet.Write(item.Template.RandomSuffixFactor);
                packet.Write((int)(item.Template.RandomSuffixFactor > 0 ?
                                   -item.Template.RandomSuffixId : item.Template.RandomPropertiesId));
                //packet.Write(LootMgr.DefaultLootRollTimeout);
                packet.Write((byte)0x0F);                                                                        // since 3.3: loot roll mask

                foreach (var looter in looters)
                {
                    if (looter.Owner != null)
                    {
                        looter.Owner.Client.Send(packet, addEnd: false);
                    }
                }
            }
        }
Ejemplo n.º 3
0
 public static void SendRoll(Character looter, Loot loot, LootItem item, int rollNumber, LootRollType rollType)
 {
     using (RealmPacketOut packet = new RealmPacketOut(RealmServerOpCode.SMSG_LOOT_ROLL))
     {
         packet.Write(loot.Lootable.EntityId);
         packet.Write(item.Index);
         packet.Write(looter.EntityId);
         packet.Write(item.Template.Id);
         packet.Write(item.Template.RandomSuffixFactor);
         packet.Write(item.Template.RandomSuffixFactor > 0U
   ? (int)-item.Template.RandomSuffixId
   : (int)item.Template.RandomPropertiesId);
         packet.Write(rollNumber);
         packet.Write((byte)rollType);
         foreach (LooterEntry looter1 in loot.Looters)
         {
             if (looter1.Owner != null)
             {
                 looter1.Owner.Client.Send(packet, false);
             }
         }
     }
 }
Ejemplo n.º 4
0
 public static void ItemsList()
 {
     try
     {
         Cons.Main.tItems = new List <LootItem>();
         List <LootItem> .Enumerator temporalItemsEnum = Cons.Main._GameWorld.LootItems.GetValuesEnumerator().GetEnumerator();
         while (temporalItemsEnum.MoveNext())
         {
             LootItem temp = temporalItemsEnum.Current;
             if (temp.GetType() == Types.LootItem || temp.GetType() == Types.ObservedLootItem)
             {
                 if (Cons.LootSearcher == "")
                 {
                     Cons.Main.tItems.Add(temp);
                 }
                 try
                 {
                     if (temp.Item.ShortName.Localized().ToLower().IndexOf(Cons.LootSearcher) >= 0)
                     {
                         Cons.Main.tItems.Add(temp);
                     }
                 }
                 catch (Exception e)
                 {
                     ErrorHandler.Catch("LootItem_Translate_SearcherIndexOf", e);
                 }
             }
         }
         Cons.Main._lootItems = Cons.Main.tItems;
         temporalItemsEnum.Dispose();
     }
     catch (Exception e)
     {
         ErrorHandler.Catch("Get_LootItems", e);
     }
 }
Ejemplo n.º 5
0
        public static void Loot(LootItem loot)
        {
            if (loot != null)
            {
                if (loot.Item.Type == ItemType.Money)
                {
                    var notification = Notification.Loot("Looted GTA$" + loot.Item.MoneyValue.ToString("N0"));
                    notification.Tracking = loot.Item.MoneyValue;
                    RPG.Notify(notification);
                    PlayerData.AddMoney(loot.Item.MoneyValue);
                    loot.Destroy();
                    Game.PlaySound("FocusOut", "HintCamSounds");
                }
                else
                {
                    RPG.Notify(Notification.Loot("Looted: " + loot.Name + " x" + loot.Item.Quantity));
                    PlayerData.AddItem(loot.Item);
                    loot.Destroy();
                    Game.PlaySound("FocusOut", "HintCamSounds");
                }
            }

            RPGInfo.NearbyLoot = null;
        }
Ejemplo n.º 6
0
 public static Color GetItemColor(LootItem itm)
 {
     if (!Settings.CItem.DisplayLootSrare && !Settings.CItem.DisplayLootCustom1 && !Settings.CItem.DisplayLootCustom2 && !Settings.CItem.DisplayLootCustom3)
     { // nothing is enabled to color staff so return basic color
         return(Settings.CItem.DrawBaseColor);
     }
     if (Settings.CItem.DisplayLootSrare && itm.Item.Template.Rarity == JsonType.ELootRarity.Superrare)
     { // enabled super rare and item is super rare
         return(Settings.CItem.DrawSRare);
     }
     if (Settings.CItem.DisplayLootCustom1 && (Array.IndexOf(IDTable1, itm.Item.TemplateId) != -1 || Array.IndexOf(IDTable1, itm.Item.Template._parent) != -1))
     { // enabled rare and item is rare
         return(Settings.CItem.DrawCustom1);
     }
     if (Settings.CItem.DisplayLootCustom2 && (Array.IndexOf(IDTable2, itm.Item.TemplateId) != -1 || Array.IndexOf(IDTable2, itm.Item.Template._parent) != -1))
     { // enabled common and item is common
         return(Settings.CItem.DrawCustom2);
     }
     if (Settings.CItem.DisplayLootCustom3 && (Array.IndexOf(IDTable3, itm.Item.TemplateId) != -1 || Array.IndexOf(IDTable3, itm.Item.Template._parent) != -1))
     { // enabled custom search and item is on list (as parent or template id)
         return(Settings.CItem.DrawCustom3);
     }
     return(Settings.CItem.DrawBaseColor);
 }
Ejemplo n.º 7
0
    public void AddItem(LootItem newItem, int amount)
    {
        //if(equippedItemSlot != null){
        //    equippedItemSlot.AddItem(newItem, amount);
        //}

        item         = newItem;
        icon.sprite  = item.icon;
        icon.enabled = true;
        if (amount == 1)
        {
            amountText.text = null;
        }
        else
        {
            amountText.text = amount.ToString();
        }

        isEmpty = (amount <= 0);
        if (image != null)
        {
            image.color = (amount <= 0) ? disabledColor : stdColor;
        }
    }
Ejemplo n.º 8
0
        public static void SendRollWon(Character looter, Loot loot, LootItem item, LootRollEntry entry)
        {
            using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_LOOT_ROLL_WON))
            {
                packet.Write(loot.Lootable.EntityId);
                packet.Write(item.Index);
                packet.Write(looter.EntityId);
                packet.Write(item.Template.Id);
                packet.Write(item.Template.RandomSuffixFactor);
                packet.Write((int)(item.Template.RandomSuffixFactor > 0 ? -item.Template.RandomSuffixId : item.Template.RandomPropertiesId));
                packet.Write(looter.EntityId);

                packet.Write(entry.Number);
                packet.Write((int)entry.Type);

                foreach (var looterEntry in loot.Looters)
                {
                    if (looterEntry.Owner != null)
                    {
                        looterEntry.Owner.Client.Send(packet);
                    }
                }
            }
        }
Ejemplo n.º 9
0
    /// <summary>
    /// Assign data from item to button
    /// </summary>
    /// <param name="item"></param>
    public void Initialize(LootItem item, ItemList list, Animator animator, Transform parentUI)
    {
        if (ItemName == null || ItemCost == null)
        {
            return;
        }

        m_List = list;
        m_Item = item;

        ItemName.text        = item.itemName;
        ItemCost.text        = item.itemCost.ToString();
        ItemImage.sprite     = item.itemShopPoster != null ? item.itemShopPoster : item.itemSprite;
        CurrencyImage.sprite = item.currencySprite;

        byte r = (byte)Random.Range(0, 255);
        byte g = (byte)Random.Range(0, 255);
        byte b = (byte)Random.Range(0, 255);

        BackgroundImage.color = new Color32(r, g, b, 150);

        m_CamAnim  = animator;
        m_ParentUI = parentUI;
    }
Ejemplo n.º 10
0
 public static void SendRollWon(Character looter, Loot loot, LootItem item, LootRollEntry entry)
 {
     using (RealmPacketOut packet = new RealmPacketOut(RealmServerOpCode.SMSG_LOOT_ROLL_WON))
     {
         packet.Write((ulong)loot.Lootable.EntityId);
         packet.Write(item.Index);
         packet.Write((ulong)looter.EntityId);
         packet.Write(item.Template.Id);
         packet.Write(item.Template.RandomSuffixFactor);
         packet.Write(item.Template.RandomSuffixFactor > 0U
             ? (int)-item.Template.RandomSuffixId
             : (int)item.Template.RandomPropertiesId);
         packet.Write((ulong)looter.EntityId);
         packet.Write(entry.Number);
         packet.Write((int)entry.Type);
         foreach (LooterEntry looter1 in (IEnumerable <LooterEntry>)loot.Looters)
         {
             if (looter1.Owner != null)
             {
                 looter1.Owner.Client.Send(packet, false);
             }
         }
     }
 }
Ejemplo n.º 11
0
        private static List <Enemy> PopulateEnemies()
        {
            context.Enemies.Include(enemy => enemy.LootTable); // !!!


            var smallDagger = new LootItem(ItemByID(ITEM_ID_SMALL_DAGGER), 100, false, ITEM_ID_SMALL_DAGGER);

            context.LootItems.Add(smallDagger);
            context.SaveChanges();

            Enemy dummy = new Enemy(ENEMY_ID_DUMMY, "Dummy", 1, 4, 0, 45, 45);

            context.Enemies.Add(dummy);

            // how to add the dagger to the dbset's instances' loottable collections, if the dbset's instances don't have access to the loottable collections in the Enemy ???
            //context.Enemies.Include(enemy => enemy.LootTable); // ^ the answer

            context.Enemies.FirstOrDefault(e => e.ID == smallDagger.EnemyID).LootTable.Add(smallDagger);

            return(new List <Enemy>()
            {
                dummy
            });
        }
Ejemplo n.º 12
0
        void PrepareItems(Player receiver, SQLTransaction trans)
        {
            if (m_mailTemplateId == 0 || !m_mailTemplateItemsNeed)
            {
                return;
            }

            m_mailTemplateItemsNeed = false;

            // The mail sent after turning in the quest The Good News and The Bad News contains 100g
            if (m_mailTemplateId == 123)
            {
                m_money = 1000000;
            }

            Loot mailLoot = new();

            // can be empty
            mailLoot.FillLoot(m_mailTemplateId, LootStorage.Mail, receiver, true, true, LootModes.Default, ItemContext.None);

            uint max_slot = mailLoot.GetMaxSlotInLootFor(receiver);

            for (uint i = 0; m_items.Count < SharedConst.MaxMailItems && i < max_slot; ++i)
            {
                LootItem lootitem = mailLoot.LootItemInSlot(i, receiver);
                if (lootitem != null)
                {
                    Item item = Item.CreateItem(lootitem.itemid, lootitem.count, lootitem.context, receiver);
                    if (item != null)
                    {
                        item.SaveToDB(trans);                           // save for prevent lost at next mail load, if send fail then item will deleted
                        AddItem(item);
                    }
                }
            }
        }
Ejemplo n.º 13
0
 static void Postfix()
 {
     BlockLootVessel.lootLists["seed"] = LootList.Create(2,
                                                         LootItem.Item(1f, 5, 7, "seeds-carrot", "seeds-onion", "seeds-spelt", "seeds-turnip", "seeds-rice", "seeds-rye", "seeds-soybean", "seeds-pumpkin", "seeds-cabbage"),
                                                         LootItem.Item(1f, 5, 7, "wildfarming:wildseeds-herb-basil", "wildfarming:wildseeds-herb-thyme", "wildfarming:wildseeds-herb-sage", "wildfarming:wildseeds-herb-chamomile", "wildfarming:wildseeds-herb-mint", "wildfarming:wildseeds-herb-saffron", "wildfarming:wildseeds-herb-marjoram", "wildfarming:wildseeds-herb-cilantro", "wildfarming:wildseeds-herb-lavender")
                                                         );
     BlockLootVessel.lootLists["food"] = LootList.Create(1,
                                                         LootItem.Item(1.5f, 8, 15, "grain-spelt", "grain-rice", "grain-flax", "grain-rye"),
                                                         LootItem.Item(1, 8, 15, "redmeat-cured", "bushmeat-cured", "poultry-cured", "pickledlegume-soybean"),
                                                         LootItem.Item(1, 8, 15, "pickledvegetable-carrot", "pickledvegetable-parsnip", "pickledvegetable-turnip", "pickledvegetable-pumpkin", "pickledvegetable-onion", "pickledvegetable-cabbage"),
                                                         LootItem.Item(0.1f, 1, 1, "resonancearchive-1", "resonancearchive-2", "resonancearchive-3", "resonancearchive-4", "resonancearchive-5", "resonancearchive-6", "resonancearchive-7", "resonancearchive-8", "resonancearchive-9")
                                                         );
     BlockLootVessel.lootLists["forage"] = LootList.Create(2.5f,
                                                           LootItem.Item(1, 2, 6, "flint"),
                                                           LootItem.Item(1, 3, 9, "stick"),
                                                           LootItem.Item(1, 3, 16, "drygrass"),
                                                           LootItem.Item(1, 3, 24, "stone-chalk"),
                                                           LootItem.Item(1, 3, 24, "clay-blue", "clay-fire"),
                                                           LootItem.Item(1, 3, 24, "cattailtops"),
                                                           LootItem.Item(1, 1, 4, "poultice-linen-horsetail"),
                                                           LootItem.Item(0.5f, 1, 12, "flaxfibers"),
                                                           LootItem.Item(0.3f, 1, 3, "honeycomb"),
                                                           LootItem.Item(1f, 2, 6, "herbbundle-basil", "herbbundle-thyme", "herbbundle-sage", "herbbundle-saffron", "herbbundle-marjoram", "herbbundle-lavender", "herbbundle-chamomile", "herbbundle-cilantro", "herbbundle-mint"),
                                                           LootItem.Item(0.3f, 2, 6, "beenade-closed")
                                                           );
     BlockLootVessel.lootLists["farming"] = LootList.Create(2.5f,
                                                            LootItem.Item(0.5f, 5, 7, "seeds-carrot", "seeds-onion", "seeds-spelt", "seeds-turnip", "seeds-rice", "seeds-rye", "seeds-soybean", "seeds-pumpkin", "seeds-cabbage"),
                                                            LootItem.Item(0.5f, 5, 7, "wildfarming:wildseeds-herb-basil", "wildfarming:wildseeds-herb-thyme", "wildfarming:wildseeds-herb-sage", "wildfarming:wildseeds-herb-chamomile", "wildfarming:wildseeds-herb-mint", "wildfarming:wildseeds-herb-saffron", "wildfarming:wildseeds-herb-marjoram", "wildfarming:wildseeds-herb-cilantro", "wildfarming:wildseeds-herb-lavender"),
                                                            LootItem.Item(0.75f, 3, 10, "feather"),
                                                            LootItem.Item(0.75f, 2, 10, "flaxfibers"),
                                                            LootItem.Item(0.35f, 2, 10, "flaxtwine"),
                                                            LootItem.Item(0.5f, 2, 6, "herbbundle-basil", "herbbundle-thyme", "herbbundle-sage", "herbbundle-saffron", "herbbundle-marjoram", "herbbundle-lavender", "herbbundle-chamomile", "herbbundle-cilantro", "herbbundle-mint"),
                                                            LootItem.Item(0.75f, 5, 10, "cattailtops"),
                                                            LootItem.Item(0.1f, 1, 1, "scythe-copper", "scythe-tinbronze")
                                                            );
 }
Ejemplo n.º 14
0
 // Token: 0x060000F5 RID: 245 RVA: 0x0000DCEC File Offset: 0x0000BEEC
 private void Update()
 {
     try
     {
         bool corpse = Config.ESP.Corpse;
         if (corpse)
         {
             bool flag = Time.time >= this._nextLootItemCacheTime && Misc.GameWorld != null && Misc.GameWorld.LootItems != null && Misc.LocalPlayer != null && !MonoBehaviourSingleton <PreloaderUI> .Instance.IsBackgroundBlackActive && Misc.MainCamera != null;
             if (flag)
             {
                 this._gameLootItems.Clear();
                 for (int i = 0; i < Misc.GameWorld.LootItems.Count; i++)
                 {
                     LootItem byIndex = Misc.GameWorld.LootItems.GetByIndex(i);
                     bool     flag2   = \uE4E3.Localized(byIndex.Item.ShortName) == "Default Inventory";
                     if (flag2)
                     {
                         bool flag3 = GameUtils.IsLootItemValid(byIndex) && Vector3.Distance(Misc.MainCamera.transform.position, byIndex.transform.position) <= 500f;
                         if (flag3)
                         {
                             this._gameLootItems.Add(new GameLootItem(byIndex));
                         }
                     }
                 }
                 this._nextLootItemCacheTime = Time.time + CorpseEsp.CacheLootItemsInterval1;
             }
             foreach (GameLootItem gameLootItem in this._gameLootItems)
             {
                 gameLootItem.RecalculateDynamics();
             }
         }
     }
     catch
     {
     }
 }
Ejemplo n.º 15
0
        public void Update()
        {
            if (!Settings.DrawLootItems)
            {
                return;
            }

            if (Time.time >= _nextLootItemCacheTime)
            {
                GameWorld gameWorld = Singleton <GameWorld> .Instance;

                if ((gameWorld != null) && (gameWorld.LootItems != null))
                {
                    _gameLootItems.Clear();

                    for (int i = 0; i < gameWorld.LootItems.Count; i++)
                    {
                        LootItem lootItem = gameWorld.LootItems.GetByIndex(i);

                        if (!GameUtils.IsLootItemValid(lootItem) || (Vector3.Distance(Camera.main.transform.position, lootItem.transform.position) > MaximumLootItemDistance))
                        {
                            continue;
                        }

                        _gameLootItems.Add(new GameLootItem(lootItem));
                    }

                    _nextLootItemCacheTime = (Time.time + CacheLootItemsInterval);
                }
            }

            foreach (GameLootItem gameLootItem in _gameLootItems)
            {
                gameLootItem.RecalculateDynamics();
            }
        }
Ejemplo n.º 16
0
	public void DisplayLootItem(LootItem item)
	{
		EditorGUILayout.Separator();
		EditorGUILayout.BeginHorizontal();
		item.itemType = (ItemType)EditorGUILayout.EnumPopup(item.itemType , GUILayout.Width(200));
		EditorGUILayout.PrefixLabel(" ID: ");
		for (int i = 0; i < item.itemID.Count; i++) 
		{
			item.itemID[i] = EditorGUILayout.IntField(item.itemID[i], GUILayout.Width(90));
		}
		if (GUILayout.Button("Add new item index", GUILayout.Width(200)))
		{
			item.itemID.Add(1);
		}

		EditorGUILayout.PrefixLabel(" itemlevel: ");
		item.itemLevel = EditorGUILayout.IntField(item.itemLevel, GUILayout.Width(90));
		EditorGUILayout.EndHorizontal();
		EditorGUILayout.BeginHorizontal();
		EditorGUILayout.PrefixLabel(" min amount: ");
		item.minQuantity = EditorGUILayout.IntField(item.minQuantity, GUILayout.Width(90));
		EditorGUILayout.PrefixLabel(" max amount: ");
		item.maxQuantity = EditorGUILayout.IntField(item.maxQuantity, GUILayout.Width(90));
		EditorGUILayout.PrefixLabel(" droprate: ");
		item.dropRate = EditorGUILayout.FloatField(item.dropRate, GUILayout.Width(90));
		EditorGUILayout.EndHorizontal();
		ConditionsUtils.Conditions(item.Conditions, Data);
	}
Ejemplo n.º 17
0
 public void AddNewLoot(LootItem loot)
 {
     lootItems.Add(loot);
 }
Ejemplo n.º 18
0
 public void AddLootByRatio(double ratio, byte container)
 {
     foreach (var i in ItemDataLists.AllItems)
     {
         if (i.Value.ValueRatio >= ratio)
         {
             LootItem lootItem = new LootItem((ushort)i.Value.Id, container, i.Value.Name);
             LootItems.Add(lootItem);
         }
     }
 }
Ejemplo n.º 19
0
        public static void Loot(LootItem loot)
        {
            if (loot != null)
            {
                if (loot.Item.Type == ItemType.Money)
                {
                    var notification = Notification.Loot("Looted GTA$" + loot.Item.MoneyValue.ToString("N0"));
                    notification.Tracking = loot.Item.MoneyValue;
                    RPG.Notify(notification);
                    PlayerData.AddMoney(loot.Item.MoneyValue);
                    loot.Destroy();
                    Game.PlaySound("FocusOut", "HintCamSounds");
                }
                else
                {
                    RPG.Notify(Notification.Loot("Looted: " + loot.Name + " x" + loot.Item.Quantity));
                    PlayerData.AddItem(loot.Item);
                    loot.Destroy();
                    Game.PlaySound("FocusOut", "HintCamSounds");
                }
            }

            RPGInfo.NearbyLoot = null;
        }
 /// <summary>
 /// Adds a weapon to the list of weapons purchased/owned by the player
 /// </summary>
 /// <param name="id">Id of the weapon to purchase</param>
 public void PurchaseWeapon(string id, LootItem weapon)
 {
     purchasedWeapons.Add(new WeaponShopSaveData(id, weapon));
 }
Ejemplo n.º 21
0
 public void AttachItem(LootItem lootItem)
 {
     image.sprite = lootItem.Icon;
 }
Ejemplo n.º 22
0
 public static void SendAllPassed(Character looter, Loot loot, LootItem item)
 {
     using (RealmPacketOut packet = new RealmPacketOut(RealmServerOpCode.SMSG_LOOT_ALL_PASSED))
         looter.Client.Send(packet, false);
 }
Ejemplo n.º 23
0
        void HandleLootMasterGive(MasterLootItem masterLootItem)
        {
            AELootResult aeResult = new();

            if (GetPlayer().GetGroup() == null || GetPlayer().GetGroup().GetLooterGuid() != GetPlayer().GetGUID() || GetPlayer().GetGroup().GetLootMethod() != LootMethod.MasterLoot)
            {
                GetPlayer().SendLootError(ObjectGuid.Empty, ObjectGuid.Empty, LootError.DidntKill);
                return;
            }

            // player on other map
            Player target = Global.ObjAccessor.GetPlayer(_player, masterLootItem.Target);

            if (!target)
            {
                GetPlayer().SendLootError(ObjectGuid.Empty, ObjectGuid.Empty, LootError.PlayerNotFound);
                return;
            }

            foreach (LootRequest req in masterLootItem.Loot)
            {
                Loot       loot     = null;
                ObjectGuid lootguid = _player.GetLootWorldObjectGUID(req.Object);

                if (!_player.IsInRaidWith(target) || !_player.IsInMap(target))
                {
                    _player.SendLootError(req.Object, ObjectGuid.Empty, LootError.MasterOther);
                    Log.outInfo(LogFilter.Cheat, $"MasterLootItem: Player {GetPlayer().GetName()} tried to give an item to ineligible player {target.GetName()} !");
                    return;
                }

                if (GetPlayer().GetLootGUID().IsCreatureOrVehicle())
                {
                    Creature creature = GetPlayer().GetMap().GetCreature(lootguid);
                    if (!creature)
                    {
                        return;
                    }

                    loot = creature.loot;
                }
                else if (GetPlayer().GetLootGUID().IsGameObject())
                {
                    GameObject pGO = GetPlayer().GetMap().GetGameObject(lootguid);
                    if (!pGO)
                    {
                        return;
                    }

                    loot = pGO.loot;
                }

                if (loot == null)
                {
                    return;
                }

                byte slotid = (byte)(req.LootListID - 1);
                if (slotid >= loot.items.Count + loot.quest_items.Count)
                {
                    Log.outDebug(LogFilter.Loot, $"MasterLootItem: Player {GetPlayer().GetName()} might be using a hack! (slot {slotid}, size {loot.items.Count})");
                    return;
                }

                LootItem item = slotid >= loot.items.Count ? loot.quest_items[slotid - loot.items.Count] : loot.items[slotid];

                List <ItemPosCount> dest = new();
                InventoryResult     msg  = target.CanStoreNewItem(ItemConst.NullBag, ItemConst.NullSlot, dest, item.itemid, item.count);
                if (!item.AllowedForPlayer(target, true))
                {
                    msg = InventoryResult.CantEquipEver;
                }
                if (msg != InventoryResult.Ok)
                {
                    if (msg == InventoryResult.ItemMaxCount)
                    {
                        _player.SendLootError(req.Object, ObjectGuid.Empty, LootError.MasterUniqueItem);
                    }
                    else if (msg == InventoryResult.InvFull)
                    {
                        _player.SendLootError(req.Object, ObjectGuid.Empty, LootError.MasterInvFull);
                    }
                    else
                    {
                        _player.SendLootError(req.Object, ObjectGuid.Empty, LootError.MasterOther);
                    }

                    return;
                }

                // now move item from loot to target inventory
                Item newitem = target.StoreNewItem(dest, item.itemid, true, item.randomBonusListId, item.GetAllowedLooters(), item.context, item.BonusListIDs);
                aeResult.Add(newitem, item.count, loot.loot_type);

                // mark as looted
                item.count     = 0;
                item.is_looted = true;

                loot.NotifyItemRemoved(slotid);
                --loot.unlootedCount;
            }

            foreach (var resultValue in aeResult.GetByOrder())
            {
                target.SendNewItem(resultValue.item, resultValue.count, false, false, true);
                target.UpdateCriteria(CriteriaType.LootItem, resultValue.item.GetEntry(), resultValue.count);
                target.UpdateCriteria(CriteriaType.GetLootByType, resultValue.item.GetEntry(), resultValue.count, (ulong)resultValue.lootType);
                target.UpdateCriteria(CriteriaType.LootAnyItem, resultValue.item.GetEntry(), resultValue.count);
            }
        }
Ejemplo n.º 24
0
    /// <summary>
    /// Add an item to the inventory.
    /// Check if the item already exists in the inventory
    /// If the item exists and is not stackable use the item
    /// immediately, if the item is a weapon fill up the clip
    /// else increment the count in the slot (= 1 if item was not in the inventory)
    /// </summary>
    /// <param name="item"></param>
    public void AddItem(LootItem item)
    {
        // Maximum amount of items that can be carried has been reached
        // We cannot add this item
        if (FreeSpace <= 0 && item.itemType != ItemType.Weapon)
        {
            Debug.Log("The maximum number of items you can carry has been reached");
            return;
        }

        bool found      = false;
        int  firstEmpty = -1;

        for (int i = 0; i < 16; i++)
        {
            if (Entries[i] == null)
            {
                if (firstEmpty == -1)
                {
                    firstEmpty = i;
                }
            }
            else if (Entries[i].Item == item)
            {
                if (Entries[i].Item.stackable)
                {
                    Entries[i].Count += 1;
                }
                else
                {
                    if (!item.UsedBy(m_Player))
                    {
                        // This is ammo, increase the count
                        Debug.Log("[Inventory] This item is not stackable but could not be used, stacking the item anyway");
                        Entries[i].Count += 1;
                        FreeSpace        -= 1;
                    }
                }
                m_Player.Experience.AddExperience(item.pickUpPoints);
                found = true;
            }
        }

        // A new item entry is done here because no such item has been found in the inventory
        if (!found && firstEmpty != -1)
        {
            if (!item.stackable)
            {
                if (item.itemType != ItemType.Weapon)
                {
                    // If this is not a weapon, try to use it before storing it
                    if (!item.UsedBy(m_Player))
                    {
                        InventoryEntry newEntry = new InventoryEntry();
                        newEntry.Item       = item;
                        newEntry.Count      = 1;
                        Entries[firstEmpty] = newEntry;
                        newEntry.Slot       = firstEmpty;

                        FreeSpace -= 1;

                        m_Player.Experience.AddExperience(item.pickUpPoints);
                        m_Player.UpdateEncumbranceUI();
                    }
                }
                else
                {
                    // This is a weapon, just store it
                    InventoryEntry newEntry = new InventoryEntry();
                    newEntry.Item       = item;
                    newEntry.Count      = 1;
                    Entries[firstEmpty] = newEntry;
                    newEntry.Slot       = firstEmpty;

                    WeaponSpace -= 1;
                    m_Player.UpdateEncumbranceUI();
                }
            }
            else
            {
                InventoryEntry entry = new InventoryEntry();
                entry.Item  = item;
                entry.Count = 1;

                Entries[firstEmpty] = entry;
                entry.Slot          = firstEmpty;
                FreeSpace          -= 1;

                m_Player.Experience.AddExperience(item.pickUpPoints);
                m_Player.UpdateEncumbranceUI();
            }
            Debug.Log("[Inventory] Done Adding");
        }
    }
Ejemplo n.º 25
0
 public void AddLootById(uint id, byte container)
 {
     if (ItemLists.AllItems.ContainsKey(id))
     {
         LootItem lootItem = new LootItem((ushort)ItemLists.AllItems[id].Id, container, ItemLists.AllItems[id].Name);
         LootItems.Add(lootItem);
     }
 }
Ejemplo n.º 26
0
        public static void HandleLootResponse(Packet packet)
        {
            var loot = new Loot();

            var guid     = packet.ReadGuid("GUID");
            var lootType = packet.ReadEnum <LootType>("Loot Type", TypeCode.Byte);

            if (lootType == LootType.Unk0)
            {
                packet.ReadByte("Slot");
                return;
            }

            loot.Gold = packet.ReadUInt32("Gold");

            var count = packet.ReadByte("Drop Count");

            byte currencyCount = 0;

            if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_0_6a_13623))
            {
                currencyCount = packet.ReadByte("Currency Count");
            }

            loot.LootItems = new List <LootItem>(count);
            for (var i = 0; i < count; ++i)
            {
                var lootItem = new LootItem();
                packet.ReadByte("Slot", i);
                lootItem.ItemId = (uint)packet.ReadEntryWithName <UInt32>(StoreNameType.Item, "Entry", i);
                lootItem.Count  = packet.ReadUInt32("Count", i);
                packet.ReadUInt32("Display ID", i);
                packet.ReadInt32("Random Suffix", i);
                packet.ReadInt32("Random Property Id", i);
                packet.ReadEnum <LootSlotType>("Slot Type", TypeCode.Byte, i);
                loot.LootItems.Add(lootItem);
            }

            for (int i = 0; i < currencyCount; ++i)
            {
                packet.ReadByte("Slot", i);
                packet.ReadInt32("Currency Id", i);
                packet.ReadInt32("Count", i); // unconfirmed
            }

            // Items do not have item id in its guid, we need to query the wowobject store go
            if (guid.GetObjectType() == ObjectType.Item)
            {
                WoWObject   item;
                UpdateField itemEntry;
                if (Storage.Objects.TryGetValue(guid, out item))
                {
                    if (item.UpdateFields.TryGetValue(UpdateFields.GetUpdateField(ObjectField.OBJECT_FIELD_ENTRY), out itemEntry))
                    {
                        Storage.Loots.Add(new Tuple <uint, ObjectType>(itemEntry.UInt32Value, guid.GetObjectType()), loot, packet.TimeSpan);
                        return;
                    }
                }
            }

            Storage.Loots.Add(new Tuple <uint, ObjectType>(guid.GetEntry(), guid.GetObjectType()), loot, packet.TimeSpan);
        }
Ejemplo n.º 27
0
 // Token: 0x0600B89F RID: 47263 RVA: 0x0011514F File Offset: 0x0011334F
 public static bool IsLootItemValid(LootItem lootItem)
 {
     return(lootItem != null && lootItem.Item != null && lootItem.Item.Template != null);
 }
Ejemplo n.º 28
0
    /// <summary>
    /// returns all possible ways to make an item from current inventory
    /// </summary>
    /// <returns>
    /// A list (paths to make the item) of lists (ingredients in the path) of LootItemQty<item required, number required>
    /// </returns>
    public List <List <LootItemQty> > findCreationPaths(LootItem result)
    {
        List <LootItemQty> lootUsed = new List <LootItemQty>();

        return(findCreationPaths(result, lootUsed));
    }
Ejemplo n.º 29
0
        private void Loot(byte number)
        {
            Container container = Core.Client.Inventory.GetContainer(number);

            if (container == null || !IsLootContainer(number))
            {
                return;
            }

            IEnumerable <Item> containterEnumerable = container.GetItems();
            List <Item>        containerItems       = containterEnumerable.ToList();

            while (containerItems.Count > 0)
            {
                Item     item     = containerItems.Last();
                LootItem lootItem = LootItems.Find(delegate(LootItem loot) { return(loot.Id == item.Id); });

                if (lootItem != null)
                {
                    if (lootItem.Container == (byte)LootContainer.Ground)
                    {
                        int startAmmount = container.Amount;

                        for (int i = 0; i < maxTries && container.Amount == startAmmount; i++)
                        {
                            item.Move(ItemLocation.FromLocation(Core.Player.Location));
                            Thread.Sleep(100);
                        }
                    }
                    else
                    {
                        Container lootContainer = null;

                        #region Select container

                        if (lootItem.Container == (byte)LootContainer.Any)
                        {
                            lootContainer = GetLootContainer(item);
                        }
                        else
                        {
                            lootContainer = Core.Client.Inventory.GetContainer(lootItem.Container);
                        }

                        #endregion

                        if (lootContainer == null)
                        {
                            continue;
                        }

                        int startAmmount = container.Amount;

                        for (int i = 0; i < maxTries && container.Amount == startAmmount; i++)
                        {
                            GetItem(item, lootContainer);
                            Thread.Sleep(100);
                        }
                    }
                }

                containerItems.Remove(item);
            }

            #region Eat Foot

            if (EatFromMonsters)
            {
                Item food = containterEnumerable.FirstOrDefault(i => ItemLists.Foods.ContainsKey(i.Id));

                if (food != null)
                {
                    for (int i = 0; i < food.Count; i++)
                    {
                        food.Use();
                        Thread.Sleep(300);
                    }
                }
            }

            #endregion

            #region Open bag / close container

            Item bag = containterEnumerable.LastOrDefault(i => i.GetFlag(Tibia.Addresses.DatItem.Flag.IsContainer));

            if (bag != null)
            {
                OpenNewContainer(bag, container.Number);
            }
            else
            {
                container.Close();
            }

            Thread.Sleep(100);

            #endregion
        }
Ejemplo n.º 30
0
    /// <summary>
    /// returns all possible ways to make an item
    /// </summary>
    /// <param name="lootUsed">The list of items already used by this recipie line</param>
    /// <returns>
    /// A list (paths to make the item)
    ///     of KeyValuePair<lists (ingredients in the path)
    ///							of LootItemQty<item required, number required>
    ///						, quantity this path can make>
    /// </returns>
    public List <KeyValuePair <List <LootItemQty>, int> > findCreationPaths(LootItem result, List <LootItemQty> lootUsed)
    {
        //create list of paths tomake the item
        List <KeyValuePair <List <LootItemQty>, int> > returnValue = new List <KeyValuePair <List <LootItemQty>, int> >();

        //loop over each basic path in the recipie list
        List <Recipie> recipiePaths = recipies.where (x => x.result == result);

        foreach (Recipie r in recipiePaths)
        {
            //default to infinite possible items to be made, then reduce based on current stock;
            int numPossible = int.MaxValue;

            foreach (LootItemQty currentIngredient in r.ingredients)
            {
                //find current stock
                LootItemQty itemInInventory = findLootInInventory(currentIngredient.item.id);
                int         numInInventory  = itemInInventory.qty;

                //take into account used up stockfrom other ingredient creation
                LootItemQty usedLoot = lootUsed.find(currentIngredient);
                if (usedLoot != null)
                {
                    numInInventory -= usedLoot.qty;
                }

                //reduce total number to be made to match inventory
                int currNumPosible = numInInventory / currIngredient.qty;
                if (currNumPossible < numPossible)
                {
                    numPossible = currNumPossible;
                }
            }

            //add basic recipie path to result set
            KeyValuePair <List <LootItemQty>, int> path = new KeyValuePair <List <LootItemQty>, int>();
            path.Key   = r.ingredients;
            path.Value = numPossible;
            returnValue.add(path);

            //note used items for sub-queries
            foreach (LootItemQty currentIngredient in r.ingredients)
            {
                LootItemQty usedLoot = lootUsed.find(currentIngredient);
                if (usedLoot != null)
                {
                    usedLoot.qty += numPossible * currentIngredient.qty;
                }
                else
                {
                    LootItemQty liq = new LootItemQty();
                    liq.item = currentIngredient.item;
                    liq.qty  = numPossible * currentIngredient.qty;
                    lootUsed.Add(liq);
                }

                //check to see if this item can be made
                List <KeyValuePair <List <LootItemQty>, int> > innerCreation = findCreationPaths(currentIngredient.Key);
                if (innerCreation.Count != 0)
                {
                    foreach (KeyValuePair <List <LootItemQty>, int> innerPath in innerCreation)
                    {
                        List <LootItemQty> newIngredients = new List <LootItemQty>();
                        foreach (LootItemQty ingredientToAdd in r.ingredients)
                        {
                            if (ingredientToAdd.Item != currentIngredient.Item)
                            {
                                newIngredients.add(ingredientToAdd);
                            }
                        }
                        foreach (List <LootItemQty> innerRecipie in innerPath.Key)
                        {
                            foreach (LootItemQty ingredientToAdd in innerRecipie)
                            {
                                newIngredients.add(ingredientToAdd);
                            }
                        }
                        KeyValuePair <List <LootItemQty>, int> newPath = new KeyValuePair <List <LootItemQty>, int>();
                        newPath.Key   = newIngredients;
                        newPath.Value = innerPath.Value;
                        returnValue.add(newIngredients);
                    }
                }
            }
        }
    }
 public void PurchaseItem(string id, LootItem item)
 {
     purchasedItems.Add(new ShopSaveData(id, item));
 }
Ejemplo n.º 32
0
    public MainWindow()
    {
        using (SqlConnection dataConnection = new SqlConnection(ConfigurationManager.AppSettings["SQL_URI"]))
        {
            dataConnection.Open();

            //load loot
            string selectLoot = @"SELECT *
								  FROM loot
								  ORDER BY id"                                ;
            using (SqlCommand comm = new SqlCommand(selectLoot, dataConnection))
            {
                using (SqlDataReader reader = comm.DataReader())
                {
                    while (reader.Read())
                    {
                        LootItem li = new LootItem();
                        li.id          = (int)reader["id"];
                        li.name        = (string)reader["name"];
                        li.description = (string)reader["description"];

                        LootItemQty liq = new LootItemQty();
                        liq.item = li;
                        liq.qty  = (int)reader["qty"];

                        loot.Add(liq);
                    }
                }
            }

            //load recipies
            string selectRecipies = @"SELECT *
									  FROM recipies
									  ORDER BY id"                                    ;
            using (SqlCommand comm = new SqlCommand(selectRecipies, dataConnection))
            {
                using (SqlDataReader reader = comm.DataReader())
                {
                    while (reader.Read())
                    {
                        Recipie r = new Recipie();
                        r.id = (int)reader["id"];

                        string selectIngredients = @"SELECT *
													 FROM recipieIngredients
													 WHERE recipieID = '"                                                     + r.id + "'";
                        using (SqlCommand commIngredients = new SqlCommand(selectIngredients, dataConnection))
                        {
                            using (SqlDataReader readerIngredients = commIngredients.DataReader())
                            {
                                while (readerIngredients.Read())
                                {
                                    LootItemQty liq = new LootItemQty();
                                    liq.item = findLootInInventory((int)reader["ingredient"]).item;
                                    liq.qty  = (int)reader["qty"];
                                    r.ingredients.add(liq);
                                }
                            }
                        }
                        LootItem result = findLootInInventory((int)reader["result"]).item;
                        r.resultQty    = (int)reader["resultQty"];
                        r.profession   = (string)reader["profession"];
                        r.crafterLevel = (string)reader["crafterLevel"];

                        recipies.Add(r);
                    }
                }
            }
        }
    }
Ejemplo n.º 33
0
        public void Update()
        {
            if (Time.time >= this.nextPlayerCacheTime)
            {
                GameWorld gameWorld = Singleton <GameWorld> .Instance;

                if ((gameWorld != null) && (gameWorld.RegisteredPlayers != null))
                {
                    this.gamePlayers.Clear();

                    foreach (Player player in gameWorld.RegisteredPlayers)
                    {
                        if (!GameUtil.IsPlayerAlive(player) || player.IsYourPlayer() || (Vector3.Distance(Camera.main.transform.position, player.Transform.position) > _maximumPlayerDistance))
                        {
                            continue;
                        }

                        this.gamePlayers.Add(new GamePlayer(player));
                    }

                    this.nextPlayerCacheTime = (Time.time + _cachePlayersInterval);
                }
            }

            if (Time.time >= this.nextLootItemCacheTime)
            {
                GameWorld gameWorld = Singleton <GameWorld> .Instance;

                if ((gameWorld != null) && (gameWorld.LootItems != null))
                {
                    this.gameLootItems.Clear();

                    for (int i = 0; i < gameWorld.LootItems.Count; i++)
                    {
                        LootItem lootItem = gameWorld.LootItems.GetByIndex(i);

                        if (!GameUtil.IsLootItemValid(lootItem) || (Vector3.Distance(Camera.main.transform.position, lootItem.transform.position) > _maximumLootItemDistance))
                        {
                            continue;
                        }

                        this.gameLootItems.Add(new GameLootItem(lootItem));
                    }

                    this.nextLootItemCacheTime = (Time.time + _cacheLootItemsInterval);
                }
            }

            foreach (GamePlayer gamePlayer in this.gamePlayers)
            {
                gamePlayer.RecalculateDynamics();
            }

            foreach (GameLootItem gameLootItem in this.gameLootItems)
            {
                gameLootItem.RecalculateDynamics();
            }

            ModuleManager.Update();

            if (Time.time >= this.nextShaderUpdateTime)
            {
                if (this.gamePlayers.Count > 0)
                {
                    foreach (GamePlayer gamePlayer in this.gamePlayers)
                    {
                        if (!GameUtil.IsPlayerAlive(gamePlayer.Player) || gamePlayer.Player.IsYourPlayer())
                        {
                            continue;
                        }

                        Color shaderColor = ((gamePlayer.IsAI) ? _botColor : _playerColor);

                        foreach (EBodyModelPart bodyModelPart in Enum.GetValues(typeof(EBodyModelPart)))
                        {
                            foreach (Renderer renderer in gamePlayer.Player.PlayerBody.BodySkins[bodyModelPart].GetRenderers())
                            {
                                Material material = renderer.material;
                                Shader   shader   = material.shader;

                                if ((shader.name == this.shader.name))
                                {
                                    continue;
                                }

                                material.shader = this.shader;

                                material.SetColor("_FirstOutlineColor", Color.red);
                                material.SetFloat("_FirstOutlineWidth", 0.02f);
                                material.SetColor("_SecondOutlineColor", shaderColor);
                                material.SetFloat("_SecondOutlineWidth", 0.0025f);
                            }
                        }
                    }

                    this.nextShaderUpdateTime = (Time.time + _shaderUpdateInterval);
                }
            }
        }
Ejemplo n.º 34
0
 private void EventPlayer(LootItem item)
 {
     EventPlayer();
 }
Ejemplo n.º 35
0
        //[WorldPacketHandler(ClientOpcodes.MasterLootItem)]
        void HandleLootMasterGive(WorldPacket packet)
        {
            ObjectGuid lootguid          = packet.ReadPackedGuid();
            byte       slotid            = packet.ReadUInt8();
            ObjectGuid target_playerguid = packet.ReadPackedGuid();

            if (GetPlayer().GetGroup() == null || GetPlayer().GetGroup().GetLooterGuid() != GetPlayer().GetGUID() || GetPlayer().GetGroup().GetLootMethod() != LootMethod.MasterLoot)
            {
                GetPlayer().SendLootError(lootguid, ObjectGuid.Empty, LootError.DidntKill);
                return;
            }

            // player on other map
            Player target = Global.ObjAccessor.GetPlayer(_player, target_playerguid);

            if (!target)
            {
                GetPlayer().SendLootError(lootguid, ObjectGuid.Empty, LootError.PlayerNotFound);
                return;
            }

            Log.outDebug(LogFilter.Network, "HandleLootMasterGive (CMSG_LOOT_MASTER_GIVE, 0x02A3) Target = [{0}].", target.GetName());

            if (GetPlayer().GetLootGUID() != lootguid)
            {
                GetPlayer().SendLootError(lootguid, ObjectGuid.Empty, LootError.DidntKill);
                return;
            }

            if (!GetPlayer().IsInRaidWith(target) || !GetPlayer().IsInMap(target))
            {
                GetPlayer().SendLootError(lootguid, ObjectGuid.Empty, LootError.MasterOther);
                Log.outInfo(LogFilter.Loot, "MasterLootItem: Player {0} tried to give an item to ineligible player {1}!", GetPlayer().GetName(), target.GetName());
                return;
            }

            Loot loot = null;

            if (GetPlayer().GetLootGUID().IsCreatureOrVehicle())
            {
                Creature creature = GetPlayer().GetMap().GetCreature(lootguid);
                if (creature == null)
                {
                    return;
                }

                loot = creature.loot;
            }
            else if (GetPlayer().GetLootGUID().IsGameObject())
            {
                GameObject pGO = GetPlayer().GetMap().GetGameObject(lootguid);
                if (pGO == null)
                {
                    return;
                }

                loot = pGO.loot;
            }

            if (loot == null)
            {
                return;
            }

            if (slotid >= loot.items.Count + loot.quest_items.Count)
            {
                Log.outDebug(LogFilter.Loot, "MasterLootItem: Player {0} might be using a hack! (slot {1}, size {2})",
                             GetPlayer().GetName(), slotid, loot.items.Count);
                return;
            }

            LootItem item = slotid >= loot.items.Count ? loot.quest_items[slotid - loot.items.Count] : loot.items[slotid];

            List <ItemPosCount> dest = new List <ItemPosCount>();
            InventoryResult     msg  = target.CanStoreNewItem(ItemConst.NullBag, ItemConst.NullSlot, dest, item.itemid, item.count);

            if (item.follow_loot_rules && !item.AllowedForPlayer(target))
            {
                msg = InventoryResult.CantEquipEver;
            }
            if (msg != InventoryResult.Ok)
            {
                if (msg == InventoryResult.ItemMaxCount)
                {
                    GetPlayer().SendLootError(lootguid, ObjectGuid.Empty, LootError.MasterUniqueItem);
                }
                else if (msg == InventoryResult.InvFull)
                {
                    GetPlayer().SendLootError(lootguid, ObjectGuid.Empty, LootError.MasterInvFull);
                }
                else
                {
                    GetPlayer().SendLootError(lootguid, ObjectGuid.Empty, LootError.MasterOther);
                }

                target.SendEquipError(msg, null, null, item.itemid);
                return;
            }

            // not move item from loot to target inventory
            Item newitem = target.StoreNewItem(dest, item.itemid, true, item.randomBonusListId, item.GetAllowedLooters(), item.context, item.BonusListIDs);

            target.SendNewItem(newitem, item.count, false, false, true);
            target.UpdateCriteria(CriteriaTypes.LootItem, item.itemid, item.count);
            target.UpdateCriteria(CriteriaTypes.LootType, item.itemid, item.count, (ulong)loot.loot_type);
            target.UpdateCriteria(CriteriaTypes.LootEpicItem, item.itemid, item.count);

            // mark as looted
            item.count     = 0;
            item.is_looted = true;

            loot.NotifyItemRemoved(slotid);
            --loot.unlootedCount;
        }
Ejemplo n.º 36
0
 public void AddLootByName(string name, byte container)
 {
     if (ItemDataLists.AllItems.ContainsKey(name))
     {
         LootItem lootItem = new LootItem((ushort)ItemDataLists.AllItems[name].Id, container, ItemDataLists.AllItems[name].Name);
         LootItems.Add(lootItem);
     }
 }