Beispiel #1
0
        private void Refinery_RetrieveVirtualItem(object a_Sender, RetrieveVirtualItemEventArgs a_QueryArgs)
        {
            MainListItem listItem = m_ItemList[a_QueryArgs.ItemIndex];

            Object[] columnData = GetListItemColumnData(listItem);

            a_QueryArgs.Item = new ListViewItem();
            ListViewItem.ListViewSubItemCollection subitems = a_QueryArgs.Item.SubItems;
            bool isQuantityOk = (m_SelectedAssets != null) && m_Engine.m_Settings.Appearance.UseAssetQuantities;

            for (int i = 0; i < (int)Columns.MaxColumns; i++)
            {
                subitems.Add(new ListViewItem.ListViewSubItem());
            }

            if (!ItemPrice.IsValidPrice((double)columnData[(int)Columns.MarketPrice]))
            {
                a_QueryArgs.Item.BackColor = Color.White;
            }
            else
            {
                a_QueryArgs.Item.BackColor = m_Engine.GetPriceColor((double)columnData[(int)Columns.RefinedCost], (double)columnData[(int)Columns.MarketPrice], isQuantityOk);
            }

            subitems[(int)Columns.Name].Text        = (string)columnData[(int)Columns.Name];
            subitems[(int)Columns.MetaLevel].Text   = columnData[(int)Columns.MetaLevel].ToString();
            subitems[(int)Columns.RefinedCost].Text = ItemPrice.FormatPrice((double)columnData[(int)Columns.RefinedCost]);
            subitems[(int)Columns.MarketPrice].Text = ItemPrice.FormatPrice((double)columnData[(int)Columns.MarketPrice]);
            subitems[(int)Columns.PriceDelta].Text  = ItemPrice.FormatPrice((double)columnData[(int)Columns.PriceDelta]);
            subitems[(int)Columns.Yield].Text       = String.Format("{0:0.00%}", (double)columnData[(int)Columns.Yield]);

            subitems[(int)Columns.Tritanium].Text = Engine.FormatDouble((double)columnData[(int)Columns.Tritanium]);
            subitems[(int)Columns.Pyerite].Text   = Engine.FormatDouble((double)columnData[(int)Columns.Pyerite]);
            subitems[(int)Columns.Mexallon].Text  = Engine.FormatDouble((double)columnData[(int)Columns.Mexallon]);
            subitems[(int)Columns.Isogen].Text    = Engine.FormatDouble((double)columnData[(int)Columns.Isogen]);
            subitems[(int)Columns.Noxcium].Text   = Engine.FormatDouble((double)columnData[(int)Columns.Noxcium]);
            subitems[(int)Columns.Zydrine].Text   = Engine.FormatDouble((double)columnData[(int)Columns.Zydrine]);
            subitems[(int)Columns.Megacyte].Text  = Engine.FormatDouble((double)columnData[(int)Columns.Megacyte]);
            subitems[(int)Columns.Morphite].Text  = Engine.FormatDouble((double)columnData[(int)Columns.Morphite]);
            subitems[(int)Columns.Quantity].Text  = String.Format("{0:#,0}", columnData[(int)Columns.Quantity]);
            subitems[(int)Columns.Type].Text      = (string)columnData[(int)Columns.Type];

            double lossPercent          = (double)columnData[(int)Columns.LossPercent];
            bool   isInvalidLossPercent = double.IsInfinity(lossPercent);

            subitems[(int)Columns.LossPercent].Text   = isInvalidLossPercent ? "" : String.Format("{0:d}%", (int)(100 * lossPercent));
            subitems[(int)Columns.Volume].Text        = Engine.FormatDouble((double)columnData[(int)Columns.Volume]);
            subitems[(int)Columns.RefinedVolume].Text = Engine.FormatDouble((double)columnData[(int)Columns.RefinedVolume]);
        }
Beispiel #2
0
        /// <summary>
        /// Gets various prices and colors for an item
        /// </summary>
        /// <param name="a_Item">Item in question</param>
        /// <param name="a_Quantity">Quantity of the item</param>
        /// <param name="a_QuantityOK">true means that quantity is valid (ie assets mode + use quantities enabled)</param>
        /// <returns>Prices and color</returns>
        public ItemPrice GetItemPrices(ItemRecord a_Item, RefiningMutators a_Mutators, UInt32 a_Quantity)
        {
            ItemPrice result = new ItemPrice();

            result.RefinedCost = GetItemRefinedPrice(a_Item, a_Mutators, a_Quantity);
            result.MarketPrice = a_Quantity * a_Item.Price;

            bool isError = false;

            if (0 == a_Item.MarketGroupID)
            {
                result.MarketPrice = ItemPrice.NonMarket;
                isError            = true;
            }
            else if (0 == result.MarketPrice)
            {
                result.MarketPrice = ItemPrice.Unknown;
                isError            = true;
            }
            else if (!a_Item.IsPricesOk(m_Settings.PriceLoad.Items.ExpiryDays))
            {
                result.MarketPrice = ItemPrice.Outdated;
                isError            = true;
            }
            else
            {
                result.PriceDelta = result.RefinedCost - result.MarketPrice;
            }

            if (isError)
            {
                result.PriceDelta = ItemPrice.Empty;
            }

            return(result);
        }
Beispiel #3
0
        private Object[] GetListItemColumnData(MainListItem a_ListItem)
        {
            Object[] result = new Object[(int)Columns.MaxColumns];

            bool   isQuantityOk = (m_SelectedAssets != null) && m_Engine.m_Settings.Appearance.UseAssetQuantities;
            UInt32 quantity     = isQuantityOk ? a_ListItem.Quantity : 1;

            bool isTotals = (a_ListItem.ItemData.TypeID == SpecialTypeID_Totals);

            if (isTotals)
            {
                quantity = 1;
            }

            lock (a_ListItem.ItemData)
            {
                ItemPrice prices = m_Engine.GetItemPrices(a_ListItem.ItemData, m_ItemsDB.GetMutators(), quantity);

                result[(int)Columns.Name]        = a_ListItem.ItemData.ItemName;
                result[(int)Columns.MetaLevel]   = a_ListItem.ItemData.MetaLevel;
                result[(int)Columns.RefinedCost] = prices.RefinedCost;
                result[(int)Columns.MarketPrice] = prices.MarketPrice;
                result[(int)Columns.PriceDelta]  = prices.PriceDelta;
                result[(int)Columns.Yield]       = m_Engine.GetEffectiveYield(a_ListItem.ItemData, m_ItemsDB.GetMutators());

                double      refinedVolume   = 0;
                Columns[]   materialColumns = new Columns[] { Columns.Tritanium, Columns.Pyerite, Columns.Mexallon, Columns.Isogen, Columns.Noxcium, Columns.Zydrine, Columns.Megacyte, Columns.Morphite };
                Materials[] columnMaterials = new Materials[] { Materials.Tritanium, Materials.Pyerite, Materials.Mexallon, Materials.Isogen, Materials.Noxcium, Materials.Zydrine, Materials.Megacyte, Materials.Morphite };
                for (int i = 0; i < materialColumns.Length; i++)
                {
                    Columns   currColumn     = materialColumns[i];
                    Materials currMaterial   = columnMaterials[i];
                    double    materialAmount = 0;

                    if (isTotals)
                    {
                        materialAmount = a_ListItem.ItemData.MaterialAmount[(UInt32)currMaterial];
                    }
                    else
                    {
                        materialAmount = m_Engine.GetEffectiveRefineQuota(a_ListItem.ItemData, m_ItemsDB.GetMutators(), quantity, currMaterial);
                    }

                    refinedVolume          += materialAmount * MaterialsInfo.GetMaterialVolume(currMaterial);
                    result[(int)currColumn] = materialAmount;
                }

                result[(int)Columns.Quantity] = a_ListItem.Quantity;
                result[(int)Columns.Type]     = a_ListItem.ItemData.TypeSortString;

                double lossPercent = 0;
                if (!ItemPrice.IsValidPrice(prices.MarketPrice))
                {
                    lossPercent = double.PositiveInfinity;
                }
                else
                {
                    lossPercent = (prices.MarketPrice - prices.RefinedCost) / prices.MarketPrice;
                }

                result[(int)Columns.LossPercent]   = lossPercent;
                result[(int)Columns.Volume]        = quantity * a_ListItem.ItemData.Volume;
                result[(int)Columns.RefinedVolume] = refinedVolume;
            }

            return(result);
        }