summaryrefslogtreecommitdiff
path: root/Assembly_CSharp/_Tower
diff options
context:
space:
mode:
Diffstat (limited to 'Assembly_CSharp/_Tower')
-rw-r--r--Assembly_CSharp/_Tower/BiPlane.cs161
-rw-r--r--Assembly_CSharp/_Tower/Dropper.cs126
-rw-r--r--Assembly_CSharp/_Tower/FlameThrower.cs68
-rw-r--r--Assembly_CSharp/_Tower/Lookout.cs97
-rw-r--r--Assembly_CSharp/_Tower/Morter.cs39
-rw-r--r--Assembly_CSharp/_Tower/Obelisk.cs99
-rw-r--r--Assembly_CSharp/_Tower/RadarTower.cs71
-rw-r--r--Assembly_CSharp/_Tower/TeslaCoil.cs45
-rw-r--r--Assembly_CSharp/_Tower/Tower.cs509
-rw-r--r--Assembly_CSharp/_Tower/TowerFlyweight.cs279
-rw-r--r--Assembly_CSharp/_Tower/TowerManager.cs1386
-rw-r--r--Assembly_CSharp/_Tower/TowerType.cs18
12 files changed, 2898 insertions, 0 deletions
diff --git a/Assembly_CSharp/_Tower/BiPlane.cs b/Assembly_CSharp/_Tower/BiPlane.cs
new file mode 100644
index 0000000..bcf32e5
--- /dev/null
+++ b/Assembly_CSharp/_Tower/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/Assembly_CSharp/_Tower/Dropper.cs b/Assembly_CSharp/_Tower/Dropper.cs
new file mode 100644
index 0000000..0dc7a10
--- /dev/null
+++ b/Assembly_CSharp/_Tower/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/Assembly_CSharp/_Tower/FlameThrower.cs b/Assembly_CSharp/_Tower/FlameThrower.cs
new file mode 100644
index 0000000..d415d88
--- /dev/null
+++ b/Assembly_CSharp/_Tower/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/Assembly_CSharp/_Tower/Lookout.cs b/Assembly_CSharp/_Tower/Lookout.cs
new file mode 100644
index 0000000..3abd55b
--- /dev/null
+++ b/Assembly_CSharp/_Tower/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/Assembly_CSharp/_Tower/Morter.cs b/Assembly_CSharp/_Tower/Morter.cs
new file mode 100644
index 0000000..2170da3
--- /dev/null
+++ b/Assembly_CSharp/_Tower/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/Assembly_CSharp/_Tower/Obelisk.cs b/Assembly_CSharp/_Tower/Obelisk.cs
new file mode 100644
index 0000000..549f3b4
--- /dev/null
+++ b/Assembly_CSharp/_Tower/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/Assembly_CSharp/_Tower/RadarTower.cs b/Assembly_CSharp/_Tower/RadarTower.cs
new file mode 100644
index 0000000..e0d8d1d
--- /dev/null
+++ b/Assembly_CSharp/_Tower/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/Assembly_CSharp/_Tower/TeslaCoil.cs b/Assembly_CSharp/_Tower/TeslaCoil.cs
new file mode 100644
index 0000000..97954e7
--- /dev/null
+++ b/Assembly_CSharp/_Tower/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/Assembly_CSharp/_Tower/Tower.cs b/Assembly_CSharp/_Tower/Tower.cs
new file mode 100644
index 0000000..4098bd6
--- /dev/null
+++ b/Assembly_CSharp/_Tower/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/Assembly_CSharp/_Tower/TowerFlyweight.cs b/Assembly_CSharp/_Tower/TowerFlyweight.cs
new file mode 100644
index 0000000..b63f8b4
--- /dev/null
+++ b/Assembly_CSharp/_Tower/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/Assembly_CSharp/_Tower/TowerManager.cs b/Assembly_CSharp/_Tower/TowerManager.cs
new file mode 100644
index 0000000..abdca52
--- /dev/null
+++ b/Assembly_CSharp/_Tower/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/Assembly_CSharp/_Tower/TowerType.cs b/Assembly_CSharp/_Tower/TowerType.cs
new file mode 100644
index 0000000..9bbc242
--- /dev/null
+++ b/Assembly_CSharp/_Tower/TowerType.cs
@@ -0,0 +1,18 @@
+public enum TowerType
+{
+ Crossbow,
+ Morter,
+ TeslaCoil,
+ Frost,
+ Obelisk,
+ FlameThrower,
+ PoisonSprayer,
+ Siphon,
+ Radar,
+ ParticleCannon,
+ DOT,
+ Global,
+ Shredder,
+ Encampment,
+ Lookout
+}
generated by cgit v1.1-26-g67d0 at 2025-05-28 08:00:33 +0000