public void TrainSoldier(AbstractPlanet planet)
{
switch (planet.planetOwnership)
{
case AbstractPlanet.Ownership.Player:
if (playerResources >= GamePlay.SOLDIER_COST)
{
playerSoldierCount += GamePlay.SOLDIER_UNIT;
playerResources -= GamePlay.SOLDIER_COST;
planet.playerSoldiers += GamePlay.SOLDIER_UNIT;
}
else
{
NotificationBoardScript.Instance.PushMessage(Notifications.NO_SOLDIER_RESOURCE_MSG);
}
break;
case AbstractPlanet.Ownership.Enemy:
if (enemyResources >= GamePlay.SOLDIER_COST)
{
enemySoldierCount += GamePlay.SOLDIER_UNIT;
enemyResources -= GamePlay.SOLDIER_COST;
planet.enemySoldiers += GamePlay.SOLDIER_UNIT;
}
break;
case AbstractPlanet.Ownership.Neutral:
break;
}
}
void CheckShip()
{
ships = gameManager.shipContainer.gameObject.GetComponentsInChildren <ShipScript>();
foreach (ShipScript s in ships)
{
if (s.shipOwnership == AbstractPlanet.Ownership.Enemy)
{
if (s.dockedPlanet != null && s.dockedPlanet.planetOwnership != AbstractPlanet.Ownership.Enemy)
{
//Send to neighboring planet with this order: Enemy => Neutral => Player
AbstractPlanet docked = s.dockedPlanet;
AbstractPlanet bestPlanet = null;
foreach (AbstractPlanet planet in docked.adjacentPlanet)
{
if (planet.planetOwnership == AbstractPlanet.Ownership.Enemy)
{
bestPlanet = planet;
break;
}
else if (planet.planetOwnership == AbstractPlanet.Ownership.Neutral)
{
bestPlanet = planet;
}
}
if (bestPlanet == null)
{
bestPlanet = docked.adjacentPlanet [0];
}
LaunchShip(docked, bestPlanet, docked.adjacentPaths, s);
action++;
}
}
}
}
int RecursivePlanetFind(AbstractPlanet prevPlanet, AbstractPlanet currentPlanet, AbstractPlanet target)
{
int sum = 0;
if (searched.Contains(currentPlanet))
{
return(0);
}
else
{
searched.Add(currentPlanet);
}
if (currentPlanet == target)
{
return(1);
}
else if (!currentPlanet.isFeeding)
{
return(0);
}
else
{
for (int i = 0; i < currentPlanet.adjacentPlanet.Length; i++)
{
int val = RecursivePlanetFind(currentPlanet, currentPlanet.adjacentPlanet [i], target);
sum += val;
if (sum > 0)
{
return(sum);
}
}
return(sum);
}
}
void NeighborAttackedAction(ref AbstractPlanet planet)
{
foreach (AbstractPlanet neigh in planet.adjacentPlanet)
{
if (actionHappened)
{
continue;
}
if (neigh.isContested && planet.planetOwnership == AbstractPlanet.Ownership.Enemy) //Is my neighbor planet being attacked
{
if (ValidPlanetForTraining(ref planet))
{
planet.TrainSoldiers(true);
}
planet.isFeeding = true;
float totalUnits = neigh.enemySoldiers + neigh.playerSoldiers;
if (neigh.playerSoldiers / totalUnits > 0.50f)
{
ship = planet.CreateShip(AbstractPlanet.Ownership.Enemy);
if (ship.soldiersOnBoard == ship.soldierCapacity ||
(!CanNewUnitsBeCreated() && ship.soldiersOnBoard > 0))
{
LaunchShip(planet, neigh, planet.adjacentPaths, ship);
}
else if (!ship.GetIsLoading())
{
ship.StartLoadingSoldiersToShip(planet);
}
}
action++;
actionHappened = true;
}
}
}
void BeingAttackedAction(ref AbstractPlanet planet)
{
if (planet.isContested)
{
if (ValidPlanetForTraining(ref planet))
{
planet.TrainSoldiers(true);
}
planet.isRequestingSoldiers = true;
//Unload my ship if I have one
ship = planet.ships [Indices.SHIP_ENEMY];
if (ship)
{
ship.StopLoadingSoldiersToShip();
//Send units to nearest neighbor
if (ship.soldiersOnBoard > 0)
{
AbstractPlanet target = NearestNeighbor(planet);
LaunchShip(planet, target, planet.adjacentPaths, ship);
}
}
action++;
actionHappened = true;
}
else
{
planet.isRequestingSoldiers = false;
}
}
bool ValidPlanetForTraining(ref AbstractPlanet planet)
{
if (planet.GetPlanetType() == AbstractPlanet.PlanetType.Hybrid || planet.GetPlanetType() == AbstractPlanet.PlanetType.Soldier)
{
return(true);
}
return(false);
}
protected override void OnActivate()
{
AbstractPlanet planet = targetGameObject.GetComponent <AbstractPlanet> ();
reactor = planet.GetComponent <ReactorPlanetScript>();
ownership = planet.planetOwnership;
gameManager = ManagerScript.Instance;
CheckForUpdate();
}
/**
* The planet variable should store the current post-capture "new" ownership
**/
public void CapturePlanet(AbstractPlanet.Ownership previousOwner, AbstractPlanet planet)
{
switch (planet.planetOwnership)
{
case AbstractPlanet.Ownership.Player:
if (previousOwner == AbstractPlanet.Ownership.Enemy)
{
enemyPlanets.Remove(planet);
playerPlanets.Add(planet);
}
else if (previousOwner == AbstractPlanet.Ownership.Neutral)
{
playerPlanets.Add(planet);
}
else //This condition shouldn't happen
{
if (!playerPlanets.Contains(planet))
{
playerPlanets.Add(planet);
}
}
break;
case AbstractPlanet.Ownership.Enemy:
if (previousOwner == AbstractPlanet.Ownership.Player)
{
playerPlanets.Remove(planet);
enemyPlanets.Add(planet);
}
else if (previousOwner == AbstractPlanet.Ownership.Neutral)
{
enemyPlanets.Add(planet);
}
else //This condition shouldn't happen
{
if (!enemyPlanets.Contains(planet))
{
enemyPlanets.Add(planet);
}
}
break;
case AbstractPlanet.Ownership.Neutral: //This condition shouldn't happen
if (enemyPlanets.Contains(planet))
{
enemyPlanets.Remove(planet);
}
if (playerPlanets.Contains(planet))
{
playerPlanets.Remove(planet);
}
break;
}
}
bool PlanetInPath(AbstractPlanet planet, AbstractPlanet target)
{
searched.Clear();
int val = RecursivePlanetFind(null, planet, target);
if (val > 0)
{
return(true);
}
return(false);
}
AbstractPlanet NearestNeighbor(AbstractPlanet planet)
{
foreach (AbstractPlanet neigh in planet.adjacentPlanet)
{
if (neigh.planetOwnership == AbstractPlanet.Ownership.Enemy)
{
return(neigh);
}
}
return(planet.adjacentPlanet[0]);
}
void Launch(PathScript path)
{
ShipScript ship = planetScript.ships [Indices.SHIP_PLAYER];
ship.gameObject.SetActive(true);
AbstractPlanet targetPlanet = path.GetDirectionStartingFrom(transform).end.gameObject.GetComponent <AbstractPlanet>();
if (targetPlanet != null)
{
ship.LaunchShipOnPath(path, transform, targetPlanet);
}
}
public void ActivateForPlanet(AbstractPlanet planet)
{
Deactivate();
selectedPlanet = planet.gameObject;
activatedPanel = contextualMenuMap[planet.GetPlanetType()];
activatedPanel.SetActive(true);
panelScripts = activatedPanel.GetComponents <AbstractPanel>();
foreach (AbstractPanel panelScript in panelScripts)
{
panelScript.ActivateForGameObject(selectedPlanet);
}
}
// Update is called once per frame
void Update()
{
AbstractPlanet selectedPlanet = ManagerScript.Instance.GetSelectedPlanet();
if (selectedPlanet)
{
spotlight.TurnOnFor(selectedPlanet.transform);
}
else
{
spotlight.TurnOff();
}
}
public PathScript[] GetAdjacentPaths(AbstractPlanet planet)
{
List <PathScript> paths = new List <PathScript>();
foreach (PathScript path in this.pathList)
{
if (path.start == planet.transform || path.end == planet.transform)
{
paths.Add(path);
}
}
return(paths.ToArray());
}
void NeighborNeedsSoldiersAction(ref AbstractPlanet planet)
{
foreach (AbstractPlanet neigh in planet.adjacentPlanet)
{
if (actionHappened)
{
continue;
}
AbstractPlanet target = null;
if (neigh.planetOwnership == AbstractPlanet.Ownership.Enemy && neigh.isRequestingSoldiers)
{
if (ValidPlanetForTraining(ref planet))
{
planet.TrainSoldiers(true);
}
planet.isFeeding = true;
planet.planetRequesting = neigh;
target = neigh;
}
else if (neigh.planetOwnership == AbstractPlanet.Ownership.Enemy && neigh.isFeeding)
{
if (PlanetInPath(neigh, neigh.planetRequesting) && neigh != neigh.planetRequesting)
{
if (ValidPlanetForTraining(ref planet))
{
planet.TrainSoldiers(true);
}
planet.isFeeding = true;
planet.planetRequesting = neigh.planetRequesting;
target = neigh;
}
}
if (target)
{
ship = planet.CreateShip(AbstractPlanet.Ownership.Enemy);
if (ship.soldiersOnBoard >= ship.soldierCapacity * 0.1f ||
(!CanNewUnitsBeCreated() && ship.soldiersOnBoard > 0))
{
LaunchShip(planet, target, planet.adjacentPaths, ship);
}
else if (!ship.GetIsLoading())
{
ship.StartLoadingSoldiersToShip(planet);
}
action++;
actionHappened = true;
}
}
}
// Use this for initialization
void Start()
{
planet = transform.parent.gameObject.GetComponent <AbstractPlanet>();
spotLight = combatBar.gameObject.GetComponentInChildren <Light> ();
spotLight.type = LightType.Spot;
spotLight.intensity = 0;
combatBar.gameObject.SetActive(false);
isSoundPlaying = false;
//For Testing
if (upgradeIcon)
{
upgradeIcon.gameObject.SetActive(false);
soldierIcon.gameObject.SetActive(false);
}
}
void LaunchShip(AbstractPlanet planet, AbstractPlanet target, PathScript[] paths, ShipScript ship)
{
PathScript chosenPath = null;
foreach (PathScript path in paths)
{
if ((path.start == planet.transform && path.end == target.transform) ||
(path.end == planet.transform && path.start == target.transform))
{
chosenPath = path;
break;
}
}
ship.LaunchShipOnPath(chosenPath, planet.transform, target);
}
void UpgradeAction(ref AbstractPlanet planet)
{
if (planet.GetPlanetType() == AbstractPlanet.PlanetType.Reactor)
{
if (gameManager.enemyResources > 100 && CanNewUnitsBeCreated())
{
if (!gameManager.GetUpgrading())
{
gameManager.ActivateUpgrade(true, AbstractPlanet.Ownership.Enemy);
action++;
actionHappened = true;
}
}
}
}
public AbstractPlanet[] GetAdjacentPlanets(AbstractPlanet planet)
{
List <AbstractPlanet> planets = new List <AbstractPlanet>();
foreach (PathScript path in this.pathList)
{
if (path.start == planet.transform)
{
planets.Add(path.end.gameObject.GetComponent <AbstractPlanet>());
}
else if (path.end == planet.transform)
{
planets.Add(path.start.gameObject.GetComponent <AbstractPlanet>());
}
}
return(planets.ToArray());
}
int AbsolutePlanetStrength(AbstractPlanet ps)
{
int skulls = 0;
switch (ps.planetOwnership)
{
case AbstractPlanet.Ownership.Player:
skulls = ps.playerSoldiers / GamePlay.SOLDIERS_PER_SKULL;
return(ps.playerSoldiers == 0 ? 0 : skulls + 1);
case AbstractPlanet.Ownership.Enemy:
skulls = ps.enemySoldiers / GamePlay.SOLDIERS_PER_SKULL;
return(ps.enemySoldiers == 0 ? 0 : skulls + 1);
default:
return(0);
}
}
void PlanetActions(AbstractPlanet planet)
{
//Always create units
CreateUnits(planet);
//Always send units to neighboring planets once ship capacity is met
//Create ship
planet.CreateShip(AbstractPlanet.Ownership.Enemy);
//Load Units to ship
planet.LoadSoldiersToShip(planet.ships[Indices.SHIP_ENEMY]);
//Load Soldiers Units until ship capacity is met
if ((planet.enemySoldiers == 0 && planet.ships[Indices.SHIP_ENEMY].soldiersOnBoard > 0) ||
planet.ships[Indices.SHIP_ENEMY].soldiersOnBoard >= planet.ships [Indices.SHIP_ENEMY].soldierCapacity)
{
//Send units to a neighboring planet
neighboringPlanet = ChoosePlanet(planet);
//Launch Ship to neighboring planet
LaunchShip(planet, neighboringPlanet, planet.adjacentPaths, planet.ships [Indices.SHIP_ENEMY]);
}
}
AbstractPlanet ChoosePlanet(AbstractPlanet planet)
{
AbstractPlanet result = null;
AbstractPlanet[] neighPlanets = planet.adjacentPlanet;
foreach (AbstractPlanet neighbor in neighPlanets)
{
if (neighbor.planetOwnership != AbstractPlanet.Ownership.Enemy)
{
result = neighbor;
}
}
if (result == null)
{
result = planet.adjacentPlanet [0];
}
return(result);
}
public ShipScript CreateShip(AbstractPlanet planet, int level)
{
ShipScript ship = null;
AbstractPlanet.Ownership ownership = planet.planetOwnership;
if (ownership == AbstractPlanet.Ownership.Player && HasLevel(playerShipPrefabs, level))
{
ship = CreateShip(playerShipPrefabs[level]);
ship.shipOwnership = AbstractPlanet.Ownership.Player;
}
if (ownership == AbstractPlanet.Ownership.Enemy && HasLevel(enemyShipPrefabs, level))
{
ship = CreateShip(enemyShipPrefabs[level]);
ship.shipOwnership = AbstractPlanet.Ownership.Enemy;
}
ship.dockedPlanet = planet;
return(ship);
}
void ExpandAction(ref AbstractPlanet planet)
{
foreach (AbstractPlanet neigh in planet.adjacentPlanet)
{
if (actionHappened)
{
continue;
}
if (neigh.planetOwnership == AbstractPlanet.Ownership.Neutral && neigh.isContested == false)
{
if (planet.GetPlanetType() != AbstractPlanet.PlanetType.Hybrid && planet.GetPlanetType() != AbstractPlanet.PlanetType.Soldier && planet.enemySoldiers == 0)
{
planet.isRequestingSoldiers = true;
}
else
{
planet.isRequestingSoldiers = false;
planet.planetRequesting = null;
if (ValidPlanetForTraining(ref planet))
{
planet.TrainSoldiers(true);
}
}
ship = planet.CreateShip(AbstractPlanet.Ownership.Enemy);
if (ship.soldiersOnBoard >= 1 ||
(!CanNewUnitsBeCreated() && ship.soldiersOnBoard > 0))
{
LaunchShip(planet, neigh, planet.adjacentPaths, ship);
planet.TrainSoldiers(false);
}
else if (!ship.GetIsLoading())
{
ship.StartLoadingSoldiersToShip(planet);
}
action++;
actionHappened = true;
}
}
}
void MoveShip()
{
isSoldierLoading = false;
isUnloading = false;
shipRenderer.enabled = true;
if (traveledDistance <= sizeChangingDistance || remainingDistance <= sizeChangingDistance)
{
this.transform.localScale = Mathf.Min(traveledDistance, remainingDistance) / sizeChangingDistance * Vector3.one;
}
if (remainingDistance < 0.05f)
{
dockedPlanet = targetPlanet;
UnloadShip();
Destroy(this.gameObject);
}
else
{
transform.position = Vector3.MoveTowards(transform.position, travelPath.end.position, Mathf.Min(movementSpeed * Time.deltaTime, remainingDistance));
}
}
void PlayerNearAction(ref AbstractPlanet planet)
{
foreach (AbstractPlanet neigh in planet.adjacentPlanet)
{
if (actionHappened)
{
continue;
}
if (neigh.planetOwnership == AbstractPlanet.Ownership.Player) //Is there an enemy next to me
{
if (ValidPlanetForTraining(ref planet))
{
planet.TrainSoldiers(true);
}
planet.isRequestingSoldiers = true;
//Am I stronger then the enemy, then attack
int estimatedUnits = (int)Mathf.Max(neigh.rankingScript.currentRank * 50 - 25, 0);
ship = planet.CreateShip(AbstractPlanet.Ownership.Enemy);
if ((ship.soldiersOnBoard + planet.enemySoldiers) > (estimatedUnits))
{
if (ship.soldiersOnBoard == ship.soldierCapacity || ship.soldiersOnBoard > estimatedUnits)
{
LaunchShip(planet, neigh, planet.adjacentPaths, ship);
}
else if (!ship.GetIsLoading())
{
ship.StartLoadingSoldiersToShip(planet);
}
}
else
{
ship.StopLoadingSoldiersToShip();
}
action++;
actionHappened = true;
}
}
}
string GetPlanetTypeName(AbstractPlanet planet)
{
switch (planet.GetPlanetType())
{
case AbstractPlanet.PlanetType.Hybrid:
return(PlanetNames.HYBRID_PLANET);
case AbstractPlanet.PlanetType.Normal:
return(PlanetNames.NORMAL_PLANET);
case AbstractPlanet.PlanetType.Reactor:
return(PlanetNames.REACTOR_PLANET);
case AbstractPlanet.PlanetType.Resource:
return(PlanetNames.RESOURCE_PLANET);
case AbstractPlanet.PlanetType.Soldier:
return(PlanetNames.SOLDIER_PLANET);
}
Debug.LogError("NormalContextMenu: PlanetType was not set on planet!");
return(null);
}
public void LaunchShipOnPath(PathScript path, Transform from, AbstractPlanet targetPlanet)
{
this.targetPlanet = targetPlanet;
ManagerScript.Instance.audioManager.PlaySound("shipMove");
switch (shipOwnership)
{
case AbstractPlanet.Ownership.Player:
dockedPlanet.ships[Indices.SHIP_PLAYER] = null;
break;
case AbstractPlanet.Ownership.Enemy:
dockedPlanet.ships[Indices.SHIP_ENEMY] = null;
break;
case AbstractPlanet.Ownership.Neutral:
break;
}
isShipMoving = true;
this.travelPath = path.GetDirectionStartingFrom(from);
this.transform.position = travelPath.shipStart;
this.transform.rotation = Quaternion.LookRotation(travelPath.shipEnd - travelPath.shipStart);
this.transform.localScale = Vector3.zero;
}
void SetPlanetStarRanking()
{
int numPlanets = planets.Length;
for (int i = 0; i < numPlanets; i++)
{
AbstractPlanet ps = planets[i];
//Turn off ranking stars if there is no ownership
if (ps.planetOwnership == AbstractPlanet.Ownership.Neutral)
{
ps.rankingScript.SetActive(false);
continue;
}
else
{
ps.rankingScript.SetActive(true);
}
//Determine Soldier Strength
int skulls = AbsolutePlanetStrength(ps);
ps.rankingScript.currentRank = Mathf.Min(skulls, 5);
//Determine star color
ps.rankingScript.activeColor = SkullColor(ps.planetOwnership, skulls);
}
}
// Update is called once per frame
void Update()
{
thinkTimer += Time.deltaTime;
if (thinkTimer >= thinkTime)
{
//Check if I have a ship with units doing nothing
CheckShip();
//Enemy Planet Actions
for (int i = 0; i < enemyPlanets.Count; i++)
{
AbstractPlanet planet = enemyPlanets [i];
actionHappened = false;
//Do nothing else if you have no more actions
if (action > actionsLimit)
{
continue;
}
//Can I upgrade
UpgradeAction(ref planet);
if (actionHappened)
{
continue;
}
//Am I being attacked
BeingAttackedAction(ref planet);
if (actionHappened)
{
continue;
}
//Is there a player adajacent to me
PlayerNearAction(ref planet);
if (actionHappened)
{
continue;
}
planet.isRequestingSoldiers = false;
planet.planetRequesting = null;
//Is a planet next to me being attacked
NeighborAttackedAction(ref planet);
if (actionHappened)
{
continue;
}
planet.isFeeding = false;
planet.planetRequesting = null;
//Does my neighbor need soldiers
NeighborNeedsSoldiersAction(ref planet);
if (actionHappened)
{
continue;
}
planet.isFeeding = false;
planet.planetRequesting = null;
//Do I want to expand
ExpandAction(ref planet);
if (actionHappened)
{
continue;
}
//Can I train soldiers with this economy
if (CanNewUnitsBeCreated())
{
planet.TrainSoldiers(true);
action++;
}
else
{
planet.TrainSoldiers(false);
}
}
thinkTimer = 0;
action = 0;
}
}