public void AddItemForSale(Trade t)
{
if (!itemsForSale.ContainsKey(t.Type))
itemsForSale.Add(t.Type, new TradeList());
itemsForSale[t.Type].Add(t);
itemsForSale[t.Type].Sort(TradeList.IncreasingUnitPrice);
}
public void AddItemWanted(Trade t)
{
if (!itemsWanted.ContainsKey(t.Type))
itemsWanted.Add(t.Type, new TradeList());
itemsWanted[t.Type].Add(t);
itemsWanted[t.Type].Sort(TradeList.DecreasingUnitPrice);
}
protected override void InterpretRow(Dictionary<string, string> fields)
{
float price = float.Parse(fields["price"], System.Globalization.CultureInfo.InvariantCulture);
int quantity = (int)float.Parse(fields["volRemaining"], System.Globalization.CultureInfo.InvariantCulture);
int minQuantity = (int)float.Parse(fields["minVolume"], System.Globalization.CultureInfo.InvariantCulture);
int typeId = int.Parse(fields["typeID"]);
int range = int.Parse(fields["range"]);
int regionId = int.Parse(fields["regionID"]);
int stationId = int.Parse(fields["stationID"]);
int systemId = int.Parse(fields["solarSystemID"]);
string isWanted = fields["bid"];
SolarSystem s = map.GetSystem(systemId);
Station station = map.GetStation(stationId);
ItemType type = itemDatabase.GetItemType(typeId);
if (s != null && type != null && station != null)
{
Trade trade = new Trade(type, price, quantity, minQuantity);
if (isWanted == "True")
{
// Range is in station only
if (range == -1)
{
station.AddItemWanted(trade);
if (!stationsWithItemsWanted.Contains(station))
{
stationsWithItemsWanted.Add(station);
}
}
// Range it either system or greater
else if ((range > -1) & (range < 32767))
{
foreach (SolarSystem sAtRange in s.Region.Systems)
{
if (map.DistanceBetween(s, sAtRange, false) <= range)
{
sAtRange.AddItemWanted(trade);
foreach (Station remoteStation in sAtRange.Stations)
{
if (!stationsWithItemsWanted.Contains(remoteStation))
{
stationsWithItemsWanted.Add(remoteStation);
}
}
}
}
}
// Range is regional
else if (range == 32767)
{
s.Region.AddItemWanted(trade);
foreach (SolarSystem system in s.Region.Systems)
{
foreach (Station remoteStation in system.Stations)
{
if (!stationsWithItemsWanted.Contains(remoteStation))
{
stationsWithItemsWanted.Add(remoteStation);
}
}
}
}
}
else
{
station.AddItemForSale(trade);
if (!stationsWithItemsForSale.Contains(station))
{
stationsWithItemsForSale.Add(station);
}
}
}
}
public TransactionItem(Trade tradeItem, int quantity)
{
this.tradeItem = tradeItem;
this.Quantity = quantity;
}
public TransactionItem(Trade tradeItem) : this(tradeItem, tradeItem.Quantity)
{
}
/*
internal SingleTrip GetBestTradeBetween(Station source, Station destination, ItemType type)
{
SingleTrip trade = new SingleTrip(map, source, destination);
float iskLeft = parameters.Isk;
float cargoSpaceLeft = parameters.CargoSpace;
Trade[] forSale = source.ItemsForSale[type].ToArray();
Trade[] wanted = destination.ItemsWanted[type].ToArray();
int si = 0;
int quantityBought = 1; // just to get us into the loop; it's reset after that
int quantityBoughtInTotal = 0;
trade.LimitedBy = LimitingFactor.Availability;
while (quantityBought > 0 && si < forSale.Length)
{
int quantityForSale = forSale[si].Quantity;
int quantityCanAfford = (int)Math.Truncate(iskLeft/forSale[si].UnitPrice);
int quantityCanTransport = (int)Math.Truncate(cargoSpaceLeft/forSale[si].Type.Volume);
if (quantityCanAfford == 0 || quantityCanTransport == 0)
break;
int quantityCanProfitablySell = GetProfitableSaleQuantity(forSale[si].UnitPrice, wanted, quantityBoughtInTotal);
quantityBought = 0; // reset to zero for clarity
quantityBought = Math.Min(quantityForSale, quantityCanAfford);
if(forSale[si].Type.Volume>0)
quantityBought = Math.Min(quantityBought, quantityCanTransport);
quantityBought = Math.Min(quantityBought, quantityCanProfitablySell);
if (quantityBought == quantityCanAfford)
{
trade.LimitedBy = LimitingFactor.Isk;
}
else if (quantityBought == quantityCanTransport)
{
trade.LimitedBy = LimitingFactor.CargoSpace;
}
trade.AddPurchase(new Trade(type, forSale[si].UnitPrice, quantityBought));
iskLeft -= quantityBought * forSale[si].UnitPrice;
cargoSpaceLeft -= quantityBought * forSale[si].Type.Volume;
quantityBoughtInTotal += quantityBought;
++si; // we've bought all we can from this for sale item; move to the next
}
return trade;
}
* */
int GetProfitableSaleQuantity(float unitPricePaid, Trade[] wanted, int quantityAlreadyBought)
{
int quantityToIgnore = quantityAlreadyBought;
int profitableQuantity = 0;
for (int i = 0; i < wanted.Length; ++i)
{
int quantityRemoved = Math.Min(quantityToIgnore, wanted[i].Quantity);
quantityToIgnore -= quantityRemoved;
if (quantityToIgnore == 0) // not strictly necessary, but helpful for clarity
{
if (wanted[i].UnitPrice > unitPricePaid)
{
profitableQuantity += wanted[i].Quantity - quantityRemoved;
}
}
}
return profitableQuantity;
}
public Transaction(Trade purchase, Trade sale)
{
if (purchase.Type != sale.Type)
{
throw new ArgumentException("Item types of the trade are not the same");
}
Init(purchase.Type);
this.AddPurchase(purchase);
this.AddSale(sale);
}
public void AddPurchase(Trade purchase, int qty)
{
if (type != purchase.Type)
{
throw new ArgumentException("Trade is not of the same item type as the transaction");
}
bool found = false;
foreach (TransactionItem t in purchases)
{
if (t.TradeItem == purchase)
{
t.Quantity += qty;
found = true;
break;
}
}
if (!found)
{
purchases.Add(new TransactionItem(purchase, qty));
}
upToDate = false;
}
public void AddPurchase(Trade purchase)
{
AddPurchase(purchase, purchase.Quantity);
}
public void AddSale(Trade sale)
{
AddSale(sale, sale.Quantity);
}
