public override void OnBeatSuccess(BasePlanet planet, BeatResult result)
{
if (planet != this)
{
return;
}
int resultBonus = result == BeatResult.Awesome ? 2 : 1;
if (planetState == PlanetState.Colonized)
{
List <BasePlanet> destroyed = manager.GetDestroyedPlanets(teamID);
if (destroyed.Count > 0 && manager.GetResourceType(repairCost.type) >= repairCost.amount)
{
int idx = UnityEngine.Random.Range(0, destroyed.Count - 1);
destroyed[idx].Repair();
manager.SpendResource(repairCost.type, repairCost.amount);
}
else
{
int units = baseBeatRate * resultBonus;
Debug.LogFormat("Adding {0} units of {1}", units, PlanetUtils.GetResourceName(resourceType));
manager.AddResource(resourceType, units);
}
}
BlinkColour();
CheckColonize(planet);
}
public void InitLeaderBoardListForPlanet()
{
List <PlanetVO> allPlayerFacingPlanets = PlanetUtils.GetAllPlayerFacingPlanets();
for (int i = 0; i < allPlayerFacingPlanets.Count; i++)
{
string uid = allPlayerFacingPlanets[i].Uid;
LeaderboardList <PlayerLBEntity> value = new LeaderboardList <PlayerLBEntity>();
this.LeadersByPlanet.Add(uid, value);
value = new LeaderboardList <PlayerLBEntity>();
this.LeadersNearMeByPlanet.Add(uid, value);
}
List <TournamentVO> allLiveAndClosingTournaments = TournamentController.GetAllLiveAndClosingTournaments();
int j = 0;
int count = allLiveAndClosingTournaments.Count;
while (j < count)
{
string planetId = allLiveAndClosingTournaments[j].PlanetId;
if (this.TournamentLeadersByPlanet.ContainsKey(planetId))
{
Service.Logger.Error("Multiple tournaments are active on planet " + planetId);
}
else
{
this.InitTournamentListForPlanet(planetId);
}
j++;
}
}
public override void OnBeatFailed(BasePlanet planet)
{
if (planet != this && planetState != PlanetState.Colonized)
{
return;
}
base.OnBeatFailed(planet);
Debug.LogFormat("Lost {0} units of {1}", resourcePenalty, PlanetUtils.GetResourceName(resourceType));
manager.DecreaseResource(resourceType, resourcePenalty);
}
private void DestinationPlanetLoadSuccess(object asset, object cookie)
{
this.destinationPlanetLoadReturned = true;
this.destinationPlanetGameObject = (asset as GameObject);
if (this.destinationPlanetGameObject == null)
{
Service.Get <StaRTSLogger>().Warn("Invalid GameObject: " + this.destinationVO.GalaxyAssetName);
}
else
{
this.planetMaterial = PlanetUtils.StopPlanetSpinning(this.destinationPlanetGameObject);
}
this.AssembleHyperSpace();
}
public override void OnBeatSuccess(BasePlanet planet, BeatResult result)
{
if (planet != this)
{
return;
}
int resultBonus = result == BeatResult.Awesome ? 2 : 1;
if (planetState == PlanetState.Colonized)
{
int units = baseBeatRate * resultBonus;
Debug.LogFormat("Adding {0} units of {1}", units, PlanetUtils.GetResourceName(resourceType));
manager.AddResource(resourceType, units);
}
base.OnBeatSuccess(planet, result);
}
private void InitPlanetOptionPlayerTab()
{
this.planetGrid.Clear();
this.planetGrid.Visible = true;
this.selectedPlanet = null;
List <PlanetVO> allPlayerFacingPlanets = PlanetUtils.GetAllPlayerFacingPlanets();
foreach (PlanetVO current in allPlayerFacingPlanets)
{
if (current != null)
{
this.AddPlanetButton(current, false, false);
}
}
this.AddAllPlanetButton();
this.planetOptionPanelBackground.Height = (float)this.planetGrid.Count * this.planetGrid.CellHeight + 20f;
this.planetGrid.RepositionItems();
}
private void OnPlanetLoaded(object asset, object cookie)
{
if (Service.Get <ScreenController>().IsFatalAlertActive())
{
return;
}
MainCamera mainCamera = Service.Get <CameraManager>().MainCamera;
CurrentPlayer currentPlayer = Service.Get <CurrentPlayer>();
AssetManager assetManager = Service.Get <AssetManager>();
AssetHandle eventEffectsHandle = AssetHandle.Invalid;
AssetHandle particleFXHandle = AssetHandle.Invalid;
AssetHandle planetGlowHandle = AssetHandle.Invalid;
Planet planet = (Planet)cookie;
GameObject gameObject = (GameObject)asset;
planet.PlanetGameObject = gameObject;
Transform transform = gameObject.transform;
transform.position = this.GetPlanetVect3Position(planet.VO.Angle, planet.VO.Radius, -planet.VO.HeightOffset);
planet.planetMaterial = PlanetUtils.GetPlanetMaterial(gameObject);
Bounds gameObjectLocalBounds = UnityUtils.GetGameObjectLocalBounds(gameObject, false);
planet.ObjectExtents = gameObjectLocalBounds.extents;
PlanetRef planetRef = gameObject.AddComponent <PlanetRef>();
planetRef.Planet = planet;
BoxCollider boxCollider = gameObject.AddComponent <BoxCollider>();
boxCollider.size = gameObjectLocalBounds.size;
Service.Get <UXController>().MiscElementsManager.CreatePlanetBackgroundUI(planet);
planet.planetMaterial = PlanetUtils.GetPlanetMaterial(gameObject);
if (!currentPlayer.IsPlanetUnlocked(planet.VO.Uid))
{
Service.Get <UXController>().MiscElementsManager.CreatePlanetLockedUI(planet);
planet.planetMaterial.SetFloat("_Bright", 0.35f);
}
assetManager.Load(ref planetGlowHandle, "fx_planetGlow", new AssetSuccessDelegate(this.OnPlanetGlowEffectLoaded), null, planet);
planet.PlanetGlowHandle = planetGlowHandle;
string text = "";
if (currentPlayer.Faction == FactionType.Empire)
{
text = "tiefighterplanet_emp-ani";
}
else if (currentPlayer.Faction == FactionType.Rebel)
{
text = "xwingplanet_rbl-ani";
}
if (!string.IsNullOrEmpty(text))
{
assetManager.Load(ref eventEffectsHandle, text, new AssetSuccessDelegate(this.OnEventEffectsLoaded), new AssetFailureDelegate(this.OnEffectLoadFailed), planet);
}
if (this.DoesPlanetHaveEvent(planet))
{
TimedEventState tournamentState = planet.TournamentState;
if (tournamentState != TimedEventState.Upcoming)
{
if (tournamentState == TimedEventState.Live)
{
assetManager.Load(ref particleFXHandle, "fx_planet_Conflict", new AssetSuccessDelegate(this.OnEventParticleFXLoaded), new AssetFailureDelegate(this.OnParticleFXLoadFailed), planet);
}
}
else
{
assetManager.Load(ref particleFXHandle, "fx_planet_Imminent", new AssetSuccessDelegate(this.OnEventParticleFXLoaded), new AssetFailureDelegate(this.OnParticleFXLoadFailed), planet);
}
}
planet.EventEffectsHandle = eventEffectsHandle;
planet.ParticleFXHandle = particleFXHandle;
transform.LookAt(mainCamera.Camera.transform.position);
}
public void InitPlanets(string startPlanetUid)
{
PlanetStatsCommand planetStatsCommand = null;
PlanetStatsRequest planetStatsRequest = null;
AssetManager assetManager = Service.Get <AssetManager>();
if (this.updatePlanetPopulations)
{
this.updatePlanetPopulations = false;
planetStatsRequest = new PlanetStatsRequest();
planetStatsCommand = new PlanetStatsCommand(planetStatsRequest);
}
this.planetIndex = 0;
this.planetsWithEvent.Clear();
this.planetsWithActiveEvents.Clear();
List <PlanetVO> allPlayerFacingPlanets = PlanetUtils.GetAllPlayerFacingPlanets();
int i = 0;
int count = allPlayerFacingPlanets.Count;
while (i < count)
{
Planet planet = new Planet(allPlayerFacingPlanets[i]);
AssetHandle handle = AssetHandle.Invalid;
if (planet.VO.Uid == startPlanetUid)
{
this.currentlyForegroundedPlanet = planet;
this.InitialPlanetPosition = this.GetPlanetVect3Position(planet.VO.Angle, planet.VO.Radius, -planet.VO.HeightOffset);
}
if (planetStatsRequest != null)
{
planetStatsRequest.AddPlanetID(planet.VO.Uid);
}
else
{
planet.ThrashingPopulation = planet.VO.Population;
}
planet.IsCurrentPlanet = (startPlanetUid == planet.VO.Uid);
this.planets.Add(planet);
this.planetLookupDict[planet.VO.Uid] = planet;
planet.Tournament = null;
TournamentVO activeTournamentOnPlanet = TournamentController.GetActiveTournamentOnPlanet(planet.VO.Uid);
if (activeTournamentOnPlanet != null)
{
TimedEventState state = TimedEventUtils.GetState(activeTournamentOnPlanet);
if (state == TimedEventState.Live)
{
this.planetsWithEvent.Add(planet);
planet.Tournament = activeTournamentOnPlanet;
this.planetsWithActiveEvents.Add(planet);
}
else if (state == TimedEventState.Upcoming)
{
this.planetsWithEvent.Add(planet);
}
}
planet.UpdatePlanetTournamentState();
assetManager.Load(ref handle, planet.VO.GalaxyAssetName, new AssetSuccessDelegate(this.OnPlanetLoaded), null, planet);
planet.Handle = handle;
i++;
}
this.UpdatePlanetsFriendData();
this.UpdatePlanetsSquadData();
if (planetStatsCommand != null)
{
Service.Get <ServerAPI>().Sync(planetStatsCommand);
}
this.planets.Sort(new Comparison <Planet>(this.ComparePlanetOrder));
}
private void AssembleLoadingScene()
{
if (this.onlyLoadUI)
{
if (!this.uiLoadReturned)
{
return;
}
this.ExecuteCallBack();
}
if (!this.uiLoadReturned || !this.modelAssetLoadReturned || !this.planetAssetLoadReturned || !this.planetGlowAssetLoadReturned || !this.starfieldAssetLoadReturned)
{
return;
}
if (this.modelGameObject != null)
{
UnityUtils.SetLayerRecursively(this.modelGameObject, 9);
Transform transform = this.modelGameObject.transform;
transform.parent = base.Root.transform.parent;
transform.localPosition = Vector3.zero;
transform.localRotation = Quaternion.identity;
transform.localScale = Vector3.one;
this.planetAnchor = UnityUtils.FindGameObject(this.modelGameObject, "PlanetAnchor");
}
if (this.planetAnchor != null)
{
Camera camera = Service.CameraManager.UXSceneCamera.Camera;
if (this.planetGameObject != null)
{
this.planetGameObject.SetActive(true);
UnityUtils.SetLayerRecursively(this.planetGameObject, 9);
Transform transform2 = this.planetGameObject.transform;
transform2.parent = this.planetAnchor.transform;
transform2.localPosition = Vector3.zero;
transform2.localRotation = Quaternion.identity;
transform2.localScale = Vector3.one;
this.planetMaterial = PlanetUtils.StopPlanetSpinning(this.planetGameObject);
Service.GalaxyPlanetController.SetPlanetLighting(this.planetGameObject, this.planetMaterial, camera);
}
if (this.planetGlowGameObject != null)
{
this.planetGlowGameObject.SetActive(true);
UnityUtils.SetLayerRecursively(this.planetGlowGameObject, 9);
Transform transform3 = this.planetGlowGameObject.transform;
transform3.parent = this.planetAnchor.transform;
transform3.localPosition = Vector3.zero;
transform3.localRotation = Quaternion.identity;
transform3.localScale = Vector3.one;
transform3.LookAt(camera.transform.position);
}
}
if (this.starsGameObject != null)
{
UnityUtils.SetLayerRecursively(this.starsGameObject, 9);
Transform transform4 = this.starsGameObject.transform;
transform4.parent = base.Root.transform.parent;
transform4.localPosition = Vector3.zero;
transform4.localRotation = Quaternion.identity;
transform4.localScale = Vector3.one;
}
this.ExecuteCallBack();
}
