using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using DarkTonic.MasterAudio;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

// Token: 0x020000A0 RID: 160
public class CreationSkills : MonoBehaviour
{
	// Token: 0x06000F17 RID: 3863 RVA: 0x00125B5C File Offset: 0x00123D5C
	private void Start()
	{
	}

	// Token: 0x06000F18 RID: 3864 RVA: 0x00125B5E File Offset: 0x00123D5E
	private void OnDisable()
	{
		this.openNum = -1;
		this.currentIndex = -1;
		this.confirming = false;
		this.savingSpell = false;
	}

	// Token: 0x06000F19 RID: 3865 RVA: 0x00125B7C File Offset: 0x00123D7C
	public void OpenMenuFromButton(Creation creationMenu, string clickedSkill, Character currCharacter)
	{
		this.arrayCount = this.textureSize * this.textureSize;
		this.creation = creationMenu;
		this.creation.animator.Play("CreationSpellsOpen");
		this.currentIndex = -1;
		for (int i = 0; i < this.characterOrder.Count; i++)
		{
			if (this.characterOrder[i] == currCharacter && clickedSkill == this.skillOrder[i])
			{
				this.currentIndex = i;
				break;
			}
		}
		this.opened = true;
		this.StartNewChoice();
	}

	// Token: 0x06000F1A RID: 3866 RVA: 0x00125C14 File Offset: 0x00123E14
	public void OpenMenu(Creation creationMenu)
	{
		this.arrayCount = this.textureSize * this.textureSize;
		this.creation = creationMenu;
		this.creation.animator.Play("CreationSpellsOpen");
		this.currentIndex = 0;
		this.opened = true;
		this.StartNewChoice();
	}

	// Token: 0x06000F1B RID: 3867 RVA: 0x00125C64 File Offset: 0x00123E64
	private void Update()
	{
		if (this.spells && this.backButton.interactable)
		{
			if (Time.realtimeSinceStartup > this.fillUpdateTime + 0.25f && this.character)
			{
				this.incompleteFillCount++;
				if (this.incompleteFillCount > 3)
				{
					this.incompleteFillCount = 0;
				}
				for (int i = 0; i < this.scrollCount; i++)
				{
					if (this.fillStatus[i] == 1)
					{
						this.CheckSpellFillStatus(i, true);
						if (this.fillStatus[i] == 1)
						{
							if (this.incompleteFillCount == 0)
							{
								this.scrollFills[i].sprite = this.scrollFillSpellsNotComplete4;
							}
							if (this.incompleteFillCount == 3)
							{
								this.scrollFills[i].sprite = this.scrollFillSpellsNotComplete3;
							}
							if (this.incompleteFillCount == 2)
							{
								this.scrollFills[i].sprite = this.scrollFillSpellsNotComplete2;
							}
							if (this.incompleteFillCount == 1)
							{
								this.scrollFills[i].sprite = this.scrollFillSpellsNotComplete1;
							}
						}
					}
				}
				this.fillUpdateTime = Time.realtimeSinceStartup;
			}
			else
			{
				for (int j = 0; j < this.scrollCount; j++)
				{
					if (this.fillStatus[j] == 1)
					{
						this.CheckSpellFillStatus(j, true);
					}
				}
			}
		}
		if (Time.realtimeSinceStartup > this.updateTime + 0.15f && this.character)
		{
			this.updateTime = Time.realtimeSinceStartup;
			this.currIndex++;
			if (this.currIndex > 4)
			{
				this.currIndex = 0;
			}
			this.portrait.texture = this.character.characterSheetPortrait.GetTextureIdle(this.currIndex);
		}
	}

	// Token: 0x06000F1C RID: 3868 RVA: 0x00125E30 File Offset: 0x00124030
	public void StartNewChoice()
	{
		if (this.currentIndex < this.skillOrder.Count)
		{
			this.newSelection = false;
			this.openNum = -1;
			this.character = this.characterOrder[this.currentIndex];
			this.currentSkill = this.skillOrder[this.currentIndex];
			this.spells = false;
			this.words = false;
			this.songs = false;
			this.maxSelections = this.GetMaxSelections(this.currentSkill, this.skillType[this.currentIndex]);
			if (this.currentSkill == "Vines" || this.currentSkill == "Fauna" || this.currentSkill == "Spores")
			{
				this.spells = true;
				if (this.currentSkill == "Vines")
				{
					this.drawImage.material = this.vines;
				}
				if (this.currentSkill == "Fauna")
				{
					this.drawImage.material = this.fauna;
				}
				if (this.currentSkill == "Spores")
				{
					this.drawImage.material = this.spores;
				}
			}
			if (this.currentSkill == "Melee" || this.currentSkill == "Range" || this.currentSkill == "Defense")
			{
				this.words = true;
			}
			if (this.currentSkill == "Horn" || this.currentSkill == "Flute" || this.currentSkill == "Drum")
			{
				this.songs = true;
			}
			for (int i = 0; i < 6; i++)
			{
				if (i < this.scrollCount)
				{
					this.scrollMainImages[i].gameObject.transform.parent.SetParent(this.usedScrolls, true);
				}
				else
				{
					this.scrollMainImages[i].gameObject.transform.parent.SetParent(this.unusedScrolls, true);
				}
				this.SetScrollStateAll(true, i);
			}
			this.str.Clear();
			if (this.character.stats.displayName != "")
			{
				this.str.Append(this.character.stats.displayName);
				this.str.Append("'s ");
			}
			this.str.Append(Links.x.manual.DisplayName(this.currentSkill));
			this.title.text = this.str.ToString();
			this.str.Clear();
			this.str.Append("Select ");
			if (this.maxSelections == 3)
			{
				this.str.Append("three");
			}
			else if (this.maxSelections == 2)
			{
				this.str.Append("two");
			}
			else
			{
				this.str.Append("one");
			}
			if (this.songs)
			{
				this.str.Append(" song");
			}
			if (this.words)
			{
				this.str.Append(" word");
			}
			if (this.spells)
			{
				this.str.Append(" spell");
			}
			if (this.maxSelections > 1)
			{
				this.str.Append("s");
			}
			this.message.text = this.str.ToString();
			foreach (Image image in this.scrollFills)
			{
				if (this.songs)
				{
					image.sprite = this.scrollFillSongs;
				}
				if (this.words)
				{
					image.sprite = this.scrollFillWords;
				}
				if (this.spells)
				{
					image.sprite = this.scrollFillSpells;
				}
				image.enabled = false;
			}
			if (this.spells)
			{
				this.ResetDrawings();
			}
			for (int j = 0; j < this.scrollCount; j++)
			{
				this.fillStatus[j] = 0;
				if (this.spells)
				{
					bool flag = false;
					if (this.characterLearned1[this.currentIndex] == j)
					{
						flag = true;
					}
					if (this.characterLearned2[this.currentIndex] == j)
					{
						flag = true;
					}
					if (this.characterLearned3[this.currentIndex] == j)
					{
						flag = true;
					}
					if (flag)
					{
						this.fillStatus[j] = 1;
						this.CheckSpellFillStatus(j, false);
						if (this.fillStatus[j] == 1)
						{
							if (this.incompleteFillCount == 0)
							{
								this.scrollFills[j].sprite = this.scrollFillSpellsNotComplete4;
							}
							if (this.incompleteFillCount == 3)
							{
								this.scrollFills[j].sprite = this.scrollFillSpellsNotComplete3;
							}
							if (this.incompleteFillCount == 2)
							{
								this.scrollFills[j].sprite = this.scrollFillSpellsNotComplete2;
							}
							if (this.incompleteFillCount == 1)
							{
								this.scrollFills[j].sprite = this.scrollFillSpellsNotComplete1;
							}
						}
					}
				}
				else
				{
					bool flag2 = false;
					if (this.characterLearned1[this.currentIndex] == j)
					{
						flag2 = true;
					}
					if (this.characterLearned2[this.currentIndex] == j)
					{
						flag2 = true;
					}
					if (this.characterLearned3[this.currentIndex] == j)
					{
						flag2 = true;
					}
					if (flag2)
					{
						this.fillStatus[j] = 2;
					}
				}
			}
			int num = 0;
			if (this.characterLearned1[this.currentIndex] > -1)
			{
				num++;
			}
			if (this.characterLearned2[this.currentIndex] > -1)
			{
				num++;
			}
			if (this.characterLearned3[this.currentIndex] > -1)
			{
				num++;
			}
			int num2 = 0;
			for (int k = 0; k < this.scrollCount; k++)
			{
				if (this.fillStatus[k] == 2)
				{
					num2++;
				}
			}
			Debug.Log(string.Concat(new string[]
			{
				num2.ToString(),
				" ",
				num.ToString(),
				" ",
				this.maxSelections.ToString()
			}));
			for (int l = 0; l < this.scrollCount; l++)
			{
				if (num < this.maxSelections || num2 < this.maxSelections)
				{
					this.SetScrollState(true, l);
					if (this.characterLearned1[this.currentIndex] == l || this.characterLearned2[this.currentIndex] == l || this.characterLearned3[this.currentIndex] == l)
					{
						this.scrollFills[l].enabled = true;
					}
				}
				else if (this.characterLearned1[this.currentIndex] == l || this.characterLearned2[this.currentIndex] == l || this.characterLearned3[this.currentIndex] == l)
				{
					this.SetScrollState(true, l);
					this.scrollFills[l].enabled = true;
				}
				else
				{
					this.SetScrollState(false, l);
				}
			}
			this.skillNames.Clear();
			this.skillAbilities.Clear();
			for (int m = 0; m < this.scrollCount; m++)
			{
				string abilityName = this.GetAbilityName(this.currentSkill, m);
				this.skillNames.Add(abilityName);
				this.skillAbilities.Add(Links.x.library.GetAbilityRow(abilityName));
			}
			for (int n = 0; n < this.scrollCount; n++)
			{
				this.scrollTitles[n].text = this.skillAbilities[n]._DisplayName;
			}
			for (int num3 = 0; num3 < this.scrollCount; num3++)
			{
				this.scrollTitles[num3].color = this.selectedText;
			}
			this.nextButton.interactable = false;
			this.backButton.interactable = true;
			this.GetButtonText(false);
		}
	}

	// Token: 0x06000F1D RID: 3869 RVA: 0x0012667C File Offset: 0x0012487C
	public void SaveAll()
	{
		this.runesSaved.Clear();
		for (int i = 0; i < this.characterOrder.Count; i++)
		{
			this.spells = false;
			this.songs = false;
			this.words = false;
			this.currentSkill = this.skillOrder[i];
			if (this.currentSkill == "Vines" || this.currentSkill == "Fauna" || this.currentSkill == "Spores")
			{
				this.spells = true;
			}
			if (this.currentSkill == "Melee" || this.currentSkill == "Range" || this.currentSkill == "Defense")
			{
				this.words = true;
			}
			if (this.currentSkill == "Horn" || this.currentSkill == "Flute" || this.currentSkill == "Drum")
			{
				this.songs = true;
			}
			bool flag = false;
			string text = this.skillOrder[i];
			if (this.skillType[i] == "Major" && this.characterOrder[i].stats.HasTokenInSkill(text, true, false))
			{
				flag = true;
			}
			if (this.skillType[i] == "Minor" && this.characterOrder[i].stats.HasTokenInSkill(text, false, true))
			{
				flag = true;
			}
			if (flag)
			{
				for (int j = 0; j < this.scrollCount; j++)
				{
					if (this.characterLearned1[i] == j || this.characterLearned2[i] == j || this.characterLearned3[i] == j)
					{
						string abilityName = this.GetAbilityName(this.currentSkill, j);
						string text2 = "Saving ";
						string text3 = abilityName;
						string text4 = " for ";
						Character character = this.characterOrder[i];
						Debug.Log(text2 + text3 + text4 + ((character != null) ? character.ToString() : null));
						if (this.spells)
						{
							Library.Abilities abilityRow = Links.x.library.GetAbilityRow(abilityName);
							string spellName = this.GetSpellName(abilityRow);
							string text5 = string.Concat(new string[]
							{
								Application.persistentDataPath,
								"/AutoSave/",
								spellName,
								"_",
								this.characterOrder[i].stats.partyID.ToString(),
								".png"
							});
							this.runesSaved.Add(text5);
							this.selectedPagan = Links.x.library.GetPaganRow(abilityName);
							Links.x.spellcrafting.selectedPagan = this.selectedPagan;
							Links.x.spellcrafting.SelectLearningButton(-1);
							this.characterOrder[i].stats.SaveSpell(this.selectedPagan._ID, spellName, (int)Links.x.spellcrafting.slider1.value, (int)Links.x.spellcrafting.slider2.value, (int)Links.x.spellcrafting.slider3.value, (int)Links.x.spellcrafting.tetherSlider.value, new Vector2(1f, 0f));
						}
						if (this.songs)
						{
							this.characterOrder[i].stats.AddSong(abilityName, abilityName, new Vector3(1f, 1f, 1f));
						}
						if (this.words)
						{
							this.characterOrder[i].stats.AddWord(abilityName, abilityName, new Vector3(1f, 1f, 1f));
						}
					}
				}
			}
			this.characterOrder[i].stats.AddSong("SummonFriend", "SummonFriend", new Vector3(1f, 1f, 1f));
		}
		string[] files = Directory.GetFiles(Application.persistentDataPath + "/AutoSave");
		for (int k = 0; k < this.runesCreated.Count; k++)
		{
			if (!this.runesSaved.Contains(this.runesCreated[k]))
			{
				foreach (string text6 in files)
				{
					if (text6 == this.runesCreated[k])
					{
						File.Delete(text6);
					}
				}
			}
		}
	}

	// Token: 0x06000F1E RID: 3870 RVA: 0x00126B03 File Offset: 0x00124D03
	public void Back()
	{
		this.confirming = true;
		this.nextButton.interactable = false;
		this.backButton.interactable = false;
		base.StartCoroutine(this.ConfirmBack());
	}

	// Token: 0x06000F1F RID: 3871 RVA: 0x00126B31 File Offset: 0x00124D31
	private IEnumerator ConfirmBack()
	{
		if (this.spells && this.openNum > -1)
		{
			this.savingSpell = true;
			base.StartCoroutine(this.SaveSpellOpenInfo());
			while (this.savingSpell)
			{
				yield return null;
			}
		}
		this.creation.SetCharacterInfo();
		this.creation.animator.Play("CreationSpellsBackToAll");
		this.creation.SetAbilityButtons(false, false);
		base.gameObject.SetActive(false);
		yield break;
	}

	// Token: 0x06000F20 RID: 3872 RVA: 0x00126B40 File Offset: 0x00124D40
	public void SelectScroll(int num)
	{
		if (!this.backButton.interactable)
		{
			return;
		}
		this.backButton.interactable = false;
		this.nextButton.interactable = false;
		base.StartCoroutine(this.OpenScrollCoroutine(num));
	}

	// Token: 0x06000F21 RID: 3873 RVA: 0x00126B76 File Offset: 0x00124D76
	private IEnumerator OpenScrollCoroutine(int num)
	{
		bool closing = false;
		if (this.spells && this.openNum > -1)
		{
			this.savingSpell = true;
			base.StartCoroutine(this.SaveSpellOpenInfo());
			while (this.savingSpell)
			{
				yield return null;
			}
		}
		if (this.creation.animator.GetCurrentAnimatorStateInfo(0).IsName("CreationSpellInfoOpen") || this.creation.animator.GetCurrentAnimatorStateInfo(0).IsName("CreationSkillInfoOpen"))
		{
			if (num == this.openNum)
			{
				closing = true;
			}
			if (closing)
			{
				if (this.spells)
				{
					this.creation.animator.Play("CreationSpellInfoClose");
				}
				else
				{
					this.creation.animator.Play("CreationSkillInfoClose");
				}
				for (int i = 0; i < this.scrollCount; i++)
				{
					this.scrollTitles[i].color = this.selectedText;
				}
				this.openNum = -1;
			}
		}
		if (!closing)
		{
			if (this.words)
			{
				this.OpenWord(num);
			}
			if (this.songs)
			{
				this.OpenSong(num);
			}
			if (this.spells)
			{
				this.OpenSpell(num);
			}
			if (!this.creation.animator.GetCurrentAnimatorStateInfo(0).IsName("CreationSpellInfoOpen") && !this.creation.animator.GetCurrentAnimatorStateInfo(0).IsName("CreationSkillInfoOpen"))
			{
				if (this.spells)
				{
					this.creation.animator.Play("CreationSpellInfoOpen");
				}
				else
				{
					this.creation.animator.Play("CreationSkillInfoOpen");
				}
			}
			for (int j = 0; j < this.scrollCount; j++)
			{
				if (j == num)
				{
					this.scrollTitles[j].color = this.selectedText;
				}
				else
				{
					this.scrollTitles[j].color = this.unselectedText;
				}
			}
		}
		if (Links.x.mk)
		{
			EventSystem.current.SetSelectedGameObject(null);
		}
		this.backButton.interactable = true;
		yield break;
	}

	// Token: 0x06000F22 RID: 3874 RVA: 0x00126B8C File Offset: 0x00124D8C
	private IEnumerator SaveSpellOpenInfo()
	{
		int num = this.arrayCount;
		if (this.characterLearned1[this.currentIndex] == this.openNum)
		{
			Color32[] pixels = this.drawingTextures[this.openNum].GetPixels32();
			Color32[] array = this.runeColors1[this.currentIndex];
			for (int i = 0; i < num; i++)
			{
				array[i] = pixels[i];
			}
		}
		if (this.characterLearned2[this.currentIndex] == this.openNum)
		{
			Color32[] pixels2 = this.drawingTextures[this.openNum].GetPixels32();
			Color32[] array2 = this.runeColors2[this.currentIndex];
			for (int j = 0; j < num; j++)
			{
				array2[j] = pixels2[j];
			}
		}
		if (this.characterLearned3[this.currentIndex] == this.openNum)
		{
			Color32[] pixels3 = this.drawingTextures[this.openNum].GetPixels32();
			Color32[] array3 = this.runeColors3[this.currentIndex];
			for (int k = 0; k < num; k++)
			{
				array3[k] = pixels3[k];
			}
		}
		string spellName = this.GetSpellName(this.openNum);
		string fileName = string.Concat(new string[]
		{
			Application.persistentDataPath,
			"/AutoSave/",
			spellName,
			"_",
			this.character.stats.partyID.ToString(),
			".png"
		});
		yield return new WaitForEndOfFrame();
		Vector3[] array4 = new Vector3[4];
		this.targetRect.GetWorldCorners(array4);
		Vector2 vector = RectTransformUtility.WorldToScreenPoint(Links.x.menuCamera, array4[0]);
		Vector2 vector2 = RectTransformUtility.WorldToScreenPoint(Links.x.menuCamera, array4[1]);
		ref Vector2 ptr = RectTransformUtility.WorldToScreenPoint(Links.x.menuCamera, array4[2]);
		int num2 = Mathf.RoundToInt(vector2.y - vector.y);
		int num3 = Mathf.RoundToInt(ptr.x - vector.x);
		Texture2D texture2D = new Texture2D(num3, num2, TextureFormat.RGB24, false);
		Rect rect = new Rect(Mathf.Round(vector.x), Mathf.Round(vector.y), (float)num3, (float)num2);
		texture2D.ReadPixels(rect, 0, 0);
		texture2D.Apply();
		if (num3 > 256)
		{
			Texture2D texture2D2 = this.ScaleTexture(texture2D, 256, 256);
			byte[] array5 = texture2D2.EncodeToPNG();
			Object.Destroy(texture2D);
			Object.Destroy(texture2D2);
			File.WriteAllBytes(fileName, array5);
		}
		else
		{
			byte[] array6 = texture2D.EncodeToPNG();
			Object.Destroy(texture2D);
			File.WriteAllBytes(fileName, array6);
		}
		if (!this.runesCreated.Contains(fileName))
		{
			this.runesCreated.Add(fileName);
		}
		this.savingSpell = false;
		yield break;
	}

	// Token: 0x06000F23 RID: 3875 RVA: 0x00126B9C File Offset: 0x00124D9C
	private Texture2D ScaleTexture(Texture2D source, int targetWidth, int targetHeight)
	{
		Texture2D texture2D = new Texture2D(targetWidth, targetHeight, source.format, true);
		Color[] pixels = texture2D.GetPixels(0);
		float num = 1f / (float)source.width * ((float)source.width / (float)targetWidth);
		float num2 = 1f / (float)source.height * ((float)source.height / (float)targetHeight);
		for (int i = 0; i < pixels.Length; i++)
		{
			pixels[i] = source.GetPixelBilinear(num * ((float)i % (float)targetWidth), num2 * Mathf.Floor((float)(i / targetWidth)));
		}
		texture2D.SetPixels(pixels, 0);
		texture2D.Apply();
		return texture2D;
	}

	// Token: 0x06000F24 RID: 3876 RVA: 0x00126C38 File Offset: 0x00124E38
	public void CheckScrollBox(int num)
	{
		if (this.backButton.interactable)
		{
			this.newSelection = true;
			if (this.scrollFills[num].enabled)
			{
				this.scrollFills[num].enabled = false;
				if (this.characterLearned1[this.currentIndex] == num)
				{
					this.characterLearned1[this.currentIndex] = -1;
				}
				if (this.characterLearned2[this.currentIndex] == num)
				{
					this.characterLearned2[this.currentIndex] = -1;
				}
				if (this.characterLearned3[this.currentIndex] == num)
				{
					this.characterLearned3[this.currentIndex] = -1;
				}
				this.fillStatus[num] = 0;
			}
			else
			{
				this.scrollFills[num].enabled = true;
				bool flag = false;
				if (this.characterLearned1[this.currentIndex] == -1)
				{
					this.characterLearned1[this.currentIndex] = num;
					flag = true;
				}
				if (this.characterLearned2[this.currentIndex] == -1 && !flag)
				{
					this.characterLearned2[this.currentIndex] = num;
					flag = true;
				}
				if (this.characterLearned3[this.currentIndex] == -1 && !flag)
				{
					this.characterLearned3[this.currentIndex] = num;
					flag = true;
				}
				if (this.spells && flag)
				{
					this.GetSpellName(num);
					int num2 = this.arrayCount;
					Color32[] pixels = this.drawingTextures[num].GetPixels32();
					if (this.characterLearned1[this.currentIndex] == num)
					{
						Color32[] array = this.runeColors1[this.currentIndex];
						for (int i = 0; i < num2; i++)
						{
							array[i] = pixels[i];
						}
					}
					if (this.characterLearned2[this.currentIndex] == num)
					{
						Color32[] array2 = this.runeColors2[this.currentIndex];
						for (int j = 0; j < num2; j++)
						{
							array2[j] = pixels[j];
						}
					}
					if (this.characterLearned3[this.currentIndex] == num)
					{
						Color32[] array3 = this.runeColors3[this.currentIndex];
						for (int k = 0; k < num2; k++)
						{
							array3[k] = pixels[k];
						}
					}
					this.fillStatus[num] = 1;
					this.CheckSpellFillStatus(num, true);
					if (this.fillStatus[num] == 1)
					{
						if (this.incompleteFillCount == 0)
						{
							this.scrollFills[num].sprite = this.scrollFillSpellsNotComplete4;
						}
						if (this.incompleteFillCount == 3)
						{
							this.scrollFills[num].sprite = this.scrollFillSpellsNotComplete3;
						}
						if (this.incompleteFillCount == 2)
						{
							this.scrollFills[num].sprite = this.scrollFillSpellsNotComplete2;
						}
						if (this.incompleteFillCount == 1)
						{
							this.scrollFills[num].sprite = this.scrollFillSpellsNotComplete1;
						}
					}
					else
					{
						this.scrollFills[num].sprite = this.scrollFillSpells;
					}
				}
				else if (!this.spells)
				{
					this.fillStatus[num] = 2;
				}
			}
			this.GetButtonText(true);
		}
		if (Links.x.mk)
		{
			EventSystem.current.SetSelectedGameObject(null);
		}
	}

	// Token: 0x06000F25 RID: 3877 RVA: 0x00126F94 File Offset: 0x00125194
	public void CheckSpellFillStatus(int num, bool canPlayFX)
	{
		bool flag = this.HasRune(num);
		if (!flag && this.openNum > -1 && num == this.openNum && base.gameObject.activeSelf)
		{
			int num2 = this.arrayCount;
			Color32[] pixels = this.drawingTextures[this.openNum].GetPixels32();
			bool flag2 = false;
			for (int i = 0; i < num2; i++)
			{
				if (pixels[i] != this.resetColor)
				{
					flag2 = true;
					break;
				}
			}
			if (flag2)
			{
				if (this.characterLearned1[this.currentIndex] == num)
				{
					Color32[] array = this.runeColors1[this.currentIndex];
					for (int j = 0; j < num2; j++)
					{
						array[j] = pixels[j];
					}
				}
				if (this.characterLearned2[this.currentIndex] == num)
				{
					Color32[] array2 = this.runeColors2[this.currentIndex];
					for (int k = 0; k < num2; k++)
					{
						array2[k] = pixels[k];
					}
				}
				if (this.characterLearned3[this.currentIndex] == num)
				{
					Color32[] array3 = this.runeColors3[this.currentIndex];
					for (int l = 0; l < num2; l++)
					{
						array3[l] = pixels[l];
					}
				}
				flag = true;
			}
		}
		if (flag)
		{
			this.fillStatus[num] = 2;
			this.GetButtonText(canPlayFX);
			this.scrollFills[num].sprite = this.scrollFillSpells;
			return;
		}
		this.fillStatus[num] = 1;
	}

	// Token: 0x06000F26 RID: 3878 RVA: 0x00127144 File Offset: 0x00125344
	public void GetButtonText(bool canPlayFX)
	{
		int num = 0;
		if (this.characterLearned1[this.currentIndex] > -1)
		{
			num++;
		}
		if (this.characterLearned2[this.currentIndex] > -1)
		{
			num++;
		}
		if (this.characterLearned3[this.currentIndex] > -1)
		{
			num++;
		}
		int num2 = 0;
		for (int i = 0; i < this.scrollCount; i++)
		{
			if (this.fillStatus[i] == 2)
			{
				num2++;
			}
		}
		if (num < this.maxSelections || num2 < this.maxSelections)
		{
			if (!this.spells || (this.spells && num < this.maxSelections))
			{
				for (int j = 0; j < this.scrollCount; j++)
				{
					this.SetScrollState(true, j);
				}
			}
			else
			{
				for (int k = 0; k < this.scrollCount; k++)
				{
					if (this.characterLearned1[this.currentIndex] != k && this.characterLearned2[this.currentIndex] != k && this.characterLearned3[this.currentIndex] != k)
					{
						this.SetScrollState(false, k);
					}
				}
			}
			this.nextButton.interactable = false;
			this.buttonText.text = string.Concat(new string[]
			{
				"(",
				num2.ToString(),
				"/",
				this.maxSelections.ToString(),
				")"
			});
			return;
		}
		for (int l = 0; l < this.scrollCount; l++)
		{
			if (this.characterLearned1[this.currentIndex] != l && this.characterLearned2[this.currentIndex] != l && this.characterLearned3[this.currentIndex] != l)
			{
				this.SetScrollState(false, l);
			}
		}
		if (!this.nextButton.interactable && canPlayFX)
		{
			for (int m = 0; m < this.scrollCount; m++)
			{
				if (this.characterLearned1[this.currentIndex] == m || this.characterLearned2[this.currentIndex] == m || this.characterLearned3[this.currentIndex] == m)
				{
					this.scrollMainImages[m].gameObject.transform.parent.GetChild(4).gameObject.GetComponent<HannahAnimator>().Play("Idle");
				}
			}
			MasterAudio.PlaySoundAndForget("Feedback", 0.4f, new float?(1f), 0f, "Level Up", null);
		}
		this.nextButton.interactable = true;
		if (this.currentIndex < this.skillOrder.Count - 2)
		{
			this.buttonText.text = "Next";
			return;
		}
		this.buttonText.text = "Finish";
	}

	// Token: 0x06000F27 RID: 3879 RVA: 0x0012742C File Offset: 0x0012562C
	public void OpenWord(int num)
	{
		this.str.Clear();
		this.str.Append("<font=Bold><size=1.6em>");
		this.str.Append(this.skillAbilities[num]._DisplayName);
		this.str.Append("</font></size>\n");
		this.str.Append(this.skillAbilities[num]._Description);
		this.skillDescription.text = this.str.ToString();
		this.infoBorderRT.sizeDelta = new Vector2(this.infoBorderRT.sizeDelta.x, this.skillDescription.preferredHeight + 60f);
		this.openNum = num;
	}

	// Token: 0x06000F28 RID: 3880 RVA: 0x001274F0 File Offset: 0x001256F0
	public void OpenSong(int num)
	{
		this.openNum = num;
		this.str.Clear();
		this.str.Append("<font=Bold><size=1.6em>");
		this.str.Append(this.skillAbilities[num]._DisplayName);
		this.str.Append("</font></size>\n");
		this.str.Append(this.skillAbilities[num]._Description);
		Library.Effects effectRow = Links.x.library.GetEffectRow(this.skillNames[num]);
		this.str.Append("\n\nSong length: ");
		int overallTime = this.skillAbilities[num]._OverallTime;
		float num2 = Records.x.ShowSeconds(overallTime);
		this.str.Append(num2);
		if (num2 == 1f)
		{
			this.str.Append(" second");
		}
		else
		{
			this.str.Append(" seconds");
		}
		if (effectRow != null)
		{
			this.str.Append("\nSong effects: ");
			this.str.Append(Links.x.manual.GetEffectDescription(effectRow, 0f, 0));
		}
		this.skillDescription.text = this.str.ToString();
		this.infoBorderRT.sizeDelta = new Vector2(this.infoBorderRT.sizeDelta.x, this.skillDescription.preferredHeight + 60f);
	}

	// Token: 0x06000F29 RID: 3881 RVA: 0x00127670 File Offset: 0x00125870
	public void OpenSpell(int num)
	{
		this.openNum = num;
		string text = this.skillNames[num];
		this.selectedPagan = Links.x.library.GetPaganRow(text);
		this.hasDrawn = false;
		Links.x.spellcrafting.selectedPagan = this.selectedPagan;
		Links.x.spellcrafting.SelectLearningButton(-1);
		this.str.Clear();
		this.str.Append("<font=Bold><size=1.6em>");
		this.str.Append(this.selectedPagan._DisplayName);
		this.str.Append("</font></size>\n");
		this.str.Append(Links.x.spellcrafting.SetDescription());
		this.str.Append("\n\n<color=#5B5452><size=.9em>Draw rune to save as learned spell.</size></color>");
		this.spellDescription.text = this.str.ToString();
		this.drawImage.enabled = true;
		this.drawImage.sprite = this.drawingSprites[num];
		this.drawing.Initialize();
	}

	// Token: 0x06000F2A RID: 3882 RVA: 0x00127788 File Offset: 0x00125988
	public void ResetTexture()
	{
		this.resetColor = new Color(0f, 0f, 0f, 0f);
		this.resetColorsArray = new Color[(int)this.drawingSprites[0].rect.width * (int)this.drawingSprites[0].rect.height];
		int num = this.resetColorsArray.Length;
		for (int i = 0; i < num; i++)
		{
			this.resetColorsArray[i] = this.resetColor;
		}
		this.drawingTextures[this.openNum].SetPixels(this.resetColorsArray);
		this.drawingTextures[this.openNum].Apply();
		if (this.characterLearned1[this.currentIndex] == this.openNum)
		{
			Color32[] array = this.runeColors1[this.currentIndex];
			for (int j = 0; j < num; j++)
			{
				array[j] = this.resetColor;
			}
		}
		if (this.characterLearned2[this.currentIndex] == this.openNum)
		{
			Color32[] array2 = this.runeColors2[this.currentIndex];
			for (int k = 0; k < num; k++)
			{
				array2[k] = this.resetColor;
			}
		}
		if (this.characterLearned3[this.currentIndex] == this.openNum)
		{
			Color32[] array3 = this.runeColors3[this.currentIndex];
			for (int l = 0; l < num; l++)
			{
				array3[l] = this.resetColor;
			}
		}
	}

	// Token: 0x06000F2B RID: 3883 RVA: 0x0012793C File Offset: 0x00125B3C
	public void ResetDrawings()
	{
		this.resetColor = new Color(0f, 0f, 0f, 0f);
		this.resetColorsArray = new Color[(int)this.drawingSprites[0].rect.width * (int)this.drawingSprites[0].rect.height];
		for (int i = 0; i < this.scrollCount; i++)
		{
			int num = this.resetColorsArray.Length;
			for (int j = 0; j < num; j++)
			{
				this.resetColorsArray[j] = this.resetColor;
			}
			if (this.characterLearned1[this.currentIndex] == i)
			{
				Color32[] array = this.runeColors1[this.currentIndex];
				for (int k = 0; k < num; k++)
				{
					this.resetColorsArray[k] = array[k];
				}
			}
			if (this.characterLearned2[this.currentIndex] == i)
			{
				Color32[] array2 = this.runeColors2[this.currentIndex];
				for (int l = 0; l < num; l++)
				{
					this.resetColorsArray[l] = array2[l];
				}
			}
			if (this.characterLearned3[this.currentIndex] == i)
			{
				Color32[] array3 = this.runeColors3[this.currentIndex];
				for (int m = 0; m < num; m++)
				{
					this.resetColorsArray[m] = array3[m];
				}
			}
			Texture2D texture2D = this.drawingTextures[i];
			texture2D.SetPixels(this.resetColorsArray);
			texture2D.Apply();
		}
	}

	// Token: 0x06000F2C RID: 3884 RVA: 0x00127AF9 File Offset: 0x00125CF9
	public void SetScrollState(bool state, int i)
	{
		this.scrollButtons[i].interactable = true;
		this.scrollMainImages[i].raycastTarget = true;
		this.scrollCheckBoxButtons[i].interactable = state;
	}

	// Token: 0x06000F2D RID: 3885 RVA: 0x00127B31 File Offset: 0x00125D31
	public void SetScrollStateAll(bool state, int i)
	{
		this.scrollButtons[i].interactable = state;
		this.scrollMainImages[i].raycastTarget = state;
		this.scrollCheckBoxButtons[i].interactable = state;
	}

	// Token: 0x06000F2E RID: 3886 RVA: 0x00127B6C File Offset: 0x00125D6C
	public bool HasSavedRune(int checkIndex, int listNumber)
	{
		int num = this.arrayCount;
		Color color = new Color(0f, 0f, 0f, 0f);
		if (listNumber == 1)
		{
			this.currentRuneColorsToCheck = this.runeColors1[checkIndex];
		}
		if (listNumber == 2)
		{
			this.currentRuneColorsToCheck = this.runeColors2[checkIndex];
		}
		if (listNumber == 3)
		{
			this.currentRuneColorsToCheck = this.runeColors3[checkIndex];
		}
		for (int i = 0; i < num; i++)
		{
			if (this.currentRuneColorsToCheck[i] != color)
			{
				return true;
			}
		}
		return false;
	}

	// Token: 0x06000F2F RID: 3887 RVA: 0x00127C08 File Offset: 0x00125E08
	private bool HasRune(int num)
	{
		Color color = new Color(0f, 0f, 0f, 0f);
		if (this.characterLearned1[this.currentIndex] == num)
		{
			int num2 = this.arrayCount;
			Color32[] array = this.runeColors1[this.currentIndex];
			for (int i = 0; i < num2; i++)
			{
				if (array[i] != color)
				{
					return true;
				}
			}
		}
		if (this.characterLearned2[this.currentIndex] == num)
		{
			int num3 = this.arrayCount;
			Color32[] array2 = this.runeColors2[this.currentIndex];
			for (int j = 0; j < num3; j++)
			{
				if (array2[j] != color)
				{
					return true;
				}
			}
		}
		if (this.characterLearned3[this.currentIndex] == num)
		{
			int num4 = this.arrayCount;
			Color32[] array3 = this.runeColors3[this.currentIndex];
			for (int k = 0; k < num4; k++)
			{
				if (array3[k] != color)
				{
					return true;
				}
			}
		}
		return false;
	}

	// Token: 0x06000F30 RID: 3888 RVA: 0x00127D30 File Offset: 0x00125F30
	private string GetAbilityName(string skill, int num)
	{
		string text = "";
		if (skill == "Vines")
		{
			if (num == 0)
			{
				text = "Entangle";
			}
			if (num == 1)
			{
				text = "EntangleSpikes";
			}
			if (num == 2)
			{
				text = "SilentMoss";
			}
			if (num == 3)
			{
				text = "Bushes";
			}
			if (num == 4)
			{
				text = "VineWall";
			}
			if (num == 5)
			{
				text = "TrapRoot";
			}
		}
		if (skill == "Fauna")
		{
			if (num == 0)
			{
				text = "ScoutFrog";
			}
			if (num == 1)
			{
				text = "AcornMen";
			}
			if (num == 2)
			{
				text = "FetishCorpse";
			}
			if (num == 3)
			{
				text = "BeeShield";
			}
			if (num == 4)
			{
				text = "Decoy";
			}
			if (num == 5)
			{
				text = "LootFrog";
			}
		}
		if (skill == "Spores")
		{
			if (num == 0)
			{
				text = "PukeSpores";
			}
			if (num == 1)
			{
				text = "SlipperyGround";
			}
			if (num == 2)
			{
				text = "HealingSpores";
			}
			if (num == 3)
			{
				text = "TurnIntoMushrooms";
			}
			if (num == 4)
			{
				text = "VolPrison";
			}
			if (num == 5)
			{
				text = "ChaosSpores";
			}
		}
		if (skill == "Melee")
		{
			if (num == 0)
			{
				text = "ShoulderRam";
			}
			if (num == 1)
			{
				text = "CrushingBlow";
			}
			if (num == 2)
			{
				text = "DmgUpDurDown";
			}
			if (num == 3)
			{
				text = "Parry";
			}
			if (num == 4)
			{
				text = "BreakArmor";
			}
			if (num == 5)
			{
				text = "StealthAttack";
			}
		}
		if (skill == "Range")
		{
			if (num == 0)
			{
				text = "Arc";
			}
			if (num == 1)
			{
				text = "DmgUpHealthDown";
			}
			if (num == 2)
			{
				text = "Strafe";
			}
			if (num == 3)
			{
				text = "CombatStartDmg";
			}
			if (num == 4)
			{
				text = "RangeStun";
			}
			if (num == 5)
			{
				text = "Repetition";
			}
		}
		if (skill == "Defense")
		{
			if (num == 0)
			{
				text = "DefenseStance";
			}
			if (num == 1)
			{
				text = "Illuminate";
			}
			if (num == 2)
			{
				text = "KillFlee";
			}
			if (num == 3)
			{
				text = "WeaponBlock";
			}
			if (num == 4)
			{
				text = "FatigueRegen";
			}
			if (num == 5)
			{
				text = "DefUpDmgDown";
			}
		}
		if (skill == "Horn")
		{
			if (num == 0)
			{
				text = "SlowSong";
			}
			if (num == 1)
			{
				text = "DodgeChanceDown";
			}
			if (num == 2)
			{
				text = "HitChanceDown";
			}
			if (num == 3)
			{
				text = "DmgDown";
			}
			if (num == 4)
			{
				text = "PaganDown";
			}
			if (num == 5)
			{
				text = "AmplifyAilments";
			}
		}
		if (skill == "Flute")
		{
			if (num == 0)
			{
				text = "HealingSong";
			}
			if (num == 1)
			{
				text = "AmplifyDmg";
			}
			if (num == 2)
			{
				text = "SpiritReleaseUp";
			}
			if (num == 3)
			{
				text = "SpeedUp";
			}
			if (num == 4)
			{
				text = "HitChanceUp";
			}
			if (num == 5)
			{
				text = "SkillsUp";
			}
		}
		if (skill == "Drum")
		{
			if (num == 0)
			{
				text = "StruckDumb";
			}
			if (num == 1)
			{
				text = "Rally";
			}
			if (num == 2)
			{
				text = "Fear";
			}
			if (num == 3)
			{
				text = "Taunt";
			}
			if (num == 4)
			{
				text = "DimVision";
			}
			if (num == 5)
			{
				text = "Confuse";
			}
		}
		return text;
	}

	// Token: 0x06000F31 RID: 3889 RVA: 0x00127FCC File Offset: 0x001261CC
	public int GetMaxSelections(string skill, string type)
	{
		int num = 0;
		if (skill == "Vines" || skill == "Fauna" || skill == "Spores")
		{
			num = 3;
			if (type == "Minor")
			{
				num = 2;
			}
			this.scrollCount = 5;
		}
		if (skill == "Melee" || skill == "Range" || skill == "Defense")
		{
			this.words = true;
			num = 2;
			if (type == "Minor")
			{
				num = 1;
			}
			this.scrollCount = 4;
		}
		if (skill == "Horn" || skill == "Flute" || skill == "Drum")
		{
			this.songs = true;
			num = 2;
			if (type == "Minor")
			{
				num = 1;
			}
			this.scrollCount = 4;
		}
		return num;
	}

	// Token: 0x06000F32 RID: 3890 RVA: 0x001280A7 File Offset: 0x001262A7
	private string GetSpellName(Library.Abilities row)
	{
		return "Initiate " + row._DisplayName;
	}

	// Token: 0x06000F33 RID: 3891 RVA: 0x001280B9 File Offset: 0x001262B9
	private string GetSpellName(int num)
	{
		return "Initiate " + this.skillAbilities[num]._DisplayName;
	}

	// Token: 0x040018B0 RID: 6320
	[Header("Info")]
	public bool spells;

	// Token: 0x040018B1 RID: 6321
	public bool songs;

	// Token: 0x040018B2 RID: 6322
	public bool words;

	// Token: 0x040018B3 RID: 6323
	public bool newSelection;

	// Token: 0x040018B4 RID: 6324
	public bool confirming;

	// Token: 0x040018B5 RID: 6325
	public int scrollCount = 5;

	// Token: 0x040018B6 RID: 6326
	public int textureSize = 512;

	// Token: 0x040018B7 RID: 6327
	private int incompleteFillCount;

	// Token: 0x040018B8 RID: 6328
	private int arrayCount;

	// Token: 0x040018B9 RID: 6329
	public int maxSelections;

	// Token: 0x040018BA RID: 6330
	public string currentSkill;

	// Token: 0x040018BB RID: 6331
	public List<Texture2D> drawingTextures = new List<Texture2D>();

	// Token: 0x040018BC RID: 6332
	public List<Sprite> drawingSprites = new List<Sprite>();

	// Token: 0x040018BD RID: 6333
	public List<Character> characterOrder = new List<Character>();

	// Token: 0x040018BE RID: 6334
	public List<string> skillOrder = new List<string>();

	// Token: 0x040018BF RID: 6335
	public List<string> skillType = new List<string>();

	// Token: 0x040018C0 RID: 6336
	public List<int> characterLearned1 = new List<int>();

	// Token: 0x040018C1 RID: 6337
	public List<int> characterLearned2 = new List<int>();

	// Token: 0x040018C2 RID: 6338
	public List<int> characterLearned3 = new List<int>();

	// Token: 0x040018C3 RID: 6339
	public List<Color32[]> runeColors1 = new List<Color32[]>();

	// Token: 0x040018C4 RID: 6340
	public List<Color32[]> runeColors2 = new List<Color32[]>();

	// Token: 0x040018C5 RID: 6341
	public List<Color32[]> runeColors3 = new List<Color32[]>();

	// Token: 0x040018C6 RID: 6342
	public List<string> skillNames = new List<string>();

	// Token: 0x040018C7 RID: 6343
	public List<Library.Abilities> skillAbilities = new List<Library.Abilities>();

	// Token: 0x040018C8 RID: 6344
	public Library.Pagan selectedPagan;

	// Token: 0x040018C9 RID: 6345
	public Character character;

	// Token: 0x040018CA RID: 6346
	public int currentIndex;

	// Token: 0x040018CB RID: 6347
	public Creation creation;

	// Token: 0x040018CC RID: 6348
	public bool opened;

	// Token: 0x040018CD RID: 6349
	private int openNum;

	// Token: 0x040018CE RID: 6350
	private Color32[] currentRuneColors;

	// Token: 0x040018CF RID: 6351
	private Color32[] currentRuneColorsToCheck;

	// Token: 0x040018D0 RID: 6352
	public List<string> runesCreated = new List<string>();

	// Token: 0x040018D1 RID: 6353
	public List<string> runesSaved = new List<string>();

	// Token: 0x040018D2 RID: 6354
	[Header("Objects")]
	public TextMeshProUGUI title;

	// Token: 0x040018D3 RID: 6355
	public TextMeshProUGUI message;

	// Token: 0x040018D4 RID: 6356
	public TextMeshProUGUI skillDescription;

	// Token: 0x040018D5 RID: 6357
	public TextMeshProUGUI spellDescription;

	// Token: 0x040018D6 RID: 6358
	public TextMeshProUGUI buttonText;

	// Token: 0x040018D7 RID: 6359
	public List<TextMeshProUGUI> scrollTitles = new List<TextMeshProUGUI>();

	// Token: 0x040018D8 RID: 6360
	public List<Image> scrollFills = new List<Image>();

	// Token: 0x040018D9 RID: 6361
	public List<ButtonMultiTargets> scrollButtons = new List<ButtonMultiTargets>();

	// Token: 0x040018DA RID: 6362
	public List<ButtonMultiTargets> scrollCheckBoxButtons = new List<ButtonMultiTargets>();

	// Token: 0x040018DB RID: 6363
	public List<int> fillStatus = new List<int>();

	// Token: 0x040018DC RID: 6364
	public List<Image> scrollMainImages = new List<Image>();

	// Token: 0x040018DD RID: 6365
	public RawImage portrait;

	// Token: 0x040018DE RID: 6366
	public DrawViewController drawing;

	// Token: 0x040018DF RID: 6367
	public Image drawImage;

	// Token: 0x040018E0 RID: 6368
	public ButtonMultiTargets nextButton;

	// Token: 0x040018E1 RID: 6369
	public ButtonMultiTargets backButton;

	// Token: 0x040018E2 RID: 6370
	public bool hasDrawn;

	// Token: 0x040018E3 RID: 6371
	public TMP_InputField nameInput;

	// Token: 0x040018E4 RID: 6372
	private StringFast str = new StringFast(64);

	// Token: 0x040018E5 RID: 6373
	public RectTransform infoBorderRT;

	// Token: 0x040018E6 RID: 6374
	public Transform unusedScrolls;

	// Token: 0x040018E7 RID: 6375
	public Transform usedScrolls;

	// Token: 0x040018E8 RID: 6376
	public RectTransform targetRect;

	// Token: 0x040018E9 RID: 6377
	public Material vines;

	// Token: 0x040018EA RID: 6378
	public Material spores;

	// Token: 0x040018EB RID: 6379
	public Material fauna;

	// Token: 0x040018EC RID: 6380
	public Color selectedText;

	// Token: 0x040018ED RID: 6381
	public Color unselectedText;

	// Token: 0x040018EE RID: 6382
	[Header("Graphics")]
	public Sprite scrollFillSpells;

	// Token: 0x040018EF RID: 6383
	public Sprite scrollFillSongs;

	// Token: 0x040018F0 RID: 6384
	public Sprite scrollFillWords;

	// Token: 0x040018F1 RID: 6385
	public Sprite scrollFillSpellsNotComplete;

	// Token: 0x040018F2 RID: 6386
	public Sprite scrollFillSpellsNotComplete1;

	// Token: 0x040018F3 RID: 6387
	public Sprite scrollFillSpellsNotComplete2;

	// Token: 0x040018F4 RID: 6388
	public Sprite scrollFillSpellsNotComplete3;

	// Token: 0x040018F5 RID: 6389
	public Sprite scrollFillSpellsNotComplete4;

	// Token: 0x040018F6 RID: 6390
	private Color[] resetColorsArray;

	// Token: 0x040018F7 RID: 6391
	private Color resetColor;

	// Token: 0x040018F8 RID: 6392
	private float updateTime;

	// Token: 0x040018F9 RID: 6393
	private float fillUpdateTime;

	// Token: 0x040018FA RID: 6394
	private int currIndex;

	// Token: 0x040018FB RID: 6395
	private bool savingSpell;
}