diff options
109 files changed, 11019 insertions, 11 deletions
diff --git a/Assembly_CSharp/.vs/ProjectEvaluation/roguetower.metadata.v5.2 b/Assembly_CSharp/.vs/ProjectEvaluation/roguetower.metadata.v5.2 Binary files differindex f9a914b..b0cfd99 100644 --- a/Assembly_CSharp/.vs/ProjectEvaluation/roguetower.metadata.v5.2 +++ b/Assembly_CSharp/.vs/ProjectEvaluation/roguetower.metadata.v5.2 diff --git a/Assembly_CSharp/.vs/ProjectEvaluation/roguetower.projects.v5.2 b/Assembly_CSharp/.vs/ProjectEvaluation/roguetower.projects.v5.2 Binary files differindex bc7c288..5fb5798 100644 --- a/Assembly_CSharp/.vs/ProjectEvaluation/roguetower.projects.v5.2 +++ b/Assembly_CSharp/.vs/ProjectEvaluation/roguetower.projects.v5.2 diff --git a/Assembly_CSharp/.vs/RogueTower/DesignTimeBuild/.dtbcache.v2 b/Assembly_CSharp/.vs/RogueTower/DesignTimeBuild/.dtbcache.v2 Binary files differindex 185c6d1..a9ca918 100644 --- a/Assembly_CSharp/.vs/RogueTower/DesignTimeBuild/.dtbcache.v2 +++ b/Assembly_CSharp/.vs/RogueTower/DesignTimeBuild/.dtbcache.v2 diff --git a/Assembly_CSharp/.vs/RogueTower/FileContentIndex/53548182-5dd3-46a3-8253-f9dcdfb12a9f.vsidx b/Assembly_CSharp/.vs/RogueTower/FileContentIndex/53548182-5dd3-46a3-8253-f9dcdfb12a9f.vsidx Binary files differdeleted file mode 100644 index 1b7038b..0000000 --- a/Assembly_CSharp/.vs/RogueTower/FileContentIndex/53548182-5dd3-46a3-8253-f9dcdfb12a9f.vsidx +++ /dev/null diff --git a/Assembly_CSharp/.vs/RogueTower/FileContentIndex/543ecb80-83ee-4e8b-a04a-2776c4c9ef4f.vsidx b/Assembly_CSharp/.vs/RogueTower/FileContentIndex/543ecb80-83ee-4e8b-a04a-2776c4c9ef4f.vsidx Binary files differdeleted file mode 100644 index 2f00599..0000000 --- a/Assembly_CSharp/.vs/RogueTower/FileContentIndex/543ecb80-83ee-4e8b-a04a-2776c4c9ef4f.vsidx +++ /dev/null diff --git a/Assembly_CSharp/.vs/RogueTower/v17/.suo b/Assembly_CSharp/.vs/RogueTower/v17/.suo Binary files differindex 69249e8..7693ec6 100644 --- a/Assembly_CSharp/.vs/RogueTower/v17/.suo +++ b/Assembly_CSharp/.vs/RogueTower/v17/.suo diff --git a/Assembly_CSharp/obj/Debug/netstandard2.0/RogueTower.GeneratedMSBuildEditorConfig.editorconfig b/Assembly_CSharp/obj/Debug/netstandard2.0/RogueTower.GeneratedMSBuildEditorConfig.editorconfig index a8e9be8..8aa5c36 100644 --- a/Assembly_CSharp/obj/Debug/netstandard2.0/RogueTower.GeneratedMSBuildEditorConfig.editorconfig +++ b/Assembly_CSharp/obj/Debug/netstandard2.0/RogueTower.GeneratedMSBuildEditorConfig.editorconfig @@ -1,3 +1,3 @@ is_global = true build_property.RootNamespace = RogueTower -build_property.ProjectDir = D:\Games\_PC\_Mono\Rogue Tower\Decompile\Assembly_CSharp\ +build_property.ProjectDir = D:\Games\PC\_Mono\Rogue Tower\Decompile\Assembly_CSharp\ diff --git a/Assembly_CSharp/obj/Debug/netstandard2.0/RogueTower.assets.cache b/Assembly_CSharp/obj/Debug/netstandard2.0/RogueTower.assets.cache Binary files differindex b8ef08a..af085e0 100644 --- a/Assembly_CSharp/obj/Debug/netstandard2.0/RogueTower.assets.cache +++ b/Assembly_CSharp/obj/Debug/netstandard2.0/RogueTower.assets.cache diff --git a/Assembly_CSharp/obj/Debug/netstandard2.0/RogueTower.csproj.AssemblyReference.cache b/Assembly_CSharp/obj/Debug/netstandard2.0/RogueTower.csproj.AssemblyReference.cache Binary files differindex 4ac6ac6..2a05939 100644 --- a/Assembly_CSharp/obj/Debug/netstandard2.0/RogueTower.csproj.AssemblyReference.cache +++ b/Assembly_CSharp/obj/Debug/netstandard2.0/RogueTower.csproj.AssemblyReference.cache diff --git a/Assembly_CSharp/obj/RogueTower.csproj.nuget.dgspec.json b/Assembly_CSharp/obj/RogueTower.csproj.nuget.dgspec.json index 5f2465c..31878da 100644 --- a/Assembly_CSharp/obj/RogueTower.csproj.nuget.dgspec.json +++ b/Assembly_CSharp/obj/RogueTower.csproj.nuget.dgspec.json @@ -1,17 +1,17 @@ { "format": 1, "restore": { - "D:\\Games\\_PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\RogueTower.csproj": {} + "D:\\Games\\PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\RogueTower.csproj": {} }, "projects": { - "D:\\Games\\_PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\RogueTower.csproj": { + "D:\\Games\\PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\RogueTower.csproj": { "version": "1.0.0", "restore": { - "projectUniqueName": "D:\\Games\\_PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\RogueTower.csproj", + "projectUniqueName": "D:\\Games\\PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\RogueTower.csproj", "projectName": "Assembly-CSharp", - "projectPath": "D:\\Games\\_PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\RogueTower.csproj", + "projectPath": "D:\\Games\\PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\RogueTower.csproj", "packagesPath": "C:\\Users\\Administrator\\.nuget\\packages\\", - "outputPath": "D:\\Games\\_PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\obj\\", + "outputPath": "D:\\Games\\PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\obj\\", "projectStyle": "PackageReference", "fallbackFolders": [ "C:\\Program Files (x86)\\Microsoft Visual Studio\\Shared\\NuGetPackages" diff --git a/Assembly_CSharp/obj/project.assets.json b/Assembly_CSharp/obj/project.assets.json index 38d8907..926b7af 100644 --- a/Assembly_CSharp/obj/project.assets.json +++ b/Assembly_CSharp/obj/project.assets.json @@ -186,11 +186,11 @@ "project": { "version": "1.0.0", "restore": { - "projectUniqueName": "D:\\Games\\_PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\RogueTower.csproj", + "projectUniqueName": "D:\\Games\\PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\RogueTower.csproj", "projectName": "Assembly-CSharp", - "projectPath": "D:\\Games\\_PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\RogueTower.csproj", + "projectPath": "D:\\Games\\PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\RogueTower.csproj", "packagesPath": "C:\\Users\\Administrator\\.nuget\\packages\\", - "outputPath": "D:\\Games\\_PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\obj\\", + "outputPath": "D:\\Games\\PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\obj\\", "projectStyle": "PackageReference", "fallbackFolders": [ "C:\\Program Files (x86)\\Microsoft Visual Studio\\Shared\\NuGetPackages" diff --git a/Assembly_CSharp/obj/project.nuget.cache b/Assembly_CSharp/obj/project.nuget.cache index 3d5d096..c9729cd 100644 --- a/Assembly_CSharp/obj/project.nuget.cache +++ b/Assembly_CSharp/obj/project.nuget.cache @@ -1,8 +1,8 @@ { "version": 2, - "dgSpecHash": "TXdjMDGnAcXpY8OX7QNyMyANBH85Ib9TBuPLsvYCe4Y195KcyQG5bt2WeTPgYc/ukbn2xXIEKovN3smCGtxa1w==", + "dgSpecHash": "+X9xFnoe2YNyXySc25Xl3dPzed7x+O7/vrAZMkSQSivo71Bz95RqS6JTrVV8bJpnKDKLegjGlRbuCMi+oCMOog==", "success": true, - "projectFilePath": "D:\\Games\\_PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\RogueTower.csproj", + "projectFilePath": "D:\\Games\\PC\\_Mono\\Rogue Tower\\Decompile\\Assembly_CSharp\\RogueTower.csproj", "expectedPackageFiles": [ "C:\\Users\\Administrator\\.nuget\\packages\\microsoft.netcore.platforms\\1.1.0\\microsoft.netcore.platforms.1.1.0.nupkg.sha512", "C:\\Users\\Administrator\\.nuget\\packages\\netstandard.library\\2.0.3\\netstandard.library.2.0.3.nupkg.sha512" diff --git a/GameCode/.NETStandard,Version=v2.0.AssemblyAttributes.cs b/GameCode/.NETStandard,Version=v2.0.AssemblyAttributes.cs new file mode 100644 index 0000000..8bf3a42 --- /dev/null +++ b/GameCode/.NETStandard,Version=v2.0.AssemblyAttributes.cs @@ -0,0 +1,4 @@ +// <autogenerated /> +using System; +using System.Reflection; +[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")] diff --git a/GameCode/AchievementManager.cs b/GameCode/AchievementManager.cs new file mode 100644 index 0000000..a189341 --- /dev/null +++ b/GameCode/AchievementManager.cs @@ -0,0 +1,424 @@ +using Steamworks; +using UnityEngine; + +public class AchievementManager : MonoBehaviour +{ + public static AchievementManager instance; + + private int goldSpentOnResearch; + + private int discoveriesMade; + + private int enemiesKilled; + + [SerializeField] + private string[] towerUnlockStrings; + + public bool shrineSpawned; + + private void Awake() + { + instance = this; + } + + private void Start() + { + if (SteamManager.Initialized) + { + SteamUserStats.GetStat("EnemiesKilled", out enemiesKilled); + SteamUserStats.GetStat("DiscoveriesMade", out discoveriesMade); + SteamUserStats.GetStat("GoldOnResearch", out goldSpentOnResearch); + } + } + + public void OnSceneClose() + { + if (SteamManager.Initialized) + { + SteamUserStats.SetStat("EnemiesKilled", enemiesKilled); + SteamUserStats.SetStat("DiscoveriesMade", discoveriesMade); + SteamUserStats.SetStat("GoldOnResearch", goldSpentOnResearch); + SteamUserStats.StoreStats(); + } + } + + public void ResetSteamStats() + { + SteamUserStats.ResetAllStats(bAchievementsToo: true); + } + + public void FundResearchAchievement(int amt) + { + if (goldSpentOnResearch < 100000 && goldSpentOnResearch + amt >= 100000) + { + UnlockAchievement("Funding100000"); + } + else if (goldSpentOnResearch < 10000 && goldSpentOnResearch + amt >= 10000) + { + UnlockAchievement("Funding10000"); + } + else if (goldSpentOnResearch < 1000 && goldSpentOnResearch + amt >= 1000) + { + UnlockAchievement("Funding1000"); + } + goldSpentOnResearch += amt; + } + + public void NewDiscoveriesAchievement() + { + discoveriesMade++; + if (discoveriesMade == 100) + { + UnlockAchievement("Discover100"); + } + else if (discoveriesMade == 10) + { + UnlockAchievement("Discover10"); + } + else if (discoveriesMade == 1) + { + UnlockAchievement("Discover1"); + } + } + + public void EnemyKilled() + { + enemiesKilled++; + if (enemiesKilled == 1000000) + { + UnlockAchievement("Kill1000000Enemies"); + } + else if (enemiesKilled == 100000) + { + UnlockAchievement("Kill100000Enemies"); + } + else if (enemiesKilled == 10000) + { + UnlockAchievement("Kill10000Enemies"); + } + else if (enemiesKilled == 1000) + { + UnlockAchievement("Kill1000Enemies"); + } + else if (enemiesKilled == 100) + { + UnlockAchievement("Kill100Enemies"); + } + } + + public void UnlockAchievement(string s) + { + if (SteamManager.Initialized) + { + Debug.Log("Unlocked Achievement: " + s); + SteamUserStats.SetAchievement(s); + SteamUserStats.StoreStats(); + } + } + + public void CheckTowerUnlocks() + { + int num = 0; + string[] array = towerUnlockStrings; + foreach (string key in array) + { + num += PlayerPrefs.GetInt(key, 0); + } + if (num == towerUnlockStrings.Length) + { + UnlockAchievement("UnlockAllTowers"); + } + } + + public void BeatLevel(int level) + { + int gameMode = GameManager.instance.gameMode; + if (level == 15) + { + switch (gameMode) + { + case 1: + UnlockAchievement("BeatLevel15Mode1"); + break; + case 2: + UnlockAchievement("BeatLevel15Mode2"); + break; + case 3: + UnlockAchievement("BeatLevel15Mode3"); + break; + } + } + if (level == 25) + { + switch (gameMode) + { + case 1: + UnlockAchievement("BeatLevel25Mode1"); + break; + case 2: + UnlockAchievement("BeatLevel25Mode2"); + break; + case 3: + UnlockAchievement("BeatLevel25Mode3"); + break; + } + } + if (level == 35) + { + switch (gameMode) + { + case 1: + UnlockAchievement("BeatLevel35Mode1"); + break; + case 2: + UnlockAchievement("BeatLevel35Mode2"); + break; + case 3: + UnlockAchievement("BeatLevel35Mode3"); + break; + } + if (!shrineSpawned) + { + UnlockAchievement("NoShrines"); + } + } + if (level == 45) + { + switch (gameMode) + { + case 1: + UnlockAchievement("BeatLevel45Mode1"); + break; + case 2: + UnlockAchievement("BeatLevel45Mode2"); + break; + case 3: + UnlockAchievement("BeatLevel45Mode3"); + break; + } + } + } + + public void TowerLevel(int level) + { + switch (level) + { + case 10: + UnlockAchievement("TowerLevel10"); + break; + case 20: + UnlockAchievement("TowerLevel20"); + break; + case 50: + UnlockAchievement("TowerLevel50"); + break; + } + } + + public void CheckTowerTypesVictory() + { + int gameMode = GameManager.instance.gameMode; + if (TowerManager.instance.towersUsed.Contains(TowerType.Crossbow) && TowerManager.instance.towersUsed.Count <= 1) + { + UnlockAchievement("OnlyBallista"); + if (gameMode >= 2) + { + UnlockAchievement("OnlyBallista2"); + } + if (gameMode >= 3) + { + UnlockAchievement("OnlyBallista3"); + } + } + if (!TowerManager.instance.towersUsed.Contains(TowerType.Crossbow)) + { + UnlockAchievement("NoBallista"); + } + if ((TowerManager.instance.towersUsed.Contains(TowerType.Crossbow) && TowerManager.instance.towersUsed.Contains(TowerType.Morter) && TowerManager.instance.towersUsed.Count <= 2) || (TowerManager.instance.towersUsed.Contains(TowerType.Morter) && TowerManager.instance.towersUsed.Count <= 1)) + { + UnlockAchievement("OnlyBallistaMortar"); + if (gameMode >= 2) + { + UnlockAchievement("OnlyBallistaMortar2"); + } + if (gameMode >= 3) + { + UnlockAchievement("OnlyBallistaMortar3"); + } + } + if ((TowerManager.instance.towersUsed.Contains(TowerType.Crossbow) && TowerManager.instance.towersUsed.Contains(TowerType.TeslaCoil) && TowerManager.instance.towersUsed.Count <= 2) || (TowerManager.instance.towersUsed.Contains(TowerType.TeslaCoil) && TowerManager.instance.towersUsed.Count <= 1)) + { + UnlockAchievement("OnlyBallistaTesla"); + if (gameMode >= 2) + { + UnlockAchievement("OnlyBallistaTesla2"); + } + if (gameMode >= 3) + { + UnlockAchievement("OnlyBallistaTesla3"); + } + } + if ((TowerManager.instance.towersUsed.Contains(TowerType.Crossbow) && TowerManager.instance.towersUsed.Contains(TowerType.Frost) && TowerManager.instance.towersUsed.Count <= 2) || (TowerManager.instance.towersUsed.Contains(TowerType.Frost) && TowerManager.instance.towersUsed.Count <= 1)) + { + UnlockAchievement("OnlyBallistaFrost"); + if (gameMode >= 2) + { + UnlockAchievement("OnlyBallistaFrost2"); + } + if (gameMode >= 3) + { + UnlockAchievement("OnlyBallistaFrost3"); + } + } + if ((TowerManager.instance.towersUsed.Contains(TowerType.Crossbow) && TowerManager.instance.towersUsed.Contains(TowerType.FlameThrower) && TowerManager.instance.towersUsed.Count <= 2) || (TowerManager.instance.towersUsed.Contains(TowerType.FlameThrower) && TowerManager.instance.towersUsed.Count <= 1)) + { + UnlockAchievement("OnlyBallistaFlameThrower"); + if (gameMode >= 2) + { + UnlockAchievement("OnlyBallistaFlameThrower2"); + } + if (gameMode >= 3) + { + UnlockAchievement("OnlyBallistaFlameThrower3"); + } + } + if ((TowerManager.instance.towersUsed.Contains(TowerType.Crossbow) && TowerManager.instance.towersUsed.Contains(TowerType.PoisonSprayer) && TowerManager.instance.towersUsed.Count <= 2) || (TowerManager.instance.towersUsed.Contains(TowerType.PoisonSprayer) && TowerManager.instance.towersUsed.Count <= 1)) + { + UnlockAchievement("OnlyBallistaPoisonSprayer"); + if (gameMode >= 2) + { + UnlockAchievement("OnlyBallistaPoisonSprayer2"); + } + if (gameMode >= 3) + { + UnlockAchievement("OnlyBallistaPoisonSprayer3"); + } + } + if ((TowerManager.instance.towersUsed.Contains(TowerType.Crossbow) && TowerManager.instance.towersUsed.Contains(TowerType.Shredder) && TowerManager.instance.towersUsed.Count <= 2) || (TowerManager.instance.towersUsed.Contains(TowerType.Shredder) && TowerManager.instance.towersUsed.Count <= 1)) + { + UnlockAchievement("OnlyBallistaShredder"); + if (gameMode >= 2) + { + UnlockAchievement("OnlyBallistaShredder2"); + } + if (gameMode >= 3) + { + UnlockAchievement("OnlyBallistaShredder3"); + } + } + if ((TowerManager.instance.towersUsed.Contains(TowerType.Crossbow) && TowerManager.instance.towersUsed.Contains(TowerType.Encampment) && TowerManager.instance.towersUsed.Count <= 2) || (TowerManager.instance.towersUsed.Contains(TowerType.Encampment) && TowerManager.instance.towersUsed.Count <= 1)) + { + UnlockAchievement("OnlyBallistaEncampment"); + if (gameMode >= 2) + { + UnlockAchievement("OnlyBallistaEncampment2"); + } + if (gameMode >= 3) + { + UnlockAchievement("OnlyBallistaEncampment3"); + } + } + if ((TowerManager.instance.towersUsed.Contains(TowerType.Crossbow) && TowerManager.instance.towersUsed.Contains(TowerType.Lookout) && TowerManager.instance.towersUsed.Count <= 2) || (TowerManager.instance.towersUsed.Contains(TowerType.Lookout) && TowerManager.instance.towersUsed.Count <= 1)) + { + UnlockAchievement("OnlyBallistaLookout"); + if (gameMode >= 2) + { + UnlockAchievement("OnlyBallistaLookout2"); + } + if (gameMode >= 3) + { + UnlockAchievement("OnlyBallistaLookout3"); + } + } + if ((TowerManager.instance.towersUsed.Contains(TowerType.Crossbow) && TowerManager.instance.towersUsed.Contains(TowerType.Radar) && TowerManager.instance.towersUsed.Count <= 2) || (TowerManager.instance.towersUsed.Contains(TowerType.Radar) && TowerManager.instance.towersUsed.Count <= 1)) + { + UnlockAchievement("OnlyBallistaRadar"); + if (gameMode >= 2) + { + UnlockAchievement("OnlyBallistaRadar2"); + } + if (gameMode >= 3) + { + UnlockAchievement("OnlyBallistaRadar3"); + } + } + if ((TowerManager.instance.towersUsed.Contains(TowerType.Crossbow) && TowerManager.instance.towersUsed.Contains(TowerType.Obelisk) && TowerManager.instance.towersUsed.Count <= 2) || (TowerManager.instance.towersUsed.Contains(TowerType.Obelisk) && TowerManager.instance.towersUsed.Count <= 1)) + { + UnlockAchievement("OnlyBallistaObelisk"); + if (gameMode >= 2) + { + UnlockAchievement("OnlyBallistaObelisk2"); + } + if (gameMode >= 3) + { + UnlockAchievement("OnlyBallistaObelisk3"); + } + } + if ((TowerManager.instance.towersUsed.Contains(TowerType.Crossbow) && TowerManager.instance.towersUsed.Contains(TowerType.ParticleCannon) && TowerManager.instance.towersUsed.Count <= 2) || (TowerManager.instance.towersUsed.Contains(TowerType.ParticleCannon) && TowerManager.instance.towersUsed.Count <= 1)) + { + UnlockAchievement("OnlyBallistaParticleCannon"); + if (gameMode >= 2) + { + UnlockAchievement("OnlyBallistaParticleCannon2"); + } + if (gameMode >= 3) + { + UnlockAchievement("OnlyBallistaParticleCannon3"); + } + } + } + + public bool CheckAllTowers() + { + if (!TowerManager.instance.towersUsed.Contains(TowerType.Crossbow)) + { + return false; + } + if (!TowerManager.instance.towersUsed.Contains(TowerType.Morter)) + { + return false; + } + if (!TowerManager.instance.towersUsed.Contains(TowerType.TeslaCoil)) + { + return false; + } + if (!TowerManager.instance.towersUsed.Contains(TowerType.Frost)) + { + return false; + } + if (!TowerManager.instance.towersUsed.Contains(TowerType.FlameThrower)) + { + return false; + } + if (!TowerManager.instance.towersUsed.Contains(TowerType.PoisonSprayer)) + { + return false; + } + if (!TowerManager.instance.towersUsed.Contains(TowerType.Shredder)) + { + return false; + } + if (!TowerManager.instance.towersUsed.Contains(TowerType.Encampment)) + { + return false; + } + if (!TowerManager.instance.towersUsed.Contains(TowerType.Lookout)) + { + return false; + } + if (!TowerManager.instance.towersUsed.Contains(TowerType.Radar)) + { + return false; + } + if (!TowerManager.instance.towersUsed.Contains(TowerType.Obelisk)) + { + return false; + } + if (!TowerManager.instance.towersUsed.Contains(TowerType.ParticleCannon)) + { + return false; + } + UnlockAchievement("UsedAllTowers"); + return true; + } +} diff --git a/GameCode/AssemblyInfo.cs b/GameCode/AssemblyInfo.cs new file mode 100644 index 0000000..bbd7eef --- /dev/null +++ b/GameCode/AssemblyInfo.cs @@ -0,0 +1,5 @@ +using System.Diagnostics; +using System.Reflection; +using System.Runtime.CompilerServices; + +[assembly: AssemblyVersion("0.0.0.0")] diff --git a/GameCode/AudioPoolSource.cs b/GameCode/AudioPoolSource.cs new file mode 100644 index 0000000..883151d --- /dev/null +++ b/GameCode/AudioPoolSource.cs @@ -0,0 +1,40 @@ +using UnityEngine; + +public class AudioPoolSource : MonoBehaviour +{ + [SerializeField] + private AudioSource audioS; + + private float timer = -1f; + + private bool active; + + public void PlayClip(AudioClip clip, float volume, float pitchVariance) + { + audioS.Stop(); + audioS.clip = clip; + audioS.pitch = 1f + Random.Range(0f - pitchVariance, pitchVariance); + audioS.volume = volume; + timer = clip.length + 0.1f; + active = true; + audioS.Play(); + } + + private void Update() + { + if (!active) + { + return; + } + timer -= Time.deltaTime; + if (timer <= 0f) + { + active = false; + if (base.transform.parent != null) + { + base.transform.parent = null; + } + SFXManager.instance.sources.Add(this); + } + } +} diff --git a/GameCode/BattleCry.cs b/GameCode/BattleCry.cs new file mode 100644 index 0000000..f76a756 --- /dev/null +++ b/GameCode/BattleCry.cs @@ -0,0 +1,84 @@ +using UnityEngine; + +public class BattleCry : MonoBehaviour +{ + public enum BattleCryTrigger + { + Death, + Spawn, + NearEnd, + ArmorBreak, + ShieldBreak + } + + [SerializeField] + private LayerMask enemyLayerMask; + + [SerializeField] + private string battleCryText = "Battle Cry!"; + + [SerializeField] + private float cryRadius; + + [SerializeField] + private BattleCryTrigger myTrigger; + + [SerializeField] + private float fortifyTime; + + [SerializeField] + private float hastePercentage; + + [SerializeField] + private GameObject[] enemiesToSpawn; + + private bool triggered; + + public void CheckBattleCry(BattleCryTrigger source) + { + if (source == myTrigger && !triggered) + { + Cry(); + } + } + + private void Cry() + { + if (enemiesToSpawn.Length != 0) + { + Waypoint currentWaypoint = GetComponent<Pathfinder>().currentWaypoint; + GameObject[] array = enemiesToSpawn; + for (int i = 0; i < array.Length; i++) + { + Enemy component = Object.Instantiate(array[i], base.transform.position + new Vector3(Random.Range(-0.5f, 0.5f), 0f, Random.Range(-0.5f, 0.5f)), Quaternion.identity).GetComponent<Enemy>(); + component.SetStats(); + component.SetFirstSpawnPoint(currentWaypoint); + SpawnManager.instance.currentEnemies.Add(component); + } + } + DamageNumber component2 = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component2.SetText(battleCryText, "Grey", 1f); + component2.SetHoldTime(2f); + if (myTrigger != 0) + { + component2.transform.parent = base.transform; + } + Collider[] array2 = Physics.OverlapSphere(base.transform.position, cryRadius, enemyLayerMask, QueryTriggerInteraction.Collide); + for (int i = 0; i < array2.Length; i++) + { + Enemy component3 = array2[i].GetComponent<Enemy>(); + if (component3 != null) + { + if (fortifyTime > 0f) + { + component3.Fortify(fortifyTime); + } + if (hastePercentage > 0f) + { + component3.AddHaste(hastePercentage); + } + } + } + triggered = true; + } +} diff --git a/GameCode/BiPlane.cs b/GameCode/BiPlane.cs new file mode 100644 index 0000000..bcf32e5 --- /dev/null +++ b/GameCode/BiPlane.cs @@ -0,0 +1,161 @@ +using UnityEngine; + +public class BiPlane : MonoBehaviour +{ + [SerializeField] + private TowerType towerType; + + [SerializeField] + private float speed; + + [SerializeField] + private float turnTime = 3f; + + [SerializeField] + private float minDistance = 3f; + + [SerializeField] + private float maxDistance = 12f; + + [SerializeField] + private float attackDistance = 6f; + + public GameObject target; + + private int directionMultiplier = 1; + + private Vector3 previousPos; + + private bool flyingTowards = true; + + private float desiredAltitude = 5f; + + private float desiredTilt; + + public int damage; + + public int healthDamage; + + public int armorDamage; + + public int shieldDamage; + + public float rps; + + public float slowPercent; + + public float bleedPercent; + + public float burnPercent; + + public float poisonPercent; + + public float critChance; + + public float stunChance; + + private int ammo; + + [SerializeField] + private int maxAmmo = 20; + + private float timeOfLastShot; + + [SerializeField] + private LayerMask bulletHitMask; + + [SerializeField] + private GameObject projectile; + + [SerializeField] + private float projectileSpeed; + + [SerializeField] + private Transform muzzle; + + [SerializeField] + private Transform artTransform; + + private void Start() + { + ammo = maxAmmo; + } + + private void Update() + { + FlightPath(); + } + + private void FixedUpdate() + { + } + + private void FlightPath() + { + Vector3 vector; + if (target != null) + { + vector = target.transform.position; + } + else + { + vector = Vector3.zero; + vector.y = 5f; + } + if (Vector3.SqrMagnitude(vector - base.transform.position) <= minDistance * minDistance) + { + flyingTowards = false; + Reload(); + } + else if (Vector3.SqrMagnitude(vector - base.transform.position) >= maxDistance * maxDistance) + { + flyingTowards = true; + } + float num = ((!flyingTowards) ? 0f : Vector2.SignedAngle(new Vector2(base.transform.forward.x, base.transform.forward.z), new Vector2(vector.x - base.transform.position.x, vector.z - base.transform.position.z))); + float num2; + if (target != null && flyingTowards && Vector3.SqrMagnitude(vector - base.transform.position) <= attackDistance * attackDistance) + { + desiredAltitude += (Mathf.Min(vector.y, 1f) - desiredAltitude) * Time.deltaTime * 1.5f; + num2 = base.transform.position.y - desiredAltitude; + if (Mathf.Abs(num) < 22.5f) + { + Fire(); + } + } + else + { + desiredAltitude += (5f - desiredAltitude) * Time.deltaTime * 3f; + num2 = base.transform.position.y - desiredAltitude; + } + num = Mathf.Clamp(num * 6f, -90f, 90f); + num2 = Mathf.Clamp(num2 * 6f, -45f, 45f); + base.transform.Rotate(new Vector3(0f, (0f - num) * Time.deltaTime / turnTime, 0f)); + base.transform.eulerAngles = new Vector3(num2, base.transform.eulerAngles.y, 0f); + base.transform.Translate(Vector3.forward * Time.deltaTime * speed); + desiredTilt += (num - desiredTilt) * Time.deltaTime; + artTransform.eulerAngles = new Vector3(base.transform.eulerAngles.x, base.transform.eulerAngles.y, desiredTilt); + } + + private void Reload() + { + ammo = maxAmmo; + } + + private void Fire() + { + if (ammo > 0 && timeOfLastShot + rps <= Time.time) + { + ammo--; + timeOfLastShot = Time.time; + LaunchProjectile(); + } + } + + private void LaunchProjectile() + { + Vector3 position = target.transform.position; + position += new Vector3(Random.Range(-0.33f, 0.33f) + Random.Range(-0.33f, 0.33f), Random.Range(-0.33f, 0.33f) + Random.Range(-0.33f, 0.33f), Random.Range(-0.33f, 0.33f) + Random.Range(-0.33f, 0.33f)); + muzzle.LookAt(position); + Object.Instantiate(projectile, muzzle.position, muzzle.rotation).GetComponent<Projectile>().SetStats(towerType, target, projectileSpeed, damage, healthDamage, armorDamage, shieldDamage, slowPercent, bleedPercent, burnPercent, poisonPercent, critChance, stunChance); + } +} diff --git a/GameCode/BuildButtonUI.cs b/GameCode/BuildButtonUI.cs new file mode 100644 index 0000000..86c7732 --- /dev/null +++ b/GameCode/BuildButtonUI.cs @@ -0,0 +1,107 @@ +using UnityEngine; +using UnityEngine.UI; + +public class BuildButtonUI : MonoBehaviour +{ + [SerializeField] + private GameObject tower; + + [SerializeField] + private TowerFlyweight towerFlyweight; + + [SerializeField] + private Text priceTag; + + [SerializeField] + private Text modifiersText; + + [SerializeField] + private TowerType myTowerType; + + private void Start() + { + priceTag.text = towerFlyweight.currentPrice + "g"; + UpdateModifiersText(); + } + + public void Build() + { + BuildingManager.instance.EnterBuildMode(tower, towerFlyweight.currentPrice, towerFlyweight.priceIncrease, myTowerType); + } + + public void UpdatePriceText() + { + priceTag.text = towerFlyweight.currentPrice + "g"; + } + + public void UpdateModifiersText() + { + if (!(modifiersText != null)) + { + return; + } + string text = ""; + if (TowerManager.instance.GetBonusBaseDamage(myTowerType) > 0) + { + text = text + "\n+" + TowerManager.instance.GetBonusBaseDamage(myTowerType) + " Base Damage"; + } + if (TowerManager.instance.GetBonusBaseDamage(myTowerType) < 0) + { + text = text + "\n" + TowerManager.instance.GetBonusBaseDamage(myTowerType) + " Base Damage"; + } + if (TowerManager.instance.GetBonusHealthDamage(myTowerType) > 0) + { + text = text + "\n+" + TowerManager.instance.GetBonusHealthDamage(myTowerType) + " Health Damage"; + } + if (TowerManager.instance.GetBonusArmorDamage(myTowerType) > 0) + { + text = text + "\n+" + TowerManager.instance.GetBonusArmorDamage(myTowerType) + " Armor Damage"; + } + if (TowerManager.instance.GetBonusShieldDamage(myTowerType) > 0) + { + text = text + "\n+" + TowerManager.instance.GetBonusShieldDamage(myTowerType) + " Shield Damage"; + } + if (TowerManager.instance.GetCritChance(myTowerType) + TowerManager.instance.GetCritChanceLevelMultiplier(myTowerType) > 0f) + { + text = text + "\n+(" + (int)(TowerManager.instance.GetCritChance(myTowerType) * 100f); + if (TowerManager.instance.GetCritChanceLevelMultiplier(myTowerType) > 1f) + { + text = text + " + " + (int)TowerManager.instance.GetCritChanceLevelMultiplier(myTowerType) + "xLvl"; + } + else if (TowerManager.instance.GetCritChanceLevelMultiplier(myTowerType) > 0f) + { + text += " + level"; + } + text += ")% Crit"; + } + if (TowerManager.instance.GetStunChance(myTowerType) > 0f) + { + text = text + "\n+" + Mathf.FloorToInt(TowerManager.instance.GetStunChance(myTowerType) * 101f) + "% Freeze Chance"; + } + if (TowerManager.instance.GetBonusRange(myTowerType) > 0f) + { + text = text + "\n+" + TowerManager.instance.GetBonusRange(myTowerType) + " Range"; + } + if (TowerManager.instance.GetBonusBlast(myTowerType) > 0f) + { + text = text + "\n+" + (int)(TowerManager.instance.GetBonusBlast(myTowerType) * 100f) + "% Blast Radius"; + } + if (TowerManager.instance.GetBonusSlow(myTowerType) > 0f) + { + text = text + "\n+" + (int)(TowerManager.instance.GetBonusSlow(myTowerType) * 100f) + "% Slow"; + } + if (TowerManager.instance.GetBonusBleed(myTowerType) > 0f) + { + text = text + "\n+" + (int)(TowerManager.instance.GetBonusBleed(myTowerType) * 100f) + "% Bleed"; + } + if (TowerManager.instance.GetBonusBurn(myTowerType) > 0f) + { + text = text + "\n+" + (int)(TowerManager.instance.GetBonusBurn(myTowerType) * 100f) + "% Burn"; + } + if (TowerManager.instance.GetBonusPoison(myTowerType) > 0f) + { + text = text + "\n+" + (int)(TowerManager.instance.GetBonusPoison(myTowerType) * 100f) + "% Poison"; + } + modifiersText.text = text; + } +} diff --git a/GameCode/BuildingGhost.cs b/GameCode/BuildingGhost.cs new file mode 100644 index 0000000..ea1db9f --- /dev/null +++ b/GameCode/BuildingGhost.cs @@ -0,0 +1,13 @@ +using UnityEngine; +using UnityEngine.UI; + +public class BuildingGhost : MonoBehaviour +{ + [SerializeField] + private Text text; + + public void SetText(string newText) + { + text.text = newText; + } +} diff --git a/GameCode/BuildingManager.cs b/GameCode/BuildingManager.cs new file mode 100644 index 0000000..4ace1ac --- /dev/null +++ b/GameCode/BuildingManager.cs @@ -0,0 +1,163 @@ +using UnityEngine; + +public class BuildingManager : MonoBehaviour +{ + public static BuildingManager instance; + + [SerializeField] + private GameObject buildingGhost; + + private GameObject currentGhost; + + [SerializeField] + private GameObject placementFXObject; + + [SerializeField] + public GameObject levelUpFX; + + [SerializeField] + private LayerMask buildableMask; + + private bool buildSpotAvailable; + + private GameObject thingToBuild; + + private int buildingCost; + + private int priceIncrease; + + private TowerType tType; + + public bool buildMode { get; private set; } + + private void Awake() + { + instance = this; + } + + private void Start() + { + buildMode = false; + } + + private void FixedUpdate() + { + if (buildMode) + { + buildSpotAvailable = SamplePoint(); + } + } + + private void Update() + { + if (!buildMode) + { + return; + } + if (Input.GetMouseButtonDown(0) && BuildingCheck()) + { + ResourceManager.instance.Spend(buildingCost); + DamageTracker.instance.AddCost(tType, buildingCost); + Build(); + if (!Input.GetKey(KeyCode.LeftShift)) + { + ExitBuildMode(); + } + else + { + buildingCost += priceIncrease; + } + } + if (Input.GetMouseButtonDown(1) || Input.GetKeyDown(KeyCode.Escape)) + { + ExitBuildMode(); + } + } + + public void EnterBuildMode(GameObject objectToBuild, int cost, int _priceIncrease, TowerType type) + { + buildMode = true; + thingToBuild = objectToBuild; + buildingCost = cost; + priceIncrease = _priceIncrease; + tType = type; + } + + private void ExitBuildMode() + { + HideGhost(); + buildMode = false; + } + + private void Build() + { + GameObject gameObject = Object.Instantiate(thingToBuild, currentGhost.transform.position, Quaternion.identity); + gameObject.GetComponent<IBuildable>()?.SetStats(); + Object.Instantiate(placementFXObject, gameObject.transform.position + Vector3.up * 0.333f, Quaternion.identity); + buildSpotAvailable = SamplePoint(); + } + + private bool BuildingCheck() + { + if (!PauseMenu.instance.paused && buildSpotAvailable && ResourceManager.instance.CheckMoney(buildingCost)) + { + return true; + } + if (!ResourceManager.instance.CheckMoney(buildingCost) && !PauseMenu.instance.paused && buildSpotAvailable) + { + DamageNumber component = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, currentGhost.transform.position + Vector3.up, Quaternion.identity).GetComponent<DamageNumber>(); + component.SetText("Not enough gold", "Grey", 1f); + component.SetHoldTime(0.25f); + } + return false; + } + + private bool SamplePoint() + { + if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out var hitInfo, 2000f, buildableMask, QueryTriggerInteraction.Ignore)) + { + if (hitInfo.collider.gameObject.layer != LayerMask.NameToLayer("Grass")) + { + HideGhost(); + return false; + } + Vector3 vector = new Vector3(Mathf.Round(hitInfo.point.x), Mathf.Round(3f * hitInfo.point.y) / 3f, Mathf.Round(hitInfo.point.z)); + if (Vector3.SqrMagnitude(hitInfo.point - vector) < 0.25f) + { + string text = ""; + if (vector.y > 0.34f) + { + text = "+" + (Mathf.RoundToInt(vector.y * 3f) - 1); + } + DisplayGhost(vector, text); + return true; + } + HideGhost(); + return false; + } + HideGhost(); + return false; + } + + private void DisplayGhost(Vector3 pos, string text) + { + if (currentGhost == null) + { + currentGhost = Object.Instantiate(buildingGhost, pos, Quaternion.identity); + } + else + { + currentGhost.SetActive(value: true); + currentGhost.transform.position = pos; + } + currentGhost.GetComponent<BuildingGhost>().SetText(text); + } + + private void HideGhost() + { + if (currentGhost != null) + { + currentGhost.SetActive(value: false); + } + } +} diff --git a/GameCode/CameraController.cs b/GameCode/CameraController.cs new file mode 100644 index 0000000..2b91184 --- /dev/null +++ b/GameCode/CameraController.cs @@ -0,0 +1,96 @@ +using UnityEngine; + +public class CameraController : MonoBehaviour +{ + public static CameraController instance; + + [SerializeField] + private Vector3 velocity = Vector3.zero; + + [SerializeField] + private float cameraSpeed = 10f; + + [SerializeField] + private float cameraBaseZoom = 10f; + + [SerializeField] + private GameObject cameraHolder; + + [SerializeField] + private Transform audioListenerObject; + + [SerializeField] + private LayerMask zeroMask; + + private Vector3 clickMoveOrigin; + + private Vector3 cameraOrigin; + + private void Awake() + { + instance = this; + } + + private void Start() + { + Camera.main.orthographicSize = cameraBaseZoom; + if (audioListenerObject != null) + { + audioListenerObject.position = new Vector3(audioListenerObject.position.x, cameraBaseZoom, audioListenerObject.position.z); + } + } + + private void Update() + { + UpdateMovement(); + UpdateZoom(); + } + + private void UpdateMovement() + { + if (Input.GetKeyDown(KeyCode.C)) + { + base.transform.position = Vector3.zero; + } + if (Input.GetMouseButtonDown(1) && Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out var hitInfo, 2000f, zeroMask, QueryTriggerInteraction.Collide)) + { + clickMoveOrigin = hitInfo.point; + cameraOrigin = base.transform.position; + } + if (Input.GetMouseButton(1)) + { + if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out var hitInfo2, 2000f, zeroMask, QueryTriggerInteraction.Collide)) + { + Vector3 vector = cameraOrigin - 2f * (hitInfo2.point - clickMoveOrigin); + base.transform.position = (base.transform.position + vector) / 2f; + } + return; + } + if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift)) + { + velocity *= 1f - Time.deltaTime; + velocity += new Vector3(Input.GetAxisRaw("Horizontal"), 0f, Input.GetAxisRaw("Vertical")) * Time.deltaTime * 2f; + float num = Mathf.Clamp(Camera.main.orthographicSize / 10f, 1f, 5f); + base.transform.Translate(velocity * Time.deltaTime * cameraSpeed * num); + return; + } + velocity = Vector3.zero; + Vector3 vector2 = new Vector3(Input.GetAxisRaw("Horizontal"), 0f, Input.GetAxisRaw("Vertical")); + if (vector2.sqrMagnitude > 0.1f) + { + float num2 = Mathf.Clamp(Camera.main.orthographicSize / 10f, 1f, 5f); + base.transform.Translate(vector2.normalized * Time.deltaTime * cameraSpeed * num2); + } + } + + private void UpdateZoom() + { + float num = Mathf.Clamp(Camera.main.orthographicSize - Input.mouseScrollDelta.y, 1f, 50f); + Camera.main.orthographicSize = num; + cameraHolder.transform.localPosition = new Vector3(0f, 5f + 2f * num, -2f * num - 5f); + if (audioListenerObject != null) + { + audioListenerObject.position = new Vector3(audioListenerObject.position.x, (num + 10f) / 2f, audioListenerObject.position.z); + } + } +} diff --git a/GameCode/CardManager.cs b/GameCode/CardManager.cs new file mode 100644 index 0000000..08797d3 --- /dev/null +++ b/GameCode/CardManager.cs @@ -0,0 +1,177 @@ +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.UI; + +public class CardManager : MonoBehaviour +{ + public static CardManager instance; + + private List<int> queuedDraws = new List<int>(); + + [SerializeField] + private int baseCardDraw = 3; + + [SerializeField] + private GameObject ui; + + [SerializeField] + private List<UpgradeCard> availableCards = new List<UpgradeCard>(); + + [SerializeField] + private List<UpgradeCard> startCardsCheck = new List<UpgradeCard>(); + + private UpgradeCard[] cards = new UpgradeCard[6]; + + [SerializeField] + private Text[] titles = new Text[6]; + + [SerializeField] + private Image[] images = new Image[6]; + + [SerializeField] + private Text[] descriptions = new Text[6]; + + [SerializeField] + private GameObject[] cardHolders = new GameObject[6]; + + public bool drawingCards { get; private set; } + + private void Awake() + { + instance = this; + } + + private void Start() + { + baseCardDraw = 3 + PlayerPrefs.GetInt("CardDraw1", 0) + PlayerPrefs.GetInt("CardDraw2", 0) + PlayerPrefs.GetInt("CardDraw3", 0); + foreach (UpgradeCard item in startCardsCheck) + { + if (item.unlocked) + { + availableCards.Add(item); + } + } + ArrangeCards(baseCardDraw); + } + + public void DrawCards() + { + DrawCards(baseCardDraw); + } + + public void DrawCards(int numb) + { + if (drawingCards) + { + Debug.Log("Queueing Draw call of " + numb); + queuedDraws.Add(numb); + return; + } + int num = numb; + if (availableCards.Count < num) + { + num = availableCards.Count; + if (num <= 0) + { + Debug.LogError("No cards to draw. (Only " + availableCards.Count + " available)"); + SpawnManager.instance.ShowSpawnUIs(state: true); + return; + } + } + ArrangeCards(num); + SFXManager.instance.PlaySound(Sound.Cards, MusicManager.instance.transform.position, MusicManager.instance.transform); + SpawnManager.instance.ShowSpawnUIs(state: false); + ui.SetActive(value: true); + drawingCards = true; + int[] array = new int[num]; + for (int i = 0; i < num; i++) + { + array[i] = -1; + } + for (int j = 0; j < num; j++) + { + int num2 = Random.Range(0, availableCards.Count); + int num3 = 0; + while (CheckArray(array, num2)) + { + num2 = Random.Range(0, availableCards.Count); + num3++; + if (num3 > 100) + { + Debug.LogError("Possible infinite loop in card selection"); + break; + } + } + array[j] = num2; + } + for (int k = 0; k < num; k++) + { + cards[k] = availableCards[array[k]]; + } + DisplayCards(num); + } + + private void ArrangeCards(int count) + { + for (int i = 0; i < count; i++) + { + cardHolders[i].SetActive(value: true); + } + for (int j = count; j < 6; j++) + { + cardHolders[j].SetActive(value: false); + } + for (int k = 0; k < count; k++) + { + cardHolders[k].transform.localPosition = new Vector3(200 * k - 100 * count + 100, 0f, 0f); + } + } + + private void DisplayCards(int count) + { + for (int i = 0; i < count; i++) + { + titles[i].text = cards[i].title; + images[i].sprite = cards[i].image; + descriptions[i].text = cards[i].description; + } + } + + public void ActivateCard(int index) + { + cards[index].Upgrade(); + foreach (UpgradeCard unlock in cards[index].unlocks) + { + if (unlock.unlocked) + { + availableCards.Add(unlock); + } + } + availableCards.Remove(cards[index]); + drawingCards = false; + if (queuedDraws.Count > 0) + { + int numb = queuedDraws[0]; + queuedDraws.RemoveAt(0); + DrawCards(numb); + return; + } + if (!SpawnManager.instance.combat) + { + SpawnManager.instance.ShowSpawnUIs(state: true); + } + ui.SetActive(value: false); + } + + private bool CheckArray(int[] array, int val) + { + for (int i = 0; i < array.Length; i++) + { + if (array[i] == val) + { + return true; + } + } + return false; + } +} diff --git a/GameCode/DOTUpgradeCard.cs b/GameCode/DOTUpgradeCard.cs new file mode 100644 index 0000000..e90b065 --- /dev/null +++ b/GameCode/DOTUpgradeCard.cs @@ -0,0 +1,109 @@ +using UnityEngine; +using UnityEngine.UI; + +public class DOTUpgradeCard : UpgradeCard +{ + [SerializeField] + private int bleedAmount; + + [SerializeField] + private int burnAmount; + + [SerializeField] + private int poisonAmount; + + [SerializeField] + private GameObject bleedUI; + + [SerializeField] + private GameObject burnUI; + + [SerializeField] + private GameObject poisonUI; + + [SerializeField] + private GameObject stunDmgUI; + + [SerializeField] + private Text bleedText; + + [SerializeField] + private Text burnText; + + [SerializeField] + private Text poisonText; + + [SerializeField] + private Text stunDmgText; + + [SerializeField] + private int bonusDamageOnBleed; + + [SerializeField] + private int bonusDamageOnBurn; + + [SerializeField] + private int bonusDamageOnPoison; + + [SerializeField] + private int bonusDamageOnStun; + + [SerializeField] + private float poisonSlowPercent; + + [SerializeField] + private float burnSpeedDamagePercentBonus; + + [SerializeField] + private float bleedingCritChance; + + [SerializeField] + private float bleedPop; + + [SerializeField] + private float burnPop; + + [SerializeField] + private float poisonPop; + + public override void Upgrade() + { + base.Upgrade(); + GameManager.instance.dotTick += new Vector3(bleedAmount, burnAmount, poisonAmount); + MonsterManager.instance.bonusDamageOnBleed += bonusDamageOnBleed; + MonsterManager.instance.bonusDamageOnBurn += bonusDamageOnBurn; + MonsterManager.instance.bonusDamageOnPoison += bonusDamageOnPoison; + MonsterManager.instance.bonusDamageOnStun += bonusDamageOnStun; + MonsterManager.instance.poisonSlowPercent += poisonSlowPercent; + MonsterManager.instance.burnSpeedDamagePercentBonus += burnSpeedDamagePercentBonus; + MonsterManager.instance.bleedingCritChance += bleedingCritChance; + MonsterManager.instance.bleedPop += bleedPop; + MonsterManager.instance.burnPop += burnPop; + MonsterManager.instance.poisonPop += poisonPop; + if (bleedAmount > 0 || bonusDamageOnBleed > 0) + { + bleedUI.SetActive(value: true); + bleedText.text = GameManager.instance.dotTick.x + " \n (+" + (1 + MonsterManager.instance.bonusDamageOnBleed) + ")"; + } + if (burnAmount > 0 || bonusDamageOnBurn > 0 || burnSpeedDamagePercentBonus > 0f) + { + burnUI.SetActive(value: true); + string text = GameManager.instance.dotTick.y + " \n (+" + (1 + MonsterManager.instance.bonusDamageOnBurn) + ")"; + if (MonsterManager.instance.burnSpeedDamagePercentBonus > 0f) + { + text = text + "\n" + Mathf.FloorToInt(0.01f + MonsterManager.instance.burnSpeedDamagePercentBonus) + "xSlow%"; + } + burnText.text = text; + } + if (poisonAmount > 0 || bonusDamageOnPoison > 0) + { + poisonUI.SetActive(value: true); + poisonText.text = GameManager.instance.dotTick.z + " \n (+" + (1 + MonsterManager.instance.bonusDamageOnPoison) + ")"; + } + if (bonusDamageOnStun > 0) + { + stunDmgUI.SetActive(value: true); + stunDmgText.text = "+" + MonsterManager.instance.bonusDamageOnStun; + } + } +} diff --git a/GameCode/DamageNumber.cs b/GameCode/DamageNumber.cs new file mode 100644 index 0000000..4355328 --- /dev/null +++ b/GameCode/DamageNumber.cs @@ -0,0 +1,138 @@ +using System.Collections; +using UnityEngine; +using UnityEngine.UI; + +public class DamageNumber : MonoBehaviour +{ + [SerializeField] + private Transform holder; + + [SerializeField] + private Text text; + + [SerializeField] + private int baseTextSize; + + [SerializeField] + private float zoom = 0.25f; + + private float hold = 0.5f; + + [SerializeField] + private float spin = 0.5f; + + [SerializeField] + private Color healthColor; + + [SerializeField] + private Color armorColor; + + [SerializeField] + private Color shieldColor; + + [SerializeField] + private Color greyColor; + + [SerializeField] + private Color greenColor; + + public void Start() + { + StartCoroutine(Bloop()); + } + + public void SetNumber(int num, string color, float fontScale) + { + text.fontSize = (int)((float)baseTextSize * fontScale); + text.text = num.ToString(); + switch (color) + { + case "Blue": + text.color = shieldColor; + break; + case "Yellow": + text.color = armorColor; + break; + case "Red": + text.color = healthColor; + break; + case "Grey": + text.color = greyColor; + break; + case "Green": + text.color = greenColor; + break; + } + } + + public void SetText(string _text, string color, float fontScale) + { + text.fontSize = (int)((float)baseTextSize * fontScale); + text.text = _text; + switch (color) + { + case "Blue": + text.color = shieldColor; + break; + case "Yellow": + text.color = armorColor; + break; + case "Red": + text.color = healthColor; + break; + case "Grey": + text.color = greyColor; + break; + case "Green": + text.color = greenColor; + break; + } + } + + public void SetHoldTime(float time) + { + hold = time; + } + + private IEnumerator Bloop() + { + Vector3 scale = Vector3.zero; + holder.localScale = scale; + holder.localPosition = new Vector3(-1.5f, 2.12132f, 1.5f); + text.rectTransform.localRotation = Quaternion.identity; + float t2 = zoom; + while (t2 > 0f) + { + scale += Vector3.one * (1f / zoom) * Time.deltaTime; + holder.localScale = scale; + t2 -= Time.deltaTime; + yield return null; + } + scale = Vector3.one; + holder.localScale = scale; + t2 = hold; + Vector3 direction = new Vector3(Random.Range(-1f, 1f), Random.Range(0f, 1f), 0f); + while (t2 > 0f) + { + holder.localPosition += direction * Time.deltaTime; + t2 -= Time.deltaTime; + yield return null; + } + t2 = spin; + int r = 1; + if (Random.Range(1f, 100f) <= 50f) + { + r = -1; + } + while (t2 > 0f) + { + holder.localPosition += direction * Time.deltaTime; + scale -= Vector3.one * (1f / spin) * Time.deltaTime; + holder.localScale = scale; + text.rectTransform.eulerAngles += r * 180 * Vector3.forward * Time.deltaTime / spin; + t2 -= Time.deltaTime; + yield return null; + } + ObjectPool.instance.PoolDamageNumber(base.gameObject); + } +} diff --git a/GameCode/DamageTracker.cs b/GameCode/DamageTracker.cs new file mode 100644 index 0000000..2d80e8f --- /dev/null +++ b/GameCode/DamageTracker.cs @@ -0,0 +1,101 @@ +using UnityEngine; +using UnityEngine.UI; + +public class DamageTracker : MonoBehaviour +{ + public enum IncomeType + { + Monster, + House, + Haunted, + Bonus + } + + public static DamageTracker instance; + + public GameObject uiObject; + + [SerializeField] + private Text healthDmg; + + [SerializeField] + private Text armorDmg; + + [SerializeField] + private Text shieldDmg; + + [SerializeField] + private Text totalDmg; + + [SerializeField] + private Text cost; + + [SerializeField] + private Text ratio; + + [SerializeField] + private Text incomeTotals; + + [SerializeField] + private Text incomePercent; + + private Vector3[] towerDamage = new Vector3[15]; + + private int[] towerCost = new int[15]; + + private int[] income = new int[4]; + + private void Awake() + { + instance = this; + } + + public void AddDamage(TowerType type, int healthDmg, int armorDmg, int shieldDmg) + { + towerDamage[(int)type].x += (float)healthDmg / 1000f; + towerDamage[(int)type].y += (float)armorDmg / 1000f; + towerDamage[(int)type].z += (float)shieldDmg / 1000f; + } + + public void AddCost(TowerType type, int gold) + { + towerCost[(int)type] += gold; + } + + public void AddIncome(IncomeType type, int gold) + { + income[(int)type] += gold; + } + + public void DisplayIncomeTotals() + { + float num = 0f; + for (int i = 0; i < income.Length; i++) + { + num += (float)income[i]; + } + num = Mathf.Max(num, 1f); + string text = "Gold Generated\n" + income[0] + "g\n" + income[1] + "g\n" + income[2] + "g\n" + income[3] + "g\n"; + incomeTotals.text = text; + string text2 = "Income Share\n" + Mathf.FloorToInt((float)(100 * income[0]) / num) + "%\n" + Mathf.FloorToInt((float)(100 * income[1]) / num) + "%\n" + Mathf.FloorToInt((float)(100 * income[2]) / num) + "%\n" + Mathf.FloorToInt((float)(100 * income[3]) / num) + "%\n"; + incomePercent.text = text2; + } + + public void DisplayDamageTotals() + { + uiObject.SetActive(value: true); + DisplayIncomeTotals(); + string text = "Health\n" + (int)towerDamage[0].x + "K\n" + (int)towerDamage[1].x + "K\n" + (int)towerDamage[2].x + "K\n" + (int)towerDamage[3].x + "K\n" + (int)towerDamage[5].x + "K\n" + (int)towerDamage[6].x + "K\n" + (int)towerDamage[12].x + "K\n" + (int)towerDamage[13].x + "K\n" + (int)towerDamage[14].x + "K\n" + (int)towerDamage[8].x + "K\n" + (int)towerDamage[4].x + "K\n" + (int)towerDamage[9].x + "K\n" + (int)towerDamage[10].x + "K\n"; + healthDmg.text = text; + string text2 = "Armor\n" + (int)towerDamage[0].y + "K\n" + (int)towerDamage[1].y + "K\n" + (int)towerDamage[2].y + "K\n" + (int)towerDamage[3].y + "K\n" + (int)towerDamage[5].y + "K\n" + (int)towerDamage[6].y + "K\n" + (int)towerDamage[12].y + "K\n" + (int)towerDamage[13].y + "K\n" + (int)towerDamage[14].y + "K\n" + (int)towerDamage[8].y + "K\n" + (int)towerDamage[4].y + "K\n" + (int)towerDamage[9].y + "K\n" + (int)towerDamage[10].y + "K\n"; + armorDmg.text = text2; + string text3 = "Shield\n" + (int)towerDamage[0].z + "K\n" + (int)towerDamage[1].z + "K\n" + (int)towerDamage[2].z + "K\n" + (int)towerDamage[3].z + "K\n" + (int)towerDamage[5].z + "K\n" + (int)towerDamage[6].z + "K\n" + (int)towerDamage[12].z + "K\n" + (int)towerDamage[13].z + "K\n" + (int)towerDamage[14].z + "K\n" + (int)towerDamage[8].z + "K\n" + (int)towerDamage[4].z + "K\n" + (int)towerDamage[9].z + "K\n" + (int)towerDamage[10].z + "K\n"; + shieldDmg.text = text3; + string text4 = "Total\n" + (int)(towerDamage[0].x + towerDamage[0].y + towerDamage[0].z) + "K\n" + (int)(towerDamage[1].x + towerDamage[1].y + towerDamage[1].z) + "K\n" + (int)(towerDamage[2].x + towerDamage[2].y + towerDamage[2].z) + "K\n" + (int)(towerDamage[3].x + towerDamage[3].y + towerDamage[3].z) + "K\n" + (int)(towerDamage[5].x + towerDamage[5].y + towerDamage[5].z) + "K\n" + (int)(towerDamage[6].x + towerDamage[6].y + towerDamage[6].z) + "K\n" + (int)(towerDamage[12].x + towerDamage[12].y + towerDamage[12].z) + "K\n" + (int)(towerDamage[13].x + towerDamage[13].y + towerDamage[13].z) + "K\n" + (int)(towerDamage[14].x + towerDamage[14].y + towerDamage[14].z) + "K\n" + (int)(towerDamage[8].x + towerDamage[8].y + towerDamage[8].z) + "K\n" + (int)(towerDamage[4].x + towerDamage[4].y + towerDamage[4].z) + "K\n" + (int)(towerDamage[9].x + towerDamage[9].y + towerDamage[9].z) + "K\n" + (int)(towerDamage[10].x + towerDamage[10].y + towerDamage[10].z) + "K\n"; + totalDmg.text = text4; + string text5 = "Cost\n" + towerCost[0] + "g\n" + towerCost[1] + "g\n" + towerCost[2] + "g\n" + towerCost[3] + "g\n" + towerCost[5] + "g\n" + towerCost[6] + "g\n" + towerCost[12] + "g\n" + towerCost[13] + "g\n" + towerCost[14] + "g\n" + towerCost[8] + "g\n" + towerCost[4] + "g\n" + towerCost[9] + "g\n"; + cost.text = text5; + string text6 = "Dmg/g\n" + (1000f * ((towerDamage[0].x + towerDamage[0].y + towerDamage[0].z) / (float)Mathf.Max(towerCost[0], 1))).ToString("F2") + "\n" + (1000f * ((towerDamage[1].x + towerDamage[1].y + towerDamage[1].z) / (float)Mathf.Max(towerCost[1], 1))).ToString("F2") + "\n" + (1000f * ((towerDamage[2].x + towerDamage[2].y + towerDamage[2].z) / (float)Mathf.Max(towerCost[2], 1))).ToString("F2") + "\n" + (1000f * ((towerDamage[3].x + towerDamage[3].y + towerDamage[3].z) / (float)Mathf.Max(towerCost[3], 1))).ToString("F2") + "\n" + (1000f * ((towerDamage[5].x + towerDamage[5].y + towerDamage[5].z) / (float)Mathf.Max(towerCost[5], 1))).ToString("F2") + "\n" + (1000f * ((towerDamage[6].x + towerDamage[6].y + towerDamage[6].z) / (float)Mathf.Max(towerCost[6], 1))).ToString("F2") + "\n" + (1000f * ((towerDamage[12].x + towerDamage[12].y + towerDamage[12].z) / (float)Mathf.Max(towerCost[12], 1))).ToString("F2") + "\n" + (1000f * ((towerDamage[13].x + towerDamage[13].y + towerDamage[13].z) / (float)Mathf.Max(towerCost[13], 1))).ToString("F2") + "\n" + (1000f * ((towerDamage[14].x + towerDamage[14].y + towerDamage[14].z) / (float)Mathf.Max(towerCost[14], 1))).ToString("F2") + "\n" + (1000f * ((towerDamage[8].x + towerDamage[8].y + towerDamage[8].z) / (float)Mathf.Max(towerCost[8], 1))).ToString("F2") + "\n" + (1000f * ((towerDamage[4].x + towerDamage[4].y + towerDamage[4].z) / (float)Mathf.Max(towerCost[4], 1))).ToString("F2") + "\n" + (1000f * ((towerDamage[9].x + towerDamage[9].y + towerDamage[9].z) / (float)Mathf.Max(towerCost[9], 1))).ToString("F2") + "\n"; + ratio.text = text6; + } +} diff --git a/GameCode/DevelopmentManager.cs b/GameCode/DevelopmentManager.cs new file mode 100644 index 0000000..7caec25 --- /dev/null +++ b/GameCode/DevelopmentManager.cs @@ -0,0 +1,23 @@ +using UnityEngine; + +public class DevelopmentManager : MonoBehaviour +{ + [SerializeField] + private GameObject[] startingDevelopments; + + private float developmentPercent; + + private void Start() + { + developmentPercent = PlayerPrefs.GetInt("UnlockedCardCount", 0) + PlayerPrefs.GetInt("Development", 0); + developmentPercent *= 0.4f; + GameObject[] array = startingDevelopments; + foreach (GameObject obj in array) + { + if (Random.Range(0f, 100f) > developmentPercent) + { + Object.Destroy(obj); + } + } + } +} diff --git a/GameCode/Dropper.cs b/GameCode/Dropper.cs new file mode 100644 index 0000000..0dc7a10 --- /dev/null +++ b/GameCode/Dropper.cs @@ -0,0 +1,126 @@ +using System.Collections.Generic; +using UnityEngine; + +public class Dropper : Tower +{ + [SerializeField] + private int manaPerSecond; + + [SerializeField] + private float dropHeight = 3f; + + [SerializeField] + private LayerMask dropSetMask; + + [SerializeField] + protected Vector2[] dropPoints; + + [SerializeField] + private bool requireTargetToDrop; + + private int currentLevel; + + public float dropperRPMdisplay; + + private float timeOfNextManaCheck; + + private bool canFire = true; + + protected override void Start() + { + base.Start(); + SetDropPoints(); + } + + public override void SetStats() + { + base.SetStats(); + rps = 60f / rpm * (10f / (10f + (float)dropPoints.Length)); + dropperRPMdisplay = rpm * (10f + (float)dropPoints.Length) / 10f; + } + + private void SetDropPoints() + { + List<Vector2> list = new List<Vector2>(); + for (int i = -(int)base.range; (float)i <= base.range; i++) + { + for (int j = -(int)base.range; (float)j <= base.range; j++) + { + if (Physics.Raycast(new Vector3(base.transform.position.x + (float)i, dropHeight, base.transform.position.z + (float)j), Vector3.down, out var hitInfo, 1.5f * dropHeight, dropSetMask, QueryTriggerInteraction.Ignore) && hitInfo.transform.gameObject.layer == LayerMask.NameToLayer("Path")) + { + list.Add(new Vector2(i, j)); + } + } + } + dropPoints = list.ToArray(); + rps = 60f / rpm * (10f / (10f + (float)dropPoints.Length)); + dropperRPMdisplay = rpm * (10f + (float)dropPoints.Length) / 10f; + } + + protected override void Update() + { + if (SpawnManager.instance.level != currentLevel) + { + SetDropPoints(); + currentLevel = SpawnManager.instance.level; + } + if (currentTarget != null) + { + if (turret != null) + { + AimTurret(); + } + GainXP(); + } + if (manaPerSecond > 0 && Time.time >= timeOfNextManaCheck && SpawnManager.instance.combat) + { + timeOfNextManaCheck = Time.time + 1f; + if (ResourceManager.instance.CheckMana(manaPerSecond)) + { + ResourceManager.instance.SpendMana(manaPerSecond); + canFire = true; + } + else + { + canFire = false; + } + } + timeSinceLastShot += Time.deltaTime; + if (canFire && TargetingCheck() && timeSinceLastShot > rps && SpawnManager.instance.combat) + { + Fire(); + timeSinceLastShot = 0f; + } + } + + private bool TargetingCheck() + { + if (requireTargetToDrop) + { + if (currentTarget != null) + { + return true; + } + return false; + } + return true; + } + + protected override void Fire() + { + if (consumesMana) + { + int manaCost = (int)((float)base.damage * manaConsumptionRate); + if (!ResourceManager.instance.CheckMana(manaCost)) + { + return; + } + ResourceManager.instance.SpendMana(manaCost); + } + if (dropPoints.Length != 0) + { + Vector2 vector = dropPoints[Random.Range(0, dropPoints.Length)]; + Object.Instantiate(projectile, new Vector3(vector.x, dropHeight, vector.y) + base.transform.position, Quaternion.identity).GetComponent<Projectile>().SetStats(towerType, null, projectileSpeed, base.damage, base.healthDamage, base.armorDamage, base.shieldDamage, base.slowPercent, base.bleedPercent, base.burnPercent, base.poisonPercent, base.critChance, base.stunChance); + } + } +} diff --git a/GameCode/Encampment.cs b/GameCode/Encampment.cs new file mode 100644 index 0000000..eaa8ab7 --- /dev/null +++ b/GameCode/Encampment.cs @@ -0,0 +1,26 @@ +using UnityEngine; + +public class Encampment : Dropper +{ + protected override void Fire() + { + if (consumesMana) + { + int manaCost = (int)((float)base.damage * manaConsumptionRate); + if (!ResourceManager.instance.CheckMana(manaCost)) + { + return; + } + ResourceManager.instance.SpendMana(manaCost); + } + if (dropPoints.Length != 0) + { + Vector2 vector = dropPoints[Random.Range(0, dropPoints.Length)]; + Vector3 endPosition = new Vector3(vector.x + Random.Range(-0.125f, 0.125f) + base.transform.position.x, 0f, vector.y + Random.Range(-0.125f, 0.125f) + base.transform.position.z); + GameObject obj = Object.Instantiate(projectile, base.transform.position, Quaternion.identity); + obj.GetComponent<Projectile>().SetStats(towerType, null, projectileSpeed, base.damage, base.healthDamage, base.armorDamage, base.shieldDamage, base.slowPercent, base.bleedPercent, base.burnPercent, base.poisonPercent, base.critChance, base.stunChance); + obj.GetComponent<Landmine>().blastRadius = base.blastRadius; + obj.GetComponent<Landmine>().SetEndPosition(endPosition); + } + } +} diff --git a/GameCode/Enemy.cs b/GameCode/Enemy.cs new file mode 100644 index 0000000..2e7ce7d --- /dev/null +++ b/GameCode/Enemy.cs @@ -0,0 +1,669 @@ +using System.Collections.Generic; +using UnityEngine; + +public class Enemy : MonoBehaviour, IDamageable +{ + [SerializeField] + private Renderer renderer; + + [SerializeField] + private Pathfinder pathfinder; + + [SerializeField] + private HealthBar healthBar; + + [SerializeField] + private GameObject deathObjectSpawn; + + [SerializeField] + private BattleCry[] battleCries; + + [SerializeField] + private GameObject treasureObject; + + [SerializeField] + private Vector2 spawnRange; + + public int level = 1; + + [SerializeField] + private int damageToTower = 1; + + [SerializeField] + private int bonusGoldDrop; + + [SerializeField] + private bool dropsGold = true; + + [SerializeField] + private int hpScaleDegree = 1; + + public int baseHealth; + + public int baseArmor; + + public int baseShield; + + public float baseSpeed; + + public int healthRegen; + + public int armorRegen; + + public int shieldRegen; + + private float timeSinceRegen; + + private float currentSpeed; + + private float currentSlowPercentage; + + private float hastePercentage; + + private float freezeTime; + + private float fortifiedTime; + + private bool fortified; + + private int bleed; + + private int burn; + + private int poison; + + private bool bleeding; + + private bool burning; + + private bool poisoned; + + private float timeSinceBleed; + + private float timeSinceBurn; + + private float timeSincePoison; + + private float dotTick; + + private HashSet<TowerType> typesOfTowers = new HashSet<TowerType>(); + + public Lookout mark; + + private bool dead; + + public int health { get; private set; } + + public int armor { get; private set; } + + public int shield { get; private set; } + + private void Start() + { + CheckBattleCries(BattleCry.BattleCryTrigger.Spawn); + healthBar.UpdateFortified(fortifiedTime); + healthBar.UpdateHaste(hastePercentage); + if (bonusGoldDrop == 0) + { + bonusGoldDrop = ResourceManager.instance.enemyBonusGoldDrop; + } + else + { + bonusGoldDrop += ResourceManager.instance.enemyBonusGoldDrop; + } + } + + public void SetStats() + { + health = baseHealth; + armor = baseArmor; + shield = baseShield; + currentSpeed = baseSpeed + MonsterManager.instance.speedBonus; + pathfinder.speed = currentSpeed; + healthBar.SetHealth(health + armor + shield, health, armor, shield, hpScaleDegree); + } + + public void SetFirstSpawnPoint(Waypoint point) + { + pathfinder.currentWaypoint = point; + } + + private void Update() + { + if (fortifiedTime > 0f) + { + FortifiedUpdate(); + } + if (currentSlowPercentage > 0f || hastePercentage > 0f || freezeTime > 0f) + { + SpeedUpdate(); + } + DOTUpdate(); + RegenUpdate(); + } + + private void SpeedUpdate() + { + float num = freezeTime; + freezeTime = Mathf.Max(0f, freezeTime - Time.deltaTime); + currentSlowPercentage = Mathf.Max(0f, currentSlowPercentage - Time.deltaTime * 0.05f); + hastePercentage = Mathf.Max(0f, hastePercentage - Time.deltaTime * 0.05f); + if (freezeTime > 0f) + { + currentSpeed = 0f; + } + else + { + currentSpeed = (baseSpeed + MonsterManager.instance.speedBonus) * (1f - currentSlowPercentage + hastePercentage); + } + pathfinder.speed = currentSpeed; + if (freezeTime <= 0f && num > 0f && renderer != null) + { + renderer.material.color = Color.white; + } + healthBar.UpdateSlow(currentSlowPercentage); + healthBar.UpdateHaste(hastePercentage); + } + + public void CheckBattleCries(BattleCry.BattleCryTrigger cryType) + { + if (battleCries.Length != 0) + { + BattleCry[] array = battleCries; + for (int i = 0; i < array.Length; i++) + { + array[i].CheckBattleCry(cryType); + } + } + } + + private void AddSlow(float newPercentage) + { + currentSlowPercentage = Mathf.Clamp(currentSlowPercentage + newPercentage, 0f, 0.6f + MonsterManager.instance.slowCapModifier); + } + + public void AddHaste(float amount) + { + hastePercentage = Mathf.Clamp(hastePercentage + amount, 0f, 0.6f + MonsterManager.instance.hasteCapModifier); + if (OptionsMenu.instance.showConditionText) + { + DamageNumber component = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component.SetText("HASTED", "Grey", 1f); + component.SetHoldTime(0.5f); + } + } + + public void Freeze() + { + freezeTime = 1f; + if (renderer != null) + { + renderer.material.color = Color.blue; + } + if (OptionsMenu.instance.showConditionText) + { + DamageNumber component = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component.SetText("FROZEN", "Grey", 1f); + component.SetHoldTime(0.5f); + } + } + + private void FortifiedUpdate() + { + fortifiedTime = Mathf.Max(fortifiedTime - Time.deltaTime, 0f); + if (fortifiedTime <= 0f) + { + fortified = false; + } + healthBar.UpdateFortified(fortifiedTime); + } + + public void Fortify(float time) + { + fortifiedTime = Mathf.Clamp(fortifiedTime + time, 0f, 12f); + healthBar.UpdateFortified(fortifiedTime); + fortified = true; + if (OptionsMenu.instance.showConditionText) + { + DamageNumber component = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component.SetText("FORTIFIED", "Grey", 1f); + component.SetHoldTime(0.5f); + } + } + + private void RegenUpdate() + { + if (timeSinceRegen >= 1f) + { + if (healthRegen > 0 && health > 0) + { + HealHealth(healthRegen); + } + if (armorRegen > 0 && armor > 0) + { + HealArmor(armorRegen); + } + if (shieldRegen > 0 && shield > 0) + { + HealShield(shieldRegen); + } + timeSinceRegen = 0f; + } + else + { + timeSinceRegen += Time.deltaTime; + } + } + + private void HealHealth(int amount) + { + if (health >= baseHealth || bleeding) + { + if (bleeding) + { + DamageTracker.instance.AddDamage(TowerType.DOT, amount, 0, 0); + } + return; + } + if (health + amount >= baseHealth) + { + if (OptionsMenu.instance.showDamageNumbers) + { + DamageNumber component = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component.SetText("+" + (baseHealth - health), "Green", 1f); + component.SetHoldTime(0.5f); + } + health = baseHealth; + } + else + { + health += amount; + if (OptionsMenu.instance.showDamageNumbers) + { + DamageNumber component2 = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component2.SetText("+" + amount, "Green", 1f); + component2.SetHoldTime(0.5f); + } + } + if (healthBar != null) + { + healthBar.UpdateHealth(health, armor, shield, currentSlowPercentage, bleeding, burning, poisoned, bleed, burn, poison); + } + } + + private void HealArmor(int amount) + { + if (armor >= baseArmor || burning) + { + if (burning) + { + DamageTracker.instance.AddDamage(TowerType.DOT, 0, amount, 0); + } + return; + } + if (armor + amount >= baseArmor) + { + if (OptionsMenu.instance.showDamageNumbers) + { + DamageNumber component = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component.SetText("+" + (baseArmor - armor), "Yellow", 1f); + component.SetHoldTime(0.5f); + } + armor = baseArmor; + } + else + { + armor += amount; + if (OptionsMenu.instance.showDamageNumbers) + { + DamageNumber component2 = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component2.SetText("+" + amount, "Yellow", 1f); + component2.SetHoldTime(0.5f); + } + } + if (healthBar != null) + { + healthBar.UpdateHealth(health, armor, shield, currentSlowPercentage, bleeding, burning, poisoned, bleed, burn, poison); + } + } + + private void HealShield(int amount) + { + if (shield >= baseShield || poisoned) + { + if (poisoned) + { + DamageTracker.instance.AddDamage(TowerType.DOT, 0, 0, amount); + } + return; + } + if (shield + amount >= baseShield) + { + if (OptionsMenu.instance.showDamageNumbers) + { + DamageNumber component = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component.SetText("+" + (baseShield - shield), "Blue", 1f); + component.SetHoldTime(0.5f); + } + shield = baseShield; + } + else + { + shield += amount; + if (OptionsMenu.instance.showDamageNumbers) + { + DamageNumber component2 = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component2.SetText("+" + amount, "Blue", 1f); + component2.SetHoldTime(0.5f); + } + } + if (healthBar != null) + { + healthBar.UpdateHealth(health, armor, shield, currentSlowPercentage, bleeding, burning, poisoned, bleed, burn, poison); + } + } + + private void DOTUpdate() + { + if (!dead) + { + BleedCheck(); + BurnCheck(); + PoisonCheck(); + if (poisoned && timeSincePoison <= 0f && dotTick <= 0f) + { + int num = poison; + poison = Mathf.Max(poison - (int)GameManager.instance.dotTick.z, 0); + num -= poison; + int num2 = Mathf.Max(num / 2, 1); + TakeDamage(TowerType.DOT, -999, num2, num2, num, 0f, 0f, 0f, 0f, 0f, 0f); + timeSincePoison = 1f; + dotTick = 0.1f; + } + if (burning && timeSinceBurn <= 0f && dotTick <= 0f) + { + int num3 = burn; + burn = Mathf.Max(burn - (int)(GameManager.instance.dotTick.y * Mathf.Max(1f + MonsterManager.instance.burnSpeedDamagePercentBonus * currentSlowPercentage, 1f)), 0); + num3 -= burn; + int num4 = num3 / 2; + TakeDamage(TowerType.DOT, -999, num4, num3, num4, 0f, 0f, 0f, 0f, 0f, 0f); + timeSinceBurn = 1f; + dotTick = 0.1f; + } + if (bleeding && timeSinceBleed <= 0f && dotTick <= 0f) + { + int num5 = bleed; + bleed = Mathf.Max(bleed - (int)GameManager.instance.dotTick.x, 0); + num5 -= bleed; + int num6 = num5 / 2; + TakeDamage(TowerType.DOT, -999, num5, num6, num6, 0f, 0f, 0f, 0f, 0f, 0f); + timeSinceBleed = 1f; + dotTick = 0.1f; + } + timeSinceBleed -= Time.deltaTime; + timeSinceBurn -= Time.deltaTime; + timeSincePoison -= Time.deltaTime; + dotTick -= Time.deltaTime; + healthBar.UpdateBleed(bleeding, bleed); + healthBar.UpdateBurn(burning, burn); + healthBar.UpdatePoison(poisoned, poison); + } + } + + private int FortifiedCheck() + { + if (fortified) + { + return 5; + } + return 0; + } + + private int BleedCheck() + { + if (bleed > 0) + { + bleeding = true; + return 1 + MonsterManager.instance.bonusDamageOnBleed; + } + bleeding = false; + return 0; + } + + private int BurnCheck() + { + if (burn > 0) + { + burning = true; + return 1 + MonsterManager.instance.bonusDamageOnBurn; + } + burning = false; + return 0; + } + + private int PoisonCheck() + { + if (poison > 0) + { + poisoned = true; + return 1 + MonsterManager.instance.bonusDamageOnPoison; + } + poisoned = false; + return 0; + } + + private int FreezeDmgCheck() + { + if (freezeTime > 0f) + { + return MonsterManager.instance.bonusDamageOnStun; + } + return 0; + } + + public float CurrentHealth() + { + return (float)(health + armor + shield) / (float)(baseHealth + baseArmor + baseShield); + } + + public void TakeDamage(TowerType whoHitMe, int _baseDmg, int healthDmg, int armorDmg, int shieldDmg, float slowPercentage, float bleedPercentage, float burnPercentage, float poisonPercentage, float critChance, float stunChance) + { + if (dead) + { + Debug.Log("Dead enemy taking damage"); + return; + } + typesOfTowers.Add(whoHitMe); + if (Random.Range(0f, 1f) < stunChance) + { + Freeze(); + } + float num = critChance; + if (_baseDmg > -1 && BleedCheck() > 0) + { + num += MonsterManager.instance.bleedingCritChance; + if (mark != null) + { + num += mark.critChance; + } + } + int num2 = _baseDmg; + string text = ""; + float num3 = 1f; + if (Random.Range(0f, 1f) < Mathf.Min(num - 1f, 0.5f)) + { + num2 *= 4; + text = "!!!"; + num3 = 2.5f; + SFXManager.instance.PlaySound(Sound.CritBig, base.transform.position); + } + else if (Random.Range(0f, 1f) < Mathf.Min(num - 0.5f, 0.5f)) + { + num2 *= 3; + text = "!!"; + num3 = 2f; + SFXManager.instance.PlaySound(Sound.CritBig, base.transform.position); + } + else if (Random.Range(0f, 1f) < Mathf.Min(num, 0.5f)) + { + num2 *= 2; + text = "!"; + num3 = 1.5f; + SFXManager.instance.PlaySound(Sound.CritBig, base.transform.position); + } + int num4 = 0; + int num5 = 0; + string color; + if (shield > 0) + { + num4 = Mathf.Max(num2 - FortifiedCheck() + (int)MarkCheck().x + FreezeDmgCheck(), 1) * (shieldDmg + PoisonCheck() + (int)MarkCheck().w); + if (num4 > shield) + { + num5 = (int)((float)(num4 - shield) / (float)shieldDmg); + } + shield -= num4; + color = "Blue"; + DamageTracker.instance.AddDamage(whoHitMe, 0, 0, num4); + shield = Mathf.Max(shield, 0); + if (shield == 0) + { + CheckBattleCries(BattleCry.BattleCryTrigger.ShieldBreak); + } + } + else if (armor > 0) + { + num4 = Mathf.Max(num2 - FortifiedCheck() + (int)MarkCheck().x + FreezeDmgCheck(), 1) * (armorDmg + BurnCheck() + (int)MarkCheck().z); + if (num4 > armor) + { + num5 = (int)((float)(num4 - armor) / (float)armorDmg); + } + armor -= num4; + color = "Yellow"; + DamageTracker.instance.AddDamage(whoHitMe, 0, num4, 0); + armor = Mathf.Max(armor, 0); + if (armor == 0) + { + CheckBattleCries(BattleCry.BattleCryTrigger.ArmorBreak); + } + } + else + { + num4 = Mathf.Max(num2 - FortifiedCheck() + (int)MarkCheck().x + FreezeDmgCheck(), 1) * (healthDmg + BleedCheck() + (int)MarkCheck().y); + if (num4 >= health) + { + DamageTracker.instance.AddDamage(whoHitMe, health, 0, 0); + } + else + { + DamageTracker.instance.AddDamage(whoHitMe, num4, 0, 0); + } + health -= num4; + color = "Red"; + } + if (OptionsMenu.instance.showDamageNumbers) + { + DamageNumber component = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component.SetText(num4 + text, color, num3); + component.SetHoldTime(0.25f); + } + if (health <= 0) + { + Die(); + return; + } + bleed += (int)((float)num4 * bleedPercentage); + burn += (int)((float)num4 * burnPercentage); + poison += (int)((float)num4 * poisonPercentage); + if (slowPercentage > 0f) + { + AddSlow((float)num4 * slowPercentage / 100f); + } + if (poisonPercentage > 0f) + { + AddSlow(MonsterManager.instance.poisonSlowPercent * poisonPercentage * (float)num4 / 100f); + } + if (num3 > 1f && _baseDmg > -1 && MonsterManager.instance.bleedPop > 0f && !dead) + { + int num6 = (int)((float)bleed * MonsterManager.instance.bleedPop); + bleed -= num6; + TakeDamage(TowerType.DOT, -999, num6, num6 / 2, num6 / 2, 0f, 0f, 0f, 0f, 0f, 0f); + } + if (num3 > 1f && _baseDmg > -1 && MonsterManager.instance.burnPop > 0f && !dead) + { + int num7 = (int)((float)burn * MonsterManager.instance.burnPop); + burn -= num7; + TakeDamage(TowerType.DOT, -999, num7 / 2, num7, num7 / 2, 0f, 0f, 0f, 0f, 0f, 0f); + } + if (num3 > 1f && _baseDmg > -1 && MonsterManager.instance.poisonPop > 0f && !dead) + { + int num8 = (int)((float)poison * MonsterManager.instance.poisonPop); + poison -= num8; + TakeDamage(TowerType.DOT, -999, num8 / 2, num8 / 2, num8, 0f, 0f, 0f, 0f, 0f, 0f); + } + if (healthBar != null) + { + healthBar.UpdateHealth(health, armor, shield, currentSlowPercentage, bleeding, burning, poisoned, bleed, burn, poison); + } + if (num5 > 0 && !dead) + { + TakeDamage(whoHitMe, num5, healthDmg, armorDmg, shieldDmg, slowPercentage, bleedPercentage, burnPercentage, poisonPercentage, 0f, 0f); + } + } + + private Vector4 MarkCheck() + { + Vector4 zero = Vector4.zero; + if (mark != null) + { + zero.x = mark.damage; + zero.y = mark.healthDamage; + zero.z = mark.armorDamage; + zero.w = mark.shieldDamage; + } + return zero; + } + + public Vector3 GetFuturePosition(float t) + { + float distance = currentSpeed * t; + return pathfinder.GetFuturePosition(distance); + } + + public void AtEnd() + { + GameManager.instance.TakeDamage(damageToTower + MonsterManager.instance.extraTowerDamage); + SpawnManager.instance.currentEnemies.Remove(this); + Object.Destroy(base.gameObject); + } + + private void Die() + { + if (!dead) + { + dead = true; + if (deathObjectSpawn != null) + { + Object.Instantiate(deathObjectSpawn, base.transform.position, Quaternion.identity); + } + if (treasureObject != null && spawnRange.y > 0f) + { + int numberOfDrops = Random.Range((int)spawnRange.x, (int)spawnRange.y + GameManager.instance.gameMode); + Object.Instantiate(treasureObject, base.transform.position, Quaternion.identity).GetComponent<TreasureChest>().numberOfDrops = numberOfDrops; + } + CheckBattleCries(BattleCry.BattleCryTrigger.Death); + typesOfTowers.Remove(TowerType.DOT); + if (dropsGold) + { + int num = level + typesOfTowers.Count + bonusGoldDrop + MonsterManager.instance.extraGoldDrop; + ResourceManager.instance.AddMoney(num); + ResourceManager.instance.AddManaPercentMax(MonsterManager.instance.manaDropOnDeath); + DamageTracker.instance.AddIncome(DamageTracker.IncomeType.Monster, num - MonsterManager.instance.extraGoldDrop); + DamageTracker.instance.AddIncome(DamageTracker.IncomeType.Bonus, MonsterManager.instance.extraGoldDrop); + } + SpawnManager.instance.currentEnemies.Remove(this); + SFXManager.instance.PlaySound(Sound.CoinLong, base.transform.position); + AchievementManager.instance.EnemyKilled(); + Object.Destroy(base.gameObject); + } + } +} diff --git a/GameCode/Explosion.cs b/GameCode/Explosion.cs new file mode 100644 index 0000000..a01aa17 --- /dev/null +++ b/GameCode/Explosion.cs @@ -0,0 +1,27 @@ +using UnityEngine; + +public class Explosion : MonoBehaviour +{ + [SerializeField] + private float duration = 2f; + + [SerializeField] + private Sound sound; + + private void Start() + { + if (sound != 0) + { + SFXManager.instance.PlaySound(sound, base.transform.position); + } + } + + private void FixedUpdate() + { + duration -= Time.fixedDeltaTime; + if (duration <= 0f) + { + Object.Destroy(base.gameObject); + } + } +} diff --git a/GameCode/FlameThrower.cs b/GameCode/FlameThrower.cs new file mode 100644 index 0000000..d415d88 --- /dev/null +++ b/GameCode/FlameThrower.cs @@ -0,0 +1,68 @@ +using UnityEngine; + +public class FlameThrower : Tower +{ + [SerializeField] + private ParticleSystem flames; + + public bool flaming; + + private bool hasMana = true; + + [SerializeField] + private AudioSource audioS; + + private bool soundPlaying; + + protected override void Update() + { + if (hasMana && currentTarget != null && !flaming) + { + flames.Play(); + PlaySound(onOff: true); + flaming = true; + } + else if (!hasMana || (currentTarget == null && flaming)) + { + flames.Stop(); + PlaySound(onOff: false); + flaming = false; + } + base.Update(); + } + + protected override void Fire() + { + if (consumesMana) + { + int manaCost = (int)((float)base.damage * manaConsumptionRate); + if (!ResourceManager.instance.CheckMana(manaCost)) + { + hasMana = false; + return; + } + ResourceManager.instance.SpendMana(manaCost); + hasMana = true; + } + RaycastHit[] array = Physics.SphereCastAll(muzzle.position, base.range / 6f, muzzle.transform.forward, base.range * 1.5f, enemyLayerMask, QueryTriggerInteraction.Collide); + foreach (RaycastHit raycastHit in array) + { + raycastHit.collider.GetComponent<IDamageable>()?.TakeDamage(towerType, base.damage, base.healthDamage, base.armorDamage, base.shieldDamage, base.slowPercent, base.bleedPercent, base.burnPercent, base.poisonPercent, base.critChance, base.stunChance); + } + } + + private void PlaySound(bool onOff) + { + if (onOff && !soundPlaying) + { + audioS.volume = OptionsMenu.instance.masterVolume * OptionsMenu.instance.sfxVolume; + audioS.Play(); + soundPlaying = true; + } + else if (!onOff && soundPlaying) + { + audioS.Stop(); + soundPlaying = false; + } + } +} diff --git a/GameCode/GameManager.cs b/GameCode/GameManager.cs new file mode 100644 index 0000000..bfa59e1 --- /dev/null +++ b/GameCode/GameManager.cs @@ -0,0 +1,476 @@ +using UnityEngine; +using UnityEngine.UI; + +public class GameManager : MonoBehaviour +{ + [SerializeField] + private TileManager tileManager; + + [SerializeField] + private SpawnManager spawnManager; + + public int gameMode = 3; + + [SerializeField] + private TerrainTile singleStartTile; + + [SerializeField] + private Waypoint[] singleStartWaypoints; + + [SerializeField] + private TerrainTile doubleStartTile; + + [SerializeField] + private Waypoint[] doubleStartWaypoints; + + [SerializeField] + private TerrainTile tripleStartTile; + + [SerializeField] + private Waypoint[] tripleStartWaypoints; + + public bool gameOver; + + public int health; + + public int maxHealth; + + private float healthLoss; + + [SerializeField] + private Text healthText; + + [SerializeField] + private Image maskBar; + + [SerializeField] + private Image healthBar; + + [SerializeField] + private Image healthLossBar; + + [SerializeField] + private GameObject gameOverMenu; + + [SerializeField] + private Text levelsCompletedText; + + [SerializeField] + private Text xpGainText; + + [SerializeField] + private Text newRecordText; + + [SerializeField] + private GameObject victoryScreen; + + [SerializeField] + private Text vicLevelsText; + + [SerializeField] + private Text vicLevelXpText; + + [SerializeField] + private Text vicXpBonusText; + + [SerializeField] + private Text vicNewRecordText; + + public Vector3 dotTick = 24f * Vector3.one; + + public int hauntedHouseEfficiency = 1; + + public int universityBonus; + + public static GameManager instance; + + private void Awake() + { + instance = this; + gameMode = PlayerPrefs.GetInt("GameMode", 1); + if (gameMode == 1) + { + singleStartTile.transform.Rotate(0f, 90 * Random.Range(-1, 3), 0f); + singleStartTile.SetCardinalDirections(); + tileManager.startTile = singleStartTile; + spawnManager.initialSpawns = singleStartWaypoints; + doubleStartTile.gameObject.SetActive(value: false); + tripleStartTile.gameObject.SetActive(value: false); + } + else if (gameMode == 2) + { + doubleStartTile.transform.Rotate(0f, 90 * Random.Range(-1, 3), 0f); + doubleStartTile.SetCardinalDirections(); + tileManager.startTile = doubleStartTile; + spawnManager.initialSpawns = doubleStartWaypoints; + singleStartTile.gameObject.SetActive(value: false); + tripleStartTile.gameObject.SetActive(value: false); + } + else if (gameMode == 3) + { + tripleStartTile.transform.Rotate(0f, 90 * Random.Range(-1, 3), 0f); + tripleStartTile.SetCardinalDirections(); + tileManager.startTile = tripleStartTile; + spawnManager.initialSpawns = tripleStartWaypoints; + doubleStartTile.gameObject.SetActive(value: false); + singleStartTile.gameObject.SetActive(value: false); + } + + } + + private void Start() + { + maxHealth = 100 + 10 * (PlayerPrefs.GetInt("TowerHealth1", 0) + PlayerPrefs.GetInt("TowerHealth2", 0) + PlayerPrefs.GetInt("TowerHealth3", 0) + PlayerPrefs.GetInt("TowerHealth4", 0) + PlayerPrefs.GetInt("TowerHealth5", 0) + PlayerPrefs.GetInt("TowerHealth6", 0) + PlayerPrefs.GetInt("TowerHealth7", 0) + PlayerPrefs.GetInt("TowerHealth8", 0) + PlayerPrefs.GetInt("TowerHealth9", 0) + PlayerPrefs.GetInt("TowerHealth10", 0)); + health = maxHealth; + healthLoss = maxHealth; + SetHealthBar(); + int num = 0; + num = PlayerPrefs.GetInt("BalistaPHealth", 0); + if (num > 0) + { + TowerManager.instance.AddBonusHealthDamage(TowerType.Crossbow, num); + } + num = PlayerPrefs.GetInt("BalistaPArmor", 0); + if (num > 0) + { + TowerManager.instance.AddBonusArmorDamage(TowerType.Crossbow, num); + } + num = PlayerPrefs.GetInt("BalistaPShield", 0); + if (num > 0) + { + TowerManager.instance.AddBonusShieldDamage(TowerType.Crossbow, num); + } + num = PlayerPrefs.GetInt("MortarPHealth", 0); + if (num > 0) + { + TowerManager.instance.AddBonusHealthDamage(TowerType.Morter, num); + } + num = PlayerPrefs.GetInt("MortarPArmor", 0); + if (num > 0) + { + TowerManager.instance.AddBonusArmorDamage(TowerType.Morter, num); + } + num = PlayerPrefs.GetInt("MortarPShield", 0); + if (num > 0) + { + TowerManager.instance.AddBonusShieldDamage(TowerType.Morter, num); + } + num = PlayerPrefs.GetInt("TeslaPHealth", 0); + if (num > 0) + { + TowerManager.instance.AddBonusHealthDamage(TowerType.TeslaCoil, num); + } + num = PlayerPrefs.GetInt("TeslaPArmor", 0); + if (num > 0) + { + TowerManager.instance.AddBonusArmorDamage(TowerType.TeslaCoil, num); + } + num = PlayerPrefs.GetInt("TeslaPShield", 0); + if (num > 0) + { + TowerManager.instance.AddBonusShieldDamage(TowerType.TeslaCoil, num); + } + num = PlayerPrefs.GetInt("FrostPHealth", 0); + if (num > 0) + { + TowerManager.instance.AddBonusHealthDamage(TowerType.Frost, num); + } + num = PlayerPrefs.GetInt("FrostPArmor", 0); + if (num > 0) + { + TowerManager.instance.AddBonusArmorDamage(TowerType.Frost, num); + } + num = PlayerPrefs.GetInt("FrostPShield", 0); + if (num > 0) + { + TowerManager.instance.AddBonusShieldDamage(TowerType.Frost, num); + } + num = PlayerPrefs.GetInt("FlamePHealth", 0); + if (num > 0) + { + TowerManager.instance.AddBonusHealthDamage(TowerType.FlameThrower, num); + } + num = PlayerPrefs.GetInt("FlamePArmor", 0); + if (num > 0) + { + TowerManager.instance.AddBonusArmorDamage(TowerType.FlameThrower, num); + } + num = PlayerPrefs.GetInt("FlamePShield", 0); + if (num > 0) + { + TowerManager.instance.AddBonusShieldDamage(TowerType.FlameThrower, num); + } + num = PlayerPrefs.GetInt("PoisonPHealth", 0); + if (num > 0) + { + TowerManager.instance.AddBonusHealthDamage(TowerType.PoisonSprayer, num); + } + num = PlayerPrefs.GetInt("PoisonPArmor", 0); + if (num > 0) + { + TowerManager.instance.AddBonusArmorDamage(TowerType.PoisonSprayer, num); + } + num = PlayerPrefs.GetInt("PoisonPShield", 0); + if (num > 0) + { + TowerManager.instance.AddBonusShieldDamage(TowerType.PoisonSprayer, num); + } + num = PlayerPrefs.GetInt("ShredderPHealth", 0); + if (num > 0) + { + TowerManager.instance.AddBonusHealthDamage(TowerType.Shredder, num); + } + num = PlayerPrefs.GetInt("ShredderPArmor", 0); + if (num > 0) + { + TowerManager.instance.AddBonusArmorDamage(TowerType.Shredder, num); + } + num = PlayerPrefs.GetInt("ShredderPShield", 0); + if (num > 0) + { + TowerManager.instance.AddBonusShieldDamage(TowerType.Shredder, num); + } + num = PlayerPrefs.GetInt("EncampmentPHealth", 0); + if (num > 0) + { + TowerManager.instance.AddBonusHealthDamage(TowerType.Encampment, num); + } + num = PlayerPrefs.GetInt("EncampmentPArmor", 0); + if (num > 0) + { + TowerManager.instance.AddBonusArmorDamage(TowerType.Encampment, num); + } + num = PlayerPrefs.GetInt("EncampmentPShield", 0); + if (num > 0) + { + TowerManager.instance.AddBonusShieldDamage(TowerType.Encampment, num); + } + num = PlayerPrefs.GetInt("LookoutPHealth", 0); + if (num > 0) + { + TowerManager.instance.AddBonusHealthDamage(TowerType.Lookout, num); + } + num = PlayerPrefs.GetInt("LookoutPArmor", 0); + if (num > 0) + { + TowerManager.instance.AddBonusArmorDamage(TowerType.Lookout, num); + } + num = PlayerPrefs.GetInt("LookoutPShield", 0); + if (num > 0) + { + TowerManager.instance.AddBonusShieldDamage(TowerType.Lookout, num); + } + num = PlayerPrefs.GetInt("RadarPHealth", 0); + if (num > 0) + { + TowerManager.instance.AddBonusHealthDamage(TowerType.Radar, num); + } + num = PlayerPrefs.GetInt("RadarPArmor", 0); + if (num > 0) + { + TowerManager.instance.AddBonusArmorDamage(TowerType.Radar, num); + } + num = PlayerPrefs.GetInt("RadarPShield", 0); + if (num > 0) + { + TowerManager.instance.AddBonusShieldDamage(TowerType.Radar, num); + } + num = PlayerPrefs.GetInt("ObeliskPHealth", 0); + if (num > 0) + { + TowerManager.instance.AddBonusHealthDamage(TowerType.Obelisk, num); + } + num = PlayerPrefs.GetInt("ObeliskPArmor", 0); + if (num > 0) + { + TowerManager.instance.AddBonusArmorDamage(TowerType.Obelisk, num); + } + num = PlayerPrefs.GetInt("ObeliskPShield", 0); + if (num > 0) + { + TowerManager.instance.AddBonusShieldDamage(TowerType.Obelisk, num); + } + num = PlayerPrefs.GetInt("ParticleCannonPHealth", 0); + if (num > 0) + { + TowerManager.instance.AddBonusHealthDamage(TowerType.ParticleCannon, num); + } + num = PlayerPrefs.GetInt("ParticleCannonPArmor", 0); + if (num > 0) + { + TowerManager.instance.AddBonusArmorDamage(TowerType.ParticleCannon, num); + } + num = PlayerPrefs.GetInt("ParticleCannonPShield", 0); + if (num > 0) + { + TowerManager.instance.AddBonusShieldDamage(TowerType.ParticleCannon, num); + } + } + + private void Update() + { + if (healthLoss > (float)health) + { + healthLoss = Mathf.Clamp(healthLoss - 4f * Time.deltaTime, health, healthLoss); + healthLossBar.rectTransform.sizeDelta = new Vector2(healthLoss / 10f, 0.25f); + } + } + + public void IncreaseTowerHealth(int amt) + { + maxHealth += amt * 10; + health += amt * 10; + healthLoss = health; + SetHealthBar(); + if (maxHealth / 10 >= 50) + { + AchievementManager.instance.UnlockAchievement("TowerHealth50"); + } + else if (maxHealth / 10 >= 40) + { + AchievementManager.instance.UnlockAchievement("TowerHealth40"); + } + else if (maxHealth / 10 >= 30) + { + AchievementManager.instance.UnlockAchievement("TowerHealth30"); + } + } + + private void SetHealthBar() + { + maskBar.rectTransform.localScale = new Vector3(2000 / maxHealth, 50f, 10f); + maskBar.rectTransform.sizeDelta = new Vector2((float)maxHealth / 10f, 0.25f); + healthLossBar.rectTransform.sizeDelta = new Vector2((float)health / 10f, 0.25f); + UpdateHealthText(); + } + + private void UpdateHealthText() + { + healthText.text = "Tower: " + health / 10 + "/" + maxHealth / 10; + healthBar.rectTransform.sizeDelta = new Vector2((float)health / 10f, 0.25f); + } + + public void TakeDamage(int damage) + { + health = Mathf.Max(health - 10 * damage, 0); + UpdateHealthText(); + if (health <= 0 && !gameOver) + { + gameOver = true; + GameOver(); + } + } + + public void RepairTower(int heal) + { + health = Mathf.Clamp(health + heal, 0, maxHealth); + if (healthLoss < (float)health) + { + healthLoss = health; + } + UpdateHealthText(); + } + + public void GameOverQuit() + { + if (!SpawnManager.instance.combat) + { + SpawnManager.instance.level++; + } + if (Time.timeScale != 1f) + { + Time.timeScale = 1f; + } + gameOver = true; + GameOver(); + } + + public int NaturalSum(int value) + { + return value * (value + 1) / 2; + } + + private void GameOver() + { + gameOverMenu.SetActive(value: true); + DamageTracker.instance.DisplayDamageTotals(); + int num = NaturalSum(SpawnManager.instance.level - 1) * gameMode; + int num2 = 0; + int @int = PlayerPrefs.GetInt("Record" + gameMode, 0); + if (SpawnManager.instance.level - 1 - @int > 0) + { + num2 = (NaturalSum(SpawnManager.instance.level - 1) - NaturalSum(@int)) * 3; + PlayerPrefs.SetInt("Record" + gameMode, SpawnManager.instance.level - 1); + string text = ""; + if (gameMode == 1) + { + text = "single"; + } + else if (gameMode == 2) + { + text = "double"; + } + else if (gameMode == 3) + { + text = "triple"; + } + newRecordText.text = "New " + text + " defense record!\n +" + num2 + " bonus xp"; + } + else + { + newRecordText.text = ""; + } + int int2 = PlayerPrefs.GetInt("XP", 0); + PlayerPrefs.SetInt("XP", int2 + num2); + levelsCompletedText.text = "Defended " + (SpawnManager.instance.level - 1) + " levels"; + xpGainText.text = "+" + num + " xp"; + } + + public void Victory() + { + AchievementManager.instance.CheckTowerTypesVictory(); + victoryScreen.SetActive(value: true); + DamageTracker.instance.DisplayDamageTotals(); + int num = NaturalSum(SpawnManager.instance.level - 1) * gameMode; + int num2 = SpawnManager.instance.lastLevel * gameMode * 10; + int num3 = 0; + int @int = PlayerPrefs.GetInt("Record" + gameMode, 0); + if (SpawnManager.instance.lastLevel - @int > 0) + { + num3 = (NaturalSum(SpawnManager.instance.level - 1) - NaturalSum(@int)) * 3; + PlayerPrefs.SetInt("Record" + gameMode, SpawnManager.instance.lastLevel); + string text = ""; + if (gameMode == 1) + { + text = "single"; + } + else if (gameMode == 2) + { + text = "double"; + } + else if (gameMode == 3) + { + text = "triple"; + } + vicNewRecordText.text = "New " + text + " defense record!\n +" + num3 + " bonus xp"; + } + else + { + vicNewRecordText.text = ""; + } + int int2 = PlayerPrefs.GetInt("XP", 0); + PlayerPrefs.SetInt("XP", int2 + num3 + num2); + vicLevelsText.text = "Defended all " + SpawnManager.instance.lastLevel + " levels"; + vicLevelXpText.text = "+" + num + " xp"; + vicXpBonusText.text = "+" + num2 + " xp"; + } + + public void LoadScene(string sceneName) + { + if (AchievementManager.instance != null) + { + AchievementManager.instance.OnSceneClose(); + } + LevelLoader.instance.LoadLevel(sceneName); + } +} diff --git a/GameCode/GoldRushCard.cs b/GameCode/GoldRushCard.cs new file mode 100644 index 0000000..79663ce --- /dev/null +++ b/GameCode/GoldRushCard.cs @@ -0,0 +1,17 @@ +using UnityEngine; + +public class GoldRushCard : UpgradeCard +{ + [SerializeField] + private int goldGain; + + [SerializeField] + private float speedBonus; + + public override void Upgrade() + { + base.Upgrade(); + MonsterManager.instance.speedBonus += speedBonus; + ResourceManager.instance.AddMoney(goldGain); + } +} diff --git a/GameCode/Grave.cs b/GameCode/Grave.cs new file mode 100644 index 0000000..45abddc --- /dev/null +++ b/GameCode/Grave.cs @@ -0,0 +1,3 @@ +public class Grave : SpawnableObject +{ +} diff --git a/GameCode/HauntedHouse.cs b/GameCode/HauntedHouse.cs new file mode 100644 index 0000000..9a23eda --- /dev/null +++ b/GameCode/HauntedHouse.cs @@ -0,0 +1,111 @@ +using UnityEngine; + +public class HauntedHouse : IncomeGenerator, IBuildable +{ + [SerializeField] + private LayerMask graveLayerMask; + + [SerializeField] + private GameObject UIObject; + + [SerializeField] + private int goldBackOnDemolish; + + private bool isGathering; + + private int graveCount; + + private int manaUsed; + + private float timer; + + private SimpleUI myUI; + + protected override void Start() + { + base.Start(); + DetectGraves(); + } + + private void Update() + { + if (myUI != null && isGathering) + { + string text = "Mana used: " + manaUsed; + text = text + "\nNearby graves: x" + graveCount; + text = text + "\nTax efficiency: x" + GameManager.instance.hauntedHouseEfficiency; + text = text + "\nDeath tax due: " + Mathf.Max((int)Mathf.Sqrt(manaUsed * GameManager.instance.hauntedHouseEfficiency * graveCount), 1) + "g"; + text = text + "\nNet tax collected: " + base.netGold + "g."; + myUI.SetDiscriptionText(text); + } + if (!isGathering || !SpawnManager.instance.combat) + { + return; + } + if (timer <= 0f) + { + if (ResourceManager.instance.CheckMana(1)) + { + ResourceManager.instance.SpendMana(1); + manaUsed++; + timer = 1f; + } + } + else + { + timer -= Time.deltaTime; + } + } + + public override void GenerateIncome() + { + incomePerRound = Mathf.Max((int)Mathf.Sqrt(manaUsed * GameManager.instance.hauntedHouseEfficiency * graveCount), 1); + base.GenerateIncome(); + manaUsed = 0; + incomePerRound = 1; + } + + public void SetStats() + { + } + + private void DetectGraves() + { + if (Physics.Raycast(base.transform.position + new Vector3(1f, 1f, 0f), -base.transform.up, out var hitInfo, 1f, graveLayerMask, QueryTriggerInteraction.Ignore)) + { + CheckGrave(hitInfo); + } + if (Physics.Raycast(base.transform.position + new Vector3(-1f, 1f, 0f), -base.transform.up, out hitInfo, 1f, graveLayerMask, QueryTriggerInteraction.Ignore)) + { + CheckGrave(hitInfo); + } + if (Physics.Raycast(base.transform.position + new Vector3(0f, 1f, 1f), -base.transform.up, out hitInfo, 1f, graveLayerMask, QueryTriggerInteraction.Ignore)) + { + CheckGrave(hitInfo); + } + if (Physics.Raycast(base.transform.position + new Vector3(0f, 1f, -1f), -base.transform.up, out hitInfo, 1f, graveLayerMask, QueryTriggerInteraction.Ignore)) + { + CheckGrave(hitInfo); + } + } + + private void CheckGrave(RaycastHit hit) + { + if (hit.collider.GetComponent<Grave>() != null && (double)Mathf.Abs(hit.collider.transform.position.y - base.transform.position.y) <= 0.001) + { + graveCount++; + isGathering = true; + } + } + + public void SpawnUI() + { + myUI = Object.Instantiate(UIObject, base.transform.position, Quaternion.identity).GetComponent<SimpleUI>(); + myUI.SetDemolishable(base.gameObject, goldBackOnDemolish); + } + + public void Demolish() + { + RemoveIncomeGeneration(); + } +} diff --git a/GameCode/HauntedHouseUpgrade.cs b/GameCode/HauntedHouseUpgrade.cs new file mode 100644 index 0000000..47d4c8a --- /dev/null +++ b/GameCode/HauntedHouseUpgrade.cs @@ -0,0 +1,8 @@ +public class HauntedHouseUpgrade : UpgradeCard +{ + public override void Upgrade() + { + base.Upgrade(); + GameManager.instance.hauntedHouseEfficiency++; + } +} diff --git a/GameCode/HealthBar.cs b/GameCode/HealthBar.cs new file mode 100644 index 0000000..558df63 --- /dev/null +++ b/GameCode/HealthBar.cs @@ -0,0 +1,157 @@ +using UnityEngine; +using UnityEngine.UI; + +public class HealthBar : MonoBehaviour +{ + [SerializeField] + private Image maskBar; + + [SerializeField] + private Image healthBar; + + [SerializeField] + private Image armorBar; + + [SerializeField] + private Image shieldBar; + + [SerializeField] + private Image dmgBar; + + [SerializeField] + private Image slowImageLeft; + + [SerializeField] + private Image slowImageRight; + + [SerializeField] + private GameObject BleedImage; + + [SerializeField] + private GameObject BurnImage; + + [SerializeField] + private GameObject PoisonImage; + + [SerializeField] + private Text bleedText; + + [SerializeField] + private Text burnText; + + [SerializeField] + private Text poisonText; + + [SerializeField] + private Image fortImageLeft; + + [SerializeField] + private Image fortImageRight; + + [SerializeField] + private Image hasteImageLeft; + + [SerializeField] + private Image hasteImageRight; + + private float maxHp; + + private float health; + + private float armor; + + private float shield; + + private float dmg; + + private float barScaler = 100f; + + private void Update() + { + if (dmg > health + armor + shield) + { + dmg = Mathf.Clamp(dmg - 4f * Time.deltaTime, health + armor + shield, dmg); + dmgBar.rectTransform.sizeDelta = new Vector2(dmg, 0.25f); + } + } + + public void SetHealth(int max, int heal, int armr, int shld, int scaleDegree) + { + barScaler = 10f * Mathf.Pow(10f, scaleDegree); + maxHp = (float)max / barScaler; + dmg = maxHp; + health = (float)heal / barScaler; + armor = (float)armr / barScaler; + shield = (float)shld / barScaler; + maskBar.rectTransform.localScale = new Vector3(3f / (maxHp + 3f), 1f, 1f); + maskBar.rectTransform.sizeDelta = new Vector2(maxHp, 0.25f); + dmgBar.rectTransform.sizeDelta = new Vector2(dmg, 0.25f); + UpdateHealth(heal, armr, shld, 0f, isBleeding: false, isBurning: false, isPoisoned: false, 0, 0, 0); + } + + public void UpdateHealth(int heal, int armr, int shld, float currentSlow, bool isBleeding, bool isBurning, bool isPoisoned, int currentBleed, int currentBurn, int currentPoison) + { + health = (float)heal / barScaler; + armor = (float)armr / barScaler; + shield = (float)shld / barScaler; + healthBar.rectTransform.sizeDelta = new Vector2(health, 0.25f); + armorBar.rectTransform.sizeDelta = new Vector2(armor, 0.25f); + shieldBar.rectTransform.sizeDelta = new Vector2(shield, 0.25f); + armorBar.rectTransform.localPosition = new Vector3(health - maskBar.rectTransform.sizeDelta.x / 2f, 0f, 0f); + shieldBar.rectTransform.localPosition = new Vector3(health + armor - maskBar.rectTransform.sizeDelta.x / 2f, 0f, 0f); + Image image = slowImageLeft; + float fillAmount = (slowImageRight.fillAmount = currentSlow); + image.fillAmount = fillAmount; + BleedImage.SetActive(isBleeding); + bleedText.gameObject.SetActive(isBleeding); + bleedText.text = currentBleed.ToString(); + BurnImage.SetActive(isBurning); + burnText.gameObject.SetActive(isBurning); + burnText.text = currentBurn.ToString(); + PoisonImage.SetActive(isPoisoned); + poisonText.gameObject.SetActive(isPoisoned); + poisonText.text = currentPoison.ToString(); + } + + public void UpdateSlow(float currentSlow) + { + Image image = slowImageLeft; + float fillAmount = (slowImageRight.fillAmount = currentSlow); + image.fillAmount = fillAmount; + } + + public void UpdateBleed(bool status, int amt) + { + BleedImage.SetActive(status); + bleedText.gameObject.SetActive(status); + bleedText.text = amt.ToString(); + } + + public void UpdateBurn(bool status, int amt) + { + BurnImage.SetActive(status); + burnText.gameObject.SetActive(status); + burnText.text = amt.ToString(); + } + + public void UpdatePoison(bool status, int amt) + { + PoisonImage.SetActive(status); + poisonText.gameObject.SetActive(status); + poisonText.text = amt.ToString(); + } + + public void UpdateFortified(float fortTime) + { + Image image = fortImageLeft; + float fillAmount = (fortImageRight.fillAmount = fortTime * 0.083333f); + image.fillAmount = fillAmount; + } + + public void UpdateHaste(float hastePercentage) + { + Image image = hasteImageLeft; + float fillAmount = (hasteImageRight.fillAmount = hastePercentage); + image.fillAmount = fillAmount; + } +} diff --git a/GameCode/House.cs b/GameCode/House.cs new file mode 100644 index 0000000..16bb26d --- /dev/null +++ b/GameCode/House.cs @@ -0,0 +1,49 @@ +using System.Collections.Generic; +using UnityEngine; + +public class House : SpawnableObject +{ + private List<Tower> defenders = new List<Tower>(); + + [SerializeField] + private IncomeGenerator myIncomeGenerator; + + protected override void Start() + { + base.Start(); + SpawnManager.instance.houses.Add(this); + } + + public void AddDefender(Tower t) + { + if (!defenders.Contains(t)) + { + defenders.Add(t); + } + CheckTowers(); + } + + public void CheckTowers() + { + for (int num = defenders.Count - 1; num > -1; num--) + { + if (defenders[num] == null) + { + defenders.RemoveAt(num); + } + } + myIncomeGenerator.incomeTimesLevel = defenders.Count; + } + + public override void SpawnUI() + { + SimpleUI component = Object.Instantiate(UIObject, base.transform.position, Quaternion.identity).GetComponent<SimpleUI>(); + if (defenders.Count > 0) + { + string text = "This house is protected by " + defenders.Count + " towers."; + text = text + "\nIts next gift will be " + (SpawnManager.instance.level + 1) * defenders.Count + "g."; + text = text + "\nNet gold gifted: " + myIncomeGenerator.netGold + "g."; + component.SetDiscriptionText(text); + } + } +} diff --git a/GameCode/IBuildable.cs b/GameCode/IBuildable.cs new file mode 100644 index 0000000..5fcdc7e --- /dev/null +++ b/GameCode/IBuildable.cs @@ -0,0 +1,8 @@ +public interface IBuildable +{ + void SetStats(); + + void Demolish(); + + void SpawnUI(); +} diff --git a/GameCode/IDamageable.cs b/GameCode/IDamageable.cs new file mode 100644 index 0000000..d010ef5 --- /dev/null +++ b/GameCode/IDamageable.cs @@ -0,0 +1,4 @@ +public interface IDamageable +{ + void TakeDamage(TowerType whoHitMe, int baseDmg, int healthDmg, int armorDmg, int shieldDmg, float slowPercentage, float bleedPercentage, float burnPercentage, float poisonPercentage, float critChance, float stunChance); +} diff --git a/GameCode/IncomeGenerator.cs b/GameCode/IncomeGenerator.cs new file mode 100644 index 0000000..9afd8f5 --- /dev/null +++ b/GameCode/IncomeGenerator.cs @@ -0,0 +1,39 @@ +using UnityEngine; + +public class IncomeGenerator : MonoBehaviour +{ + public int incomePerRound; + + public float incomeTimesLevel; + + [SerializeField] + private DamageTracker.IncomeType myIncomeType; + + public int netGold { get; private set; } + + protected virtual void Start() + { + SpawnManager.instance.incomeGenerators.Add(this); + netGold = 0; + } + + public virtual void GenerateIncome() + { + int num = incomePerRound + (int)(incomeTimesLevel * (float)SpawnManager.instance.level); + if (num > 0) + { + ResourceManager.instance.AddMoney(num); + netGold += num; + DamageTracker.instance.AddIncome(myIncomeType, num); + SFXManager.instance.PlaySound(Sound.CoinShort, base.transform.position); + DamageNumber component = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component.SetText("+" + num + "g", "Grey", 1f); + component.SetHoldTime(2.5f); + } + } + + public void RemoveIncomeGeneration() + { + SpawnManager.instance.incomeGenerators.Remove(this); + } +} diff --git a/GameCode/IronVein.cs b/GameCode/IronVein.cs new file mode 100644 index 0000000..06af952 --- /dev/null +++ b/GameCode/IronVein.cs @@ -0,0 +1,3 @@ +public class IronVein : SpawnableObject +{ +} diff --git a/GameCode/KeyDisappear.cs b/GameCode/KeyDisappear.cs new file mode 100644 index 0000000..d997703 --- /dev/null +++ b/GameCode/KeyDisappear.cs @@ -0,0 +1,61 @@ +using UnityEngine; + +public class KeyDisappear : MonoBehaviour +{ + [SerializeField] + private GameObject wKey; + + [SerializeField] + private GameObject aKey; + + [SerializeField] + private GameObject sKey; + + [SerializeField] + private GameObject dKey; + + private bool w; + + private bool a; + + private bool s; + + private bool d; + + [SerializeField] + private bool destroyOnCompletion = true; + + private float time; + + private void Update() + { + time += Time.deltaTime; + if (time > 3f) + { + if (Input.GetKeyUp(KeyCode.W)) + { + wKey.SetActive(value: false); + w = true; + } + if (Input.GetKeyUp(KeyCode.A)) + { + aKey.SetActive(value: false); + a = true; + } + if (Input.GetKeyUp(KeyCode.S)) + { + sKey.SetActive(value: false); + s = true; + } + if (Input.GetKeyUp(KeyCode.D)) + { + dKey.SetActive(value: false); + d = true; + } + if (destroyOnCompletion && w && a && s && d) + { + Object.Destroy(base.gameObject); + } + } + } +} diff --git a/GameCode/Landmine.cs b/GameCode/Landmine.cs new file mode 100644 index 0000000..5422016 --- /dev/null +++ b/GameCode/Landmine.cs @@ -0,0 +1,67 @@ +using System.Collections; +using UnityEngine; + +public class Landmine : Projectile +{ + public float blastRadius = 0.5f; + + private bool armed; + + [SerializeField] + private GameObject explosion; + + protected override void Start() + { + base.Start(); + SpawnManager.instance.destroyOnNewLevel.Add(base.gameObject); + } + + public void SetEndPosition(Vector3 endPos) + { + StartCoroutine(ThrowMine(endPos)); + } + + protected override void FixedUpdate() + { + } + + private void OnTriggerEnter(Collider other) + { + if (armed && other.gameObject.layer == LayerMask.NameToLayer("Enemy")) + { + Explode(); + } + } + + private void Explode() + { + Collider[] array = Physics.OverlapSphere(base.transform.position, blastRadius, layermask, QueryTriggerInteraction.Collide); + for (int i = 0; i < array.Length; i++) + { + IDamageable component = array[i].GetComponent<IDamageable>(); + if (component != null) + { + DealDamage(component); + } + } + Object.Instantiate(explosion, base.transform.position, Quaternion.identity).transform.localScale = Vector3.one * 0.5f; + SpawnManager.instance.destroyOnNewLevel.Remove(base.gameObject); + Object.Destroy(base.gameObject); + } + + private IEnumerator ThrowMine(Vector3 endPos) + { + Vector3 direction = endPos - base.transform.position; + float throwTime = 1f; + base.transform.localScale = Vector3.zero; + for (float i = 0f; i < 1f; i += Time.deltaTime / throwTime) + { + base.transform.localScale = Vector3.one * i; + base.transform.Translate(direction * Time.deltaTime / throwTime); + yield return null; + } + base.transform.localScale = Vector3.one; + base.transform.position = endPos; + armed = true; + } +} diff --git a/GameCode/LevelLoader.cs b/GameCode/LevelLoader.cs new file mode 100644 index 0000000..1698c15 --- /dev/null +++ b/GameCode/LevelLoader.cs @@ -0,0 +1,116 @@ +using System.Collections; +using UnityEngine; +using UnityEngine.SceneManagement; +using UnityEngine.UI; + +public class LevelLoader : MonoBehaviour +{ + public static LevelLoader instance; + + [SerializeField] + private Image circle; + + [SerializeField] + private Text loadingText; + + [SerializeField] + private Text tipText; + + [SerializeField] + private string[] tips; + + private void Awake() + { + instance = this; + } + + private void Start() + { + loadingText.text = ""; + tipText.text = ""; + StartCoroutine(CircleExitStart()); + } + + public void LoadLevel(string sceneName) + { + if (MusicManager.instance != null) + { + MusicManager.instance.FadeOut(2.5f); + } + StartCoroutine(LoadAsyncronously(sceneName)); + } + + private IEnumerator LoadAsyncronously(string sceneName) + { + float num = Mathf.Sqrt(Screen.height * Screen.width) * 1.1f; + Vector2 endSize = new Vector2(2f, 1f) * num * 2f; + Vector2 startSize = new Vector2(0f, 1f) * num * 2f; + circle.rectTransform.sizeDelta = startSize; + Vector3 endPosition = new Vector3((float)Screen.height / 2f, (float)Screen.height / 2f, 0f); + Vector3 startPosition = new Vector3((float)Screen.width * 1.1f, (float)Screen.height / 2f, 0f); + circle.transform.position = startPosition; + float t = 0f; + while (t < 1f) + { + circle.rectTransform.sizeDelta = Vector2.Lerp(startSize, endSize, t); + circle.transform.position = Vector3.Lerp(startPosition, endPosition, t); + t += Time.deltaTime / 1.5f; + yield return null; + } + circle.rectTransform.sizeDelta = endSize; + circle.transform.position = endPosition; + tipText.text = GetTipsText(); + AsyncOperation operation = SceneManager.LoadSceneAsync(sceneName); + operation.allowSceneActivation = false; + float waitFill = 0f; + while (!operation.isDone || waitFill < 1f) + { + waitFill = Mathf.Clamp(waitFill + Time.deltaTime / 3f, 0f, 1f); + float num2 = Mathf.Clamp(operation.progress / 0.9f, 0f, 1f); + if (waitFill >= 1f) + { + operation.allowSceneActivation = true; + } + loadingText.text = GetLoadingText((waitFill * num2 + waitFill) / 2f); + yield return null; + } + } + + private string GetLoadingText(float percent) + { + return "Loading...".Substring(0, (int)Mathf.Round(percent * 10f)); + } + + private string GetTipsText() + { + int num = Random.Range(0, tips.Length); + int @int = PlayerPrefs.GetInt("PreviousTip", 0); + if (num == @int) + { + num = (num + 1) % tips.Length; + } + PlayerPrefs.SetInt("PreviousTip", num); + return tips[num]; + } + + private IEnumerator CircleExitStart() + { + float num = Mathf.Sqrt(Screen.height * Screen.width) * 1.1f; + Vector2 startSize = new Vector2(2f, 1f) * num * 2f; + Vector2 endSize = new Vector2(0f, 1f) * num * 2f; + circle.rectTransform.sizeDelta = startSize; + Vector3 startPosition = new Vector3((float)Screen.height / 2f, (float)Screen.height / 2f, 0f); + Vector3 endPosition = new Vector3((float)(-Screen.width) * 0.1f, (float)Screen.height / 2f, 0f); + circle.transform.position = startPosition; + float t = 0f; + while (t < 1f) + { + circle.rectTransform.sizeDelta = Vector2.Lerp(startSize, endSize, t); + circle.transform.position = Vector3.Lerp(startPosition, endPosition, t); + t += Time.deltaTime / 1.5f; + yield return null; + } + circle.rectTransform.sizeDelta = endSize; + circle.transform.position = endPosition; + } +} diff --git a/GameCode/LightManager.cs b/GameCode/LightManager.cs new file mode 100644 index 0000000..e38ac0f --- /dev/null +++ b/GameCode/LightManager.cs @@ -0,0 +1,62 @@ +using System.Collections; +using UnityEngine; + +public class LightManager : MonoBehaviour +{ + [SerializeField] + private Color stage2Color; + + [SerializeField] + private Color stage3Color; + + [SerializeField] + private Color stage4Color; + + [SerializeField] + private Light light; + + private void Start() + { + } + + public void ChangeColor(int stage) + { + switch (stage) + { + case 2: + StartCoroutine(ShiftLight(stage2Color, 180f)); + break; + case 3: + StartCoroutine(ShiftLight(stage3Color, 180f)); + break; + case 4: + StartCoroutine(ShiftLight(stage4Color, 180f)); + break; + } + } + + private IEnumerator ShiftLight(Color newColor, float rotationInDeg) + { + Color startColor = light.color; + Vector3 startEuler = light.transform.eulerAngles; + Vector3 newEuler = startEuler + new Vector3(0f, rotationInDeg, 0f); + float timer = 0f; + float count = 0f; + while (timer < 1f) + { + light.color = Color.Lerp(startColor, newColor, timer); + light.transform.eulerAngles = Vector3.Lerp(startEuler, newEuler, timer); + count += Time.deltaTime; + if (count > 60f) + { + Debug.LogError("Possible infinite loop"); + break; + } + timer += Time.deltaTime / 30f; + yield return new WaitForEndOfFrame(); + } + light.color = newColor; + light.transform.eulerAngles = newEuler; + yield return null; + } +} diff --git a/GameCode/Lookout.cs b/GameCode/Lookout.cs new file mode 100644 index 0000000..3abd55b --- /dev/null +++ b/GameCode/Lookout.cs @@ -0,0 +1,97 @@ +using UnityEngine; + +public class Lookout : Tower +{ + [SerializeField] + private GameObject markIcon; + + private GameObject currentMark; + + protected override void Update() + { + if (currentTarget != null) + { + markIcon.SetActive(value: true); + UpdateMark(); + GainXP(); + } + else + { + markIcon.SetActive(value: false); + } + } + + private void UpdateMark() + { + if (currentTarget != currentMark) + { + if (currentMark != null) + { + currentMark.GetComponent<Enemy>().mark = null; + } + currentMark = currentTarget; + currentMark.GetComponent<Enemy>().mark = this; + } + markIcon.transform.position = currentMark.transform.position; + } + + protected override GameObject SelectEnemy(Collider[] possibleTargets) + { + GameObject result = null; + float num = -1f; + for (int i = 0; i < possibleTargets.Length; i++) + { + float num2 = 1f; + Enemy component = possibleTargets[i].GetComponent<Enemy>(); + if (!(component.mark != this) || !(component.mark != null)) + { + if (CheckPriority(Priority.Progress)) + { + num2 /= Mathf.Max(0.001f, possibleTargets[i].GetComponent<Pathfinder>().distanceFromEnd); + } + if (CheckPriority(Priority.NearDeath)) + { + num2 /= Mathf.Max(0.001f, component.CurrentHealth()); + } + if (CheckPriority(Priority.MostHealth)) + { + num2 *= (float)Mathf.Max(1, component.health); + } + if (CheckPriority(Priority.MostArmor)) + { + num2 *= (float)Mathf.Max(1, component.armor); + } + if (CheckPriority(Priority.MostShield)) + { + num2 *= (float)Mathf.Max(1, component.shield); + } + if (CheckPriority(Priority.LeastHealth)) + { + num2 /= (float)Mathf.Max(1, component.health); + } + if (CheckPriority(Priority.LeastArmor)) + { + num2 /= (float)Mathf.Max(1, component.armor); + } + if (CheckPriority(Priority.LeastShield)) + { + num2 /= (float)Mathf.Max(1, component.shield); + } + if (CheckPriority(Priority.Fastest)) + { + num2 *= Mathf.Max(0.001f, possibleTargets[i].GetComponent<Pathfinder>().speed); + } + if (CheckPriority(Priority.Slowest)) + { + num2 /= Mathf.Max(0.001f, possibleTargets[i].GetComponent<Pathfinder>().speed); + } + if (num2 > num) + { + result = component.gameObject; + num = num2; + } + } + } + return result; + } +} diff --git a/GameCode/MainMenu.cs b/GameCode/MainMenu.cs new file mode 100644 index 0000000..1028d13 --- /dev/null +++ b/GameCode/MainMenu.cs @@ -0,0 +1,16 @@ +using UnityEngine; + +public class MainMenu : MonoBehaviour +{ + + void Awake() + { + Screen.fullScreen = false; + Screen.SetResolution(1920, 1080, false); + } + + public void QuitGame() + { + Application.Quit(); + } +} diff --git a/GameCode/ManaBank.cs b/GameCode/ManaBank.cs new file mode 100644 index 0000000..b82d36e --- /dev/null +++ b/GameCode/ManaBank.cs @@ -0,0 +1,68 @@ +using UnityEngine; + +public class ManaBank : MonoBehaviour, IBuildable +{ + [SerializeField] + private int gatherRatePerSec; + + [SerializeField] + private int maxManaIncrease; + + [SerializeField] + private GameObject UIObject; + + [SerializeField] + private int goldBackOnDemolish; + + private float timer = 1f; + + private void Start() + { + maxManaIncrease += ResourceManager.instance.manaBankBonusMana; + ResourceManager.instance.UpdateManaGatherRate(gatherRatePerSec); + ResourceManager.instance.AddMaxMana(maxManaIncrease); + ResourceManager.instance.manaBanks.Add(this); + } + + private void Update() + { + if (timer <= 0f) + { + Gather(); + timer = 1f; + } + else if (SpawnManager.instance.combat) + { + timer -= Time.deltaTime; + } + } + + public void SetStats() + { + } + + public void UpgradeMaxMana(int addition) + { + ResourceManager.instance.AddMaxMana(addition); + maxManaIncrease += addition; + } + + public void SpawnUI() + { + SimpleUI component = Object.Instantiate(UIObject, base.transform.position, Quaternion.identity).GetComponent<SimpleUI>(); + component.SetDemolishable(base.gameObject, goldBackOnDemolish); + component.SetDiscriptionText("This bank currently stores " + maxManaIncrease + " mana. It is generating " + ((float)Mathf.FloorToInt(10f * ResourceManager.instance.manaMaxRegenPercent * (float)maxManaIncrease) / 10f + 1f) + " mana/s through sorcery and clever investing."); + } + + public void Demolish() + { + ResourceManager.instance.UpdateManaGatherRate(-gatherRatePerSec); + ResourceManager.instance.AddMaxMana(-maxManaIncrease); + ResourceManager.instance.manaBanks.Remove(this); + } + + private void Gather() + { + ResourceManager.instance.AddMana(gatherRatePerSec); + } +} diff --git a/GameCode/ManaCrystal.cs b/GameCode/ManaCrystal.cs new file mode 100644 index 0000000..4b84e56 --- /dev/null +++ b/GameCode/ManaCrystal.cs @@ -0,0 +1,3 @@ +public class ManaCrystal : SpawnableObject +{ +} diff --git a/GameCode/ManaGenUpgradeCard.cs b/GameCode/ManaGenUpgradeCard.cs new file mode 100644 index 0000000..e56b63a --- /dev/null +++ b/GameCode/ManaGenUpgradeCard.cs @@ -0,0 +1,21 @@ +using UnityEngine; + +public class ManaGenUpgradeCard : UpgradeCard +{ + [SerializeField] + private float manaPercentRegenIncrease; + + [SerializeField] + private int manaBankMaxManaIncrease; + + public override void Upgrade() + { + base.Upgrade(); + ResourceManager.instance.AddPercentManaGathering(manaPercentRegenIncrease); + ResourceManager.instance.UpdateManaHUD(); + if (manaBankMaxManaIncrease != 0) + { + ResourceManager.instance.UpgradeManaBankMaxMana(manaBankMaxManaIncrease); + } + } +} diff --git a/GameCode/ManaSiphon.cs b/GameCode/ManaSiphon.cs new file mode 100644 index 0000000..89e578e --- /dev/null +++ b/GameCode/ManaSiphon.cs @@ -0,0 +1,92 @@ +using UnityEngine; + +public class ManaSiphon : MonoBehaviour, IBuildable +{ + [SerializeField] + private int gatherRatePerSec; + + [SerializeField] + private LayerMask layermask; + + [SerializeField] + private GameObject UIObject; + + [SerializeField] + private int goldBackOnDemolish; + + private bool gathering; + + private float timer = 1f; + + private void Start() + { + DetectMana(); + if (gathering) + { + ResourceManager.instance.UpdateManaGatherRate(gatherRatePerSec); + } + } + + private void Update() + { + if (timer <= 0f) + { + Gather(); + timer = 1f; + } + else if (gathering && SpawnManager.instance.combat) + { + timer -= Time.deltaTime; + } + } + + public void SetStats() + { + } + + public void SpawnUI() + { + SimpleUI component = Object.Instantiate(UIObject, base.transform.position, Quaternion.identity).GetComponent<SimpleUI>(); + component.SetDemolishable(base.gameObject, goldBackOnDemolish); + if (gathering) + { + component.SetDiscriptionText("Currently gathering 1 mana/sec."); + } + } + + public void Demolish() + { + if (gathering) + { + ResourceManager.instance.UpdateManaGatherRate(-gatherRatePerSec); + } + } + + private void Gather() + { + ResourceManager.instance.AddMana(gatherRatePerSec); + } + + private void DetectMana() + { + if ((!Physics.Raycast(base.transform.position + new Vector3(1f, 1f, 0f), -base.transform.up, out var hitInfo, 1f, layermask, QueryTriggerInteraction.Ignore) || !Rotate(hitInfo)) && (!Physics.Raycast(base.transform.position + new Vector3(-1f, 1f, 0f), -base.transform.up, out hitInfo, 1f, layermask, QueryTriggerInteraction.Ignore) || !Rotate(hitInfo)) && (!Physics.Raycast(base.transform.position + new Vector3(0f, 1f, 1f), -base.transform.up, out hitInfo, 1f, layermask, QueryTriggerInteraction.Ignore) || !Rotate(hitInfo)) && Physics.Raycast(base.transform.position + new Vector3(0f, 1f, -1f), -base.transform.up, out hitInfo, 1f, layermask, QueryTriggerInteraction.Ignore)) + { + Rotate(hitInfo); + } + } + + private bool Rotate(RaycastHit hit) + { + if (hit.collider.GetComponent<ManaCrystal>() == null) + { + return false; + } + if ((double)Mathf.Abs(hit.collider.transform.position.y - base.transform.position.y) > 0.001) + { + return false; + } + base.transform.LookAt(hit.collider.transform.position, Vector3.up); + gathering = true; + return true; + } +} diff --git a/GameCode/MaxHealthUpgradeCard.cs b/GameCode/MaxHealthUpgradeCard.cs new file mode 100644 index 0000000..467b669 --- /dev/null +++ b/GameCode/MaxHealthUpgradeCard.cs @@ -0,0 +1,13 @@ +using UnityEngine; + +public class MaxHealthUpgradeCard : UpgradeCard +{ + [SerializeField] + private int healthIncrease; + + public override void Upgrade() + { + base.Upgrade(); + GameManager.instance.IncreaseTowerHealth(healthIncrease); + } +} diff --git a/GameCode/Mine.cs b/GameCode/Mine.cs new file mode 100644 index 0000000..55d7b6f --- /dev/null +++ b/GameCode/Mine.cs @@ -0,0 +1,81 @@ +using UnityEngine; + +public class Mine : MonoBehaviour, IBuildable +{ + [SerializeField] + private int goldBackOnDemolish; + + [SerializeField] + private LayerMask layermask; + + [SerializeField] + private GameObject UIObject; + + private bool gathering; + + private void Start() + { + SpawnManager.instance.mines.Add(this); + DetectIron(); + } + + public void SetStats() + { + } + + public void Repair() + { + if (gathering && Random.Range(0f, 1f) < 0.1f) + { + GameManager.instance.RepairTower(10); + } + } + + private void SetBonus(int value) + { + GameManager.instance.IncreaseTowerHealth(value); + } + + public void SpawnUI() + { + SimpleUI component = Object.Instantiate(UIObject, base.transform.position, Quaternion.identity).GetComponent<SimpleUI>(); + component.SetDemolishable(base.gameObject, goldBackOnDemolish); + if (gathering) + { + component.SetDiscriptionText("Currently mining. Tower maximum health increased by 1 and a 10% chance to repair damage."); + } + } + + private void DetectIron() + { + if ((!Physics.Raycast(base.transform.position + new Vector3(1f, 1f, 0f), -base.transform.up, out var hitInfo, 1f, layermask, QueryTriggerInteraction.Ignore) || !Rotate(hitInfo)) && (!Physics.Raycast(base.transform.position + new Vector3(-1f, 1f, 0f), -base.transform.up, out hitInfo, 1f, layermask, QueryTriggerInteraction.Ignore) || !Rotate(hitInfo)) && (!Physics.Raycast(base.transform.position + new Vector3(0f, 1f, 1f), -base.transform.up, out hitInfo, 1f, layermask, QueryTriggerInteraction.Ignore) || !Rotate(hitInfo)) && Physics.Raycast(base.transform.position + new Vector3(0f, 1f, -1f), -base.transform.up, out hitInfo, 1f, layermask, QueryTriggerInteraction.Ignore)) + { + Rotate(hitInfo); + } + } + + private bool Rotate(RaycastHit hit) + { + if (hit.collider.GetComponent<IronVein>() == null) + { + return false; + } + if ((double)Mathf.Abs(hit.collider.transform.position.y - base.transform.position.y) > 0.001) + { + return false; + } + base.transform.LookAt(hit.collider.transform.position, Vector3.up); + gathering = true; + SetBonus(1); + return true; + } + + public void Demolish() + { + SpawnManager.instance.mines.Remove(this); + if (gathering) + { + SetBonus(-1); + } + } +} diff --git a/GameCode/MonsterManager.cs b/GameCode/MonsterManager.cs new file mode 100644 index 0000000..40a7a35 --- /dev/null +++ b/GameCode/MonsterManager.cs @@ -0,0 +1,43 @@ +using UnityEngine; + +public class MonsterManager : MonoBehaviour +{ + public static MonsterManager instance; + + public int extraTowerDamage; + + public int extraGoldDrop; + + public float manaDropOnDeath; + + public float speedBonus; + + public int bonusDamageOnBleed; + + public int bonusDamageOnBurn; + + public int bonusDamageOnPoison; + + public int bonusDamageOnStun; + + public float poisonSlowPercent; + + public float burnSpeedDamagePercentBonus; + + public float bleedingCritChance; + + public float bleedPop; + + public float burnPop; + + public float poisonPop; + + public float slowCapModifier; + + public float hasteCapModifier; + + private void Awake() + { + instance = this; + } +} diff --git a/GameCode/MonsterManualEntry.cs b/GameCode/MonsterManualEntry.cs new file mode 100644 index 0000000..6c5156c --- /dev/null +++ b/GameCode/MonsterManualEntry.cs @@ -0,0 +1,63 @@ +using UnityEngine; +using UnityEngine.UI; + +public class MonsterManualEntry : MonoBehaviour +{ + [SerializeField] + private int level; + + [SerializeField] + private Enemy prefab; + + [SerializeField] + private Text titleText; + + [SerializeField] + private Text descriptionText; + + [SerializeField] + private Image img; + + [SerializeField] + private Sprite unknownSprite; + + private void Start() + { + int b = 0; + b = Mathf.Max(PlayerPrefs.GetInt("Record1", 0), b); + b = Mathf.Max(PlayerPrefs.GetInt("Record2", 0), b); + b = Mathf.Max(PlayerPrefs.GetInt("Record3", 0), b); + if (b + 1 < prefab.level) + { + titleText.text = "???"; + descriptionText.text = "???"; + img.sprite = unknownSprite; + return; + } + string text = descriptionText.text; + string text2 = ""; + text2 = text2 + "Speed: " + prefab.baseSpeed; + text2 = text2 + "| Health: " + prefab.baseHealth; + if (prefab.baseArmor > 0) + { + text2 = text2 + "| Armor: " + prefab.baseArmor; + } + if (prefab.baseShield > 0) + { + text2 = text2 + "| Shield: " + prefab.baseShield; + } + if (prefab.healthRegen > 0) + { + text2 = text2 + "| Heal: " + prefab.healthRegen + "/sec"; + } + if (prefab.armorRegen > 0) + { + text2 = text2 + "| Armor repair: " + prefab.armorRegen + "/sec"; + } + if (prefab.shieldRegen > 0) + { + text2 = text2 + "| Shield regen: " + prefab.shieldRegen + "/sec"; + } + descriptionText.text = text2 + "\n" + text; + } +} diff --git a/GameCode/MonsterUpgradeCard.cs b/GameCode/MonsterUpgradeCard.cs new file mode 100644 index 0000000..d78ab81 --- /dev/null +++ b/GameCode/MonsterUpgradeCard.cs @@ -0,0 +1,57 @@ +using UnityEngine; +using UnityEngine.UI; + +public class MonsterUpgradeCard : UpgradeCard +{ + [SerializeField] + private GameObject banditObject; + + [SerializeField] + private Text banditText; + + [SerializeField] + private int extraTowerDamage; + + [SerializeField] + private int extraGoldDrop; + + [SerializeField] + private float manaDropOnDeath; + + [SerializeField] + private float speedBonus; + + [SerializeField] + private float slowCapMod; + + [SerializeField] + private float hasteCapMod; + + public override void Upgrade() + { + base.Upgrade(); + MonsterManager.instance.extraTowerDamage += extraTowerDamage; + MonsterManager.instance.extraGoldDrop += extraGoldDrop; + MonsterManager.instance.manaDropOnDeath += manaDropOnDeath; + MonsterManager.instance.speedBonus += speedBonus; + MonsterManager.instance.slowCapModifier += slowCapMod; + MonsterManager.instance.hasteCapModifier += hasteCapMod; + if (extraGoldDrop > 0) + { + banditObject.SetActive(value: true); + banditText.text = "+" + MonsterManager.instance.extraGoldDrop + "g"; + } + if (manaDropOnDeath > 0f) + { + ResourceManager.instance.UpdateManaHUD(); + } + if ((double)MonsterManager.instance.slowCapModifier >= 0.3) + { + AchievementManager.instance.UnlockAchievement("MaxSlow"); + } + if (MonsterManager.instance.hasteCapModifier <= -0.6f) + { + AchievementManager.instance.UnlockAchievement("MaxHaste"); + } + } +} diff --git a/GameCode/Morter.cs b/GameCode/Morter.cs new file mode 100644 index 0000000..2170da3 --- /dev/null +++ b/GameCode/Morter.cs @@ -0,0 +1,39 @@ +using UnityEngine; + +public class Morter : Tower +{ + protected override void AimTurret() + { + } + + protected override void Fire() + { + if (consumesMana) + { + int manaCost = (int)((float)base.damage * finalManaConsumption); + if (!ResourceManager.instance.CheckMana(manaCost)) + { + return; + } + ResourceManager.instance.SpendMana(manaCost); + } + float num = projectileSpeed * Mathf.Clamp(Vector3.SqrMagnitude(currentTarget.transform.position - base.transform.position) / (2f * baseRange * baseRange), 1f, float.MaxValue); + Vector3 vector = currentTarget.GetComponent<Enemy>().GetFuturePosition(num) - turret.transform.position; + GameObject gameObject = Object.Instantiate(rotation: Quaternion.LookRotation(new Vector3(vector.x, 0f, vector.z), Vector3.up), original: projectile, position: muzzle.position); + gameObject.GetComponent<Projectile>().SetStats(towerType, currentTarget, num, base.damage, base.healthDamage, base.armorDamage, base.shieldDamage, base.slowPercent, base.bleedPercent, base.burnPercent, base.poisonPercent, base.critChance, base.stunChance); + gameObject.GetComponent<MorterShell>().SetMorterPhysics(currentTarget.GetComponent<Enemy>().GetFuturePosition(num)); + gameObject.GetComponent<MorterShell>().blastRadius = base.blastRadius; + if (extraProjectileFX != null) + { + GameObject gameObject2 = Object.Instantiate(extraProjectileFX, gameObject.transform.position, gameObject.transform.rotation); + gameObject2.transform.SetParent(gameObject.transform); + gameObject2.GetComponent<ProjectileFX>().SetFX(base.bleedPercent, base.burnPercent, base.poisonPercent, base.slowPercent, consumesMana); + Projectile component = gameObject.GetComponent<Projectile>(); + if (component.detachOnDestruction == null) + { + component.detachOnDestruction = gameObject2; + component.extraFX = gameObject2.GetComponent<ProjectileFX>(); + } + } + } +} diff --git a/GameCode/MorterShell.cs b/GameCode/MorterShell.cs new file mode 100644 index 0000000..ce93441 --- /dev/null +++ b/GameCode/MorterShell.cs @@ -0,0 +1,81 @@ +using UnityEngine; + +public class MorterShell : Projectile +{ + [SerializeField] + private GameObject artObject; + + [SerializeField] + private LayerMask layersAffectedByBlast; + + public float blastRadius = 1f; + + private Vector3 destination; + + private float timeOfFlight; + + [SerializeField] + private float vSpeed; + + [SerializeField] + private float hSpeed; + + [SerializeField] + private float gravity = 5f; + + [SerializeField] + private GameObject explosion; + + private float lookAhead; + + private Vector3 previousPos; + + public void SetMorterPhysics(Vector3 pos) + { + destination = pos; + timeOfFlight = speed; + vSpeed = gravity * timeOfFlight / 2f; + hSpeed = Vector3.Magnitude(base.transform.position - destination) / timeOfFlight; + lookAhead = vSpeed + hSpeed; + } + + protected override void MoveProjectile() + { + previousPos = base.transform.position; + base.transform.Translate(Vector3.forward * hSpeed * Time.fixedDeltaTime); + base.transform.Translate(Vector3.up * vSpeed * Time.fixedDeltaTime); + vSpeed -= gravity * Time.fixedDeltaTime; + artObject.transform.rotation = Quaternion.LookRotation(base.transform.position - previousPos, Vector3.up); + } + + protected override void CheckForHits() + { + if (!(vSpeed > 0f) && Physics.Raycast(artObject.transform.position, artObject.transform.forward, out var hitInfo, lookAhead * Time.fixedDeltaTime, layermask, QueryTriggerInteraction.Collide)) + { + OnHit(hitInfo); + } + } + + protected override void OnHit(RaycastHit hit) + { + Collider[] array = Physics.OverlapSphere(base.transform.position, blastRadius, layersAffectedByBlast, QueryTriggerInteraction.Collide); + for (int i = 0; i < array.Length; i++) + { + IDamageable component = array[i].GetComponent<IDamageable>(); + if (component != null) + { + DealDamage(component); + } + } + if (detachOnDestruction != null) + { + detachOnDestruction.transform.parent = null; + } + if (extraFX != null) + { + extraFX.OnDetach(); + } + Object.Instantiate(explosion, base.transform.position, Quaternion.identity); + Object.Destroy(base.gameObject); + } +} diff --git a/GameCode/MusicManager.cs b/GameCode/MusicManager.cs new file mode 100644 index 0000000..8a39705 --- /dev/null +++ b/GameCode/MusicManager.cs @@ -0,0 +1,164 @@ +using System.Collections; +using UnityEngine; + +public class MusicManager : MonoBehaviour +{ + public static MusicManager instance; + + [SerializeField] + private AudioSource[] hard; + + [SerializeField] + private AudioSource[] soft; + + [SerializeField] + private int currentSorceIndex; + + [SerializeField] + private int currentSong; + + private float currentSongLoopDuration; + + [SerializeField] + private AudioClip[] hardTracks; + + [SerializeField] + private AudioClip[] softTracks; + + [SerializeField] + private int[] BPMin; + + [SerializeField] + private int[] BPMeasure; + + [SerializeField] + private int[] measures; + + private int intensity = 1; + + private void Awake() + { + instance = this; + } + + private void Start() + { + PlaySong(0, action: false); + } + + private void Update() + { + if (hard[currentSorceIndex].time >= currentSongLoopDuration) + { + int num = (currentSorceIndex + 1) % 2; + hard[num].Stop(); + soft[num].Stop(); + hard[num].Play(); + soft[num].Play(); + currentSorceIndex = num; + } + int num2 = (currentSorceIndex + 1) % 2; + if (hard[num2].time >= hard[num2].clip.length - 0.1f) + { + hard[num2].Stop(); + soft[num2].Stop(); + } + } + + public void SetIntensity(bool action) + { + int num = (action ? 1 : 0); + if (num != intensity) + { + intensity = num; + StartCoroutine(CrossFade(intensity)); + } + } + + public void UpdateVolume(float newVolume) + { + hard[0].volume = newVolume * (float)intensity; + hard[1].volume = newVolume * (float)intensity; + soft[0].volume = newVolume * (float)(1 - intensity); + soft[1].volume = newVolume * (float)(1 - intensity); + } + + public void PlaySong(int songNumber, bool action) + { + StopAllCoroutines(); + hard[0].Stop(); + hard[1].Stop(); + soft[0].Stop(); + soft[1].Stop(); + currentSong = songNumber; + currentSongLoopDuration = (float)(60 * measures[currentSong] * BPMeasure[currentSong]) / (float)BPMin[currentSong]; + hard[0].clip = hardTracks[currentSong]; + hard[1].clip = hardTracks[currentSong]; + soft[0].clip = softTracks[currentSong]; + soft[1].clip = softTracks[currentSong]; + intensity = (action ? 1 : 0); + float num = OptionsMenu.instance.masterVolume * OptionsMenu.instance.musicVolume; + hard[0].volume = (float)intensity * num; + hard[1].volume = (float)intensity * num; + soft[0].volume = (float)(1 - intensity) * num; + soft[1].volume = (float)(1 - intensity) * num; + currentSorceIndex = 0; + hard[0].Play(); + soft[0].Play(); + } + + private IEnumerator CrossFade(int newIntensity) + { + float startIntensity = ((newIntensity != 1) ? 1 : 0); + float vMod = OptionsMenu.instance.masterVolume * OptionsMenu.instance.musicVolume; + float fadeTime = 2f; + int saftyCount = 0; + for (float f = startIntensity; f != (startIntensity + 1f) % 2f; f = Mathf.Clamp(f + Time.unscaledDeltaTime * ((float)newIntensity - startIntensity) / fadeTime, 0f, 1f)) + { + hard[0].volume = f * vMod; + hard[1].volume = f * vMod; + soft[0].volume = (1f - f) * vMod; + soft[1].volume = (1f - f) * vMod; + yield return null; + saftyCount++; + if ((float)saftyCount > 1000f * fadeTime) + { + Debug.LogError("Possible infinite loop"); + break; + } + } + hard[0].volume = (float)newIntensity * vMod; + hard[1].volume = (float)newIntensity * vMod; + soft[0].volume = (float)(1 - newIntensity) * vMod; + soft[1].volume = (float)(1 - newIntensity) * vMod; + } + + public void FadeOut(float t) + { + StartCoroutine(FadeOutCo(t)); + } + + private IEnumerator FadeOutCo(float fadeTime) + { + float vMod = OptionsMenu.instance.masterVolume * OptionsMenu.instance.musicVolume; + int saftyCount = 0; + for (float f = 1f; f > 0f; f -= Time.unscaledDeltaTime / fadeTime) + { + hard[0].volume = (float)intensity * vMod * f; + hard[1].volume = (float)intensity * vMod * f; + soft[0].volume = (float)(1 - intensity) * vMod * f; + soft[1].volume = (float)(1 - intensity) * vMod * f; + yield return null; + saftyCount++; + if ((float)saftyCount > 1000f * fadeTime) + { + Debug.LogError("Possible infinite loop"); + break; + } + } + hard[0].volume = 0f; + hard[1].volume = 0f; + soft[0].volume = 0f; + soft[1].volume = 0f; + } +} diff --git a/GameCode/Obelisk.cs b/GameCode/Obelisk.cs new file mode 100644 index 0000000..549f3b4 --- /dev/null +++ b/GameCode/Obelisk.cs @@ -0,0 +1,99 @@ +using UnityEngine; + +public class Obelisk : Tower +{ + [SerializeField] + private GameObject beam; + + [SerializeField] + private AudioSource audioS; + + private bool soundPlaying; + + private IDamageable lastThingIHit; + + private float timeOnTarget; + + protected override void Update() + { + if (currentTarget != null) + { + if (turret != null) + { + AimTurret(); + } + GainXP(); + } + else + { + beam.SetActive(value: false); + PlaySound(onOff: false); + } + timeSinceLastShot += Time.deltaTime; + if (currentTarget != null && timeSinceLastShot > rps) + { + Fire(); + timeSinceLastShot = 0f; + } + } + + protected override void Fire() + { + if (consumesMana) + { + int manaCost = (int)((float)base.damage * manaConsumptionRate); + if (!ResourceManager.instance.CheckMana(manaCost)) + { + beam.SetActive(value: false); + PlaySound(onOff: false); + return; + } + ResourceManager.instance.SpendMana(manaCost); + } + DealDamage(); + } + + protected override void AimTurret() + { + Vector3 forward = currentTarget.transform.position - turret.transform.position + Vector3.up * 0.5f; + Quaternion rotation = Quaternion.LookRotation(forward, Vector3.up); + turret.transform.rotation = rotation; + beam.transform.localScale = new Vector3(1f, 1f, forward.magnitude); + } + + private void DealDamage() + { + IDamageable component = currentTarget.GetComponent<IDamageable>(); + if (component != null) + { + if (component == lastThingIHit) + { + timeOnTarget += rps; + } + else + { + timeOnTarget = 0f; + lastThingIHit = component; + } + int num = Mathf.Clamp(Mathf.FloorToInt(timeOnTarget * TowerManager.instance.obeliskTimeOnTargetMultiplier), 0, base.damage); + component.TakeDamage(towerType, base.damage + num, base.healthDamage, base.armorDamage, base.shieldDamage, base.slowPercent, base.bleedPercent, base.burnPercent, base.poisonPercent, base.critChance, base.stunChance); + beam.SetActive(value: true); + PlaySound(onOff: true); + } + } + + private void PlaySound(bool onOff) + { + if (onOff && !soundPlaying) + { + audioS.volume = OptionsMenu.instance.masterVolume * OptionsMenu.instance.sfxVolume; + audioS.Play(); + soundPlaying = true; + } + else if (!onOff && soundPlaying) + { + audioS.Stop(); + soundPlaying = false; + } + } +} diff --git a/GameCode/ObjectPool.cs b/GameCode/ObjectPool.cs new file mode 100644 index 0000000..feb9c40 --- /dev/null +++ b/GameCode/ObjectPool.cs @@ -0,0 +1,58 @@ +using System.Collections.Generic; +using UnityEngine; + +public class ObjectPool : MonoBehaviour +{ + public enum ObjectType + { + DamageNumber + } + + public static ObjectPool instance; + + [SerializeField] + private GameObject damageNumberPrefab; + + [SerializeField] + private List<GameObject> pooledDamageNumbers = new List<GameObject>(); + + private void Awake() + { + instance = this; + } + + public GameObject SpawnObject(ObjectType type, Vector3 position, Quaternion rotation) + { + if (type == ObjectType.DamageNumber) + { + return SpawnDamageNumber(position, rotation); + } + Debug.LogError("Failed to spawn object from pool"); + return null; + } + + private GameObject SpawnDamageNumber(Vector3 position, Quaternion rotation) + { + while (pooledDamageNumbers.Count > 0 && pooledDamageNumbers[0] == null) + { + pooledDamageNumbers.RemoveAt(0); + } + if (pooledDamageNumbers.Count > 0) + { + GameObject gameObject = pooledDamageNumbers[0]; + pooledDamageNumbers.Remove(gameObject); + gameObject.SetActive(value: true); + gameObject.transform.position = position; + gameObject.transform.rotation = rotation; + gameObject.GetComponent<DamageNumber>().Start(); + return gameObject; + } + return Object.Instantiate(damageNumberPrefab, position, rotation); + } + + public void PoolDamageNumber(GameObject damageNumber) + { + pooledDamageNumbers.Add(damageNumber); + damageNumber.SetActive(value: false); + } +} diff --git a/GameCode/OptionsMenu.cs b/GameCode/OptionsMenu.cs new file mode 100644 index 0000000..7377cfd --- /dev/null +++ b/GameCode/OptionsMenu.cs @@ -0,0 +1,187 @@ +using UnityEngine; +using UnityEngine.UI; + +public class OptionsMenu : MonoBehaviour +{ + public static OptionsMenu instance; + + public bool showConditionText; + + public bool showDamageNumbers = true; + + public bool extraProjectileEffects = true; + + public float masterVolume; + + public float musicVolume; + + public float sfxVolume; + + [SerializeField] + private Transform[] scalableUIs; + + public float uiScale; + + [SerializeField] + private Toggle showDamageToggle; + + [SerializeField] + private Toggle showConditionToggle; + + [SerializeField] + private Toggle projectileFXToggle; + + [SerializeField] + private Slider masterVolumeSlider; + + [SerializeField] + private Slider musicVolumeSlider; + + [SerializeField] + private Slider sfxVolumeSlider; + + [SerializeField] + private Slider uiScaleSlider; + + private float timer = 1f; + + private void Awake() + { + instance = this; + } + + private void Update() + { + if (timer >= 0f) + { + timer -= Time.deltaTime; + } + } + + private void Start() + { + if (PlayerPrefs.GetInt("ShowConditionText", 0) == 1) + { + showConditionText = true; + } + else + { + showConditionText = false; + } + if (showConditionToggle != null) + { + showConditionToggle.isOn = showConditionText; + } + if (PlayerPrefs.GetInt("ShowDamageNumbers", 1) == 1) + { + showDamageNumbers = true; + } + else + { + showDamageNumbers = false; + } + if (showDamageToggle != null) + { + showDamageToggle.isOn = showDamageNumbers; + } + if (PlayerPrefs.GetInt("ExtraProjectileFX", 1) == 1) + { + extraProjectileEffects = true; + } + else + { + extraProjectileEffects = false; + } + if (projectileFXToggle != null) + { + projectileFXToggle.isOn = extraProjectileEffects; + } + masterVolume = PlayerPrefs.GetFloat("MasterVolume", 1f); + musicVolume = PlayerPrefs.GetFloat("MusicVolume", 0.5f); + sfxVolume = PlayerPrefs.GetFloat("SFXVolume", 0.5f); + masterVolumeSlider.value = masterVolume; + musicVolumeSlider.value = musicVolume; + sfxVolumeSlider.value = sfxVolume; + if (uiScaleSlider != null) + { + uiScale = PlayerPrefs.GetFloat("UIScale", 0.5f); + uiScaleSlider.value = uiScale; + } + } + + public void ToggleDamageNumbers() + { + showDamageNumbers = showDamageToggle.isOn; + PlayerPrefs.SetInt("ShowDamageNumbers", showDamageNumbers ? 1 : 0); + if (timer < 0f) + { + SFXManager.instance.ButtonClick(); + } + } + + public void ToggleConditionTexts() + { + showConditionText = showConditionToggle.isOn; + PlayerPrefs.SetInt("ShowConditionText", showConditionText ? 1 : 0); + if (timer < 0f) + { + SFXManager.instance.ButtonClick(); + } + } + + public void ToggleProjectileFX() + { + extraProjectileEffects = projectileFXToggle.isOn; + PlayerPrefs.SetInt("ExtraProjectileFX", extraProjectileEffects ? 1 : 0); + if (timer < 0f) + { + SFXManager.instance.ButtonClick(); + } + } + + public void ChangeMasterVolume() + { + masterVolume = masterVolumeSlider.value; + PlayerPrefs.SetFloat("MasterVolume", masterVolume); + if (MusicManager.instance != null) + { + MusicManager.instance.UpdateVolume(masterVolume * musicVolume); + } + if (SFXManager.instance != null) + { + SFXManager.instance.volume = masterVolume * sfxVolume; + } + } + + public void ChangeMusicVolume() + { + musicVolume = musicVolumeSlider.value; + PlayerPrefs.SetFloat("MusicVolume", musicVolume); + if (MusicManager.instance != null) + { + MusicManager.instance.UpdateVolume(masterVolume * musicVolume); + } + } + + public void ChangeSFXVolume() + { + sfxVolume = sfxVolumeSlider.value; + PlayerPrefs.SetFloat("SFXVolume", sfxVolume); + if (SFXManager.instance != null) + { + SFXManager.instance.volume = masterVolume * sfxVolume; + } + } + + public void ChangeUIScale() + { + uiScale = uiScaleSlider.value; + PlayerPrefs.SetFloat("UIScale", uiScale); + float num = Mathf.Max(uiScale + 0.5f, (uiScale + 0.5f) * 2f - 1f); + Transform[] array = scalableUIs; + for (int i = 0; i < array.Length; i++) + { + array[i].localScale = num * Vector3.one; + } + } +} diff --git a/GameCode/ParticleBeam.cs b/GameCode/ParticleBeam.cs new file mode 100644 index 0000000..6a7bf2a --- /dev/null +++ b/GameCode/ParticleBeam.cs @@ -0,0 +1,19 @@ +using UnityEngine; + +public class ParticleBeam : Projectile +{ + [SerializeField] + private GameObject beamTrail; + + protected override void MoveProjectile() + { + base.MoveProjectile(); + beamTrail.transform.position = base.transform.position + new Vector3(Random.Range(-1f, 1f), Random.Range(0f, 1f), Random.Range(-1f, 1f)); + } + + protected new virtual void OnHit(RaycastHit hit) + { + beamTrail.transform.position = hit.point; + base.OnHit(hit); + } +} diff --git a/GameCode/Pathfinder.cs b/GameCode/Pathfinder.cs new file mode 100644 index 0000000..5426574 --- /dev/null +++ b/GameCode/Pathfinder.cs @@ -0,0 +1,91 @@ +using UnityEngine; + +public class Pathfinder : MonoBehaviour +{ + public float distanceFromEnd = 2.1474836E+09f; + + public bool atEnd; + + public float speed = 1f; + + public Waypoint currentWaypoint; + + [SerializeField] + private Enemy enemyScript; + + private void Start() + { + if (enemyScript == null) + { + enemyScript = GetComponent<Enemy>(); + } + } + + private void FixedUpdate() + { + CheckWaypointDistance(); + Move(); + } + + private void Move() + { + Vector3 vector = currentWaypoint.transform.position - base.transform.position; + vector.Normalize(); + base.transform.Translate(vector * speed * Time.fixedDeltaTime); + distanceFromEnd -= speed * Time.fixedDeltaTime; + } + + private void CheckWaypointDistance() + { + if (Vector3.SqrMagnitude(currentWaypoint.transform.position - base.transform.position) < 4f * speed * speed * Time.fixedDeltaTime * Time.fixedDeltaTime && !GetNewWaypoint()) + { + atEnd = true; + enemyScript.AtEnd(); + } + } + + public Vector3 GetFuturePosition(float distance) + { + Vector3 position = base.transform.position; + Waypoint nextWaypoint = currentWaypoint; + float num = distance; + int num2 = 0; + while (num > 0f) + { + if (Vector3.SqrMagnitude(nextWaypoint.transform.position - position) >= num * num) + { + return position + (nextWaypoint.transform.position - position).normalized * num; + } + if (nextWaypoint.GetNextWaypoint() == nextWaypoint) + { + return nextWaypoint.transform.position; + } + num -= Vector3.Magnitude(nextWaypoint.transform.position - position); + position = nextWaypoint.transform.position; + nextWaypoint = nextWaypoint.GetNextWaypoint(); + num2++; + if (num2 > 100) + { + Debug.LogError("GetFuturePosition looping too much"); + break; + } + } + Debug.LogError("GetFuturePosition broken"); + return Vector3.zero; + } + + private bool GetNewWaypoint() + { + if (currentWaypoint.GetNextWaypoint() == currentWaypoint) + { + return false; + } + distanceFromEnd = currentWaypoint.distanceFromEnd; + currentWaypoint = currentWaypoint.GetNextWaypoint(); + if (distanceFromEnd <= 24f) + { + enemyScript.CheckBattleCries(BattleCry.BattleCryTrigger.NearEnd); + } + return true; + } +} diff --git a/GameCode/PauseMenu.cs b/GameCode/PauseMenu.cs new file mode 100644 index 0000000..0ccfc28 --- /dev/null +++ b/GameCode/PauseMenu.cs @@ -0,0 +1,140 @@ +using UnityEngine; + +public class PauseMenu : MonoBehaviour +{ + [SerializeField] + private KeyCode pauseKey1; + + [SerializeField] + private KeyCode pauseKey2; + + [SerializeField] + private KeyCode hideUIKey; + + [SerializeField] + private KeyCode damageTrackerKey; + + [SerializeField] + private GameObject pauseMenu; + + [SerializeField] + private GameObject areYouSureMenu; + + [SerializeField] + private GameObject optionsMenu; + + [SerializeField] + private GameObject[] hideableUI; + + [SerializeField] + private GameObject[] hideableWithTracker; + + private bool uiHidden; + + private bool trackerHidden = true; + + public bool paused; + + public static PauseMenu instance; + + private void Awake() + { + instance = this; + } + + private void Update() + { + if (Input.GetKeyDown(pauseKey1) || Input.GetKeyDown(pauseKey2)) + { + if (!paused) + { + UnHideUI(); + Pause(); + } + else + { + UnPause(); + } + } + if (Input.GetKeyDown(hideUIKey)) + { + if (uiHidden) + { + UnHideUI(); + } + else + { + hideUI(); + } + } + if (Input.GetKeyDown(damageTrackerKey)) + { + if (trackerHidden) + { + UnHideTracker(); + } + else + { + HideTracker(); + } + } + } + + public void Pause() + { + paused = true; + Time.timeScale = 0f; + pauseMenu.SetActive(value: true); + } + + public void UnPause() + { + pauseMenu.SetActive(value: false); + areYouSureMenu.SetActive(value: false); + optionsMenu.SetActive(value: false); + Time.timeScale = 1f; + paused = false; + } + + public void hideUI() + { + uiHidden = true; + GameObject[] array = hideableUI; + for (int i = 0; i < array.Length; i++) + { + array[i].SetActive(value: false); + } + } + + public void UnHideUI() + { + uiHidden = false; + GameObject[] array = hideableUI; + for (int i = 0; i < array.Length; i++) + { + array[i].SetActive(value: true); + } + } + + public void HideTracker() + { + trackerHidden = true; + DamageTracker.instance.uiObject.SetActive(value: false); + GameObject[] array = hideableWithTracker; + for (int i = 0; i < array.Length; i++) + { + array[i].SetActive(value: false); + } + } + + public void UnHideTracker() + { + trackerHidden = false; + DamageTracker.instance.DisplayDamageTotals(); + GameObject[] array = hideableWithTracker; + for (int i = 0; i < array.Length; i++) + { + array[i].SetActive(value: true); + } + } +} diff --git a/GameCode/PlayMenu.cs b/GameCode/PlayMenu.cs new file mode 100644 index 0000000..19514b3 --- /dev/null +++ b/GameCode/PlayMenu.cs @@ -0,0 +1,27 @@ +using UnityEngine; +using UnityEngine.UI; + +public class PlayMenu : MonoBehaviour +{ + [SerializeField] + private Text record1Text; + + [SerializeField] + private Text record2Text; + + [SerializeField] + private Text record3Text; + + private void Start() + { + record1Text.text = "Current Record\nLevel " + PlayerPrefs.GetInt("Record1", 0); + record2Text.text = "Current Record\nLevel " + PlayerPrefs.GetInt("Record2", 0); + record3Text.text = "Current Record\nLevel " + PlayerPrefs.GetInt("Record3", 0); + } + + public void StartGame(int mode) + { + PlayerPrefs.SetInt("GameMode", Mathf.Clamp(mode, 1, 3)); + LevelLoader.instance.LoadLevel("GameScene"); + } +} diff --git a/GameCode/Projectile.cs b/GameCode/Projectile.cs new file mode 100644 index 0000000..3c15fe4 --- /dev/null +++ b/GameCode/Projectile.cs @@ -0,0 +1,141 @@ +using UnityEngine; + +public class Projectile : MonoBehaviour +{ + [SerializeField] + protected Sound launchSound; + + [SerializeField] + protected Sound hitSound; + + protected TowerType shotBy; + + [SerializeField] + protected LayerMask layermask; + + [SerializeField] + protected float speed; + + [SerializeField] + protected bool homing; + + [SerializeField] + protected float maximumLifeTime = 10f; + + [SerializeField] + public GameObject detachOnDestruction; + + [SerializeField] + public ProjectileFX extraFX; + + protected GameObject target; + + protected int damage; + + protected int healthDamage; + + protected int armorDamage; + + protected int shieldDamage; + + protected float slowPercent; + + protected float bleedPercent; + + protected float burnPercent; + + protected float poisonPercent; + + protected float critChance; + + protected float stunChance; + + protected virtual void Start() + { + if (launchSound != 0) + { + SFXManager.instance.PlaySound(launchSound, base.transform.position); + } + } + + protected virtual void FixedUpdate() + { + maximumLifeTime -= Time.fixedDeltaTime; + if (maximumLifeTime < 0f) + { + Object.Destroy(base.gameObject); + } + CheckForHits(); + MoveProjectile(); + if (homing) + { + AlterCourse(); + } + } + + public virtual void SetStats(TowerType whoShotMe, GameObject _target, float spd, int dmg, int healthDmg, int armorDmg, int shieldDmg, float slow, float bleed, float burn, float poison, float crit, float stun) + { + shotBy = whoShotMe; + target = _target; + speed = spd; + damage = dmg; + healthDamage = healthDmg; + armorDamage = armorDmg; + shieldDamage = shieldDmg; + slowPercent = slow; + bleedPercent = bleed; + burnPercent = burn; + poisonPercent = poison; + critChance = crit; + stunChance = stun; + } + + protected virtual void MoveProjectile() + { + base.transform.Translate(Vector3.forward * speed * Time.fixedDeltaTime); + } + + protected virtual void AlterCourse() + { + if (!(target == null)) + { + Quaternion rotation = Quaternion.LookRotation(0.25f * Vector3.up + target.transform.position - base.transform.position, Vector3.up); + base.transform.rotation = rotation; + } + } + + protected virtual void CheckForHits() + { + if (Physics.Raycast(base.transform.position, base.transform.forward, out var hitInfo, speed * Time.fixedDeltaTime, layermask, QueryTriggerInteraction.Collide)) + { + OnHit(hitInfo); + } + } + + protected virtual void OnHit(RaycastHit hit) + { + IDamageable component = hit.transform.GetComponent<IDamageable>(); + if (component != null) + { + DealDamage(component); + } + if (detachOnDestruction != null) + { + detachOnDestruction.transform.parent = null; + } + if (extraFX != null) + { + extraFX.OnDetach(); + } + Object.Destroy(base.gameObject); + } + + protected virtual void DealDamage(IDamageable target) + { + target.TakeDamage(shotBy, damage, healthDamage, armorDamage, shieldDamage, slowPercent, bleedPercent, burnPercent, poisonPercent, critChance, stunChance); + if (hitSound != 0) + { + SFXManager.instance.PlaySound(hitSound, base.transform.position); + } + } +} diff --git a/GameCode/ProjectileFX.cs b/GameCode/ProjectileFX.cs new file mode 100644 index 0000000..df82c3d --- /dev/null +++ b/GameCode/ProjectileFX.cs @@ -0,0 +1,47 @@ +using System.Collections; +using UnityEngine; + +public class ProjectileFX : MonoBehaviour +{ + [SerializeField] + private GameObject bleedingPS; + + [SerializeField] + private GameObject burrningPS; + + [SerializeField] + private GameObject poisonPS; + + public void SetFX(float bleeding, float burning, float poison, float slow, bool arcane) + { + if (OptionsMenu.instance.extraProjectileEffects) + { + if (bleeding > 0f) + { + bleedingPS.SetActive(value: true); + } + if (burning > 0f) + { + burrningPS.SetActive(value: true); + } + if (poison > 0f) + { + poisonPS.SetActive(value: true); + } + } + } + + public void OnDetach() + { + StartCoroutine(Die()); + } + + private IEnumerator Die() + { + bleedingPS.GetComponent<ParticleSystem>().Stop(withChildren: true); + burrningPS.GetComponent<ParticleSystem>().Stop(withChildren: true); + poisonPS.GetComponent<ParticleSystem>().Stop(withChildren: true); + yield return new WaitForSeconds(1.1f); + Object.Destroy(base.gameObject); + } +} diff --git a/GameCode/RadarTower.cs b/GameCode/RadarTower.cs new file mode 100644 index 0000000..e0d8d1d --- /dev/null +++ b/GameCode/RadarTower.cs @@ -0,0 +1,71 @@ +using UnityEngine; + +public class RadarTower : Tower +{ + [SerializeField] + private GameObject biPlanePrefab; + + [SerializeField] + private BiPlane myPlane; + + protected override void Start() + { + if (myPlane == null) + { + myPlane = Object.Instantiate(biPlanePrefab, base.transform.position + new Vector3(-50f, 5f, 0f), Quaternion.identity).GetComponent<BiPlane>(); + } + base.Start(); + } + + public override void SetStats() + { + base.SetStats(); + if (myPlane == null) + { + myPlane = Object.Instantiate(biPlanePrefab, base.transform.position + new Vector3(-50f, 5f, 0f), Quaternion.identity).GetComponent<BiPlane>(); + } + myPlane.damage = base.damage; + myPlane.healthDamage = base.healthDamage; + myPlane.armorDamage = base.armorDamage; + myPlane.shieldDamage = base.shieldDamage; + myPlane.rps = rps; + myPlane.slowPercent = base.slowPercent; + myPlane.bleedPercent = base.bleedPercent; + myPlane.burnPercent = base.burnPercent; + myPlane.poisonPercent = base.poisonPercent; + myPlane.critChance = base.critChance; + myPlane.stunChance = base.stunChance; + } + + protected override void Update() + { + if (currentTarget != null) + { + if (turret != null) + { + AimTurret(); + } + GainXP(); + } + timeSinceLastShot += Time.deltaTime; + if (currentTarget != null && timeSinceLastShot > 3f) + { + SendTargetInfo(currentTarget); + timeSinceLastShot = 0f; + } + } + + private void SendTargetInfo(GameObject target) + { + if (myPlane.target == null) + { + myPlane.target = target; + } + } + + public override void Demolish() + { + Object.Destroy(myPlane.gameObject); + base.Demolish(); + } +} diff --git a/GameCode/ResourceManager.cs b/GameCode/ResourceManager.cs new file mode 100644 index 0000000..5b9867f --- /dev/null +++ b/GameCode/ResourceManager.cs @@ -0,0 +1,225 @@ +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.UI; + +public class ResourceManager : MonoBehaviour +{ + public static ResourceManager instance; + + [SerializeField] + private int gold; + + [SerializeField] + private Text goldText; + + [SerializeField] + private int mana; + + private float manaLoss = 1f; + + [SerializeField] + private int maxMana; + + [SerializeField] + private int manaGatherRate; + + [SerializeField] + private Text manaText; + + [SerializeField] + private Image maskBar; + + [SerializeField] + private Image manaBar; + + [SerializeField] + private Image manaLossBar; + + private float manaTimer; + + private int manaGen; + + public float manaMaxRegenPercent; + + [SerializeField] + private GameObject manaHUDObject; + + [SerializeField] + private Text manaHUDText; + + public int enemyBonusGoldDrop; + + public List<ManaBank> manaBanks = new List<ManaBank>(); + + public int manaBankBonusMana; + + private void Awake() + { + instance = this; + } + + private void Start() + { + gold = 1000 + 100 * (PlayerPrefs.GetInt("StartGold1", 0) + PlayerPrefs.GetInt("StartGold2", 0) + PlayerPrefs.GetInt("StartGold3", 0) + PlayerPrefs.GetInt("StartGold4", 0) + PlayerPrefs.GetInt("StartGold5", 0) + PlayerPrefs.GetInt("StartGold6", 0) + PlayerPrefs.GetInt("StartGold7", 0) + PlayerPrefs.GetInt("StartGold8", 0) + PlayerPrefs.GetInt("StartGold9", 0) + PlayerPrefs.GetInt("StartGold10", 0)); + maxMana = 100 + 20 * (PlayerPrefs.GetInt("MaxMana1", 0) + PlayerPrefs.GetInt("MaxMana2", 0) + PlayerPrefs.GetInt("MaxMana3", 0) + PlayerPrefs.GetInt("MaxMana4", 0) + PlayerPrefs.GetInt("MaxMana5", 0)); + enemyBonusGoldDrop = PlayerPrefs.GetInt("GoldDrop1", 0) + PlayerPrefs.GetInt("GoldDrop2", 0) + PlayerPrefs.GetInt("GoldDrop3", 0) + PlayerPrefs.GetInt("GoldDrop4", 0) + PlayerPrefs.GetInt("GoldDrop5", 0); + manaGen = PlayerPrefs.GetInt("ManaGen1", 0) + PlayerPrefs.GetInt("ManaGen2", 0) + PlayerPrefs.GetInt("ManaGen3", 0); + UpdateManaGatherRate(manaGen); + SetManaBar(); + } + + private void Update() + { + if (manaLoss > (float)mana) + { + float num = 20f; + if (maxMana >= 500) + { + num = 100f; + } + manaLoss = Mathf.Clamp(manaLoss - num * Time.deltaTime, mana, manaLoss); + manaLossBar.rectTransform.sizeDelta = new Vector2(manaLoss / num, 0.25f); + } + if (manaTimer <= 0f) + { + AddMana(manaGen); + AddManaPercentMax(manaMaxRegenPercent); + manaTimer = 1f; + } + else if (manaGen > 0 && SpawnManager.instance.combat) + { + manaTimer -= Time.deltaTime; + } + } + + public void Spend(int goldCost) + { + gold -= goldCost; + UpdateResourceText(); + } + + public void AddMoney(int addedGold) + { + gold += addedGold; + UpdateResourceText(); + } + + public bool CheckMoney(int goldCost) + { + if (gold >= goldCost) + { + return true; + } + return false; + } + + public void SpendMana(int manaCost) + { + mana -= manaCost; + UpdateResourceText(); + } + + public void AddMana(int addedMana) + { + mana = Mathf.Clamp(mana + addedMana, 0, maxMana); + if (manaLoss < (float)mana) + { + manaLoss = mana; + } + UpdateResourceText(); + } + + public void AddManaPercentMax(float percent) + { + AddMana(Mathf.FloorToInt(percent * (float)maxMana)); + } + + public void AddMaxMana(int amount) + { + maxMana += amount; + float num = 20f; + if (maxMana >= 500) + { + num = 100f; + } + maskBar.rectTransform.localScale = new Vector3(num * 200f / (float)maxMana, 50f, 10f); + maskBar.rectTransform.sizeDelta = new Vector2((float)maxMana / num, 0.25f); + UpdateResourceText(); + } + + public bool CheckMana(int manaCost) + { + if (mana >= manaCost) + { + return true; + } + return false; + } + + public void UpdateManaGatherRate(int addedGatherRate) + { + manaGatherRate += addedGatherRate; + UpdateResourceText(); + } + + public void UpdateManaHUD() + { + string text = ""; + if (manaMaxRegenPercent > 0f) + { + text = text + "+" + Mathf.FloorToInt(101f * manaMaxRegenPercent) + "%/s\n"; + } + if (MonsterManager.instance.manaDropOnDeath > 0f) + { + text = text + Mathf.FloorToInt(101f * MonsterManager.instance.manaDropOnDeath) + "%/kill"; + } + if (text.Length > 1) + { + manaHUDObject.SetActive(value: true); + manaHUDText.text = text; + } + } + + public void AddPercentManaGathering(float percent) + { + manaMaxRegenPercent += percent; + UpdateResourceText(); + } + + private void UpdateResourceText() + { + goldText.text = "Gold: " + gold; + manaText.text = "Mana: " + mana + "/" + maxMana + " (+" + (manaGatherRate + Mathf.FloorToInt(manaMaxRegenPercent * (float)maxMana)) + "/s)"; + float num = 20f; + if (maxMana >= 500) + { + num = 100f; + } + manaBar.rectTransform.sizeDelta = new Vector2((float)mana / num, 0.25f); + } + + public void SetManaBar() + { + float num = 20f; + if (maxMana >= 500) + { + num = 100f; + } + maskBar.rectTransform.localScale = new Vector3(num * 200f / (float)maxMana, 50f, 10f); + maskBar.rectTransform.sizeDelta = new Vector2((float)maxMana / num, 0.25f); + manaLossBar.rectTransform.sizeDelta = new Vector2((float)maxMana / num, 0.25f); + UpdateResourceText(); + } + + public void UpgradeManaBankMaxMana(int addition) + { + manaBankBonusMana += addition; + foreach (ManaBank manaBank in manaBanks) + { + if (manaBank != null) + { + manaBank.UpgradeMaxMana(addition); + } + } + } +} diff --git a/GameCode/RogueTower.csproj b/GameCode/RogueTower.csproj new file mode 100644 index 0000000..4530366 --- /dev/null +++ b/GameCode/RogueTower.csproj @@ -0,0 +1,260 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <AssemblyName>Assembly-CSharp</AssemblyName> + <GenerateAssemblyInfo>False</GenerateAssemblyInfo> + <TargetFramework>netstandard2.0</TargetFramework> + </PropertyGroup> + <PropertyGroup> + <LangVersion>11.0</LangVersion> + <AllowUnsafeBlocks>True</AllowUnsafeBlocks> + </PropertyGroup> + <PropertyGroup /> + <ItemGroup> + <Reference Include="Mono.Security"> + <HintPath>..\..\Rogue Tower_Data\Managed\Mono.Security.dll</HintPath> + </Reference> + <Reference Include="Newtonsoft.Json"> + <HintPath>..\..\Rogue Tower_Data\Managed\Newtonsoft.Json.dll</HintPath> + </Reference> + <Reference Include="System.Configuration"> + <HintPath>..\..\Rogue Tower_Data\Managed\System.Configuration.dll</HintPath> + </Reference> + <Reference Include="System.Diagnostics.StackTrace"> + <HintPath>..\..\Rogue Tower_Data\Managed\System.Diagnostics.StackTrace.dll</HintPath> + </Reference> + <Reference Include="System.EnterpriseServices"> + <HintPath>..\..\Rogue Tower_Data\Managed\System.EnterpriseServices.dll</HintPath> + </Reference> + <Reference Include="System.Globalization.Extensions"> + <HintPath>..\..\Rogue Tower_Data\Managed\System.Globalization.Extensions.dll</HintPath> + </Reference> + <Reference Include="System.ServiceModel.Internals"> + <HintPath>..\..\Rogue Tower_Data\Managed\System.ServiceModel.Internals.dll</HintPath> + </Reference> + <Reference Include="System.Xml.XPath.XDocument"> + <HintPath>..\..\Rogue Tower_Data\Managed\System.Xml.XPath.XDocument.dll</HintPath> + </Reference> + <Reference Include="Unity.Postprocessing.Runtime"> + <HintPath>..\..\Rogue Tower_Data\Managed\Unity.Postprocessing.Runtime.dll</HintPath> + </Reference> + <Reference Include="Unity.TextMeshPro"> + <HintPath>..\..\Rogue Tower_Data\Managed\Unity.TextMeshPro.dll</HintPath> + </Reference> + <Reference Include="Unity.Timeline"> + <HintPath>..\..\Rogue Tower_Data\Managed\Unity.Timeline.dll</HintPath> + </Reference> + <Reference Include="Unity.VisualScripting.Antlr3.Runtime"> + <HintPath>..\..\Rogue Tower_Data\Managed\Unity.VisualScripting.Antlr3.Runtime.dll</HintPath> + </Reference> + <Reference Include="Unity.VisualScripting.Core"> + <HintPath>..\..\Rogue Tower_Data\Managed\Unity.VisualScripting.Core.dll</HintPath> + </Reference> + <Reference Include="Unity.VisualScripting.Flow"> + <HintPath>..\..\Rogue Tower_Data\Managed\Unity.VisualScripting.Flow.dll</HintPath> + </Reference> + <Reference Include="Unity.VisualScripting.State"> + <HintPath>..\..\Rogue Tower_Data\Managed\Unity.VisualScripting.State.dll</HintPath> + </Reference> + <Reference Include="UnityEngine"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.AccessibilityModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.AccessibilityModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.AIModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.AIModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.AndroidJNIModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.AndroidJNIModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.AnimationModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.AnimationModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.ARModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.ARModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.AssetBundleModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.AssetBundleModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.ClothModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.ClothModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.ClusterInputModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.ClusterInputModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.ClusterRendererModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.ClusterRendererModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.CoreModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.CoreModule.dll</HintPath> + </Reference> + <Reference Include="Assembly-CSharp-firstpass"> + <HintPath>..\..\Rogue Tower_Data\Managed\Assembly-CSharp-firstpass.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.AudioModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.AudioModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.CrashReportingModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.CrashReportingModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.DirectorModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.DirectorModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.DSPGraphModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.DSPGraphModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.GameCenterModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.GameCenterModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.GIModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.GIModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.GridModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.GridModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.HotReloadModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.HotReloadModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.ImageConversionModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.ImageConversionModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.IMGUIModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.IMGUIModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.InputModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.InputModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.JSONSerializeModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.JSONSerializeModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.LocalizationModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.LocalizationModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.PerformanceReportingModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.PerformanceReportingModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.Physics2DModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.Physics2DModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.PhysicsModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.PhysicsModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.ProfilerModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.ProfilerModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.RuntimeInitializeOnLoadManagerInitializerModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.RuntimeInitializeOnLoadManagerInitializerModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.ScreenCaptureModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.ScreenCaptureModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.SharedInternalsModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.SharedInternalsModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.SpriteMaskModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.SpriteMaskModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.SpriteShapeModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.SpriteShapeModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.StreamingModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.StreamingModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.SubstanceModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.SubstanceModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.SubsystemsModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.SubsystemsModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.TerrainModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.TerrainModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.TerrainPhysicsModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.TerrainPhysicsModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.TextCoreModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.TextCoreModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.TextRenderingModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.TextRenderingModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.TilemapModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.TilemapModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.TLSModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.TLSModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UI"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UI.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.ParticleSystemModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.ParticleSystemModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.InputLegacyModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.InputLegacyModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UIElementsModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UIElementsModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UIElementsNativeModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UIElementsNativeModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UIModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UIModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UmbraModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UmbraModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UNETModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UNETModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UnityAnalyticsModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UnityAnalyticsModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UnityConnectModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UnityConnectModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UnityCurlModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UnityCurlModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UnityTestProtocolModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UnityTestProtocolModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UnityWebRequestAssetBundleModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UnityWebRequestAssetBundleModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UnityWebRequestAudioModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UnityWebRequestAudioModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UnityWebRequestModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UnityWebRequestModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UnityWebRequestTextureModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UnityWebRequestTextureModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.UnityWebRequestWWWModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.UnityWebRequestWWWModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.VehiclesModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.VehiclesModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.VFXModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.VFXModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.VideoModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.VideoModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.VirtualTexturingModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.VirtualTexturingModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.VRModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.VRModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.WindModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.WindModule.dll</HintPath> + </Reference> + <Reference Include="UnityEngine.XRModule"> + <HintPath>..\..\Rogue Tower_Data\Managed\UnityEngine.XRModule.dll</HintPath> + </Reference> + </ItemGroup> +</Project>
\ No newline at end of file diff --git a/GameCode/SFXManager.cs b/GameCode/SFXManager.cs new file mode 100644 index 0000000..9c972e5 --- /dev/null +++ b/GameCode/SFXManager.cs @@ -0,0 +1,158 @@ +using System.Collections.Generic; +using UnityEngine; + +public class SFXManager : MonoBehaviour +{ + public float volume = 0.5f; + + [SerializeField] + private AudioClip ballistaClip; + + [SerializeField] + private AudioClip mortarClip; + + [SerializeField] + private AudioClip teslaClip; + + [SerializeField] + private AudioClip[] explosions; + + [SerializeField] + private AudioClip biPlaneGunClip; + + [SerializeField] + private AudioClip particleCannonClip; + + [SerializeField] + private AudioClip shredderClip; + + [SerializeField] + private AudioClip[] ballistaHits; + + [SerializeField] + private AudioClip frostHitClip; + + [SerializeField] + private AudioClip shredderHitClip; + + [SerializeField] + private AudioClip[] bulletHits; + + [SerializeField] + private AudioClip particleHitClip; + + [SerializeField] + private AudioClip[] coinLongClips; + + [SerializeField] + private AudioClip[] coinShortClips; + + [SerializeField] + private AudioClip buttonClick; + + [SerializeField] + private AudioClip[] critSmall; + + [SerializeField] + private AudioClip[] critBig; + + [SerializeField] + private AudioClip cards; + + [SerializeField] + private GameObject sourceObject; + + public List<AudioPoolSource> sources = new List<AudioPoolSource>(); + + public static SFXManager instance; + + private void Awake() + { + instance = this; + } + + private void Start() + { + volume = OptionsMenu.instance.masterVolume * OptionsMenu.instance.sfxVolume; + } + + public void ButtonClick() + { + PlaySound(Sound.ButtonClick, MusicManager.instance.transform.position, MusicManager.instance.transform); + } + + public void PlaySound(Sound s, Vector3 pos) + { + PlaySound(s, pos, null); + } + + public void PlaySound(Sound s, Vector3 pos, Transform parent) + { + if (!(volume <= 0f)) + { + AudioClip clip = GetClip(s); + AudioPoolSource audioPoolSource; + if (sources.Count < 1) + { + audioPoolSource = Object.Instantiate(sourceObject).GetComponent<AudioPoolSource>(); + } + else + { + audioPoolSource = sources[0]; + sources.Remove(audioPoolSource); + } + audioPoolSource.transform.position = pos; + audioPoolSource.PlayClip(clip, volume, 0.08333f); + if (parent != null) + { + audioPoolSource.transform.parent = parent; + } + } + } + + private AudioClip GetClip(Sound s) + { + switch (s) + { + case Sound.Ballista: + return ballistaClip; + case Sound.Mortar: + return mortarClip; + case Sound.TeslaZap: + return teslaClip; + case Sound.Explosion: + return explosions[Random.Range(0, explosions.Length)]; + case Sound.BiPlaneGun: + return biPlaneGunClip; + case Sound.ParticleCannon: + return particleCannonClip; + case Sound.Shredder: + return shredderClip; + case Sound.BallistaHit: + return ballistaHits[Random.Range(0, ballistaHits.Length)]; + case Sound.FrostHit: + return frostHitClip; + case Sound.ShredderHit: + return shredderHitClip; + case Sound.BulletHit: + return bulletHits[Random.Range(0, bulletHits.Length)]; + case Sound.ParticleHit: + return particleHitClip; + case Sound.CoinLong: + return coinLongClips[Random.Range(0, coinLongClips.Length)]; + case Sound.CoinShort: + return coinShortClips[Random.Range(0, coinShortClips.Length)]; + case Sound.ButtonClick: + return buttonClick; + case Sound.CritSmall: + return critSmall[Random.Range(0, critSmall.Length)]; + case Sound.CritBig: + return critBig[Random.Range(0, critBig.Length)]; + case Sound.Cards: + return cards; + default: + Debug.LogError("No Audio Clip Found Type " + s); + return null; + } + } +} diff --git a/GameCode/Sawblade.cs b/GameCode/Sawblade.cs new file mode 100644 index 0000000..19038df --- /dev/null +++ b/GameCode/Sawblade.cs @@ -0,0 +1,87 @@ +using System.Collections.Generic; +using UnityEngine; + +public class Sawblade : Projectile +{ + private Pathfinder targetPathfinder; + + private Waypoint nextWaypoint; + + private bool pathMode; + + private HashSet<Collider> targetsHit = new HashSet<Collider>(); + + public override void SetStats(TowerType whoShotMe, GameObject _target, float spd, int dmg, int healthDmg, int armorDmg, int shieldDmg, float slow, float bleed, float burn, float poison, float crit, float stun) + { + base.SetStats(whoShotMe, _target, spd, dmg, healthDmg, armorDmg, shieldDmg, slow, bleed, burn, poison, crit, stun); + targetPathfinder = target.GetComponent<Pathfinder>(); + nextWaypoint = targetPathfinder.currentWaypoint; + } + + protected override void AlterCourse() + { + if (!pathMode && targetPathfinder != null) + { + nextWaypoint = targetPathfinder.currentWaypoint; + } + if (!pathMode && (target == null || Vector3.SqrMagnitude(target.transform.position - base.transform.position) < 0.125f)) + { + nextWaypoint = GetPreviousWaypoint(); + pathMode = true; + } + Vector3 position; + if (!pathMode) + { + position = target.transform.position; + } + else + { + if (Vector3.SqrMagnitude(nextWaypoint.transform.position - base.transform.position) < 0.125f) + { + nextWaypoint = GetPreviousWaypoint(); + } + position = nextWaypoint.transform.position; + } + Quaternion rotation = Quaternion.LookRotation(position - base.transform.position, Vector3.up); + base.transform.rotation = rotation; + } + + protected override void CheckForHits() + { + Collider[] array = Physics.OverlapBox(base.transform.position, Vector3.one * 0.25f, Quaternion.identity, layermask, QueryTriggerInteraction.Collide); + foreach (Collider collider in array) + { + if (!pathMode && collider.gameObject == target) + { + nextWaypoint = GetPreviousWaypoint(); + pathMode = true; + } + if (targetsHit.Contains(collider)) + { + continue; + } + IDamageable component = collider.GetComponent<IDamageable>(); + if (component != null) + { + DealDamage(component); + damage--; + if (damage <= 0) + { + Object.Destroy(base.gameObject); + } + } + targetsHit.Add(collider); + } + } + + private Waypoint GetPreviousWaypoint() + { + Waypoint[] previousWaypoints = nextWaypoint.GetPreviousWaypoints(); + if (previousWaypoints.Length == 0) + { + Object.Destroy(base.gameObject); + return nextWaypoint; + } + return previousWaypoints[Random.Range(0, previousWaypoints.Length)]; + } +} diff --git a/GameCode/Shrine.cs b/GameCode/Shrine.cs new file mode 100644 index 0000000..bbdfd2d --- /dev/null +++ b/GameCode/Shrine.cs @@ -0,0 +1,11 @@ +public class Shrine : SpawnableObject +{ + protected override void Start() + { + base.Start(); + if (spawned) + { + AchievementManager.instance.shrineSpawned = true; + } + } +} diff --git a/GameCode/SimpleUI.cs b/GameCode/SimpleUI.cs new file mode 100644 index 0000000..ec51413 --- /dev/null +++ b/GameCode/SimpleUI.cs @@ -0,0 +1,51 @@ +using UnityEngine; +using UnityEngine.UI; + +public class SimpleUI : MonoBehaviour +{ + private GameObject demolishableObject; + + private int goldBackOnDemolish; + + [SerializeField] + private Text demolishText; + + [SerializeField] + private Text discriptionText; + + [SerializeField] + private GameObject demolishButton; + + private void Start() + { + UIManager.instance.SetNewUI(base.gameObject); + } + + public void SetDemolishable(GameObject obj, int goldReturned) + { + demolishableObject = obj; + goldBackOnDemolish = goldReturned; + demolishButton.SetActive(value: true); + if (demolishText != null) + { + demolishText.text = "Demolish (" + goldBackOnDemolish + "g)"; + } + } + + public void Demolish() + { + demolishableObject.GetComponent<IBuildable>()?.Demolish(); + Object.Destroy(demolishableObject); + ResourceManager.instance.AddMoney(goldBackOnDemolish); + SFXManager.instance.ButtonClick(); + UIManager.instance.CloseUI(base.gameObject); + } + + public void SetDiscriptionText(string txt) + { + if (discriptionText != null) + { + discriptionText.text = txt; + } + } +} diff --git a/GameCode/SlowRotate.cs b/GameCode/SlowRotate.cs new file mode 100644 index 0000000..7a0306a --- /dev/null +++ b/GameCode/SlowRotate.cs @@ -0,0 +1,12 @@ +using UnityEngine; + +public class SlowRotate : MonoBehaviour +{ + [SerializeField] + private Vector3 rotation; + + private void Update() + { + base.transform.localEulerAngles += rotation * Time.deltaTime; + } +} diff --git a/GameCode/SnowFlake.cs b/GameCode/SnowFlake.cs new file mode 100644 index 0000000..238b829 --- /dev/null +++ b/GameCode/SnowFlake.cs @@ -0,0 +1,23 @@ +using UnityEngine; + +public class SnowFlake : Projectile +{ + protected override void Start() + { + base.Start(); + base.transform.Translate(new Vector3(Random.Range(-0.25f, 0.25f), Random.Range(-0.25f, 0.25f), Random.Range(-0.25f, 0.25f))); + } + + protected override void MoveProjectile() + { + base.transform.Translate(Vector3.down * speed * Time.fixedDeltaTime); + } + + protected override void CheckForHits() + { + if (Physics.SphereCast(base.transform.position, 0.125f, Vector3.down, out var hitInfo, speed * Time.fixedDeltaTime, layermask, QueryTriggerInteraction.Collide)) + { + OnHit(hitInfo); + } + } +} diff --git a/GameCode/SocialMediaManager.cs b/GameCode/SocialMediaManager.cs new file mode 100644 index 0000000..25f761f --- /dev/null +++ b/GameCode/SocialMediaManager.cs @@ -0,0 +1,9 @@ +using UnityEngine; + +public class SocialMediaManager : MonoBehaviour +{ + public void OpenLink(string s) + { + Application.OpenURL(s); + } +} diff --git a/GameCode/Sound.cs b/GameCode/Sound.cs new file mode 100644 index 0000000..8a1528f --- /dev/null +++ b/GameCode/Sound.cs @@ -0,0 +1,22 @@ +public enum Sound +{ + None, + Ballista, + Mortar, + TeslaZap, + Explosion, + BiPlaneGun, + ParticleCannon, + Shredder, + BallistaHit, + FrostHit, + ShredderHit, + BulletHit, + ParticleHit, + CoinLong, + CoinShort, + ButtonClick, + CritSmall, + CritBig, + Cards +} diff --git a/GameCode/SpawnManager.cs b/GameCode/SpawnManager.cs new file mode 100644 index 0000000..4e66c04 --- /dev/null +++ b/GameCode/SpawnManager.cs @@ -0,0 +1,495 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.UI; + +public class SpawnManager : MonoBehaviour +{ + public static SpawnManager instance; + + public Waypoint[] initialSpawns; + + private HashSet<Waypoint> spawnPoints = new HashSet<Waypoint>(); + + public HashSet<IncomeGenerator> incomeGenerators = new HashSet<IncomeGenerator>(); + + public HashSet<University> universities = new HashSet<University>(); + + public HashSet<Mine> mines = new HashSet<Mine>(); + + public HashSet<House> houses = new HashSet<House>(); + + public HashSet<GameObject> destroyOnNewLevel = new HashSet<GameObject>(); + + public HashSet<GameObject> tileSpawnUis = new HashSet<GameObject>(); + + public HashSet<Enemy> currentEnemies = new HashSet<Enemy>(); + + public bool combat; + + private float levelTime; + + [SerializeField] + private Text levelText; + + [SerializeField] + private Text scoreText; + + [SerializeField] + private int cardDrawFrequency = 5; + + [SerializeField] + private float baseRepairChance; + + public int level; + + public int lastLevel = 30; + + [SerializeField] + private GameObject level1Enemy; + + [SerializeField] + private GameObject level3Enemy; + + [SerializeField] + private GameObject level5Enemy; + + [SerializeField] + private GameObject level7Enemy; + + [SerializeField] + private GameObject level9Enemy; + + [SerializeField] + private GameObject level12Enemy; + + [SerializeField] + private GameObject level16Enemy; + + [SerializeField] + private GameObject level18Enemy; + + [SerializeField] + private GameObject level20Enemy; + + [SerializeField] + private GameObject level21Enemy; + + [SerializeField] + private GameObject level23Enemy; + + [SerializeField] + private GameObject level26Enemy; + + [SerializeField] + private GameObject level28Enemy; + + [SerializeField] + private GameObject level30Enemy; + + [SerializeField] + private GameObject level32Enemy; + + [SerializeField] + private GameObject level36Enemy; + + [SerializeField] + private GameObject level38Enemy; + + [SerializeField] + private GameObject level40Enemy; + + [SerializeField] + private GameObject level15Boss; + + [SerializeField] + private GameObject level25Boss; + + [SerializeField] + private GameObject level35Boss; + + [SerializeField] + private GameObject level45Boss; + + [SerializeField] + private LightManager lightManager; + + [SerializeField] + private int secondStageLightLevel; + + [SerializeField] + private int thirdStageLightLevel; + + [SerializeField] + private int fourthStageLightLevel; + + private void Awake() + { + instance = this; + } + + private void Start() + { + Waypoint[] array = initialSpawns; + foreach (Waypoint item in array) + { + spawnPoints.Add(item); + } + levelText.text = "Level: " + level; + scoreText.text = "Score: " + 0; + cardDrawFrequency = 3 - PlayerPrefs.GetInt("CardFreq1", 0) - PlayerPrefs.GetInt("CardFreq2", 0); + baseRepairChance = 34f * (float)(PlayerPrefs.GetInt("TowerRepair1", 0) + PlayerPrefs.GetInt("TowerRepair2", 0) + PlayerPrefs.GetInt("TowerRepair3", 0)); + } + + private void Update() + { + if (combat && currentEnemies.Count == 0 && !GameManager.instance.gameOver && levelTime > 2f) + { + EndWave(); + } + else + { + levelTime += Time.deltaTime; + } + } + + private void EndWave() + { + combat = false; + AchievementManager.instance.BeatLevel(level); + int @int = PlayerPrefs.GetInt("XP", 0); + PlayerPrefs.SetInt("XP", @int + level * GameManager.instance.gameMode); + scoreText.text = "Score: " + GameManager.instance.NaturalSum(level) * GameManager.instance.gameMode; + if (level >= lastLevel) + { + GameManager.instance.Victory(); + return; + } + ShowSpawnUIs(state: true); + if (level % cardDrawFrequency == 0) + { + ShowSpawnUIs(state: false); + CardManager.instance.DrawCards(); + } + if (level == 15 || level == 25 || level == 35) + { + MusicManager.instance.FadeOut(6f); + } + else + { + MusicManager.instance.SetIntensity(action: false); + } + GameObject[] array = new GameObject[destroyOnNewLevel.Count]; + destroyOnNewLevel.CopyTo(array); + GameObject[] array2 = array; + foreach (GameObject gameObject in array2) + { + destroyOnNewLevel.Remove(gameObject); + Object.Destroy(gameObject); + } + if (tileSpawnUis.Count == 0) + { + Debug.Log("I GUESS ILL JUST DIE THEN"); + AchievementManager.instance.UnlockAchievement("NoMorePaths"); + StartNextWave(); + } + } + + public void StartNextWave() + { + levelTime = 0f; + UpdateSpawnPoints(); + float num = 1f - (float)(GameManager.instance.health / GameManager.instance.maxHealth); + if (Random.Range(1f, 100f) <= baseRepairChance * num) + { + GameManager.instance.RepairTower(10); + } + level++; + levelText.text = "Level: " + level; + if (level == secondStageLightLevel) + { + lightManager.ChangeColor(2); + } + else if (level == thirdStageLightLevel) + { + lightManager.ChangeColor(3); + } + else if (level == fourthStageLightLevel) + { + lightManager.ChangeColor(4); + } + if (level == 15 || level == 25 || level == 35 || level == 45) + { + SpawnBoss(level); + } + if (level == 16) + { + MusicManager.instance.PlaySong(1, action: true); + } + else if (level == 26) + { + MusicManager.instance.PlaySong(2, action: true); + } + else if (level == 36) + { + MusicManager.instance.PlaySong(3, action: true); + } + else if (level > 1) + { + MusicManager.instance.SetIntensity(action: true); + } + StartCoroutine(Spawn(level * level)); + combat = true; + ShowSpawnUIs(state: false); + foreach (House house in houses) + { + if (house != null) + { + house.CheckTowers(); + } + } + foreach (IncomeGenerator incomeGenerator in incomeGenerators) + { + if (incomeGenerator != null) + { + incomeGenerator.GenerateIncome(); + } + } + foreach (University university in universities) + { + if (university != null) + { + university.Research(); + } + } + foreach (Mine mine in mines) + { + if (mine != null) + { + mine.Repair(); + } + } + } + + public void ShowSpawnUIs(bool state) + { + foreach (GameObject tileSpawnUi in tileSpawnUis) + { + tileSpawnUi.SetActive(state); + } + } + + private void SpawnBoss(int lvl) + { + Waypoint spawnLocation = null; + float num = -1f; + foreach (Waypoint spawnPoint in spawnPoints) + { + if (spawnPoint.distanceFromEnd > num) + { + num = spawnPoint.distanceFromEnd; + spawnLocation = spawnPoint; + } + } + switch (lvl) + { + case 15: + SpawnEnemy(level15Boss, spawnLocation); + break; + case 25: + SpawnEnemy(level25Boss, spawnLocation); + break; + case 35: + SpawnEnemy(level35Boss, spawnLocation); + break; + case 45: + SpawnEnemy(level45Boss, spawnLocation); + break; + } + } + + private IEnumerator Spawn(int num) + { + int safetyCount = level * level + 100; + int count = num; + float t = 0.5f / (float)spawnPoints.Count; + while (count > 0) + { + foreach (Waypoint spawnPoint in spawnPoints) + { + if (count <= 0) + { + break; + } + count -= SpawnSelection(spawnPoint); + yield return new WaitForSeconds(t); + } + safetyCount--; + if (safetyCount <= 0) + { + Debug.LogError("Spawn loop might be looping infinitely"); + break; + } + } + } + + private int SpawnSelection(Waypoint spawnPoint) + { + if (level >= 40 && Random.Range(1f, 100f) < 10f) + { + SpawnEnemy(level40Enemy, spawnPoint); + return 10; + } + if (level >= 38 && Random.Range(1f, 100f) < 10f) + { + SpawnEnemy(level38Enemy, spawnPoint); + return 10; + } + if (level >= 36 && Random.Range(1f, 100f) < 12f) + { + SpawnEnemy(level36Enemy, spawnPoint); + return 9; + } + if (level >= 32 && Random.Range(1f, 100f) < 10f) + { + SpawnEnemy(level32Enemy, spawnPoint); + return 10; + } + if (level >= 30 && Random.Range(1f, 100f) < 10f) + { + SpawnEnemy(level30Enemy, spawnPoint); + return 10; + } + if (level >= 28 && Random.Range(1f, 100f) < 11f) + { + SpawnEnemy(level28Enemy, spawnPoint); + return 10; + } + if (level >= 26 && Random.Range(1f, 100f) < 12f) + { + SpawnEnemy(level26Enemy, spawnPoint); + return 7; + } + if (level >= 23 && Random.Range(1f, 100f) < 9f) + { + SpawnEnemy(level23Enemy, spawnPoint); + return 12; + } + if (level >= 21 && Random.Range(1f, 100f) < 10f) + { + SpawnEnemy(level21Enemy, spawnPoint); + return 10; + } + if (level >= 20 && Random.Range(1f, 100f) < 10f) + { + SpawnEnemy(level20Enemy, spawnPoint); + return 10; + } + if (level >= 18 && Random.Range(1f, 100f) < 12f) + { + SpawnEnemy(level18Enemy, spawnPoint); + return 9; + } + if (level >= 16 && Random.Range(1f, 100f) < 13f) + { + SpawnEnemy(level16Enemy, spawnPoint); + return 8; + } + if (level >= 12 && Random.Range(1f, 100f) < 9f) + { + SpawnEnemy(level12Enemy, spawnPoint); + return 12; + } + if (level >= 9 && Random.Range(1f, 100f) < 12f) + { + SpawnEnemy(level9Enemy, spawnPoint); + return 9; + } + if (level >= 7 && Random.Range(1f, 100f) < 14f) + { + SpawnEnemy(level7Enemy, spawnPoint); + return 7; + } + if (level >= 5 && Random.Range(1f, 100f) < 20f) + { + SpawnEnemy(level5Enemy, spawnPoint); + return 5; + } + if (level >= 3 && Random.Range(1f, 100f) < 34f) + { + SpawnEnemy(level3Enemy, spawnPoint); + return 3; + } + SpawnEnemy(level1Enemy, spawnPoint); + return 1; + } + + private void SpawnEnemy(GameObject unit, Waypoint spawnLocation) + { + Enemy component = Object.Instantiate(unit, spawnLocation.transform.position, Quaternion.identity).GetComponent<Enemy>(); + component.SetStats(); + component.SetFirstSpawnPoint(spawnLocation); + currentEnemies.Add(component); + } + + private void UpdateSpawnPoints() + { + List<Waypoint> list = new List<Waypoint>(); + List<Waypoint> list2 = new List<Waypoint>(); + foreach (Waypoint spawnPoint in spawnPoints) + { + if (!CheckSpawnPoint(spawnPoint)) + { + continue; + } + list.Add(spawnPoint); + foreach (Waypoint newSpawnPoint in GetNewSpawnPoints(spawnPoint, 1)) + { + list2.Add(newSpawnPoint); + } + } + foreach (Waypoint item in list) + { + spawnPoints.Remove(item); + } + foreach (Waypoint item2 in list2) + { + spawnPoints.Add(item2); + } + } + + private bool CheckSpawnPoint(Waypoint point) + { + if (point.GetPreviousWaypoints().Length != 0) + { + return true; + } + return false; + } + + private List<Waypoint> GetNewSpawnPoints(Waypoint start, int count) + { + if (count > 100) + { + Debug.LogError("Possible infinite loop while finding new spawn points (count over 100)"); + return null; + } + Waypoint[] previousWaypoints = start.GetPreviousWaypoints(); + List<Waypoint> list = new List<Waypoint>(); + if (previousWaypoints.Length == 0) + { + list.Add(start); + return list; + } + count++; + Waypoint[] array = previousWaypoints; + foreach (Waypoint start2 in array) + { + foreach (Waypoint newSpawnPoint in GetNewSpawnPoints(start2, count)) + { + list.Add(newSpawnPoint); + } + } + return list; + } +} diff --git a/GameCode/SpawnableObject.cs b/GameCode/SpawnableObject.cs new file mode 100644 index 0000000..fd7b169 --- /dev/null +++ b/GameCode/SpawnableObject.cs @@ -0,0 +1,54 @@ +using UnityEngine; + +public class SpawnableObject : MonoBehaviour, IBuildable +{ + [SerializeField] + private GameObject artStuff; + + [SerializeField] + private bool randomRotation = true; + + [SerializeField] + private float spawnChance; + + [SerializeField] + private Vector2 spawnLevels; + + [SerializeField] + protected GameObject UIObject; + + protected bool spawned; + + protected virtual void Start() + { + if ((float)SpawnManager.instance.level >= spawnLevels.x && (float)SpawnManager.instance.level <= spawnLevels.y && Random.Range(1f, 100f) < 100f * spawnChance) + { + if (randomRotation) + { + artStuff.transform.eulerAngles = new Vector3(0f, Random.Range(0, 4) * 90, 0f); + } + artStuff.SetActive(value: true); + spawned = true; + } + else + { + Object.Destroy(base.gameObject); + } + } + + public void SetStats() + { + } + + public virtual void SpawnUI() + { + if (UIObject != null) + { + Object.Instantiate(UIObject, base.transform.position, Quaternion.identity); + } + } + + public void Demolish() + { + } +} diff --git a/GameCode/SteamManager.cs b/GameCode/SteamManager.cs new file mode 100644 index 0000000..642003a --- /dev/null +++ b/GameCode/SteamManager.cs @@ -0,0 +1,123 @@ +using System; +using System.Text; +using AOT; +using Steamworks; +using UnityEngine; + +[DisallowMultipleComponent] +public class SteamManager : MonoBehaviour +{ + protected static bool s_EverInitialized; + + protected static SteamManager s_instance; + + protected bool m_bInitialized; + + protected SteamAPIWarningMessageHook_t m_SteamAPIWarningMessageHook; + + protected static SteamManager Instance + { + get + { + if (s_instance == null) + { + return new GameObject("SteamManager").AddComponent<SteamManager>(); + } + return s_instance; + } + } + + public static bool Initialized => Instance.m_bInitialized; + + [MonoPInvokeCallback(typeof(SteamAPIWarningMessageHook_t))] + protected static void SteamAPIDebugTextHook(int nSeverity, StringBuilder pchDebugText) + { + Debug.LogWarning(pchDebugText); + } + + [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)] + private static void InitOnPlayMode() + { + s_EverInitialized = false; + s_instance = null; + } + + protected virtual void Awake() + { + if (s_instance != null) + { + UnityEngine.Object.Destroy(base.gameObject); + return; + } + s_instance = this; + if (s_EverInitialized) + { + throw new Exception("Tried to Initialize the SteamAPI twice in one session!"); + } + UnityEngine.Object.DontDestroyOnLoad(base.gameObject); + if (!Packsize.Test()) + { + Debug.LogError("[Steamworks.NET] Packsize Test returned false, the wrong version of Steamworks.NET is being run in this platform.", this); + } + if (!DllCheck.Test()) + { + Debug.LogError("[Steamworks.NET] DllCheck Test returned false, One or more of the Steamworks binaries seems to be the wrong version.", this); + } + try + { + if (SteamAPI.RestartAppIfNecessary((AppId_t)1843760u)) + { + Application.Quit(); + return; + } + } + catch (DllNotFoundException ex) + { + Debug.LogError("[Steamworks.NET] Could not load [lib]steam_api.dll/so/dylib. It's likely not in the correct location. Refer to the README for more details.\n" + ex, this); + Application.Quit(); + return; + } + m_bInitialized = SteamAPI.Init(); + if (!m_bInitialized) + { + Debug.LogError("[Steamworks.NET] SteamAPI_Init() failed. Refer to Valve's documentation or the comment above this line for more information.", this); + } + else + { + s_EverInitialized = true; + } + } + + protected virtual void OnEnable() + { + if (s_instance == null) + { + s_instance = this; + } + if (m_bInitialized && m_SteamAPIWarningMessageHook == null) + { + m_SteamAPIWarningMessageHook = SteamAPIDebugTextHook; + SteamClient.SetWarningMessageHook(m_SteamAPIWarningMessageHook); + } + } + + protected virtual void OnDestroy() + { + if (!(s_instance != this)) + { + s_instance = null; + if (m_bInitialized) + { + SteamAPI.Shutdown(); + } + } + } + + protected virtual void Update() + { + if (m_bInitialized) + { + SteamAPI.RunCallbacks(); + } + } +} diff --git a/GameCode/TerrainTile.cs b/GameCode/TerrainTile.cs new file mode 100644 index 0000000..932ff37 --- /dev/null +++ b/GameCode/TerrainTile.cs @@ -0,0 +1,87 @@ +using UnityEngine; + +public class TerrainTile : MonoBehaviour +{ + public Waypoint last; + + [SerializeField] + private Waypoint left; + + [SerializeField] + private Waypoint top; + + [SerializeField] + private Waypoint right; + + public Waypoint south; + + public Waypoint west; + + public Waypoint north; + + public Waypoint east; + + public void SetCardinalDirections() + { + if (base.transform.eulerAngles.y == 0f) + { + south = last; + west = left; + north = top; + east = right; + } + else if (base.transform.eulerAngles.y == 90f) + { + south = right; + west = last; + north = left; + east = top; + } + else if (base.transform.eulerAngles.y == 180f) + { + south = top; + west = right; + north = last; + east = left; + } + else if (base.transform.eulerAngles.y == 270f) + { + south = left; + west = top; + north = right; + east = last; + } + else + { + Debug.LogError(base.name + " not at a proper rotation. Current rotation: " + base.transform.eulerAngles.y); + } + } + + public void ConnectToTile(TerrainTile next) + { + if (base.transform.eulerAngles.y == 0f) + { + last.SetNextWaypoint(next.north); + next.north.AddPreviousWaypoint(last); + } + else if (base.transform.eulerAngles.y == 90f) + { + last.SetNextWaypoint(next.east); + next.east.AddPreviousWaypoint(last); + } + else if (base.transform.eulerAngles.y == 180f) + { + last.SetNextWaypoint(next.south); + next.south.AddPreviousWaypoint(last); + } + else if (base.transform.eulerAngles.y == 270f) + { + last.SetNextWaypoint(next.west); + next.west.AddPreviousWaypoint(last); + } + else + { + Debug.LogError(base.name + " not at a proper rotation"); + } + } +} diff --git a/GameCode/TeslaCoil.cs b/GameCode/TeslaCoil.cs new file mode 100644 index 0000000..97954e7 --- /dev/null +++ b/GameCode/TeslaCoil.cs @@ -0,0 +1,45 @@ +using System; +using System.Collections; +using UnityEngine; + +public class TeslaCoil : Tower +{ + [SerializeField] + private GameObject lightningTrail; + + protected override void AimTurret() + { + } + + protected override void Fire() + { + if (consumesMana) + { + int manaCost = (int)((float)base.damage * manaConsumptionRate); + if (!ResourceManager.instance.CheckMana(manaCost)) + { + return; + } + ResourceManager.instance.SpendMana(manaCost); + } + Vector3 position = base.transform.position; + position.y = 0f; + Collider[] array = Physics.OverlapSphere(position, base.range, enemyLayerMask, QueryTriggerInteraction.Collide); + for (int i = 0; i < array.Length; i++) + { + array[i].GetComponent<IDamageable>()?.TakeDamage(towerType, base.damage, base.healthDamage, base.armorDamage, base.shieldDamage, base.slowPercent, base.bleedPercent, base.burnPercent, base.poisonPercent, base.critChance, base.stunChance); + } + SFXManager.instance.PlaySound(Sound.TeslaZap, base.transform.position); + StartCoroutine(DrawLightning()); + } + + private IEnumerator DrawLightning() + { + for (float i = 0f; i <= (float)Math.PI * 2f; i += 0.5f) + { + Vector3 vector = new Vector3(UnityEngine.Random.Range(-0.5f, 0.5f), UnityEngine.Random.Range(-0.5f, 0.5f), UnityEngine.Random.Range(-0.5f, 0.5f)); + lightningTrail.transform.position = vector + new Vector3(base.transform.position.x + Mathf.Sin(i) * base.range, 0.75f, base.transform.position.z + Mathf.Cos(i) * base.range); + yield return new WaitForEndOfFrame(); + } + } +} diff --git a/GameCode/TileManager.cs b/GameCode/TileManager.cs new file mode 100644 index 0000000..592d861 --- /dev/null +++ b/GameCode/TileManager.cs @@ -0,0 +1,236 @@ +using System.Collections.Generic; +using UnityEngine; + +public class TileManager : MonoBehaviour +{ + public static TileManager instance; + + [SerializeField] + private GameObject tilePlacementFXObject; + + [SerializeField] + private GameObject[] deadEndTiles; + + [SerializeField] + private GameObject[] Ltiles; + + [SerializeField] + private GameObject[] Ttiles; + + [SerializeField] + private GameObject[] Rtiles; + + [SerializeField] + private GameObject[] LTtiles; + + [SerializeField] + private GameObject[] LRtiles; + + [SerializeField] + private GameObject[] TRtiles; + + [SerializeField] + private GameObject[] LTRtiles; + + public TerrainTile startTile; + + [SerializeField] + private GameObject tileSpawnLocation; + + private int[,] intArray = new int[99, 99]; + + private TerrainTile[,] tileArray = new TerrainTile[99, 99]; + + private void Awake() + { + instance = this; + } + + private void Start() + { + intArray[50, 50] = 1; + tileArray[50, 50] = startTile; + for (int i = 0; i < 99; i++) + { + intArray[0, i] = 1; + intArray[i, 0] = 1; + intArray[98, i] = 1; + intArray[i, 98] = 1; + } + UpdateIntArrayFromTile(startTile, 50, 50); + } + + private void UpdateIntArrayFromTile(TerrainTile tile, int posX, int posY) + { + if (tile.south != null && tile.south != tile.last && intArray[posX, posY - 1] == 0) + { + intArray[posX, posY - 1] = 2; + TileSpawnLocation component = Object.Instantiate(tileSpawnLocation, new Vector3(posX - 50, 0f, posY - 1 - 50) * 7f, Quaternion.identity).GetComponent<TileSpawnLocation>(); + component.eulerAngle = 180; + component.posX = posX; + component.posY = posY - 1; + } + if (tile.west != null && tile.west != tile.last && intArray[posX - 1, posY] == 0) + { + intArray[posX - 1, posY] = 2; + TileSpawnLocation component2 = Object.Instantiate(tileSpawnLocation, new Vector3(posX - 1 - 50, 0f, posY - 50) * 7f, Quaternion.identity).GetComponent<TileSpawnLocation>(); + component2.eulerAngle = 270; + component2.posX = posX - 1; + component2.posY = posY; + } + if (tile.north != null && tile.north != tile.last && intArray[posX, posY + 1] == 0) + { + intArray[posX, posY + 1] = 2; + TileSpawnLocation component3 = Object.Instantiate(tileSpawnLocation, new Vector3(posX - 50, 0f, posY + 1 - 50) * 7f, Quaternion.identity).GetComponent<TileSpawnLocation>(); + component3.eulerAngle = 0; + component3.posX = posX; + component3.posY = posY + 1; + } + if (tile.east != null && tile.east != tile.last && intArray[posX + 1, posY] == 0) + { + intArray[posX + 1, posY] = 2; + TileSpawnLocation component4 = Object.Instantiate(tileSpawnLocation, new Vector3(posX + 1 - 50, 0f, posY - 50) * 7f, Quaternion.identity).GetComponent<TileSpawnLocation>(); + component4.eulerAngle = 90; + component4.posX = posX + 1; + component4.posY = posY; + } + } + + public void SpawnNewTile(int posX, int posY, int eulerAngle) + { + bool flag = false; + bool flag2 = false; + bool flag3 = false; + bool flag4 = false; + if (intArray[posX, posY - 1] == 0) + { + flag = true; + } + if (intArray[posX - 1, posY] == 0) + { + flag2 = true; + } + if (intArray[posX, posY + 1] == 0) + { + flag3 = true; + } + if (intArray[posX + 1, posY] == 0) + { + flag4 = true; + } + bool flag5 = false; + bool flag6 = false; + bool flag7 = false; + switch (eulerAngle) + { + case 0: + flag5 = flag2; + flag6 = flag3; + flag7 = flag4; + break; + case 90: + flag5 = flag3; + flag6 = flag4; + flag7 = flag; + break; + case 180: + flag5 = flag4; + flag6 = flag; + flag7 = flag2; + break; + case 270: + flag5 = flag; + flag6 = flag2; + flag7 = flag3; + break; + default: + Debug.LogError("Trying to spawn a tile at an invalid eulerAngle" + eulerAngle); + break; + } + List<GameObject> list = new List<GameObject>(); + int num = SpawnManager.instance.lastLevel - SpawnManager.instance.level; + int count = SpawnManager.instance.tileSpawnUis.Count; + bool flag8 = false; + bool flag9 = false; + if (count + 3 >= num || SpawnManager.instance.level < 3) + { + flag8 = true; + } + if (count == num) + { + flag9 = true; + } + if (!flag9) + { + if (flag5) + { + list.AddRange(Ltiles); + } + if (flag6) + { + list.AddRange(Ttiles); + } + if (flag7) + { + list.AddRange(Rtiles); + } + if (flag5 && flag6 && !flag8) + { + list.AddRange(LTtiles); + } + if (flag5 && flag7 && !flag8) + { + list.AddRange(LRtiles); + } + if (flag6 && flag7 && !flag8) + { + list.AddRange(TRtiles); + } + if (flag5 && flag6 && flag7 && !flag8) + { + list.AddRange(LTRtiles); + } + } + if (list.Count == 0) + { + list.AddRange(deadEndTiles); + } + GameObject original = list[Random.Range(0, list.Count)]; + Vector3 vector = new Vector3(posX - 50, 0f, posY - 50) * 7f; + GameObject obj = Object.Instantiate(original, vector, Quaternion.identity); + obj.transform.eulerAngles = new Vector3(0f, eulerAngle, 0f); + intArray[posX, posY] = 1; + TerrainTile component = obj.GetComponent<TerrainTile>(); + tileArray[posX, posY] = component; + component.SetCardinalDirections(); + UpdateIntArrayFromTile(component, posX, posY); + TerrainTile terrainTile = null; + switch (eulerAngle) + { + case 0: + terrainTile = tileArray[posX, posY - 1]; + break; + case 90: + terrainTile = tileArray[posX - 1, posY]; + break; + case 180: + terrainTile = tileArray[posX, posY + 1]; + break; + case 270: + terrainTile = tileArray[posX + 1, posY]; + break; + default: + Debug.LogError("Trying to spawn a tile at an invalid eulerAngle" + eulerAngle); + break; + } + if (terrainTile == null) + { + Debug.LogError("Unable to find previous tile"); + } + component.ConnectToTile(terrainTile); + if (tilePlacementFXObject != null) + { + Object.Instantiate(tilePlacementFXObject, vector + Vector3.up, Quaternion.identity).transform.localScale = Vector3.one * 7f; + } + } +} diff --git a/GameCode/TileSpawnLocation.cs b/GameCode/TileSpawnLocation.cs new file mode 100644 index 0000000..e1575b1 --- /dev/null +++ b/GameCode/TileSpawnLocation.cs @@ -0,0 +1,27 @@ +using UnityEngine; + +public class TileSpawnLocation : MonoBehaviour +{ + public int eulerAngle; + + public int posX; + + public int posY; + + private void Start() + { + SpawnManager.instance.tileSpawnUis.Add(base.gameObject); + if (SpawnManager.instance.combat) + { + base.gameObject.SetActive(value: false); + } + } + + public void SpawnTile() + { + TileManager.instance.SpawnNewTile(posX, posY, eulerAngle); + SpawnManager.instance.tileSpawnUis.Remove(base.gameObject); + SpawnManager.instance.StartNextWave(); + Object.Destroy(base.gameObject); + } +} diff --git a/GameCode/Tower.cs b/GameCode/Tower.cs new file mode 100644 index 0000000..4098bd6 --- /dev/null +++ b/GameCode/Tower.cs @@ -0,0 +1,509 @@ +using UnityEngine; + +public class Tower : MonoBehaviour, IBuildable +{ + public enum Priority + { + Progress, + NearDeath, + MostHealth, + MostArmor, + MostShield, + LeastHealth, + LeastArmor, + LeastShield, + Fastest, + Slowest, + Marked + } + + public TowerType towerType; + + public bool squareUI; + + [SerializeField] + protected GameObject towerUI; + + public Priority[] priorities = new Priority[3]; + + [SerializeField] + protected GameObject turret; + + [SerializeField] + protected bool towerVerticalyAims = true; + + [SerializeField] + protected Transform muzzle; + + [SerializeField] + protected GameObject projectile; + + [SerializeField] + protected float projectileSpeed = 10f; + + [SerializeField] + protected GameObject extraProjectileFX; + + [SerializeField] + protected int baseDamage; + + [SerializeField] + protected int baseHealthDamage; + + [SerializeField] + protected int baseArmorDamage; + + [SerializeField] + protected int baseShieldDamage; + + public float rpm; + + protected float rps; + + [SerializeField] + protected float baseRange; + + [SerializeField] + protected float baseSlowPercentage; + + [SerializeField] + protected float baseBleedPercentage; + + [SerializeField] + protected float baseBurnPercentage; + + [SerializeField] + protected float basePoisonPercentage; + + [SerializeField] + protected LayerMask enemyLayerMask; + + [SerializeField] + protected LayerMask buildingLayerMask; + + public bool consumesMana; + + public float manaConsumptionRate; + + public float finalManaConsumption; + + public int upgradeCostMultiplier = 1; + + private int damageUpgrade; + + private int healthDamageUpgrade; + + private int armorDamageUpgrade; + + private int shieldDamageUpgrade; + + private int heightBonus; + + protected float timeSinceLastShot; + + private float lastTargetUpdate = 1f; + + protected GameObject currentTarget; + + [SerializeField] + protected float baseBlastRadius; + + public int level { get; private set; } + + public float healthXP { get; private set; } + + public float armorXP { get; private set; } + + public float shieldXP { get; private set; } + + public int damage { get; private set; } + + public int healthDamage { get; private set; } + + public int armorDamage { get; private set; } + + public int shieldDamage { get; private set; } + + public float range { get; private set; } + + public float slowPercent { get; private set; } + + public float bleedPercent { get; private set; } + + public float burnPercent { get; private set; } + + public float poisonPercent { get; private set; } + + public float critChance { get; private set; } + + public float stunChance { get; private set; } + + public float blastRadius { get; private set; } + + protected virtual void Start() + { + level = 1; + SetStats(); + TowerManager.instance.AddNewTower(this, towerType); + DetectHouses(); + priorities[0] = (priorities[1] = (priorities[2] = Priority.Progress)); + } + + public virtual void SetStats() + { + heightBonus = (int)Mathf.Round(base.transform.position.y * 3f - 1f); + damage = Mathf.Max(baseDamage + heightBonus + damageUpgrade + TowerManager.instance.GetBonusBaseDamage(towerType), 0); + healthDamage = baseHealthDamage + healthDamageUpgrade + TowerManager.instance.GetBonusHealthDamage(towerType); + armorDamage = baseArmorDamage + armorDamageUpgrade + TowerManager.instance.GetBonusArmorDamage(towerType); + shieldDamage = baseShieldDamage + shieldDamageUpgrade + TowerManager.instance.GetBonusShieldDamage(towerType); + rps = 60f / rpm; + range = baseRange + (float)heightBonus / 2f + TowerManager.instance.GetBonusRange(towerType); + slowPercent = baseSlowPercentage + TowerManager.instance.GetBonusSlow(towerType); + bleedPercent = baseBleedPercentage + TowerManager.instance.GetBonusBleed(towerType); + burnPercent = baseBurnPercentage + TowerManager.instance.GetBonusBurn(towerType); + poisonPercent = basePoisonPercentage + TowerManager.instance.GetBonusPoison(towerType); + blastRadius = baseBlastRadius + TowerManager.instance.GetBonusBlast(towerType); + finalManaConsumption = manaConsumptionRate + TowerManager.instance.GetManaConsumptionBonus(towerType); + if (TowerManager.instance.GetManaConsumptionBonus(towerType) > 0f) + { + consumesMana = true; + } + critChance = TowerManager.instance.GetCritChance(towerType) + TowerManager.instance.GetCritChanceLevelMultiplier(towerType) * (float)level / 100f; + stunChance = TowerManager.instance.GetStunChance(towerType); + } + + private void FixedUpdate() + { + if (lastTargetUpdate <= 0f) + { + DetectEnemies(); + } + else + { + lastTargetUpdate -= Time.fixedDeltaTime; + } + } + + protected virtual void Update() + { + if (currentTarget != null) + { + if (turret != null) + { + AimTurret(); + } + GainXP(); + } + timeSinceLastShot += Time.deltaTime; + if (currentTarget != null && timeSinceLastShot > rps) + { + Fire(); + timeSinceLastShot = 0f; + } + } + + private void DetectHouses() + { + if (Physics.Raycast(base.transform.position + new Vector3(1f, 1f, 0f), -base.transform.up, out var hitInfo, 1f, buildingLayerMask, QueryTriggerInteraction.Ignore)) + { + CheckForHouse(hitInfo); + } + if (Physics.Raycast(base.transform.position + new Vector3(-1f, 1f, 0f), -base.transform.up, out hitInfo, 1f, buildingLayerMask, QueryTriggerInteraction.Ignore)) + { + CheckForHouse(hitInfo); + } + if (Physics.Raycast(base.transform.position + new Vector3(0f, 1f, 1f), -base.transform.up, out hitInfo, 1f, buildingLayerMask, QueryTriggerInteraction.Ignore)) + { + CheckForHouse(hitInfo); + } + if (Physics.Raycast(base.transform.position + new Vector3(0f, 1f, -1f), -base.transform.up, out hitInfo, 1f, buildingLayerMask, QueryTriggerInteraction.Ignore)) + { + CheckForHouse(hitInfo); + } + } + + private void CheckForHouse(RaycastHit hit) + { + if (hit.collider.GetComponent<House>() != null && (double)Mathf.Abs(hit.collider.transform.position.y - base.transform.position.y) <= 0.001) + { + hit.collider.GetComponent<House>().AddDefender(this); + } + } + + public void TogglePriority(int index, int direction) + { + priorities[index] = (Priority)(((int)(priorities[index] + direction) % 11 + 11) % 11); + } + + protected virtual void Fire() + { + if (consumesMana) + { + int manaCost = (int)((float)damage * finalManaConsumption); + if (!ResourceManager.instance.CheckMana(manaCost)) + { + return; + } + ResourceManager.instance.SpendMana(manaCost); + } + GameObject gameObject = Object.Instantiate(projectile, muzzle.position, muzzle.rotation); + gameObject.GetComponent<Projectile>().SetStats(towerType, currentTarget, projectileSpeed, damage, healthDamage, armorDamage, shieldDamage, slowPercent, bleedPercent, burnPercent, poisonPercent, critChance, stunChance); + if (extraProjectileFX != null) + { + GameObject gameObject2 = Object.Instantiate(extraProjectileFX, gameObject.transform.position, gameObject.transform.rotation); + gameObject2.transform.SetParent(gameObject.transform); + gameObject2.GetComponent<ProjectileFX>().SetFX(bleedPercent, burnPercent, poisonPercent, slowPercent, consumesMana); + Projectile component = gameObject.GetComponent<Projectile>(); + if (component.detachOnDestruction == null) + { + component.detachOnDestruction = gameObject2; + component.extraFX = gameObject2.GetComponent<ProjectileFX>(); + } + } + } + + protected virtual void AimTurret() + { + Vector3 forward = currentTarget.transform.position - turret.transform.position; + if (!towerVerticalyAims) + { + forward.y = 0f; + } + Quaternion rotation = Quaternion.LookRotation(forward, Vector3.up); + turret.transform.rotation = rotation; + } + + protected void GainXP() + { + Enemy component = currentTarget.GetComponent<Enemy>(); + if (component != null) + { + if (component.shield > 0) + { + shieldXP += Time.deltaTime / (2f * range) + Time.deltaTime / 2f; + } + else if (component.armor > 0) + { + armorXP += Time.deltaTime / (2f * range) + Time.deltaTime / 2f; + } + else + { + healthXP += Time.deltaTime / (2f * range) + Time.deltaTime / 2f; + } + CheckXPAndLevelUp(); + } + } + + private void CheckXPAndLevelUp() + { + if (healthXP >= (float)(10 * level)) + { + healthXP -= 10 * level; + level++; + damageUpgrade++; + healthDamageUpgrade++; + SetStats(); + LevelUpText(); + } + if (armorXP >= (float)(10 * level)) + { + armorXP -= 10 * level; + level++; + damageUpgrade++; + armorDamageUpgrade++; + SetStats(); + LevelUpText(); + } + if (shieldXP >= (float)(10 * level)) + { + shieldXP -= 10 * level; + level++; + damageUpgrade++; + shieldDamageUpgrade++; + SetStats(); + LevelUpText(); + } + } + + private void LevelUpText() + { + Object.Instantiate(BuildingManager.instance.levelUpFX, base.transform.position, Quaternion.identity); + DamageNumber component = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component.SetText("LEVEL UP!", "Grey", 1f); + component.SetHoldTime(1f); + AchievementManager.instance.TowerLevel(level); + } + + public void BuyHealthLevel() + { + int num = (10 * level - (int)healthXP) * upgradeCostMultiplier; + if (ResourceManager.instance.CheckMoney(num)) + { + ResourceManager.instance.Spend(num); + DamageTracker.instance.AddCost(towerType, num); + healthXP -= 10 * level - num / upgradeCostMultiplier; + level++; + damageUpgrade++; + healthDamageUpgrade++; + SetStats(); + LevelUpText(); + } + } + + public void BuyArmorLevel() + { + int num = (10 * level - (int)armorXP) * upgradeCostMultiplier; + if (ResourceManager.instance.CheckMoney(num)) + { + ResourceManager.instance.Spend(num); + DamageTracker.instance.AddCost(towerType, num); + armorXP -= 10 * level - num / upgradeCostMultiplier; + level++; + damageUpgrade++; + armorDamageUpgrade++; + SetStats(); + LevelUpText(); + } + } + + public void BuyShieldLevel() + { + int num = (10 * level - (int)shieldXP) * upgradeCostMultiplier; + if (ResourceManager.instance.CheckMoney(num)) + { + ResourceManager.instance.Spend(num); + DamageTracker.instance.AddCost(towerType, num); + shieldXP -= 10 * level - num / upgradeCostMultiplier; + level++; + damageUpgrade++; + shieldDamageUpgrade++; + SetStats(); + LevelUpText(); + } + } + + private void DetectEnemies() + { + Collider[] array = Physics.OverlapSphere(base.transform.position, range, enemyLayerMask, QueryTriggerInteraction.Collide); + if (array.Length != 0) + { + currentTarget = SelectEnemy(array); + } + else + { + currentTarget = null; + } + lastTargetUpdate = Random.Range(0.25f, 1f); + } + + protected bool CheckPriority(Priority check) + { + for (int i = 0; i < priorities.Length; i++) + { + if (check == priorities[i]) + { + return true; + } + } + return false; + } + + protected int PriorityScale(Priority check) + { + for (int i = 0; i < priorities.Length; i++) + { + if (check == priorities[i]) + { + return Mathf.Clamp(3 - i, 1, 3); + } + } + return 1; + } + + protected virtual GameObject SelectEnemy(Collider[] possibleTargets) + { + GameObject result = null; + float num = -1f; + for (int i = 0; i < possibleTargets.Length; i++) + { + float num2 = 1f; + Enemy component = possibleTargets[i].GetComponent<Enemy>(); + if (CheckPriority(Priority.Progress)) + { + float f = Mathf.Max(0.001f, possibleTargets[i].GetComponent<Pathfinder>().distanceFromEnd); + num2 /= Mathf.Pow(f, PriorityScale(Priority.Progress)); + } + if (CheckPriority(Priority.NearDeath)) + { + float f2 = Mathf.Max(0.001f, component.CurrentHealth()); + num2 /= Mathf.Pow(f2, PriorityScale(Priority.NearDeath)); + } + if (CheckPriority(Priority.MostHealth)) + { + float f3 = (float)Mathf.Max(1, component.health) / 1000f; + num2 *= Mathf.Pow(f3, PriorityScale(Priority.MostHealth)); + } + if (CheckPriority(Priority.MostArmor)) + { + float f4 = (float)Mathf.Max(1, component.armor) / 1000f; + num2 *= Mathf.Pow(f4, PriorityScale(Priority.MostArmor)); + } + if (CheckPriority(Priority.MostShield)) + { + float f5 = (float)Mathf.Max(1, component.shield) / 1000f; + num2 *= Mathf.Pow(f5, PriorityScale(Priority.MostShield)); + } + if (CheckPriority(Priority.LeastHealth)) + { + float f6 = Mathf.Max(1, component.health); + num2 /= Mathf.Pow(f6, PriorityScale(Priority.LeastHealth)); + } + if (CheckPriority(Priority.LeastArmor)) + { + float f7 = Mathf.Max(1, component.armor); + num2 /= Mathf.Pow(f7, PriorityScale(Priority.LeastArmor)); + } + if (CheckPriority(Priority.LeastShield)) + { + float f8 = Mathf.Max(1, component.shield); + num2 /= Mathf.Pow(f8, PriorityScale(Priority.LeastShield)); + } + if (CheckPriority(Priority.Fastest)) + { + float f9 = Mathf.Max(0.001f, possibleTargets[i].GetComponent<Pathfinder>().speed); + num2 *= Mathf.Pow(f9, PriorityScale(Priority.Fastest)); + } + if (CheckPriority(Priority.Slowest)) + { + float f10 = Mathf.Max(0.001f, possibleTargets[i].GetComponent<Pathfinder>().speed); + num2 /= Mathf.Pow(f10, PriorityScale(Priority.Slowest)); + } + if (CheckPriority(Priority.Marked)) + { + float f11 = 1f; + if (component.mark != null) + { + f11 = (float)(component.mark.damage * (component.mark.healthDamage + component.mark.armorDamage + component.mark.shieldDamage)) * (1f + component.mark.critChance); + } + num2 *= Mathf.Pow(f11, PriorityScale(Priority.Marked)); + } + if (num2 > num) + { + result = component.gameObject; + num = num2; + } + } + return result; + } + + public void SpawnUI() + { + Object.Instantiate(towerUI, base.transform.position, Quaternion.identity).GetComponent<TowerUI>().SetStats(this); + } + + public virtual void Demolish() + { + TowerManager.instance.RemoveTower(this, towerType); + Object.Destroy(base.gameObject); + } +} diff --git a/GameCode/TowerFlyweight.cs b/GameCode/TowerFlyweight.cs new file mode 100644 index 0000000..b63f8b4 --- /dev/null +++ b/GameCode/TowerFlyweight.cs @@ -0,0 +1,279 @@ +using System.Collections.Generic; +using UnityEngine; + +public class TowerFlyweight : MonoBehaviour +{ + private HashSet<Tower> towers = new HashSet<Tower>(); + + [SerializeField] + private BuildButtonUI myBuildButton; + + [SerializeField] + private int basePrice; + + [SerializeField] + public int priceIncrease; + + [SerializeField] + public int currentPrice; + + [SerializeField] + public int sellPrice; + + [SerializeField] + public float bonusRange; + + [SerializeField] + public int bonusBaseDamage; + + [SerializeField] + public int bonusHealthDamage; + + [SerializeField] + public int bonusArmorDamage; + + [SerializeField] + public int bonusShieldDamage; + + [SerializeField] + public float bonusSlow; + + [SerializeField] + public float bonusBleed; + + [SerializeField] + public float bonusBurn; + + [SerializeField] + public float bonusPoison; + + [SerializeField] + public float bonusBlast; + + [SerializeField] + public float critChance; + + [SerializeField] + public float critChanceLevelMultiplier; + + [SerializeField] + public float stunChance; + + [SerializeField] + public float manaConsumptionAddition; + + [SerializeField] + private TowerType towerTypeForDamageTracker; + + public void AddNewTower(Tower newTower) + { + towers.Add(newTower); + currentPrice = basePrice + towers.Count * priceIncrease; + sellPrice = basePrice + (towers.Count - 1) * priceIncrease; + myBuildButton.UpdatePriceText(); + } + + public void RemoveTower(Tower newTower) + { + towers.Remove(newTower); + currentPrice = basePrice + towers.Count * priceIncrease; + sellPrice = basePrice + (towers.Count - 1) * priceIncrease; + myBuildButton.UpdatePriceText(); + ResourceManager.instance.AddMoney(basePrice + towers.Count * priceIncrease); + DamageTracker.instance.AddCost(towerTypeForDamageTracker, -(basePrice + towers.Count * priceIncrease)); + } + + public void UpdateTowerStats() + { + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } + + public void AddManaAddition(float bonus) + { + manaConsumptionAddition += bonus; + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } + + public void AddStunChance(float bonus) + { + stunChance += bonus; + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } + + public void AddCritChance(float bonus) + { + critChance += bonus; + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } + + public void AddCritChanceLevelMultiplier(float bonus) + { + critChanceLevelMultiplier += bonus; + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } + + public void AddBonusRange(float bonus) + { + bonusRange += bonus; + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } + + public void AddBonusBaseDamage(int bonus) + { + bonusBaseDamage += bonus; + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } + + public void AddBonusHealthDamage(int bonus) + { + bonusHealthDamage += bonus; + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } + + public void AddBonusArmorDamage(int bonus) + { + bonusArmorDamage += bonus; + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } + + public void AddBonusShieldDamage(int bonus) + { + bonusShieldDamage += bonus; + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } + + public void AddBonusSlow(float bonus) + { + bonusSlow += bonus; + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } + + public void AddBonusBleed(float bonus) + { + bonusBleed += bonus; + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } + + public void AddBonusBurn(float bonus) + { + bonusBurn += bonus; + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } + + public void AddBonusPoison(float bonus) + { + bonusPoison += bonus; + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } + + public void AddBonusBlast(float bonus) + { + bonusBlast += bonus; + foreach (Tower tower in towers) + { + tower.SetStats(); + } + if (myBuildButton != null) + { + myBuildButton.UpdateModifiersText(); + } + } +} diff --git a/GameCode/TowerManager.cs b/GameCode/TowerManager.cs new file mode 100644 index 0000000..abdca52 --- /dev/null +++ b/GameCode/TowerManager.cs @@ -0,0 +1,1386 @@ +using System.Collections.Generic; +using UnityEngine; + +public class TowerManager : MonoBehaviour +{ + public static TowerManager instance; + + [SerializeField] + private TowerFlyweight global; + + [SerializeField] + private TowerFlyweight crossbow; + + [SerializeField] + private TowerFlyweight morter; + + [SerializeField] + private TowerFlyweight teslaCoil; + + [SerializeField] + private TowerFlyweight flameThrower; + + [SerializeField] + private TowerFlyweight poisonSprayer; + + [SerializeField] + private TowerFlyweight frostKeep; + + [SerializeField] + private TowerFlyweight radar; + + [SerializeField] + private TowerFlyweight obelisk; + + [SerializeField] + private TowerFlyweight particleCannon; + + [SerializeField] + private TowerFlyweight shredder; + + [SerializeField] + private TowerFlyweight encampment; + + [SerializeField] + private TowerFlyweight lookout; + + [SerializeField] + private TowerFlyweight siphon; + + public HashSet<TowerType> towersUsed = new HashSet<TowerType>(); + + private bool usedAllTowers; + + public float obeliskTimeOnTargetMultiplier; + + private void Awake() + { + instance = this; + } + + public void AddNewTower(Tower t, TowerType type) + { + if (type != TowerType.Siphon) + { + towersUsed.Add(type); + } + if (!usedAllTowers) + { + usedAllTowers = AchievementManager.instance.CheckAllTowers(); + } + switch (type) + { + case TowerType.Crossbow: + crossbow.AddNewTower(t); + break; + case TowerType.Morter: + morter.AddNewTower(t); + break; + case TowerType.TeslaCoil: + teslaCoil.AddNewTower(t); + break; + case TowerType.FlameThrower: + flameThrower.AddNewTower(t); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddNewTower(t); + break; + case TowerType.Frost: + frostKeep.AddNewTower(t); + break; + case TowerType.Radar: + radar.AddNewTower(t); + break; + case TowerType.Obelisk: + obelisk.AddNewTower(t); + break; + case TowerType.ParticleCannon: + particleCannon.AddNewTower(t); + break; + case TowerType.Shredder: + shredder.AddNewTower(t); + break; + case TowerType.Encampment: + encampment.AddNewTower(t); + break; + case TowerType.Lookout: + lookout.AddNewTower(t); + break; + default: + Debug.LogError("Failed to add tower to flyweight"); + break; + } + } + + public void RemoveTower(Tower t, TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.RemoveTower(t); + break; + case TowerType.Morter: + morter.RemoveTower(t); + break; + case TowerType.TeslaCoil: + teslaCoil.RemoveTower(t); + break; + case TowerType.FlameThrower: + flameThrower.RemoveTower(t); + break; + case TowerType.PoisonSprayer: + poisonSprayer.RemoveTower(t); + break; + case TowerType.Frost: + frostKeep.RemoveTower(t); + break; + case TowerType.Obelisk: + obelisk.RemoveTower(t); + break; + case TowerType.Radar: + radar.RemoveTower(t); + break; + case TowerType.ParticleCannon: + particleCannon.RemoveTower(t); + break; + case TowerType.Shredder: + shredder.RemoveTower(t); + break; + case TowerType.Encampment: + encampment.RemoveTower(t); + break; + case TowerType.Lookout: + lookout.RemoveTower(t); + break; + default: + Debug.LogError("Failed to add tower to flyweight"); + break; + } + } + + public void UpdateAllTowers() + { + crossbow.UpdateTowerStats(); + morter.UpdateTowerStats(); + teslaCoil.UpdateTowerStats(); + flameThrower.UpdateTowerStats(); + poisonSprayer.UpdateTowerStats(); + frostKeep.UpdateTowerStats(); + radar.UpdateTowerStats(); + obelisk.UpdateTowerStats(); + particleCannon.UpdateTowerStats(); + shredder.UpdateTowerStats(); + encampment.UpdateTowerStats(); + lookout.UpdateTowerStats(); + } + + public int GetSellPrice(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return crossbow.sellPrice; + case TowerType.Morter: + return morter.sellPrice; + case TowerType.TeslaCoil: + return teslaCoil.sellPrice; + case TowerType.FlameThrower: + return flameThrower.sellPrice; + case TowerType.PoisonSprayer: + return poisonSprayer.sellPrice; + case TowerType.Frost: + return frostKeep.sellPrice; + case TowerType.Obelisk: + return obelisk.sellPrice; + case TowerType.Radar: + return radar.sellPrice; + case TowerType.ParticleCannon: + return particleCannon.sellPrice; + case TowerType.Shredder: + return shredder.sellPrice; + case TowerType.Encampment: + return encampment.sellPrice; + case TowerType.Lookout: + return lookout.sellPrice; + default: + Debug.LogError("Failed to add tower to flyweight"); + return -1; + } + } + + public float GetManaConsumptionBonus(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return global.manaConsumptionAddition + crossbow.manaConsumptionAddition; + case TowerType.Morter: + return global.manaConsumptionAddition + morter.manaConsumptionAddition; + case TowerType.TeslaCoil: + return global.manaConsumptionAddition + teslaCoil.manaConsumptionAddition; + case TowerType.FlameThrower: + return global.manaConsumptionAddition + flameThrower.manaConsumptionAddition; + case TowerType.PoisonSprayer: + return global.manaConsumptionAddition + poisonSprayer.manaConsumptionAddition; + case TowerType.Frost: + return global.manaConsumptionAddition + frostKeep.manaConsumptionAddition; + case TowerType.Radar: + return global.manaConsumptionAddition + radar.manaConsumptionAddition; + case TowerType.Obelisk: + return global.manaConsumptionAddition + obelisk.manaConsumptionAddition; + case TowerType.ParticleCannon: + return global.manaConsumptionAddition + particleCannon.manaConsumptionAddition; + case TowerType.Shredder: + return global.manaConsumptionAddition + shredder.manaConsumptionAddition; + case TowerType.Encampment: + return global.manaConsumptionAddition + encampment.manaConsumptionAddition; + case TowerType.Lookout: + return global.manaConsumptionAddition + lookout.manaConsumptionAddition; + default: + Debug.Log("Failed to get global bonus"); + return 0f; + } + } + + public float GetCritChance(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return global.critChance + crossbow.critChance; + case TowerType.Morter: + return global.critChance + morter.critChance; + case TowerType.TeslaCoil: + return global.critChance + teslaCoil.critChance; + case TowerType.FlameThrower: + return global.critChance + flameThrower.critChance; + case TowerType.PoisonSprayer: + return global.critChance + poisonSprayer.critChance; + case TowerType.Frost: + return global.critChance + frostKeep.critChance; + case TowerType.Radar: + return global.critChance + radar.critChance; + case TowerType.Obelisk: + return global.critChance + obelisk.critChance; + case TowerType.ParticleCannon: + return global.critChance + particleCannon.critChance; + case TowerType.Shredder: + return global.critChance + shredder.critChance; + case TowerType.Encampment: + return global.critChance + encampment.critChance; + case TowerType.Lookout: + return global.critChance + lookout.critChance; + default: + Debug.Log("Failed to get global bonus"); + return 0f; + } + } + + public float GetStunChance(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return global.stunChance + crossbow.stunChance; + case TowerType.Morter: + return global.stunChance + morter.stunChance; + case TowerType.TeslaCoil: + return global.stunChance + teslaCoil.stunChance; + case TowerType.FlameThrower: + return global.stunChance + flameThrower.stunChance; + case TowerType.PoisonSprayer: + return global.stunChance + poisonSprayer.stunChance; + case TowerType.Frost: + return global.stunChance + frostKeep.stunChance; + case TowerType.Radar: + return global.stunChance + radar.stunChance; + case TowerType.Obelisk: + return global.stunChance + obelisk.stunChance; + case TowerType.ParticleCannon: + return global.stunChance + particleCannon.stunChance; + case TowerType.Shredder: + return global.stunChance + shredder.stunChance; + case TowerType.Encampment: + return global.stunChance + encampment.stunChance; + case TowerType.Lookout: + return global.stunChance + lookout.stunChance; + default: + Debug.Log("Failed to get global bonus"); + return 0f; + } + } + + public float GetCritChanceLevelMultiplier(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return global.critChanceLevelMultiplier + crossbow.critChanceLevelMultiplier; + case TowerType.Morter: + return global.critChanceLevelMultiplier + morter.critChanceLevelMultiplier; + case TowerType.TeslaCoil: + return global.critChanceLevelMultiplier + teslaCoil.critChanceLevelMultiplier; + case TowerType.FlameThrower: + return global.critChanceLevelMultiplier + flameThrower.critChanceLevelMultiplier; + case TowerType.PoisonSprayer: + return global.critChanceLevelMultiplier + poisonSprayer.critChanceLevelMultiplier; + case TowerType.Frost: + return global.critChanceLevelMultiplier + frostKeep.critChanceLevelMultiplier; + case TowerType.Radar: + return global.critChanceLevelMultiplier + radar.critChanceLevelMultiplier; + case TowerType.Obelisk: + return global.critChanceLevelMultiplier + obelisk.critChanceLevelMultiplier; + case TowerType.ParticleCannon: + return global.critChanceLevelMultiplier + particleCannon.critChanceLevelMultiplier; + case TowerType.Shredder: + return global.critChanceLevelMultiplier + shredder.critChanceLevelMultiplier; + case TowerType.Encampment: + return global.critChanceLevelMultiplier + encampment.critChanceLevelMultiplier; + case TowerType.Lookout: + return global.critChanceLevelMultiplier + lookout.critChanceLevelMultiplier; + default: + Debug.Log("Failed to get global bonus"); + return 0f; + } + } + + public float GetBonusRange(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return global.bonusRange + crossbow.bonusRange; + case TowerType.Morter: + return global.bonusRange + morter.bonusRange; + case TowerType.TeslaCoil: + return global.bonusRange + teslaCoil.bonusRange; + case TowerType.FlameThrower: + return global.bonusRange + flameThrower.bonusRange; + case TowerType.PoisonSprayer: + return global.bonusRange + poisonSprayer.bonusRange; + case TowerType.Frost: + return global.bonusRange + frostKeep.bonusRange; + case TowerType.Radar: + return global.bonusRange + radar.bonusRange; + case TowerType.Obelisk: + return global.bonusRange + obelisk.bonusRange; + case TowerType.ParticleCannon: + return global.bonusRange + particleCannon.bonusRange; + case TowerType.Shredder: + return global.bonusRange + shredder.bonusRange; + case TowerType.Encampment: + return global.bonusRange + encampment.bonusRange; + case TowerType.Lookout: + return global.bonusRange + lookout.bonusRange; + default: + Debug.Log("Failed to get global bonus"); + return 0f; + } + } + + public int GetBonusBaseDamage(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return global.bonusBaseDamage + crossbow.bonusBaseDamage; + case TowerType.Morter: + return global.bonusBaseDamage + morter.bonusBaseDamage; + case TowerType.TeslaCoil: + return global.bonusBaseDamage + teslaCoil.bonusBaseDamage; + case TowerType.FlameThrower: + return global.bonusBaseDamage + flameThrower.bonusBaseDamage; + case TowerType.PoisonSprayer: + return global.bonusBaseDamage + poisonSprayer.bonusBaseDamage; + case TowerType.Frost: + return global.bonusBaseDamage + frostKeep.bonusBaseDamage; + case TowerType.Radar: + return global.bonusBaseDamage + radar.bonusBaseDamage; + case TowerType.Obelisk: + return global.bonusBaseDamage + obelisk.bonusBaseDamage; + case TowerType.ParticleCannon: + return global.bonusBaseDamage + particleCannon.bonusBaseDamage; + case TowerType.Shredder: + return global.bonusBaseDamage + shredder.bonusBaseDamage; + case TowerType.Encampment: + return global.bonusBaseDamage + encampment.bonusBaseDamage; + case TowerType.Lookout: + return global.bonusBaseDamage + lookout.bonusBaseDamage; + default: + Debug.Log("Failed to get global bonus"); + return 0; + } + } + + public int GetBonusHealthDamage(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return global.bonusHealthDamage + crossbow.bonusHealthDamage; + case TowerType.Morter: + return global.bonusHealthDamage + morter.bonusHealthDamage; + case TowerType.TeslaCoil: + return global.bonusHealthDamage + teslaCoil.bonusHealthDamage; + case TowerType.FlameThrower: + return global.bonusHealthDamage + flameThrower.bonusHealthDamage; + case TowerType.PoisonSprayer: + return global.bonusHealthDamage + poisonSprayer.bonusHealthDamage; + case TowerType.Frost: + return global.bonusHealthDamage + frostKeep.bonusHealthDamage; + case TowerType.Radar: + return global.bonusHealthDamage + radar.bonusHealthDamage; + case TowerType.Obelisk: + return global.bonusHealthDamage + obelisk.bonusHealthDamage; + case TowerType.ParticleCannon: + return global.bonusHealthDamage + particleCannon.bonusHealthDamage; + case TowerType.Shredder: + return global.bonusHealthDamage + shredder.bonusHealthDamage; + case TowerType.Encampment: + return global.bonusHealthDamage + encampment.bonusHealthDamage; + case TowerType.Lookout: + return global.bonusHealthDamage + lookout.bonusHealthDamage; + default: + Debug.Log("Failed to get global bonus"); + return 0; + } + } + + public int GetBonusArmorDamage(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return global.bonusArmorDamage + crossbow.bonusArmorDamage; + case TowerType.Morter: + return global.bonusArmorDamage + morter.bonusArmorDamage; + case TowerType.TeslaCoil: + return global.bonusArmorDamage + teslaCoil.bonusArmorDamage; + case TowerType.FlameThrower: + return global.bonusArmorDamage + flameThrower.bonusArmorDamage; + case TowerType.PoisonSprayer: + return global.bonusArmorDamage + poisonSprayer.bonusArmorDamage; + case TowerType.Frost: + return global.bonusArmorDamage + frostKeep.bonusArmorDamage; + case TowerType.Radar: + return global.bonusArmorDamage + radar.bonusArmorDamage; + case TowerType.Obelisk: + return global.bonusArmorDamage + obelisk.bonusArmorDamage; + case TowerType.ParticleCannon: + return global.bonusArmorDamage + particleCannon.bonusArmorDamage; + case TowerType.Shredder: + return global.bonusArmorDamage + shredder.bonusArmorDamage; + case TowerType.Encampment: + return global.bonusArmorDamage + encampment.bonusArmorDamage; + case TowerType.Lookout: + return global.bonusArmorDamage + lookout.bonusArmorDamage; + default: + Debug.Log("Failed to get global bonus"); + return 0; + } + } + + public int GetBonusShieldDamage(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return global.bonusShieldDamage + crossbow.bonusShieldDamage; + case TowerType.Morter: + return global.bonusShieldDamage + morter.bonusShieldDamage; + case TowerType.TeslaCoil: + return global.bonusShieldDamage + teslaCoil.bonusShieldDamage; + case TowerType.FlameThrower: + return global.bonusShieldDamage + flameThrower.bonusShieldDamage; + case TowerType.PoisonSprayer: + return global.bonusShieldDamage + poisonSprayer.bonusShieldDamage; + case TowerType.Frost: + return global.bonusShieldDamage + frostKeep.bonusShieldDamage; + case TowerType.Radar: + return global.bonusShieldDamage + radar.bonusShieldDamage; + case TowerType.Obelisk: + return global.bonusShieldDamage + obelisk.bonusShieldDamage; + case TowerType.ParticleCannon: + return global.bonusShieldDamage + particleCannon.bonusShieldDamage; + case TowerType.Shredder: + return global.bonusShieldDamage + shredder.bonusShieldDamage; + case TowerType.Encampment: + return global.bonusShieldDamage + encampment.bonusShieldDamage; + case TowerType.Lookout: + return global.bonusShieldDamage + lookout.bonusShieldDamage; + default: + Debug.Log("Failed to get global bonus"); + return 0; + } + } + + public float GetBonusSlow(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return global.bonusSlow + crossbow.bonusSlow; + case TowerType.Morter: + return global.bonusSlow + morter.bonusSlow; + case TowerType.TeslaCoil: + return global.bonusSlow + teslaCoil.bonusSlow; + case TowerType.FlameThrower: + return global.bonusSlow + flameThrower.bonusSlow; + case TowerType.PoisonSprayer: + return global.bonusSlow + poisonSprayer.bonusSlow; + case TowerType.Frost: + return global.bonusSlow + frostKeep.bonusSlow; + case TowerType.Radar: + return global.bonusSlow + radar.bonusSlow; + case TowerType.Obelisk: + return global.bonusSlow + obelisk.bonusSlow; + case TowerType.ParticleCannon: + return global.bonusSlow + particleCannon.bonusSlow; + case TowerType.Shredder: + return global.bonusSlow + shredder.bonusSlow; + case TowerType.Encampment: + return global.bonusSlow + encampment.bonusSlow; + case TowerType.Lookout: + return global.bonusSlow + lookout.bonusSlow; + default: + Debug.Log("Failed to get global bonus"); + return 0f; + } + } + + public float GetBonusBleed(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return global.bonusBleed + crossbow.bonusBleed; + case TowerType.Morter: + return global.bonusBleed + morter.bonusBleed; + case TowerType.TeslaCoil: + return global.bonusBleed + teslaCoil.bonusBleed; + case TowerType.FlameThrower: + return global.bonusBleed + flameThrower.bonusBleed; + case TowerType.PoisonSprayer: + return global.bonusBleed + poisonSprayer.bonusBleed; + case TowerType.Frost: + return global.bonusBleed + frostKeep.bonusBleed; + case TowerType.Radar: + return global.bonusBleed + radar.bonusBleed; + case TowerType.Obelisk: + return global.bonusBleed + obelisk.bonusBleed; + case TowerType.ParticleCannon: + return global.bonusBleed + particleCannon.bonusBleed; + case TowerType.Shredder: + return global.bonusBleed + shredder.bonusBleed; + case TowerType.Encampment: + return global.bonusBleed + encampment.bonusBleed; + case TowerType.Lookout: + return global.bonusBleed + lookout.bonusBleed; + default: + Debug.Log("Failed to get global bonus"); + return 0f; + } + } + + public float GetBonusBurn(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return global.bonusBurn + crossbow.bonusBurn; + case TowerType.Morter: + return global.bonusBurn + morter.bonusBurn; + case TowerType.TeslaCoil: + return global.bonusBurn + teslaCoil.bonusBurn; + case TowerType.FlameThrower: + return global.bonusBurn + flameThrower.bonusBurn; + case TowerType.PoisonSprayer: + return global.bonusBurn + poisonSprayer.bonusBurn; + case TowerType.Frost: + return global.bonusBurn + frostKeep.bonusBurn; + case TowerType.Radar: + return global.bonusBurn + radar.bonusBurn; + case TowerType.Obelisk: + return global.bonusBurn + obelisk.bonusBurn; + case TowerType.ParticleCannon: + return global.bonusBurn + particleCannon.bonusBurn; + case TowerType.Shredder: + return global.bonusBurn + shredder.bonusBurn; + case TowerType.Encampment: + return global.bonusBurn + encampment.bonusBurn; + case TowerType.Lookout: + return global.bonusBurn + lookout.bonusBurn; + default: + Debug.Log("Failed to get global bonus"); + return 0f; + } + } + + public float GetBonusPoison(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return global.bonusPoison + crossbow.bonusPoison; + case TowerType.Morter: + return global.bonusPoison + morter.bonusPoison; + case TowerType.TeslaCoil: + return global.bonusPoison + teslaCoil.bonusPoison; + case TowerType.FlameThrower: + return global.bonusPoison + flameThrower.bonusPoison; + case TowerType.PoisonSprayer: + return global.bonusPoison + poisonSprayer.bonusPoison; + case TowerType.Frost: + return global.bonusPoison + frostKeep.bonusPoison; + case TowerType.Radar: + return global.bonusPoison + radar.bonusPoison; + case TowerType.Obelisk: + return global.bonusPoison + obelisk.bonusPoison; + case TowerType.ParticleCannon: + return global.bonusPoison + particleCannon.bonusPoison; + case TowerType.Shredder: + return global.bonusPoison + shredder.bonusPoison; + case TowerType.Encampment: + return global.bonusPoison + encampment.bonusPoison; + case TowerType.Lookout: + return global.bonusPoison + lookout.bonusPoison; + default: + Debug.Log("Failed to get global bonus"); + return 0f; + } + } + + public float GetBonusBlast(TowerType type) + { + switch (type) + { + case TowerType.Crossbow: + return global.bonusBlast + crossbow.bonusBlast; + case TowerType.Morter: + return global.bonusBlast + morter.bonusBlast; + case TowerType.TeslaCoil: + return global.bonusBlast + teslaCoil.bonusBlast; + case TowerType.FlameThrower: + return global.bonusBlast + flameThrower.bonusBlast; + case TowerType.PoisonSprayer: + return global.bonusBlast + poisonSprayer.bonusBlast; + case TowerType.Frost: + return global.bonusBlast + frostKeep.bonusBlast; + case TowerType.Radar: + return global.bonusBlast + radar.bonusBlast; + case TowerType.Obelisk: + return global.bonusBlast + obelisk.bonusBlast; + case TowerType.ParticleCannon: + return global.bonusBlast + particleCannon.bonusBlast; + case TowerType.Shredder: + return global.bonusBlast + shredder.bonusBlast; + case TowerType.Encampment: + return global.bonusBlast + encampment.bonusBlast; + case TowerType.Lookout: + return global.bonusBlast + lookout.bonusBlast; + default: + Debug.Log("Failed to get global bonus"); + return 0f; + } + } + + public void AddManaConsumption(TowerType type, float value) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.AddManaAddition(value); + break; + case TowerType.Morter: + morter.AddManaAddition(value); + break; + case TowerType.TeslaCoil: + teslaCoil.AddManaAddition(value); + break; + case TowerType.FlameThrower: + flameThrower.AddManaAddition(value); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddManaAddition(value); + break; + case TowerType.Frost: + frostKeep.AddManaAddition(value); + break; + case TowerType.Radar: + radar.AddManaAddition(value); + break; + case TowerType.Obelisk: + obelisk.AddManaAddition(value); + break; + case TowerType.ParticleCannon: + particleCannon.AddManaAddition(value); + break; + case TowerType.Shredder: + shredder.AddManaAddition(value); + break; + case TowerType.Encampment: + encampment.AddManaAddition(value); + break; + case TowerType.Lookout: + lookout.AddManaAddition(value); + break; + case TowerType.Global: + global.AddManaAddition(value); + UpdateAllTowers(); + break; + default: + Debug.Log("Failed to set global bonus"); + break; + } + } + + public void AddCritChance(TowerType type, float value) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.AddCritChance(value); + break; + case TowerType.Morter: + morter.AddCritChance(value); + break; + case TowerType.TeslaCoil: + teslaCoil.AddCritChance(value); + break; + case TowerType.FlameThrower: + flameThrower.AddCritChance(value); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddCritChance(value); + break; + case TowerType.Frost: + frostKeep.AddCritChance(value); + break; + case TowerType.Radar: + radar.AddCritChance(value); + break; + case TowerType.Obelisk: + obelisk.AddCritChance(value); + break; + case TowerType.ParticleCannon: + particleCannon.AddCritChance(value); + break; + case TowerType.Shredder: + shredder.AddCritChance(value); + break; + case TowerType.Encampment: + encampment.AddCritChance(value); + break; + case TowerType.Lookout: + lookout.AddCritChance(value); + break; + case TowerType.Global: + global.AddCritChance(value); + UpdateAllTowers(); + break; + default: + Debug.Log("Failed to set global bonus"); + break; + } + } + + public void AddStunChance(TowerType type, float value) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.AddStunChance(value); + break; + case TowerType.Morter: + morter.AddStunChance(value); + break; + case TowerType.TeslaCoil: + teslaCoil.AddStunChance(value); + break; + case TowerType.FlameThrower: + flameThrower.AddStunChance(value); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddStunChance(value); + break; + case TowerType.Frost: + frostKeep.AddStunChance(value); + break; + case TowerType.Radar: + radar.AddStunChance(value); + break; + case TowerType.Obelisk: + obelisk.AddStunChance(value); + break; + case TowerType.ParticleCannon: + particleCannon.AddStunChance(value); + break; + case TowerType.Shredder: + shredder.AddStunChance(value); + break; + case TowerType.Encampment: + encampment.AddStunChance(value); + break; + case TowerType.Lookout: + lookout.AddStunChance(value); + break; + case TowerType.Global: + global.AddStunChance(value); + UpdateAllTowers(); + break; + default: + Debug.Log("Failed to set global bonus"); + break; + } + } + + public void AddCritChanceLevelMultiplier(TowerType type, float value) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.AddCritChanceLevelMultiplier(value); + break; + case TowerType.Morter: + morter.AddCritChanceLevelMultiplier(value); + break; + case TowerType.TeslaCoil: + teslaCoil.AddCritChanceLevelMultiplier(value); + break; + case TowerType.FlameThrower: + flameThrower.AddCritChanceLevelMultiplier(value); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddCritChanceLevelMultiplier(value); + break; + case TowerType.Frost: + frostKeep.AddCritChanceLevelMultiplier(value); + break; + case TowerType.Radar: + radar.AddCritChanceLevelMultiplier(value); + break; + case TowerType.Obelisk: + obelisk.AddCritChanceLevelMultiplier(value); + break; + case TowerType.ParticleCannon: + particleCannon.AddCritChanceLevelMultiplier(value); + break; + case TowerType.Shredder: + shredder.AddCritChanceLevelMultiplier(value); + break; + case TowerType.Encampment: + encampment.AddCritChanceLevelMultiplier(value); + break; + case TowerType.Lookout: + lookout.AddCritChanceLevelMultiplier(value); + break; + case TowerType.Global: + global.AddCritChanceLevelMultiplier(value); + UpdateAllTowers(); + break; + default: + Debug.Log("Failed to set global bonus"); + break; + } + } + + public void AddBonusRange(TowerType type, float value) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.AddBonusRange(value); + break; + case TowerType.Morter: + morter.AddBonusRange(value); + break; + case TowerType.TeslaCoil: + teslaCoil.AddBonusRange(value); + break; + case TowerType.FlameThrower: + flameThrower.AddBonusRange(value); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddBonusRange(value); + break; + case TowerType.Frost: + frostKeep.AddBonusRange(value); + break; + case TowerType.Radar: + radar.AddBonusRange(value); + break; + case TowerType.Obelisk: + obelisk.AddBonusRange(value); + break; + case TowerType.ParticleCannon: + particleCannon.AddBonusRange(value); + break; + case TowerType.Shredder: + shredder.AddBonusRange(value); + break; + case TowerType.Encampment: + encampment.AddBonusRange(value); + break; + case TowerType.Lookout: + lookout.AddBonusRange(value); + break; + case TowerType.Global: + global.AddBonusRange(value); + UpdateAllTowers(); + break; + default: + Debug.Log("Failed to set global bonus"); + break; + } + } + + public void AddBonusBaseDamage(TowerType type, int value) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.AddBonusBaseDamage(value); + break; + case TowerType.Morter: + morter.AddBonusBaseDamage(value); + break; + case TowerType.TeslaCoil: + teslaCoil.AddBonusBaseDamage(value); + break; + case TowerType.FlameThrower: + flameThrower.AddBonusBaseDamage(value); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddBonusBaseDamage(value); + break; + case TowerType.Frost: + frostKeep.AddBonusBaseDamage(value); + break; + case TowerType.Radar: + radar.AddBonusBaseDamage(value); + break; + case TowerType.Obelisk: + obelisk.AddBonusBaseDamage(value); + break; + case TowerType.ParticleCannon: + particleCannon.AddBonusBaseDamage(value); + break; + case TowerType.Shredder: + shredder.AddBonusBaseDamage(value); + break; + case TowerType.Encampment: + encampment.AddBonusBaseDamage(value); + break; + case TowerType.Lookout: + lookout.AddBonusBaseDamage(value); + break; + case TowerType.Global: + global.AddBonusBaseDamage(value); + UpdateAllTowers(); + break; + default: + Debug.Log("Failed to set global bonus"); + break; + } + } + + public void AddBonusHealthDamage(TowerType type, int value) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.AddBonusHealthDamage(value); + break; + case TowerType.Morter: + morter.AddBonusHealthDamage(value); + break; + case TowerType.TeslaCoil: + teslaCoil.AddBonusHealthDamage(value); + break; + case TowerType.FlameThrower: + flameThrower.AddBonusHealthDamage(value); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddBonusHealthDamage(value); + break; + case TowerType.Frost: + frostKeep.AddBonusHealthDamage(value); + break; + case TowerType.Radar: + radar.AddBonusHealthDamage(value); + break; + case TowerType.Obelisk: + obelisk.AddBonusHealthDamage(value); + break; + case TowerType.ParticleCannon: + particleCannon.AddBonusHealthDamage(value); + break; + case TowerType.Shredder: + shredder.AddBonusHealthDamage(value); + break; + case TowerType.Encampment: + encampment.AddBonusHealthDamage(value); + break; + case TowerType.Lookout: + lookout.AddBonusHealthDamage(value); + break; + case TowerType.Global: + global.AddBonusHealthDamage(value); + UpdateAllTowers(); + break; + default: + Debug.Log("Failed to set global bonus"); + break; + } + } + + public void AddBonusArmorDamage(TowerType type, int value) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.AddBonusArmorDamage(value); + break; + case TowerType.Morter: + morter.AddBonusArmorDamage(value); + break; + case TowerType.TeslaCoil: + teslaCoil.AddBonusArmorDamage(value); + break; + case TowerType.FlameThrower: + flameThrower.AddBonusArmorDamage(value); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddBonusArmorDamage(value); + break; + case TowerType.Frost: + frostKeep.AddBonusArmorDamage(value); + break; + case TowerType.Radar: + radar.AddBonusArmorDamage(value); + break; + case TowerType.Obelisk: + obelisk.AddBonusArmorDamage(value); + break; + case TowerType.ParticleCannon: + particleCannon.AddBonusArmorDamage(value); + break; + case TowerType.Shredder: + shredder.AddBonusArmorDamage(value); + break; + case TowerType.Encampment: + encampment.AddBonusArmorDamage(value); + break; + case TowerType.Lookout: + lookout.AddBonusArmorDamage(value); + break; + case TowerType.Global: + global.AddBonusArmorDamage(value); + UpdateAllTowers(); + break; + default: + Debug.Log("Failed to set global bonus"); + break; + } + } + + public void AddBonusShieldDamage(TowerType type, int value) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.AddBonusShieldDamage(value); + break; + case TowerType.Morter: + morter.AddBonusShieldDamage(value); + break; + case TowerType.TeslaCoil: + teslaCoil.AddBonusShieldDamage(value); + break; + case TowerType.FlameThrower: + flameThrower.AddBonusShieldDamage(value); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddBonusShieldDamage(value); + break; + case TowerType.Frost: + frostKeep.AddBonusShieldDamage(value); + break; + case TowerType.Radar: + radar.AddBonusShieldDamage(value); + break; + case TowerType.Obelisk: + obelisk.AddBonusShieldDamage(value); + break; + case TowerType.ParticleCannon: + particleCannon.AddBonusShieldDamage(value); + break; + case TowerType.Shredder: + shredder.AddBonusShieldDamage(value); + break; + case TowerType.Encampment: + encampment.AddBonusShieldDamage(value); + break; + case TowerType.Lookout: + lookout.AddBonusShieldDamage(value); + break; + case TowerType.Global: + global.AddBonusShieldDamage(value); + UpdateAllTowers(); + break; + default: + Debug.Log("Failed to set global bonus"); + break; + } + } + + public void AddBonusSlow(TowerType type, float value) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.AddBonusSlow(value); + break; + case TowerType.Morter: + morter.AddBonusSlow(value); + break; + case TowerType.TeslaCoil: + teslaCoil.AddBonusSlow(value); + break; + case TowerType.FlameThrower: + flameThrower.AddBonusSlow(value); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddBonusSlow(value); + break; + case TowerType.Frost: + frostKeep.AddBonusSlow(value); + break; + case TowerType.Radar: + radar.AddBonusSlow(value); + break; + case TowerType.Obelisk: + obelisk.AddBonusSlow(value); + break; + case TowerType.ParticleCannon: + particleCannon.AddBonusSlow(value); + break; + case TowerType.Shredder: + shredder.AddBonusSlow(value); + break; + case TowerType.Encampment: + encampment.AddBonusSlow(value); + break; + case TowerType.Lookout: + lookout.AddBonusSlow(value); + break; + case TowerType.Global: + global.AddBonusSlow(value); + UpdateAllTowers(); + break; + default: + Debug.Log("Failed to set global bonus"); + break; + } + } + + public void AddBonusBleed(TowerType type, float value) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.AddBonusBleed(value); + break; + case TowerType.Morter: + morter.AddBonusBleed(value); + break; + case TowerType.TeslaCoil: + teslaCoil.AddBonusBleed(value); + break; + case TowerType.FlameThrower: + flameThrower.AddBonusBleed(value); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddBonusBleed(value); + break; + case TowerType.Frost: + frostKeep.AddBonusBleed(value); + break; + case TowerType.Radar: + radar.AddBonusBleed(value); + break; + case TowerType.Obelisk: + obelisk.AddBonusBleed(value); + break; + case TowerType.ParticleCannon: + particleCannon.AddBonusBleed(value); + break; + case TowerType.Shredder: + shredder.AddBonusBleed(value); + break; + case TowerType.Encampment: + encampment.AddBonusBleed(value); + break; + case TowerType.Lookout: + lookout.AddBonusBleed(value); + break; + case TowerType.Global: + global.AddBonusBleed(value); + UpdateAllTowers(); + break; + default: + Debug.Log("Failed to set global bonus"); + break; + } + } + + public void AddBonusBurn(TowerType type, float value) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.AddBonusBurn(value); + break; + case TowerType.Morter: + morter.AddBonusBurn(value); + break; + case TowerType.TeslaCoil: + teslaCoil.AddBonusBurn(value); + break; + case TowerType.FlameThrower: + flameThrower.AddBonusBurn(value); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddBonusBurn(value); + break; + case TowerType.Frost: + frostKeep.AddBonusBurn(value); + break; + case TowerType.Radar: + radar.AddBonusBurn(value); + break; + case TowerType.Obelisk: + obelisk.AddBonusBurn(value); + break; + case TowerType.ParticleCannon: + particleCannon.AddBonusBurn(value); + break; + case TowerType.Shredder: + shredder.AddBonusBurn(value); + break; + case TowerType.Encampment: + encampment.AddBonusBurn(value); + break; + case TowerType.Lookout: + lookout.AddBonusBurn(value); + break; + case TowerType.Global: + global.AddBonusBurn(value); + UpdateAllTowers(); + break; + default: + Debug.Log("Failed to set global bonus"); + break; + } + } + + public void AddBonusPoison(TowerType type, float value) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.AddBonusPoison(value); + break; + case TowerType.Morter: + morter.AddBonusPoison(value); + break; + case TowerType.TeslaCoil: + teslaCoil.AddBonusPoison(value); + break; + case TowerType.FlameThrower: + flameThrower.AddBonusPoison(value); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddBonusPoison(value); + break; + case TowerType.Frost: + frostKeep.AddBonusPoison(value); + break; + case TowerType.Radar: + radar.AddBonusPoison(value); + break; + case TowerType.Obelisk: + obelisk.AddBonusPoison(value); + break; + case TowerType.ParticleCannon: + particleCannon.AddBonusPoison(value); + break; + case TowerType.Shredder: + shredder.AddBonusPoison(value); + break; + case TowerType.Encampment: + encampment.AddBonusPoison(value); + break; + case TowerType.Lookout: + lookout.AddBonusPoison(value); + break; + case TowerType.Global: + global.AddBonusPoison(value); + UpdateAllTowers(); + break; + default: + Debug.Log("Failed to set global bonus"); + break; + } + } + + public void AddBonusBlast(TowerType type, float value) + { + switch (type) + { + case TowerType.Crossbow: + crossbow.AddBonusBlast(value); + break; + case TowerType.Morter: + morter.AddBonusBlast(value); + break; + case TowerType.TeslaCoil: + teslaCoil.AddBonusBlast(value); + break; + case TowerType.FlameThrower: + flameThrower.AddBonusBlast(value); + break; + case TowerType.PoisonSprayer: + poisonSprayer.AddBonusBlast(value); + break; + case TowerType.Frost: + frostKeep.AddBonusBlast(value); + break; + case TowerType.Radar: + radar.AddBonusBlast(value); + break; + case TowerType.Obelisk: + obelisk.AddBonusBlast(value); + break; + case TowerType.ParticleCannon: + particleCannon.AddBonusBlast(value); + break; + case TowerType.Shredder: + shredder.AddBonusBlast(value); + break; + case TowerType.Encampment: + encampment.AddBonusBlast(value); + break; + case TowerType.Lookout: + lookout.AddBonusBlast(value); + break; + case TowerType.Global: + global.AddBonusBlast(value); + UpdateAllTowers(); + break; + default: + Debug.Log("Failed to set global bonus"); + break; + } + } +} diff --git a/GameCode/TowerType.cs b/GameCode/TowerType.cs new file mode 100644 index 0000000..9bbc242 --- /dev/null +++ b/GameCode/TowerType.cs @@ -0,0 +1,18 @@ +public enum TowerType +{ + Crossbow, + Morter, + TeslaCoil, + Frost, + Obelisk, + FlameThrower, + PoisonSprayer, + Siphon, + Radar, + ParticleCannon, + DOT, + Global, + Shredder, + Encampment, + Lookout +} diff --git a/GameCode/TowerUI.cs b/GameCode/TowerUI.cs new file mode 100644 index 0000000..7b49139 --- /dev/null +++ b/GameCode/TowerUI.cs @@ -0,0 +1,289 @@ +using System; +using UnityEngine; +using UnityEngine.UI; + +public class TowerUI : MonoBehaviour +{ + private Tower myTower; + + private int level; + + private int baseDamage; + + private int healthDamage; + + private int armorDamage; + + private int shieldDamage; + + private float healthXP; + + private float armorXP; + + private float shieldXP; + + private bool usesMana; + + private float range; + + private float manaUseMultiplier; + + private int rpm; + + [SerializeField] + private Image healthXPImg; + + [SerializeField] + private Image armorXPImg; + + [SerializeField] + private Image shieldXPImg; + + [SerializeField] + private Text levelText; + + [SerializeField] + private Text baseDamageText; + + [SerializeField] + private Text healthDamageText; + + [SerializeField] + private Text armorDamageText; + + [SerializeField] + private Text shieldDamageText; + + [SerializeField] + private Text healthXPText; + + [SerializeField] + private Text armorXPText; + + [SerializeField] + private Text shieldXPText; + + [SerializeField] + private Text[] priorityTexts; + + [SerializeField] + private Text slowText; + + [SerializeField] + private Text bleedText; + + [SerializeField] + private Text burnText; + + [SerializeField] + private Text poisonText; + + [SerializeField] + private Text critText; + + [SerializeField] + private Text rangeText; + + [SerializeField] + private Text rpmText; + + [SerializeField] + private Text manaUseText; + + [SerializeField] + private Text demolishText; + + private float timer = 0.5f; + + [SerializeField] + private LineRenderer line; + + private void Start() + { + UIManager.instance.SetNewUI(base.gameObject); + } + + private void Update() + { + if (timer < 0f) + { + SetStats(myTower); + timer = 0.5f; + } + timer -= Time.deltaTime; + if (Input.GetKeyDown(KeyCode.Alpha1) || Input.GetKeyDown(KeyCode.Keypad1)) + { + BuyHealthLevel(); + } + if (Input.GetKeyDown(KeyCode.Alpha2) || Input.GetKeyDown(KeyCode.Keypad2)) + { + BuyArmorLevel(); + } + if (Input.GetKeyDown(KeyCode.Alpha3) || Input.GetKeyDown(KeyCode.Keypad3)) + { + BuyShieldLevel(); + } + } + + public void SetStats(Tower _myTower) + { + myTower = _myTower; + level = myTower.level; + baseDamage = myTower.damage; + healthDamage = myTower.healthDamage; + armorDamage = myTower.armorDamage; + shieldDamage = myTower.shieldDamage; + healthXP = myTower.healthXP; + armorXP = myTower.armorXP; + shieldXP = myTower.shieldXP; + slowText.text = (int)(myTower.slowPercent * 100f) + "%"; + bleedText.text = (int)(myTower.bleedPercent * 100f) + "%"; + burnText.text = (int)(myTower.burnPercent * 100f) + "%"; + poisonText.text = (int)(myTower.poisonPercent * 100f) + "%"; + critText.text = CritText(); + if (myTower.range != range) + { + DrawCircle(); + } + range = myTower.range; + rpm = (int)myTower.rpm; + usesMana = myTower.consumesMana; + manaUseMultiplier = myTower.finalManaConsumption; + UpdateText(); + for (int i = 0; i < priorityTexts.Length; i++) + { + priorityTexts[i].text = myTower.priorities[i].ToString(); + } + } + + private void DrawCircle() + { + float num = myTower.range; + if (myTower.squareUI) + { + num += 0.5f; + line.SetVertexCount(5); + line.useWorldSpace = true; + Vector3 position = base.transform.position; + position.y = 0.4f; + line.SetPosition(0, new Vector3(num, 0f, num) + position); + line.SetPosition(1, new Vector3(num, 0f, 0f - num) + position); + line.SetPosition(2, new Vector3(0f - num, 0f, 0f - num) + position); + line.SetPosition(3, new Vector3(0f - num, 0f, num) + position); + line.SetPosition(4, new Vector3(num, 0f, num) + position); + return; + } + line.SetVertexCount(61); + line.useWorldSpace = true; + Vector3 vector = new Vector3(0f, 0f, 0f); + Vector3 position2 = base.transform.position; + position2.y = 0.4f; + float num2 = 0f; + for (int i = 0; i < 61; i++) + { + vector.x = Mathf.Cos((float)Math.PI / 180f * num2) * num; + vector.z = Mathf.Sin((float)Math.PI / 180f * num2) * num; + line.SetPosition(i, vector + position2); + num2 += 6f; + } + } + + private string CritText() + { + string text = "x2! "; + text = text + (int)Mathf.Clamp(myTower.critChance * 100f, 0f, 50f) + "%"; + if (myTower.critChance > 0.5f) + { + text = text + "\nx3!! " + (int)Mathf.Clamp(myTower.critChance * 100f - 50f, 0f, 50f) + "%"; + } + if (myTower.critChance > 1f) + { + text = text + "\nx4!! " + (int)Mathf.Clamp(myTower.critChance * 100f - 100f, 0f, 50f) + "%"; + } + return text; + } + + private void UpdateText() + { + levelText.text = "Level: " + level; + baseDamageText.text = "Base Damage: " + baseDamage; + healthDamageText.text = "Health Multiplier: " + healthDamage + " (" + baseDamage * healthDamage + ")"; + armorDamageText.text = "Armor Multiplier: " + armorDamage + " (" + baseDamage * armorDamage + ")"; + shieldDamageText.text = "Shield Multiplier: " + shieldDamage + " (" + baseDamage * shieldDamage + ")"; + healthXPText.text = ((10 * level - (int)healthXP) * myTower.upgradeCostMultiplier).ToString(); + armorXPText.text = ((10 * level - (int)armorXP) * myTower.upgradeCostMultiplier).ToString(); + shieldXPText.text = ((10 * level - (int)shieldXP) * myTower.upgradeCostMultiplier).ToString(); + healthXPImg.rectTransform.sizeDelta = new Vector2(healthXP / (float)level, 0.25f); + armorXPImg.rectTransform.sizeDelta = new Vector2(armorXP / (float)level, 0.25f); + shieldXPImg.rectTransform.sizeDelta = new Vector2(shieldXP / (float)level, 0.25f); + rangeText.text = "Range: " + range; + if (myTower.GetComponent<Dropper>() != null) + { + rpmText.text = "Fire Rate: " + (int)myTower.GetComponent<Dropper>().dropperRPMdisplay + " RPM"; + } + else + { + rpmText.text = "Fire Rate: " + rpm + " RPM"; + } + if (usesMana) + { + manaUseText.text = "Mana Use: " + (int)((float)baseDamage * manaUseMultiplier) + "/shot"; + } + else if (!usesMana && manaUseMultiplier > 0f) + { + manaUseText.text = "Mana Use: " + manaUseMultiplier + "/sec"; + } + else + { + manaUseText.text = ""; + } + demolishText.text = "Demolish (" + TowerManager.instance.GetSellPrice(myTower.towerType) + "g)"; + } + + public void BuyHealthLevel() + { + SFXManager.instance.ButtonClick(); + myTower.BuyHealthLevel(); + SetStats(myTower); + } + + public void BuyArmorLevel() + { + SFXManager.instance.ButtonClick(); + myTower.BuyArmorLevel(); + SetStats(myTower); + } + + public void BuyShieldLevel() + { + SFXManager.instance.ButtonClick(); + myTower.BuyShieldLevel(); + SetStats(myTower); + } + + public void TogglePriorityUp(int index) + { + SFXManager.instance.ButtonClick(); + myTower.TogglePriority(index, 1); + priorityTexts[index].text = myTower.priorities[index].ToString(); + } + + public void TogglePriorityDown(int index) + { + SFXManager.instance.ButtonClick(); + myTower.TogglePriority(index, -1); + priorityTexts[index].text = myTower.priorities[index].ToString(); + } + + public void DemolishTower() + { + SFXManager.instance.ButtonClick(); + myTower.Demolish(); + CloseUI(); + } + + public void CloseUI() + { + UIManager.instance.CloseUI(base.gameObject); + } +} diff --git a/GameCode/TowerUnlockCard.cs b/GameCode/TowerUnlockCard.cs new file mode 100644 index 0000000..0f14ed3 --- /dev/null +++ b/GameCode/TowerUnlockCard.cs @@ -0,0 +1,16 @@ +using UnityEngine; + +public class TowerUnlockCard : UpgradeCard +{ + [SerializeField] + private GameObject towerUIObject; + + [SerializeField] + private bool isTower = true; + + public override void Upgrade() + { + base.Upgrade(); + TowerUnlockManager.instance.UnlockTower(towerUIObject, isTower); + } +} diff --git a/GameCode/TowerUnlockManager.cs b/GameCode/TowerUnlockManager.cs new file mode 100644 index 0000000..d96b9d5 --- /dev/null +++ b/GameCode/TowerUnlockManager.cs @@ -0,0 +1,54 @@ +using System.Collections.Generic; +using UnityEngine; + +public class TowerUnlockManager : MonoBehaviour +{ + public static TowerUnlockManager instance; + + [SerializeField] + private List<GameObject> unlockedTowers = new List<GameObject>(); + + [SerializeField] + private List<GameObject> unlockedBuildings = new List<GameObject>(); + + private void Awake() + { + instance = this; + } + + private void Start() + { + DisplayButtons(); + } + + public void UnlockTower(GameObject towerUIObject, bool isTower) + { + towerUIObject.SetActive(value: true); + if (isTower) + { + unlockedTowers.Add(towerUIObject); + } + else + { + unlockedBuildings.Add(towerUIObject); + } + DisplayButtons(); + } + + private void DisplayButtons() + { + int num = 0; + int num2 = ((unlockedBuildings.Count > 0) ? 1 : 0); + foreach (GameObject unlockedTower in unlockedTowers) + { + unlockedTower.transform.localPosition = new Vector3(num * 100 - unlockedTowers.Count * 50 + 50, 100 * num2, 0f); + num++; + } + num = 0; + foreach (GameObject unlockedBuilding in unlockedBuildings) + { + unlockedBuilding.transform.localPosition = new Vector3(num * 100 - unlockedBuildings.Count * 50 + 50, 0f, 0f); + num++; + } + } +} diff --git a/GameCode/TowerUpgradeCard.cs b/GameCode/TowerUpgradeCard.cs new file mode 100644 index 0000000..c37da5e --- /dev/null +++ b/GameCode/TowerUpgradeCard.cs @@ -0,0 +1,117 @@ +using UnityEngine; + +public class TowerUpgradeCard : UpgradeCard +{ + [SerializeField] + private TowerType towerType; + + [SerializeField] + private float range; + + [SerializeField] + private int damage; + + [SerializeField] + private int healthDmg; + + [SerializeField] + private int armorDmg; + + [SerializeField] + private int shieldDmg; + + [SerializeField] + private float slowPercent; + + [SerializeField] + private float bleedPercent; + + [SerializeField] + private float burnPercent; + + [SerializeField] + private float poisonPercent; + + [SerializeField] + private float blast; + + [SerializeField] + private float critChance; + + [SerializeField] + private float critChanceLevelMultiplier; + + [SerializeField] + private float stunChance; + + [SerializeField] + private float manaConsumptionAddition; + + [SerializeField] + private float obeliskTimeOnTargetMultiplier; + + public override void Upgrade() + { + if (range != 0f) + { + TowerManager.instance.AddBonusRange(towerType, range); + } + if (damage != 0) + { + TowerManager.instance.AddBonusBaseDamage(towerType, damage); + } + if (healthDmg != 0) + { + TowerManager.instance.AddBonusHealthDamage(towerType, healthDmg); + } + if (armorDmg != 0) + { + TowerManager.instance.AddBonusArmorDamage(towerType, armorDmg); + } + if (shieldDmg != 0) + { + TowerManager.instance.AddBonusShieldDamage(towerType, shieldDmg); + } + if (slowPercent != 0f) + { + TowerManager.instance.AddBonusSlow(towerType, slowPercent); + } + if (bleedPercent != 0f) + { + TowerManager.instance.AddBonusBleed(towerType, bleedPercent); + } + if (burnPercent != 0f) + { + TowerManager.instance.AddBonusBurn(towerType, burnPercent); + } + if (poisonPercent != 0f) + { + TowerManager.instance.AddBonusPoison(towerType, poisonPercent); + } + if (blast != 0f) + { + TowerManager.instance.AddBonusBlast(towerType, blast); + } + if (critChance != 0f) + { + TowerManager.instance.AddCritChance(towerType, critChance); + } + if (critChanceLevelMultiplier != 0f) + { + TowerManager.instance.AddCritChanceLevelMultiplier(towerType, critChanceLevelMultiplier); + } + if (stunChance != 0f) + { + TowerManager.instance.AddStunChance(towerType, stunChance); + } + if (manaConsumptionAddition != 0f) + { + TowerManager.instance.AddManaConsumption(towerType, manaConsumptionAddition); + } + if (obeliskTimeOnTargetMultiplier != 0f) + { + TowerManager.instance.obeliskTimeOnTargetMultiplier += obeliskTimeOnTargetMultiplier; + } + base.Upgrade(); + } +} diff --git a/GameCode/TreasureChest.cs b/GameCode/TreasureChest.cs new file mode 100644 index 0000000..cf18502 --- /dev/null +++ b/GameCode/TreasureChest.cs @@ -0,0 +1,26 @@ +using UnityEngine; + +public class TreasureChest : MonoBehaviour, IBuildable +{ + [SerializeField] + private GameObject uiObject; + + public int numberOfDrops = 1; + + private void Start() + { + } + + public void SpawnUI() + { + Object.Instantiate(uiObject, base.transform.position, Quaternion.identity).GetComponent<TreasureUI>().myChest = base.gameObject; + } + + public void Demolish() + { + } + + public void SetStats() + { + } +} diff --git a/GameCode/TreasureUI.cs b/GameCode/TreasureUI.cs new file mode 100644 index 0000000..c0e297f --- /dev/null +++ b/GameCode/TreasureUI.cs @@ -0,0 +1,30 @@ +using UnityEngine; + +public class TreasureUI : MonoBehaviour +{ + public GameObject myChest; + + private int cardDraw = 2; + + private void Start() + { + UIManager.instance.SetNewUI(base.gameObject); + cardDraw = 2 + PlayerPrefs.GetInt("TreasureDraw1", 0); + } + + public void Open() + { + SFXManager.instance.PlaySound(Sound.CritBig, myChest.transform.position); + for (int i = 0; i < myChest.GetComponent<TreasureChest>().numberOfDrops; i++) + { + CardManager.instance.DrawCards(cardDraw); + } + Die(); + } + + public void Die() + { + Object.Destroy(myChest); + UIManager.instance.CloseUI(base.gameObject); + } +} diff --git a/GameCode/UICameraController.cs b/GameCode/UICameraController.cs new file mode 100644 index 0000000..c309492 --- /dev/null +++ b/GameCode/UICameraController.cs @@ -0,0 +1,67 @@ +using UnityEngine; + +public class UICameraController : MonoBehaviour +{ + [SerializeField] + private float cameraSpeed = 10f; + + [SerializeField] + private float cameraZoom = 1f; + + private Vector3 oldPos; + + private void Start() + { + } + + private void Update() + { + UpdateMovement(); + UpdateZoom(); + } + + public void ResetPosition() + { + base.transform.localPosition = Vector3.zero; + cameraZoom = 1f; + base.transform.localScale = Vector3.one * cameraZoom; + } + + private Vector3 ViewPointToPixels(Vector3 view) + { + return new Vector3(view.x * (float)Camera.main.scaledPixelWidth, view.y * (float)Camera.main.scaledPixelHeight, 0f); + } + + private void UpdateMovement() + { + if (Input.GetMouseButtonDown(1)) + { + oldPos = ViewPointToPixels(Camera.main.ScreenToViewportPoint(Input.mousePosition)); + } + if (Input.GetMouseButton(1)) + { + Vector3 vector = ViewPointToPixels(Camera.main.ScreenToViewportPoint(Input.mousePosition)); + Vector3 translation = vector - oldPos; + translation.z = 0f; + base.transform.Translate(translation); + oldPos = vector; + } + else + { + Vector3 vector2 = new Vector3(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical"), 0f); + if (vector2.sqrMagnitude > 0.1f) + { + base.transform.Translate(-vector2.normalized * Time.deltaTime * cameraSpeed * (6f / (5f + cameraZoom))); + } + } + } + + private void UpdateZoom() + { + float num = cameraZoom; + cameraZoom = Mathf.Clamp(cameraZoom + Input.mouseScrollDelta.y / 10f, 0.5f, 2f); + base.transform.localScale = Vector3.one * cameraZoom; + base.transform.localPosition *= cameraZoom / num; + base.transform.localPosition += new Vector3(0f, 0.5f * (float)Camera.main.scaledPixelHeight * (cameraZoom - num), 0f); + } +} diff --git a/GameCode/UIManager.cs b/GameCode/UIManager.cs new file mode 100644 index 0000000..2a7081f --- /dev/null +++ b/GameCode/UIManager.cs @@ -0,0 +1,47 @@ +using UnityEngine; + +public class UIManager : MonoBehaviour +{ + public static UIManager instance; + + [SerializeField] + private LayerMask clickableMask; + + private GameObject currentUI; + + private void Awake() + { + instance = this; + } + + public void SetNewUI(GameObject newUI) + { + if (currentUI != null) + { + Object.Destroy(currentUI); + } + currentUI = newUI; + } + + public void CloseUI(GameObject oldUI) + { + currentUI = null; + Object.Destroy(oldUI); + } + + private void Update() + { + if (Input.GetKeyDown(KeyCode.Escape) && currentUI != null) + { + CloseUI(currentUI); + } + if (!BuildingManager.instance.buildMode && Input.GetMouseButtonDown(0) && Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out var hitInfo, 2000f, clickableMask, QueryTriggerInteraction.Collide)) + { + hitInfo.collider.GetComponent<IBuildable>()?.SpawnUI(); + } + if (Input.GetMouseButtonDown(1)) + { + CloseUI(currentUI); + } + } +} diff --git a/GameCode/UniBonusUI.cs b/GameCode/UniBonusUI.cs new file mode 100644 index 0000000..8d29a9b --- /dev/null +++ b/GameCode/UniBonusUI.cs @@ -0,0 +1,46 @@ +using UnityEngine; +using UnityEngine.UI; + +public class UniBonusUI : MonoBehaviour +{ + public static UniBonusUI instance; + + [SerializeField] + private GameObject uniUI; + + [SerializeField] + private Text uniUIText; + + private int healthTotal; + + private int armorTotal; + + private int shieldTotal; + + private void Awake() + { + instance = this; + } + + public void UniBonus(int health, int armor, int shield) + { + healthTotal += health; + armorTotal += armor; + shieldTotal += shield; + uniUI.SetActive(value: true); + string text = ""; + if (healthTotal > 0) + { + text = text + "+" + healthTotal + "HD"; + } + if (armorTotal > 0) + { + text = text + "\n+" + armorTotal + "AD"; + } + if (shieldTotal > 0) + { + text = text + "\n+" + shieldTotal + "SD"; + } + uniUIText.text = text; + } +} diff --git a/GameCode/University.cs b/GameCode/University.cs new file mode 100644 index 0000000..5115f50 --- /dev/null +++ b/GameCode/University.cs @@ -0,0 +1,150 @@ +using UnityEngine; + +public class University : MonoBehaviour, IBuildable +{ + [SerializeField] + private GameObject UIObject; + + [SerializeField] + private GameObject mainUIObject; + + public int goldBackOnDemolish; + + [SerializeField] + private LayerMask layermask; + + private bool active; + + public int healthPercent { get; private set; } + + public int armorPercent { get; private set; } + + public int shieldPercent { get; private set; } + + public int healthGained { get; private set; } + + public int armorGained { get; private set; } + + public int shieldGained { get; private set; } + + private void Start() + { + SpawnManager.instance.universities.Add(this); + DetectShrines(); + } + + public void SetStats() + { + } + + public void Research() + { + if (active) + { + if (Random.Range(0f, 100f) <= (float)(healthPercent + GameManager.instance.universityBonus)) + { + healthGained++; + TowerManager.instance.AddBonusHealthDamage(TowerType.Global, 1); + UniBonusUI.instance.UniBonus(1, 0, 0); + DamageNumber component = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component.SetText("New Discoveries!", "Grey", 1f); + component.SetHoldTime(2f); + AchievementManager.instance.NewDiscoveriesAchievement(); + } + if (Random.Range(0f, 100f) <= (float)(armorPercent + GameManager.instance.universityBonus)) + { + armorGained++; + UniBonusUI.instance.UniBonus(0, 1, 0); + TowerManager.instance.AddBonusArmorDamage(TowerType.Global, 1); + DamageNumber component2 = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component2.SetText("New Discoveries!", "Grey", 1f); + component2.SetHoldTime(2f); + AchievementManager.instance.NewDiscoveriesAchievement(); + } + if (Random.Range(0f, 100f) <= (float)(shieldPercent + GameManager.instance.universityBonus)) + { + shieldGained++; + UniBonusUI.instance.UniBonus(0, 0, 1); + TowerManager.instance.AddBonusShieldDamage(TowerType.Global, 1); + DamageNumber component3 = ObjectPool.instance.SpawnObject(ObjectPool.ObjectType.DamageNumber, base.transform.position, Quaternion.identity).GetComponent<DamageNumber>(); + component3.SetText("New Discoveries!", "Grey", 1f); + component3.SetHoldTime(2f); + AchievementManager.instance.NewDiscoveriesAchievement(); + } + } + } + + public void FundHealthStudies() + { + int num = (healthPercent + armorPercent + shieldPercent + 1) * 20; + if (ResourceManager.instance.CheckMoney(num)) + { + healthPercent++; + ResourceManager.instance.Spend(num); + AchievementManager.instance.FundResearchAchievement(num); + } + } + + public void FundArmorStudies() + { + int num = (healthPercent + armorPercent + shieldPercent + 1) * 20; + if (ResourceManager.instance.CheckMoney(num)) + { + armorPercent++; + ResourceManager.instance.Spend(num); + AchievementManager.instance.FundResearchAchievement(num); + } + } + + public void FundShieldStudies() + { + int num = (healthPercent + armorPercent + shieldPercent + 1) * 20; + if (ResourceManager.instance.CheckMoney(num)) + { + shieldPercent++; + ResourceManager.instance.Spend(num); + AchievementManager.instance.FundResearchAchievement(num); + } + } + + public void SpawnUI() + { + if (!active) + { + Object.Instantiate(UIObject, base.transform.position, Quaternion.identity).GetComponent<SimpleUI>().SetDemolishable(base.gameObject, goldBackOnDemolish); + } + else + { + Object.Instantiate(mainUIObject, base.transform.position, Quaternion.identity).GetComponent<UniversityUI>().SetStats(this); + } + } + + public void Demolish() + { + SpawnManager.instance.universities.Remove(this); + } + + private void DetectShrines() + { + if ((!Physics.Raycast(base.transform.position + new Vector3(1f, 1f, 0f), -base.transform.up, out var hitInfo, 1f, layermask, QueryTriggerInteraction.Ignore) || !Rotate(hitInfo)) && (!Physics.Raycast(base.transform.position + new Vector3(-1f, 1f, 0f), -base.transform.up, out hitInfo, 1f, layermask, QueryTriggerInteraction.Ignore) || !Rotate(hitInfo)) && (!Physics.Raycast(base.transform.position + new Vector3(0f, 1f, 1f), -base.transform.up, out hitInfo, 1f, layermask, QueryTriggerInteraction.Ignore) || !Rotate(hitInfo)) && Physics.Raycast(base.transform.position + new Vector3(0f, 1f, -1f), -base.transform.up, out hitInfo, 1f, layermask, QueryTriggerInteraction.Ignore)) + { + Rotate(hitInfo); + } + } + + private bool Rotate(RaycastHit hit) + { + if (hit.collider.GetComponent<Shrine>() == null) + { + return false; + } + if ((double)(hit.collider.transform.position.y - base.transform.position.y) > 0.001) + { + return false; + } + base.transform.LookAt(hit.collider.transform.position, Vector3.up); + active = true; + SetStats(); + return true; + } +} diff --git a/GameCode/UniversityUI.cs b/GameCode/UniversityUI.cs new file mode 100644 index 0000000..bf7b8bd --- /dev/null +++ b/GameCode/UniversityUI.cs @@ -0,0 +1,135 @@ +using UnityEngine; +using UnityEngine.UI; + +public class UniversityUI : MonoBehaviour +{ + private University myUniversity; + + [SerializeField] + private Text healthCostText; + + [SerializeField] + private Text armorCostText; + + [SerializeField] + private Text shieldCostText; + + [SerializeField] + private Text healthDiscoveresText; + + [SerializeField] + private Text armorDiscoveriesText; + + [SerializeField] + private Text shieldDiscoveriesText; + + [SerializeField] + private Text healthBonusText; + + [SerializeField] + private Text armorBonusText; + + [SerializeField] + private Text shieldBonusText; + + [SerializeField] + private Text healthPercentageText; + + [SerializeField] + private Text armorPercentageText; + + [SerializeField] + private Text shieldPercentageText; + + [SerializeField] + private Image healthPercentageImg; + + [SerializeField] + private Image armorPercentageImg; + + [SerializeField] + private Image shieldPercentageImg; + + [SerializeField] + private Text demolishText; + + private void Start() + { + UIManager.instance.SetNewUI(base.gameObject); + if (demolishText != null) + { + demolishText.text = "Demolish (" + myUniversity.goldBackOnDemolish + "g)"; + } + } + + public void SetStats(University myUni) + { + myUniversity = myUni; + int num = (myUniversity.healthPercent + myUniversity.armorPercent + myUniversity.shieldPercent + 1) * 20; + healthCostText.text = num.ToString(); + armorCostText.text = num.ToString(); + shieldCostText.text = num.ToString(); + healthDiscoveresText.text = "Health Studies: " + myUniversity.healthGained; + armorDiscoveriesText.text = "Armor Studies: " + myUniversity.armorGained; + shieldDiscoveriesText.text = "Magic Studies: " + myUniversity.shieldGained; + healthBonusText.text = "Global Health Damage: +" + myUniversity.healthGained; + armorBonusText.text = "Global Armor Damage: +" + myUniversity.armorGained; + shieldBonusText.text = "Global Shield Damage: +" + myUniversity.shieldGained; + healthPercentageText.text = "Health Studies: " + (myUniversity.healthPercent + GameManager.instance.universityBonus) + "%"; + armorPercentageText.text = "Armor Studies: " + (myUniversity.armorPercent + GameManager.instance.universityBonus) + "%"; + shieldPercentageText.text = "Magic Studies: " + (myUniversity.shieldPercent + GameManager.instance.universityBonus) + "%"; + healthPercentageImg.rectTransform.sizeDelta = new Vector2((float)(myUniversity.healthPercent + GameManager.instance.universityBonus) / 10f, 0.25f); + armorPercentageImg.rectTransform.sizeDelta = new Vector2((float)(myUniversity.armorPercent + GameManager.instance.universityBonus) / 10f, 0.25f); + shieldPercentageImg.rectTransform.sizeDelta = new Vector2((float)(myUniversity.shieldPercent + GameManager.instance.universityBonus) / 10f, 0.25f); + if (demolishText != null) + { + demolishText.text = "Demolish (" + myUniversity.goldBackOnDemolish + "g)"; + } + } + + private void Update() + { + if (Input.GetKeyDown(KeyCode.Alpha1) || Input.GetKeyDown(KeyCode.Keypad1)) + { + FundHealthResearch(); + } + if (Input.GetKeyDown(KeyCode.Alpha2) || Input.GetKeyDown(KeyCode.Keypad2)) + { + FundArmorResearch(); + } + if (Input.GetKeyDown(KeyCode.Alpha3) || Input.GetKeyDown(KeyCode.Keypad3)) + { + FundShieldResearch(); + } + } + + public void FundHealthResearch() + { + SFXManager.instance.ButtonClick(); + myUniversity.FundHealthStudies(); + SetStats(myUniversity); + } + + public void FundArmorResearch() + { + SFXManager.instance.ButtonClick(); + myUniversity.FundArmorStudies(); + SetStats(myUniversity); + } + + public void FundShieldResearch() + { + SFXManager.instance.ButtonClick(); + myUniversity.FundShieldStudies(); + SetStats(myUniversity); + } + + public void Demolish() + { + SFXManager.instance.ButtonClick(); + myUniversity.Demolish(); + Object.Destroy(myUniversity.gameObject); + ResourceManager.instance.AddMoney(myUniversity.goldBackOnDemolish); + UIManager.instance.CloseUI(base.gameObject); + } +} diff --git a/GameCode/UniversityUpgrade.cs b/GameCode/UniversityUpgrade.cs new file mode 100644 index 0000000..391c336 --- /dev/null +++ b/GameCode/UniversityUpgrade.cs @@ -0,0 +1,13 @@ +using UnityEngine; + +public class UniversityUpgrade : UpgradeCard +{ + [SerializeField] + private int bonus = 1; + + public override void Upgrade() + { + base.Upgrade(); + GameManager.instance.universityBonus += bonus; + } +} diff --git a/GameCode/UpgradeButton.cs b/GameCode/UpgradeButton.cs new file mode 100644 index 0000000..271976b --- /dev/null +++ b/GameCode/UpgradeButton.cs @@ -0,0 +1,167 @@ +using System.Collections; +using UnityEngine; +using UnityEngine.UI; + +public class UpgradeButton : MonoBehaviour +{ + [SerializeField] + private string unlockString; + + [SerializeField] + public int xpCost; + + public int cardCountRequirement; + + [SerializeField] + private bool countsAsCardUnlock = true; + + [SerializeField] + private bool countAsDevelopment; + + [SerializeField] + private Sprite unlockedSprite; + + [SerializeField] + private bool checkAchievements; + + [SerializeField] + private GameObject priceTag; + + private GameObject currentPriceTag; + + private Image img; + + private Button btn; + + [SerializeField] + private UpgradeButton previous; + + [SerializeField] + private UpgradeButton[] next; + + public bool unlocked; + + private void Start() + { + img = GetComponent<Image>(); + btn = GetComponent<Button>(); + CheckUnlock(); + StartCoroutine(LateStart()); + } + + public void Unlock() + { + if (UpgradeManager.instance.xp >= xpCost) + { + SFXManager.instance.ButtonClick(); + UpgradeManager.instance.AddXP(-xpCost); + PlayerPrefs.SetInt(unlockString, 1); + if (checkAchievements) + { + AchievementManager.instance.CheckTowerUnlocks(); + } + UpgradeManager.instance.CountCard(countsAsCardUnlock); + UpgradeManager.instance.CountDevelopment(countAsDevelopment); + btn.enabled = false; + img.sprite = unlockedSprite; + unlocked = true; + UpdateTitleText(); + UpgradeButton[] array = next; + for (int i = 0; i < array.Length; i++) + { + array[i].CheckEnabled(); + } + } + } + + public void ResetUnlock() + { + PlayerPrefs.SetInt(unlockString, 0); + unlocked = false; + } + + private void CheckUnlock() + { + if (PlayerPrefs.GetInt(unlockString, 0) == 1) + { + btn.enabled = false; + img.sprite = unlockedSprite; + unlocked = true; + } + } + + public void CheckEnabled() + { + if (previous == null) + { + if (cardCountRequirement <= UpgradeManager.instance.unlockedCardCount) + { + btn.interactable = true; + } + else + { + btn.interactable = false; + } + UpdateTitleText(); + } + else + { + if (previous.unlocked && cardCountRequirement <= UpgradeManager.instance.unlockedCardCount) + { + btn.interactable = true; + } + else + { + btn.interactable = false; + } + UpdateTitleText(); + } + } + + private void UpdateTitleText() + { + if (!unlocked) + { + if (currentPriceTag == null) + { + currentPriceTag = Object.Instantiate(priceTag, base.transform); + currentPriceTag.transform.localPosition = new Vector3(-63.7f, 0f, 0f); + int num = cardCountRequirement - UpgradeManager.instance.unlockedCardCount; + if (num > 0) + { + currentPriceTag.GetComponent<RectTransform>().sizeDelta = new Vector2(75f, 50f); + currentPriceTag.GetComponentInChildren<Text>().text = " Unlock " + num + "\n more cards"; + } + else + { + currentPriceTag.GetComponent<RectTransform>().sizeDelta = new Vector2(50f, 25f); + currentPriceTag.GetComponentInChildren<Text>().text = xpCost + " xp"; + } + } + else + { + int num2 = cardCountRequirement - UpgradeManager.instance.unlockedCardCount; + if (num2 > 0) + { + currentPriceTag.GetComponent<RectTransform>().sizeDelta = new Vector2(75f, 50f); + currentPriceTag.GetComponentInChildren<Text>().text = " Unlock " + num2 + "\n more cards"; + } + else + { + currentPriceTag.GetComponent<RectTransform>().sizeDelta = new Vector2(50f, 25f); + currentPriceTag.GetComponentInChildren<Text>().text = xpCost + " xp"; + } + } + } + else if (currentPriceTag != null) + { + currentPriceTag.SetActive(value: false); + } + } + + private IEnumerator LateStart() + { + yield return new WaitForSeconds(0.1f); + CheckEnabled(); + } +} diff --git a/GameCode/UpgradeCard.cs b/GameCode/UpgradeCard.cs new file mode 100644 index 0000000..45b6ce8 --- /dev/null +++ b/GameCode/UpgradeCard.cs @@ -0,0 +1,37 @@ +using System.Collections.Generic; +using UnityEngine; + +public class UpgradeCard : MonoBehaviour +{ + [SerializeField] + private string unlockName; + + [SerializeField] + private bool unlockedByDefault; + + public bool unlocked; + + public string title; + + public Sprite image; + + public string description; + + public List<UpgradeCard> unlocks = new List<UpgradeCard>(); + + private void Awake() + { + if (unlockedByDefault || PlayerPrefs.GetInt(unlockName, 0) == 1) + { + unlocked = true; + } + else + { + unlocked = false; + } + } + + public virtual void Upgrade() + { + } +} diff --git a/GameCode/UpgradeManager.cs b/GameCode/UpgradeManager.cs new file mode 100644 index 0000000..685308e --- /dev/null +++ b/GameCode/UpgradeManager.cs @@ -0,0 +1,120 @@ +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.UI; + +public class UpgradeManager : MonoBehaviour +{ + public static UpgradeManager instance; + + public int xp; + + public int prestige; + + [SerializeField] + private Text xpText; + + [SerializeField] + private GameObject prestigeDisplay; + + [SerializeField] + private Text prestigeText; + + public int unlockedCardCount; + + [SerializeField] + private UpgradeButton[] allButtons; + + [SerializeField] + private List<UpgradeButton> cardsWhichRequireCardCount = new List<UpgradeButton>(); + + private void Awake() + { + instance = this; + } + + private void Start() + { + allButtons = Object.FindObjectsOfType<UpgradeButton>(); + UpgradeButton[] array = allButtons; + foreach (UpgradeButton upgradeButton in array) + { + if (upgradeButton.cardCountRequirement > 0) + { + cardsWhichRequireCardCount.Add(upgradeButton); + } + } + unlockedCardCount = PlayerPrefs.GetInt("UnlockedCardCount", 0); + xp = PlayerPrefs.GetInt("XP", 0); + xpText.text = "XP: " + xp; + prestige = PlayerPrefs.GetInt("Prestige", 0); + if (prestige > 0) + { + prestigeDisplay.SetActive(value: true); + prestigeText.text = "Prestige: " + prestige; + } + } + + public void AddXP(int change) + { + xp += change; + PlayerPrefs.SetInt("XP", xp); + xpText.text = "XP: " + xp; + } + + public void ResetUpgrades() + { + int num = 0; + UpgradeButton[] array = allButtons; + foreach (UpgradeButton upgradeButton in array) + { + if (upgradeButton.enabled) + { + if (upgradeButton.unlocked) + { + num += upgradeButton.xpCost; + } + upgradeButton.ResetUnlock(); + } + } + num += xp / 2; + Debug.Log("Refunded xp: " + num); + PlayerPrefs.SetInt("Prestige", prestige + num / 1000); + xp = 0; + PlayerPrefs.SetInt("XP", 0); + PlayerPrefs.SetInt("UnlockedCardCount", 0); + PlayerPrefs.SetInt("Development", 0); + PlayerPrefs.SetInt("Record1", 0); + PlayerPrefs.SetInt("Record2", 0); + PlayerPrefs.SetInt("Record3", 0); + LevelLoader.instance.LoadLevel("MainMenu"); + } + + public void CountCard(bool countsAsCardUnlock) + { + if (countsAsCardUnlock) + { + unlockedCardCount++; + Debug.Log("Number of unlocked cards: " + unlockedCardCount); + PlayerPrefs.SetInt("UnlockedCardCount", unlockedCardCount); + CheckCardCount(); + } + } + + public void CountDevelopment(bool value) + { + if (value) + { + int @int = PlayerPrefs.GetInt("Development", 0); + PlayerPrefs.SetInt("Development", @int + 1); + Debug.Log("Development: " + (@int + 1)); + } + } + + public void CheckCardCount() + { + foreach (UpgradeButton item in cardsWhichRequireCardCount) + { + item.CheckEnabled(); + } + } +} diff --git a/GameCode/WalkAnimator.cs b/GameCode/WalkAnimator.cs new file mode 100644 index 0000000..4f2b997 --- /dev/null +++ b/GameCode/WalkAnimator.cs @@ -0,0 +1,55 @@ +using System; +using UnityEngine; + +public class WalkAnimator : MonoBehaviour +{ + private Pathfinder p; + + [SerializeField] + private Transform directionalTransform; + + [SerializeField] + private Transform rotationalOffsetTransform; + + [SerializeField] + private Transform artTransform; + + [SerializeField] + private float strideLength = 1f; + + [SerializeField] + private float strideHeight = 1f; + + [SerializeField] + private float sideAngles = 20f; + + [SerializeField] + private float strideVariationPercentage = 0.1f; + + private float step; + + private Vector3 preiviousPosition; + + private Vector3 direction; + + private void Start() + { + strideLength = UnityEngine.Random.Range(strideLength * (1f - strideVariationPercentage), strideLength * (1f + strideVariationPercentage)); + strideHeight = UnityEngine.Random.Range(strideHeight * (1f - strideVariationPercentage), strideHeight * (1f + strideVariationPercentage)); + p = GetComponent<Pathfinder>(); + preiviousPosition = base.transform.position; + } + + private void FixedUpdate() + { + direction = base.transform.position - preiviousPosition; + preiviousPosition = base.transform.position; + if (direction.sqrMagnitude != 0f) + { + directionalTransform.rotation = Quaternion.LookRotation(direction, Vector3.up); + } + step = (step + p.speed * Time.fixedDeltaTime / strideLength) % 2f; + artTransform.localPosition = strideHeight * Vector3.up * Mathf.Abs(Mathf.Cos(step * (float)Math.PI)); + artTransform.localEulerAngles = new Vector3(sideAngles * Mathf.Sin(step * (float)Math.PI), 0f, 0f); + } +} diff --git a/GameCode/Waypoint.cs b/GameCode/Waypoint.cs new file mode 100644 index 0000000..b250079 --- /dev/null +++ b/GameCode/Waypoint.cs @@ -0,0 +1,62 @@ +using System.Collections.Generic; +using UnityEngine; + +public class Waypoint : MonoBehaviour +{ + [SerializeField] + private Waypoint next; + + [SerializeField] + private List<Waypoint> previous = new List<Waypoint>(); + + public float distanceFromEnd; + + public bool trueDistance; + + private void Start() + { + UpdateDistance(); + } + + public Waypoint GetNextWaypoint() + { + if (next != null) + { + return next; + } + return this; + } + + public void SetNextWaypoint(Waypoint newNext) + { + next = newNext; + } + + public void AddPreviousWaypoint(Waypoint previousWaypoint) + { + previous.Add(previousWaypoint); + } + + public Waypoint[] GetPreviousWaypoints() + { + return previous.ToArray(); + } + + public void UpdateDistance() + { + if (next == null) + { + trueDistance = true; + return; + } + if (!next.trueDistance) + { + next.UpdateDistance(); + } + if (!trueDistance) + { + distanceFromEnd = next.distanceFromEnd + Vector3.Magnitude(next.transform.position - base.transform.position); + trueDistance = true; + } + } +} |