Project/Assets/Scripts/Map/Map.cs

//================================================================================
//
//================================================================================

using UnityEngine;
using System.Collections;
using KishiTechUnity.ScreenFade;
using KishiTechUnity.KishiTechDebug;

//================================================================================
//
//================================================================================
namespace ReaderRabbit
{

	//================================================================================
	//
	//================================================================================
	public class Map : MonoBehaviour
	{

		//================================================================================
		// Singleton
		//================================================================================
		private static Map s_Instance = null;
		public static Map Instance()
		{
			if (s_Instance == null)
			{
				s_Instance = GameObject.FindObjectOfType<Map>();
				
				if (s_Instance == null) 
				{
					GameObject gameObject = new GameObject("Map");
					DontDestroyOnLoad(gameObject);
					s_Instance = gameObject.AddComponent<Map>();
				}
			}

			return s_Instance;
		}

		//================================================================================
		// This is the same as enum Location but as string.
		// Used in TypeWriterStartButton to load the last location that the player was in.
		//================================================================================
		public static string[] LocationAsString =
		{
			"EdgeOfCloudNine",
			"CloudNineGateway",
			"CloudSpellingChallenge",
			"DowntownCloudNine",
			"CloudNineArtGallery",
			"AmazingArtGallery",
			"CloudSheepCrossing",
			"NewspaperCarrierScene",
			"RaingearIsland",
			"IrvinsHouse",
			"GumballScience",
			"RaingearThrowingMachine",
			"MusicalMarblePatterns",
			"RaingearForest",
			"RaingearForestMath",
			"SillySandwichShop",
			"RockHead",
			"FlowerpotPhonics",
			"RaingearRescue",
		};

		//================================================================================
		//
		//================================================================================
		SceneCommon m_ParentScene;

		[SerializeField] RRInteractiveRectangle m_BackgroundRectangle;
		[SerializeField] SpriteRenderer m_MapBackground;

		[SerializeField] GameObject m_CurrentLocation;
		
		// ATTENTION: Navigation order is important! Must match enum Location.		
		[SerializeField] HUDMapNavigation[] m_Navigation;

		[SerializeField] HUDCommon[] m_HUD;

		System.Action m_PreviousOnFadeOutFinishedCallback;

		// HACK: Force visual update (position and size) according to current resolution.
		static bool m_CalledUpdateVisual;

		string m_LevelSelected;

        public enum MapOpenedType
        {
            None = 0,
            Opened,
            OpenedSpeechMarble,
        };

        private bool m_ChangedLocationFromMap;

		//================================================================================
		//
		//================================================================================
		void Awake()
		{
			if (s_Instance == null)
			{
				s_Instance = this;
				DontDestroyOnLoad(this);
			}
			else
			{
				if (s_Instance != this)
					Destroy(this.gameObject);
			}
		}

		//================================================================================
		//
		//================================================================================
		void Start()
		{
			float deltaX = (Screen.width - m_BackgroundRectangle.GetAABB().width) * 0.5f;
			float deltaY = -(Screen.height - m_BackgroundRectangle.GetAABB().height) * 0.5f;
			
			Vector3 mapPosition = s_Instance.gameObject.transform.position;
			mapPosition.x = deltaX;
			mapPosition.y = deltaY;
			s_Instance.gameObject.transform.position = mapPosition;

			if (m_BackgroundRectangle != null)
				m_BackgroundRectangle.UpdateAABB();

			Close();

			m_CalledUpdateVisual = false;

            m_ChangedLocationFromMap = false;

            PlayerData.Instance().CurrentMapOpenedType = MapOpenedType.None;
		}

		//================================================================================
		// HACK: Force visual update (position and size) according to current resolution.
		//================================================================================
		void UpdateVisual()
		{
			KishiTechUnity.ScreenResolution.ScreenResolutionManager.Instance().ForceUpdateGameObject(s_Instance.gameObject);

			// HACK: Oh boy. Here comes some ugly code.
			// After updating game object (position and size), we update the background rectangle.
			if (m_BackgroundRectangle != null)
			{
				KishiTechUnity.ScreenResolution.ScreenResolutionManager.Instance().ForceUpdateInteractiveRectangle(m_BackgroundRectangle);
				m_BackgroundRectangle.UpdateAABB();
			}

			// We use the updated background rectangle here - center the Map parent but using a top-left anchor point.
			float deltaX = (Screen.width - m_BackgroundRectangle.GetAABB().width) * 0.5f;
			float deltaY = -(Screen.height - m_BackgroundRectangle.GetAABB().height) * 0.5f;
			
			// Then we center the Map parent onscreen.
			Vector3 mapPosition = s_Instance.gameObject.transform.position;
			mapPosition.x = deltaX;
			mapPosition.y = deltaY;
			s_Instance.gameObject.transform.position = mapPosition;

			// And we update the background rectangle (once again). Maybe we should simply use a center anchor point.
			if (m_BackgroundRectangle != null)
				m_BackgroundRectangle.UpdateAABB();

			m_CalledUpdateVisual = true;
		}

		//================================================================================
		//
		//================================================================================
		private void SetFadeOutCallback()
		{
			m_PreviousOnFadeOutFinishedCallback = ScreenFade.Instance().GetOnFadeOutFinishedCallback();
			ScreenFade.Instance().SetOnFadeOutFinishedCallback(FinishedFadeOut);
		}

		//================================================================================
		//
		//================================================================================
		private void RestorePreviousFadeOutCallback()
		{
			ScreenFade.Instance().SetOnFadeOutFinishedCallback(m_PreviousOnFadeOutFinishedCallback);
			m_PreviousOnFadeOutFinishedCallback = null;
		}

		//================================================================================
		//
		//================================================================================
		private void UpdateMap()
		{
			if (!m_CalledUpdateVisual)
				UpdateVisual();

			if (PlayerData.Instance().IsPracticeMode())
			{
				if (m_Navigation != null)
				{
					for (int i = 0; i < m_Navigation.Length; ++i)
					{
						m_Navigation[i].Hide();
					}
					m_Navigation[(int)Location.CloudSpellingChallenge].Show();
					m_Navigation[(int)Location.AmazingArtGallery].Show();
					m_Navigation[(int)Location.GumballScience].Show();
					m_Navigation[(int)Location.MusicalMarblePatterns].Show();
					m_Navigation[(int)Location.RaingearForestMath].Show();
					m_Navigation[(int)Location.SillySandwichShop].Show();
					m_Navigation[(int)Location.FlowerpotPhonics].Show();
					m_Navigation[(int)Location.RaingearRescue].Show();
				}
			}
			else
			{
				bool debugEnabled = KTDebug.Instance().IsEnabled();
				if (m_Navigation != null)
				{
					for (int i = 0; i < m_Navigation.Length; ++i)
					{
						m_Navigation[i].SetVisible(PlayerData.Instance().DidVisit(i) || debugEnabled);
					}
				}
			}

			Location currentLocation = PlayerData.Instance().GetCurrentLocation();
			if (currentLocation == Location.Quantity)
			{
				m_CurrentLocation.SetActive(false);
			}
			else
			{
				if (!m_CurrentLocation.activeSelf)
					m_CurrentLocation.SetActive(true);

                float offsetX = 5.0f * KishiTechUnity.ScreenResolution.ScreenResolutionManager.Instance().ConversionRatio;
                float offsetY = -5.0f;

				// HACK: There are five activity icons that has the marble at their top-right corner so we need to adjust the yellow circle y-position accordingly.
                switch (currentLocation)
                {
				    case Location.CloudSpellingChallenge:
                        offsetY = -2.0f;
                        break;

                    case Location.GumballScience:
                        offsetY = 11.0f;
                        break;

                    case Location.RaingearForestMath:
                        offsetY = 8.0f;
                        break;

                    case Location.SillySandwichShop:
                        offsetY = 8.0f;
                        break;

                    case Location.FlowerpotPhonics:
                        offsetY = 11.0f;
                        break;
                }

                Vector3 currentScreenPosition = m_Navigation[(int)currentLocation].transform.position;
                currentScreenPosition.x -= offsetX;
                currentScreenPosition.y -= (offsetY * KishiTechUnity.ScreenResolution.ScreenResolutionManager.Instance().ConversionRatio);
				m_CurrentLocation.transform.position = currentScreenPosition;
			}

			if (m_BackgroundRectangle != null)
				m_BackgroundRectangle.UpdateDebugEnabled();
		}

		//================================================================================
		//
		//================================================================================
		public SceneCommon GetParentScene()
		{
			return m_ParentScene;
		}

		//================================================================================
		//
		//================================================================================
		public void Open(SceneCommon parentScene)
		{
            m_ChangedLocationFromMap = false;

			m_ParentScene = parentScene;
			if (m_ParentScene != null)
				m_ParentScene.DisableColliders();

			s_Instance.gameObject.SetActive(true);

			AudioManager.Instance().PlaySFX("Map_Options");

			SetFadeOutCallback();
			UpdateMap();

			m_LevelSelected = "";

            if (PlayerData.Instance().CurrentMapOpenedType == MapOpenedType.None)
            {
                PlayerData.Instance().CurrentMapOpenedType = MapOpenedType.Opened;
                if (PlayerData.Instance().IsPracticeMode())
                    AudioManager.Instance().PlaySpeech("4601");
                else
                    AudioManager.Instance().PlaySpeech("4503");
            }
            else
            {
                if (PlayerData.Instance().IsPracticeMode())
                {
                    AudioManager.Instance().PlaySpeech("4602");
                }
                else if (PlayerData.Instance().CurrentMapOpenedType == MapOpenedType.Opened)
                {
                    if (PlayerData.Instance().DidVisitMusicalMarblePatterns())
                    {
                        AudioManager.Instance().PlaySpeech("4301");
                        PlayerData.Instance().CurrentMapOpenedType = MapOpenedType.OpenedSpeechMarble;
                    }
                }
            }
		}

		//================================================================================
		//
		//================================================================================
		public void Close()
		{
            if (AudioManager.Instance().IsPlayingSpeech("4601")
                || AudioManager.Instance().IsPlayingSpeech("4602")
                || AudioManager.Instance().IsPlayingSpeech("4503")
                || AudioManager.Instance().IsPlayingSpeech("4301")
                )
            {
                AudioManager.Instance().StopSpeech();
            }

			RestorePreviousFadeOutCallback();

			s_Instance.gameObject.SetActive(false);

			if (m_ParentScene != null)
			{
				m_ParentScene.RestoreColliders();
				m_ParentScene.OnMapClose();
				m_ParentScene = null;
			}
		}

        //================================================================================
        //
        //================================================================================
        public void ResetMapOpenedType()
        {
            PlayerData.Instance().CurrentMapOpenedType = MapOpenedType.None;
        }

		//================================================================================
		// Called when Options is closed.
		//================================================================================
		public void BackFromOptions()
		{
			s_Instance.gameObject.SetActive(true);
		}
		
		//================================================================================
		// Called when Options is opened.
		//================================================================================
		public void HideForOptions()
		{
			s_Instance.gameObject.SetActive(false);
		}
		
		//================================================================================
		//
		//================================================================================
		public bool IsOpened()
		{
			return s_Instance.gameObject.activeInHierarchy;
		}

        //================================================================================
        //
        //================================================================================
        public void EnableAll()
        {
            if (m_Navigation != null)
            {
                foreach (HUDMapNavigation navigation in m_Navigation)
                {
                    navigation.Enable();
                }
            }

            if (m_HUD != null)
            {
                foreach (HUDCommon hud in m_HUD)
                {
                    hud.Enable();
                }
            }
        }

        //================================================================================
        //
        //================================================================================
        public void DisableAll()
        {
            if (m_Navigation != null)
            {
                foreach (HUDMapNavigation navigation in m_Navigation)
                {
                    navigation.Disable();
                }
            }

            if (m_HUD != null)
            {
                foreach (HUDCommon hud in m_HUD)
                {
                    hud.Disable();
                }
            }
        }

        //================================================================================
		//
		//================================================================================
		void FinishedFadeOut()
		{
			KishiTechUnity.KishiTechDebug.KTDebug.Instance().Log("Calling Map.FinishedFadeOut()...");
			
			Close();
			Chester.Instance().CloseInstantly();

			KishiTechUnity.Loading.Loading.Instance().Show();

			// HUDMapNavigation started fade-out. When it is over, we load the level defined there (which is copied to m_LevelSelected).
            if (!string.IsNullOrEmpty(m_LevelSelected))
            {
                m_ChangedLocationFromMap = true;
                Application.LoadLevel(m_LevelSelected);
            }
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetLevelSelected(string levelName)
		{
			m_LevelSelected = levelName;
		}

		//================================================================================
		//
		//================================================================================
		bool CheckHUD()
		{
			if (m_HUD != null)
			{
				foreach (HUDCommon hud in m_HUD)
				{
					if (hud.WasUpAsButton() || hud.DidExitWhileDown())
					{
						hud.ClearWasUpAsButton();
						hud.ClearDidExitWhileDown();
						return true;
					}
				}
			}
			
			return false;
		}

		//================================================================================
		//
		//================================================================================
		bool CheckNavigation(float x, float y)
		{
			if (m_Navigation != null)
			{
				foreach (HUDCommon navigation in m_Navigation)
				{
					if (navigation.WasUpAsButton() || navigation.DidExitWhileDown())
					{
						navigation.ClearWasUpAsButton();
						navigation.ClearDidExitWhileDown();
						return true;
					}
				}
			}

			return false;
		}
		
		//================================================================================
		//
		//================================================================================
		public void CheckAll(float x, float y)
		{
			// HUD priority is #1.
			bool clickedOnHUD = CheckHUD();
			if (!clickedOnHUD)
			{
				// Navigation priority is #2.
				bool clickedOnNavigation = CheckNavigation(x, y);
				if (!clickedOnNavigation)
				{
					if (m_BackgroundRectangle != null)
					{
						if (m_BackgroundRectangle.IsPointInside(x, y))
						{
							int textureX = (int)(x - gameObject.transform.position.x);
							int textureY = (int)y;//((Screen.height - y) - (-gameObject.transform.position.y));

							float alpha = m_MapBackground.sprite.texture.GetPixel(textureX, textureY).a;

							KishiTechUnity.KishiTechDebug.KTDebug.Instance().Log("xy(" + x + ", " + y + "), tex(" + textureX + ", " + textureY + "), alpha: " + alpha);

							if (alpha < 0.0001f)
							{
								Close();
							}
						}
						else
						{
							Close();
						}
					}
				}
			}
		}

        //================================================================================
        //
        //================================================================================
        public bool ChangedLocationFromMap
        {
            get { return m_ChangedLocationFromMap; }
            set { m_ChangedLocationFromMap = value; }
        }

	} // public class Map : MonoBehaviour

} // namespace ReaderRabbit