コード例 #1
0
        public static ItemsByMaterial On_ItemsByQuality_ItemsOfQualityOrHigher(ItemsByQuality self, ItemQuality itemQuality)
        {
            var items = myClasses[self];

            if (itemQuality == ItemQuality.Any)
            {
                itemQuality = ItemQuality.Poor;
            }
            ItemsByMaterial itemsByMaterial = new ItemsByMaterial();

            foreach (KeyValuePair <ItemQuality, LargeItemsByMaterial> current in items)
            {
                if (current.Key >= itemQuality)
                {
                    foreach (KeyValuePair <int, HashSet <Item> > current2 in current.Value.Items)
                    {
                        List <Item> list;
                        if (itemsByMaterial.Items.TryGetValue(current2.Key, out list))
                        {
                            itemsByMaterial.Items[current2.Key] = itemsByMaterial.Items[current2.Key].Concat(current2.Value).ToList <Item>();
                        }
                        else
                        {
#warning have to find a performant way to replace this, likely by replacing lots a stockmanager funcs
                            itemsByMaterial.Items.Add(current2.Key, current2.Value);
                        }
                    }
                }
            }
            return(itemsByMaterial);
        }
コード例 #2
0
        public static void On_ItemsByQuality_AddItem(ItemsByQuality self, ItemQuality quality, int material)
        {
            var items = myClasses[self];
            LargeItemsByMaterial itemsByMaterial = null;

            if (!items.TryGetValue(quality, out itemsByMaterial))
            {
                itemsByMaterial = new LargeItemsByMaterial();
                items[quality]  = itemsByMaterial;
            }
            itemsByMaterial.AddItem(material);
        }
コード例 #3
0
        public static bool On_StockManager_AreItemsAvailable(StockManager self, Vector3 pos, ItemID itemID, uint quantity, int material, ItemQuality itemQuality, bool atLeastQuality)
        {
            if (GnomanEmpire.Instance.Map.GetCell(pos).NavGraphNode == null)
            {
                return(false);
            }
            ItemsByQuality itemsByQuality = ((ItemsByQuality[])StockManager_ItemsByQuality_InStockItems.GetValue(self))[(int)itemID];

            if (itemsByQuality == null)
            {
                return(false);
            }
            ItemsByMaterial itemsByMaterial = itemsByQuality.ItemsOfQuality(itemQuality, atLeastQuality);

            return(itemsByMaterial != null && itemsByMaterial.AreItemsAvailable(pos, quantity, material));
        }
コード例 #4
0
        public static ItemsByMaterial On_ItemsByQuality_ItemsOfQuality(ItemsByQuality self, ItemQuality quality, bool atLeast)
        {
            if (quality == ItemQuality.Any)
            {
                return(self.AllItems());
            }
            if (atLeast)
            {
                return(self.ItemsOfQualityOrHigher(quality));
            }
            LargeItemsByMaterial result;

            if (myClasses[self].TryGetValue(quality, out result))
            {
                return(result.ToItemsByMaterial());
            }
            return(null);
        }
コード例 #5
0
        public static int On_StockManager_QuantityInStock(StockManager self, ItemID itemID, int material)
        {
            ItemsByQuality itemsByQuality = ((ItemsByQuality[])StockManager_ItemsByQuality_InStockItems.GetValue(self))[(int)itemID];

            if (itemsByQuality == null)
            {
                return(0);
            }
            var largeItems = myClasses[itemsByQuality];

            if (largeItems == null)
            {
                return(0);
            }
            var count = 0;

            foreach (var cat in largeItems)
            {
                if (material == 80)
                {
                    foreach (var list in cat.Value.Items)
                    {
                        count += list.Value.Count;
                    }
                }
                else
                {
                    HashSet <Item> list;
                    if (cat.Value.Items.TryGetValue(material, out list))
                    {
                        count += list.Count;
                    }
                }
            }
            return(count);
        }
コード例 #6
0
        public static bool On_StockManager_IsItemInStocks(StockManager self, Item item)
        {
            var inStockItems = (ItemsByQuality[])StockManager_ItemsByQuality_InStockItems.GetValue(self);

            ItemsByQuality itemsByQuality = inStockItems[(int)item.ItemID];

            if (itemsByQuality == null)
            {
                return(false);
            }
            var items = myClasses[itemsByQuality];

            foreach (var el in items)
            {
                foreach (var el2 in el.Value.Items)
                {
                    if (el2.Value.Contains(item))
                    {
                        return(true);
                    }
                }
            }
            return(false);
        }
コード例 #7
0
        public static bool On_ItemsByQuality_RemoveItem(ItemsByQuality self, Item item)
        {
            LargeItemsByMaterial itemsByMaterial = null;

            return(myClasses[self].TryGetValue(item.Quality, out itemsByMaterial) && itemsByMaterial.RemoveItem(item));
        }
コード例 #8
0
 public static int On_ItemsByQuality_QuantityInStock(ItemsByQuality self, ItemQuality quality)
 {
     throw new Exception("Thought this function is not used!?");
 }
コード例 #9
0
        public static Dictionary <ItemQuality, ItemsByMaterial> Get_ItemsByQuality_Items(ItemsByQuality self)
        {
            var result = new Dictionary <ItemQuality, ItemsByMaterial>();

            foreach (var el in myClasses[self])
            {
                result.Add(el.Key, el.Value.ToItemsByMaterial());
            }
            return(result);
        }
コード例 #10
0
 public static bool On_ItemsByQuality_RemoveItem(ItemsByQuality self, Item item)
 {
     LargeItemsByMaterial itemsByMaterial = null;
     return myClasses[self].TryGetValue(item.Quality, out itemsByMaterial) && itemsByMaterial.RemoveItem(item);
 }
コード例 #11
0
        public DataTable FindItems(IList <ItemID> itemIDs, GameLibrary.ItemQuality quality)
        {
            if (_gnomanEmpire == null)
            {
                throw new InvalidOperationException("You must LoadGame() prior to FindItems()");
            }

            Dictionary <string, List <Item> > searchResult = null;
            ItemsByQuality resultByQuality = null;

            DataTable itemTable = new DataTable("items");

            DataColumn cNum = new DataColumn("Num", typeof(string));

            itemTable.PrimaryKey = new DataColumn[] { itemTable.Columns.Add(cNum.ColumnName) };

            itemTable.Columns.Add("Name", typeof(string));
            itemTable.Columns.Add("Material", typeof(string));
            itemTable.Columns.Add("Quality", typeof(string));
            itemTable.Columns.Add("Location type", typeof(string));
            itemTable.Columns.Add("Location", typeof(string));
            itemTable.Columns.Add("Position", typeof(string));

            // When no object matches, the result can be null, or contain only empty lists.
            foreach (ItemID itemID in itemIDs)
            {
                resultByQuality = _gnomanEmpire.Fortress.StockManager.ItemsByQuality(itemID.ToString());
                if (resultByQuality != null)
                {
                    searchResult = resultByQuality.ItemsOfQualityOrHigher(quality).Items;
                }
                else
                {
                    searchResult = null;
                }
                if (searchResult != null)
                {
                    foreach (var valuePair in searchResult)
                    {
                        List <Game.Item> list = valuePair.Value;
                        foreach (Game.Item item in list)
                        {
                            DataRow tmpRow = itemTable.NewRow();
                            int     col    = 0;

                            // Base attributes
                            tmpRow[col++] = item.ID;
                            tmpRow[col++] = Item.GroupName(item.ItemID);// item.Name();
                            tmpRow[col++] = item.MaterialName();
                            tmpRow[col++] = item.Quality;

                            // Parent type and parent
                            if (item.Parent != null)
                            {
                                if (item.Parent is Game.Character)
                                {
                                    tmpRow[col++] = "Gnome";
                                }
                                else if (item.Parent is Game.StorageContainer)
                                {
                                    tmpRow[col++] = "Container";
                                }
                                else
                                {
                                    tmpRow[col++] = "?"; // Default catcher. Could be monster?
                                }
                                tmpRow[col++] = item.Parent.Name();
                            }
                            else
                            {
                                tmpRow[col++] = "Ground";
                                tmpRow[col++] = "";
                            }

                            tmpRow[col++] = item.Position.ToString();

                            itemTable.Rows.Add(tmpRow);
                        }
                    }
                }
            }

            return(itemTable);
        }
コード例 #12
0
 public static int On_ItemsByQuality_QuantityInStock(ItemsByQuality self, ItemQuality quality)
 {
     throw new Exception("Thought this function is not used!?");
 }
コード例 #13
0
        public static ItemsByMaterial On_ItemsByQuality_ItemsOfQualityOrHigher(ItemsByQuality self, ItemQuality itemQuality)
        {
            var items = myClasses[self];
            if (itemQuality == ItemQuality.Any)
            {
                itemQuality = ItemQuality.Poor;
            }
            ItemsByMaterial itemsByMaterial = new ItemsByMaterial();
            foreach (KeyValuePair<ItemQuality, LargeItemsByMaterial> current in items)
            {
                if (current.Key >= itemQuality)
                {
                    foreach (KeyValuePair<int, HashSet<Item>> current2 in current.Value.Items)
                    {
                        List<Item> list;
                        if (itemsByMaterial.Items.TryGetValue(current2.Key, out list))
                        {
                            itemsByMaterial.Items[current2.Key] = itemsByMaterial.Items[current2.Key].Concat(current2.Value).ToList<Item>();
                        }
                        else
                        {
#warning have to find a performant way to replace this, likely by replacing lots a stockmanager funcs
                            itemsByMaterial.Items.Add(current2.Key, current2.Value);
                        }
                    }
                }
            }
            return itemsByMaterial;
        }
コード例 #14
0
 public static ItemsByMaterial On_ItemsByQuality_ItemsOfQuality(ItemsByQuality self, ItemQuality quality, bool atLeast)
 {
     if (quality == ItemQuality.Any)
     {
         return self.AllItems();
     }
     if (atLeast)
     {
         return self.ItemsOfQualityOrHigher(quality);
     }
     LargeItemsByMaterial result;
     if (myClasses[self].TryGetValue(quality, out result))
     {
         return result.ToItemsByMaterial();
     }
     return null;
 }
コード例 #15
0
 public static void On_ItemsByQuality_AddItem(ItemsByQuality self, ItemQuality quality, int material)
 {
     var items = myClasses[self];
     LargeItemsByMaterial itemsByMaterial = null;
     if (!items.TryGetValue(quality, out itemsByMaterial))
     {
         itemsByMaterial = new LargeItemsByMaterial();
         items[quality] = itemsByMaterial;
     }
     itemsByMaterial.AddItem(material);
 }
コード例 #16
0
 public static Dictionary<ItemQuality, ItemsByMaterial> Get_ItemsByQuality_Items(ItemsByQuality self)
 {
     var result = new Dictionary<ItemQuality, ItemsByMaterial>();
     foreach (var el in myClasses[self])
     {
         result.Add(el.Key, el.Value.ToItemsByMaterial());
     }
     return result;
 }