public void SpawnNewPlanets(GameObject originPlanet)
{
// put the possible spawn positions into an array
Vector3[] possibleSpawnPositions = new Vector3[48];
for (int i = 0; i < originPlanet.transform.childCount - 1; i++)
{
// need to make sure this one child doesnt get added to the array
if (originPlanet.transform.GetChild(i).name != "ConqueredLostSpriteHolder")
{
possibleSpawnPositions[i] = originPlanet.transform.GetChild(i).position;
}
}
// get a random amount of spawn positions
int minPlanets = 2;
int maxPlanets = 6;
int randomTotal = Random.Range(minPlanets, maxPlanets);
// find a random open position and spawn there the randomTotal amount of times
for (int i = 0; i < randomTotal; i++)
{
Vector3 mySpawnPosition = new Vector3(1, 1, 1);
Vector3 defaultPosition = new Vector3(1, 1, 1);
// while GetRandomPosition is failing keep trying until you get an open position
while (mySpawnPosition == defaultPosition)
{
mySpawnPosition = GetRandomPosition(possibleSpawnPositions);
}
// we found an open position now spawn a random planet
//mySpawnPosition = defaultPosition;
GameObject newPlanet = Instantiate(planet, mySpawnPosition, Quaternion.identity);
newPlanet.transform.SetParent(GameObject.Find("SpaceSceneSaver").transform);
spawnedPlanets.Add(newPlanet);
PlanetInformation planetInfo = newPlanet.GetComponent <PlanetInformation>();
planetInfo.planetName = planetBuilder.GetRandomPlanetName();
planetInfo.type = planetBuilder.GetPlanetType();
planetInfo.planetAI = Instantiate(planetBuilder.GetPlanetAI());
planetInfo.planetAI.transform.SetParent(planetInfo.transform);
planetInfo.planetAI.SetActive(false);
AIInformation aiInfo = planetInfo.planetAI.GetComponent <AIInformation>();
planetInfo.planetPowerLevel = aiInfo.aiPowerLevel;
planetInfo.difficulty = planetInfo.planetPowerLevel.ToString();
planetInfo.negativeEffect = planetBuilder.GetPlanetNegativeEffect(planetInfo.type);
planetInfo.planetSprite = planetBuilder.GetPlanetSprite(planetInfo.type);
// manditory gold resource
planetInfo.resources.Add("Gold");
for (int r = 0; r < 3; r++)
{
planetInfo.resources.Add(planetBuilder.GetPlanetResources(planetInfo.planetPowerLevel));
}
newPlanet.GetComponent <SpriteRenderer>().sprite = planetInfo.unknownPlanetSprite;
}
}
private void Start()
{
var texts = GetComponentsInChildren <Text>();
name_t = texts [0];
description = texts [1];
Shown = false;
GetComponent <RectTransform>().sizeDelta = new Vector2(500, Screen.height * .5f - 50);
Active = this;
transform.position = new Vector3(-525, transform.position.y);
SetVariables(1, transform.position, new Vector3(-10, transform.position.y));
}
public void UseScanner()
{
transform.localScale = GetScannerRange();
PlayerInfoStatic.CurrentShipPower -= (50 - ShipStatsUpgradesStatic.GetShipScannerCost());
// stop the ship
playerShipController.isMoving = false;
// make the scanner brighter
Color alpha = scannerSprite.color;
alpha.a = 100;
scannerSprite.enabled = true;
scannerSprite.color = alpha;
foreach (GameObject planet in planetSpawnerScript.spawnedPlanets)
{
PlanetInformation planetInfo = planet.GetComponent <PlanetInformation>();
if (planetInfo.GetComponent <SpriteRenderer>().sprite == planetInfo.unknownPlanetScanSprite)
{
planetInfo.isScanned = true;
if (ShipStatsUpgradesStatic.GetShipScannerLevel() == 0)
{
planetInfo.revealInformationCase = "Scan01";
planetInfo.PlanetSpriteStateMachine();
}
else if (ShipStatsUpgradesStatic.GetShipScannerLevel() == 1)
{
planetInfo.revealInformationCase = "Scan02";
planetInfo.PlanetSpriteStateMachine();
}
else if (ShipStatsUpgradesStatic.GetShipScannerLevel() == 2)
{
planetInfo.revealInformationCase = "Scan03";
planetInfo.PlanetSpriteStateMachine();
}
else if (ShipStatsUpgradesStatic.GetShipScannerLevel() == 4)
{
planetInfo.revealInformationCase = "Scan04";
planetInfo.PlanetSpriteStateMachine();
}
else if (ShipStatsUpgradesStatic.GetShipScannerLevel() == 5)
{
planetInfo.revealInformationCase = "Scan05";
planetInfo.PlanetSpriteStateMachine();
}
}
}
scannerSprite.enabled = false;
}
public void AttackPlanetClicked()
{
PlanetInformation selectedPlanetInfo = selectedPlanet.GetComponent <PlanetInformation>();
SavedPlanetForBattleStatic.thePlanet = selectedPlanet;
SavedPlanetForBattleStatic.resources = selectedPlanetInfo.resources;
SavedPlanetForBattleStatic.type = selectedPlanetInfo.type;
SavedPlanetForBattleStatic.fuelReward = selectedPlanetInfo.fuelRewardAmount;
SavedPlanetForBattleStatic.xPReward = selectedPlanetInfo.xPRewardAmount;
SavedPlanetForBattleStatic.creditReward = selectedPlanetInfo.creditRewardAmount;
BattleAISaverStatic.savedAIStartingParent = selectedPlanetInfo.gameObject;
selectedPlanetInfo.planetAI.transform.SetParent(aiSaver.transform);
levelManager.LoadLevel("03a_Battle");
gameObject.SetActive(false);
}
private void GetResourceImages(PlanetInformation planetInfo)
{
// need to code this for each resource type just return gold for now
for (int i = 0; i < planetInfo.resources.Count; i++)
{
if (planetInfo.uiResources[i] == "UnknownResource")
{
resourceImages[i].sprite = resourceSprites[0];
}
else if (planetInfo.uiResources[i] == "Gold")
{
resourceImages[i].sprite = resourceSprites[1];
}
else if (planetInfo.uiResources[i] == "Iron")
{
resourceImages[i].sprite = resourceSprites[2];
}
else if (planetInfo.uiResources[i] == "Copper")
{
resourceImages[i].sprite = resourceSprites[3];
}
else if (planetInfo.uiResources[i] == "Nickel")
{
resourceImages[i].sprite = resourceSprites[4];
}
else if (planetInfo.uiResources[i] == "Silver")
{
resourceImages[i].sprite = resourceSprites[5];
}
else if (planetInfo.uiResources[i] == "Cobalt")
{
resourceImages[i].sprite = resourceSprites[6];
}
else if (planetInfo.uiResources[i] == "Cadmium")
{
resourceImages[i].sprite = resourceSprites[7];
}
else if (planetInfo.uiResources[i] == "Iridium")
{
resourceImages[i].sprite = resourceSprites[8];
}
else if (planetInfo.uiResources[i] == "Paladium")
{
resourceImages[i].sprite = resourceSprites[9];
}
}
}
void GetClickedPlanetInfo()
{
RaycastHit2D hit = Physics2D.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.zero);
if (hit.collider != null)
{
PlanetInformation planetInfo = hit.collider.gameObject.GetComponent <PlanetInformation>();
if (planetInfo.planetName != "Home Planet" && planetInfo.planetComplete == false)
{
approachPanel.SetActive(true);
approachPanel.GetComponent <ApproachPanelController>().PopulateAttackPanel(hit.transform.gameObject);
shipController.isMoving = false;
shipController.engine1.enableEmission = false;
shipController.engine2.enableEmission = false;
}
}
}
private void SpawnHomePlanet()
{
Vector3 spawnPosition = new Vector3(0, 0, 0);
GameObject homePlanet = Instantiate(planet, spawnPosition, Quaternion.identity);
homePlanet.tag = "HomePlanet";
PlanetInformation planetInfo = homePlanet.GetComponent <PlanetInformation>();
SpriteRenderer spriteRenderer = homePlanet.GetComponent <SpriteRenderer>();
planetInfo.planetSprite = PlayerInfoStatic.HomePlanetSprite;
spriteRenderer.sprite = planetInfo.planetSprite;
planetInfo.planetName = "Home Planet";
planetInfo.isScanned = true;
planetInfo.type = PlayerInfoStatic.HomePlanetType;
homePlanet.transform.SetParent(GameObject.Find("SpaceSceneSaver").transform);
spawnedPlanets.Add(homePlanet);
// spawn the starting planets after spawning the home planet
SpawnStartingPlanets(homePlanet);
}
// Use this for initialization
void Start()
{
PlanetImage.Add("mercury", mercury);
PlanetImage.Add("venus", venus);
PlanetImage.Add("earth", earth);
PlanetImage.Add("mars", mars);
PlanetImage.Add("jupiter", jupiter);
PlanetImage.Add("saturn", saturn);
PlanetImage.Add("uranus", uranus);
PlanetImage.Add("neptune", neptune);
PlanetImage.Add("pluto", pluto);
planet = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <PlanetInformation>();
}
public void LoadPlanet(Planet planet)
{
this.planet = planet;
PlanetInformation.updateText();
}
public void PopulateAttackPanel(GameObject clickedPlanet)
{
// temp testing distance
float distance = Vector3.Distance(clickedPlanet.transform.position, playerShip.transform.position);
// end temp testing
// need to redo all of this for the scanner
selectedPlanet = clickedPlanet;
PlanetInformation planetInfo = clickedPlanet.GetComponent <PlanetInformation>();
planetNegativeEffect.text = "Planet Effect: " + "<color=#ff0000ff>" + planetInfo.negativeEffect + "</color>";
// switch statement moved to the actual planet the ui will get all of the planet info from the planet itself
if (ShipCloseToPlanet(clickedPlanet))
{
if (!planetInfo.isScanned)
{
planetInfo.revealInformationCase = "Scan01";
planetInfo.planetProximityScan = true;
planetInfo.PlanetSpriteStateMachine();
}
}
if (!ShipCloseToPlanet(clickedPlanet) && !planetInfo.isScanned)
{
planetInfo.revealInformationCase = "Scan00";
planetInfo.PlanetSpriteStateMachine();
}
if (!ShipCloseToPlanet(clickedPlanet) && planetInfo.planetProximityScan)
{
planetInfo.revealInformationCase = "Scan01";
planetInfo.PlanetSpriteStateMachine();
}
// if the planet is scanned then the state machine is already set so reveal the information
if (planetInfo.isScanned)
{
planetInfo.PlanetSpriteStateMachine();
}
planetImageSprite.sprite = planetInfo.GetComponent <SpriteRenderer>().sprite;
planetType.text = "Planet Type: " + planetInfo.uiType;
planetDifficulty.text = "Enemy Power Level: " + planetInfo.uiDifficulty;
planetName.text = planetInfo.planetName;
fuelTravelCost.text = "Fuel Cost to Planet: " + planetInfo.uiFuelCostToPlanet;
GetResourceImages(planetInfo);
fuelRewardText.text = planetInfo.uiFuelRewardAmount;
xpRewardText.text = planetInfo.uixPRewardAmount;
creditsRewardText.text = planetInfo.uiCreditRewardAmount;
if (ShipCloseToPlanet(clickedPlanet))
{
attackButton.enabled = true;
attackButtonText.text = "Attack Planet";
attackButtonText.color = Color.white;
}
else
{
attackButton.enabled = false;
attackButtonText.text = "(Planet too far to attack)";
attackButtonText.color = Color.gray;
}
}
private void OnInfoChanged()
{
switch (this._info?.ToLower().Trim())
{
case "soi-distance":
this._planetInformationType = PlanetInformation.SphereOfInfluenceDistance;
break;
case "soi-exit-distance":
this._planetInformationType = PlanetInformation.SphereOfInfluenceExitDistance;
break;
case "rotation-angle":
this._planetInformationType = PlanetInformation.RotationAngle;
break;
case "angular-velocity":
this._planetInformationType = PlanetInformation.AngularVelocity;
break;
case "is-terrain-data-loaded":
this._planetInformationType = PlanetInformation.IsTerrainDataLoaded;
break;
case "has-water":
this._planetInformationType = PlanetInformation.HasWater;
break;
case "sea-level":
this._planetInformationType = PlanetInformation.SeaLevel;
break;
case "structure-names":
this._planetInformationType = PlanetInformation.StructureNames;
break;
case "structure-locations":
this._planetInformationType = PlanetInformation.StructureLocations;
break;
case "structure-headings":
this._planetInformationType = PlanetInformation.StructureHeadings;
break;
case "launch-location-names":
this._planetInformationType = PlanetInformation.LaunchLocationNames;
break;
case "launch-locations":
this._planetInformationType = PlanetInformation.LaunchLocations;
break;
case "launch-location-headings":
this._planetInformationType = PlanetInformation.LaunchLocationHeadings;
break;
default:
this._planetInformationType = default;
break;
}
}
private void GetPossiblePlanetsToScan(string enterOrExit)
{
if (enterOrExit == "enter")
{
foreach (GameObject planet in planetSpawnerScript.spawnedPlanets)
{
PlanetInformation planetInfo = planet.GetComponent <PlanetInformation>();
float distance = Vector3.Distance(planet.transform.position, playerShip.transform.position);
// if the planet is in range and is not already scanned
if (!planetInfo.planetComplete && planetInfo.planetName != "Home Planet")
{
if (ShipStatsUpgradesStatic.GetShipScannerRange() == 0)
{
if (distance <= 8f)
{
planetInfo.GetComponent <SpriteRenderer>().sprite = planetInfo.unknownPlanetScanSprite;
}
}
else if (ShipStatsUpgradesStatic.GetShipScannerRange() == 1)
{
if (distance <= 10f)
{
planetInfo.GetComponent <SpriteRenderer>().sprite = planetInfo.unknownPlanetScanSprite;
}
}
else if (ShipStatsUpgradesStatic.GetShipScannerRange() == 2)
{
if (distance <= 12f)
{
planetInfo.GetComponent <SpriteRenderer>().sprite = planetInfo.unknownPlanetScanSprite;
}
}
else if (ShipStatsUpgradesStatic.GetShipScannerRange() == 3)
{
if (distance <= 14f)
{
planetInfo.GetComponent <SpriteRenderer>().sprite = planetInfo.unknownPlanetScanSprite;
}
}
else if (ShipStatsUpgradesStatic.GetShipScannerRange() == 4)
{
if (distance <= 16f)
{
planetInfo.GetComponent <SpriteRenderer>().sprite = planetInfo.unknownPlanetScanSprite;
}
}
}
}
}
else
{
foreach (GameObject planet in planetSpawnerScript.spawnedPlanets)
{
PlanetInformation planetInfo = planet.GetComponent <PlanetInformation>();
// if the planet is in range and is not already scanned
if (planetInfo.GetComponent <SpriteRenderer>().sprite == planetInfo.unknownPlanetScanSprite)
{
if (planetInfo.isScanned || planetInfo.planetProximityScan)
{
planetInfo.GetComponent <SpriteRenderer>().sprite = planetInfo.planetSprite;
}
else
{
planetInfo.GetComponent <SpriteRenderer>().sprite = planetInfo.unknownPlanetSprite;
}
}
}
}
}
public void Awake()
{
info = this;
}
