public virtual CargoResult AddStatefulCargo(StatefulCargo c, bool suspendBoundsChecking) { #if !ADMIN if (suspendBoundsChecking || CheckCargoSpace(c.CargoType, 1)) { #endif if (!_model.StatefulCargo.ContainsKey(c.Id)) { _model.StatefulCargo.Add(c.Id, c); _model.FilledHolds += StatefulCargo.SpacePerObject(c.CargoType); _incrementStatefulCargoCount(c.CargoType); return(CargoResult.Success); } else { return(CargoResult.StatefulCargoIDAlreadyAdded); } #if !ADMIN } else { return(CargoResult.NotEnoughCargoSpace); } #endif }
public static StatefulCargo InstantiateStatefulCargo(StatefulCargoData data) { StatefulCargo c = null; switch (data.CargoType) { case StatefulCargoTypes.LaserTurret: { c = new CargoLaserTurret(data.Id, ((CargoLaserTurretData)data).Health, new LaserWeaponStats()); break; } case StatefulCargoTypes.DefensiveMine: { c = new StatefulCargo(data.Id, StatefulCargoTypes.DefensiveMine); break; } case StatefulCargoTypes.Module: { c = InstantiateModule((CargoModuleData)data); break; } default: Console.WriteLine("StatefulCargoType " + data.CargoType.ToString() + " not implemented in ReadNewShip."); break; } return(c); }
public override CargoResult Process() { if (CargoID != null) { RemovedCargo = _cargoHandler.RemoveStatefulCargo((int)CargoID); } else { RemovedCargo = _cargoHandler.RemoveStatefulCargo(CargoType); } if (RemovedCargo != null) { ResultCompletionSource.SetResult(CargoResult.Success); } else { ResultCompletionSource.SetResult(CargoResult.CargoNotInHolds); } if (!IsInSequence && ResultTask.Result == CargoResult.Success) { CloseTransaction(); } return(ResultTask.Result); }
public override CargoResult AddStatefulCargo(StatefulCargo c, bool suspendBoundsChecking) { _model.StatefulCargo.Add(c.Id, c); _model.FilledHolds += StatefulCargo.SpacePerObject(c.CargoType); _incrementStatefulCargoCount(c.CargoType); if (StatefulCargoPriceGetter != null) { SetCargoPurchasePrice(PortHelper.GetPortWareIdentifier(c.CargoType), StatefulCargoPriceGetter(new StatefulCargo_RO(c), GetCargoAmount(c.CargoType), PriceType.PortPurchasing)); SetCargoSalePrice(PortHelper.GetPortWareIdentifier(c.CargoType), StatefulCargoPriceGetter(new StatefulCargo_RO(c), GetCargoAmount(c.CargoType), PriceType.PortSelling)); } PortWareIdentifier identifier; if (c.CargoType == StatefulCargoTypes.Module) { _model.UIComponent.Modules.Add(c.Id, UIHelper.GetUIData((Module)c)); } else if (Enum.TryParse(c.CargoType.ToString(), out identifier)) { UpdateGoodCounts(identifier, +1); UpdateUIStatLists(identifier, c, true); } return(CargoResult.Success); }
/// <summary> /// For structures which originate as StatefulCargo, as they already have a GalaxyID /// </summary> /// <param name="c"></param> /// <returns></returns> public static IStructure CreateStructure(StatefulCargo c, float xPos, float yPos, Player owner, CommandCenter commandCenter, int currentAreaID, IPlayerLocator pl) { IStructure s; switch (c.CargoType) { case (StatefulCargoTypes.LaserTurret): { TurretTypes t = owner.GetArea().AreaType == AreaTypes.Planet ? TurretTypes.Planet : TurretTypes.Space; s = new Turret(c.Id, xPos, yPos, owner.Id, currentAreaID, t, pl); break; } case (StatefulCargoTypes.DefensiveMine): { s = new DefensiveMine(xPos, yPos, c.Id, owner.Id, currentAreaID, pl); break; } default: throw new Exception("CreateStructure not implemented for structure type " + c.CargoType.ToString()); } _galaxyRegistrationManager.RegisterObject(s); return(s); }
public virtual bool CheckCargoSpace(Dictionary <StatefulCargoTypes, float> typesAndQuantities, ref float spaceOccupied) { foreach (var t in typesAndQuantities) { spaceOccupied += StatefulCargo.SpacePerObject(t.Key) * (int)t.Value; } return(spaceOccupied <= _model.TotalHolds - _model.FilledHolds); }
public virtual bool CheckCargoSpace(IEnumerable <StatefulCargo> statefulCargo, ref float spaceOccupied) { foreach (var s in statefulCargo) { spaceOccupied += StatefulCargo.SpacePerObject(s.CargoType); } return(spaceOccupied <= _model.TotalHolds - _model.FilledHolds); }
/// <summary> /// Leave cargoObject null to chain to a previous transaction in a sequence. /// </summary> /// <param name="recipient"></param> /// <param name="cargoObject"></param> /// <param name="suspendBoundsChecking"></param> public TransactionAddStatefulCargo(IHasCargo recipient, StatefulCargo cargoObject, bool suspendBoundsChecking) : base(recipient, CargoTransactionTypes.AddStatefulCargo) { if (cargoObject != null) { CargoType = cargoObject.CargoType; } CargoObject = cargoObject; }
/// <summary> /// Removes the stateful cargo with the given ID if it exists /// </summary> /// <param name="id"></param> /// <returns></returns> public virtual StatefulCargo RemoveStatefulCargo(int id) { if (_model.StatefulCargo.ContainsKey(id)) { StatefulCargo s = _model.StatefulCargo[id]; _model.FilledHolds -= Core.Models.StatefulCargo.SpacePerObject(s.CargoType); _decrementStatefulCargoCount(s.CargoType); _model.StatefulCargo.Remove(id); return(s); } else { return(null); } }
/// <summary> /// For structures which originate as StatefulCargo, as they already have a GalaxyID /// </summary> /// <param name="c"></param> /// <returns></returns> public static IStructure CreateStructure(StatefulCargo c, float xPos, float yPos, Player owner, CommandCenter commandCenter, int currentAreaID, IPlayerLocator pl) { IStructure s; switch (c.Type) { case (StatefulCargoTypes.LaserTurret): s = new Turret(_localIDManager.PopFreeID(), xPos, yPos, owner, commandCenter, currentAreaID, pl); break; default: throw new Exception("CreateStructure not implemented for structure type " + c.Type.ToString()); } _galaxyRegistrationManager.RegisterObject(s); return(s); }
/// <summary> /// Notifies a player, if online, of a module added to his ship /// </summary> /// <param name="sender"></param> /// <param name="transaction"></param> public void NotifyCargoAdded(object sender, ITransactionAddStatefulCargo transaction) { if (transaction.CargoHolder is IShip) { IShip s = transaction.CargoHolder as IShip; Player p = s.GetPlayer(); if (p.IsOnline) { StatefulCargo m = transaction.CargoObject; MessageAddCargoToShip data = new MessageAddCargoToShip(); data.ShipID = s.Id; data.StatefulCargoData.Add(m.GetNetworkObject()); p.SendMessage(new NetworkMessageContainer(data, MessageTypes.AddCargoToShip)); } } }
/// <summary> /// Adds if addOrRemove is true, removes otherwise /// </summary> /// <param name="statefulCargo"></param> /// <param name="addOrRemove"></param> void UpdateUIStatLists(PortWareIdentifier portGoodIdentifier, StatefulCargo statefulCargo, bool addOrRemove) { if (addOrRemove) { if (!_model.UIComponent.Goods.ContainsKey(portGoodIdentifier)) { _model.UIComponent.Goods.Add(portGoodIdentifier, UIHelper.GetUIData(statefulCargo)); } } else { if (_model.UIComponent.Goods.ContainsKey(portGoodIdentifier)) { _model.UIComponent.Goods.Remove(portGoodIdentifier); } } }
/// <summary> /// Removes the stateful cargo with the given ID if it exists /// </summary> /// <param name="id"></param> /// <returns></returns> public override StatefulCargo RemoveStatefulCargo(int id) { if (_model.StatefulCargo.ContainsKey(id)) { StatefulCargo s = _model.StatefulCargo[id]; _model.FilledHolds -= Core.Models.StatefulCargo.SpacePerObject(s.CargoType); _decrementStatefulCargoCount(s.CargoType); if (StatefulCargoPriceGetter != null) { SetCargoPurchasePrice(PortHelper.GetPortWareIdentifier(s.CargoType), StatefulCargoPriceGetter(new StatefulCargo_RO(s), GetCargoAmount(s.CargoType), PriceType.PortPurchasing)); SetCargoSalePrice(PortHelper.GetPortWareIdentifier(s.CargoType), StatefulCargoPriceGetter(new StatefulCargo_RO(s), GetCargoAmount(s.CargoType), PriceType.PortSelling)); } PortWareIdentifier identifier = PortHelper.GetPortWareIdentifier(s.CargoType); if (s.CargoType == StatefulCargoTypes.Module) { _model.UIComponent.Modules.Remove(id); } else if (identifier != PortWareIdentifier.Null) { UpdateGoodCounts(identifier, -1); UpdateUIStatLists(identifier, s, false); if (!_model.PortGoodCounts.ContainsKey(identifier))//UpdateGoodCounts will have removed the key if no more goods of this type are in the inventory { _model.Prices_ShipSaleToPort.Remove(identifier); } } return(s); } else { return(null); } }
public virtual bool IsCargoInHolds(StatefulCargo c) { return(_model.StatefulCargo.ContainsKey(c.Id)); }
/// <summary> /// DON'T USE THIS EVER FOR ANYTHING UNDER ANY CIRCUMSTANCES /// </summary> /// <returns></returns> public void CHEATADDCARGO(StatefulCargo c) { //Adds without checking or changing capacity. Cheap way to f**k around with "infinite" holds. Will remove eventually. _model.StatefulCargo.Add(c.Id, c); }
async Task FillPorts(GalaxyManager galaxyManager, LocalIDManager galaxyIDManager, CargoSynchronizer cargoSynchronizer) { var ports = galaxyManager.GetAllAreas().Where(a => a.AreaType == AreaTypes.Port); CargoTransaction lastTransaction = null; foreach (var p in ports) { var port = p as Port; foreach (var s in _config.PortConfig.StatefulCargoCounts) { StatefulCargo sc; for (int i = 0; i < s.Value; i++)//Yes, this loop is lazy, but it's 11:30PM... { //TODO: make a StatefulCargoFactory switch (s.Key) { case StatefulCargoTypes.Barge: { sc = new CargoShip(galaxyIDManager.PopFreeID(), 666, ShipStats[ShipTypes.Barge]); break; } case StatefulCargoTypes.BattleCruiser: { sc = new CargoShip(galaxyIDManager.PopFreeID(), 666, ShipStats[ShipTypes.BattleCruiser]); break; } case StatefulCargoTypes.Penguin: { sc = new CargoShip(galaxyIDManager.PopFreeID(), 666, ShipStats[ShipTypes.Penguin]); break; } case StatefulCargoTypes.Reaper: { sc = new CargoShip(galaxyIDManager.PopFreeID(), 666, ShipStats[ShipTypes.Reaper]); break; } case StatefulCargoTypes.LaserTurret: { sc = new CargoLaserTurret(galaxyIDManager.PopFreeID(), 666, new LaserWeaponStats()); break; } default: { sc = new StatefulCargo(galaxyIDManager.PopFreeID(), s.Key); break; } } CargoTransaction tr = new TransactionAddStatefulCargo(port, sc, true); cargoSynchronizer.RequestTransaction(tr); lastTransaction = tr; } } foreach (var s in _config.PortConfig.StatelessCargoCounts) { var tr = new TransactionAddStatelessCargo(port, s.Key, s.Value, true); cargoSynchronizer.RequestTransaction(tr); lastTransaction = tr; } foreach (var s in _config.PortConfig.ModuleCounts) { Module m = ModuleFactory.CreateModule(s.Key, galaxyIDManager.PopFreeID(), 1); var tr = new TransactionAddStatefulCargo(port, m, true); cargoSynchronizer.RequestTransaction(tr); lastTransaction = tr; } } if (lastTransaction != null) { await lastTransaction.ResultTask; } }
/// <summary> /// Set isPlayerShip if this is the client's ship, false otherwise. /// </summary> /// <param name="msg"></param> /// <param name="world"></param> /// <param name="clientShipManager"></param> /// <param name="isPlayerShip"></param> /// <returns></returns> public static Ship InstantiateShip(ShipData data, World world, ClientShipManager clientShipManager, bool isPlayerShip) { ShipStats stats = new ShipStats(); if (data.ShipStats != null) { stats = new ShipStats(data.ShipStats); } Vector2 position = new Vector2(data.PosX, data.PosY); Vector2 velocity = new Vector2(data.VelX, data.VelY); Ship newShip = null; if (!isPlayerShip) { newShip = clientShipManager.CreateShip(world, data.IsNPC, position, data.Id, data.Rotation, velocity, data.PlayerName, stats, data.WeaponTypes, data.TeamIDs); } else { if (data.PlayerID == null) { throw new NotImplementedException("Null playerID not yet implemented on the client."); } newShip = clientShipManager.CreatePlayerShip(world, position, data.Id, data.Rotation, velocity, data.PlayerName, stats, data.WeaponTypes, data.TeamIDs); } newShip.CurrentHealth = (int)data.CurrentHealth; newShip.Shields.CurrentShields = (int)data.CurrentShields; #region Cargo if (data.Cargo != null) { foreach (var sc in data.Cargo.StatelessCargo) { newShip.Cargo.AddStatelessCargo(sc.CargoType, sc.Quantity, true); } foreach (var sc in data.Cargo.StatefulCargo) { StatefulCargo c = InstantiateStatefulCargo(sc); switch (c.CargoType) { case StatefulCargoTypes.Module: { newShip.AddModule((Module)c); newShip.Cargo.AddStatefulCargo(c, true); break; } default: { newShip.Cargo.AddStatefulCargo(c, true); break; } } } newShip.RecalculateModuleBonuses(); } #endregion newShip.MissileLauncher?.SetMissileType(data.SelectedMissileType); newShip.Pilot.IsAlive = !data.IsDead; return(newShip); }