using System;
using System.Collections;
using System.Collections.Generic;
using DarkTonic.MasterAudio;
using PixelCrushers.DialogueSystem;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

// Token: 0x020000AF RID: 175
public class HUD : MonoBehaviour
{
	// Token: 0x06000FDF RID: 4063 RVA: 0x00132220 File Offset: 0x00130420
	private void Awake()
	{
		this.canvas.enabled = true;
		this.windowsCanvas.enabled = true;
		this.feedCanvas.enabled = true;
		this.SwitchController(false);
	}

	// Token: 0x06000FE0 RID: 4064 RVA: 0x00132250 File Offset: 0x00130450
	private void Start()
	{
		Links.x.hudControl = this;
		this.itemInfo.gameObject.SetActive(false);
		this.party = Links.x.party;
		this.portraitOrder = Links.x.portraitOrder;
		this.hudAnimator.enabled = false;
		this.hudState = true;
		this.attackTimerAnimator.gameObject.SetActive(true);
		this.demoMessage.SetActive(false);
		this.demoIntroAnimator.gameObject.SetActive(false);
		this.badgeControllerText.SetActive(false);
		this.skipIntro.SetActive(false);
		this.ClosePinnedNote();
		this.tipsMenu.SetActive(false);
		this.boroCard.gameObject.SetActive(false);
		this.JoyBox(false);
		foreach (Windows windows in this.windows)
		{
			windows.GetStartPositions();
		}
		this.startStaminaColor = this.stamina.color;
		for (int i = 0; i < this.dockButtons.Count; i++)
		{
		}
		Links.x.gameCard.gameObject.SetActive(true);
		Links.x.itemCard.gameObject.SetActive(true);
		this.groupHud = false;
		for (int j = 0; j < this.portraits.Count; j++)
		{
			this.portraits[j].gameObject.SetActive(false);
		}
		this.sheepPedestal.SetActive(false);
		Links.x.keyboardScript.gameObject.SetActive(false);
		this.SetModalWindowState(true, false);
		Links.x.inspectTextAnimator.gameObject.SetActive(false);
		this.ToggleAttackTimer(false);
		this.CloseMenuSwitcher();
		if (this.tutorial)
		{
			this.tutorial.SetActive(false);
		}
		this.hidingHud = false;
		this.ClearRally();
		Links.x.pocketWheel.rallyWheel.SetActive(false);
		Links.x.pocketWheel.rallyText.SetActive(false);
	}

	// Token: 0x06000FE1 RID: 4065 RVA: 0x00132480 File Offset: 0x00130680
	public void JoyBox(bool state)
	{
		if (Links.x.mk)
		{
			state = false;
		}
		this.joyRT.gameObject.SetActive(state);
	}

	// Token: 0x06000FE2 RID: 4066 RVA: 0x001324A4 File Offset: 0x001306A4
	public void JoyBoxIcon(bool state, bool mainMenu, string type)
	{
		if (!mainMenu)
		{
			this.joyIconMM.enabled = false;
			this.joyIconHolderMM.enabled = false;
			this.joyIcon.enabled = state;
			this.joyIconHolder.enabled = state;
			if (state)
			{
				int num = 0;
				if (type == "A" || type == "Pocket")
				{
					num = 0;
				}
				if (type == "Y")
				{
					num = 1;
				}
				if (type == "Joy")
				{
					num = 2;
				}
				if (type == "JoyL")
				{
					num = 3;
				}
				if (Links.x.gameplay.currentSpriteSheetAsset <= 1)
				{
					this.joyIcon.sprite = this.xboxIcons[num];
				}
				else if (Links.x.gameplay.currentSpriteSheetAsset == 2)
				{
					this.joyIcon.sprite = this.playstationIcons[num];
				}
				else if (Links.x.gameplay.currentSpriteSheetAsset == 3)
				{
					this.joyIcon.sprite = this.switchIcons[num];
				}
				else if (Links.x.gameplay.currentSpriteSheetAsset == 4)
				{
					this.joyIcon.sprite = this.steamIcons[num];
				}
			}
			if (type.Contains("Pocket"))
			{
				if (type == "PocketNone")
				{
					this.joyIcon.enabled = false;
				}
				this.joyBorder.enabled = false;
				this.joyIconHolder.enabled = false;
			}
			else
			{
				this.joyBorder.enabled = true;
			}
			if (Links.x.characterSheet.open && Links.x.inventory.repairing)
			{
				this.joyIcon.sprite = this.repairing;
			}
			if (Links.x.characterSheet.open && Links.x.inventory.mineralizing)
			{
				this.joyIcon.sprite = this.mineralizing;
				return;
			}
		}
		else
		{
			this.joyBorder.enabled = false;
			this.joyIcon.enabled = false;
			this.joyIconHolder.enabled = false;
			this.joyIconMM.enabled = true;
			this.joyIconHolderMM.enabled = true;
			int num2 = 0;
			if (Links.x.gameplay.currentSpriteSheetAsset <= 1)
			{
				this.joyIconMM.sprite = this.xboxIcons[num2];
				return;
			}
			if (Links.x.gameplay.currentSpriteSheetAsset == 2)
			{
				this.joyIconMM.sprite = this.playstationIcons[num2];
				return;
			}
			if (Links.x.gameplay.currentSpriteSheetAsset == 3)
			{
				this.joyIconMM.sprite = this.switchIcons[num2];
				return;
			}
			if (Links.x.gameplay.currentSpriteSheetAsset == 4)
			{
				this.joyIconMM.sprite = this.steamIcons[num2];
			}
		}
	}

	// Token: 0x06000FE3 RID: 4067 RVA: 0x00132760 File Offset: 0x00130960
	public Vector3 WorldToUISpaceAnchor(Vector3 screenPos)
	{
		Vector3 vector = screenPos;
		vector.z = 0f;
		vector.x = vector.x * (Links.x.canvasRT.sizeDelta.x / (float)Screen.width) - Links.x.canvasRT.sizeDelta.x / 2f;
		vector.y = vector.y * (Links.x.canvasRT.sizeDelta.y / (float)Screen.height) - Links.x.canvasRT.sizeDelta.y / 2f;
		return vector;
	}

	// Token: 0x06000FE4 RID: 4068 RVA: 0x00132804 File Offset: 0x00130A04
	public void SetJoyBox(UITriggerButton trigBtn)
	{
		if (!trigBtn)
		{
			return;
		}
		bool flag = false;
		if (Records.x.mainMenuOpen && !Links.x.saveLoad.open && !Links.x.options.contents1.activeSelf)
		{
			flag = true;
		}
		if (trigBtn.isSlider)
		{
			this.JoyBoxIcon(true, flag, "Joy");
		}
		else if (trigBtn.isScrollBar)
		{
			this.JoyBoxIcon(true, flag, "JoyL");
		}
		else if (!trigBtn.customIcon && (trigBtn.selectOnly || trigBtn.noIcon))
		{
			this.JoyBoxIcon(false, flag, "");
		}
		else if (trigBtn.interacting && !trigBtn.clicking && !trigBtn.customIcon)
		{
			this.JoyBoxIcon(true, flag, "Y");
		}
		else if (trigBtn.interacting && trigBtn.clicking)
		{
			if (trigBtn.gameObject.name.Contains("Pin_"))
			{
				if (trigBtn.gameObject.GetComponent<Pin>().inBox)
				{
					this.JoyBoxIcon(true, flag, "Y");
				}
				else
				{
					this.JoyBoxIcon(true, flag, "A");
				}
			}
			else
			{
				this.JoyBoxIcon(true, flag, "A");
			}
		}
		else if (trigBtn.customIcon)
		{
			if (Links.x.creation)
			{
				if (trigBtn.gameObject.transform.parent.gameObject.name == "Skill Hovers")
				{
					if (Links.x.creation.HasTokenSkill(trigBtn.gameObject.name))
					{
						this.JoyBoxIcon(true, flag, "A");
					}
					else if (Links.x.creation.HasFreeSkillToken())
					{
						this.JoyBoxIcon(true, flag, "A");
					}
					else
					{
						this.JoyBoxIcon(false, flag, "");
					}
				}
				if (trigBtn.gameObject.transform.parent.gameObject.name == "Stats & Skills")
				{
					if (Links.x.creation.HasTokenStat(trigBtn.gameObject.name))
					{
						this.JoyBoxIcon(true, flag, "A");
					}
					else if (Links.x.creation.HasFreeStatToken())
					{
						this.JoyBoxIcon(true, flag, "A");
					}
					else
					{
						this.JoyBoxIcon(false, flag, "");
					}
				}
				if (trigBtn.gameObject.name.Contains("Archetypes Button") || trigBtn.gameObject.name.Contains("Finish"))
				{
					this.JoyBoxIcon(true, flag, "A");
				}
			}
			else
			{
				string name = trigBtn.gameObject.name;
				if (name.Contains("Spell Song Word"))
				{
					if (Links.x.characterSheet.open)
					{
						this.JoyBoxIcon(true, flag, "A");
					}
					else
					{
						this.JoyBoxIcon(true, flag, "Y");
					}
				}
				if (name.Contains("Level Up") || name.Contains("Autocast") || name.Contains("Pin"))
				{
					this.JoyBoxIcon(true, flag, "A");
				}
				if (trigBtn.gameObject.transform.parent)
				{
					if (trigBtn.gameObject.transform.parent.gameObject.name == "Equip Slots")
					{
						ItemEquipped component = trigBtn.gameObject.GetComponent<ItemEquipped>();
						if (component)
						{
							if (component.buddyItemEquipped3D)
							{
								this.JoyBoxIcon(true, flag, "A");
							}
							else
							{
								this.JoyBoxIcon(false, flag, "");
							}
						}
						else
						{
							this.JoyBoxIcon(true, flag, "A");
						}
					}
					if (trigBtn.gameObject.transform.parent.gameObject.name == "Skill Hovers")
					{
						if (Links.x.characterSheet.levelUpMenu)
						{
							if (Links.x.characterSheet.levelUpMenu.HasTokens() || Links.x.characterSheet.levelUpMenu.IsToken(trigBtn.gameObject))
							{
								this.JoyBoxIcon(true, flag, "A");
							}
							else
							{
								this.JoyBoxIcon(false, flag, "");
							}
						}
						else
						{
							this.JoyBoxIcon(false, flag, "");
						}
					}
				}
				if (name.Contains("Aura") || name.Contains("Strength") || name.Contains("Agility") || name.Contains("Dexterity") || name.Contains("Pagan") || name.Contains("Sensory"))
				{
					if (Links.x.characterSheet.levelUpMenu)
					{
						this.JoyBoxIcon(true, flag, "A");
					}
					else
					{
						this.JoyBoxIcon(false, flag, "");
					}
				}
				if (Links.x.pocketWheel.open && trigBtn.gameObject.transform.parent.gameObject.transform.parent.gameObject.name == "Pocket")
				{
					if (trigBtn.noIcon)
					{
						this.JoyBoxIcon(true, false, "PocketNone");
					}
					else
					{
						this.JoyBoxIcon(true, false, "Pocket");
					}
				}
			}
		}
		else
		{
			this.JoyBoxIcon(true, flag, "A");
		}
		this.JoyBounds(trigBtn.rt, trigBtn.boxOffset, false);
		this.JoyBox(true);
	}

	// Token: 0x06000FE5 RID: 4069 RVA: 0x00132D58 File Offset: 0x00130F58
	public void SetJoyBox(RectTransform rt, Vector4 offset, bool showIcon, bool isInventoryItem)
	{
		if (showIcon)
		{
			if (Links.x.inventory.dragging && isInventoryItem)
			{
				this.JoyBoxIcon(true, false, "JoyL");
			}
			else
			{
				this.JoyBoxIcon(true, false, "A");
			}
		}
		else
		{
			this.JoyBoxIcon(false, false, "");
		}
		this.JoyBounds(rt, offset, isInventoryItem);
		this.JoyBox(true);
	}

	// Token: 0x06000FE6 RID: 4070 RVA: 0x00132DB8 File Offset: 0x00130FB8
	public void JoyBounds(RectTransform rt, Vector4 offset, bool isInventoryItem)
	{
		if (!rt)
		{
			return;
		}
		Vector3[] array = new Vector3[4];
		rt.GetWorldCorners(array);
		Vector2 vector = RectTransformUtility.WorldToScreenPoint(Links.x.menuCamera, array[0]);
		Vector2 vector2 = RectTransformUtility.WorldToScreenPoint(Links.x.menuCamera, array[1]);
		Vector2 vector3 = RectTransformUtility.WorldToScreenPoint(Links.x.menuCamera, array[2]);
		vector = this.WorldToUISpaceAnchor(vector);
		vector2 = this.WorldToUISpaceAnchor(vector2);
		vector3 = this.WorldToUISpaceAnchor(vector3);
		float num = vector2.y - vector.y;
		float num2 = vector3.x - vector.x;
		Vector3 vector4 = vector;
		vector4.x += num2 / 2f;
		vector4.y += num / 2f;
		vector4.x += offset.x;
		vector4.y += offset.y;
		num2 += offset.z;
		num += offset.w;
		if (isInventoryItem)
		{
			num2 = Mathf.Round(num2 / 58f) * 58f;
			num = Mathf.Round(num / 56f) * 56f;
		}
		this.joyRT.sizeDelta = new Vector2(num2, num);
		this.joyRT.localPosition = vector4;
	}

	// Token: 0x06000FE7 RID: 4071 RVA: 0x00132F29 File Offset: 0x00131129
	public void ToggleControllerControls(bool state)
	{
		this.turnOnForController[0].SetActive(state);
	}

	// Token: 0x06000FE8 RID: 4072 RVA: 0x00132F40 File Offset: 0x00131140
	public void SwitchController(bool joystick)
	{
		foreach (GameObject gameObject in this.turnOffForController)
		{
			if (!joystick)
			{
				gameObject.SetActive(true);
			}
			else
			{
				gameObject.SetActive(false);
			}
		}
		foreach (GameObject gameObject2 in this.turnOnForController)
		{
			gameObject2.SetActive(joystick);
		}
		if (joystick)
		{
			Links.x.partyColliderAdventure.ToggleController();
			Links.x.inspectTextAnimator.gameObject.GetComponent<RectTransform>().anchoredPosition3D = new Vector3(100000f, 0f, -100000f);
			if (Links.x.inspectTextAnimator.gameObject.activeSelf)
			{
				this.ClickedInspectButton();
			}
		}
		else
		{
			this.JoyBox(false);
			Links.x.inspectTextAnimator.gameObject.GetComponent<RectTransform>().anchoredPosition3D = new Vector3(-10f, -10f, 0f);
		}
		if (Links.x.creation)
		{
			Links.x.creation.Controllers(joystick);
		}
		if (!joystick)
		{
			Shader.SetGlobalVector("_JoystickDirection", Links.x.gameplay.farPosition);
		}
		if (joystick)
		{
			this.pinnedNoteClose.SetActive(false);
		}
		else
		{
			this.pinnedNoteClose.SetActive(true);
		}
		Links.x.inventory.groundBag.itemLabelGrid.Controller(joystick);
		Links.x.fellowship.SetPortraitHotkeys(joystick);
	}

	// Token: 0x06000FE9 RID: 4073 RVA: 0x001330FC File Offset: 0x001312FC
	public void AddRemoveInteraction(bool state, Character nearCharacter, BreakableActions nearBreak, ChestActions nearChest, PuzzleActions nearPuzzle, DoorActions nearDoor, MapExitActions nearMap, Boat nearBoat)
	{
		bool flag = true;
		if (Links.x.mk)
		{
			flag = false;
		}
		if (nearCharacter)
		{
			int num = this.nearTalkCharacters.IndexOf(nearCharacter);
			if (num == -1 && state)
			{
				this.nearTalkCharacters.Add(nearCharacter);
				AnimateButton animateButton = this.SetupNearIcon();
				this.nearBtnCharsUsed.Add(animateButton);
				InteractionIconAnimator component = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
				if (nearCharacter.stats.dialogueFile == "Quip")
				{
					component.animationType = InteractionIconAnimator.type.Quip;
				}
				else
				{
					component.animationType = InteractionIconAnimator.type.Talk;
				}
				component.GetSpriteList();
				component.enabled = false;
				animateButton.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>().enabled = false;
				if (Links.x.joy)
				{
					flag = Links.x.partyColliderAdventure.InRange(nearCharacter);
				}
				if (flag)
				{
					component.gameObject.transform.parent.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
				}
				else
				{
					component.gameObject.transform.parent.transform.localScale = Vector3.zero;
				}
			}
			if (num > -1 && !state)
			{
				this.nearTalkCharacters.RemoveAt(num);
				this.nearBtns.Add(this.nearBtnCharsUsed[num]);
				this.nearBtnCharsUsed[num].gameObject.transform.parent.gameObject.SetActive(false);
				this.nearBtnCharsUsed.RemoveAt(num);
			}
		}
		if (nearBoat)
		{
			int num2 = this.nearBoats.IndexOf(nearBoat);
			if (num2 == -1 && state)
			{
				this.nearBoats.Add(nearBoat);
				AnimateButton animateButton2 = this.SetupNearIcon();
				this.nearBtnBoatsUsed.Add(animateButton2);
				InteractionIconAnimator component2 = animateButton2.gameObject.GetComponent<InteractionIconAnimator>();
				component2.animationType = InteractionIconAnimator.type.Use;
				component2.GetSpriteList();
				component2.enabled = false;
				animateButton2.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>().enabled = false;
				if (Links.x.joy)
				{
					flag = Links.x.partyColliderAdventure.InRange(nearBoat);
				}
				if (flag)
				{
					component2.gameObject.transform.parent.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
				}
				else
				{
					component2.gameObject.transform.parent.transform.localScale = Vector3.zero;
				}
			}
			if (num2 > -1 && !state)
			{
				this.nearBoats.RemoveAt(num2);
				this.nearBtns.Add(this.nearBtnBoatsUsed[num2]);
				this.nearBtnBoatsUsed[num2].gameObject.transform.parent.gameObject.SetActive(false);
				this.nearBtnBoatsUsed.RemoveAt(num2);
			}
		}
		if (nearBreak)
		{
			int num3 = this.nearBreakables.IndexOf(nearBreak);
			if (num3 == -1 && state)
			{
				this.nearBreakables.Add(nearBreak);
				AnimateButton animateButton3 = this.SetupNearIcon();
				this.nearBtnBreaksUsed.Add(animateButton3);
				InteractionIconAnimator component3 = animateButton3.gameObject.GetComponent<InteractionIconAnimator>();
				if (nearBreak.resourceLocation == -1)
				{
					component3.animationType = InteractionIconAnimator.type.Kick;
				}
				else
				{
					component3.animationType = InteractionIconAnimator.type.Use;
				}
				component3.GetSpriteList();
				component3.enabled = false;
				animateButton3.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>().enabled = false;
				if (Links.x.joy)
				{
					flag = Links.x.partyColliderAdventure.InRange(nearBreak);
				}
				if (flag)
				{
					component3.gameObject.transform.parent.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
				}
				else
				{
					component3.gameObject.transform.parent.transform.localScale = Vector3.zero;
				}
			}
			if (num3 > -1 && !state)
			{
				this.nearBreakables.RemoveAt(num3);
				this.nearBtns.Add(this.nearBtnBreaksUsed[num3]);
				this.nearBtnBreaksUsed[num3].gameObject.transform.parent.gameObject.SetActive(false);
				this.nearBtnBreaksUsed.RemoveAt(num3);
			}
		}
		if (nearChest)
		{
			int num4 = this.nearChests.IndexOf(nearChest);
			if (num4 == -1 && state)
			{
				this.nearChests.Add(nearChest);
				AnimateButton animateButton4 = this.SetupNearIcon();
				this.nearBtnChestsUsed.Add(animateButton4);
				InteractionIconAnimator component4 = animateButton4.gameObject.GetComponent<InteractionIconAnimator>();
				if (nearChest.chest.locked)
				{
					component4.animationType = InteractionIconAnimator.type.Unlock;
				}
				else
				{
					component4.animationType = InteractionIconAnimator.type.Use;
				}
				component4.GetSpriteList();
				component4.enabled = false;
				animateButton4.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>().enabled = false;
				if (Links.x.joy)
				{
					flag = Links.x.partyColliderAdventure.InRange(nearChest);
				}
				if (flag)
				{
					component4.gameObject.transform.parent.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
				}
				else
				{
					component4.gameObject.transform.parent.transform.localScale = Vector3.zero;
				}
			}
			if (num4 > -1 && !state)
			{
				this.nearChests.RemoveAt(num4);
				this.nearBtns.Add(this.nearBtnChestsUsed[num4]);
				this.nearBtnChestsUsed[num4].gameObject.transform.parent.gameObject.SetActive(false);
				this.nearBtnChestsUsed.RemoveAt(num4);
			}
		}
		if (nearPuzzle)
		{
			int num5 = this.nearPuzzles.IndexOf(nearPuzzle);
			if (num5 == -1 && state)
			{
				this.nearPuzzles.Add(nearPuzzle);
				AnimateButton animateButton5 = this.SetupNearIcon();
				this.nearBtnPuzzUsed.Add(animateButton5);
				InteractionIconAnimator component5 = animateButton5.gameObject.GetComponent<InteractionIconAnimator>();
				component5.animationType = InteractionIconAnimator.type.Use;
				component5.GetSpriteList();
				component5.enabled = false;
				animateButton5.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>().enabled = false;
				if (Links.x.joy)
				{
					flag = Links.x.partyColliderAdventure.InRange(nearPuzzle);
				}
				if (flag)
				{
					component5.gameObject.transform.parent.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
				}
				else
				{
					component5.gameObject.transform.parent.transform.localScale = Vector3.zero;
				}
			}
			if (num5 > -1 && !state)
			{
				this.nearPuzzles.RemoveAt(num5);
				this.nearBtns.Add(this.nearBtnPuzzUsed[num5]);
				this.nearBtnPuzzUsed[num5].gameObject.transform.parent.gameObject.SetActive(false);
				this.nearBtnPuzzUsed.RemoveAt(num5);
			}
		}
		if (nearDoor)
		{
			int num6 = this.nearDoors.IndexOf(nearDoor);
			if (num6 == -1 && state)
			{
				this.nearDoors.Add(nearDoor);
				AnimateButton animateButton6 = this.SetupNearIcon();
				this.nearBtnDoorsUsed.Add(animateButton6);
				InteractionIconAnimator component6 = animateButton6.gameObject.GetComponent<InteractionIconAnimator>();
				component6.animationType = InteractionIconAnimator.type.Unlock;
				if (!nearDoor.door.locked)
				{
					component6.animationType = InteractionIconAnimator.type.Lockpick;
				}
				component6.GetSpriteList();
				component6.enabled = false;
				animateButton6.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>().enabled = false;
				if (Links.x.joy)
				{
					flag = Links.x.partyColliderAdventure.InRange(nearDoor);
				}
				if (flag)
				{
					component6.gameObject.transform.parent.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
				}
				else
				{
					component6.gameObject.transform.parent.transform.localScale = Vector3.zero;
				}
			}
			if (num6 > -1 && !state)
			{
				this.nearDoors.RemoveAt(num6);
				this.nearBtns.Add(this.nearBtnDoorsUsed[num6]);
				this.nearBtnDoorsUsed[num6].gameObject.transform.parent.gameObject.SetActive(false);
				this.nearBtnDoorsUsed.RemoveAt(num6);
			}
		}
		if (nearMap)
		{
			int num7 = this.nearMapExits.IndexOf(nearMap);
			if (num7 == -1 && state)
			{
				this.nearMapExits.Add(nearMap);
				AnimateButton animateButton7 = this.SetupNearIcon();
				this.nearBtnExitsUsed.Add(animateButton7);
				InteractionIconAnimator component7 = animateButton7.gameObject.GetComponent<InteractionIconAnimator>();
				component7.animationType = InteractionIconAnimator.type.Use;
				component7.GetSpriteList();
				component7.enabled = false;
				animateButton7.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>().enabled = false;
				if (Links.x.joy)
				{
					flag = Links.x.partyColliderAdventure.InRange(nearMap);
				}
				if (flag)
				{
					component7.gameObject.transform.parent.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
				}
				else
				{
					component7.gameObject.transform.parent.transform.localScale = Vector3.zero;
				}
			}
			if (num7 > -1 && !state)
			{
				this.nearMapExits.RemoveAt(num7);
				this.nearBtns.Add(this.nearBtnExitsUsed[num7]);
				this.nearBtnExitsUsed[num7].gameObject.transform.parent.gameObject.SetActive(false);
				this.nearBtnExitsUsed.RemoveAt(num7);
			}
		}
	}

	// Token: 0x06000FEA RID: 4074 RVA: 0x00133B5C File Offset: 0x00131D5C
	public AnimateButton SetupNearIcon()
	{
		AnimateButton animateButton;
		if (this.nearBtns.Count > 0)
		{
			animateButton = this.nearBtns[0];
			this.nearBtns.RemoveAt(0);
		}
		else
		{
			animateButton = Object.Instantiate<GameObject>(this.nearBtnPrefab, new Vector3(0f, 0f, 0f), Quaternion.identity, this.interactionBtnsTransform).transform.GetChild(0).gameObject.GetComponent<AnimateButton>();
		}
		animateButton.GetParentRT();
		animateButton.gameObject.transform.parent.gameObject.SetActive(true);
		return animateButton;
	}

	// Token: 0x06000FEB RID: 4075 RVA: 0x00133BF6 File Offset: 0x00131DF6
	public bool CharacterIsNear(Character c)
	{
		return this.nearTalkCharacters.Contains(c);
	}

	// Token: 0x06000FEC RID: 4076 RVA: 0x00133C09 File Offset: 0x00131E09
	public bool BreakableIsNear(BreakableActions c)
	{
		return this.nearBreakables.Contains(c);
	}

	// Token: 0x06000FED RID: 4077 RVA: 0x00133C1C File Offset: 0x00131E1C
	public bool ChestIsNear(ChestActions c)
	{
		return this.nearChests.Contains(c);
	}

	// Token: 0x06000FEE RID: 4078 RVA: 0x00133C2F File Offset: 0x00131E2F
	public bool PuzzleIsNear(PuzzleActions c)
	{
		return this.nearPuzzles.Contains(c);
	}

	// Token: 0x06000FEF RID: 4079 RVA: 0x00133C42 File Offset: 0x00131E42
	public bool DoorIsNear(DoorActions c)
	{
		return this.nearDoors.Contains(c);
	}

	// Token: 0x06000FF0 RID: 4080 RVA: 0x00133C55 File Offset: 0x00131E55
	public bool ExitIsNear(MapExitActions c)
	{
		return this.nearMapExits.Contains(c);
	}

	// Token: 0x06000FF1 RID: 4081 RVA: 0x00133C68 File Offset: 0x00131E68
	public bool BoatIsNear(Boat c)
	{
		return this.nearBoats.Contains(c);
	}

	// Token: 0x06000FF2 RID: 4082 RVA: 0x00133C7C File Offset: 0x00131E7C
	public void ClearOnReload()
	{
		for (int i = 0; i < this.nearBtnExitsUsed.Count; i++)
		{
			if (this.nearBtnExitsUsed[i])
			{
				this.nearBtnExitsUsed[i].gameObject.transform.parent.gameObject.SetActive(false);
				this.nearBtns.Add(this.nearBtnExitsUsed[i]);
			}
		}
		for (int j = 0; j < this.nearBtnDoorsUsed.Count; j++)
		{
			if (this.nearBtnDoorsUsed[j])
			{
				this.nearBtnDoorsUsed[j].gameObject.transform.parent.gameObject.SetActive(false);
				this.nearBtns.Add(this.nearBtnDoorsUsed[j]);
			}
		}
		for (int k = 0; k < this.nearBtnPuzzUsed.Count; k++)
		{
			if (this.nearBtnPuzzUsed[k])
			{
				this.nearBtnPuzzUsed[k].gameObject.transform.parent.gameObject.SetActive(false);
				this.nearBtns.Add(this.nearBtnPuzzUsed[k]);
			}
		}
		for (int l = 0; l < this.nearBtnChestsUsed.Count; l++)
		{
			if (this.nearBtnChestsUsed[l])
			{
				this.nearBtnChestsUsed[l].gameObject.transform.parent.gameObject.SetActive(false);
				this.nearBtns.Add(this.nearBtnChestsUsed[l]);
			}
		}
		for (int m = 0; m < this.nearBtnBreaksUsed.Count; m++)
		{
			if (this.nearBtnBreaksUsed[m])
			{
				this.nearBtnBreaksUsed[m].gameObject.transform.parent.gameObject.SetActive(false);
				this.nearBtns.Add(this.nearBtnBreaksUsed[m]);
			}
		}
		for (int n = 0; n < this.nearBtnCharsUsed.Count; n++)
		{
			if (this.nearBtnCharsUsed[n])
			{
				this.nearBtnCharsUsed[n].gameObject.transform.parent.gameObject.SetActive(false);
				this.nearBtns.Add(this.nearBtnCharsUsed[n]);
			}
		}
		for (int num = 0; num < this.nearBtnBoatsUsed.Count; num++)
		{
			if (this.nearBtnBoatsUsed[num])
			{
				this.nearBtnBoatsUsed[num].gameObject.transform.parent.gameObject.SetActive(false);
				this.nearBtns.Add(this.nearBtnBoatsUsed[num]);
			}
		}
		this.nearBtnCharsUsed.Clear();
		this.nearBtnDoorsUsed.Clear();
		this.nearBtnPuzzUsed.Clear();
		this.nearBtnChestsUsed.Clear();
		this.nearBtnBreaksUsed.Clear();
		this.nearBtnBoatsUsed.Clear();
		this.nearBtnExitsUsed.Clear();
		this.nearTalkCharacters.Clear();
		this.nearBreakables.Clear();
		this.nearChests.Clear();
		this.nearPuzzles.Clear();
		this.nearDoors.Clear();
		this.nearMapExits.Clear();
		this.nearBoats.Clear();
	}

	// Token: 0x06000FF3 RID: 4083 RVA: 0x00134004 File Offset: 0x00132204
	public int ItemCardCount()
	{
		return this.nearBreakables.Count + this.nearDoors.Count + this.nearTalkCharacters.Count + this.nearChests.Count + this.nearPuzzles.Count + this.nearBoats.Count;
	}

	// Token: 0x06000FF4 RID: 4084 RVA: 0x00134058 File Offset: 0x00132258
	public void NearButtonLocations()
	{
		float num = 0f;
		if (!Links.x.worldCamera.orthographic)
		{
			num = 1f;
		}
		bool flag = false;
		for (int i = 0; i < this.nearBtnExitsUsed.Count; i++)
		{
			if (!flag && this.nearBtnExitsUsed[i])
			{
				if (this.nearMapExits[i])
				{
					bool flag2 = false;
					if (Links.x.joy)
					{
						flag2 = Links.x.partyColliderAdventure.InRange(this.nearMapExits[i]);
					}
					if (flag2)
					{
						this.nearBtnExitsUsed[i].SetPositionAtWorldPoint(this.nearMapExits[i].GetIconPosition());
						if (!this.nearBtnExitsUsed[i].gameObject.activeSelf)
						{
							this.nearBtnExitsUsed[i].gameObject.transform.parent.gameObject.SetActive(true);
						}
						if (this.nearBtnExitsUsed[i].transform.parent.transform.localScale.x == 0f)
						{
							this.nearBtnExitsUsed[i].gameObject.transform.parent.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
						}
					}
					else if (this.nearBtnExitsUsed[i].transform.parent.transform.localScale.x != 0f)
					{
						this.nearBtnExitsUsed[i].gameObject.transform.parent.transform.localScale = Vector3.zero;
					}
				}
				else
				{
					this.nearMapExits.RemoveAt(i);
					this.nearBtns.Add(this.nearBtnExitsUsed[i]);
					this.nearBtnExitsUsed[i].gameObject.transform.parent.gameObject.SetActive(false);
					this.nearBtnExitsUsed.RemoveAt(i);
					flag = true;
				}
			}
		}
		flag = false;
		for (int j = 0; j < this.nearBtnDoorsUsed.Count; j++)
		{
			if (!flag && this.nearBtnDoorsUsed[j])
			{
				if (this.nearDoors[j])
				{
					bool flag3 = false;
					if (Links.x.joy)
					{
						flag3 = Links.x.partyColliderAdventure.InRange(this.nearDoors[j]);
					}
					if (flag3)
					{
						this.nearBtnDoorsUsed[j].SetPositionAtWorldPoint(this.nearDoors[j].lockColliderPosition + new Vector3(0f, 1f - num, 0f));
						if (!this.nearBtnDoorsUsed[j].gameObject.activeSelf)
						{
							this.nearBtnDoorsUsed[j].gameObject.transform.parent.gameObject.SetActive(true);
						}
						if (this.nearBtnDoorsUsed[j].transform.parent.transform.localScale.x == 0f)
						{
							this.nearBtnDoorsUsed[j].gameObject.transform.parent.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
						}
					}
					else if (this.nearBtnDoorsUsed[j].transform.parent.transform.localScale.x != 0f)
					{
						this.nearBtnDoorsUsed[j].gameObject.transform.parent.transform.localScale = Vector3.zero;
					}
				}
				else
				{
					this.nearDoors.RemoveAt(j);
					this.nearBtns.Add(this.nearBtnDoorsUsed[j]);
					this.nearBtnDoorsUsed[j].gameObject.transform.parent.gameObject.SetActive(false);
					this.nearBtnDoorsUsed.RemoveAt(j);
					flag = true;
				}
			}
		}
		flag = false;
		for (int k = 0; k < this.nearBtnPuzzUsed.Count; k++)
		{
			if (!flag && this.nearBtnPuzzUsed[k])
			{
				if (this.nearPuzzles[k])
				{
					bool flag4 = false;
					if (Links.x.joy)
					{
						flag4 = Links.x.partyColliderAdventure.InRange(this.nearPuzzles[k]);
					}
					if (flag4)
					{
						this.nearBtnPuzzUsed[k].SetPositionAtWorldPoint(this.nearPuzzles[k].gameObject.transform.position + new Vector3(0f, this.nearPuzzles[k].interactionPointY - num, 0f));
						if (!this.nearBtnPuzzUsed[k].gameObject.activeSelf)
						{
							this.nearBtnPuzzUsed[k].gameObject.transform.parent.gameObject.SetActive(true);
						}
						if (this.nearBtnPuzzUsed[k].transform.parent.transform.localScale.x == 0f)
						{
							this.nearBtnPuzzUsed[k].gameObject.transform.parent.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
						}
					}
					else if (this.nearBtnPuzzUsed[k].transform.parent.transform.localScale.x != 0f)
					{
						this.nearBtnPuzzUsed[k].gameObject.transform.parent.transform.localScale = Vector3.zero;
					}
				}
				else
				{
					this.nearPuzzles.RemoveAt(k);
					this.nearBtns.Add(this.nearBtnPuzzUsed[k]);
					this.nearBtnPuzzUsed[k].gameObject.transform.parent.gameObject.SetActive(false);
					this.nearBtnPuzzUsed.RemoveAt(k);
					flag = true;
				}
			}
		}
		flag = false;
		for (int l = 0; l < this.nearBtnChestsUsed.Count; l++)
		{
			if (!flag && this.nearBtnChestsUsed[l])
			{
				if (this.nearChests[l])
				{
					bool flag5 = false;
					if (Links.x.joy)
					{
						flag5 = Links.x.partyColliderAdventure.InRange(this.nearChests[l]);
					}
					if (flag5)
					{
						this.nearBtnChestsUsed[l].SetPositionAtWorldPoint(this.nearChests[l].tr.position + new Vector3(0f, 1.5f - num, 0f));
						if (!this.nearBtnChestsUsed[l].gameObject.activeSelf)
						{
							this.nearBtnChestsUsed[l].gameObject.transform.parent.gameObject.SetActive(true);
						}
						if (this.nearBtnChestsUsed[l].transform.parent.transform.localScale.x == 0f)
						{
							this.nearBtnChestsUsed[l].gameObject.transform.parent.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
						}
					}
					else if (this.nearBtnChestsUsed[l].transform.parent.transform.localScale.x != 0f)
					{
						this.nearBtnChestsUsed[l].gameObject.transform.parent.transform.localScale = Vector3.zero;
					}
				}
				else
				{
					this.nearChests.RemoveAt(l);
					this.nearBtns.Add(this.nearBtnChestsUsed[l]);
					this.nearBtnChestsUsed[l].gameObject.transform.parent.gameObject.SetActive(false);
					this.nearBtnChestsUsed.RemoveAt(l);
					flag = true;
				}
			}
		}
		flag = false;
		for (int m = 0; m < this.nearBtnBreaksUsed.Count; m++)
		{
			if (!flag && this.nearBtnBreaksUsed[m])
			{
				if (this.nearBreakables[m])
				{
					bool flag6 = false;
					if (Links.x.joy)
					{
						flag6 = Links.x.partyColliderAdventure.InRange(this.nearBreakables[m]);
					}
					if (flag6)
					{
						this.nearBtnBreaksUsed[m].SetPositionAtWorldPoint(this.nearBreakables[m].transform.position + new Vector3(0f, 3f - num, 0f));
						if (!this.nearBtnBreaksUsed[m].gameObject.activeSelf)
						{
							this.nearBtnBreaksUsed[m].gameObject.transform.parent.gameObject.SetActive(true);
						}
						if (this.nearBtnBreaksUsed[m].transform.parent.transform.localScale.x == 0f)
						{
							this.nearBtnBreaksUsed[m].gameObject.transform.parent.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
						}
					}
					else if (this.nearBtnBreaksUsed[m].transform.parent.transform.localScale.x != 0f)
					{
						this.nearBtnBreaksUsed[m].gameObject.transform.parent.transform.localScale = Vector3.zero;
					}
				}
				else
				{
					this.nearBreakables.RemoveAt(m);
					this.nearBtns.Add(this.nearBtnBreaksUsed[m]);
					this.nearBtnBreaksUsed[m].gameObject.transform.parent.gameObject.SetActive(false);
					this.nearBtnBreaksUsed.RemoveAt(m);
					flag = true;
				}
			}
		}
		flag = false;
		for (int n = 0; n < this.nearBtnCharsUsed.Count; n++)
		{
			if (!flag && this.nearBtnCharsUsed[n])
			{
				if (this.nearTalkCharacters[n])
				{
					Character character = this.nearTalkCharacters[n];
					bool flag7 = false;
					if (Links.x.joy)
					{
						flag7 = Links.x.partyColliderAdventure.InRange(character);
					}
					if (flag7)
					{
						if ((character.isBoro && Records.x.partySailing) || character.inactive || character.hasActions || character.dayNightVanishing || !character.IsSentient())
						{
							this.AddRemoveInteraction(false, character, null, null, null, null, null, null);
						}
						else
						{
							this.nearBtnCharsUsed[n].SetPositionAtWorldPoint(this.nearTalkCharacters[n].body.GetNeck().position + new Vector3(0f, 2.1f - num, 0f));
							if (!this.nearBtnCharsUsed[n].gameObject.activeSelf)
							{
								this.nearBtnCharsUsed[n].gameObject.transform.parent.gameObject.SetActive(true);
							}
						}
						if (this.nearBtnCharsUsed[n].transform.parent.transform.localScale.x == 0f)
						{
							this.nearBtnCharsUsed[n].gameObject.transform.parent.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
						}
					}
					else if (this.nearBtnCharsUsed[n].transform.parent.transform.localScale.x != 0f)
					{
						this.nearBtnCharsUsed[n].gameObject.transform.parent.transform.localScale = Vector3.zero;
					}
				}
				else
				{
					this.nearTalkCharacters.RemoveAt(n);
					this.nearBtns.Add(this.nearBtnCharsUsed[n]);
					this.nearBtnCharsUsed[n].gameObject.transform.parent.gameObject.SetActive(false);
					this.nearBtnCharsUsed.RemoveAt(n);
					flag = true;
				}
			}
		}
		flag = false;
		for (int num2 = 0; num2 < this.nearBtnBoatsUsed.Count; num2++)
		{
			if (!flag && this.nearBtnBoatsUsed[num2])
			{
				bool flag8 = false;
				if (Links.x.joy)
				{
					flag8 = Links.x.partyColliderAdventure.InRange(this.nearBoats[num2]);
				}
				if (flag8)
				{
					this.nearBtnBoatsUsed[num2].SetPositionAtWorldPoint(this.nearBoats[num2].tr.position + new Vector3(0f, 2f - num, 0f));
					if (!this.nearBtnBoatsUsed[num2].gameObject.activeSelf)
					{
						this.nearBtnBoatsUsed[num2].gameObject.transform.parent.gameObject.SetActive(true);
					}
					if (this.nearBtnBoatsUsed[num2].transform.parent.transform.localScale.x == 0f)
					{
						this.nearBtnBoatsUsed[num2].gameObject.transform.parent.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
					}
				}
				else if (this.nearBtnBoatsUsed[num2].transform.parent.transform.localScale.x != 0f)
				{
					this.nearBtnBoatsUsed[num2].gameObject.transform.parent.transform.localScale = Vector3.zero;
				}
			}
		}
	}

	// Token: 0x06000FF5 RID: 4085 RVA: 0x00134FF4 File Offset: 0x001331F4
	public void HighlightBoat(bool state, Boat boat)
	{
		bool flag = false;
		if (!boat)
		{
			flag = true;
		}
		bool flag2 = true;
		if (Links.x.mk)
		{
			flag2 = false;
		}
		bool flag3 = false;
		if (Links.x.mk && state)
		{
			for (int i = 0; i < this.nearBoats.Count; i++)
			{
				if (this.nearBoats[i] == boat || flag)
				{
					flag3 = true;
				}
			}
			if (!flag3)
			{
				this.AddRemoveInteraction(state, null, null, null, null, null, null, boat);
			}
		}
		for (int j = 0; j < this.nearBoats.Count; j++)
		{
			if (this.nearBoats[j] == boat || flag)
			{
				AnimateButton animateButton = this.nearBtnBoatsUsed[j];
				TextMeshProUGUI component = animateButton.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>();
				if (state)
				{
					InteractionIconAnimator component2 = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
					component2.enabled = true;
					component.enabled = Links.x.joy;
					if (Links.x.joy)
					{
						component.spriteAsset = Links.x.GetSpriteSheetAsset(Links.x.gameplay.currentSpriteSheetAsset);
						component.text = "<sprite=" + Links.x.gameplay.GetControllerSprite("Interact", Links.x.gameplay.controllerName).ToString() + ">";
					}
					component2.gameObject.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
				}
				else
				{
					InteractionIconAnimator component3 = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
					component3.enabled = false;
					component.enabled = false;
					if (flag2)
					{
						component3.gameObject.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
					}
					else
					{
						component3.gameObject.transform.localScale = Vector3.zero;
					}
				}
			}
		}
		if (Links.x.mk && !state)
		{
			this.AddRemoveInteraction(state, null, null, null, null, null, null, boat);
		}
	}

	// Token: 0x06000FF6 RID: 4086 RVA: 0x00135214 File Offset: 0x00133414
	public void HighlightCharacter(bool state, Character character)
	{
		bool flag = false;
		if (!character)
		{
			flag = true;
		}
		bool flag2 = true;
		if (Links.x.mk)
		{
			flag2 = false;
		}
		bool flag3 = false;
		if (Links.x.mk && state)
		{
			for (int i = 0; i < this.nearTalkCharacters.Count; i++)
			{
				if (this.nearTalkCharacters[i] == character || flag)
				{
					flag3 = true;
				}
			}
			if (!flag3)
			{
				this.AddRemoveInteraction(state, character, null, null, null, null, null, null);
			}
		}
		for (int j = 0; j < this.nearTalkCharacters.Count; j++)
		{
			if (this.nearTalkCharacters[j] == character || flag)
			{
				AnimateButton animateButton = this.nearBtnCharsUsed[j];
				TextMeshProUGUI component = animateButton.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>();
				if (state && flag2)
				{
					InteractionIconAnimator component2 = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
					component2.enabled = true;
					component.enabled = Links.x.joy;
					if (Links.x.joy)
					{
						component.spriteAsset = Links.x.GetSpriteSheetAsset(Links.x.gameplay.currentSpriteSheetAsset);
						component.text = "<sprite=" + Links.x.gameplay.GetControllerSprite("Interact", Links.x.gameplay.controllerName).ToString() + ">";
					}
					component2.gameObject.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
				}
				else
				{
					InteractionIconAnimator component3 = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
					component3.enabled = false;
					component.enabled = false;
					if (flag2)
					{
						component3.gameObject.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
					}
					else
					{
						component3.gameObject.transform.localScale = Vector3.zero;
					}
				}
			}
		}
		if (Links.x.mk && !state)
		{
			this.AddRemoveInteraction(state, character, null, null, null, null, null, null);
		}
	}

	// Token: 0x06000FF7 RID: 4087 RVA: 0x00135434 File Offset: 0x00133634
	public void HighlightChest(bool state, ChestActions chest)
	{
		bool flag = false;
		if (!chest)
		{
			flag = true;
		}
		bool flag2 = true;
		if (Links.x.mk)
		{
			flag2 = false;
		}
		bool flag3 = false;
		if (Links.x.mk && state)
		{
			for (int i = 0; i < this.nearChests.Count; i++)
			{
				if (this.nearChests[i] == chest || flag)
				{
					flag3 = true;
				}
			}
			if (!flag3)
			{
				this.AddRemoveInteraction(state, null, null, chest, null, null, null, null);
			}
		}
		for (int j = 0; j < this.nearChests.Count; j++)
		{
			if (this.nearChests[j] == chest || flag)
			{
				AnimateButton animateButton = this.nearBtnChestsUsed[j];
				TextMeshProUGUI component = animateButton.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>();
				if (state)
				{
					InteractionIconAnimator component2 = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
					component2.enabled = true;
					component.enabled = Links.x.joy;
					if (Links.x.joy)
					{
						component.spriteAsset = Links.x.GetSpriteSheetAsset(Links.x.gameplay.currentSpriteSheetAsset);
						component.text = "<sprite=" + Links.x.gameplay.GetControllerSprite("Interact", Links.x.gameplay.controllerName).ToString() + ">";
					}
					component2.gameObject.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
				}
				else
				{
					InteractionIconAnimator component3 = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
					component3.enabled = false;
					component.enabled = false;
					if (flag2)
					{
						component3.gameObject.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
					}
					else
					{
						component3.gameObject.transform.localScale = Vector3.zero;
					}
				}
			}
		}
		if (Links.x.mk && !state)
		{
			this.AddRemoveInteraction(state, null, null, chest, null, null, null, null);
		}
	}

	// Token: 0x06000FF8 RID: 4088 RVA: 0x00135654 File Offset: 0x00133854
	public void HighlightBreakable(bool state, BreakableActions breakable)
	{
		bool flag = false;
		if (!breakable)
		{
			flag = true;
		}
		bool flag2 = true;
		if (Links.x.mk)
		{
			flag2 = false;
		}
		bool flag3 = false;
		if (Links.x.mk && state)
		{
			for (int i = 0; i < this.nearBreakables.Count; i++)
			{
				if (this.nearBreakables[i] == breakable || flag)
				{
					flag3 = true;
				}
			}
			if (!flag3)
			{
				this.AddRemoveInteraction(state, null, breakable, null, null, null, null, null);
			}
		}
		for (int j = 0; j < this.nearBreakables.Count; j++)
		{
			if (this.nearBreakables[j] == breakable || flag)
			{
				AnimateButton animateButton = this.nearBtnBreaksUsed[j];
				TextMeshProUGUI component = animateButton.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>();
				if (state && flag2)
				{
					InteractionIconAnimator component2 = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
					component2.enabled = true;
					component.enabled = Links.x.joy;
					if (Links.x.joy)
					{
						component.spriteAsset = Links.x.GetSpriteSheetAsset(Links.x.gameplay.currentSpriteSheetAsset);
						component.text = "<sprite=" + Links.x.gameplay.GetControllerSprite("Interact", Links.x.gameplay.controllerName).ToString() + ">";
					}
					component2.gameObject.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
				}
				else
				{
					InteractionIconAnimator component3 = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
					component3.enabled = false;
					component.enabled = false;
					if (flag2)
					{
						component3.gameObject.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
					}
					else
					{
						component3.gameObject.transform.localScale = Vector3.zero;
					}
				}
			}
		}
		if (Links.x.mk && !state)
		{
			this.AddRemoveInteraction(state, null, breakable, null, null, null, null, null);
		}
	}

	// Token: 0x06000FF9 RID: 4089 RVA: 0x00135874 File Offset: 0x00133A74
	public void HighlightDoor(bool state, DoorActions door)
	{
		bool flag = false;
		if (!door)
		{
			flag = true;
		}
		bool flag2 = true;
		if (Links.x.mk)
		{
			flag2 = false;
		}
		bool flag3 = false;
		if (Links.x.mk && state)
		{
			for (int i = 0; i < this.nearDoors.Count; i++)
			{
				if (this.nearDoors[i] == door || flag)
				{
					flag3 = true;
				}
			}
			if (!flag3)
			{
				this.AddRemoveInteraction(state, null, null, null, null, door, null, null);
			}
		}
		for (int j = 0; j < this.nearDoors.Count; j++)
		{
			if (this.nearDoors[j] == door || flag)
			{
				AnimateButton animateButton = this.nearBtnDoorsUsed[j];
				TextMeshProUGUI component = animateButton.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>();
				if (state)
				{
					InteractionIconAnimator component2 = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
					component2.enabled = true;
					component.enabled = Links.x.joy;
					if (Links.x.joy)
					{
						component.spriteAsset = Links.x.GetSpriteSheetAsset(Links.x.gameplay.currentSpriteSheetAsset);
						component.text = "<sprite=" + Links.x.gameplay.GetControllerSprite("Interact", Links.x.gameplay.controllerName).ToString() + ">";
					}
					component2.gameObject.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
				}
				else
				{
					InteractionIconAnimator component3 = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
					component3.enabled = false;
					component.enabled = false;
					if (flag2)
					{
						component3.gameObject.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
					}
					else
					{
						component3.gameObject.transform.localScale = Vector3.zero;
					}
				}
			}
		}
		if (Links.x.mk && !state)
		{
			this.AddRemoveInteraction(state, null, null, null, null, door, null, null);
		}
	}

	// Token: 0x06000FFA RID: 4090 RVA: 0x00135A94 File Offset: 0x00133C94
	public void HighlightExit(bool state, MapExitActions exit)
	{
		bool flag = false;
		if (!exit)
		{
			flag = true;
		}
		bool flag2 = true;
		if (Links.x.mk)
		{
			flag2 = false;
		}
		bool flag3 = false;
		if (Links.x.mk && state)
		{
			for (int i = 0; i < this.nearMapExits.Count; i++)
			{
				if (this.nearMapExits[i] == exit || flag)
				{
					flag3 = true;
				}
			}
			if (!flag3)
			{
				this.AddRemoveInteraction(state, null, null, null, null, null, exit, null);
			}
		}
		for (int j = 0; j < this.nearMapExits.Count; j++)
		{
			if (this.nearMapExits[j] == exit || flag)
			{
				AnimateButton animateButton = this.nearBtnExitsUsed[j];
				TextMeshProUGUI component = animateButton.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>();
				if (state && flag2)
				{
					InteractionIconAnimator component2 = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
					component2.enabled = true;
					component.enabled = Links.x.joy;
					if (Links.x.joy)
					{
						component.spriteAsset = Links.x.GetSpriteSheetAsset(Links.x.gameplay.currentSpriteSheetAsset);
						component.text = "<sprite=" + Links.x.gameplay.GetControllerSprite("Interact", Links.x.gameplay.controllerName).ToString() + ">";
					}
					component2.gameObject.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
				}
				else
				{
					InteractionIconAnimator component3 = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
					component3.enabled = false;
					component.enabled = false;
					if (flag2)
					{
						component3.gameObject.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
					}
					else
					{
						component3.gameObject.transform.localScale = Vector3.zero;
					}
				}
			}
		}
		if (Links.x.mk && !state)
		{
			this.AddRemoveInteraction(state, null, null, null, null, null, exit, null);
		}
	}

	// Token: 0x06000FFB RID: 4091 RVA: 0x00135CB4 File Offset: 0x00133EB4
	public void HighlightPuzzle(bool state, PuzzleActions puzzle)
	{
		bool flag = false;
		if (!puzzle)
		{
			flag = true;
		}
		bool flag2 = true;
		if (Links.x.mk)
		{
			flag2 = false;
		}
		bool flag3 = false;
		if (Links.x.mk && state)
		{
			for (int i = 0; i < this.nearPuzzles.Count; i++)
			{
				if (this.nearPuzzles[i] == puzzle || flag)
				{
					flag3 = true;
				}
			}
			if (!flag3)
			{
				this.AddRemoveInteraction(state, null, null, null, puzzle, null, null, null);
			}
		}
		for (int j = 0; j < this.nearPuzzles.Count; j++)
		{
			if (this.nearPuzzles[j] == puzzle || flag)
			{
				AnimateButton animateButton = this.nearBtnPuzzUsed[j];
				TextMeshProUGUI component = animateButton.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>();
				if (state && flag2)
				{
					InteractionIconAnimator component2 = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
					component2.enabled = true;
					component.enabled = Links.x.joy;
					if (Links.x.joy)
					{
						component.spriteAsset = Links.x.GetSpriteSheetAsset(Links.x.gameplay.currentSpriteSheetAsset);
						component.text = "<sprite=" + Links.x.gameplay.GetControllerSprite("Interact", Links.x.gameplay.controllerName).ToString() + ">";
					}
					component2.gameObject.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
				}
				else
				{
					InteractionIconAnimator component3 = animateButton.gameObject.GetComponent<InteractionIconAnimator>();
					component3.enabled = false;
					component.enabled = false;
					if (flag2)
					{
						component3.gameObject.transform.localScale = new Vector3(this.iconScale, this.iconScale, this.iconScale);
					}
					else
					{
						component3.gameObject.transform.localScale = Vector3.zero;
					}
				}
			}
		}
		if (Links.x.mk && !state)
		{
			this.AddRemoveInteraction(state, null, null, null, puzzle, null, null, null);
		}
	}

	// Token: 0x06000FFC RID: 4092 RVA: 0x00135ED3 File Offset: 0x001340D3
	public void RemoveAllHighlights()
	{
		this.HighlightPuzzle(false, null);
		this.HighlightBoat(false, null);
		this.HighlightChest(false, null);
		this.HighlightDoor(false, null);
		this.HighlightBreakable(false, null);
		this.HighlightCharacter(false, null);
	}

	// Token: 0x06000FFD RID: 4093 RVA: 0x00135F08 File Offset: 0x00134108
	public void CheckIfInspecting()
	{
		if (!Links.x.inspectTextAnimator.gameObject.activeSelf)
		{
			return;
		}
		if (Records.x.inspecting)
		{
			this.ClickedInspectButton();
			Records.x.inspectCamera = null;
			Links.x.inspectTextAnimator.Play("InspectOff");
		}
	}

	// Token: 0x06000FFE RID: 4094 RVA: 0x00135F60 File Offset: 0x00134160
	public void ClickedInspectButton()
	{
		if (!Links.x.inspectTextAnimator.gameObject.activeSelf)
		{
			return;
		}
		if (Records.x.inspecting)
		{
			Records.x.inspecting = false;
			if (!Records.x.previousView)
			{
				if (Links.x.main.desiredGraph == 0)
				{
					Records.x.previousView = Links.x.diorama.GetOutdoorView();
				}
				else
				{
					Records.x.previousView = Links.x.diorama.GetIndoorView();
				}
			}
			Links.x.diorama.ToggleSceneCameras(Records.x.previousView.isInterior, Records.x.previousView.id);
			Links.x.rtsCamera.ReturnOrthographicCamera();
			Links.x.inspectTextAnimator.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>().text = "Inspect";
			return;
		}
		if (Records.x.inspectCamera)
		{
			Records.x.previousView = Links.x.diorama.activeView;
			Links.x.diorama.ToggleSceneCameras(Records.x.inspectCamera.isInterior, Records.x.inspectCamera.id);
			Links.x.rtsCamera.CopyPerspectiveCamera(Links.x.diorama.activeView.sceneCamera, null, null);
			Links.x.inspectTextAnimator.gameObject.transform.GetChild(0).gameObject.GetComponent<TextMeshProUGUI>().text = "Return";
			Records.x.inspecting = true;
		}
	}

	// Token: 0x06000FFF RID: 4095 RVA: 0x00136118 File Offset: 0x00134318
	public void MoveFeedAndNote()
	{
		Windows windows = this.windows[0];
		Windows windows2 = this.windows[6];
		windows.SetPivotLeft();
		windows2.SetPivotLeft();
		int num = 0;
		float num2 = 100000f;
		for (int i = 0; i < 4; i++)
		{
			float sqrMagnitude = (windows.rt.position - this.feedPositions[i].position).sqrMagnitude;
			if (sqrMagnitude < num2)
			{
				num2 = sqrMagnitude;
				num = i;
			}
		}
		if (num == 0 || num == 1)
		{
			float y = windows.rt.sizeDelta.y;
			float num3 = Mathf.Abs(this.feedPositions[0].sizeDelta.y - y);
			if (Mathf.Abs(this.feedPositions[1].sizeDelta.y - y) < num3)
			{
				num = 1;
			}
		}
		int num4 = num + 1;
		if (num4 == 4)
		{
			num4 = 0;
		}
		windows.rt.anchoredPosition3D = this.feedPositions[num4].anchoredPosition3D;
		windows.rt.sizeDelta = this.feedPositions[num4].sizeDelta;
		windows2.rt.anchoredPosition3D = this.feedPositions[num4 + 4].anchoredPosition3D;
		windows2.rt.sizeDelta = this.feedPositions[num4 + 4].sizeDelta;
	}

	// Token: 0x06001000 RID: 4096 RVA: 0x00136280 File Offset: 0x00134480
	public void ToggleControllerItemsIcon(bool state)
	{
		if (Links.x.joy)
		{
			this.controllerItem1.SetActive(state);
			this.controllerItem2.SetActive(state);
			if (Links.x.pocketWheel.open)
			{
				this.controllerLeader1.SetActive(true);
				this.controllerLeader2.SetActive(true);
				return;
			}
			this.controllerLeader1.SetActive(state);
			this.controllerLeader2.SetActive(state);
		}
	}

	// Token: 0x06001001 RID: 4097 RVA: 0x001362F4 File Offset: 0x001344F4
	public void SaveWindows()
	{
		string text = Records.x.openBook + "/Quests.es3";
		Vector3 zero = Vector3.zero;
		Vector3 zero2 = Vector3.zero;
		bool flag = false;
		float num = 0f;
		float num2 = 0f;
		this.windowsPosition.Clear();
		this.windowsSize.Clear();
		this.windowsFull.Clear();
		this.windowsCharacter.Clear();
		for (int i = 0; i < this.windows.Count; i++)
		{
			this.windows[i].Save(out zero, out zero2, out flag, out num, out num2);
			this.windowsPosition.Add(zero2);
			this.windowsSize.Add(zero);
			Vector3 vector = new Vector3(num, num2, 0f);
			if (flag)
			{
				vector.z = 1f;
			}
			this.windowsFull.Add(vector);
			if (this.windows[i].linkedPortrait)
			{
				if (this.windows[i].linkedPortrait.character)
				{
					this.windowsCharacter.Add(this.windows[i].linkedPortrait.character.stats.GetName());
				}
				else
				{
					this.windowsCharacter.Add("");
				}
			}
			else
			{
				this.windowsCharacter.Add("");
			}
		}
		ES3.Save<List<Vector3>>("WindowsPosition", this.windowsPosition, text);
		ES3.Save<List<Vector3>>("WindowsSize", this.windowsSize, text);
		ES3.Save<List<Vector3>>("WindowsFull", this.windowsFull, text);
		ES3.Save<List<string>>("WindowsCharacter", this.windowsCharacter, text);
	}

	// Token: 0x06001002 RID: 4098 RVA: 0x001364AC File Offset: 0x001346AC
	public void LoadWindows()
	{
		string text = Records.x.openBook + "/Quests.es3";
		this.windowsPosition.Clear();
		this.windowsSize.Clear();
		this.windowsFull.Clear();
		this.windowsCharacter.Clear();
		this.windowsPosition = ES3.Load<List<Vector3>>("WindowsPosition", text, this.windowsPosition);
		this.windowsSize = ES3.Load<List<Vector3>>("WindowsSize", text, this.windowsSize);
		this.windowsFull = ES3.Load<List<Vector3>>("WindowsFull", text, this.windowsFull);
		this.windowsCharacter = ES3.Load<List<string>>("WindowsCharacter", text, this.windowsCharacter);
		this.hasWindowSaveFile = true;
		for (int i = 0; i < this.windows.Count; i++)
		{
			bool flag = false;
			if (i < this.windowsPosition.Count)
			{
				if (this.windowsFull[i].z > 0f)
				{
					flag = true;
				}
				if (this.windowsCharacter[i] == "")
				{
					this.windows[i].Load(this.windowsSize[i], this.windowsPosition[i], flag, this.windowsFull[i].x, this.windowsFull[i].y);
				}
			}
		}
	}

	// Token: 0x06001003 RID: 4099 RVA: 0x00136608 File Offset: 0x00134808
	public void GetWindowInfo(Character character, Windows window)
	{
		if (!this.hasWindowSaveFile)
		{
			return;
		}
		for (int i = 0; i < this.windowsCharacter.Count; i++)
		{
			if (character.stats.GetName() == this.windowsCharacter[i])
			{
				bool flag = false;
				if (this.windowsFull[i].z > 0f)
				{
					flag = true;
				}
				window.Load(this.windowsSize[i], this.windowsPosition[i], flag, this.windowsFull[i].x, this.windowsFull[i].y);
				return;
			}
		}
	}

	// Token: 0x06001004 RID: 4100 RVA: 0x001366B8 File Offset: 0x001348B8
	public void Controller()
	{
		if (Links.x.joy)
		{
			this.sheepButton.interactable = false;
		}
		else
		{
			this.sheepButton.interactable = true;
		}
		foreach (Windows windows in this.windows)
		{
			windows.ToggleController();
			if (windows.linkedPortrait)
			{
				windows.linkedPortrait.UpdateController();
			}
		}
	}

	// Token: 0x06001005 RID: 4101 RVA: 0x00136748 File Offset: 0x00134948
	public void ShowSheep(bool always)
	{
		bool flag = true;
		if (this.texturesIdle != null && !always)
		{
			flag = false;
		}
		if (flag)
		{
			Links.x.renderPortraits.AddCharacter(Links.x.gaia.boro, Records.x.boroID, null, false, null, null, null, null);
			this.sheepPedestal.SetActive(true);
			this.sheepImage.enabled = true;
		}
	}

	// Token: 0x06001006 RID: 4102 RVA: 0x001367B3 File Offset: 0x001349B3
	public void ClearSheep()
	{
		Links.x.renderPortraits.RemoveCharacter(Links.x.gaia.boro, Records.x.boroID, null);
		this.texturesIdle = null;
	}

	// Token: 0x06001007 RID: 4103 RVA: 0x001367E8 File Offset: 0x001349E8
	private void Update()
	{
		if (this.boroCardOn)
		{
			this.BoroCardPosition();
		}
		if (!Links.x.combat && !Records.x.pocketPause && Links.x.gameplay.seconds > this.updateRallyTime + 20f && Links.x.fellowship.rally > 0f)
		{
			this.updateRallyTime = Links.x.gameplay.seconds;
			this.UpdateRally(-1f);
		}
	}

	// Token: 0x06001008 RID: 4104 RVA: 0x00136874 File Offset: 0x00134A74
	public GameObject GetFirstBadge()
	{
		if (this.stunBadgeParent.childCount > 2 && this.stunBadgeParent.GetChild(2).gameObject.activeSelf)
		{
			int childCount = this.stunBadgeParent.childCount;
			Navigation navigation = default(Navigation);
			for (int i = 0; i < childCount; i++)
			{
				GameObject gameObject = this.stunBadgeParent.GetChild(i).GetChild(0).gameObject;
				if (gameObject.activeSelf)
				{
					Button component = gameObject.GetComponent<Button>();
					navigation.mode = Navigation.Mode.Explicit;
					component.navigation = navigation;
					Navigation navigation2 = component.navigation;
					navigation2.selectOnDown = null;
					navigation2.selectOnUp = null;
					navigation2.selectOnLeft = null;
					navigation2.selectOnRight = null;
					bool flag = false;
					for (int j = i + 1; j < childCount; j++)
					{
						GameObject gameObject2 = this.stunBadgeParent.GetChild(j).GetChild(0).gameObject;
						if (gameObject2.activeSelf)
						{
							Button component2 = gameObject2.gameObject.GetComponent<Button>();
							if (!flag)
							{
								navigation2.selectOnRight = component2;
								flag = true;
							}
						}
					}
					flag = false;
					for (int k = i - 1; k >= 0; k--)
					{
						GameObject gameObject3 = this.stunBadgeParent.GetChild(k).GetChild(0).gameObject;
						if (gameObject3.activeSelf)
						{
							Button component3 = gameObject3.GetComponent<Button>();
							if (!flag)
							{
								navigation2.selectOnLeft = component3;
								flag = true;
							}
						}
					}
					component.navigation = navigation2;
				}
			}
			return this.stunBadgeParent.GetChild(2).GetChild(0).gameObject;
		}
		return null;
	}

	// Token: 0x06001009 RID: 4105 RVA: 0x00136A00 File Offset: 0x00134C00
	public void RemoveBadgeNavigation()
	{
		if (this.stunBadgeParent.childCount > 2 && this.stunBadgeParent.GetChild(2).gameObject.activeSelf)
		{
			Navigation navigation = default(Navigation);
			int childCount = this.stunBadgeParent.childCount;
			for (int i = 0; i < childCount; i++)
			{
				GameObject gameObject = this.stunBadgeParent.GetChild(i).GetChild(0).gameObject;
				if (gameObject.activeSelf)
				{
					Selectable component = gameObject.GetComponent<Button>();
					navigation.mode = Navigation.Mode.None;
					component.navigation = navigation;
				}
			}
		}
	}

	// Token: 0x0600100A RID: 4106 RVA: 0x00136A88 File Offset: 0x00134C88
	public AnimateButton GetStunBadge(string characterName)
	{
		for (int i = 0; i < this.usedBadges.Count; i++)
		{
			if (this.usedBadges[i].info.Contains(characterName))
			{
				return this.usedBadges[i];
			}
		}
		return null;
	}

	// Token: 0x0600100B RID: 4107 RVA: 0x00136AD4 File Offset: 0x00134CD4
	public void UpdateBadgeState(AnimateButton btn)
	{
		btn.state = true;
		btn.gameObject.transform.parent.GetChild(2).gameObject.GetComponent<Image>().enabled = false;
		btn.gameObject.transform.parent.gameObject.GetComponent<Image>();
	}

	// Token: 0x0600100C RID: 4108 RVA: 0x00136B2C File Offset: 0x00134D2C
	public void BadgeController()
	{
		if (Links.x.mk)
		{
			if (this.badgeControllerText.activeSelf)
			{
				this.badgeControllerText.SetActive(false);
				return;
			}
		}
		else if (this.usedBadges.Count > 0 || this.usedBribeBadges.Count > 0)
		{
			if (!this.badgeControllerText.activeSelf)
			{
				this.badgeControllerText.SetActive(true);
				return;
			}
		}
		else if (this.badgeControllerText.activeSelf)
		{
			this.badgeControllerText.SetActive(false);
		}
	}

	// Token: 0x0600100D RID: 4109 RVA: 0x00136BB0 File Offset: 0x00134DB0
	public void AddStunBadge(string characterName, float t, bool state, bool fromSave)
	{
		this.stunGrid.enabled = true;
		if (this.gridCorout != null)
		{
			base.StopCoroutine(this.gridCorout);
			this.gridCorout = null;
		}
		AnimateButton animateButton;
		if (this.openBadges.Count == 0)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.badge, new Vector3(0f, 0f, 0f), Quaternion.identity, this.stunBadgeParent);
			animateButton = gameObject.transform.GetChild(0).GetComponent<AnimateButton>();
			gameObject.transform.localPosition = Vector3.zero;
			gameObject.SetActive(true);
		}
		else
		{
			animateButton = this.openBadges[0];
			this.openBadges.RemoveAt(0);
			animateButton.gameObject.transform.parent.gameObject.SetActive(true);
		}
		Links.x.renderPortraits.AddCharacter(null, characterName, null, false, null, animateButton.gameObject.GetComponent<RawImage>(), null, null);
		Image component = animateButton.gameObject.transform.GetChild(0).gameObject.GetComponent<Image>();
		int num = (int)t + 24 - (int)Mathf.Floor((float)Links.x.gameplay.GetCurrentGameTimeHours());
		component.fillAmount = (float)num / 24f;
		animateButton.info = characterName;
		animateButton.state = state;
		Image component2 = animateButton.gameObject.transform.parent.GetChild(2).gameObject.GetComponent<Image>();
		animateButton.gameObject.transform.parent.gameObject.GetComponent<Image>();
		if (!state)
		{
			component2.enabled = true;
		}
		else
		{
			component2.enabled = false;
		}
		animateButton.id = (int)t;
		this.usedBadges.Add(animateButton);
		if (!fromSave)
		{
			MasterAudio.PlaySoundAndForget("Feedback", 0.3f, new float?(1f), 0f, "HealProc", null);
			Links.x.itemPickupFX.gameObject.SetActive(true);
			Links.x.itemPickupFX.gameObject.GetComponent<HannahAnimator>().Play("Idle");
			Vector3 position = animateButton.gameObject.transform.position;
			Links.x.itemPickupFX.position = position;
		}
		this.stunBadgeParent.transform.parent.SetAsLastSibling();
		this.gridCorout = this.TurnOffStunGrid();
		base.StartCoroutine(this.gridCorout);
		this.BadgeController();
	}

	// Token: 0x0600100E RID: 4110 RVA: 0x00136E10 File Offset: 0x00135010
	public void UpdateStunHours()
	{
		for (int i = 0; i < this.usedBadges.Count; i++)
		{
			Image component = this.usedBadges[i].gameObject.transform.GetChild(0).gameObject.GetComponent<Image>();
			int num = this.usedBadges[i].id + 24 - (int)Mathf.Floor((float)Links.x.gameplay.GetCurrentGameTimeHours());
			component.fillAmount = (float)num / 24f;
		}
	}

	// Token: 0x0600100F RID: 4111 RVA: 0x00136E92 File Offset: 0x00135092
	private IEnumerator TurnOffStunGrid()
	{
		yield return new WaitForSecondsRealtime(0.1f);
		this.stunGrid.enabled = false;
		this.gridCorout = null;
		yield break;
	}

	// Token: 0x06001010 RID: 4112 RVA: 0x00136EA4 File Offset: 0x001350A4
	public void ClearBadges()
	{
		for (int i = 0; i < this.usedBadges.Count; i++)
		{
			this.openBadges.Add(this.usedBadges[i]);
			this.usedBadges[i].gameObject.transform.parent.gameObject.SetActive(false);
			this.usedBadges[i] = null;
		}
		this.usedBadges.Clear();
		this.BadgeController();
	}

	// Token: 0x06001011 RID: 4113 RVA: 0x00136F24 File Offset: 0x00135124
	public void RemoveStunBadge(string characterName, bool turnedIn)
	{
		this.stunGrid.enabled = true;
		if (this.gridCorout != null)
		{
			base.StopCoroutine(this.gridCorout);
			this.gridCorout = null;
		}
		for (int i = 0; i < this.usedBadges.Count; i++)
		{
			if (this.usedBadges[i].info.Contains(characterName))
			{
				this.openBadges.Add(this.usedBadges[i]);
				Links.x.renderPortraits.RemoveCharacter(null, characterName, null);
				if (turnedIn)
				{
					MasterAudio.PlaySoundAndForget("Feedback", 0.2f, new float?(1f), 0f, "TurnInCrime", null);
				}
				else
				{
					MasterAudio.PlaySoundAndForget("Feedback", 0.2f, new float?(1f), 0f, "NoneTheWiser", null);
				}
				Links.x.removeFX.gameObject.SetActive(true);
				Links.x.removeFX.gameObject.GetComponent<HannahAnimator>().Play("Idle");
				Vector3 position = this.usedBadges[i].gameObject.transform.position;
				Links.x.removeFX.position = position;
				this.usedBadges[i].gameObject.transform.parent.gameObject.SetActive(false);
				this.usedBadges[i] = null;
			}
		}
		this.usedBadges.RemoveAll((AnimateButton item) => item == null);
		this.gridCorout = this.TurnOffStunGrid();
		base.StartCoroutine(this.gridCorout);
		this.BadgeController();
	}

	// Token: 0x06001012 RID: 4114 RVA: 0x001370F4 File Offset: 0x001352F4
	public AnimateButton GetBribeBadge(string characterName)
	{
		for (int i = 0; i < this.usedBribeBadges.Count; i++)
		{
			if (this.usedBribeBadges[i].info.Contains(characterName))
			{
				return this.usedBribeBadges[i];
			}
		}
		return null;
	}

	// Token: 0x06001013 RID: 4115 RVA: 0x00137140 File Offset: 0x00135340
	public void UpdateBribeBadgeState(AnimateButton btn, bool transparent)
	{
		btn.state = transparent;
		Image component = btn.gameObject.transform.parent.GetChild(2).gameObject.GetComponent<Image>();
		if (transparent)
		{
			component.enabled = true;
			Image component2 = btn.gameObject.transform.parent.gameObject.GetComponent<Image>();
			component2.color = new Color(component2.color.r, component2.color.g, component2.color.b, 0.5f);
			RawImage component3 = btn.gameObject.transform.parent.GetChild(0).gameObject.GetComponent<RawImage>();
			component3.color = new Color(component3.color.r, component3.color.g, component3.color.b, 0.5f);
			btn.gameObject.transform.GetChild(0).gameObject.GetComponent<Image>().enabled = true;
			this.UpdateBribeHours();
			return;
		}
		component.enabled = false;
		Image component4 = btn.gameObject.transform.parent.gameObject.GetComponent<Image>();
		component4.color = new Color(component4.color.r, component4.color.g, component4.color.b, 1f);
		RawImage component5 = btn.gameObject.transform.parent.GetChild(0).gameObject.GetComponent<RawImage>();
		component5.color = new Color(component5.color.r, component5.color.g, component5.color.b, 1f);
		btn.gameObject.transform.GetChild(0).gameObject.GetComponent<Image>().enabled = false;
	}

	// Token: 0x06001014 RID: 4116 RVA: 0x00137314 File Offset: 0x00135514
	public void UpdateBribeHours()
	{
		for (int i = 0; i < this.usedBribeBadges.Count; i++)
		{
			if (this.usedBribeBadges[i].gameObject.transform.parent.GetChild(2).gameObject.GetComponent<Image>().enabled)
			{
				Image component = this.usedBribeBadges[i].gameObject.transform.GetChild(0).gameObject.GetComponent<Image>();
				int num = this.usedBribeBadges[i].id + 24 - (int)Mathf.Floor((float)Links.x.gameplay.GetCurrentGameTimeHours());
				component.fillAmount = (float)num / 24f;
				if (component.fillAmount <= 0f)
				{
					this.UpdateBribeBadgeState(this.usedBribeBadges[i], false);
					Records.x.UpdateBribeBadgeFromTimer(this.usedBribeBadges[i].info);
				}
			}
		}
	}

	// Token: 0x06001015 RID: 4117 RVA: 0x0013740C File Offset: 0x0013560C
	public void AddBribeBadge(string characterName, float t, bool transparent, bool fromSave)
	{
		Debug.Log("Bribe badge added " + characterName + " " + transparent.ToString());
		this.stunGrid.enabled = true;
		if (this.gridCorout != null)
		{
			base.StopCoroutine(this.gridCorout);
			this.gridCorout = null;
		}
		AnimateButton animateButton;
		if (this.openBribeBadges.Count == 0)
		{
			GameObject gameObject = Object.Instantiate<GameObject>(this.bribeBadge, new Vector3(0f, 0f, 0f), Quaternion.identity, this.stunBadgeParent);
			animateButton = gameObject.transform.GetChild(0).GetComponent<AnimateButton>();
			gameObject.transform.localPosition = Vector3.zero;
			gameObject.SetActive(true);
		}
		else
		{
			animateButton = this.openBribeBadges[0];
			this.openBribeBadges.RemoveAt(0);
			animateButton.gameObject.transform.parent.gameObject.SetActive(true);
		}
		Links.x.renderPortraits.AddCharacter(null, characterName, null, false, null, animateButton.gameObject.GetComponent<RawImage>(), null, null);
		animateButton.info = characterName;
		animateButton.state = transparent;
		Image component = animateButton.gameObject.transform.parent.gameObject.GetComponent<Image>();
		RawImage component2 = animateButton.gameObject.transform.parent.GetChild(0).gameObject.GetComponent<RawImage>();
		Image component3 = animateButton.gameObject.transform.parent.GetChild(2).gameObject.GetComponent<Image>();
		Image component4 = animateButton.gameObject.transform.GetChild(0).gameObject.GetComponent<Image>();
		if (!transparent)
		{
			component.color = new Color(component.color.r, component.color.g, component.color.b, 1f);
			component2.color = new Color(component2.color.r, component2.color.g, component2.color.b, 1f);
			component3.enabled = false;
			component4.enabled = false;
		}
		else
		{
			component.color = new Color(component.color.r, component.color.g, component.color.b, 0.5f);
			component2.color = new Color(component2.color.r, component2.color.g, component2.color.b, 0.5f);
			component3.enabled = true;
			component4.enabled = true;
			int num = (int)t + 24 - (int)Mathf.Floor((float)Links.x.gameplay.GetCurrentGameTimeHours());
			component4.fillAmount = (float)num / 24f;
		}
		animateButton.state = transparent;
		animateButton.id = (int)t;
		this.usedBribeBadges.Add(animateButton);
		if (!fromSave)
		{
			MasterAudio.PlaySoundAndForget("Feedback", 0.3f, new float?(1f), 0f, "TurnInCrime2", null);
			Links.x.itemPickupFX.gameObject.SetActive(true);
			Links.x.itemPickupFX.gameObject.GetComponent<HannahAnimator>().Play("Idle");
			Vector3 position = animateButton.gameObject.transform.position;
			Links.x.itemPickupFX.position = position;
		}
		this.stunBadgeParent.transform.parent.SetAsLastSibling();
		this.gridCorout = this.TurnOffStunGrid();
		base.StartCoroutine(this.gridCorout);
		this.BadgeController();
	}

	// Token: 0x06001016 RID: 4118 RVA: 0x00137790 File Offset: 0x00135990
	public void ClearBribeBadges()
	{
		for (int i = 0; i < this.usedBribeBadges.Count; i++)
		{
			this.openBribeBadges.Add(this.usedBribeBadges[i]);
			this.usedBribeBadges[i].gameObject.transform.parent.gameObject.SetActive(false);
			this.usedBribeBadges[i] = null;
		}
		this.usedBribeBadges.Clear();
		this.BadgeController();
	}

	// Token: 0x06001017 RID: 4119 RVA: 0x00137810 File Offset: 0x00135A10
	public void RemoveBribeBadge(string characterName)
	{
		Debug.Log("Remove bribe bagde for " + characterName);
		this.stunGrid.enabled = true;
		if (this.gridCorout != null)
		{
			base.StopCoroutine(this.gridCorout);
			this.gridCorout = null;
		}
		for (int i = 0; i < this.usedBribeBadges.Count; i++)
		{
			if (this.usedBribeBadges[i].info.Contains(characterName))
			{
				this.openBribeBadges.Add(this.usedBribeBadges[i]);
				Links.x.renderPortraits.RemoveCharacter(null, characterName, this.usedBribeBadges[i].gameObject.GetComponent<RawImage>().texture);
				if (!Records.x.dialogue)
				{
					MasterAudio.PlaySoundAndForget("Feedback", 0.2f, new float?(1f), 0f, "NoneTheWiser", null);
					Links.x.removeFX.gameObject.SetActive(true);
					Links.x.removeFX.gameObject.GetComponent<HannahAnimator>().Play("Idle");
					Vector3 position = this.usedBribeBadges[i].gameObject.transform.position;
					Links.x.removeFX.position = position;
				}
				this.usedBribeBadges[i].gameObject.transform.parent.gameObject.SetActive(false);
				this.usedBribeBadges[i] = null;
			}
		}
		this.usedBribeBadges.RemoveAll((AnimateButton item) => item == null);
		this.BadgeController();
	}

	// Token: 0x06001018 RID: 4120 RVA: 0x001379D0 File Offset: 0x00135BD0
	public void ArrangePortraits()
	{
		this.upCharacter = null;
		this.downCharacter = null;
		this.leftCharacter = null;
		this.rightCharacter = null;
		this.portraitOrderList.Clear();
		for (int i = 0; i < 4; i++)
		{
			float num = 100000f;
			int num2 = -1;
			for (int j = 0; j < this.portraitOrder.Count; j++)
			{
				Character character = this.portraitOrder[j];
				if (!this.portraitOrderList.Contains(character) && character.party && !character.dead)
				{
					Vector3 position = character.portrait.skillBag.trinketWindow.tr.position;
					Vector3 position2 = this.bottomLeft.transform.position;
					float num3 = Vector3.Distance(position, position2);
					if (num3 < num)
					{
						num = num3;
						num2 = j;
					}
				}
			}
			if (num2 > -1)
			{
				this.portraitOrderList.Add(this.portraitOrder[num2]);
			}
		}
		int num4 = this.portraitOrderList.IndexOf(Links.x.main);
		if (num4 > -1)
		{
			if (num4 + 1 < this.portraitOrderList.Count)
			{
				this.upCharacter = this.portraitOrderList[num4 + 1];
			}
			if (num4 - 1 < this.portraitOrderList.Count && num4 - 1 >= 0)
			{
				this.downCharacter = this.portraitOrderList[num4 - 1];
			}
		}
	}

	// Token: 0x06001019 RID: 4121 RVA: 0x00137B30 File Offset: 0x00135D30
	public void OpenMenuSwitcher(string lastMenuOpened)
	{
		if (!Links.x.creation)
		{
			if (!Records.x.mainMenuOpen)
			{
				this.menuSwitcher.SetActive(true);
			}
			this.UpdateMenuSwitcher(lastMenuOpened);
		}
		this.MenuText();
		this.menuSwitcherLower.SetActive(true);
		this.menuSwitcherLowerText.spriteAsset = Links.x.GetSpriteSheetAsset(Links.x.gameplay.currentSpriteSheetAsset);
	}

	// Token: 0x0600101A RID: 4122 RVA: 0x00137BA4 File Offset: 0x00135DA4
	public void MenuText()
	{
		this.str.Clear();
		this.str.Append("<voffset=.4em><size=40><sprite=");
		int num = Links.x.gameplay.GetControllerSprite("Joystick", Links.x.gameplay.controllerName);
		this.str.Append(num);
		this.str.Append("></size></voffset>Navigate       ");
		this.str.Append("<voffset=.4em><size=40><sprite=");
		if ((!Links.x.characterSheet.open || (!Links.x.inventory.repairing && !Links.x.inventory.mineralizing)) && Links.x.characterSheet.open && !Links.x.characterSheet.minstrel && !Links.x.characterSheet.blacksmith && !Links.x.inventory.enchantMenu.open)
		{
			num = Links.x.gameplay.GetControllerSprite("Press Joystick Left", Links.x.gameplay.controllerName);
			this.str.Append(num);
			this.str.Append("></size></voffset>Status       ");
			this.str.Append("<voffset=.4em><size=40><sprite=");
			num = Links.x.gameplay.GetControllerSprite("Right Joystick", Links.x.gameplay.controllerName);
			this.str.Append(num);
			this.str.Append("></size></voffset>Spin       ");
			this.str.Append("<voffset=.4em><size=40><sprite=");
		}
		num = Links.x.gameplay.GetControllerSprite("Cancel", Links.x.gameplay.controllerName);
		if (Links.x.characterSheet.open && Links.x.inventory.mineralizing)
		{
			this.str.Append(num);
			this.str.Append("></size></voffset>Stop Mineralizing");
		}
		else if (Links.x.characterSheet.open && Links.x.inventory.repairing)
		{
			this.str.Append(num);
			this.str.Append("></size></voffset>Stop Repairing");
		}
		else
		{
			this.str.Append(num);
			this.str.Append("></size></voffset>Exit");
		}
		this.menuSwitcherLowerText.text = this.str.ToString();
	}

	// Token: 0x0600101B RID: 4123 RVA: 0x00137E31 File Offset: 0x00136031
	public void CloseMenuSwitcher()
	{
		this.menuSwitcher.SetActive(false);
		this.menuSwitcherLower.SetActive(false);
	}

	// Token: 0x0600101C RID: 4124 RVA: 0x00137E4C File Offset: 0x0013604C
	public void UpdateMenuSwitcher(string lastMenuOpened)
	{
		if (lastMenuOpened == "Character Sheet")
		{
			this.csToggle.isOn = true;
		}
		if (lastMenuOpened == "Scene Map")
		{
			this.mapToggle.isOn = true;
		}
		if (lastMenuOpened == "Journal")
		{
			this.journalToggle.isOn = true;
		}
		if (lastMenuOpened == "Formation")
		{
			this.tacticsToggle.isOn = true;
		}
		if (lastMenuOpened == "Options")
		{
			this.optionsToggle.isOn = true;
		}
		if (lastMenuOpened == "Rest")
		{
			this.restToggle.isOn = true;
		}
		Links.x.gameplay.lastMenuOpened = lastMenuOpened;
	}

	// Token: 0x0600101D RID: 4125 RVA: 0x00137F00 File Offset: 0x00136100
	public void ChangeWindowSize()
	{
		for (int i = 0; i < this.windows.Count; i++)
		{
			this.windows[i].ChangeScreenSize();
		}
	}

	// Token: 0x0600101E RID: 4126 RVA: 0x00137F34 File Offset: 0x00136134
	public void LoadButtonImages()
	{
		for (int i = 0; i < this.animateButtonsLoadState.Count; i++)
		{
			this.animateButtonsLoadState[i].SetImageFromSave();
		}
	}

	// Token: 0x0600101F RID: 4127 RVA: 0x00137F68 File Offset: 0x00136168
	public void ToggleStayBack()
	{
		this.animateButtonsLoadState[0].canInteract = true;
		this.animateButtonsLoadState[0].OnPointerUp(null);
	}

	// Token: 0x06001020 RID: 4128 RVA: 0x00137F8E File Offset: 0x0013618E
	public void SetTrueStayBack()
	{
		this.animateButtonsLoadState[0].CircleOn();
	}

	// Token: 0x06001021 RID: 4129 RVA: 0x00137FA1 File Offset: 0x001361A1
	public void SetFalseStayBack()
	{
		this.animateButtonsLoadState[0].CircleOff();
	}

	// Token: 0x06001022 RID: 4130 RVA: 0x00137FB4 File Offset: 0x001361B4
	public void CircleBreak()
	{
		this.animateButtonsLoadState[0].CircleBreak();
	}

	// Token: 0x06001023 RID: 4131 RVA: 0x00137FC7 File Offset: 0x001361C7
	public void SetMorale(float x)
	{
		this.animateButtonsLoadState[0].CircleMorale(x);
	}

	// Token: 0x06001024 RID: 4132 RVA: 0x00137FDC File Offset: 0x001361DC
	public void ToggleBoroButtonSprite()
	{
		if (Links.x.gaia.boroControls)
		{
			if (Links.x.gaia.boroControls.BoroNearby())
			{
				this.animateButtonsLoadState[3].image.sprite = this.animateButtonsLoadState[3].sprite2;
				return;
			}
			this.animateButtonsLoadState[3].image.sprite = this.animateButtonsLoadState[3].sprite1;
		}
	}

	// Token: 0x06001025 RID: 4133 RVA: 0x00138064 File Offset: 0x00136264
	public void ToggleModalWindowsFromBtn()
	{
		if (this.allModalWindowsOpen)
		{
			this.SetModalWindowState(false, false);
			return;
		}
		this.SetModalWindowState(true, false);
	}

	// Token: 0x06001026 RID: 4134 RVA: 0x0013807F File Offset: 0x0013627F
	public void ToggleLethalityJoystick()
	{
		this.animateButtonsLoadState[2].canInteract = true;
		this.animateButtonsLoadState[2].clickedDown = true;
		this.animateButtonsLoadState[2].OnPointerUp(null);
	}

	// Token: 0x06001027 RID: 4135 RVA: 0x001380B8 File Offset: 0x001362B8
	public void ToggleLethality(bool fromSave)
	{
		if (Records.x.kill)
		{
			Records.x.kill = false;
			if (!fromSave)
			{
				Links.x.gameFeed.AddFeed("Guards will stun enemies");
			}
		}
		else
		{
			Records.x.kill = true;
			if (!fromSave)
			{
				Links.x.gameFeed.AddFeed("Guards will kill enemies");
			}
		}
		if (Records.x.InCombat(false))
		{
			Links.x.combat.SwitchLethality();
		}
	}

	// Token: 0x06001028 RID: 4136 RVA: 0x00138134 File Offset: 0x00136334
	public void SetModalWindowState(bool state, bool fromMenus)
	{
		if (this.portraits[0].character)
		{
			this.portraits[0].skillBag.ToggleWindows(state, fromMenus);
		}
		if (this.portraits[1].character)
		{
			this.portraits[1].skillBag.ToggleWindows(state, fromMenus);
		}
		if (this.portraits[2].character)
		{
			this.portraits[2].skillBag.ToggleWindows(state, fromMenus);
		}
		if (this.portraits[3].character)
		{
			this.portraits[3].skillBag.ToggleWindows(state, fromMenus);
		}
		if (state && fromMenus && !this.allModalWindowsOpen)
		{
			state = false;
		}
		if (!fromMenus)
		{
			this.allModalWindowsOpen = state;
		}
		for (int i = 0; i < this.gameFeedWindowText.Count; i++)
		{
			this.gameFeedWindowText[i].enabled = state;
		}
		for (int j = 0; j < this.gameFeedWindowImages.Count; j++)
		{
			this.gameFeedWindowImages[j].enabled = state;
		}
		for (int k = 0; k < this.mapWindowText.Count; k++)
		{
			this.mapWindowText[k].enabled = state;
		}
		for (int l = 0; l < this.mapWindowImages.Count; l++)
		{
			this.mapWindowImages[l].enabled = state;
		}
		for (int m = 0; m < this.mapWindowRawImages.Count; m++)
		{
			this.mapWindowRawImages[m].enabled = state;
		}
	}

	// Token: 0x06001029 RID: 4137 RVA: 0x001382EC File Offset: 0x001364EC
	public void ToggleWindowVisual(bool state)
	{
		for (int i = 0; i < this.windows.Count; i++)
		{
			if (this.windows[i].linkedPortrait)
			{
				this.windows[i].ToggleWindowVisual(state);
			}
		}
	}

	// Token: 0x0600102A RID: 4138 RVA: 0x0013833C File Offset: 0x0013653C
	public void ToggleWindowInteractables(bool state)
	{
		for (int i = 0; i < this.windows.Count; i++)
		{
			this.windows[i].ToggleWindowInteractables(state);
		}
		if (!state && Records.x.movingWindows)
		{
			this.ToggleCanvasGroup(false);
			return;
		}
		this.ToggleCanvasGroup(true);
	}

	// Token: 0x0600102B RID: 4139 RVA: 0x00138390 File Offset: 0x00136590
	public bool AnyWindowDraggingResizing()
	{
		for (int i = 0; i < this.windows.Count; i++)
		{
			if (this.windows[i].dragging)
			{
				return true;
			}
			if (this.windows[i].resizing)
			{
				return true;
			}
		}
		return false;
	}

	// Token: 0x0600102C RID: 4140 RVA: 0x001383DE File Offset: 0x001365DE
	public void UpdateTimeOfDay()
	{
	}

	// Token: 0x0600102D RID: 4141 RVA: 0x001383E0 File Offset: 0x001365E0
	public GameObject GetDockButton(int i)
	{
		return this.dockButtons[i];
	}

	// Token: 0x0600102E RID: 4142 RVA: 0x001383EE File Offset: 0x001365EE
	public AnimateButton GetDockButtonControl(int i)
	{
		return this.dockButtonControllers[i];
	}

	// Token: 0x0600102F RID: 4143 RVA: 0x001383FC File Offset: 0x001365FC
	public void CloseDescWindow()
	{
		this.descriptionAnimator.Play("DescriptionWindowClose");
		this.descriptionWindowOpen = false;
	}

	// Token: 0x06001030 RID: 4144 RVA: 0x00138418 File Offset: 0x00136618
	public void SetWindowsAtStartPosition()
	{
		foreach (Windows windows in this.windows)
		{
			windows.SetAtStartPosition();
		}
	}

	// Token: 0x06001031 RID: 4145 RVA: 0x00138468 File Offset: 0x00136668
	public void EndOfCombat()
	{
		this.updateRallyTime = Links.x.gameplay.seconds;
	}

	// Token: 0x06001032 RID: 4146 RVA: 0x00138480 File Offset: 0x00136680
	public void UpdateRally(float amt)
	{
		float num = Links.x.fellowship.rally + Links.x.fellowship.rallyBoost;
		if (num + amt > this.rallyInterval * 3f)
		{
			amt = this.rallyInterval * 3f - num;
		}
		Links.x.fellowship.rally += amt;
		if (Links.x.fellowship.rally + Links.x.fellowship.rallyBoost <= 0f && !Links.x.combat)
		{
			Links.x.fellowship.rallyAttacks = 0f;
		}
		this.SetRallyBars();
	}

	// Token: 0x06001033 RID: 4147 RVA: 0x00138536 File Offset: 0x00136736
	public void RemoveRallyBar(float amt)
	{
		Links.x.fellowship.rally -= amt * this.rallyInterval;
		this.SetRallyBars();
		this.UpdateRallyAttacks();
	}

	// Token: 0x06001034 RID: 4148 RVA: 0x00138564 File Offset: 0x00136764
	public void FillRallyBar()
	{
		float rally = Links.x.fellowship.rally;
		if (rally < this.rallyInterval)
		{
			Links.x.fellowship.rally = this.rallyInterval;
		}
		else if (rally >= this.rallyInterval && rally < this.rallyInterval * 2f)
		{
			Links.x.fellowship.rally = this.rallyInterval * 2f;
		}
		else if (rally >= this.rallyInterval * 2f)
		{
			Links.x.fellowship.rally = this.rallyInterval * 3f;
		}
		this.SetRallyBars();
	}

	// Token: 0x06001035 RID: 4149 RVA: 0x00138606 File Offset: 0x00136806
	public void ClearRally()
	{
		Links.x.fellowship.rally = 0f;
		Links.x.fellowship.rallyAttacks = 0f;
		this.SetRallyBars();
	}

	// Token: 0x06001036 RID: 4150 RVA: 0x00138638 File Offset: 0x00136838
	public void UpdateRallyAttacks()
	{
		Links.x.fellowship.rallyAttacks += 1f;
		if (Links.x.fellowship.rallyAttacks > 4f)
		{
			Links.x.fellowship.rallyAttacks = 4f;
		}
		this.SetRallyBars();
	}

	// Token: 0x06001037 RID: 4151 RVA: 0x00138690 File Offset: 0x00136890
	public void UsedRallyAttackSpecial()
	{
		Links.x.fellowship.rallyAttacks = 0f;
		this.SetRallyBars();
	}

	// Token: 0x06001038 RID: 4152 RVA: 0x001386AC File Offset: 0x001368AC
	public void SetRallyBars()
	{
		float num = Links.x.fellowship.rally + Links.x.fellowship.rallyBoost;
		if (num <= this.rallyInterval)
		{
			float num2 = num / this.rallyInterval;
			if (num2 >= 1f)
			{
				this.rallyTri1.sprite = this.rallySpriteOn;
			}
			else
			{
				this.rallyTri1.sprite = this.rallySpriteOff;
			}
			this.rallyTri2.sprite = this.rallySpriteOff;
			this.rallyTri3.sprite = this.rallySpriteOff;
			float num3 = Mathf.Lerp(45f, -74f, num2);
			this.rallySpin.localRotation = Quaternion.Euler(0f, 0f, num3);
		}
		else if (num > this.rallyInterval && num <= this.rallyInterval * 2f)
		{
			if (Records.x.needsSynergyTooltip && !Records.x.needsCircleTooltip)
			{
				Links.x.hudControl.ShowTutorialTooltip("Synergy");
			}
			float num4 = (num - this.rallyInterval) / this.rallyInterval;
			if (num4 >= 1f)
			{
				this.rallyTri2.sprite = this.rallySpriteOn;
			}
			else
			{
				this.rallyTri2.sprite = this.rallySpriteOff;
			}
			this.rallyTri1.sprite = this.rallySpriteOn;
			this.rallyTri3.sprite = this.rallySpriteOff;
			float num5 = Mathf.Lerp(-75f, -194f, num4);
			this.rallySpin.localRotation = Quaternion.Euler(0f, 0f, num5);
		}
		else if (num > this.rallyInterval * 2f)
		{
			float num6 = (num - this.rallyInterval * 2f) / this.rallyInterval;
			if (num6 >= 1f)
			{
				this.rallyTri3.sprite = this.rallySpriteOn;
			}
			else
			{
				this.rallyTri3.sprite = this.rallySpriteOff;
			}
			this.rallyTri1.sprite = this.rallySpriteOn;
			this.rallyTri2.sprite = this.rallySpriteOn;
			float num7 = Mathf.Lerp(-195f, -314f, num6);
			this.rallySpin.localRotation = Quaternion.Euler(0f, 0f, num7);
		}
		float rallyAttacks = Links.x.fellowship.rallyAttacks;
		if (rallyAttacks < 1f)
		{
			if (this.rallyStage1.activeSelf)
			{
				this.rallyStage1.SetActive(false);
			}
			if (this.rallyStage2.activeSelf)
			{
				this.rallyStage2.SetActive(false);
			}
			if (this.rallyStage3.activeSelf)
			{
				this.rallyStage3.SetActive(false);
			}
			if (this.rallyStage4.activeSelf)
			{
				this.rallyStage4.SetActive(false);
			}
		}
		if (rallyAttacks >= 1f && rallyAttacks < 2f)
		{
			if (!this.rallyStage1.activeSelf)
			{
				this.rallyStage1.SetActive(true);
			}
			if (this.rallyStage2.activeSelf)
			{
				this.rallyStage2.SetActive(false);
			}
			if (this.rallyStage3.activeSelf)
			{
				this.rallyStage3.SetActive(false);
			}
			if (this.rallyStage4.activeSelf)
			{
				this.rallyStage4.SetActive(false);
			}
		}
		if (rallyAttacks >= 2f && rallyAttacks < 3f)
		{
			if (!this.rallyStage1.activeSelf)
			{
				this.rallyStage1.SetActive(true);
			}
			if (!this.rallyStage2.activeSelf)
			{
				this.rallyStage2.SetActive(true);
			}
			if (this.rallyStage3.activeSelf)
			{
				this.rallyStage3.SetActive(false);
			}
			if (this.rallyStage4.activeSelf)
			{
				this.rallyStage4.SetActive(false);
			}
		}
		if (rallyAttacks >= 3f && rallyAttacks < 4f)
		{
			if (!this.rallyStage1.activeSelf)
			{
				this.rallyStage1.SetActive(true);
			}
			if (!this.rallyStage2.activeSelf)
			{
				this.rallyStage2.SetActive(true);
			}
			if (!this.rallyStage3.activeSelf)
			{
				this.rallyStage3.SetActive(true);
			}
			if (this.rallyStage4.activeSelf)
			{
				this.rallyStage4.SetActive(false);
			}
		}
		if (rallyAttacks >= 4f)
		{
			if (!this.rallyStage1.activeSelf)
			{
				this.rallyStage1.SetActive(true);
			}
			if (!this.rallyStage2.activeSelf)
			{
				this.rallyStage2.SetActive(true);
			}
			if (!this.rallyStage3.activeSelf)
			{
				this.rallyStage3.SetActive(true);
			}
			if (!this.rallyStage4.activeSelf)
			{
				this.rallyStage4.SetActive(true);
			}
		}
	}

	// Token: 0x06001039 RID: 4153 RVA: 0x00138B36 File Offset: 0x00136D36
	public void ToggleRallyBuff()
	{
	}

	// Token: 0x0600103A RID: 4154 RVA: 0x00138B38 File Offset: 0x00136D38
	public void ToggleAttackTimer(bool state)
	{
		bool @bool = this.attackTimerAnimator.GetBool("Show");
		if (state)
		{
			this.attackTimerAnimator.SetBool("Show", true);
			if (!@bool)
			{
				this.attackTimerAnimator.Play("AttackTimerOn");
				return;
			}
		}
		else
		{
			this.attackTimerAnimator.SetBool("Show", false);
			if (@bool)
			{
				this.attackTimerAnimator.Play("AttackTimerOff");
			}
			if (this.inAction.activeSelf)
			{
				this.inAction.SetActive(false);
			}
			if (this.addTime.activeSelf)
			{
				this.addTime.SetActive(false);
			}
			if (this.notReady.activeSelf)
			{
				this.notReady.SetActive(false);
			}
			this.actionUp.SetActive(false);
			this.actionDown.SetActive(false);
		}
	}

	// Token: 0x0600103B RID: 4155 RVA: 0x00138C08 File Offset: 0x00136E08
	public void ScaleRallyBar(bool large)
	{
	}

	// Token: 0x0600103C RID: 4156 RVA: 0x00138C0C File Offset: 0x00136E0C
	public void RallyBuffToggle(bool state)
	{
		if (Links.x.fellowship.rallySpeed < 0.05f)
		{
			this.rallyBuff.color = new Color(0.58431375f, 0.58431375f, 0.58431375f, 1f);
			return;
		}
		this.rallyBuff.color = Color.white;
	}

	// Token: 0x0600103D RID: 4157 RVA: 0x00138C64 File Offset: 0x00136E64
	public void AttackTimerNotReady()
	{
		if (this.at2.fillAmount < 0.95f)
		{
			this.attackTimerAnimator.Play("AttackTimerNotReady");
		}
	}

	// Token: 0x0600103E RID: 4158 RVA: 0x00138C88 File Offset: 0x00136E88
	public void AttackTimerDecreaseTime()
	{
		float fillAmount = this.at2.fillAmount;
	}

	// Token: 0x0600103F RID: 4159 RVA: 0x00138C9C File Offset: 0x00136E9C
	public void UpdateAttackTimeMods()
	{
		if (Links.x.main.stats.actionTimeMod < 0f)
		{
			if (!this.actionUp.activeSelf)
			{
				this.actionUp.SetActive(true);
			}
			if (this.actionDown.activeSelf)
			{
				this.actionDown.SetActive(false);
				return;
			}
		}
		else if (Links.x.main.stats.actionTimeMod > 0f)
		{
			if (this.actionUp.activeSelf)
			{
				this.actionUp.SetActive(false);
			}
			if (!this.actionDown.activeSelf)
			{
				this.actionDown.SetActive(true);
				return;
			}
		}
		else
		{
			if (this.actionUp.activeSelf)
			{
				this.actionUp.SetActive(false);
			}
			if (this.actionDown.activeSelf)
			{
				this.actionDown.SetActive(false);
			}
		}
	}

	// Token: 0x06001040 RID: 4160 RVA: 0x00138D7C File Offset: 0x00136F7C
	public void UpdateAttackTime(float t, float total, float addedTime)
	{
		if (Links.x.hasMain)
		{
			if (Links.x.main.dead)
			{
				t = 0f;
				if (this.attackTimerAnimator.gameObject.transform.localScale.x != 0f)
				{
					this.attackTimerAnimator.gameObject.transform.localScale = Vector3.zero;
				}
			}
			else
			{
				if (this.attackTimerAnimator.gameObject.transform.localScale.x < 1f)
				{
					this.attackTimerAnimator.gameObject.transform.localScale = Vector3.one;
				}
				if (this.attackTimerAnimator.gameObject.transform.localScale.x > 1f && Time.timeScale >= 1f && !Records.x.pocketPause)
				{
					this.attackTimerAnimator.gameObject.transform.localScale = Vector3.one;
				}
			}
			this.UpdateAttackTimeMods();
		}
		this.at2.fillAmount = t / total;
		if (t >= 1f)
		{
			this.at2.color = this.attackTimerColorReady;
			if (!this.attackTimerAnimator.GetBool("Complete") && Links.x.gaia.sceneLoaded && Records.x.InCombat(false) && !Records.x.pocketPause)
			{
				MasterAudio.PlaySoundAndForget("Attack Ready", 1f, new float?(1f), 0f, "", null);
			}
			this.attackTimerAnimator.SetBool("Complete", true);
			if (this.notReady.activeSelf)
			{
				this.notReady.SetActive(false);
			}
		}
		else
		{
			this.at2.color = Color.Lerp(this.attackTimerColorWait, this.attackTimerColorReady, t * 0.7f);
			this.attackTimerAnimator.SetBool("Complete", false);
		}
		if (addedTime > 0f)
		{
			if (!this.addTime.activeSelf)
			{
				this.addTime.SetActive(true);
			}
			string text = addedTime.ToString();
			if (this.addTimeText.text != text)
			{
				this.addTimeText.text = text;
			}
		}
		else if (this.addTime.activeSelf)
		{
			this.addTime.SetActive(false);
		}
		if (Records.x.pocketPause)
		{
			if (Links.x.main.timelineIcon)
			{
				if (!Links.x.main.CanAttack() && !Links.x.main.timelineIcon.overridePause && !Links.x.combat.inPocketAttack)
				{
					if (!this.notReady.activeSelf)
					{
						this.notReady.SetActive(true);
					}
					if (Links.x.main.inAction)
					{
						if (!this.inAction.activeSelf)
						{
							this.inAction.SetActive(true);
						}
						this.inActionText.text = "Attacking";
						return;
					}
					if (Links.x.main.isHit)
					{
						this.inActionText.text = "Hit";
						if (!this.inAction.activeSelf)
						{
							this.inAction.SetActive(true);
							return;
						}
					}
					else if (Links.x.main.downed)
					{
						this.inActionText.text = "Stunned";
						if (!this.inAction.activeSelf)
						{
							this.inAction.SetActive(true);
							return;
						}
					}
					else if (Links.x.main.stats.pinning)
					{
						this.inActionText.text = "Pinning";
						if (!this.inAction.activeSelf)
						{
							this.inAction.SetActive(true);
							return;
						}
					}
					else if (Links.x.main.stats.pinned)
					{
						this.inActionText.text = "Pinned";
						if (!this.inAction.activeSelf)
						{
							this.inAction.SetActive(true);
							return;
						}
					}
					else if (Links.x.main.inQueuedAbility)
					{
						this.inActionText.text = "Playing Song";
						if (!this.inAction.activeSelf)
						{
							this.inAction.SetActive(true);
							return;
						}
					}
					else
					{
						if (Links.x.main.stats.Confuse() > 0)
						{
							if (!this.inAction.activeSelf)
							{
								this.inAction.SetActive(true);
							}
							this.inActionText.text = "Confused";
							return;
						}
						if (this.inAction.activeSelf)
						{
							this.inAction.SetActive(false);
						}
						this.inActionText.text = "";
						return;
					}
				}
				else
				{
					if (this.inAction.activeSelf)
					{
						this.inAction.SetActive(false);
					}
					if (this.notReady.activeSelf)
					{
						this.notReady.SetActive(false);
						return;
					}
				}
			}
			else
			{
				if (this.inAction.activeSelf)
				{
					this.inAction.SetActive(false);
				}
				if (this.notReady.activeSelf)
				{
					this.notReady.SetActive(false);
					return;
				}
			}
		}
		else
		{
			if (this.inAction.activeSelf)
			{
				this.inAction.SetActive(false);
			}
			if (this.notReady.activeSelf)
			{
				this.notReady.SetActive(false);
			}
		}
	}

	// Token: 0x06001041 RID: 4161 RVA: 0x001392E0 File Offset: 0x001374E0
	public void BoroCardPosition()
	{
		Vector3 position = this.hoverBoro.body.GetNeck().position;
		position.y += 1f;
		Vector3 vector = Links.x.worldCamera.WorldToScreenPoint(position);
		vector.z = 0f;
		vector.x = vector.x * (1920f / (float)Screen.width) - 960f;
		vector.y = vector.y * (Links.x.canvasRT.sizeDelta.y / (float)Screen.height) - Links.x.canvasRT.sizeDelta.y / 2f;
		this.boroHoverCardRT.localPosition = vector;
	}

	// Token: 0x06001042 RID: 4162 RVA: 0x001393A0 File Offset: 0x001375A0
	public void OpenBoroCard()
	{
		this.boroCard.gameObject.SetActive(true);
		this.boroCardName.text = Records.x.boroName;
		Vector3 boroBonus = Records.x.boroBonus;
		Vector4 boroShrines = Records.x.boroShrines;
		this.boroSpeed.fillAmount = boroBonus.x / Records.x.BoroMaxSpeed();
		this.boroStrength.fillAmount = boroBonus.y / Records.x.BoroMaxStrength();
		this.boroSpirit.fillAmount = boroBonus.z / Records.x.BoroMaxSpirit();
		if (boroShrines.x > 0f)
		{
			this.boroShrine1.material = this.boroShrineOn;
		}
		else
		{
			this.boroShrine1.material = this.boroShrineOff;
		}
		if (boroShrines.y > 0f)
		{
			this.boroShrine2.material = this.boroShrineOn;
		}
		else
		{
			this.boroShrine2.material = this.boroShrineOff;
		}
		if (boroShrines.z > 0f)
		{
			this.boroShrine3.material = this.boroShrineOn;
			return;
		}
		this.boroShrine3.material = this.boroShrineOff;
	}

	// Token: 0x06001043 RID: 4163 RVA: 0x001394CD File Offset: 0x001376CD
	public void CloseBoroCard()
	{
		this.boroCard.gameObject.SetActive(false);
	}

	// Token: 0x06001044 RID: 4164 RVA: 0x001394E0 File Offset: 0x001376E0
	public void EditBoroName()
	{
		Records.x.SetTypingState(true);
		this.boroCardEditName.SetActive(true);
	}

	// Token: 0x06001045 RID: 4165 RVA: 0x001394FC File Offset: 0x001376FC
	public void CloseEditBoroName()
	{
		Records.x.SetTypingState(false);
		if (this.boroInput.text != "")
		{
			Records.x.boroName = this.boroInput.text;
			Records.x.UpdateBoroInSavedList(Records.x.boroID, Records.x.boroBonus, Records.x.boroShrines, Records.x.boroName);
		}
		this.boroCardEditName.SetActive(false);
		this.boroCardName.text = Records.x.boroName;
	}

	// Token: 0x06001046 RID: 4166 RVA: 0x00139594 File Offset: 0x00137794
	public void OpenBoroHoverCard(Character c, Character herder)
	{
		this.hoverBoro = c;
		string xmlName = this.hoverBoro.stats.xmlName;
		Vector3 vector;
		Vector4 vector2;
		string text;
		int num;
		Records.x.BoroStats(xmlName, out vector, out vector2, out text, out num, true);
		Vector3 vector3;
		Vector4 vector4;
		string text2;
		int num2;
		Records.x.BoroStats(Records.x.boroID, out vector3, out vector4, out text2, out num2, true);
		if (vector != Vector3.zero)
		{
			this.boroHoverCard.SetActive(true);
			this.boroHoverCardAnimator.Play("BoroHoverOn");
			this.boroHoverCardName.text = text;
			this.boroHoverCardCompareName.text = Records.x.boroName;
			this.boroHoverCardSpeed.fillAmount = vector.x / Records.x.BoroMaxSpeed();
			this.boroHoverCardStrength.fillAmount = vector.y / Records.x.BoroMaxStrength();
			this.boroHoverCardSpirit.fillAmount = vector.z / Records.x.BoroMaxSpirit();
			if (vector2.x > 0f)
			{
				this.boroHoverCardShrine1.material = this.boroShrineOn;
			}
			else
			{
				this.boroHoverCardShrine1.material = this.boroShrineOff;
			}
			if (vector2.y > 0f)
			{
				this.boroHoverCardShrine2.material = this.boroShrineOn;
			}
			else
			{
				this.boroHoverCardShrine2.material = this.boroShrineOff;
			}
			if (vector2.z > 0f)
			{
				this.boroHoverCardShrine3.material = this.boroShrineOn;
			}
			else
			{
				this.boroHoverCardShrine3.material = this.boroShrineOff;
			}
			this.boroHoverCardSpeedCompare.fillAmount = Records.x.boroBonus.x / Records.x.BoroMaxSpeed();
			this.boroHoverCardStrengthCompare.fillAmount = Records.x.boroBonus.y / Records.x.BoroMaxStrength();
			this.boroHoverCardSpiritCompare.fillAmount = Records.x.boroBonus.z / Records.x.BoroMaxSpirit();
			if (Records.x.boroShrines.x > 0f)
			{
				this.boroHoverCardShrine1Compare.material = this.boroShrineOn;
			}
			else
			{
				this.boroHoverCardShrine1Compare.material = this.boroShrineOff;
			}
			if (Records.x.boroShrines.y > 0f)
			{
				this.boroHoverCardShrine2Compare.material = this.boroShrineOn;
			}
			else
			{
				this.boroHoverCardShrine2Compare.material = this.boroShrineOff;
			}
			if (Records.x.boroShrines.z > 0f)
			{
				this.boroHoverCardShrine3Compare.material = this.boroShrineOn;
			}
			else
			{
				this.boroHoverCardShrine3Compare.material = this.boroShrineOff;
			}
			if (herder)
			{
				this.boroCost.SetActive(true);
				int num3 = num - num2;
				if (num3 < 0)
				{
					num3 = 0;
				}
				this.boroHoverCardCost.text = num3.ToString();
				this.boroHoverCardCost.enabled = true;
			}
			else
			{
				this.boroCost.SetActive(false);
				this.boroHoverCardCost.enabled = false;
			}
			this.boroCardOn = true;
			this.BoroCardPosition();
		}
	}

	// Token: 0x06001047 RID: 4167 RVA: 0x001398A3 File Offset: 0x00137AA3
	public void CloseBoroHoverCard()
	{
		this.boroHoverCardAnimator.Play("BoroHoverOff");
	}

	// Token: 0x06001048 RID: 4168 RVA: 0x001398B5 File Offset: 0x00137AB5
	public void BoroHoverCardOff()
	{
		this.boroHoverCard.SetActive(false);
		this.boroCardOn = false;
	}

	// Token: 0x06001049 RID: 4169 RVA: 0x001398CA File Offset: 0x00137ACA
	public void CloseTooltip()
	{
		this.itemInfo.EndMenu();
		this.tooltipItem = null;
	}

	// Token: 0x0600104A RID: 4170 RVA: 0x001398DE File Offset: 0x00137ADE
	public void OpenTooltip(global::Item tooltip, bool forSale)
	{
		this.tooltipItem = tooltip;
		this.itemInfo.gameObject.SetActive(true);
		this.itemInfo.showEmeralds = forSale;
		this.itemInfo.StartMenu(tooltip, null);
	}

	// Token: 0x0600104B RID: 4171 RVA: 0x00139911 File Offset: 0x00137B11
	public void BoroTooltipOn(string t)
	{
		this.boroTooltip.SetActive(true);
		this.boroTooltipText.text = t;
	}

	// Token: 0x0600104C RID: 4172 RVA: 0x0013992B File Offset: 0x00137B2B
	public void BoroTooltipOff()
	{
		this.boroTooltip.SetActive(false);
	}

	// Token: 0x0600104D RID: 4173 RVA: 0x00139939 File Offset: 0x00137B39
	public void UpdateKeys()
	{
	}

	// Token: 0x0600104E RID: 4174 RVA: 0x0013993B File Offset: 0x00137B3B
	public void SetPartyWait()
	{
	}

	// Token: 0x0600104F RID: 4175 RVA: 0x00139940 File Offset: 0x00137B40
	public void SetTimeOfDay(float t)
	{
		for (int i = 0; i < this.clockHours.Count; i++)
		{
			if (this.clockHours[i] == t)
			{
				this.clockImage.sprite = this.clockImages[i];
				return;
			}
		}
	}

	// Token: 0x06001050 RID: 4176 RVA: 0x0013998C File Offset: 0x00137B8C
	public Portrait CreatePortrait(Character character)
	{
		int num = 0;
		for (int i = 0; i < this.portraits.Count; i++)
		{
			if (!this.portraits[i].character)
			{
				num = i;
				break;
			}
		}
		Portrait portrait = this.portraits[num];
		portrait.gameObject.SetActive(true);
		portrait.SetCharacter(character);
		return portrait;
	}

	// Token: 0x06001051 RID: 4177 RVA: 0x001399EC File Offset: 0x00137BEC
	public void SetPortraitPositions()
	{
		int num = 0;
		for (int i = 0; i < this.portraitOrder.Count; i++)
		{
			if (this.portraitOrder[i] && this.portraitOrder[i].portrait)
			{
				num++;
			}
		}
		this.sheepPedestal.transform.SetAsLastSibling();
	}

	// Token: 0x06001052 RID: 4178 RVA: 0x00139A50 File Offset: 0x00137C50
	public void SetPortraitBacks()
	{
	}

	// Token: 0x06001053 RID: 4179 RVA: 0x00139A52 File Offset: 0x00137C52
	public void RemovePortrait(Portrait portrait)
	{
		portrait.Remove();
	}

	// Token: 0x06001054 RID: 4180 RVA: 0x00139A5C File Offset: 0x00137C5C
	public void SwitchScene()
	{
		if (Records.x.inOverworldMap)
		{
			for (int i = 0; i < this.overworldMapImages.Count; i++)
			{
				this.overworldMapImages[i].enabled = true;
			}
			this.overworldMapMask.enabled = true;
		}
		else
		{
			for (int j = 0; j < this.overworldMapImages.Count; j++)
			{
				this.overworldMapImages[j].enabled = false;
			}
			this.overworldMapMask.enabled = false;
		}
		if (this.hidingHud)
		{
			this.HideShowHud(true);
		}
	}

	// Token: 0x06001055 RID: 4181 RVA: 0x00139AEE File Offset: 0x00137CEE
	public void StartCombat()
	{
	}

	// Token: 0x06001056 RID: 4182 RVA: 0x00139AF0 File Offset: 0x00137CF0
	public void EndCombat()
	{
	}

	// Token: 0x06001057 RID: 4183 RVA: 0x00139AF2 File Offset: 0x00137CF2
	public void ChangeUse(string newUse)
	{
	}

	// Token: 0x06001058 RID: 4184 RVA: 0x00139AF4 File Offset: 0x00137CF4
	public void ToggleMenus()
	{
		if (Records.x.inMenus)
		{
			this.miscFolderQuipsTransform.localScale = Vector3.zero;
			return;
		}
		this.miscFolderQuipsTransform.localScale = Vector3.one;
	}

	// Token: 0x06001059 RID: 4185 RVA: 0x00139B24 File Offset: 0x00137D24
	public void HideShowHud(bool state)
	{
		if (!this.hudState)
		{
			return;
		}
		this.hidingHud = state;
		if (this.hidingHud)
		{
			this.windowsCanvasGroup.alpha = 0.25f;
			this.feedCanvasGroup.alpha = 0.25f;
			this.canvasGroup.alpha = 0.25f;
			this.cardCanvasGroup.alpha = 0.25f;
			this.windowsCanvasGroup.interactable = false;
			this.windowsCanvasGroup.blocksRaycasts = false;
			this.feedCanvasGroup.interactable = false;
			this.feedCanvasGroup.blocksRaycasts = false;
			this.canvasGroup.interactable = false;
			this.canvasGroup.blocksRaycasts = false;
			this.cardCanvasGroup.blocksRaycasts = false;
			this.cardCanvasGroup.interactable = false;
			this.windowsAnimator.Play("WindowsHalfOut");
			this.feedAnimator.Play("WindowsHalfOut");
			this.gameCardAnimator.Play("WindowsHalfOut");
			this.hudAnimator.Play("HudHalfOut");
			return;
		}
		this.windowsCanvasGroup.alpha = 1f;
		this.feedCanvasGroup.alpha = 1f;
		this.canvasGroup.alpha = 1f;
		this.cardCanvasGroup.alpha = 1f;
		this.windowsCanvasGroup.interactable = true;
		this.windowsCanvasGroup.blocksRaycasts = true;
		this.feedCanvasGroup.interactable = true;
		this.feedCanvasGroup.blocksRaycasts = true;
		this.canvasGroup.interactable = true;
		this.canvasGroup.blocksRaycasts = true;
		this.cardCanvasGroup.blocksRaycasts = true;
		this.cardCanvasGroup.interactable = true;
		this.windowsAnimator.Play("WindowsHalfIn");
		this.feedAnimator.Play("WindowsHalfIn");
		this.gameCardAnimator.Play("WindowsHalfIn");
		this.hudAnimator.Play("HudHalfIn");
	}

	// Token: 0x0600105A RID: 4186 RVA: 0x00139D10 File Offset: 0x00137F10
	public void ChangeHudVisibility(bool state, bool all)
	{
		if (Links.x.creation)
		{
			return;
		}
		if (Records.x.miniGame && state)
		{
			return;
		}
		if (state && (Links.x.spellcrafting.open || (Links.x.characterSheet.open && Links.x.gaia.sceneLoaded) || Records.x.mainMenuOpen || Links.x.gaia.changingScene || Links.x.forfeits.on || Records.x.dialogue))
		{
			return;
		}
		if (QuestLog.GetQuestState("CharacterCreation") == QuestState.Active && Records.x.removeControls && Links.x.gaia.sceneLoaded)
		{
			return;
		}
		this.hudAnimator.enabled = true;
		if (Records.x.inOverworldMap || Records.x.mainMenuOpen)
		{
			state = false;
		}
		this.hudAnimator.enabled = true;
		if (!state)
		{
			this.hidingHud = false;
			this.hudAnimator.Play("HudOut");
			this.canvasGroup.interactable = false;
			this.canvasGroup.blocksRaycasts = false;
			if (!Links.x.pocketWheel.rallyWheelOpen)
			{
				this.gameCardAnimator.Play("WindowsOut");
				this.cardCanvasGroup.interactable = false;
			}
		}
		else
		{
			this.hudAnimator.Play("HudIn");
			this.canvasGroup.interactable = true;
			this.canvasGroup.blocksRaycasts = true;
			this.gameCardAnimator.Play("WindowsIn");
			this.cardCanvasGroup.interactable = true;
		}
		this.hudState = state;
		if (!state || (state && !Records.x.movingWindows))
		{
			if (state && this.windowsAnimator.GetCurrentAnimatorStateInfo(0).IsName("WindowsOut"))
			{
				this.windowsAnimator.Play("WindowsIn");
				this.feedAnimator.Play("WindowsIn");
			}
			if (!state && this.windowsAnimator.GetCurrentAnimatorStateInfo(0).IsName("WindowsIn"))
			{
				this.windowsAnimator.Play("WindowsOut");
				this.feedAnimator.Play("WindowsOut");
			}
			this.windowsCanvasGroup.interactable = state;
			this.windowsCanvasGroup.blocksRaycasts = state;
			this.feedCanvas.enabled = state;
			this.feedCanvasGroup.interactable = state;
			this.feedCanvasGroup.blocksRaycasts = state;
		}
	}

	// Token: 0x0600105B RID: 4187 RVA: 0x00139F89 File Offset: 0x00138189
	public void ToggleCanvasGroup(bool interactable)
	{
		this.canvasGroup.interactable = interactable;
		this.canvasGroup.blocksRaycasts = interactable;
	}

	// Token: 0x0600105C RID: 4188 RVA: 0x00139FA4 File Offset: 0x001381A4
	public void ToggleBothCanvasGroup(bool interactable)
	{
		if (interactable && !this.hudState)
		{
			return;
		}
		this.windowsCanvasGroup.interactable = interactable;
		this.canvasGroup.interactable = interactable;
		this.windowsCanvasGroup.blocksRaycasts = interactable;
		this.canvasGroup.blocksRaycasts = interactable;
		this.feedCanvasGroup.interactable = interactable;
		this.feedCanvasGroup.blocksRaycasts = interactable;
		this.feedCanvasGroup.interactable = interactable;
		this.cardCanvasGroup.interactable = interactable;
	}

	// Token: 0x0600105D RID: 4189 RVA: 0x0013A020 File Offset: 0x00138220
	public void HudAnimationInDone()
	{
		if (this.windowsAnimator.GetCurrentAnimatorStateInfo(0).IsName("WindowsOut"))
		{
			this.windowsAnimator.Play("WindowsIn");
			this.feedAnimator.Play("WindowsIn");
		}
		this.windowsCanvasGroup.interactable = true;
		this.windowsCanvasGroup.blocksRaycasts = true;
		this.feedCanvasGroup.interactable = true;
		this.feedCanvasGroup.blocksRaycasts = true;
		this.feedCanvas.enabled = true;
		this.hudState = true;
	}

	// Token: 0x0600105E RID: 4190 RVA: 0x0013A0AB File Offset: 0x001382AB
	public void HudAnimationOutDone()
	{
	}

	// Token: 0x0600105F RID: 4191 RVA: 0x0013A0B0 File Offset: 0x001382B0
	public void SkipPrologue()
	{
		this.skippingIntro = true;
		Records.x.partyTotal++;
		Records.x.partyTotal++;
		GameObject.Find("random prompt ishaat").GetComponent<PromptActions>().Ishaat();
		this.skipIntro.SetActive(false);
	}

	// Token: 0x06001060 RID: 4192 RVA: 0x0013A108 File Offset: 0x00138308
	public void OpenChalkRubbing()
	{
		this.chalkRubbing.SetActive(true);
	}

	// Token: 0x06001061 RID: 4193 RVA: 0x0013A118 File Offset: 0x00138318
	public void CloseChalkRubbing()
	{
		if (this.savingChalk)
		{
			return;
		}
		this.savingChalk = true;
		string text = Application.persistentDataPath + "/AutoSave/";
		string text2 = "";
		if (Links.x.diorama.sceneName == "C6_Tomb")
		{
			text += "C6_Tomb.png";
			text2 = "C6_Tomb";
		}
		bool flag = false;
		string text3 = "";
		if (Links.x.diorama.sceneName == "C6_Tomb")
		{
			text3 = "ChalkRubbingLazureMap";
		}
		Library.Inventory invRowFromName = Links.x.library.GetInvRowFromName(text3);
		int id = invRowFromName._ID;
		for (int i = 0; i < this.portraitOrder.Count; i++)
		{
			if (this.portraitOrder[i] && !flag && this.portraitOrder[i].HasItem(id) > -1)
			{
				flag = true;
			}
		}
		this.chalkRubbingDrawController.SaveAsSprite(text, flag, text3, invRowFromName, text2);
	}

	// Token: 0x06001062 RID: 4194 RVA: 0x0013A218 File Offset: 0x00138418
	public void FinishedSavingChalkRubbing(float percent, string scrollName, Library.Inventory invRow)
	{
		int num = -1;
		Library.Inventory invRowFromName = Links.x.library.GetInvRowFromName("ChalkRubbingKit");
		for (int i = 0; i < this.portraitOrder.Count; i++)
		{
			if (this.portraitOrder[i] && num == -1)
			{
				num = this.portraitOrder[i].HasItem(invRowFromName._ID);
				if (num > -1)
				{
					this.portraitOrder[i].RemoveItem(invRowFromName._ID, 1);
				}
			}
		}
		int id = invRow._ID;
		int num2 = -1;
		for (int j = 0; j < this.portraitOrder.Count; j++)
		{
			if (this.portraitOrder[j] && num2 == -1)
			{
				num2 = this.portraitOrder[j].HasItem(id);
				int num3 = (int)this.portraitOrder[j].GetDurabilityNum(num2 / 2).x - (int)percent;
				Debug.Log("percent change " + num3.ToString() + " index: " + num2.ToString());
				if (num2 > -1)
				{
					this.portraitOrder[j].UpdateDurability(num2 / 2, num3, false, true);
				}
			}
		}
		if (num2 == -1)
		{
			Debug.Log("Percent " + percent.ToString());
			global::Item item;
			ItemEquipped itemEquipped;
			Links.x.inventory.AddFromGround(null, null, 0, false, 0f, id, 1, Vector3.zero, Vector3.zero, new Vector4(percent, 0f, 0f, 0f), Links.x.main, true, true, out item, out itemEquipped);
		}
		this.chalkRubbing.SetActive(false);
		this.savingChalk = false;
	}

	// Token: 0x06001063 RID: 4195 RVA: 0x0013A3D0 File Offset: 0x001385D0
	public void PinToDock(string saveNoteImage, string saveNoteRune, string saveNoteText)
	{
		this.savedNoteImage = saveNoteImage;
		this.savedNoteText = saveNoteText;
		this.savedNoteRune = saveNoteRune;
		this.pinnedNote.SetActive(true);
		Debug.Log(saveNoteText + " " + saveNoteImage);
		if (this.savedNoteText != "" || saveNoteImage.Contains("Jrnl"))
		{
			this.pinnedNoteTextScrollview.SetActive(true);
			this.pinnedNoteText.text = saveNoteText;
			this.pinnedNoteImage.gameObject.SetActive(false);
			return;
		}
		this.pinnedNoteText.text = "";
		if (this.savedNoteRune != "")
		{
			string text = Application.persistentDataPath + "/AutoSave/";
			text += saveNoteRune;
			text += ".png";
			Sprite sprite = Links.x.archives.AddRune(saveNoteRune, text, "", saveNoteRune);
			this.pinnedNoteImage.sprite = sprite;
		}
		else
		{
			Sprite sprite2 = Resources.Load<Sprite>(saveNoteImage);
			this.pinnedNoteImage.sprite = sprite2;
		}
		this.pinnedNoteTextScrollview.SetActive(true);
		this.pinnedNoteImage.gameObject.SetActive(true);
	}

	// Token: 0x06001064 RID: 4196 RVA: 0x0013A4F4 File Offset: 0x001386F4
	public void SetPinnedNoteFromLoad()
	{
		if (this.savedNoteImage != "" || this.savedNoteRune != "" || this.savedNoteText != "")
		{
			this.PinToDock(this.savedNoteImage, this.savedNoteRune, this.savedNoteText);
			return;
		}
		this.ClosePinnedNote();
	}

	// Token: 0x06001065 RID: 4197 RVA: 0x0013A556 File Offset: 0x00138756
	public void ClosePinnedNote()
	{
		this.pinnedNote.SetActive(false);
		this.savedNoteImage = "";
		this.savedNoteText = "";
		this.savedNoteRune = "";
	}

	// Token: 0x06001066 RID: 4198 RVA: 0x0013A588 File Offset: 0x00138788
	public void SetMaskedItemPivot(RectTransform rt, Image img)
	{
		Vector2 sizeDelta = rt.sizeDelta;
		Vector2 pivot = img.sprite.pivot;
		Vector2 vector = new Vector2(pivot.x / sizeDelta.x, pivot.y / sizeDelta.y);
		rt.pivot = vector;
	}

	// Token: 0x06001067 RID: 4199 RVA: 0x0013A5D0 File Offset: 0x001387D0
	public void OpenTips()
	{
		Records.x.AddMenu(this.tipsMenu);
		Links.x.saveLoad.StartEndMenu(false);
		this.attackTip.spriteAsset = Links.x.GetSpriteSheetAsset(Links.x.gameplay.currentSpriteSheetAsset);
		this.defenseTip.spriteAsset = Links.x.GetSpriteSheetAsset(Links.x.gameplay.currentSpriteSheetAsset);
		this.rallyTip.spriteAsset = Links.x.GetSpriteSheetAsset(Links.x.gameplay.currentSpriteSheetAsset);
		this.circleTip.spriteAsset = Links.x.GetSpriteSheetAsset(Links.x.gameplay.currentSpriteSheetAsset);
		this.str.Clear();
		this.str.Append("<font=BoldOutline><size=1.4em>Dodging Attacks</size></font>\n");
		this.TipText("Defend");
		this.defenseTip.text = this.str.ToString();
		this.str.Clear();
		this.str.Append("<font=BoldOutline><size=1.4em>The Combat Dome</size></font>\n");
		this.TipText("Attack");
		this.attackTip.text = this.str.ToString();
		this.str.Clear();
		this.str.Append("<font=BoldOutline><size=1.4em>Rallies</size></font>\n");
		this.TipText("Rally");
		this.rallyTip.text = this.str.ToString();
		this.str.Clear();
		this.str.Append("<font=BoldOutline><size=1.4em>Form Up</size></font>\n");
		this.TipText("Circle");
		this.circleTip.text = this.str.ToString();
		this.tipsMenu.SetActive(true);
		this.ChangeTip(null);
	}

	// Token: 0x06001068 RID: 4200 RVA: 0x0013A798 File Offset: 0x00138998
	public void CloseTips()
	{
		this.tipsMenu.SetActive(false);
		Records.x.RemoveMenu(this.tipsMenu);
		this.JoyBox(false);
		Links.x.gameplay.openingAnotherMenu = false;
		Links.x.gameplay.CloseDock();
	}

	// Token: 0x06001069 RID: 4201 RVA: 0x0013A7E8 File Offset: 0x001389E8
	public void ChangeTip(GameObject go)
	{
		string text = "The Combat Dome";
		if (go)
		{
			text = go.name;
		}
		foreach (object obj in this.tipImages.transform)
		{
			Transform transform = (Transform)obj;
			if (transform.gameObject.name != text)
			{
				transform.gameObject.SetActive(false);
			}
			else
			{
				transform.gameObject.SetActive(true);
			}
		}
	}

	// Token: 0x0600106A RID: 4202 RVA: 0x0013A884 File Offset: 0x00138A84
	public void StartDemoIntro()
	{
		this.demoIntroAnimator.gameObject.SetActive(true);
	}

	// Token: 0x0600106B RID: 4203 RVA: 0x0013A897 File Offset: 0x00138A97
	public void EndDemoIntro()
	{
		this.demoIntroAnimator.Play("Out");
	}

	// Token: 0x0600106C RID: 4204 RVA: 0x0013A8A9 File Offset: 0x00138AA9
	public void CloseTutorialTooltip()
	{
		this.tutorialAnimator.Play("DialoguePopsTooltipEnd");
		this.tutorialTipOpen = false;
	}

	// Token: 0x0600106D RID: 4205 RVA: 0x0013A8C4 File Offset: 0x00138AC4
	public void TipText(string type)
	{
		if (type == "Circle")
		{
			if (Links.x.mk)
			{
				if (Links.x.pathfind)
				{
					this.str.Append("Hold ");
					this.str.Append(Links.x.keyControl.GetHotkeyString("Commands"));
					this.str.Append(" and click the ground ");
				}
				else
				{
					this.str.Append("Left click the ground ");
				}
				this.str.Append("to form up, or use the button on the bottom right corner of the screen. ");
			}
			else
			{
				int controllerSprite = Links.x.gameplay.GetControllerSprite("Press Joystick Right", Links.x.gameplay.controllerName);
				this.str.Append("Press ");
				this.str.Append("    <voffset=.4em><size=30><sprite=");
				this.str.Append(controllerSprite);
				this.str.Append("></size></voffset>");
				this.str.Append(" to form up. ");
			}
			this.str.Append("When your guards are huddled in formation, they'll get a defensive upgrade and the Rally meter fills faster.\n\nFormation can break if all your guards are forced out or too many enemies enter. If the formation breaks, you'll temporarily lose morale and attack less effectively.");
		}
		if (type == "Defend")
		{
			if (Links.x.mk)
			{
				this.str.Append("Press ");
				this.str.Append(Links.x.keyControl.GetHotkeyString("DodgePathfind"));
				this.str.Append(" ");
			}
			else
			{
				int controllerSprite2 = Links.x.gameplay.GetControllerSprite("Dodge", Links.x.gameplay.controllerName);
				this.str.Append("Press ");
				this.str.Append("    <voffset=.4em><size=30><sprite=");
				this.str.Append(controllerSprite2);
				this.str.Append("></size></voffset>");
			}
			this.str.Append("to dodge");
			if (Links.x.mk)
			{
				this.str.Append(" toward your cursor");
			}
			this.str.Append(". Dodging requires stamina but doesn't cost Action Time and can be done in between attacks.\n\nA perfect dodge will fill your action bar immediately.");
		}
		if (type == "Attack")
		{
			if (Links.x.mk)
			{
				this.str.Append("Right click");
			}
			else
			{
				int controllerSprite3 = Links.x.gameplay.GetControllerSprite("Action", Links.x.gameplay.controllerName);
				this.str.Append("Press ");
				this.str.Append("    <voffset=.4em><size=40><sprite=");
				this.str.Append(controllerSprite3);
				this.str.Append("></size></voffset>");
			}
			this.str.Append(" when your action bar is full to open the combat dome.");
			this.str.Append("\n\nYou can attack, pin, or charge any enemy inside the dome.\n\n");
		}
		if (type == "Rally")
		{
			this.str.Append("When one of the Rally bars at the bottom right of the screen is full, you'll unlock a new attack.\n\nMore than one full bar allows companions to chain together attacks regardless of their Action Time or distance away.\n\nCompanions cannot do a Rally Attack while they are in the middle of an action, are hit, or are pinning an enemy.");
		}
	}

	// Token: 0x0600106E RID: 4206 RVA: 0x0013ABC0 File Offset: 0x00138DC0
	public void ShowTutorialTooltip(string type)
	{
		if (type == "Companion" && !Records.x.needsCompanionTooltip && !Records.x.editor)
		{
			return;
		}
		if (type == "Defend" && !Records.x.needsDefendTooltip && !Records.x.editor)
		{
			return;
		}
		if (type == "Synergy" && !Records.x.needsSynergyTooltip)
		{
			return;
		}
		if (type == "Attack" && !Records.x.needsAttackTooltip && !Records.x.editor)
		{
			return;
		}
		if (type == "More" && !Records.x.needsMoreTooltip && !Records.x.editor)
		{
			return;
		}
		if (type == "Circle" && !Records.x.needsCircleTooltip && !Records.x.editor)
		{
			return;
		}
		Debug.Log("tooltip " + type);
		if (Records.x.filming)
		{
			return;
		}
		this.tutorialText.spriteAsset = Links.x.GetSpriteSheetAsset(Links.x.gameplay.currentSpriteSheetAsset);
		bool flag = false;
		this.str.Clear();
		if (type == "More")
		{
			if (Links.x.mk)
			{
				this.str.Append("Additional tips can be found in the settings menu. Press Escape to find the tips button.");
			}
			else
			{
				int controllerSprite = Links.x.gameplay.GetControllerSprite("Open Menus", Links.x.gameplay.controllerName);
				this.str.Append("Additional tips can be found in the settings menu. Press ");
				this.str.Append("    <voffset=.4em><size=30><sprite=");
				this.str.Append(controllerSprite);
				this.str.Append("></size></voffset> open your menus and find the tips button.");
			}
			this.tutorialText.text = this.str.ToString();
			flag = true;
		}
		if (type == "Companion")
		{
			if (Links.x.mk)
			{
				this.str.Append("Two companions have joined your party. You can click their portrait or use hot keys to switch your party leader.\n\nDuring combat, your companions will attack and cast spells based on the tactics you've set in their Spellbook and Tactics menu.");
			}
			else
			{
				this.str.Append("Two companions have joined your party. You can switch your party leader by pressing up or down on the D-Pad.\n\nDuring combat, your companions will attack and cast spells based on the tactics you've set in their Spellbook and Tactics menu.");
			}
			this.tutorialText.text = this.str.ToString();
			flag = true;
		}
		if (type == "Defend")
		{
			this.TipText("Defend");
			this.tutorialText.text = this.str.ToString();
			flag = true;
		}
		if (type == "Attack")
		{
			this.TipText("Attack");
			this.tutorialText.text = this.str.ToString();
			flag = true;
		}
		if (type == "Synergy")
		{
			this.TipText("Rally");
			this.tutorialText.text = this.str.ToString();
			flag = true;
		}
		if (type == "Circle")
		{
			this.TipText("Circle");
			this.tutorialText.text = this.str.ToString();
			flag = true;
		}
		if (flag)
		{
			if (type == "Synergy" && this.tutorialCoroutine != null)
			{
				return;
			}
			if (this.tutorialCoroutine != null)
			{
				base.StopCoroutine(this.tutorialCoroutine);
			}
			this.tutorialCoroutine = this.TutorialWait(type);
			base.StartCoroutine(this.tutorialCoroutine);
		}
	}

	// Token: 0x0600106F RID: 4207 RVA: 0x0013AEFC File Offset: 0x001390FC
	private bool Clicked()
	{
		return Links.x.joy && (Links.x.gameplay.cancelStart || Links.x.gameplay.actionStart || Links.x.gameplay.interactStart);
	}

	// Token: 0x06001070 RID: 4208 RVA: 0x0013AF4B File Offset: 0x0013914B
	private bool CanOpenAttack()
	{
		return Links.x.main && Links.x.main.attackTime >= 1f;
	}

	// Token: 0x06001071 RID: 4209 RVA: 0x0013AF77 File Offset: 0x00139177
	private IEnumerator TutorialWait(string type)
	{
		if (type != "Attack")
		{
			if (type == "Defend")
			{
				while (!Records.x.InCombat(false))
				{
					yield return null;
				}
				while (Records.x.pocketPause)
				{
					yield return null;
				}
			}
			if (type == "Synergy")
			{
				while (!Records.x.pocketPause)
				{
					yield return null;
				}
			}
			yield return new WaitForSecondsRealtime(0.5f);
			Links.x.gameplay.TogglePause(true);
		}
		else if (type == "Attack")
		{
			while (!this.CanOpenAttack())
			{
				yield return null;
			}
			Links.x.gameplay.TogglePause(true);
		}
		this.tutorial.SetActive(true);
		MasterAudio.PlaySoundAndForget("Feedback", 0.2f, new float?(1f), 0f, "Highlight Window", null);
		this.tutorialTipOpen = true;
		Records.x.RemoveControls(true);
		if (type == "Defend")
		{
			this.tutorialImage.sprite = this.defendSprite;
		}
		if (type == "Attack")
		{
			this.tutorialImage.sprite = this.actionSprite;
		}
		if (type == "Synergy")
		{
			this.tutorialImage.sprite = this.synergySprite;
		}
		if (type == "Companion")
		{
			this.tutorialImage.sprite = this.companionSprite;
		}
		if (type == "More")
		{
			this.tutorialImage.sprite = this.moreSprite;
		}
		if (type == "Circle")
		{
			this.tutorialImage.sprite = this.circleSprite;
		}
		this.tutorialAnimator.Play("DialoguePopsTooltip");
		MasterAudio.PlaySoundAndForget("Pause", 1f, new float?(1f), 0f, "", null);
		if (type == "Synergy")
		{
			Records.x.needsSynergyTooltip = false;
		}
		if (type == "Defend")
		{
			Records.x.needsDefendTooltip = false;
		}
		if (type == "Companion")
		{
			Records.x.needsCompanionTooltip = false;
		}
		if (type == "Attack")
		{
			Records.x.needsAttackTooltip = false;
		}
		if (type == "Attack")
		{
			Records.x.needsMoreTooltip = false;
		}
		if (type == "Circle")
		{
			Records.x.needsCircleTooltip = false;
		}
		float timeToLerp = 0.75f;
		float percentage = 0f;
		float startTime = Time.realtimeSinceStartup;
		while (percentage < 1f)
		{
			if (!this.tutorialTipOpen)
			{
				break;
			}
			percentage = (Time.realtimeSinceStartup - startTime) / timeToLerp;
			yield return null;
		}
		while (!this.Clicked() && this.tutorialTipOpen)
		{
			yield return null;
		}
		Links.x.gameplay.TogglePause(false);
		this.tutorialTipOpen = false;
		Records.x.RemoveControls(false);
		MasterAudio.PlaySoundAndForget("Feedback", 1f, new float?(1f), 0f, "Box Close", null);
		this.tutorialCoroutine = null;
		this.tutorialAnimator.Play("DialoguePopsTooltipEnd");
		this.tutorial.SetActive(false);
		yield break;
	}

	// Token: 0x04001A52 RID: 6738
	[Header("LISTS")]
	private List<Character> party;

	// Token: 0x04001A53 RID: 6739
	private List<Character> portraitOrder;

	// Token: 0x04001A54 RID: 6740
	public List<Windows> windows = new List<Windows>();

	// Token: 0x04001A55 RID: 6741
	public List<TextMeshProUGUI> keys = new List<TextMeshProUGUI>();

	// Token: 0x04001A56 RID: 6742
	public List<Image> menuButtonImages = new List<Image>();

	// Token: 0x04001A57 RID: 6743
	public List<Button> menuButtons = new List<Button>();

	// Token: 0x04001A58 RID: 6744
	public List<Image> timeOfDaySprites = new List<Image>();

	// Token: 0x04001A59 RID: 6745
	public List<Image> gameFeedWindowImages = new List<Image>();

	// Token: 0x04001A5A RID: 6746
	public List<TextMeshProUGUI> gameFeedWindowText = new List<TextMeshProUGUI>();

	// Token: 0x04001A5B RID: 6747
	public List<Image> mapWindowImages = new List<Image>();

	// Token: 0x04001A5C RID: 6748
	public List<RawImage> mapWindowRawImages = new List<RawImage>();

	// Token: 0x04001A5D RID: 6749
	public List<Transform> portraitPoints = new List<Transform>();

	// Token: 0x04001A5E RID: 6750
	public List<Sprite> clockImages = new List<Sprite>();

	// Token: 0x04001A5F RID: 6751
	public List<float> clockHours = new List<float>();

	// Token: 0x04001A60 RID: 6752
	public List<RectTransform> feedPositions = new List<RectTransform>();

	// Token: 0x04001A61 RID: 6753
	public List<TextMeshProUGUI> mapWindowText = new List<TextMeshProUGUI>();

	// Token: 0x04001A62 RID: 6754
	public List<AnimateButton> animateButtonsLoadState = new List<AnimateButton>();

	// Token: 0x04001A63 RID: 6755
	public List<GameObject> portraitBacks = new List<GameObject>();

	// Token: 0x04001A64 RID: 6756
	public AnimateButton currentHotkeyButton;

	// Token: 0x04001A65 RID: 6757
	public List<GameObject> dockButtons = new List<GameObject>();

	// Token: 0x04001A66 RID: 6758
	public List<AnimateButton> dockButtonControllers = new List<AnimateButton>();

	// Token: 0x04001A67 RID: 6759
	private List<Character> portraitOrderList = new List<Character>();

	// Token: 0x04001A68 RID: 6760
	[Header("OBJECTS")]
	public Canvas canvas;

	// Token: 0x04001A69 RID: 6761
	public Canvas windowsCanvas;

	// Token: 0x04001A6A RID: 6762
	public Canvas feedCanvas;

	// Token: 0x04001A6B RID: 6763
	public CanvasGroup canvasGroup;

	// Token: 0x04001A6C RID: 6764
	public CanvasGroup windowsCanvasGroup;

	// Token: 0x04001A6D RID: 6765
	public CanvasGroup feedCanvasGroup;

	// Token: 0x04001A6E RID: 6766
	public CanvasGroup cardCanvasGroup;

	// Token: 0x04001A6F RID: 6767
	public CanvasGroup cinematicQuips;

	// Token: 0x04001A70 RID: 6768
	public GameObject sheepPedestal;

	// Token: 0x04001A71 RID: 6769
	public Transform quipHolderCinematic;

	// Token: 0x04001A72 RID: 6770
	public Image clockImage;

	// Token: 0x04001A73 RID: 6771
	public RawImage sheepImage;

	// Token: 0x04001A74 RID: 6772
	public Button sheepButton;

	// Token: 0x04001A75 RID: 6773
	public Portrait portraitDragSelected;

	// Token: 0x04001A76 RID: 6774
	public RectTransform portraitsBar;

	// Token: 0x04001A77 RID: 6775
	public RectTransform gameFeedBar;

	// Token: 0x04001A78 RID: 6776
	public List<Image> overworldMapImages = new List<Image>();

	// Token: 0x04001A79 RID: 6777
	public Mask overworldMapMask;

	// Token: 0x04001A7A RID: 6778
	public GameObject bottomLeft;

	// Token: 0x04001A7B RID: 6779
	public Image leftBackground;

	// Token: 0x04001A7C RID: 6780
	public List<GameObject> turnOffForController = new List<GameObject>();

	// Token: 0x04001A7D RID: 6781
	public List<GameObject> turnOnForController = new List<GameObject>();

	// Token: 0x04001A7E RID: 6782
	public Animator clockAnimator;

	// Token: 0x04001A7F RID: 6783
	public Animator hudAnimator;

	// Token: 0x04001A80 RID: 6784
	public Animator windowsAnimator;

	// Token: 0x04001A81 RID: 6785
	public Animator feedAnimator;

	// Token: 0x04001A82 RID: 6786
	public Animator gameCardAnimator;

	// Token: 0x04001A83 RID: 6787
	public Animator demoIntroAnimator;

	// Token: 0x04001A84 RID: 6788
	public RenderTexture texturesIdle;

	// Token: 0x04001A85 RID: 6789
	public RawImage companionPortrait;

	// Token: 0x04001A86 RID: 6790
	public Image mask;

	// Token: 0x04001A87 RID: 6791
	private float updateTime;

	// Token: 0x04001A88 RID: 6792
	public List<Portrait> portraits = new List<Portrait>();

	// Token: 0x04001A89 RID: 6793
	public Button timeOfDayBtn;

	// Token: 0x04001A8A RID: 6794
	public GameObject descriptionWindow;

	// Token: 0x04001A8B RID: 6795
	public GameObject descriptionWindowSpirit;

	// Token: 0x04001A8C RID: 6796
	public GameObject descriptionWindowSpirit1;

	// Token: 0x04001A8D RID: 6797
	public GameObject descriptionWindowSpirit2;

	// Token: 0x04001A8E RID: 6798
	public GameObject descriptionWindowSpirit3;

	// Token: 0x04001A8F RID: 6799
	public Animator descriptionAnimator;

	// Token: 0x04001A90 RID: 6800
	public bool descriptionWindowOpen;

	// Token: 0x04001A91 RID: 6801
	public Image bg1;

	// Token: 0x04001A92 RID: 6802
	public Image bg2;

	// Token: 0x04001A93 RID: 6803
	public Image descSprite;

	// Token: 0x04001A94 RID: 6804
	public TextMeshProUGUI descText;

	// Token: 0x04001A95 RID: 6805
	public TextMeshProUGUI descControllerText;

	// Token: 0x04001A96 RID: 6806
	public ScrollRectNoDragging scrollRect1;

	// Token: 0x04001A97 RID: 6807
	public ScrollRectNoDragging scrollRect2;

	// Token: 0x04001A98 RID: 6808
	public GameObject gameFeedPopout;

	// Token: 0x04001A99 RID: 6809
	public GameObject pinnedNoteClose;

	// Token: 0x04001A9A RID: 6810
	public Scrollbar scrollbar;

	// Token: 0x04001A9B RID: 6811
	public TextMeshProUGUI popoutText;

	// Token: 0x04001A9C RID: 6812
	public TextMeshProUGUI gameFeedText;

	// Token: 0x04001A9D RID: 6813
	public ItemBook itemInfo;

	// Token: 0x04001A9E RID: 6814
	public global::Item tooltipItem;

	// Token: 0x04001A9F RID: 6815
	public GameObject numbers;

	// Token: 0x04001AA0 RID: 6816
	public Transform startEnemy;

	// Token: 0x04001AA1 RID: 6817
	public Transform endEnemy;

	// Token: 0x04001AA2 RID: 6818
	public Transform startParty;

	// Token: 0x04001AA3 RID: 6819
	public Transform endParty;

	// Token: 0x04001AA4 RID: 6820
	public Transform actionEnemy;

	// Token: 0x04001AA5 RID: 6821
	public Transform actionParty;

	// Token: 0x04001AA6 RID: 6822
	public Animator timelineAnimator;

	// Token: 0x04001AA7 RID: 6823
	public SkillBag currentSpellBook;

	// Token: 0x04001AA8 RID: 6824
	public HannahAnimator pauseAnimator;

	// Token: 0x04001AA9 RID: 6825
	public List<Vector3> windowsPosition = new List<Vector3>();

	// Token: 0x04001AAA RID: 6826
	public List<Vector3> windowsFull = new List<Vector3>();

	// Token: 0x04001AAB RID: 6827
	public List<Vector3> windowsSize = new List<Vector3>();

	// Token: 0x04001AAC RID: 6828
	public List<string> windowsCharacter = new List<string>();

	// Token: 0x04001AAD RID: 6829
	public GameObject badge;

	// Token: 0x04001AAE RID: 6830
	public GameObject bribeBadge;

	// Token: 0x04001AAF RID: 6831
	public Transform stunBadgeParent;

	// Token: 0x04001AB0 RID: 6832
	public GameObject badgeControllerText;

	// Token: 0x04001AB1 RID: 6833
	public List<AnimateButton> usedBadges = new List<AnimateButton>();

	// Token: 0x04001AB2 RID: 6834
	public List<AnimateButton> openBadges = new List<AnimateButton>();

	// Token: 0x04001AB3 RID: 6835
	public List<AnimateButton> usedBribeBadges = new List<AnimateButton>();

	// Token: 0x04001AB4 RID: 6836
	public List<AnimateButton> openBribeBadges = new List<AnimateButton>();

	// Token: 0x04001AB5 RID: 6837
	private IEnumerator gridCorout;

	// Token: 0x04001AB6 RID: 6838
	public GridLayoutGroup stunGrid;

	// Token: 0x04001AB7 RID: 6839
	private bool hudState;

	// Token: 0x04001AB8 RID: 6840
	public GameObject chalkRubbing;

	// Token: 0x04001AB9 RID: 6841
	public DrawViewController chalkRubbingDrawController;

	// Token: 0x04001ABA RID: 6842
	public Image at1;

	// Token: 0x04001ABB RID: 6843
	public Image at2;

	// Token: 0x04001ABC RID: 6844
	public Image at3;

	// Token: 0x04001ABD RID: 6845
	public Animator attackTimerAnimator;

	// Token: 0x04001ABE RID: 6846
	public GameObject actionUp;

	// Token: 0x04001ABF RID: 6847
	public GameObject actionDown;

	// Token: 0x04001AC0 RID: 6848
	public Color attackTimerColorWait;

	// Token: 0x04001AC1 RID: 6849
	public Color attackTimerColorReady;

	// Token: 0x04001AC2 RID: 6850
	public TextMeshProUGUI addTimeText;

	// Token: 0x04001AC3 RID: 6851
	public TextMeshProUGUI inActionText;

	// Token: 0x04001AC4 RID: 6852
	public GameObject addTime;

	// Token: 0x04001AC5 RID: 6853
	public GameObject inAction;

	// Token: 0x04001AC6 RID: 6854
	public GameObject notReady;

	// Token: 0x04001AC7 RID: 6855
	public GameObject menuSwitcher;

	// Token: 0x04001AC8 RID: 6856
	public GameObject menuSwitcherLower;

	// Token: 0x04001AC9 RID: 6857
	public TextMeshProUGUI leftMenuSwitchText;

	// Token: 0x04001ACA RID: 6858
	public TextMeshProUGUI rightMenuSwitchText;

	// Token: 0x04001ACB RID: 6859
	public TextMeshProUGUI menuSwitcherLowerText;

	// Token: 0x04001ACC RID: 6860
	public global::UnityEngine.UI.Toggle csToggle;

	// Token: 0x04001ACD RID: 6861
	public global::UnityEngine.UI.Toggle journalToggle;

	// Token: 0x04001ACE RID: 6862
	public global::UnityEngine.UI.Toggle mapToggle;

	// Token: 0x04001ACF RID: 6863
	public global::UnityEngine.UI.Toggle optionsToggle;

	// Token: 0x04001AD0 RID: 6864
	public global::UnityEngine.UI.Toggle tacticsToggle;

	// Token: 0x04001AD1 RID: 6865
	public global::UnityEngine.UI.Toggle restToggle;

	// Token: 0x04001AD2 RID: 6866
	public GameObject tutorial;

	// Token: 0x04001AD3 RID: 6867
	public TextMeshProUGUI tutorialText;

	// Token: 0x04001AD4 RID: 6868
	public Image tutorialImage;

	// Token: 0x04001AD5 RID: 6869
	public Sprite actionSprite;

	// Token: 0x04001AD6 RID: 6870
	public Sprite defendSprite;

	// Token: 0x04001AD7 RID: 6871
	public Sprite synergySprite;

	// Token: 0x04001AD8 RID: 6872
	public Sprite companionSprite;

	// Token: 0x04001AD9 RID: 6873
	public Sprite moreSprite;

	// Token: 0x04001ADA RID: 6874
	public Sprite circleSprite;

	// Token: 0x04001ADB RID: 6875
	public Animator tutorialAnimator;

	// Token: 0x04001ADC RID: 6876
	private IEnumerator tutorialCoroutine;

	// Token: 0x04001ADD RID: 6877
	public GameObject demoMessage;

	// Token: 0x04001ADE RID: 6878
	public GameObject skipIntro;

	// Token: 0x04001ADF RID: 6879
	public GameObject pinnedNote;

	// Token: 0x04001AE0 RID: 6880
	public GameObject pinnedNoteTextScrollview;

	// Token: 0x04001AE1 RID: 6881
	public TextMeshProUGUI pinnedNoteText;

	// Token: 0x04001AE2 RID: 6882
	public Image pinnedNoteImage;

	// Token: 0x04001AE3 RID: 6883
	public GameObject controllerItem1;

	// Token: 0x04001AE4 RID: 6884
	public GameObject controllerItem2;

	// Token: 0x04001AE5 RID: 6885
	public GameObject controllerLeader1;

	// Token: 0x04001AE6 RID: 6886
	public GameObject controllerLeader2;

	// Token: 0x04001AE7 RID: 6887
	public RectTransform rallySpin;

	// Token: 0x04001AE8 RID: 6888
	public Image rallyTri1;

	// Token: 0x04001AE9 RID: 6889
	public Image rallyTri2;

	// Token: 0x04001AEA RID: 6890
	public Image rallyTri3;

	// Token: 0x04001AEB RID: 6891
	public Image rallyBuff;

	// Token: 0x04001AEC RID: 6892
	public GameObject rallyStage1;

	// Token: 0x04001AED RID: 6893
	public GameObject rallyStage2;

	// Token: 0x04001AEE RID: 6894
	public GameObject rallyStage3;

	// Token: 0x04001AEF RID: 6895
	public GameObject rallyStage4;

	// Token: 0x04001AF0 RID: 6896
	public Sprite rallySpriteOn;

	// Token: 0x04001AF1 RID: 6897
	public Sprite rallySpriteOff;

	// Token: 0x04001AF2 RID: 6898
	public Image stamina;

	// Token: 0x04001AF3 RID: 6899
	public GameObject staminaBuff;

	// Token: 0x04001AF4 RID: 6900
	public Color startStaminaColor;

	// Token: 0x04001AF5 RID: 6901
	[Header("INTERACTIONS")]
	public List<Character> nearTalkCharacters = new List<Character>();

	// Token: 0x04001AF6 RID: 6902
	public List<BreakableActions> nearBreakables = new List<BreakableActions>();

	// Token: 0x04001AF7 RID: 6903
	public List<ChestActions> nearChests = new List<ChestActions>();

	// Token: 0x04001AF8 RID: 6904
	public List<PuzzleActions> nearPuzzles = new List<PuzzleActions>();

	// Token: 0x04001AF9 RID: 6905
	public List<DoorActions> nearDoors = new List<DoorActions>();

	// Token: 0x04001AFA RID: 6906
	public List<Boat> nearBoats = new List<Boat>();

	// Token: 0x04001AFB RID: 6907
	public List<MapExitActions> nearMapExits = new List<MapExitActions>();

	// Token: 0x04001AFC RID: 6908
	public List<AnimateButton> nearBtnCharsUsed = new List<AnimateButton>();

	// Token: 0x04001AFD RID: 6909
	public List<AnimateButton> nearBtnBreaksUsed = new List<AnimateButton>();

	// Token: 0x04001AFE RID: 6910
	public List<AnimateButton> nearBtnChestsUsed = new List<AnimateButton>();

	// Token: 0x04001AFF RID: 6911
	public List<AnimateButton> nearBtnPuzzUsed = new List<AnimateButton>();

	// Token: 0x04001B00 RID: 6912
	public List<AnimateButton> nearBtnDoorsUsed = new List<AnimateButton>();

	// Token: 0x04001B01 RID: 6913
	public List<AnimateButton> nearBtnExitsUsed = new List<AnimateButton>();

	// Token: 0x04001B02 RID: 6914
	public List<AnimateButton> nearBtnBoatsUsed = new List<AnimateButton>();

	// Token: 0x04001B03 RID: 6915
	public List<AnimateButton> nearBtns = new List<AnimateButton>();

	// Token: 0x04001B04 RID: 6916
	public GameObject nearBtnPrefab;

	// Token: 0x04001B05 RID: 6917
	public Transform interactionBtnsTransform;

	// Token: 0x04001B06 RID: 6918
	public Transform miscFolderQuipsTransform;

	// Token: 0x04001B07 RID: 6919
	public Image joyIcon;

	// Token: 0x04001B08 RID: 6920
	public Image joyIconHolder;

	// Token: 0x04001B09 RID: 6921
	public Image joyIconMM;

	// Token: 0x04001B0A RID: 6922
	public Image joyIconHolderMM;

	// Token: 0x04001B0B RID: 6923
	public Image joyBorder;

	// Token: 0x04001B0C RID: 6924
	public RectTransform joyRT;

	// Token: 0x04001B0D RID: 6925
	public Sprite[] xboxIcons;

	// Token: 0x04001B0E RID: 6926
	public Sprite[] playstationIcons;

	// Token: 0x04001B0F RID: 6927
	public Sprite[] switchIcons;

	// Token: 0x04001B10 RID: 6928
	public Sprite[] steamIcons;

	// Token: 0x04001B11 RID: 6929
	public Sprite mineralizing;

	// Token: 0x04001B12 RID: 6930
	public Sprite repairing;

	// Token: 0x04001B13 RID: 6931
	private float updateRallyTime;

	// Token: 0x04001B14 RID: 6932
	[Header("BOOKS")]
	public bool spellBookOpen;

	// Token: 0x04001B15 RID: 6933
	public bool menuButtonsOpen;

	// Token: 0x04001B16 RID: 6934
	private int currIndex;

	// Token: 0x04001B17 RID: 6935
	[Header("INFO")]
	public string use = "Weapon";

	// Token: 0x04001B18 RID: 6936
	public bool groupHud;

	// Token: 0x04001B19 RID: 6937
	public int skillBagsOpen;

	// Token: 0x04001B1A RID: 6938
	public bool allModalWindowsOpen;

	// Token: 0x04001B1B RID: 6939
	private bool hasWindowSaveFile;

	// Token: 0x04001B1C RID: 6940
	private bool savingChalk;

	// Token: 0x04001B1D RID: 6941
	private StringFast str = new StringFast(32);

	// Token: 0x04001B1E RID: 6942
	public Character upCharacter;

	// Token: 0x04001B1F RID: 6943
	public Character downCharacter;

	// Token: 0x04001B20 RID: 6944
	public Character leftCharacter;

	// Token: 0x04001B21 RID: 6945
	public Character rightCharacter;

	// Token: 0x04001B22 RID: 6946
	public string savedNoteImage;

	// Token: 0x04001B23 RID: 6947
	public string savedNoteText;

	// Token: 0x04001B24 RID: 6948
	public string savedNoteRune;

	// Token: 0x04001B25 RID: 6949
	public float iconScale = 0.85f;

	// Token: 0x04001B26 RID: 6950
	public bool tutorialTipOpen;

	// Token: 0x04001B27 RID: 6951
	public bool skippingIntro;

	// Token: 0x04001B28 RID: 6952
	public float rallyInterval = 15f;

	// Token: 0x04001B29 RID: 6953
	public bool hidingHud;

	// Token: 0x04001B2A RID: 6954
	[Header("TIPS")]
	public TextMeshProUGUI attackTip;

	// Token: 0x04001B2B RID: 6955
	public TextMeshProUGUI defenseTip;

	// Token: 0x04001B2C RID: 6956
	public TextMeshProUGUI rallyTip;

	// Token: 0x04001B2D RID: 6957
	public TextMeshProUGUI circleTip;

	// Token: 0x04001B2E RID: 6958
	public GameObject tipsMenu;

	// Token: 0x04001B2F RID: 6959
	public GameObject tipImages;

	// Token: 0x04001B30 RID: 6960
	[Header("BORO")]
	public Windows boroCard;

	// Token: 0x04001B31 RID: 6961
	public TMP_InputField boroInput;

	// Token: 0x04001B32 RID: 6962
	public GameObject boroCardEditName;

	// Token: 0x04001B33 RID: 6963
	public GameObject boroTooltip;

	// Token: 0x04001B34 RID: 6964
	public TextMeshProUGUI boroCardName;

	// Token: 0x04001B35 RID: 6965
	public TextMeshProUGUI boroTooltipText;

	// Token: 0x04001B36 RID: 6966
	public Image boroSpeed;

	// Token: 0x04001B37 RID: 6967
	public Image boroStrength;

	// Token: 0x04001B38 RID: 6968
	public Image boroSpirit;

	// Token: 0x04001B39 RID: 6969
	public Image boroShrine1;

	// Token: 0x04001B3A RID: 6970
	public Image boroShrine2;

	// Token: 0x04001B3B RID: 6971
	public Image boroShrine3;

	// Token: 0x04001B3C RID: 6972
	public Material boroShrineOn;

	// Token: 0x04001B3D RID: 6973
	public Material boroShrineOff;

	// Token: 0x04001B3E RID: 6974
	public GameObject boroHoverCard;

	// Token: 0x04001B3F RID: 6975
	public GameObject boroCost;

	// Token: 0x04001B40 RID: 6976
	public TextMeshProUGUI boroHoverCardName;

	// Token: 0x04001B41 RID: 6977
	public TextMeshProUGUI boroHoverCardCompareName;

	// Token: 0x04001B42 RID: 6978
	public TextMeshProUGUI boroHoverCardCost;

	// Token: 0x04001B43 RID: 6979
	public Image boroHoverCardSpeed;

	// Token: 0x04001B44 RID: 6980
	public Image boroHoverCardStrength;

	// Token: 0x04001B45 RID: 6981
	public Image boroHoverCardSpirit;

	// Token: 0x04001B46 RID: 6982
	public Image boroHoverCardShrine1;

	// Token: 0x04001B47 RID: 6983
	public Image boroHoverCardShrine2;

	// Token: 0x04001B48 RID: 6984
	public Image boroHoverCardShrine3;

	// Token: 0x04001B49 RID: 6985
	public Image boroHoverCardSpeedCompare;

	// Token: 0x04001B4A RID: 6986
	public Image boroHoverCardStrengthCompare;

	// Token: 0x04001B4B RID: 6987
	public Image boroHoverCardSpiritCompare;

	// Token: 0x04001B4C RID: 6988
	public Image boroHoverCardShrine1Compare;

	// Token: 0x04001B4D RID: 6989
	public Image boroHoverCardShrine2Compare;

	// Token: 0x04001B4E RID: 6990
	public Image boroHoverCardShrine3Compare;

	// Token: 0x04001B4F RID: 6991
	public Animator boroHoverCardAnimator;

	// Token: 0x04001B50 RID: 6992
	public bool boroCardOn;

	// Token: 0x04001B51 RID: 6993
	public Character hoverBoro;

	// Token: 0x04001B52 RID: 6994
	public RectTransform boroHoverCardRT;
}
