/// <summary> /// Returns the number of holds each cargo object occupies /// </summary> public static float SpacePerObject(StatefulCargoTypes type) { switch (type) { case StatefulCargoTypes.LaserTurret: return(2f); case StatefulCargoTypes.Laser: return(.5f); case StatefulCargoTypes.Barge: return(25000f); case StatefulCargoTypes.Reaper: return(15000f); case StatefulCargoTypes.BattleCruiser: return(20000f); case StatefulCargoTypes.Penguin: return(12000f); case StatefulCargoTypes.Module: return(4f); case StatefulCargoTypes.DefensiveMine: return(2f); default: Console.WriteLine("SpacePerObject not implemented for this cargo of type " + type.ToString()); return(1); } }
public static bool GetCargoType(PortWareIdentifier wareType, out StatefulCargoTypes cargoType) { bool success = Enum.TryParse(wareType.ToString(), out cargoType); if (!success) { cargoType = StatefulCargoTypes.Null; } return(success); }
protected virtual void _decrementStatefulCargoCount(StatefulCargoTypes t) { if (_model.StatefulCargoCounts.ContainsKey(t)) { _model.StatefulCargoCounts[t]--; if (_model.StatefulCargoCounts[t] == 0) { _model.StatefulCargoCounts.Remove(t);//Might be excessive to remove it } } }
protected virtual void _incrementStatefulCargoCount(StatefulCargoTypes t) { if (_model.StatefulCargoCounts.ContainsKey(t)) { _model.StatefulCargoCounts[t]++; } else { _model.StatefulCargoCounts.Add(t, 1); } }
/// <summary> /// Returns an object of with matching type, if any exists in the CargoHandler, Null otherwise /// Does not remove the object. /// </summary> /// <param name="type"></param> /// <returns></returns> public virtual StatefulCargo GetAnyStatefulCargo(StatefulCargoTypes type) { var s = _model.StatefulCargo.FirstOrDefault(e => e.Value.CargoType == type); if (s.Value != null)//This might crash? { return(s.Value); } else { return(null); } }
/// <summary> /// Removes the stateful cargo with the given ID if it exists /// </summary> /// <param name="id"></param> /// <returns></returns> public virtual StatefulCargo RemoveStatefulCargo(StatefulCargoTypes type) { var s = _model.StatefulCargo.First(e => e.Value.CargoType == type); if (s.Value != null)//This might crash? { _model.StatefulCargo.Remove(s.Key); _model.FilledHolds -= Core.Models.StatefulCargo.SpacePerObject(type); _decrementStatefulCargoCount(type); _model.StatefulCargo.Remove(s.Key); return(s.Value); } else { return(null); } }
/// <summary> /// Removes the stateful cargo with the given ID if it exists /// </summary> /// <param name="id"></param> /// <returns></returns> public override StatefulCargo RemoveStatefulCargo(StatefulCargoTypes type) { var s = _model.StatefulCargo.First(e => e.Value.CargoType == type); if (s.Value != null)//This might crash? { _model.StatefulCargo.Remove(s.Key); _model.FilledHolds -= Core.Models.StatefulCargo.SpacePerObject(type); _decrementStatefulCargoCount(type); if (StatefulCargoPriceGetter != null) { SetCargoPurchasePrice(PortHelper.GetPortWareIdentifier(type), StatefulCargoPriceGetter(new StatefulCargo_RO(s.Value), GetCargoAmount(s.Value.CargoType), PriceType.PortPurchasing)); SetCargoSalePrice(PortHelper.GetPortWareIdentifier(type), StatefulCargoPriceGetter(new StatefulCargo_RO(s.Value), GetCargoAmount(s.Value.CargoType), PriceType.PortSelling)); } return(s.Value); } else { return(null); } }
/// <summary> /// TODO: consider hardcoding values, or preloading a dictionary, to avoid parsing strings? /// </summary> /// <param name="cargoType"></param> /// <returns></returns> public static PortWareIdentifier GetPortWareIdentifier(StatefulCargoTypes cargoType) { PortWareIdentifier identifier; return(Enum.TryParse(cargoType.ToString(), out identifier) ? identifier : PortWareIdentifier.Null); }
public int GetCargoAmount(StatefulCargoTypes type) { return(_model.StatefulCargoCounts[type]); }
public virtual bool CheckCargoSpace(StatefulCargoTypes type, int quantity) { float spaceOccupied = 0; return(CheckCargoSpace(type, quantity, ref spaceOccupied)); }
public virtual bool CheckCargoSpace(StatefulCargoTypes type, int quantity, ref float spaceOccupied) { spaceOccupied += Core.Models.StatefulCargo.SpacePerObject(type) * quantity; return(spaceOccupied <= _model.TotalHolds - _model.FilledHolds); }
/// <summary> /// Returns true if the specified quantity of StatefulCargo with matching type exists. /// </summary> /// <param name="type"></param> /// <returns></returns> public virtual bool IsCargoInHolds(StatefulCargoTypes type, int quantity) { return(_model.StatefulCargo.Select(c => { return c.Value.CargoType == type; }).Count() >= quantity); }
public float GetPrice(StatefulCargoTypes cargoType, int quantity, PortTradeDirection direction) { var identifier = PortHelper.GetPortWareIdentifier(cargoType); return(GetPrice(identifier, quantity, direction)); }
public StatefulCargo(int ID, StatefulCargoTypes type) { IsForSale = true; _model.Id = ID; CargoType = type; }
public override bool CheckCargoSpace(StatefulCargoTypes type, int quantity) { return(true); }
/// <summary> /// Set cargoID to null if transaction applies to first cargo found in IHasCargo object /// </summary> /// <param name="objectID"></param> /// <param name="cargoType"></param> /// <param name="cargoID"></param> /// <param name="transferToNextTransaction">If true, and this transaction occurs as part of a SequentialTransaction, and the next transaction is of type AddStatefulCargo, then the cargo object removed by this transaction will serve as the Cargo added in the subsequent AddStatefulCargoTransaction</param> public TransactionRemoveStatefulCargo(IHasCargo donor, StatefulCargoTypes cargoType, int?cargoID, bool transferToNextTransaction = false) : base(donor, CargoTransactionTypes.RemoveStatefulCargo) { CargoType = cargoType; CargoID = cargoID; TransferToNextTransaction = transferToNextTransaction; }