private void InitializeGalaxyData()
{
var galaxyData = new GalaxyData();
galaxyData.Name = "Sefardim";
var ssg = new StarSystemGenerator(galaxyData);
var starSystem = ssg.GenerateStarSystem(GameState.PlayerData.SpaceShipData.GridPosition);
galaxyData.StarSystems.Add(starSystem.Position, starSystem);
GameState.GalaxyData = galaxyData;
}
public static void Create(int sector, Action <StarSystem> callback, Action <Exception> error)
{
StarSystem starSystem = StarSystemGenerator.Generate(sector);
Request <StarSystemCreateRequest> request = new Request <StarSystemCreateRequest>(CreateMethod, StarSystemCreateRequest.FromModel(starSystem));
request.Then(json =>
{
StarSystemResponse response = JsonUtility.FromJson <StarSystemResponse>(json);
StarSystem system = StarSystem.CreateFromDTO(response);
callback.Invoke(system);
}).Catch(error.Invoke);
}
public void GenerateSystem(int seed, int numberOfPlanets, bool hasAsteroidBelt, StarType starType)
{
GameObject newSystem = StarSystemGenerator.CreateSystem(seed, numberOfPlanets, hasAsteroidBelt, starType);
newSystem.transform.parent = transform;
Vector3 particlePosition = Random.insideUnitSphere * 200;
particlePosition.y = Random.Range(-350, -500);
ps [1].transform.position = particlePosition;
for (int i = 0; i < ps.Length; i++)
{
ps[i].randomSeed = (uint)Random.Range(0, 99999);
ps[i].Play();
}
}
public Clue CreateClue(int seed, int numberOfJumps, float distance)
{
clueKnown = new bool[5];
Clue newClue = new Clue();
StarSystemGenerator.StarSystemInfo ssi = StarSystemGenerator.GetStarSystemInfo(seed);
newClue.systemNumberOfPlanets = ssi.numberOfPlanets;
newClue.systemNumberOfPlanetsMin = ssi.numberOfPlanets - Random.Range(1, 4);
if (newClue.systemNumberOfPlanetsMin < 0)
{
newClue.systemNumberOfPlanetsMin = 0;
}
newClue.systemNumberOfPlanetsMax = ssi.numberOfPlanets + Random.Range(1, 4);
newClue.systemHasAsteroidBelt = ssi.asteroidBelt;
newClue.systemStarType = ssi.starType;
newClue.systemStarTypeFake1 = GetRandomStarType(new StarType[] { ssi.starType });
newClue.systemStarTypeFake2 = GetRandomStarType(new StarType[] { ssi.starType, newClue.systemStarTypeFake1 });
newClue.distance = distance;
newClue.distanceMin = distance - Random.Range(50, 250);
if (newClue.distanceMin < 0)
{
newClue.distanceMin = 0;
}
newClue.distanceMax = distance + Random.Range(50, 250);
newClue.jumpDistance = numberOfJumps;
newClue.jumpDistanceMin = numberOfJumps - Random.Range(8, 20);
if (newClue.jumpDistanceMin < 0)
{
newClue.jumpDistanceMin = 0;
}
newClue.jumpDistanceMax = numberOfJumps + Random.Range(8, 20);
return(newClue);
}
public StarSystemGenerator.StarSystemInfo GenerateSystem(StarSystem _starSystem, bool _active)
{
GameObject newSystem = StarSystemGenerator.CreateSystem(_starSystem.seed);
newSystem.transform.parent = transform;
//StarSystemGenerator.CreateSystemEdgeRing (seed).transform.parent = transform.GetChild(1);
for (int i = 0; i < _starSystem.anomaliEvent.Length; i++)
{
GameObject newPoint = new GameObject("Anomali Event");
newPoint.transform.parent = newSystem.transform;
newPoint.transform.localScale = new Vector3(2, 2, 2);
newPoint.AddComponent <MeshFilter> ().mesh = SolarBodyGeneration.GetTorusMesh();
newPoint.AddComponent <MeshRenderer> ().material.mainTexture = new Texture();
newPoint.GetComponent <MeshRenderer> ().material.color = Color.white;
GameObject newPoint2 = new GameObject();
newPoint2.transform.parent = newPoint.transform;
newPoint2.transform.rotation = new Quaternion(-180, 0, 0, 0);
newPoint2.transform.position = new Vector3(0, 6, 0);
newPoint2.transform.localScale = new Vector3(2, 2, 2);
newPoint2.AddComponent <MeshFilter> ().mesh = SolarBodyGeneration.GetConeMesh();
newPoint2.AddComponent <MeshRenderer> ().material.mainTexture = new Texture();
newPoint2.GetComponent <MeshRenderer> ().material.color = Color.white;
//newPoint.transform.position = StarSystemGenerator.GetRandomPoint (StarSystemGenerator.GetStarSystemEdgeDistance(_starSystem.seed));
//Vector3 newPos = Random.insideUnitSphere * StarSystemGenerator.GetStarSystemEdgeDistance(_starSystem.seed);
//newPos.y = 25;
newPoint.transform.position = GetRandomNonCollidingPoint(StarSystemGenerator.GetStarSystemEdgeDistance(_starSystem.seed));
newPoint.tag = "EventPoint";
newPoint.AddComponent <SphereCollider> ();
newPoint.AddComponent <EventPoint> ().eventNumber = i;
newPoint.GetComponent <EventPoint> ().eventListNumber = Random.Range(0, 23);
}
if (_starSystem.mainEvent)
{
GameObject newPoint = new GameObject("Main Event");
newPoint.transform.parent = newSystem.transform;
newPoint.transform.localScale = new Vector3(2, 2, 2);
newPoint.AddComponent <MeshFilter> ().mesh = SolarBodyGeneration.GetTorusMesh();
newPoint.AddComponent <MeshRenderer> ().material.mainTexture = new Texture();
newPoint.GetComponent <MeshRenderer> ().material.color = Color.yellow;
GameObject newPoint2 = new GameObject();
newPoint2.transform.parent = newPoint.transform;
newPoint2.transform.rotation = new Quaternion(-180, 0, 0, 0);
newPoint2.transform.position = new Vector3(0, 6, 0);
newPoint2.transform.localScale = new Vector3(2, 2, 2);
newPoint2.AddComponent <MeshFilter> ().mesh = SolarBodyGeneration.GetConeMesh();
newPoint2.AddComponent <MeshRenderer> ().material.mainTexture = new Texture();
newPoint2.GetComponent <MeshRenderer> ().material.color = Color.yellow;
//newPoint.transform.position = StarSystemGenerator.GetRandomPoint (StarSystemGenerator.GetStarSystemEdgeDistance(_starSystem.seed));
//Vector3 newPos = Random.insideUnitSphere * StarSystemGenerator.GetStarSystemEdgeDistance(_starSystem.seed);
//newPos.y = 25;
//newPoint.transform.position = newPos;
newPoint.transform.position = GetRandomNonCollidingPoint(StarSystemGenerator.GetStarSystemEdgeDistance(_starSystem.seed));
newPoint.tag = "MainEventPoint";
newPoint.AddComponent <SphereCollider> ();
}
if (_starSystem.trader)
{
GameObject newPoint = new GameObject("Trader");
newPoint.transform.parent = newSystem.transform;
GameObject ob = Instantiate(traderGameObject [Random.Range(0, traderGameObject.Length)], new Vector3(0, -12, 0), traderGameObject [Random.Range(0, traderGameObject.Length)].transform.rotation, newPoint.transform);
newPoint.transform.position = GetRandomNonCollidingPoint(StarSystemGenerator.GetStarSystemEdgeDistance(_starSystem.seed));
newPoint.tag = "Trader";
newPoint.AddComponent <SphereCollider> ();
}
if (_starSystem.researchOutpost)
{
GameObject newPoint = new GameObject("Research Outpost");
newPoint.transform.parent = newSystem.transform;
GameObject ob = Instantiate(researchGameObject [Random.Range(0, researchGameObject.Length)], new Vector3(0, -12, 0), researchGameObject [Random.Range(0, researchGameObject.Length)].transform.rotation, newPoint.transform);
newPoint.transform.position = GetRandomNonCollidingPoint(StarSystemGenerator.GetStarSystemEdgeDistance(_starSystem.seed));
newPoint.tag = "ResearchOutpost";
newPoint.AddComponent <SphereCollider> ();
}
Vector3 particlePosition = Random.insideUnitSphere * 200;
particlePosition.y = Random.Range(-350, -500);
ps [1].transform.position = particlePosition;
ParticleSystem.MainModule mainP = ps [1].main;
mainP.startColor = new ParticleSystem.MinMaxGradient(NebulaColour.GetColour(Random.Range(0, 4)));
for (int i = 0; i < ps.Length; i++)
{
ps[i].Stop();
ps[i].Clear();
ps[i].randomSeed = (uint)Random.Range(0, 99999);
ps[i].Play();
}
newSystem.SetActive(_active);
return(StarSystemGenerator.GetStarSystemInfo(_starSystem.seed));
}
//public int numberOfSystems;
public static GameObject CreateGalaxy(out StarSystem[] starSystem, int numberOfSystems)
{
GameObject newGalaxy = new GameObject("Galaxy");
starSystem = new StarSystem[numberOfSystems];
for (int i = 0; i < starSystem.Length; i++)
{
int[] ae = new int[Random.Range(0, 3)];
for (int e = 0; e < ae.Length; e++)
{
ae [e] = Random.Range(0, 3);
}
bool me = false;
if (i < 10)
{
me = true;
}
bool t = false;
if (Random.Range(0, 100) < 50)
{
t = true;
}
bool ro = false;
if (Random.Range(0, 100) < 50)
{
ro = true;
}
starSystem [i] = new StarSystem(Random.Range(0, 10000000), ae, me, t, ro);
GameObject newSystemPoint = new GameObject("SystemPoint");
newSystemPoint.transform.parent = newGalaxy.transform;
newSystemPoint.transform.position = new Vector3((20 * (i)), 0, 0);
newSystemPoint.transform.localScale = new Vector3(4, 4, 4);
newSystemPoint.AddComponent <MeshFilter> ().mesh = SolarBodyGeneration.GetSphereMesh();
MeshRenderer mr = newSystemPoint.AddComponent <MeshRenderer> ();
newSystemPoint.AddComponent <SphereCollider> ().radius = 1;
newSystemPoint.AddComponent <SystemPoint> ().SetStarSystem(i);
newSystemPoint.tag = "SystemPoint";
int pixWidth = 16;
int pixHeight = 16;
int scale = 1;
float xOrg = 0;
float yOrg = 0;
StarType st = StarSystemGenerator.GetStarSystemInfo(starSystem[i].seed).starType;
mr.material.mainTexture = Noise.CalculateSeamlessNoise(pixWidth, pixHeight, scale, xOrg, yOrg, starSystem[i].seed, StarColour.GetStarColour(st));
mr.material.EnableKeyword("_EMISSION");
mr.material.SetTexture("_EmissionMap", Noise.CalculateSeamlessNoise(pixWidth, pixHeight, scale, xOrg, yOrg, starSystem[i].seed, StarColour.GetStarColour(st)));
mr.material.SetColor("_EmissionColor", new Color(0.5f, 0.5f, 0.5f));
}
return(newGalaxy);
}
public void UpdateClueDisplay()
{
clueText [5].text = (clueKnown[0])? clue.systemNumberOfPlanets.ToString() : clue.systemNumberOfPlanetsMin.ToString() + "-" + clue.systemNumberOfPlanetsMax.ToString();
clueText [6].text = (clueKnown[1])? clue.systemHasAsteroidBelt.ToString() : "???";
string[] starTypeString = new string[] {
clue.systemStarTypeFake1.ToString(),
clue.systemStarType.ToString(),
clue.systemStarTypeFake2.ToString()
};
RandomiseOrder(starTypeString);
clueText [7].text = (clueKnown[2])? clue.systemStarType.ToString() : starTypeString[0] + "-" + starTypeString[1] + "-" + starTypeString[2];
clueText [8].text = (clueKnown[3])? ((int)clue.distance).ToString() : ((int)clue.distanceMin).ToString() + "-" + ((int)clue.distanceMax).ToString();
clueText [9].text = (clueKnown[4])? clue.jumpDistance.ToString() : clue.jumpDistanceMin.ToString() + "-" + clue.jumpDistanceMax.ToString();
StarSystemGenerator.StarSystemInfo ssi = StarSystemGenerator.GetStarSystemInfo(mainGeneration.starSystem [targetSystem].seed);
clueText [10].text = ssi.numberOfPlanets.ToString();
clueText [11].text = ssi.asteroidBelt.ToString();
clueText [12].text = ssi.starType.ToString();
clueText [13].text = ((int)GetSystemDistance(mainGeneration.currentSystem, targetSystem)).ToString();
clueText [14].text = mainGeneration.systemPoint [targetSystem].numberOfJumpsAway.ToString();
if (clueKnown [0])
{
clueText [15].text = (clue.systemNumberOfPlanets == ssi.numberOfPlanets ? "=" : "<color=#ff0000ff>X</color>");
}
else
{
if (ssi.numberOfPlanets >= clue.systemNumberOfPlanetsMin && ssi.numberOfPlanets <= clue.systemNumberOfPlanetsMax)
{
clueText [15].text = "~";
}
else
{
clueText [15].text = "<color=#ff0000ff>X</color>";
}
}
if (clueKnown [1])
{
clueText [16].text = (clue.systemHasAsteroidBelt == ssi.asteroidBelt ? "=" : "<color=#ff0000ff>X</color>");
}
else
{
clueText [16].text = "~";
}
if (clueKnown [2])
{
clueText [17].text = (clue.systemStarType == ssi.starType ? "=" : "<color=#ff0000ff>X</color>");
}
else
{
if (ssi.starType == clue.systemStarType || ssi.starType == clue.systemStarTypeFake1 || ssi.starType == clue.systemStarTypeFake2)
{
clueText [17].text = "~";
}
else
{
clueText [17].text = "<color=#ff0000ff>X</color>";
}
}
if (clueKnown [3])
{
clueText [18].text = ((int)clue.distance == (int)GetSystemDistance(mainGeneration.currentSystem, targetSystem) ? "=" : "<color=#ff0000ff>X</color>");
}
else
{
if ((int)GetSystemDistance(mainGeneration.currentSystem, targetSystem) >= clue.distanceMin && (int)GetSystemDistance(mainGeneration.currentSystem, targetSystem) <= clue.distanceMax)
{
clueText [18].text = "~";
}
else
{
clueText [18].text = "<color=#ff0000ff>X</color>";
}
}
if (clueKnown [4])
{
clueText [19].text = (clue.jumpDistance == mainGeneration.systemPoint [targetSystem].numberOfJumpsAway ? "=" : "<color=#ff0000ff>X</color>");
}
else
{
if (mainGeneration.systemPoint [targetSystem].numberOfJumpsAway >= clue.jumpDistanceMin && mainGeneration.systemPoint [targetSystem].numberOfJumpsAway <= clue.jumpDistanceMax)
{
clueText [19].text = "~";
}
else
{
clueText [19].text = "<color=#ff0000ff>X</color>";
}
}
}
void UpdateGame()
{
if (finalEventBox.activeSelf)
{
return;
}
if (shipDestroyedBox.activeSelf)
{
return;
}
if (Input.GetKeyDown(KeyCode.Escape))
{
if (eventSystem.eventObject.activeSelf)
{
return;
}
else if (researchOutpostUI.activeSelf)
{
return;
}
else if (shopUI.activeSelf)
{
return;
}
else if (autoPilotToggle.isOn)
{
CancelAutoPilotConfimation();
autoPilotToggle.isOn = false;
}
else if (blockingCanvas.sortingOrder == 3)
{
OpenQuitConfimationBoxMenu(false);
OpenQuitConfimationBoxDesktop(false);
}
else if (gameMenuUI.activeSelf)
{
OpenGameMenu(false);
}
else if (blockingCanvas.sortingOrder == 1 && blockingCanvas.gameObject.activeSelf)
{
CancelDriveJumpConfimation();
CancelSystemJumpConfimation();
}
else
{
OpenGameMenu(true);
}
}
if (blockingCanvas.gameObject.activeSelf)
{
return;
}
if (autoPilotToggle.isOn)
{
UpdateAutoPilot();
}
if (systemJumping)
{
UpdateSystemJump();
return;
}
if (driveJumping)
{
UpdateJumpDrive();
return;
}
if (mainEventProgress == 10)
{
FinalEvent();
SetBlockingCanvas(true, 1);
}
for (int i = 0; i < 2; i++)
{
cameras[i].UpdateCamera(mainMenu.cameraFollowShip.isOn);
}
if (ship.gameObject.activeSelf)
{
if (ship.UpdateShip(mainMenu.holdToMove.isOn) == false)
{
ShipDestroyed();
SetBlockingCanvas(true, 1);
}
Collider[] overlaps;
overlaps = Physics.OverlapSphere(ship.transform.position, 5);
if (overlaps.Length > 0)
{
interactionUI.SetActive(true);
interactionText.text = overlaps [0].tag;
}
else
{
interactionUI.SetActive(false);
}
if (Input.GetKeyDown(KeyCode.E))
{
InteractionCheck();
}
}
if (ship.money < 0)
{
ship.money = 0;
}
if (ship.research < 0)
{
ship.research = 0;
}
if (ship.jumpCharges < 0)
{
ship.jumpCharges = 0;
}
shipText [0].text = ship.strength.ToString() + "/" + ship.maxStrength.ToString();
shipText [1].text = ship.money.ToString();
shipText [2].text = ship.research.ToString();
shipText [3].text = ship.jumpCharges.ToString() + "/" + ship.maxJumpCharges.ToString();
if (Vector3.Distance(transform.position, ship.transform.position) > StarSystemGenerator.GetStarSystemEdgeDistance(mainGeneration.starSystem[mainGeneration.currentSystem].seed))
{
shipOnOuterEdge = true;
}
else
{
shipOnOuterEdge = false;
}
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit))
{
if (hit.transform.tag == "SystemPoint")
{
mainGeneration.currentHoverSystem = hit.transform.gameObject.GetComponent <SystemPoint> ().GetStarSystem();
SystemInfoUI.SetActive(true);
// if (Input.mousePosition.y > (Screen.height / 10) *9) {
//
//
// }
SystemInfoUI.transform.position = Input.mousePosition;
StarSystemGenerator.StarSystemInfo ssi = StarSystemGenerator.GetStarSystemInfo(mainGeneration.starSystem [mainGeneration.currentHoverSystem].seed);
text [0].text = "Number of Planets: " + ssi.numberOfPlanets.ToString();
text [1].text = "Has Asteroid Belt: " + ssi.asteroidBelt.ToString();
text [2].text = "Star Class: " + ssi.starType.ToString();
text [3].text = "Distance: " + (int)GetSystemDistance(mainGeneration.currentSystem, mainGeneration.currentHoverSystem);
text [4].text = "System Jumps Away: " + mainGeneration.systemPoint [mainGeneration.currentHoverSystem].numberOfJumpsAway;
if (Input.GetMouseButtonDown(0))
{
//if (jumping) {
if (driveModeSlider.value == 0)
{
if (CheckSystemDistance(mainGeneration.currentSystem, mainGeneration.currentHoverSystem, ship.maxJumpDistance))
{
driveJumpConfimationBox.SetActive(true);
driveJumpConfimationBox.transform.position = Input.mousePosition;
audioControl.PlaySoundEffect(2);
SetBlockingCanvas(true, 1);
}
}
else
{
if (CheckSystemConnection(mainGeneration.currentSystem, mainGeneration.currentHoverSystem))
{
if (shipOnOuterEdge)
{
systemJumpConfimationBox.SetActive(true);
systemJumpConfimationBox.transform.position = Input.mousePosition;
audioControl.PlaySoundEffect(2);
SetBlockingCanvas(true, 1);
}
}
}
}
else if (Input.GetMouseButtonDown(1))
{
SetupNewTargetSystem(mainGeneration.currentHoverSystem);
UpdateClueDisplay();
}
}
}
else
{
SystemInfoUI.SetActive(false);
}
}
