path: root/Thronefall_v1.0/Decompile/EnemySpawner.cs

using System.Collections.Generic;
using UnityEngine;

public class EnemySpawner : MonoBehaviour, DayNightCycle.IDaytimeSensitive
{
	private PerkManager perkManager;

	private EnemySpawnManager enemySpawnManager;

	public static EnemySpawner instance;

	private TutorialManager tutorialManager;

	public int goldBalanceAtStart = 10;

	private bool spawningInProgress;

	public List<Wave> waves = new List<Wave>();

	private List<ScreenMarker> screenMarkersEnemySpawns = new List<ScreenMarker>();

	private List<ScreenMarker> screenMarkersOffscreenWarnings = new List<ScreenMarker>();

	private int wavenumber = -1;

	private float lastSpawnPeriodDuration;

	private bool treasureHunterActive;

	private bool cheeseGodActive;

	private bool diseaseGodActive;

	private float timeToNextHpDecrease = 2.1f;

	public bool SpawningInProgress => spawningInProgress;

	public int WaveCount => waves.Count;

	public int Wavenumber => wavenumber;

	public bool MatchOver
	{
		get
		{
			if (wavenumber >= waves.Count - 1)
			{
				return !SpawningInProgress;
			}
			return false;
		}
	}

	public bool LevelBeatenAsSoonAsWaveFinished => wavenumber > waves.Count - 2;

	public bool FinalWaveComingUp => wavenumber == waves.Count - 2;

	public bool PreFinalWaveComingUp => wavenumber == waves.Count - 3;

	public float LastSpawnPeriodDuration => lastSpawnPeriodDuration;

	public bool InfinitelySpawning { get; set; }

	public void DebugSkipWave()
	{
		StopSpawnAfterWaveAndReset();
		wavenumber++;
	}

	public void EnemySpawnersHornFocussed()
	{
		if ((bool)tutorialManager && !tutorialManager.MayShowEnemySpawn)
		{
			for (int i = 0; i < screenMarkersEnemySpawns.Count; i++)
			{
				screenMarkersEnemySpawns[i].showWhenOnScreen = false;
				screenMarkersEnemySpawns[i].showWhenOffScreen = false;
			}
			for (int j = 0; j < screenMarkersOffscreenWarnings.Count; j++)
			{
				screenMarkersOffscreenWarnings[j].showWhenOnScreen = false;
				screenMarkersOffscreenWarnings[j].showWhenOffScreen = false;
			}
		}
		else
		{
			for (int k = 0; k < screenMarkersEnemySpawns.Count; k++)
			{
				screenMarkersEnemySpawns[k].showWhenOnScreen = true;
				screenMarkersEnemySpawns[k].showWhenOffScreen = true;
			}
			for (int l = 0; l < screenMarkersOffscreenWarnings.Count; l++)
			{
				screenMarkersOffscreenWarnings[l].showWhenOnScreen = false;
				screenMarkersOffscreenWarnings[l].showWhenOffScreen = false;
			}
		}
	}

	public void EnemySpawnersHornUnFocussed()
	{
		if ((bool)tutorialManager && !tutorialManager.MayShowEnemySpawn)
		{
			for (int i = 0; i < screenMarkersEnemySpawns.Count; i++)
			{
				screenMarkersEnemySpawns[i].showWhenOnScreen = false;
				screenMarkersEnemySpawns[i].showWhenOffScreen = false;
			}
			for (int j = 0; j < screenMarkersOffscreenWarnings.Count; j++)
			{
				screenMarkersOffscreenWarnings[j].showWhenOnScreen = false;
				screenMarkersOffscreenWarnings[j].showWhenOffScreen = false;
			}
		}
		else
		{
			for (int k = 0; k < screenMarkersEnemySpawns.Count; k++)
			{
				screenMarkersEnemySpawns[k].showWhenOnScreen = true;
				screenMarkersEnemySpawns[k].showWhenOffScreen = true;
			}
			for (int l = 0; l < screenMarkersOffscreenWarnings.Count; l++)
			{
				screenMarkersOffscreenWarnings[l].showWhenOnScreen = false;
				screenMarkersOffscreenWarnings[l].showWhenOffScreen = false;
			}
		}
	}

	private void Awake()
	{
		instance = this;
	}

	private void Start()
	{
		perkManager = PerkManager.instance;
		enemySpawnManager = EnemySpawnManager.instance;
		tutorialManager = TutorialManager.instance;
		EnemySpawnersHornUnFocussed();
		if ((bool)DayNightCycle.Instance)
		{
			DayNightCycle.Instance.RegisterDaytimeSensitiveObject(this);
		}
		spawningInProgress = false;
		wavenumber = -1;
		if (DebugController.instance.StartGameInWave != -1)
		{
			wavenumber = DebugController.instance.StartGameInWave - 1;
		}
		PlayerMovement[] registeredPlayers = PlayerManager.Instance.RegisteredPlayers;
		for (int i = 0; i < registeredPlayers.Length; i++)
		{
			registeredPlayers[i].GetComponent<PlayerInteraction>().AddCoin(goldBalanceAtStart);
		}
		LevelProgressManager.instance.GetLevelDataForActiveScene()?.dayToDayNetworth.Add(goldBalanceAtStart);
		treasureHunterActive = PerkManager.instance.TreasureHunterActive;
		cheeseGodActive = PerkManager.instance.CheeseGodActive;
		if (cheeseGodActive)
		{
			for (int j = 0; j < Mathf.Min(3, waves.Count); j++)
			{
				foreach (Spawn spawn in waves[j].spawns)
				{
					spawn.count *= 2;
				}
			}
		}
		OnStartOfTheDay();
	}

	private void Update()
	{
		if (!spawningInProgress)
		{
			return;
		}
		lastSpawnPeriodDuration += Time.deltaTime;
		waves[wavenumber].Update();
		if (!waves[wavenumber].HasFinished())
		{
			return;
		}
		if (InfinitelySpawning)
		{
			if (TagManager.instance.CountAllTaggedObjectsWithTag(TagManager.ETag.EnemyOwned) > 0)
			{
				return;
			}
			{
				foreach (Spawn spawn in waves[wavenumber].spawns)
				{
					spawn.Reset(_resetGold: false);
				}
				return;
			}
		}
		StopSpawnAfterWaveAndReset();
	}

	public void OnStartOfTheDay()
	{
		if (wavenumber + 1 >= waves.Count)
		{
			return;
		}
		if (FinalWaveComingUp && treasureHunterActive)
		{
			PlayerMovement[] registeredPlayers = PlayerManager.Instance.RegisteredPlayers;
			for (int i = 0; i < registeredPlayers.Length; i++)
			{
				registeredPlayers[i].GetComponent<PlayerInteraction>().AddCoin(PerkManager.instance.treasureHunterGoldAmount);
			}
		}
		foreach (Spawn spawn in waves[wavenumber + 1].spawns)
		{
			Vector3 vector = (spawn.spawnLine.GetChild(0).position + spawn.spawnLine.GetChild(spawn.spawnLine.childCount - 1).position) / 2f;
			Sprite sprite = spawn.enemyPrefab.GetComponent<ScreenMarkerIcon>().sprite;
			ScreenMarker screenMarker = null;
			for (int j = 0; j < screenMarkersEnemySpawns.Count; j++)
			{
				if (!(screenMarkersEnemySpawns[j].Sprite != sprite) && !(screenMarkersEnemySpawns[j].transform.position != vector))
				{
					screenMarker = screenMarkersEnemySpawns[j];
					screenMarker.SetNumber(screenMarker.Number + spawn.count);
				}
			}
			if (!(screenMarker != null))
			{
				ScreenMarker component = Object.Instantiate(enemySpawnManager.screenMarkerPrefabEnemySpawns, vector, Quaternion.identity).GetComponent<ScreenMarker>();
				component.SetSprite(sprite);
				component.SetNumber(spawn.count);
				screenMarkersEnemySpawns.Add(component);
			}
		}
		EnemySpawnersHornUnFocussed();
	}

	public void OnStartOfTheNight()
	{
		for (int num = screenMarkersEnemySpawns.Count - 1; num >= 0; num--)
		{
			Object.Destroy(screenMarkersEnemySpawns[num].gameObject);
		}
		screenMarkersEnemySpawns.Clear();
		for (int num2 = screenMarkersOffscreenWarnings.Count - 1; num2 >= 0; num2--)
		{
			Object.Destroy(screenMarkersOffscreenWarnings[num2].gameObject);
		}
		screenMarkersOffscreenWarnings.Clear();
		StartSpawning();
	}

	public void StartSpawning()
	{
		if (!spawningInProgress)
		{
			lastSpawnPeriodDuration = 0f;
			wavenumber++;
			wavenumber = Mathf.Clamp(wavenumber, 0, waves.Count - 1);
			waves[wavenumber].Reset();
			spawningInProgress = true;
		}
	}

	public void StopSpawnAfterWaveAndReset()
	{
		if (spawningInProgress)
		{
			spawningInProgress = false;
		}
	}

	public void OnDusk()
	{
		OnStartOfTheNight();
	}

	public void OnDawn_AfterSunrise()
	{
		OnStartOfTheDay();
	}

	public void OnDawn_BeforeSunrise()
	{
	}
}