protected override void OnInitialize()
{
Model = model;
game = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <GameManager>();
galaxy = game.galaxy;
sprite = GetComponent <SpriteRenderer>();
line = GetComponent <LineRenderer>();
name = model.name;
timeUpdate = model.age.time + Dated.Hour;
sprite.color = model.color;
background.color = model.backgroundColor;
//transform.position = (Vector2) model.GamePosition(game.data.date.time, model.solar.satelites[moon.solarIndex[1]].mass);
if (!game.data.stars[model.solarIndex].isActive)
{
sprite.enabled = false;
background.enabled = false;
}
else
{
sprite.enabled = true;
background.enabled = true;
}
}
public void ShipSelected(GameObject capsuleItem)
{
Ship s = capsuleItem.GetComponent <Ship> ();
if (PlayerData.instance.RemoveScrap(s.ScrapCost))
{
ClearAll();
Qvent q = new Qvent(QventType.DESTROYED, typeof(Ship), PlayerData.instance.PlayerShip);
foreach (QventHandler handler in PlayerData.instance.PlayerShip.Listeners)
{
handler.HandleQvent(q);
}
Vector3 previousPlayerPos = PlayerData.instance.PlayerShip.gameObject.transform.position;
PlayerData.instance.AddScrap(s.ScrapCost);
GameObject.Destroy(PlayerData.instance.PlayerShip.gameObject);
PlayerData.instance.PlayerShip = null;
GameObject newShip = GalaxyManager.SpawnWorldObject(s.gameObject, previousPlayerPos);
Ship ship = newShip.GetComponent <Ship> ();
ship.IsPlayer = true;
ship.curhp = ship.maxhp / 5;
PlayerData.instance.PlayerShip = ship;
newShip.AddComponent <PlayerController> ();
CameraManager.instance.SetToFollow(newShip);
GalaxyManager.instance.AddObserver(newShip);
}
}
private void Update()
{
int x = Random.Range(0, GalaxyManager.instance.Width - 1);
int y = Random.Range(0, GalaxyManager.instance.Height - 1);
Vector2 pos = GalaxyManager.instance.SectorToWorldPoint(new Vector2Int(x, y));;
pos.x += Random.Range(-50, 50);
pos.y += Random.Range(-50, 50);
if (Input.GetKeyDown(KeyCode.Q))
{
GalaxyManager.SpawnWorldObject(prefab, pos);
}
if (Input.GetKeyDown(KeyCode.E))
{
GalaxyManager.SpawnWorldObject(prefab2, pos);
}
if (Input.GetKeyDown(KeyCode.S))
{
SpaceSerializerDeserializer.MyMonoSerializeToFile(GalaxyManager.instance, "Galaxy.xml");
}
if (Input.GetKeyDown(KeyCode.L))
{
SpaceSerializerDeserializer.DeserializeGalaxyManager(GalManSource.text);
}
}
public new static GameObject ReadXml(XmlReader reader, Component workingObj)
{
GalaxyManager galman = (GalaxyManager)workingObj;
if (GalaxyManager.instance == galman)
{
}
else
{
Debug.LogWarning("More than one galaxy manager");
return(null);
}
reader.Read();
galman.SectorSize = int.Parse(reader.ReadString());
reader.Read();
galman.Width = int.Parse(reader.ReadString());
reader.Read();
galman.Height = int.Parse(reader.ReadString());
reader.Read();
galman.UpdateTime = float.Parse(reader.ReadString());
reader.Read();
galman.CheckTime = float.Parse(reader.ReadString());
return(workingObj.gameObject);
}
public void GenerateProperties()
{
GalaxyManager gm = GameObject.Find("Camera").GetComponent <GalaxyManager>();
int[] planetSA = new int[gm.noPlanets];
int million = 1000000;
for (int i = 0; i < gm.noPlanets; i++)
{
switch (gm.GetPlanetByIndex(i)._Scale)
{
case (1):
planetSA[i] = 350 * million;
break;
case (1.5f):
planetSA[i] = 500 * million;
break;
case (2):
planetSA[i] = 800 * million;
break;
}
int j;
int areaAllowance = planetSA[i];
while (areaAllowance > 0)
{
}
}
}
public DBFillerUtils(IDatabaseManager databaseManager, GalaxyManager galaxyManager, LocatorService locatorService, WarpManager warpManager, LocalIDManager galaxyIdManager)
{
_databaseManager = databaseManager;
_galaxyManager = galaxyManager;
_locatorService = locatorService;
ShipFactory = new ShipFactory(locatorService.RegistrationManager, warpManager, galaxyIdManager, locatorService, databaseManager);
}
/// <summary>
/// Gives each player a ship
/// Galaxy must already have been generated
/// </summary>
async Task CreateShips(IEnumerable <Player> players, GalaxyManager galaxyManager, LocalIDManager IDManager, GalaxyRegistrationManager rm, PlayerManager pm, LocatorService locatorService)
{
ships = new List <IShip>();
int counter = 0;
foreach (Player p in players)
{
List <WeaponTypes> weapons = new List <WeaponTypes>
{
WeaponTypes.PlasmaCannon,
WeaponTypes.BC_Laser,
WeaponTypes.LaserWave,
WeaponTypes.GravBomber,
WeaponTypes.HurrDurr
};
ShipCreationProperties props = new ShipCreationProperties(counter + 10, counter + 10, (int)galaxyManager.SolAreaID, PilotTypes.Player, ShipTypes.BattleCruiser, weapons);
var tempShip = _dbFillerUtils.ShipFactory.CreateShip(props);
tempShip.SetPlayer(p);
p.SetActiveShip(tempShip, MockServer.WarpManager);
tempShip.CurrentEnergy = tempShip.ShipStats.Energy;
ships.Add(tempShip);
counter++;
}
}
public void Update()
{
switch (Mode)
{
case GameMode.SETUP:
GameObject chosen = Utils.getRandomEntry <GameObject>(StartingShips);
GameObject starter = GalaxyManager.SpawnWorldObject(chosen, Vector3.zero);
GalaxyManager.instance.AddObserver(starter);
starter.name = "Player";
starter.AddComponent <PlayerController>();
Ship ship = starter.GetComponent <Ship>();
ship.SetFaction(FACTION.PLAYER_FACTION);
ship.IsPlayer = true;
PlayerData.instance.PlayerShip = ship;
PlayerData.instance.AddScrap(StartingScrap);
foreach (GameObject mod in StartingModules)
{
PlayerData.instance.AddModule(mod);
}
CameraManager.instance.SetToFollow(PlayerData.instance.PlayerShip.gameObject);
CameraManager.instance.SetOffset(new Vector3(0, 0, -10));
HudController.instance.Disable();
MenuController.instance.Disable();
ShipEditor.instance.Enable();
// Galaxy Generation
Mode = GameMode.NORMAL;
break;
}
HandleMetaInput();
}
// Use this for initialization
void Start()
{
galaxy = galaxyManager.GetComponent <GalaxyManager>();
tradeRequestManager = pathfindingManager.GetComponent <TradeRouteRequestManager>();
data = new GameDataModel();
setup = true;
GetLoadingPanel().LoadAssets();
}
public GameObject CreateFloatingSchematic(Module module, Vector2 pos)
{
GameObject go = GalaxyManager.SpawnWorldObject(FloatingSchematic, pos);
FloatingSchematic ffm = go.GetComponent <FloatingSchematic> ();
ffm.SetItem(module.BASE_PATH);
return(go);
}
public GameObject CreateFloatingScrap(int value, Vector2 pos)
{
GameObject go = GalaxyManager.SpawnWorldObject(FreeFloatingScrap, pos);
FloatingScrap fs = go.GetComponent <FloatingScrap> ();
fs.ScrapValue = value;
return(go);
}
void OnDestroy()
{
/* Shuts down the working instance of GalaxyPeer.
* NOTE: Shutdown should be the last method called, and all listeners should be closed before that. */
GalaxyInstance.Shutdown(true);
Instance = null;
Destroy(this);
}
private void Awake()
{
instance = this;
mapButtonCanvases = new List <Canvas>();
hyperSpaceShips = new ModelRefs <ShipModel>();
game = GameManager.instance;
cam = game.GetComponent <Camera>();
}
// Use this for initialization
public void Awake()
{
game = GameManager.instance;
galaxy = GetComponent <GalaxyManager>();
maxLocalSize = game.data.stars.Count;
nodes = new Node[game.data.stars.Count];
requestManager = GetComponent <PathRequestManager>();
}
// Use this for initialization
void Start()
{
line = GetComponent <LineRenderer>();
galaxy = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <GalaxyManager>();
ship = GetComponent <ShipController>();
target = ship.solarIndex;
oldTarget = ship.solarIndex;
}
public void CreateGame()
{
galaxy = GalaxyManager.instance;
game = GameManager.instance;
names = new NameGen();
GameManager.instance.setup = true;
loadingPanel.SetActive(true);
StartCoroutine("CreatingGame"); //Creates a new Game
}
public void LoadGame()
{
galaxy = GalaxyManager.instance;
game = GameManager.instance;
loadingPanel.SetActive(true);
GameManager.instance.setup = true;
Model.DeleteAll();
Model.Load("TraderSaves", OnStart, OnProgress, OnDone, OnError);
}
void Awake()
{
if (Instance == null)
{
Instance = this;
DontDestroyOnLoad(gameObject);
}
else
{
Destroy(this);
}
}
private void Build()
{
// done building
if (Progress <= 0)
{
// we are actually building sth
if (ChosenToBuild)
{
// Create the ship
GameObject newShip = GalaxyManager.SpawnWorldObject(ChosenToBuild, transform.position);
Ship ship = newShip.GetComponent <Ship> ();
// Set hp to 1/5
ship.curhp = ship.maxhp / 5;
foreach (Port p in ship.ports)
{
Module m;
if ((m = p.GetModule()))
{
m.curhp = m.maxhp / 5;
}
}
foreach (Port p in ship.mainPorts)
{
Module m;
if ((m = p.GetModule()))
{
m.curhp = m.maxhp / 5;
}
}
// set faction
ship.SetFaction(this.faction);
// add to list
SpawnedShips.Add(newShip);
ChosenToBuild = null;
}
if (SpawnedShips.Count < MaxSpawned)
{
ChosenToBuild = Utils.getRandomEntry <GameObject> (ShipsToSpawn);
Progress = ChosenToBuild.GetComponent <Ship> ().RepairTime * 3;
}
}
else
{
Progress -= SpaceGameGlobal.TICK_RATE;
}
}
void Awake()
{
//Make a Singleton
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(this);
}
//This stays in every scene
DontDestroyOnLoad(gameObject);
}
public bool PSystemsLoaded;//Signals that all PSystems have been loaded and the server is ready
//TODO: Implement pause to object updating when additional systems need to be loaded while server is up
public MasterServerMessageHandler(
int mySlaveID,
RedisServer redisServer,
ConnectionManager connectionManager,
LocatorService ls,
AccountManager accountManager,
LocalIDManager accountIdManager,
IDatabaseManager databaseManager,
GalaxyManager galaxyManager,
LocalIDManager galaxyIDManager,
PlayerManager playerManager,
ShipManager shipManager,
GalaxyRegistrationManager rm,
LocalIDManager teamIDManager,
MessageManager messageManager,
GlobalTeamManager teamManager,
WarpManager warpManager,
LocalIDManager transactionIdManager,
EventHandler <NetworkMessageContainer> routedMessageProcessor
)
{
_connectionManager = connectionManager;
_accountManager = accountManager;
_accountIdManager = accountIdManager;
_databaseManager = databaseManager;
_galaxyIDManager = galaxyIDManager;
_galaxyManager = galaxyManager;
_teamIDManager = teamIDManager;
_playerManager = playerManager;
_shipManager = shipManager;
_registrationManager = rm;
_locatorService = ls;
_messageManager = messageManager;
_teamManager = teamManager;
_redisServer = redisServer;
_warpManager = warpManager;
_transactionIdManager = transactionIdManager;
_mySlaveID = mySlaveID;
_routedMessageProcessor = routedMessageProcessor;
_redisServer.Subscribe(MessageTypes.Redis_LoginDataRequest, _handleLoginDataRequest);
_redisServer.Subscribe(MessageTypes.Redis_ColonyDataPush, _handleColonyDataPush);
_redisServer.Subscribe(MessageTypes.Redis_ClientHandoff, _handleHandoff);
_redisServer.Subscribe(MessageTypes.Redis_StartUpdatingSystems, _handleMessageStartUpdatingSystems);
_redisServer.Subscribe(MessageTypes.Redis_IDResponse, _handleMessageIDResponse);
_redisServer.Subscribe(MessageTypes.Redis_AdminWarpPlayer, _handleAdminWarpPlayer);
}
public void ToggleAllLines()
{
GalaxyManager gm = GameObject.Find("Camera").GetComponent <GalaxyManager>();
gm.TradeLinesOn = !gm.TradeLinesOn;
if (gm.TradeLinesOn == false)
{
gm.LMDeactivateAllLines();
}
//else
//gm.DrawAllPlanetsToAll(gm.TradeLinesOn); HAVE TO DECOUPLE INCREMENTING ORBITS FROM INCREMENTING TURNS
Debug.Log("Trade lines on state is " + GameObject.Find("Camera").GetComponent <GalaxyManager>().TradeLinesOn);
}
protected override void OnInitialize()
{
lastCamPosition.z = -10;
game = GameManager.instance;
galaxy = GalaxyManager.instance;
transform.position = model.galacticPosition;
name = model.name;
sprite = GetComponent <SpriteRenderer>();
sprite.color = model.solar.color;
transform.localScale = Vector3.one * (float)Mathd.Pow((model.solar.bodyRadius), .02f);
if (model.isActive)
{
CreateSystem();
}
}
public MinimalMockServer(GalacticProperties gp, IDatabaseManager databaseManager, IDbIdIoService dbIdIoService)
{
Logger.Initialize();
DatabaseManager = databaseManager;
DbIdIoService = dbIdIoService;
//Minimal initializations
GalaxyIDManager = new LocalIDManager(null, IDTypes.GalaxyID);
TeamIDManager = new LocalIDManager(null, IDTypes.TeamID);
accountIDManager = new LocalIDManager(null, IDTypes.AccountID);
InitializeIdData(gp);
globalGalaxyIDManager = new GlobalGalaxyIDManager(dbIdIoService, gp);
GenerateIDsForLocalIDManager(globalGalaxyIDManager, GalaxyIDManager, gp.IdProperties[IDTypes.GalaxyID].LastIDAdded);
globalTeamIDManager = new GlobalTeamIDManager(dbIdIoService, gp);
GenerateIDsForLocalIDManager(globalTeamIDManager, TeamIDManager, gp.IdProperties[IDTypes.TeamID].LastIDAdded);
globalAccountIDManager = new GlobalAccountIDManager(dbIdIoService, gp);
GenerateIDsForLocalIDManager(globalAccountIDManager, accountIDManager, gp.IdProperties[IDTypes.AccountID].LastIDAdded);
_redisServer = new RedisServer(Logger.LogRedisError, Logger.LogRedisInfo, new RedisConfig().Address);
TeamManager = new GlobalTeamManager(TeamIDManager, null, null, null, DatabaseManager);
PlayerManager = new PlayerManager(DatabaseManager, null, _redisServer, GalaxyIDManager, null);
GalaxyManager = new GalaxyManager(gp.SolID, TeamManager);
shipManager = new ShipManager(null, GalaxyManager, null, null, DatabaseManager);
CollisionManager = new CollisionManager(GalaxyManager, null, null, null);
GalaxyGenerator = new DebugGalaxyGenerator(PlayerManager, GalaxyManager, shipManager);
AccountManager = new AccountManager_MasterServer(accountIDManager, DatabaseManager, false);
CargoSynchronizer = new Server.Managers.CargoSynchronizer();
StructureManager = new StructureManager(DatabaseManager, GalaxyManager, GalaxyIDManager, CargoSynchronizer);
RegistrationManger = new GalaxyRegistrationManager(GalaxyManager, shipManager, CollisionManager, GalaxyIDManager, PlayerManager, null, CargoSynchronizer, StructureManager);
ColonyFactory.Initialize(GalaxyIDManager, RegistrationManger);
StructureFactory.Initialize(GalaxyIDManager, RegistrationManger);
LocatorService = new LocatorService(RegistrationManger, PlayerManager, GalaxyManager, shipManager, AccountManager, TeamManager, TeamManager, null, StructureManager, null);
WarpManager = new WarpManager(GalaxyManager, null, null, _redisServer, AccountManager, null);
CargoSynchronizer.Start(10, 4);
}
private void init()
{
if (initialized)
{
return;
}
if (instance != null)
{
return;
}
instance = this;
Sectors = new Sector[Height, Width];
for (int x = 0; x < Width; x++)
{
for (int y = 0; y < Height; y++)
{
// spawn sectors.
GameObject sectorGO = new GameObject("Sector " + x + ":" + y);
Sector sector = sectorGO.AddComponent <Sector> ();
Sectors [y, x] = sector;
sector.index = new Vector2Int(x, y);
sectorGO.transform.position = SectorToWorldPoint(new Vector2Int(x, y));
sectorGO.transform.SetParent(this.transform);
}
}
if (Generate)
{
for (int x = 0; x < Width; x++)
{
for (int y = 0; y < Height; y++)
{
// spawn sectors.
Sector sector = Sectors[y, x];
Scheme.Generate(sector);
}
}
}
initialized = true;
}
protected override void OnInitialize()
{
game = GameManager.instance;
galaxy = game.galaxy;
unit = GetComponent <Unit>();
sprite = GetComponent <SpriteRenderer>();
line = GetComponent <LineRenderer>();
solarMask = gameObject.layer;
mapMask = game.gameObject.layer;
name = model.name;
model.moneyStats = new DataGraph("Money Over Time", "Time (hours)", "Money");
model.moneyStats.data.Add("Money", new List <Stat>()
{
new Stat(model.age.hour, model.money)
});
model.moneyStats.data.Add("Money Change", new List <Stat>());
transform.localScale = Vector3.one * (model.capacity / 200f + .5f);
timeUpdate = model.age.time + Dated.Hour;
}
static void Main(string[] args)
{
//var galacticUnits = new GalaxyDictionary<string, Romans>();
//var itemCredits = new GalaxyDictionary<string, float>();
//var manager = new GalaxyManager(galacticUnits,itemCredits);
var manager = new GalaxyManager();
PrintInstructions();
foreach (var arg in args)
{
manager.ProcessMessage(arg);
}
do
{
try
{
var line = Console.ReadLine();
if (string.IsNullOrEmpty(line))
{
continue;
}
var status = manager.ProcessMessage(line);
if (!status.Equals("scuess", StringComparison.CurrentCultureIgnoreCase))
{
Console.WriteLine(status);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
} while (true);
// ReSharper disable once FunctionNeverReturns
}
public static GalaxyManager DeserializeGalaxyManager(XmlReader reader)
{
GalaxyManager galman = GalaxyManager.instance;
while (reader.Read())
{
if (reader.IsStartElement())
{
switch (reader.LocalName)
{
case "GALAXY_DATA":
GalaxyManager.ReadXml(reader, galman);
break;
case "Sector":
Sector sector = DeserializeSector(reader);
Debug.Log(sector.index);
galman.SetSector(sector, sector.index);
break;
}
}
}
return(galman);
}
public override void Generate(Sector sector)
{
List <GameObject> ltu;
Vector2Int index = sector.index;
Vector2Int delta = sector.index - new Vector2Int(GalaxyManager.instance.Width / 2, GalaxyManager.instance.Height / 2);
if (delta.magnitude >= 4)
{
ltu = Level4Objects;
}
else if (delta.magnitude >= 3)
{
ltu = Level3Objects;
}
else if (delta.magnitude >= 2)
{
ltu = Level2Objects;
}
else if (delta.magnitude >= 1)
{
ltu = Level1Objects;
}
else
{
ltu = Level0Objects;
}
int num = Random.Range(1, Range);
for (int i = 0; i < num; i++)
{
Vector2 pos = GalaxyManager.instance.SectorToWorldPoint(index);
pos += Random.insideUnitCircle * GalaxyManager.instance.SectorSize / 2;
GalaxyManager.SpawnWorldObject(Utils.getRandomEntry <GameObject> (ltu), pos);
}
}
/// <summary>
/// Returns created NPCPlayers
/// </summary>
/// <param name="galaxyManager"></param>
/// <param name="IDManager"></param>
/// <param name="rm"></param>
/// <param name="pm"></param>
/// <param name="npcShips"></param>
/// <returns></returns>
async Task <IEnumerable <NPCPlayer> > CreateNPCs(GalaxyManager galaxyManager, LocalIDManager IDManager, GalaxyRegistrationManager rm, PlayerManager pm, LocatorService locatorService, CargoSynchronizer cargoSynchronizer, GlobalTeamManager teamManager, LocalIDManager galaxyIDManager)
{
Random r = new Random(666);
var players = new List <NPCPlayer>();
var systems = galaxyManager.Systems;
int npcCount = 0;
foreach (PSystem s in systems)
{
List <Player> team1 = new List <Player>();
List <Player> team2 = new List <Player>();
List <Player> team3 = new List <Player>();
for (int i = 0; i < _config.NumNPCsPerSystem; i++)
{
List <WeaponTypes> weapons = new List <WeaponTypes>();
ShipTypes shipType = ShipTypes.Barge;
switch (npcCount % 3)
{
case 0:
shipType = ShipTypes.Penguin;
break;
case 1:
shipType = ShipTypes.Barge;
break;
case 2:
shipType = ShipTypes.Reaper;
break;
}
if (shipType == ShipTypes.Reaper)
{
weapons.Add(WeaponTypes.LaserWave);
weapons.Add(WeaponTypes.PlasmaCannon);
}
else
{
weapons.Add(WeaponTypes.AltLaser);
weapons.Add(WeaponTypes.LaserWave);
}
ShipCreationProperties props = new ShipCreationProperties(r.Next(-20, 20), r.Next(-20, 20), (int)galaxyManager.SolAreaID, PilotTypes.NPC, shipType, weapons);
IShip tempShip = _dbFillerUtils.ShipFactory.CreateShip(props);
tempShip.ShipStats.ShieldType = ShieldTypes.QuickRegen;
NPCPlayer p = pm.CreateNPCPlayer(locatorService);
pm.RegisterPlayer(p);
players.Add(p);
tempShip.SetPlayer(p);
p.SetActiveShip(tempShip, MockServer.WarpManager);
TransactionAddStatelessCargo tr = new TransactionAddStatelessCargo(tempShip,
StatelessCargoTypes.AmbassadorMissile, 666666, true);
cargoSynchronizer.RequestTransaction(tr);
await tr.ResultTask;
tr = new TransactionAddStatelessCargo(tempShip, StatelessCargoTypes.Biodome, 666666, true);
cargoSynchronizer.RequestTransaction(tr);
await tr.ResultTask;
Helpers.DebugWarp(s, p, tempShip);
ships.Add(tempShip);
//Random team assignment
switch (npcCount % 2)
{
case 0:
team1.Add(p);
break;
case 1:
team2.Add(p);
break;
case 2:
team3.Add(p);
break;
}
//Give the guy some turrets
for (int j = 0; j < _config.NumTurretsPerNPC; j++)
{
var t = StructureFactory.CreateStructure(StructureTypes.LaserTurret, r.Next(-20, 20),
r.Next(-20, 20), p, null, (int)p.CurrentAreaID, locatorService.PlayerLocator, true, dbm);
p.GetArea().AddStructure(t);
}
AddModulesToShip(tempShip, 5, cargoSynchronizer, galaxyIDManager);
npcCount++;
}
foreach (Planet pl in s.GetPlanets())
{
npcCount = 0;
for (int i = 0; i < _config.NumNpcsPerPlanet; i++)
{
ShipTypes shipType = ShipTypes.Barge;
switch (npcCount % 3)
{
case 0:
shipType = ShipTypes.Penguin;
break;
case 1:
shipType = ShipTypes.Barge;
break;
case 2:
shipType = ShipTypes.Reaper;
break;
}
NPCPlayer p = pm.CreateNPCPlayer(locatorService);
pm.RegisterPlayer(p);
players.Add(p);
IShip tempShip = new NPCShip(ShipStatManager.TypeToStats[shipType], locatorService);
tempShip.ShipStats.ShieldType = ShieldTypes.QuickRegen;
tempShip.Id = IDManager.PopFreeID();
rm.RegisterObject(tempShip);
p.SetActiveShip(tempShip, MockServer.WarpManager);
tempShip.SetWeapon(WeaponManager.GetNewWeapon(WeaponTypes.MissileLauncher));
if (shipType == ShipTypes.Reaper)
{
tempShip.SetWeapon(WeaponManager.GetNewWeapon(WeaponTypes.LaserWave));
tempShip.SetWeapon(WeaponManager.GetNewWeapon(WeaponTypes.PlasmaCannon));
}
else
{
tempShip.SetWeapon(WeaponManager.GetNewWeapon(WeaponTypes.AltLaser));
tempShip.SetWeapon(WeaponManager.GetNewWeapon(WeaponTypes.LaserWave));
}
TransactionAddStatelessCargo tr = new TransactionAddStatelessCargo(tempShip,
StatelessCargoTypes.AmbassadorMissile, 666666, true);
cargoSynchronizer.RequestTransaction(tr);
await tr.ResultTask;
tr = new TransactionAddStatelessCargo(tempShip, StatelessCargoTypes.Biodome, 666666, true);
cargoSynchronizer.RequestTransaction(tr);
await tr.ResultTask;
tempShip.PosX = r.Next(-20, 20);
tempShip.PosY = r.Next(-20, 20);
Helpers.DebugWarp(pl, p, tempShip);
ships.Add(tempShip);
//Random team assignment
switch (npcCount % 2)
{
case 0:
team1.Add(p);
break;
case 1:
team2.Add(p);
break;
case 2:
team3.Add(p);
break;
}
AddModulesToShip(tempShip, 5, cargoSynchronizer, galaxyIDManager);
npcCount++;
}
teamManager.DebugCreateNewTeam(team1);
teamManager.DebugCreateNewTeam(team2);
teamManager.DebugCreateNewTeam(team3);
}
}
return(players);
}