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; } }