/// <summary>
/// receivingPlayers get mines in cargo, owningPlayers get the mines added to the receivingSystems (deployed in space)
/// </summary>
/// <param name="receivingPlayers"></param>
/// <param name="receivingSystems"></param>
/// <param name="owningPlayers"></param>
void AddMines(IEnumerable <Player> receivingPlayers, IEnumerable <PSystem> receivingSystems, IEnumerable <Player> owningPlayers, CargoSynchronizer cargoSynchronizer, GalaxyManager galaxyManager, LocalIDManager galaxyIDManager, StructureManager structureManager, LocatorService locatorService)
{
foreach (Player p in receivingPlayers)
{
for (int i = 0; i < _config.CARGO_NumMines; i++)
{
TransactionAddStatefulCargo t = new TransactionAddStatefulCargo(p.GetActiveShip(), new StatefulCargo(galaxyIDManager.PopFreeID(), StatefulCargoTypes.DefensiveMine), true);
cargoSynchronizer.RequestTransaction(t);
}
}
if (owningPlayers.Count() < 2)
{
return;
}
var itr = new CyclicalIterator <Player>(owningPlayers);
itr.MoveNext();
foreach (var system in galaxyManager.Systems)
{
for (int i = 0; i < _config.NumMinesPerSystem; i++)
{
int ownerID = itr.Current.Id;
var mine = new DefensiveMine(Rand.Random.Next(-system.AreaSize / 100, system.AreaSize / 100), Rand.Random.Next(-system.AreaSize / 100, system.AreaSize / 100), galaxyIDManager.PopFreeID(), ownerID, system.Id, locatorService.PlayerLocator);
structureManager.RegisterObject(mine);
system.AddStructure(mine);
itr.MoveNext();
}
}
}
/// <summary>
/// Converts from Constructables, if ready, to a cargo object, adding the cargo object to the factory's cargo.
/// </summary>
/// <param name="f"></param>
/// <returns></returns>
async Task _handleFactoryConstruction(Factory f)
{
CargoTransaction tr = null;
switch (f.CompletedPendingInstantiation)
{
case Constructables.Null:
tr = null;
break;
case Constructables.LaserTurret:
{
CargoLaserTurret t = new CargoLaserTurret(_galaxyIDManager.PopFreeID(), 666, new LaserWeaponStats());
tr = new TransactionAddStatefulCargo(f, t, false);
_cargoSynchronizer.RequestTransaction(tr);
await tr.ResultTask;
break;
}
}
if (tr != null && tr.ResultTask.Result == CargoResult.Success)
{
f.CompletedPendingInstantiation = Constructables.Null;
}
}
public void AddModulesToShip(IShip ship, int numMods, CargoSynchronizer cargoSynchronizer, LocalIDManager galaxyIDManager)
{
for (int i = 0; i < numMods; i++)
{
Module m = null;
int moduleID = galaxyIDManager.PopFreeID();
byte level = (byte)Rand.Random.Next(1, 4);
int modnum = Rand.Random.Next(1, 11);
{
switch (modnum)
{
case 1:
m = new EnergyRegenModule(moduleID, level);
break;
case 2:
m = new ThrustModule(moduleID, level);
break;
case 3:
m = new MaxShieldModule(moduleID, level);
break;
case 4:
m = new ShieldRegenModule(moduleID, level);
break;
case 5:
m = new MaxEnergyModule(moduleID, level);
break;
case 6:
m = new DamageModule(moduleID, level);
break;
case 7:
m = new DefenseModule(moduleID, level);
break;
case 8:
m = new TurnRateModule(moduleID, level);
break;
case 9:
m = new LateralThrustModule(moduleID, level);
break;
case 10:
m = new TopSpeedModule(moduleID, level);
break;
}
}
TransactionAddStatefulCargo str = new TransactionAddStatefulCargo(ship, m, true);
str.OnCompletion += ship.CargoAdded;
cargoSynchronizer.RequestTransaction(str);
}
}
async Task AddCargoToPlayerShips(IEnumerable <IShip> ships, ILocalIDManager galaxyIDManager, GalaxyRegistrationManager registrationManager, CargoSynchronizer cargoSynchronizer)
{
//Making this into a grand test of transaction sequences, there's really no reason to put this all into one sequence
CargoTransactionSequence cs = new CargoTransactionSequence();
foreach (var s in ships)
{
for (int i = 0; i < _config.CARGO_NumTurrets; i++)//Sending ship state over a network might be painful while this is here...
{
CargoLaserTurret c = new CargoLaserTurret(galaxyIDManager.PopFreeID(), 666, new LaserWeaponStats());
TransactionAddStatefulCargo t = new TransactionAddStatefulCargo(s, c, true);
cs.Add(t);
registrationManager.RegisterObject(c);
}
TransactionAddStatelessCargo tr = new TransactionAddStatelessCargo(s, StatelessCargoTypes.AmbassadorMissile, _config.CARGO_NumMissiles, true);
cs.Add(tr);
tr = new TransactionAddStatelessCargo(s, StatelessCargoTypes.HellHoundMissile, _config.CARGO_NumMissiles, true);
cs.Add(tr);
tr = new TransactionAddStatelessCargo(s, StatelessCargoTypes.MissileType1, _config.CARGO_NumMissiles, true);
cs.Add(tr);
tr = new TransactionAddStatelessCargo(s, StatelessCargoTypes.MissileType2, _config.CARGO_NumMissiles, true);
cs.Add(tr);
tr = new TransactionAddStatelessCargo(s, StatelessCargoTypes.MissileType3, _config.CARGO_NumMissiles, true);
cs.Add(tr);
tr = new TransactionAddStatelessCargo(s, StatelessCargoTypes.MissileType4, _config.CARGO_NumMissiles, true);
cs.Add(tr);
tr = new TransactionAddStatelessCargo(s, StatelessCargoTypes.Biodome, _config.CARGO_NumBiodomes, true);
cs.Add(tr);
}
cargoSynchronizer.RequestAtomicTransactionSequence(cs);
await cs.ResultTask;
if (cs.ResultTask.Result != CargoResult.Success)
{
ConsoleManager.WriteLine(cs.ResultTask.Result.ToString());
}
return;
}
PurchaseResult GenerateSaleTransactionSequence(IShip sellingShip, Port purchasingPort, HashSet <int> statefulCargoIDs, ref List <CargoTransaction> transactionsToSchedule, ref float totalPrice)
{
var cargoToSell = sellingShip.Cargo.GetStatefulCargo(statefulCargoIDs.ToList());
if (cargoToSell.Count != statefulCargoIDs.Count)
{
return(PurchaseResult.CargoNotInHolds);
}
totalPrice += purchasingPort.Cargo.GetPrice(cargoToSell, PortTradeDirection.ShipSaleToPort);
foreach (var i in statefulCargoIDs)
{
var fromShip = new TransactionRemoveStatefulCargo(sellingShip, StatefulCargoTypes.Null, i, true);
var toPort = new TransactionAddStatefulCargo(purchasingPort, null, true);
transactionsToSchedule.Add(fromShip);
transactionsToSchedule.Add(toPort);
}
return(PurchaseResult.Success);
}
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;
}
}
