* move

10 files changed, 577 insertions, 0 deletions

diff --git a/Assembly_CSharp/Card/CardManager.cs b/Assembly_CSharp/Card/CardManager.cs
new file mode 100644
index 0000000..08797d3
--- /dev/null
+++ b/Assembly_CSharp/Card/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/Assembly_CSharp/Card/DOTUpgradeCard.cs b/Assembly_CSharp/Card/DOTUpgradeCard.cs
new file mode 100644
index 0000000..e90b065
--- /dev/null
+++ b/Assembly_CSharp/Card/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/Assembly_CSharp/Card/GoldRushCard.cs b/Assembly_CSharp/Card/GoldRushCard.cs
new file mode 100644
index 0000000..79663ce
--- /dev/null
+++ b/Assembly_CSharp/Card/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/Assembly_CSharp/Card/ManaGenUpgradeCard.cs b/Assembly_CSharp/Card/ManaGenUpgradeCard.cs
new file mode 100644
index 0000000..e56b63a
--- /dev/null
+++ b/Assembly_CSharp/Card/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/Assembly_CSharp/Card/MaxHealthUpgradeCard.cs b/Assembly_CSharp/Card/MaxHealthUpgradeCard.cs
new file mode 100644
index 0000000..467b669
--- /dev/null
+++ b/Assembly_CSharp/Card/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/Assembly_CSharp/Card/MonsterUpgradeCard.cs b/Assembly_CSharp/Card/MonsterUpgradeCard.cs
new file mode 100644
index 0000000..d78ab81
--- /dev/null
+++ b/Assembly_CSharp/Card/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/Assembly_CSharp/Card/TowerUnlockCard.cs b/Assembly_CSharp/Card/TowerUnlockCard.cs
new file mode 100644
index 0000000..0f14ed3
--- /dev/null
+++ b/Assembly_CSharp/Card/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/Assembly_CSharp/Card/TowerUpgradeCard.cs b/Assembly_CSharp/Card/TowerUpgradeCard.cs
new file mode 100644
index 0000000..c37da5e
--- /dev/null
+++ b/Assembly_CSharp/Card/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/Assembly_CSharp/Card/UniversityUpgrade.cs b/Assembly_CSharp/Card/UniversityUpgrade.cs
new file mode 100644
index 0000000..391c336
--- /dev/null
+++ b/Assembly_CSharp/Card/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/Assembly_CSharp/Card/UpgradeCard.cs b/Assembly_CSharp/Card/UpgradeCard.cs
new file mode 100644
index 0000000..45b6ce8
--- /dev/null
+++ b/Assembly_CSharp/Card/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()
+	{
+	}
+}