using System;
using System.Collections;
using System.Collections.Generic;
using CIG;
using CIG.Translation;
using CIGEnums;
using Inno.DLC;
using SUISS.Core;
using SUISS.Scheduling;
using SUISSEngine;
using UnityEngine;

public class CityIsland : MonoBehaviour, IHasNotification
{
	public CIGBuilding[] BuiltBuildings
	{
		get
		{
			return base.GetComponentInChildren<IsometricGrid>().GetComponentsInChildren<CIGBuilding>();
		}
	}

	public static string VersionString
	{
		get
		{
			return string.Format("{0} ({1}Build {2})", NativeGameVersion.Version, (!Debug.isDebugBuild) ? string.Empty : "Debug ", NativeGameVersion.Build);
		}
	}

	public bool IsTimeSpeedupActive
	{
		get
		{
			return this.timeSpeedupActive;
		}
	}

	public DateTime TimeWarpEnd { get; private set; }

	public double TimeBoostMultiplier { get; private set; }

	public string DlcMusicName
	{
		get
		{
			return this.dlcMusicName + ".mp3";
		}
	}

	public static CityIsland GetParent(Component node)
	{
		return node.GetComponentInParent<CityIsland>();
	}

	public static bool IsCurrent(CityIsland cityIsland)
	{
		if (cityIsland == null)
		{
			return CityIsland.Current == null;
		}
		return CityIsland.Current != null && cityIsland.island == CityIsland.Current.island;
	}

	public static bool IsCurrent(Island island)
	{
		if (CityIsland.Current == null)
		{
			return island == Island.None;
		}
		return island == CityIsland.Current.island;
	}

	public PlannedNotification[] GetNotifications()
	{
		List<PlannedNotification> list = new List<PlannedNotification>();
		list.Add(IAPPackSaleLocalNotifications.GetNotification());
		int num = 0;
		int num2 = 0;
		foreach (GridTile gridTile in this.isometricIsland.grid.Tiles)
		{
			CIGCommercialBuilding component = gridTile.GetComponent<CIGCommercialBuilding>();
			if (component != null)
			{
				num2++;
				num = Math.Max(num, component.ProfitTimeLeft);
			}
		}
		if (num > 0 && num2 >= 5)
		{
			int seconds = Math.Max(300, num + 60);
			list.Add(new PlannedNotification(seconds, Localization.Key("notification_commercial_buildings_ready"), false));
		}
		return list.ToArray();
	}

	protected void Awake()
	{
		if (this.expansions == null)
		{
			UnityEngine.Debug.LogWarning("Cannot find CIGExpansions component");
		}
		IsometricIsland oldIsland = null;
		if (CityIsland.Current != null)
		{
			oldIsland = CityIsland.Current.isometricIsland;
		}
		HUDState hudstate = UnityEngine.Object.FindObjectOfType<HUDState>();
		if (hudstate != null)
		{
			hudstate.OnIslandChange(oldIsland, this.isometricIsland);
		}
		CityIsland.Current = this;
		if (this.isometricIsland == null)
		{
			UnityEngine.Debug.LogError("Cannot find IsometricIsland component to set Current!");
		}
		else
		{
			IsometricIsland.Current = this.isometricIsland;
		}
	}

	protected void Start()
	{
		this.fsm = UnityEngine.Object.FindObjectOfType<FiniteStateMachine>();
		SingletonMonobehaviour<CIGAudioManager>.Instance.EnableMusic(Singleton<CIGSettings>.Instance.MusicEnabled);
		SingletonMonobehaviour<CIGAudioManager>.Instance.EnableSFX(Singleton<CIGSettings>.Instance.SoundEffectsEnabled);
		SingletonMonobehaviour<CIGWebService>.Instance.PullRequestCompleted += this.PullRequestFinished;
		this.SetupMusic();
		TimeBoostReward timeBoostReward = Singleton<OngoingRewardManager>.Instance.FindActiveReward((IOngoingReward reward) => reward is TimeBoostReward) as TimeBoostReward;
		if (timeBoostReward != null)
		{
			timeBoostReward.Run();
		}
		SingletonMonobehaviour<CIGLocalNotificationManager>.Instance.HasNotification(this);
		IAPPackSaleLocalNotifications.Init();
	}

	protected void OnGridDeserialized()
	{
		this.islandState.LoadValuesFromBuildings();
		if (SingletonMonobehaviour<CIGGameStats>.IsAvailable)
		{
			CIGGameStats instance = SingletonMonobehaviour<CIGGameStats>.Instance;
			instance.SetCurrentCityIsland(this);
		}
	}

	protected void Update()
	{
		TimeBoostReward timeBoostReward = Singleton<OngoingRewardManager>.Instance.FindActiveReward((IOngoingReward reward) => reward is TimeBoostReward) as TimeBoostReward;
		if (this.TimeWarpEnd <= DateTime.UtcNow || (this.warpType == CityIsland.TimeWarpType.Boost && timeBoostReward == null))
		{
			Timing.scale = 1.0;
			this.timeSpeedupActive = false;
		}
	}

	public void DownloadCompleted(string group, string name)
	{
		if (group == this.island.ToString() && this.DlcMusicName == name)
		{
			this.SetupMusic();
		}
	}

	private void SetupMusic()
	{
		AudioClip x = this.music;
		if (!string.IsNullOrEmpty(this.DlcMusicName) && this.island != Island.GoneGreenlands)
		{
			DLCManager dlcmanager = ServiceLocator.Find<DLCManager>();
			if (dlcmanager != null && dlcmanager.IsEnabled)
			{
				string text = this.island.ToString();
				DLCGroup dlcgroup = dlcmanager.GetGroup(text).FileSelection("Type", "Music");
				if (dlcgroup.IsDownloaded)
				{
					DLCFile fileWithName = dlcgroup.GetFileWithName(this.DlcMusicName);
					if (fileWithName != null)
					{
						SingletonMonobehaviour<Scheduler>.Instance.StartRoutine(this.PlayWhenReady(fileWithName), base.gameObject);
						return;
					}
					UnityEngine.Debug.LogError(string.Format("No file with name {0} in group {1}", this.DlcMusicName, text));
				}
			}
			else
			{
				UnityEngine.Debug.LogWarning("No DLC manager");
			}
		}
		if (x != null)
		{
			SingletonMonobehaviour<CIGAudioManager>.Instance.SetMusic(x);
		}
	}

	private IEnumerator PlayWhenReady(DLCFile file)
	{
		WWW www = new WWW(file.URI);
		yield return www;
		yield return this.PlayWhenReady(www.GetAudioClip());
		yield break;
	}

	private IEnumerator PlayWhenReady(AudioClip clip)
	{
		yield return null;
		while (clip.loadState != AudioDataLoadState.Loaded)
		{
			yield return Timing.time + 0.1;
		}
		SingletonMonobehaviour<CIGAudioManager>.Instance.SetMusic(clip);
		yield break;
	}

	public static Currencies GetTotalSpeedupCost()
	{
		Currencies currencies = Currencies.Zero;
		int num = 0;
		foreach (CIGBuilding cigbuilding in UnityEngine.Object.FindObjectsOfType<CIGBuilding>())
		{
			if (cigbuilding.GetSecondsLeft() > 0L)
			{
				currencies += new Currencies("Gold", cigbuilding.SpeedupCostGold);
				num++;
			}
		}
		if (num > 2)
		{
			currencies *= 0.5m;
		}
		else if (num == 2)
		{
			currencies *= 0.75m;
		}
		return currencies.Round();
	}

	public static void SpeedupAllBuildings()
	{
		foreach (CIGBuilding cigbuilding in UnityEngine.Object.FindObjectsOfType<CIGBuilding>())
		{
			if (cigbuilding.GetSecondsLeft() > 0L)
			{
				if (!cigbuilding.IsConstructed)
				{
					cigbuilding.FinishConstruction();
				}
				else if (cigbuilding.IsUpgrading)
				{
					cigbuilding.FinishUpgrade();
				}
				else
				{
					cigbuilding.FinishDemolishing();
				}
			}
		}
	}

	private void OnApplicationPause(bool pause)
	{
		CIGGameState instance = SingletonMonobehaviour<CIGGameState>.Instance;
		if (pause)
		{
			int value = instance.GetValue<int>("currentRetentionReward", 0);
			if (value < this.RetentionRewards.Length && this.RetentionRewards[value] > 0L)
			{
				long num = 86400L * this.RetentionRewards[value];
				long num2 = (long)Timing.UtcNow + num;
				instance.SetValue("retentionRewardTimestamp", num2);
				this.isometricIsland.EnsureSave();
			}
		}
		else
		{
			long value2 = instance.GetValue<long>("retentionRewardTimestamp", -1L);
			if (value2 != -1L)
			{
				if (Singleton<CIGSettings>.Instance.NotificationsEnabled && (long)Timing.UtcNow > value2)
				{
					decimal value3 = 2m;
					Currencies currencies = new Currencies("Gold", value3);
					SingletonMonobehaviour<PopupManager>.Instance.ShowReceiveRewardPopup(currencies);
					instance.EarnCurrencies(currencies, null);
					instance.SetValue("currentRetentionReward", instance.GetValue<int>("currentRetentionReward", 0) + 1);
				}
				instance.SetValue("retentionRewardTimestamp", -1L);
			}
		}
		SingletonMonobehaviour<CIGSessionRestarter>.Instance.ApplicationPause(pause);
	}

	private void OnDestroy()
	{
		if (SingletonMonobehaviour<CIGLocalNotificationManager>.IsAvailable)
		{
			SingletonMonobehaviour<CIGLocalNotificationManager>.Instance.NoLongerHasNotification(this);
		}
		if (SingletonMonobehaviour<CIGGameStats>.IsAvailable)
		{
			CIGGameStats instance = SingletonMonobehaviour<CIGGameStats>.Instance;
			instance.SetCurrentCityIsland(null);
		}
	}

	private IEnumerator TimeSpeedUp(double seconds)
	{
		double MaxTimeScale = (seconds >= 3600.0) ? 1000.0 : 100.0;
		while (Timing.scale < MaxTimeScale)
		{
			Timing.scale = Math.Min(MaxTimeScale, Timing.scale * 1.2);
			yield return null;
		}
		Timing.scale = MaxTimeScale;
		yield return new WaitForSeconds((float)seconds / (float)Timing.scale * (float)Timing.Instance.maximumTimeScale);
		while (Timing.scale > 1.0)
		{
			Timing.scale = Math.Max(1.0, Timing.scale * 0.8);
			yield return null;
		}
		Timing.scale = 1.0;
		foreach (CIGBuilding cigbuilding in CityIsland.ProfitGeneratingBuildings())
		{
			cigbuilding.GetComponent<Serializing>().Serialize();
		}
		this.timeSpeedupActive = false;
		SingletonMonobehaviour<PopupManager>.Instance.RequestGenericPopup(UISpriteType.TimeWarpClock, Localization.Key("timewarp_title"), Localization.Format("{0} ({1})", new ILocalizedString[]
		{
			Localization.Key("timewarp_executed"),
			Localization.TimeSpan(TimeSpan.FromSeconds(seconds), false)
		}), Localization.Key("ok"), null, null, null, null, true);
		yield break;
	}

	private static List<CIGBuilding> ProfitGeneratingBuildings()
	{
		List<CIGBuilding> list = new List<CIGBuilding>();
		list.AddRange(UnityEngine.Object.FindObjectsOfType<CIGCommercialBuilding>());
		return list;
	}

	public void StartSpeedup(double seconds)
	{
		if (this.timeSpeedupActive)
		{
			UnityEngine.Debug.LogWarning("Cannot StartSpeedup when timeSpeedupActive.");
			return;
		}
		this.timeSpeedupActive = true;
		base.StartCoroutine(this.TimeSpeedUp(seconds));
	}

	public bool TimeBoost(double multiplier, TimeSpan duration)
	{
		if (this.timeSpeedupActive)
		{
			UnityEngine.Debug.LogWarning("Cannot TimeBoost when timeSpeedupActive.");
			return false;
		}
		TimingScaleRestore.Instance.SetScaleUntil(multiplier, DateTime.UtcNow + duration);
		this.timeSpeedupActive = true;
		this.TimeWarpEnd = DateTime.UtcNow + duration;
		this.warpType = CityIsland.TimeWarpType.Boost;
		return true;
	}

	public bool TimeWarp(TimeSpan warpedTime, TimeSpan duration)
	{
		if (this.timeSpeedupActive)
		{
			UnityEngine.Debug.LogWarning("Cannot TimeWarp when timeSpeedupActive.");
			return false;
		}
		TimingScaleRestore.Instance.SetScaleUntil(warpedTime.TotalSeconds / duration.TotalSeconds, DateTime.UtcNow + duration);
		this.timeSpeedupActive = true;
		this.TimeWarpEnd = DateTime.UtcNow + duration;
		this.warpType = CityIsland.TimeWarpType.Warp;
		return true;
	}

	public void StartBuilding(GameObject buildingPrefab)
	{
		this.isometricIsland.builder.BeginBuild(buildingPrefab);
		this.SetupConfirmState(true, this.GetHintLocalization(buildingPrefab, Localization.Key("help_building_drag_to_empty_space")), CIGBuilding.GetImmediateConstructionCost(buildingPrefab));
	}

	public void StartMoving(GameObject building)
	{
		if (!building.GetComponent<Building>().movable)
		{
			UnityEngine.Debug.LogWarning("Trying to move an unmovable building; aborting move");
			return;
		}
		this.isometricIsland.builder.BeginMove(building);
		this.SetupConfirmState(true, this.GetHintLocalization(building, Localization.Key("help_building_drag_to_empty_space")), null);
	}

	private ILocalizedString GetHintLocalization(GameObject building, ILocalizedString defaultValue)
	{
		int num = -1;
		GridTile component = building.GetComponent<GridTile>();
		if (component != null)
		{
			num = component.requiredGridType;
		}
		if (num == 2)
		{
			return Localization.Key("building_tile_type_beach");
		}
		if (num == 3)
		{
			return Localization.Key("building_tile_type_water");
		}
		return defaultValue;
	}

	private void SetupConfirmState(bool flip, ILocalizedString hintLocalization, Currencies cost)
	{
		HUDConfirmState hudconfirmState = this.fsm.SwitchState<HUDConfirmState>();
		if (flip)
		{
			hudconfirmState.ShowFlipButton();
		}
		if (hintLocalization != null)
		{
			hudconfirmState.SetHintText(hintLocalization);
		}
		hudconfirmState.SetImmediateCost(cost);
		hudconfirmState.OKEvent += this.FinishBuilding;
		hudconfirmState.CancelEvent += this.CancelBuilding;
		if (flip)
		{
			hudconfirmState.FlipEvent += this.FlipBuilding;
		}
		if (cost != null)
		{
			hudconfirmState.InstantEvent += this.ImmediateBuild;
		}
	}

	private void RemoveConfirmEventHandlers()
	{
		if (!(this.fsm.CurrentState is HUDConfirmState))
		{
			UnityEngine.Debug.LogWarning("Unable to remove event handlers because current state is no longer HUDConfirmState");
			return;
		}
		HUDConfirmState hudconfirmState = (HUDConfirmState)this.fsm.CurrentState;
		hudconfirmState.OKEvent -= this.FinishBuilding;
		hudconfirmState.CancelEvent -= this.CancelBuilding;
		hudconfirmState.FlipEvent -= this.FlipBuilding;
		hudconfirmState.InstantEvent -= this.ImmediateBuild;
	}

	public bool FlipBuilding()
	{
		this.isometricIsland.builder.UpdateBuild(!this.isometricIsland.builder.currentTile.mirrored);
		return false;
	}

	public bool FinishBuilding()
	{
		if (this.isometricIsland.builder.isBuildingRoad)
		{
			this.isometricIsland.builder.FinishRoad();
		}
		else if (this.isometricIsland.builder.isBuilding)
		{
			if (!this.isometricIsland.builder.CanBuild())
			{
				return false;
			}
			GridTile currentTile = this.isometricIsland.builder.currentTile;
			if (currentTile.status == GridTile.Status.Moving)
			{
				this.isometricIsland.builder.FinishBuild();
			}
			else
			{
				CIGBuilding building = currentTile.GetComponent<CIGBuilding>();
				if (building != null)
				{
					Currencies cost = building.PurchasePrice;
					decimal extraCost = 0m;
					Action action = delegate()
					{
						cost += new Currencies("Gold", extraCost);
						this.isometricIsland.gameState.SpendCurrencies(cost, true, delegate(bool succes, Currencies spent)
						{
							if (succes)
							{
								CIGGameStats instance = SingletonMonobehaviour<CIGGameStats>.Instance;
								int num = Mathf.RoundToInt((float)extraCost);
								int num2 = Mathf.RoundToInt((float)spent.GetValue("Gold"));
								if (num2 > 0)
								{
									if (building.initialPurchasePrice.ContainsPositive("Gold"))
									{
										instance.AddGoldSpent_GoldBuildings(num2 - num);
									}
									else
									{
										instance.AddGoldSpent_CashBuildings(num2 - num);
									}
								}
								if (num > 0)
								{
									instance.AddGoldSpent_CraneHire(num);
								}
								if (spent.GetValue("Cash") > 0m)
								{
									instance.AddCashBuilding(building.name);
								}
								else
								{
									instance.AddVirtualCurrencySpent();
								}
								if (SingletonMonobehaviour<CIGPurchasedBuildingsManager>.Instance.IsUnconsumed(building))
								{
									SingletonMonobehaviour<CIGPurchasedBuildingsManager>.Instance.ConsumeBuilding(building);
								}
								this.isometricIsland.builder.FinishBuild();
							}
							else
							{
								this.CancelBuilding();
							}
						});
					};
					Action cancelAction = delegate()
					{
						this.isometricIsland.builder.CancelBuild();
					};
					if (SingletonMonobehaviour<CIGBuilderManager>.Instance.CurrentBuildCount < SingletonMonobehaviour<CIGBuilderManager>.Instance.MaxBuildCount)
					{
						action();
					}
					else
					{
						extraCost = 1m;
						Currencies extraCost2 = new Currencies("Gold", extraCost);
						SingletonMonobehaviour<PopupManager>.Instance.ShowTooMuchParallelBuildsPopup(action, cancelAction, extraCost2);
					}
					this.RemoveConfirmEventHandlers();
					return true;
				}
				this.CancelBuilding();
				return false;
			}
		}
		else if (this.isometricIsland.destroyer.isSelecting)
		{
			this.isometricIsland.destroyer.DestroySelection();
		}
		else
		{
			UnityEngine.Debug.LogWarning("Don't know what we're finishing.");
		}
		this.RemoveConfirmEventHandlers();
		return true;
	}

	public bool CancelBuilding()
	{
		if (this.isometricIsland.builder.isBuildingRoad)
		{
			this.isometricIsland.builder.CancelRoad();
		}
		else if (this.isometricIsland.builder.isBuilding)
		{
			this.isometricIsland.builder.CancelBuild();
		}
		else if (this.isometricIsland.destroyer.isSelecting)
		{
			this.isometricIsland.destroyer.CancelSelecting();
		}
		else
		{
			UnityEngine.Debug.LogWarning("Don't know what we're canceling.");
		}
		this.RemoveConfirmEventHandlers();
		return true;
	}

	public bool ImmediateBuild()
	{
		HUDConfirmState hudconfirmState = this.fsm.CurrentState as HUDConfirmState;
		if (hudconfirmState == null)
		{
			UnityEngine.Debug.LogWarning("Current FSM state is not HUDConfirmState.");
			return false;
		}
		Currencies immediateCost = hudconfirmState.ImmediateCost;
		if (this.isometricIsland.builder.isBuilding && this.isometricIsland.builder.CanBuild())
		{
			GridTile currentTile = this.isometricIsland.builder.currentTile;
			if (currentTile.status == GridTile.Status.Preview)
			{
				this.isometricIsland.gameState.SpendCurrencies(immediateCost, true, delegate(bool success, Currencies spent)
				{
					if (success)
					{
						GridTile gridTile = this.isometricIsland.builder.FinishBuild();
						CIGBuilding component = gridTile.GetComponent<CIGBuilding>();
						if (component != null)
						{
							int num = (int)spent.GetValue("Gold");
							CIGGameStats instance = SingletonMonobehaviour<CIGGameStats>.Instance;
							instance.AddGoldSpent_ImmediateBuild(num);
							instance.AddVirtualCurrencySpent();
							component.FinishConstruction();
						}
					}
					else
					{
						this.CancelBuilding();
					}
				});
				this.RemoveConfirmEventHandlers();
				return true;
			}
		}
		UnityEngine.Debug.LogWarning("Cannot handle this state with ImmediateBuild.");
		return false;
	}

	public void StartBuildingRoad(GameObject road)
	{
		this.isometricIsland.builder.BeginRoad(road);
		this.SetupConfirmState(false, Localization.Key("help_build_roads"), null);
	}

	public void StartDestroying()
	{
		this.isometricIsland.destroyer.StartSelecting();
		this.SetupConfirmState(false, Localization.Key("help_destroy"), null);
	}

	private void PrefabRegistrationRequest(GameObjectManager manager)
	{
	}

	private IEnumerator AllBuildingPrefabs()
	{
		GameObjectManager goManager = SingletonMonobehaviour<GameObjectManager>.Instance;
		int length = goManager.Residential.Length;
		for (int i = 0; i < length; i++)
		{
			yield return goManager.Residential[i].Prefab;
		}
		length = goManager.Community.Length;
		for (int j = 0; j < length; j++)
		{
			yield return goManager.Community[j].Prefab;
		}
		length = goManager.Commercial.Length;
		for (int k = 0; k < length; k++)
		{
			yield return goManager.Commercial[k].Prefab;
		}
		length = goManager.Decoration.Length;
		for (int l = 0; l < length; l++)
		{
			yield return goManager.Decoration[l].Prefab;
		}
		yield break;
	}

	private void TryUpdateRoad(GridIndex index)
	{
		if (index.isInvalid || index.u >= this.isometricIsland.grid.sizeU || index.v >= this.isometricIsland.grid.sizeV)
		{
			return;
		}
		if (this.isometricIsland.grid[index] != null && this.isometricIsland.grid[index].Tile != null)
		{
			return;
		}
		this.isometricIsland.builder.UpdateRoad(index);
	}

	private IEnumerator BuildScriptRoutine()
	{
		Queue<Building> queue = new Queue<Building>();
		IEnumerator prefabs = this.AllBuildingPrefabs();
		while (prefabs.MoveNext())
		{
			object obj = prefabs.Current;
			GameObject prefab = obj as GameObject;
			UnityEngine.Debug.Log(string.Format("Prefab name is {0}", prefab.name));
			CIGBuilding cigBuilding = prefab.GetComponent<CIGBuilding>();
			if (!cigBuilding.activatable)
			{
				int count = Mathf.Min(2, Mathf.Max(1, cigBuilding.unlockLevels.Length));
				for (int i = 0; i < count; i++)
				{
					this.isometricIsland.builder.BeginBuild(prefab);
					if (this.isometricIsland.builder.isBuilding)
					{
						yield return null;
						GridTile tile = null;
						if (this.isometricIsland.builder.CanBuild())
						{
							tile = this.isometricIsland.builder.FinishBuild();
						}
						else
						{
							this.isometricIsland.builder.CancelBuild();
						}
						yield return null;
						if (tile == null)
						{
							if (this.expansions == null)
							{
								UnityEngine.Debug.LogWarning("Unable to find a CIGExpensions object.");
							}
							else
							{
								bool done = false;
								for (int u = 0; u < this.expansions.BlocksU; u++)
								{
									for (int v = 0; v < this.expansions.BlocksV; v++)
									{
										CIGExpansions.ExpansionBlock block = this.expansions.GetBlock(u, v);
										if (block != null)
										{
											if ((double)block.AvailableFraction >= 0.4 && (double)block.VisibleFraction >= 0.4)
											{
												if (!block.Unlocked && block.CanUnlock)
												{
													this.expansions.UnlockBlock(block, new Currencies());
													for (u = block.Origin.u; u < block.Origin.u + block.Size.u; u++)
													{
														for (v = block.Origin.v; v < block.Origin.v + block.Size.v; v++)
														{
															GridIndex index = new GridIndex(u, v);
															if (this.isometricIsland.grid.IsWithinBounds(index))
															{
																GridElement gridElement = this.isometricIsland.grid[index];
																if (gridElement != null)
																{
																	GridTile tile2 = gridElement.Tile;
																	if (tile2 != null)
																	{
																		CIGScenery component = tile2.GetComponent<CIGScenery>();
																		if (component != null)
																		{
																			this.isometricIsland.destroyer.DestroyBuilding(component);
																		}
																	}
																}
															}
														}
													}
													yield return null;
													this.isometricIsland.destroyer.FinishAll();
													yield return null;
													done = true;
													break;
												}
											}
										}
									}
									if (done)
									{
										break;
									}
								}
								if (!done)
								{
									UnityEngine.Debug.LogWarning("Did not manage to unlock a new expansions block.");
								}
								else
								{
									this.isometricIsland.builder.BeginBuild(prefab);
									if (this.isometricIsland.builder.isBuilding)
									{
										yield return null;
										if (this.isometricIsland.builder.CanBuild())
										{
											tile = this.isometricIsland.builder.FinishBuild();
										}
										else
										{
											this.isometricIsland.builder.CancelBuild();
										}
										yield return null;
									}
								}
							}
						}
						if (tile != null)
						{
							int roadType = UnityEngine.Random.Range(0, Math.Min(3, this.roads.Length));
							this.isometricIsland.builder.BeginRoad(this.roads[roadType]);
							if (this.isometricIsland.builder.isBuildingRoad)
							{
								yield return null;
								for (int j = tile.index.u - tile.size.u; j <= tile.index.u + 1; j++)
								{
									this.TryUpdateRoad(new GridIndex(j, tile.index.v + 1));
									this.TryUpdateRoad(new GridIndex(j, tile.index.v - tile.size.v));
								}
								for (int k = tile.index.v - tile.size.v + 1; k <= tile.index.v; k++)
								{
									this.TryUpdateRoad(new GridIndex(tile.index.u + 1, k));
									this.TryUpdateRoad(new GridIndex(tile.index.u - tile.size.u, k));
								}
								yield return null;
								this.isometricIsland.builder.FinishRoad();
							}
							Building building = tile.GetComponent<Building>();
							if (building != null)
							{
								queue.Enqueue(building);
							}
						}
						else
						{
							UnityEngine.Debug.LogWarning("Failed to build " + prefab.name);
						}
					}
					else
					{
						UnityEngine.Debug.LogWarning("Failed to start building " + prefab.name);
					}
					yield return null;
				}
				yield return new WaitForSeconds(1f);
				if (queue.Count > 0 && UnityEngine.Random.Range(0, 2) == 0)
				{
					yield return null;
					queue.Dequeue().FinishConstruction();
				}
			}
		}
		while (queue.Count > 0)
		{
			yield return null;
			queue.Dequeue().FinishConstruction();
			yield return new WaitForSeconds(1f);
		}
		yield break;
	}

	public void StartBuildScript()
	{
		base.StartCoroutine("BuildScriptRoutine");
	}

	public void StopBuildScript()
	{
		base.StopCoroutine("BuildScriptRoutine");
	}

	private void UpdateConfirmed()
	{
		Application.OpenURL(SingletonMonobehaviour<CIGGameConstants>.Instance.UpdateUrl);
	}

	private void PullRequestFinished()
	{
		CIGWebService instance = SingletonMonobehaviour<CIGWebService>.Instance;
		if (instance.UpdateAvailable)
		{
			bool flag = true;
			string value = this.isometricIsland.gameState.GetValue<string>(CityIsland.ShownUpdatePopupVersionKey, string.Empty);
			if (value != null && value == "3.0.6")
			{
				double value2 = this.isometricIsland.gameState.GetValue<double>(CityIsland.ShownUpdatePopupTimestampKey, 0.0);
				flag = (Timing.UtcNow - value2 >= 172800.0);
			}
			if (flag)
			{
				this.isometricIsland.gameState.SetValue(CityIsland.ShownUpdatePopupVersionKey, "3.0.6");
				this.isometricIsland.gameState.SetValue(CityIsland.ShownUpdatePopupTimestampKey, Timing.UtcNow);
				SingletonMonobehaviour<PopupManager>.Instance.RequestGenericPopup(UISpriteType.UpgradeIcon, Localization.Key("update_available"), Localization.Key("update_older_version"), Localization.Key("update_go"), Localization.Key("not_now"), new Action(this.UpdateConfirmed), null, null, true);
			}
		}
		if (!instance.Undelivered.IsEmpty())
		{
			this.DeliverCurrencies(instance.Undelivered);
			instance.ClearUndelivered();
		}
	}

	private void DeliverCurrencies(Currencies currencies)
	{
		if (currencies.ContainsPositive("XP") && !currencies.ContainsPositive("Cash") && !currencies.ContainsPositive("Gold"))
		{
			SingletonMonobehaviour<PopupManager>.Instance.ShowInfoPopup(null, Localization.Format(Localization.Key("you_have_received"), new ILocalizedString[]
			{
				currencies.LocalizedString()
			}));
		}
		else
		{
			SingletonMonobehaviour<PopupManager>.Instance.ShowReceiveRewardPopup(currencies);
		}
		CIGGameState instance = SingletonMonobehaviour<CIGGameState>.Instance;
		instance.GiveCurrencies(currencies);
	}

	private void OnNativeMessage(string message)
	{
		if (message.Equals("DeviceShake"))
		{
			base.StartCoroutine(this.DoEarthquake());
		}
		else
		{
			UnityEngine.Debug.Log("Unknown native message: " + message);
		}
	}

	public IEnumerator DoEarthquake()
	{
		if (this.quakeActive)
		{
			yield break;
		}
		this.quakeActive = true;
		UnityEngine.Debug.LogWarning("RUN FOR YOUR LIVES!!!!");
		GameObject eq = new GameObject("Earthquake");
		eq.transform.parent = base.transform;
		eq.transform.localPosition = Vector3.zero;
		AudioSource audio = eq.AddComponent<AudioSource>();
		Animator animator = this.isometricIsland.islandCamera.GetComponent<Animator>();
		audio.PlayOneShot(this.earthquakeSound);
		animator.SetBool("Quake", true);
		AudioSource music = SingletonMonobehaviour<CIGAudioManager>.Instance.GetComponent<AudioSource>();
		if (music.isPlaying)
		{
			float v = music.volume;
			while (v > 0.01f)
			{
				v -= Time.deltaTime;
				music.volume = v;
				yield return null;
			}
			music.volume = 0f;
			yield return new WaitForSeconds(8f);
			animator.SetBool("Quake", false);
			yield return new WaitForSeconds(4f);
			v = music.volume;
			while (v < 0.99f)
			{
				v += Time.deltaTime * 0.5f;
				music.volume = v;
				yield return null;
			}
			music.volume = 1f;
		}
		else
		{
			yield return new WaitForSeconds(9f);
			animator.SetBool("Quake", false);
			yield return new WaitForSeconds(5f);
		}
		UnityEngine.Object.Destroy(eq);
		this.quakeActive = false;
		yield break;
	}

	public static readonly string TimewarpLength = "TimewarpDuration";

	public static readonly string TimeboostMultiplierKey = "TimeboostMultiplier";

	private static readonly string ShownUpdatePopupVersionKey = "shownUpdatePopupVersion";

	private static readonly string ShownUpdatePopupTimestampKey = "shownUpdatePopupTimestamp";

	private long[] RetentionRewards = new long[]
	{
		3L,
		7L,
		14L,
		30L
	};

	public static CityIsland Current;

	public CityIsland.TimeWarpType warpType;

	public GameObject[] roads;

	public AudioClip earthquakeSound;

	public Island island;

	public Transform UI3D;

	public AudioClip music;

	[SerializeField]
	private string dlcMusicName;

	[SelfReference]
	public IsometricIsland isometricIsland;

	[SelfReference]
	public CIGExpansions expansions;

	[SelfReference]
	public CIGIslandState islandState;

	private FiniteStateMachine fsm;

	private bool timeSpeedupActive;

	private bool quakeActive;

	public const string CurrentRetentionRewardKey = "currentRetentionReward";

	public const string RetentionRewardTimestampKey = "retentionRewardTimestamp";

	public enum TimeWarpType
	{
		Warp,
		Boost
	}
}