Project/Assets/Scripts/PlayerData/PlayerData.cs

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

using UnityEngine;
using System.Collections;

//================================================================================
//
//================================================================================
namespace ReaderRabbit
{
	//================================================================================
	// Progress report.
	//================================================================================
	public enum ProgressType
	{
		None = 0,
		Unknown,
		Ok,
		Good,
		Wow,
	};

	//================================================================================
	// Videos played ingame.
	//================================================================================
	public enum VideoType
	{
		Introduction = 0,
		CloudNine,
		QueenCumulus,
		ArtGallery,
		Irvin,
		EndGame,
		Quantity,
		// The following two videos are not locked/unlocked because the player cannot play them in Options/Movies screen.
		GameTitle,
		CompanyLogo,
        GotoRaingearIsland,
        GotoEdgeOfCloudNine,
	};

    //================================================================================
    // DowntownCloudNine.
    //================================================================================
    public enum DCN_BackTypeEnum
    {
        // Queen Cumulus will speak different phrases based on the following player actions.
        DidNotVisitIslandFirstTimeOnly = 0,
        DidNotVisitIsland,
        AfterVisitingIslandFirstTimeOnly,
        AfterVisitingIsland,
        AfterVisitingIrvinsHouseFirstTimeOnly,
        AfterVisitingIrvinsHouse,
    };


	//================================================================================
	//
	//================================================================================
	public class PlayerData
	{

		//================================================================================
		// Singleton
		//================================================================================
		private static PlayerData s_Instance = null;
		public static PlayerData Instance()
		{
			if (s_Instance == null)
				s_Instance = new PlayerData();

			return s_Instance;
		}
		
		//================================================================================
		//
		//================================================================================
		const string PRACTICE_MODE_FILENAME = "_practice_mode_";
		private bool m_IsPracticeMode;

		private string m_PlayerName;

		private ItemState[] m_Items;

		private int m_SandwichCount;
		private int m_RedMarbleCount;
		private int m_OrangeMarbleCount;
		private int m_YellowMarbleCount;
		private int m_GreenMarbleCount;
		private int m_BlueMarbleCount;

        private int m_UsedRedMarbleCount;
        private int m_UsedOrangeMarbleCount;
        private int m_UsedYellowMarbleCount;
        private int m_UsedGreenMarbleCount;
        private int m_UsedBlueMarbleCount;

		private bool[] m_Visited;
		private Location m_CurrentLocation;
        private Location m_PreviousLocation;

		// Flags for blocked scenes.
		private bool[] m_BlockedLocation;
		private bool[] BlockedLocation =
		{
			true, //EdgeOfCloudNine,
			true, //CloudNineGateway,
			false, //CloudSpellingChallenge,
			false, //DowntownCloudNine,
			false, //CloudNineArtGallery,
			false, //AmazingArtGallery,
			true, //CloudSheepCrossing,
			false, //NewspaperCarrierScene,
			false, //RaingearIsland,
			false, //IrvinsHouse,
			false, //GumballScience,
			true, //RaingearThrowingMachine,
			false, //MusicalMarblePatterns,
			false, //RaingearForest,
			false, //RaingearForestMath,
			false, //SillySandwichShop,
			true, //RockHead,
			false, //FlowerpotPhonics,
			false, //RaingearRescue,
		};

		// Player levels.
		private int[] m_ActivityLevel;
		private bool[] m_IsActivityLocked;
		private bool[] m_IsActivityAutoLevel;

		private ProgressType[] m_ProgressLevel1;
		private ProgressType[] m_ProgressLevel2;
		private ProgressType[] m_ProgressLevel3;
		private int[] m_RaingearRescueProgressLevels;
		private int m_AmazingArtGalleryPagesCreated;

		private bool[] m_IsVideoLocked;

		private bool m_IsBackgroundMusicEnabled;
		private bool m_IsPrinterEnabled;

        // EdgeOfCloudNine
        private bool m_EOCN_IsSecondTime;
        private bool m_EOCN_IsCloudVisible;

		// CloudSpellingChallenge
		private int m_CSC_WinsCount;

        // CloudNineGateway
        private bool m_CNG_IsFirstClickWelcomeSign;
        private bool m_CNG_IsFirstClickPaigeWithoutBell;
        private bool m_CNG_IsFirstClickPaigeWithBell;
        private bool m_CNG_IsFirstClickPaigeAfterOpeningGate;
        private bool m_CNG_IsFirstClickReaderWithoutBell;
        private bool m_CNG_IsFirstClickReaderWithBell;
        private bool m_CNG_IsFirstClickReaderAfterOpeningGate;

        // DowntownCloudNine
        private DCN_BackTypeEnum m_DCN_BackType;
        private int m_DCN_BackAfterIrvinsHouseQueenSpeech;
        private int m_DCN_EnteredFromCatapultCount;
        private bool m_DCN_IsFirstClickCloudNineArtGallery;
        private bool m_DCN_BackAfterOneItem;
        private bool m_DCN_BackAfterTwoItems;
        private bool m_DCN_BackAfterThreeItems;

        // CloudSheepCrossing
        private bool m_CSC_IsFirstWhistle;
        private bool m_CSC_IsFirstSheepClick;

        // RaingearIslandRainbow
        private int m_RGIR_Direction;

        // NewspaperCarrierScene
        private bool m_NCS_IsSecondTime;
        private bool m_NCS_IsCarryInScene;
        private bool m_NCS_IsFirstClickRainbow;
        private bool m_NCS_IsFirstClickCarry;
        private bool m_NCS_IsFirstTimeWithWagon;

        // IrvinsHouse
        private int m_IH_GameState;
        private int m_IH_ReEntryCount;
        private bool m_IH_IsFirstFromRaingearThrowingMachine;

        // RaingearThrowingMachine
        private int m_RTM_VisitCount;
        private int m_RTM_UsedCatapultCount;
        private bool m_RTM_IsFluffySleeping;
        private bool m_RTM_IsCatapultReady;
        private bool m_RTM_IsFirstSandwich;

        // RockHead
        private int m_RH_GameState;
        private bool m_RH_IsFirstTimeFromRainbow;
        private bool m_RH_DidTalkToRockHead;
        private int m_RH_RockClickCount;

        // CloudNineArtGallery
        private int m_CNAG_GameState;
        private bool m_CNAG_DidSaySS4Speech;
        private bool m_CNAG_DidSayAct4Speech;
        private bool m_CNAG_IsFirstEditSpeech;
        private bool m_CNAG_IsFromSample;
        private int m_CNAG_VisitCount;

        // AmazingArtGallery
        private int m_AAG_NextClickCount;
        private bool m_AAG_PaigeClicked;
        private int m_AAG_Enter1Count;
        private int m_AAG_Enter2Count;
        private int m_AAG_Enter3Count;
        private bool m_AAG_PaintUsed;
        private bool m_AAG_EraseUsed;
        private bool m_AAG_StampUsed;
        private bool m_AAG_FillUsed;
        private bool m_AAG_BombUsed;
        private bool m_AAG_TwoPagesUsed;
        private bool m_AAG_PlayUsed;
		private string m_AAG_framePath; //mycode --rafael

        // RaingearForestMath
        private int m_RFM_RoundsCompleted;

        // FlowerpotPhonics
        private int m_FP_GameState;
        private bool m_FP_WagonHere;

        private Map.MapOpenedType m_MapOpenedType;

        //================================================================================
		//
		//================================================================================
		public PlayerData()
		{
            Reset();
		}

		//================================================================================
		//
		//================================================================================
		public void Reset()
		{
            m_PlayerName = "";

            if (m_Items == null)
                m_Items = new ItemState[(int)ItemEnum.Quantity];
            for (int i = 0; i < (int)ItemEnum.Quantity; ++i)
                m_Items[i] = ItemState.None;

            m_SandwichCount = 0;
            m_RedMarbleCount = 0;
            m_OrangeMarbleCount = 0;
            m_YellowMarbleCount = 0;
            m_GreenMarbleCount = 0;
            m_BlueMarbleCount = 0;

            m_UsedRedMarbleCount = 0;
            m_UsedOrangeMarbleCount = 0;
            m_UsedYellowMarbleCount = 0;
            m_UsedGreenMarbleCount = 0;
            m_UsedBlueMarbleCount = 0;

            if (m_Visited == null)
                m_Visited = new bool[(int)Location.Quantity];
            if (m_BlockedLocation == null)
                m_BlockedLocation = new bool[(int)Location.Quantity];
            for (int i = 0; i < (int)Location.Quantity; ++i)
            {
                m_Visited[i] = false;
                m_BlockedLocation[i] = true;
            }

            m_CurrentLocation = Location.EdgeOfCloudNine;
            m_PreviousLocation = Location.EdgeOfCloudNine;

            if (m_ActivityLevel == null)
                m_ActivityLevel = new int[(int)Activity.Quantity];
            if (m_IsActivityLocked == null)
                m_IsActivityLocked = new bool[(int)Activity.Quantity];
            if (m_IsActivityAutoLevel == null)
                m_IsActivityAutoLevel = new bool[(int)Activity.Quantity];

            for (int i = 0; i < (int)Activity.Quantity; ++i)
            {
                m_ActivityLevel[i] = 1;
                m_IsActivityLocked[i] = true;
                m_IsActivityAutoLevel[i] = true;
            }

            // We don't keep progress of Raingear Rescue and Amazing Art Gallery using ProgressType.
            // Raingear Rescue progress is defined by the number of times the player completed the activity.
            // Amazing Art Gallery progress is defined by the number of pages created in the activity.
            if (m_ProgressLevel1 == null)
                m_ProgressLevel1 = new ProgressType[(int)Activity.Quantity - 2];
            if (m_ProgressLevel2 == null)
                m_ProgressLevel2 = new ProgressType[(int)Activity.Quantity - 2];
            if (m_ProgressLevel3 == null)
                m_ProgressLevel3 = new ProgressType[(int)Activity.Quantity - 2];
            for (int i = 0; i < (int)Activity.Quantity - 2; ++i)
            {
                m_ProgressLevel1[i] = ProgressType.None;
                m_ProgressLevel2[i] = ProgressType.None;
                m_ProgressLevel3[i] = ProgressType.None;
            }

            if (m_RaingearRescueProgressLevels == null)
                m_RaingearRescueProgressLevels = new int[3];
            for (int i = 0; i < 3; ++i)
                m_RaingearRescueProgressLevels[i] = 0;
            m_AmazingArtGalleryPagesCreated = 0;

            if (m_IsVideoLocked == null)
                m_IsVideoLocked = new bool[(int)VideoType.Quantity];
            for (int i = 0; i < (int)VideoType.Quantity; ++i)
                m_IsVideoLocked[i] = true;

            m_IsBackgroundMusicEnabled = true;
            m_IsPrinterEnabled = true;

            ResetSceneSpecificVariables();

            m_MapOpenedType = Map.MapOpenedType.None;
		}

        //================================================================================
        //
        //================================================================================
        void ResetSceneSpecificVariables()
        {
            m_EOCN_IsSecondTime = false;
            m_EOCN_IsCloudVisible = true;

			m_CSC_WinsCount = 0;

            m_CNG_IsFirstClickWelcomeSign = true;
            m_CNG_IsFirstClickPaigeWithoutBell = true;
            m_CNG_IsFirstClickPaigeWithBell = true;
            m_CNG_IsFirstClickPaigeAfterOpeningGate = true;
            m_CNG_IsFirstClickReaderWithoutBell = true;
            m_CNG_IsFirstClickReaderWithBell = true;
            m_CNG_IsFirstClickReaderAfterOpeningGate = true;

            m_DCN_BackType = DCN_BackTypeEnum.DidNotVisitIslandFirstTimeOnly;
            m_DCN_BackAfterIrvinsHouseQueenSpeech = 0;
            m_DCN_EnteredFromCatapultCount = 0;
            m_DCN_IsFirstClickCloudNineArtGallery = true;
            m_DCN_BackAfterOneItem = false;
            m_DCN_BackAfterTwoItems = false;
            m_DCN_BackAfterThreeItems = false;

            m_CSC_IsFirstWhistle = true;
            m_CSC_IsFirstSheepClick = true;

            m_RGIR_Direction = 0;

            m_NCS_IsSecondTime = false;
            m_NCS_IsCarryInScene = true;
            m_NCS_IsFirstClickRainbow = true;
            m_NCS_IsFirstClickCarry = true;
            m_NCS_IsFirstTimeWithWagon = true;

            m_IH_GameState = 1;
            m_IH_ReEntryCount = 0;
            m_IH_IsFirstFromRaingearThrowingMachine = true;

            m_RTM_VisitCount = 0;
            m_RTM_UsedCatapultCount = 0;
            m_RTM_IsFluffySleeping = false;
            m_RTM_IsCatapultReady = false;
            m_RTM_IsFirstSandwich = true;

            m_RH_GameState = 1;
            m_RH_IsFirstTimeFromRainbow = true;
            m_RH_DidTalkToRockHead = false;
            m_RH_RockClickCount = 0;

            m_CNAG_GameState = 1;
            m_CNAG_DidSaySS4Speech = false;
            m_CNAG_DidSayAct4Speech = false;
            m_CNAG_IsFirstEditSpeech = true;
            m_CNAG_IsFromSample = false;
            m_CNAG_VisitCount = 0;

            m_AAG_NextClickCount = 0;
            m_AAG_PaigeClicked = false;
            m_AAG_Enter1Count = 0;
            m_AAG_Enter2Count = 0;
            m_AAG_Enter3Count = 0;
            m_AAG_PaintUsed = false;
            m_AAG_EraseUsed = false;
            m_AAG_StampUsed = false;
            m_AAG_FillUsed = false;
			m_AAG_framePath = ""; //mycode --rafael
            m_AAG_BombUsed = false;
            m_AAG_TwoPagesUsed = false;
            m_AAG_PlayUsed = false;

            m_RFM_RoundsCompleted = 0;

            m_FP_GameState = 1;
            m_FP_WagonHere = false;
        }

		//================================================================================
		//
		//================================================================================
		public bool IsPracticeMode()
		{
			return m_IsPracticeMode;
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetPracticeMode(bool isPracticeMode)
		{
			m_IsPracticeMode = isPracticeMode;

            if (m_IsPracticeMode)
            {
                m_PlayerName = GameStrings.Instance().GetString(GameStringsEnum.PracticeMode);

                for (int i = 0; i < (int)ItemEnum.Quantity; ++i)
                    m_Items[i] = ItemState.None;

                m_SandwichCount = 0;
                m_RedMarbleCount = 0;
                m_OrangeMarbleCount = 0;
                m_YellowMarbleCount = 0;
                m_GreenMarbleCount = 0;
                m_BlueMarbleCount = 0;

                m_UsedRedMarbleCount = 0;
                m_UsedOrangeMarbleCount = 0;
                m_UsedYellowMarbleCount = 0;
                m_UsedGreenMarbleCount = 0;
                m_UsedBlueMarbleCount = 0;

                for (int i = 0; i < (int)Location.Quantity; ++i)
                {
                    m_Visited[i] = false;
                    m_BlockedLocation[i] = true;
                }

                m_CurrentLocation = Location.Quantity;
                m_PreviousLocation = Location.Quantity;

                for (int i = 0; i < (int)Activity.Quantity; ++i)
                {
                    m_ActivityLevel[i] = 1;
                    m_IsActivityLocked[i] = false;
                    m_IsActivityAutoLevel[i] = true;
                }

                for (int i = 0; i < (int)Activity.Quantity - 2; ++i)
                {
                    m_ProgressLevel1[i] = ProgressType.None;
                    m_ProgressLevel2[i] = ProgressType.None;
                    m_ProgressLevel3[i] = ProgressType.None;
                }
                for (int i = 0; i < 3; ++i)
                    m_RaingearRescueProgressLevels[i] = 0;
                m_AmazingArtGalleryPagesCreated = 0;

                // All videos are locked in Practice Mode.
                for (int i = 0; i < (int)VideoType.Quantity; ++i)
                    m_IsVideoLocked[i] = true;

                m_IsBackgroundMusicEnabled = true;
                m_IsPrinterEnabled = true;

                ResetSceneSpecificVariables();
            }
            else
            {
                m_PlayerName = "";
            }
		}

		//================================================================================
		//
		//================================================================================
		public bool IsInActivity(Activity activity)
		{
			switch (activity)
			{
			case Activity.CloudSpellingChallenge:
				return m_CurrentLocation == Location.CloudSpellingChallenge;

			case Activity.RaingearForestMath:
				return m_CurrentLocation == Location.RaingearForestMath;

			case Activity.FlowerpotPhonics:
				return m_CurrentLocation == Location.FlowerpotPhonics;

			case Activity.SillySandwichShop:
				return m_CurrentLocation == Location.SillySandwichShop;
			
			case Activity.MusicalMarblePatterns:
				return m_CurrentLocation == Location.MusicalMarblePatterns;
			
			case Activity.GumballScience:
				return m_CurrentLocation == Location.GumballScience;

			case Activity.RaingearRescue:
				return m_CurrentLocation == Location.RaingearRescue;

			case Activity.AmazingArtGallery:
				return m_CurrentLocation == Location.AmazingArtGallery;
			}

			return false;
		}
		
		//================================================================================
		//
		//================================================================================
		public string GetPlayerName()
		{
			return m_PlayerName;
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetPlayerName(string name)
		{
			m_PlayerName = name;
		}

		//================================================================================
		//
		//================================================================================
		public ItemState GetItemState(int index)
		{
			return m_Items[index];
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetItemState(ItemEnum item)
		{
			return m_Items[(int)item];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetItemState(ItemEnum item, ItemState state)
		{
			m_Items[(int)item] = state;
		}

		//================================================================================
		//
		//================================================================================
		public ItemState GetBell()
		{
			return m_Items[(int)ItemEnum.Bell];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetBell(ItemState state)
		{
			m_Items[(int)ItemEnum.Bell] = state;
		}

		//================================================================================
		//
		//================================================================================
		public ItemState GetWhistle()
		{
			return m_Items[(int)ItemEnum.Whistle];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetWhistle(ItemState state)
		{
			m_Items[(int)ItemEnum.Whistle] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetLadder()
		{
			return m_Items[(int)ItemEnum.Ladder];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetLadder(ItemState state)
		{
			m_Items[(int)ItemEnum.Ladder] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetWagon()
		{
			return m_Items[(int)ItemEnum.Wagon];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetWagon(ItemState state)
		{
			m_Items[(int)ItemEnum.Wagon] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetRubberBand()
		{
			return m_Items[(int)ItemEnum.RubberBand];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetRubberBand(ItemState state)
		{
			m_Items[(int)ItemEnum.RubberBand] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetHat()
		{
			return m_Items[(int)ItemEnum.Hat];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetHat(ItemState state)
		{
			m_Items[(int)ItemEnum.Hat] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetHoop()
		{
			return m_Items[(int)ItemEnum.Hoop];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetHoop(ItemState state)
		{
			m_Items[(int)ItemEnum.Hoop] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetPillow()
		{
			return m_Items[(int)ItemEnum.Pillow];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetPillow(ItemState state)
		{
			m_Items[(int)ItemEnum.Pillow] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetSandwich()
		{
			return m_Items[(int)ItemEnum.Sandwich];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetSandwich(ItemState state)
		{
			m_Items[(int)ItemEnum.Sandwich] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetRedMarble()
		{
			return m_Items[(int)ItemEnum.MarbleRed];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetRedMarble(ItemState state)
		{
			m_Items[(int)ItemEnum.MarbleRed] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetOrangeMarble()
		{
			return m_Items[(int)ItemEnum.MarbleOrange];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetOrangeMarble(ItemState state)
		{
			m_Items[(int)ItemEnum.MarbleOrange] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetYellowMarble()
		{
			return m_Items[(int)ItemEnum.MarbleYellow];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetYellowMarble(ItemState state)
		{
			m_Items[(int)ItemEnum.MarbleYellow] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetGreenMarble()
		{
			return m_Items[(int)ItemEnum.MarbleGreen];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetGreenMarble(ItemState state)
		{
			m_Items[(int)ItemEnum.MarbleGreen] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetBlueMarble()
		{
			return m_Items[(int)ItemEnum.MarbleBlue];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetBlueMarble(ItemState state)
		{
			m_Items[(int)ItemEnum.MarbleBlue] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetRubberBandNone()
		{
			return m_Items[(int)ItemEnum.RubberBandNone];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetRubberBandNone(ItemState state)
		{
			m_Items[(int)ItemEnum.RubberBandNone] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetHoopNone()
		{
			return m_Items[(int)ItemEnum.HoopNone];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetHoopNone(ItemState state)
		{
			m_Items[(int)ItemEnum.HoopNone] = state;
		}
		
		//================================================================================
		//
		//================================================================================
		public ItemState GetPillowNone()
		{
			return m_Items[(int)ItemEnum.PillowNone];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetPillowNone(ItemState state)
		{
			m_Items[(int)ItemEnum.PillowNone] = state;
		}
		

		//================================================================================
		//
		//================================================================================
		public int GetSandwichCount()
		{
			return m_SandwichCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetSandwichCount(int count)
		{
			m_SandwichCount = count;
		}
		
		//================================================================================
		//
		//================================================================================
		public void IncSandwichCount()
		{
			++m_SandwichCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public void DecSandwichCount()
		{
			--m_SandwichCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public int GetRedMarbleCount()
		{
			return m_RedMarbleCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetRedMarbleCount(int count)
		{
			m_RedMarbleCount = count;
		}
		
		//================================================================================
		//
		//================================================================================
		public void IncRedMarbleCount()
		{
			++m_RedMarbleCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public void DecRedMarbleCount()
		{
			--m_RedMarbleCount;
		}

		//================================================================================
		//
		//================================================================================
		public int GetOrangeMarbleCount()
		{
			return m_OrangeMarbleCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetOrangeMarbleCount(int count)
		{
			m_OrangeMarbleCount = count;
		}
		
		//================================================================================
		//
		//================================================================================
		public void IncOrangeMarbleCount()
		{
			++m_OrangeMarbleCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public void DecOrangeMarbleCount()
		{
			--m_OrangeMarbleCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public int GetYellowMarbleCount()
		{
			return m_YellowMarbleCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetYellowMarbleCount(int count)
		{
			m_YellowMarbleCount = count;
		}
		
		//================================================================================
		//
		//================================================================================
		public void IncYellowMarbleCount()
		{
			++m_YellowMarbleCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public void DecYellowMarbleCount()
		{
			--m_YellowMarbleCount;
		}

		//================================================================================
		//
		//================================================================================
		public int GetGreenMarbleCount()
		{
			return m_GreenMarbleCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetGreenMarbleCount(int count)
		{
			m_GreenMarbleCount = count;
		}
		
		//================================================================================
		//
		//================================================================================
		public void IncGreenMarbleCount()
		{
			++m_GreenMarbleCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public void DecGreenMarbleCount()
		{
			--m_GreenMarbleCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public int GetBlueMarbleCount()
		{
			return m_BlueMarbleCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetBlueMarbleCount(int count)
		{
			m_BlueMarbleCount = count;
		}
		
		//================================================================================
		//
		//================================================================================
		public void IncBlueMarbleCount()
		{
			++m_BlueMarbleCount;
		}
		
		//================================================================================
		//
		//================================================================================
		public void DecBlueMarbleCount()
		{
			--m_BlueMarbleCount;
		}


		//================================================================================
		//
		//================================================================================
		public bool DidVisit(int locationIndex)
		{
			return m_Visited[locationIndex];
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisit(Location location)
		{
			return m_Visited[(int)location];
		}

        //================================================================================
        //
        //================================================================================
        public bool DidVisit(SceneIndex sceneIndex)
        {
            switch (sceneIndex)
            {
                case SceneIndex.AmazingArtGallery:
                    return m_Visited[(int)Location.AmazingArtGallery];

                case SceneIndex.CloudNineArtGallery:
                    return m_Visited[(int)Location.CloudNineArtGallery];

                case SceneIndex.CloudNineGateway:
                    return m_Visited[(int)Location.CloudNineGateway];

                case SceneIndex.CloudSheepCrossing:
                    return m_Visited[(int)Location.CloudSheepCrossing];

                case SceneIndex.CloudSpellingChallenge:
                    return m_Visited[(int)Location.CloudSpellingChallenge];

                case SceneIndex.DowntownCloudNine:
                    return m_Visited[(int)Location.DowntownCloudNine];

                case SceneIndex.EdgeOfCloudNine:
                    return m_Visited[(int)Location.EdgeOfCloudNine];

                case SceneIndex.FlowerpotPhonics:
                    return m_Visited[(int)Location.FlowerpotPhonics];

                case SceneIndex.GumballScience:
                    return m_Visited[(int)Location.GumballScience];

                case SceneIndex.IrvinsHouse:
                    return m_Visited[(int)Location.IrvinsHouse];

                case SceneIndex.MusicalMarblePatterns:
                    return m_Visited[(int)Location.MusicalMarblePatterns];

                case SceneIndex.NewspaperCarrierScene:
                    return m_Visited[(int)Location.NewspaperCarrierScene];

                case SceneIndex.RaingearForest:
                    return m_Visited[(int)Location.RaingearForest];

                case SceneIndex.RaingearForestMath:
                    return m_Visited[(int)Location.RaingearForestMath];

                case SceneIndex.RaingearIsland:
                    return m_Visited[(int)Location.RaingearIsland];

                case SceneIndex.RaingearRescue:
                    return m_Visited[(int)Location.RaingearRescue];

                case SceneIndex.RaingearThrowingMachine:
                    return m_Visited[(int)Location.RaingearThrowingMachine];

                case SceneIndex.RockHead:
                    return m_Visited[(int)Location.RockHead];

                case SceneIndex.SillySandwichShop:
                    return m_Visited[(int)Location.SillySandwichShop];
            }

            return false;
        }

        //================================================================================
        //
        //================================================================================
        public bool DidVisit(Activity activity)
        {
            switch (activity)
            {
                case Activity.CloudSpellingChallenge:
                    return m_Visited[(int)Location.CloudSpellingChallenge];

                case Activity.RaingearForestMath:
                    return m_Visited[(int)Location.RaingearForestMath];

                case Activity.FlowerpotPhonics:
                    return m_Visited[(int)Location.FlowerpotPhonics];

                case Activity.SillySandwichShop:
                    return m_Visited[(int)Location.SillySandwichShop];

                case Activity.MusicalMarblePatterns:
                    return m_Visited[(int)Location.MusicalMarblePatterns];

                case Activity.GumballScience:
                    return m_Visited[(int)Location.GumballScience];

                case Activity.RaingearRescue:
                    return m_Visited[(int)Location.RaingearRescue];

                case Activity.AmazingArtGallery:
                    return m_Visited[(int)Location.AmazingArtGallery];
            }

            return false;
        }

		//================================================================================
		//
		//================================================================================
		public void SetVisited(Location location, bool visited)
		{
			m_Visited[(int)location] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitEdgeOfCloudNine()
		{
			return m_Visited[(int)Location.EdgeOfCloudNine];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedEdgeOfCloudNine(bool visited)
		{
			m_Visited[(int)Location.EdgeOfCloudNine] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitCloudNineGateway()
		{
			return m_Visited[(int)Location.CloudNineGateway];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedCloudNineGateway(bool visited)
		{
			m_Visited[(int)Location.CloudNineGateway] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitCloudSpellingChallenge()
		{
			return m_Visited[(int)Location.CloudSpellingChallenge];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedCloudSpellingChallenge(bool visited)
		{
			m_Visited[(int)Location.CloudSpellingChallenge] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitDowntownCloudNine()
		{
			return m_Visited[(int)Location.DowntownCloudNine];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedDowntownCloudNine(bool visited)
		{
			m_Visited[(int)Location.DowntownCloudNine] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitCloudNineArtGallery()
		{
			return m_Visited[(int)Location.CloudNineArtGallery];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedCloudNineArtGallery(bool visited)
		{
			m_Visited[(int)Location.CloudNineArtGallery] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitAmazingArtGallery()
		{
			return m_Visited[(int)Location.AmazingArtGallery];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedAmazingArtGallery(bool visited)
		{
			m_Visited[(int)Location.AmazingArtGallery] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitCloudSheepCrossing()
		{
			return m_Visited[(int)Location.CloudSheepCrossing];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedCloudSheepCrossing(bool visited)
		{
			m_Visited[(int)Location.CloudSheepCrossing] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitNewspaperCarrierScene()
		{
			return m_Visited[(int)Location.NewspaperCarrierScene];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedNewspaperCarrierScene(bool visited)
		{
			m_Visited[(int)Location.NewspaperCarrierScene] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitRaingearIsland()
		{
			return m_Visited[(int)Location.RaingearIsland];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedRaingearIsland(bool visited)
		{
			m_Visited[(int)Location.RaingearIsland] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitIrvinsHouse()
		{
			return m_Visited[(int)Location.IrvinsHouse];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedIrvinsHouse(bool visited)
		{
			m_Visited[(int)Location.IrvinsHouse] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitGumballScience()
		{
			return m_Visited[(int)Location.GumballScience];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedGumballScience(bool visited)
		{
			m_Visited[(int)Location.GumballScience] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitRaingearThrowingMachine()
		{
			return m_Visited[(int)Location.RaingearThrowingMachine];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedRaingearThrowingMachine(bool visited)
		{
			m_Visited[(int)Location.RaingearThrowingMachine] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitMusicalMarblePatterns()
		{
			return m_Visited[(int)Location.MusicalMarblePatterns];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedMusicalMarblePatterns(bool visited)
		{
			m_Visited[(int)Location.MusicalMarblePatterns] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitRaingearForest()
		{
			return m_Visited[(int)Location.RaingearForest];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedRaingearForest(bool visited)
		{
			m_Visited[(int)Location.RaingearForest] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitRaingearForestMath()
		{
			return m_Visited[(int)Location.RaingearForestMath];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedRaingearForestMath(bool visited)
		{
			m_Visited[(int)Location.RaingearForestMath] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitSillySandwichShop()
		{
			return m_Visited[(int)Location.SillySandwichShop];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedSillySandwichShop(bool visited)
		{
			m_Visited[(int)Location.SillySandwichShop] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitRockHead()
		{
			return m_Visited[(int)Location.RockHead];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedRockHead(bool visited)
		{
			m_Visited[(int)Location.RockHead] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitFlowerpotPhonics()
		{
			return m_Visited[(int)Location.FlowerpotPhonics];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedFlowerpotPhonics(bool visited)
		{
			m_Visited[(int)Location.FlowerpotPhonics] = visited;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool DidVisitRaingearRescue()
		{
			return m_Visited[(int)Location.RaingearRescue];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetVisitedRaingearRescue(bool visited)
		{
			m_Visited[(int)Location.RaingearRescue] = visited;
		}


		//================================================================================
		//
		//================================================================================
		public Location GetCurrentLocation()
		{
			return m_CurrentLocation;
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetCurrentLocation(Location location)
		{
            m_PreviousLocation = m_CurrentLocation;
			m_CurrentLocation = location;
		}

        //================================================================================
        //
        //================================================================================
        public Location GetPreviousLocation()
        {
            return m_PreviousLocation;
        }


		//================================================================================
		//
		//================================================================================
		public bool MustUnblock(Location location)
		{
			return BlockedLocation[(int)location];
		}
		
		//================================================================================
		//
		//================================================================================
		public bool IsLocationBlocked(Location location)
		{
			return m_BlockedLocation[(int)location];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetLocationBlocked(Location location, bool blocked)
		{
			m_BlockedLocation[(int)location] = blocked;
		}
		
		//================================================================================
		//
		//================================================================================
		public void BlockLocation(Location location)
		{
			m_BlockedLocation[(int)location] = true;
		}
		
		//================================================================================
		//
		//================================================================================
		public void UnblockLocation(Location location)
		{
			m_BlockedLocation[(int)location] = false;
		}
		
		
		//================================================================================
		//
		//================================================================================
		public int GetActivityLevel(Activity activity)
		{
			return m_ActivityLevel[(int)activity];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetActivityLevel(Activity activity, int level)
		{
			m_ActivityLevel[(int)activity] = level;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool IsActivityLocked(Activity activity)
		{
			return m_IsActivityLocked[(int)activity];
		}
		
		//================================================================================
		//
		//================================================================================
		public void LockActivity(Activity activity)
		{
			m_IsActivityLocked[(int)activity] = true;
		}
		
		//================================================================================
		//
		//================================================================================
		public void UnlockActivity(Activity activity)
		{
			m_IsActivityLocked[(int)activity] = false;
		}
		
		//================================================================================
		//
		//================================================================================
		public void ToggleActivityLocked(Activity activity)
		{
			m_IsActivityLocked[(int)activity] = !m_IsActivityLocked[(int)activity];
		}	
		
		//================================================================================
		//
		//================================================================================
		public bool IsActivityAutoLevel(Activity activity)
		{
			return m_IsActivityAutoLevel[(int)activity];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetActivityAutoLevel(Activity activity, bool isAutoLevel)
		{
			m_IsActivityAutoLevel[(int)activity] = isAutoLevel;
		}
		
		//================================================================================
		//
		//================================================================================
		public void ToggleActivityAutoLevel(Activity activity)
		{
			m_IsActivityAutoLevel[(int)activity] = !m_IsActivityAutoLevel[(int)activity];
		}
		

		//================================================================================
		//
		//================================================================================
		public ProgressType GetProgressTypeLevel1(Activity activity)
		{
			return m_ProgressLevel1[(int)activity];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetProgressTypeLevel1(Activity activity, ProgressType progressType)
		{
			m_ProgressLevel1[(int)activity] = progressType;
		}
		
		//================================================================================
		//
		//================================================================================
		public ProgressType GetProgressTypeLevel2(Activity activity)
		{
			return m_ProgressLevel2[(int)activity];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetProgressTypeLevel2(Activity activity, ProgressType progressType)
		{
			m_ProgressLevel2[(int)activity] = progressType;
		}
		
		//================================================================================
		//
		//================================================================================
		public ProgressType GetProgressTypeLevel3(Activity activity)
		{
			return m_ProgressLevel3[(int)activity];
		}
		
		//================================================================================
		//
		//================================================================================
		public void SetProgressTypeLevel3(Activity activity, ProgressType progressType)
		{
			m_ProgressLevel3[(int)activity] = progressType;
		}

		//================================================================================
		//
		//================================================================================
		public int GetRaingearRescueProgress(int level)
		{
			return m_RaingearRescueProgressLevels[level];
		}
		
		//================================================================================
		//
		//================================================================================
		public void IncRaingearRescueProgress(int level)
		{
			++m_RaingearRescueProgressLevels[level];
		}
		
		//================================================================================
		//
		//================================================================================
		public int GetAmazingArtGalleryPagesCreated()
		{
			return m_AmazingArtGalleryPagesCreated;
		}
		
		//================================================================================
		// We consider that a page is created only when the player first modify it.
		// If the player go to "next" page but does nothing on the new page, we do not
		// count it as a new page created.
		//================================================================================
		public void IncAmazingArtGalleryPagesCreated()
		{
			++m_AmazingArtGalleryPagesCreated;
		}


		//================================================================================
		//
		//================================================================================
		public bool IsVideoLocked(VideoType video)
		{
			return m_IsVideoLocked[(int)video];
		}
		
		//================================================================================
		//
		//================================================================================
		public void LockVideo(VideoType video)
		{
			m_IsVideoLocked[(int)video] = true;
		}
		
		//================================================================================
		//
		//================================================================================
		public void UnlockVideo(VideoType video)
		{
			m_IsVideoLocked[(int)video] = false;
		}
		
		//================================================================================
		//
		//================================================================================
		public void ToggleVideoLocked(VideoType video)
		{
			m_IsVideoLocked[(int)video] = !m_IsVideoLocked[(int)video];
		}


		//================================================================================
		//
		//================================================================================
		public bool IsBackgroundMusicEnabled()
		{
			return m_IsBackgroundMusicEnabled;
		}
		
		//================================================================================
		//
		//================================================================================
		public void EnableBackgroundMusic()
		{
			m_IsBackgroundMusicEnabled = true;
		}
		
		//================================================================================
		//
		//================================================================================
		public void DisableBackgroundMusic()
		{
			m_IsBackgroundMusicEnabled = false;
		}
		
		//================================================================================
		//
		//================================================================================
		public void ToggleBackgroundMusic()
		{
			m_IsBackgroundMusicEnabled = !m_IsBackgroundMusicEnabled;
		}
		
		//================================================================================
		//
		//================================================================================
		public bool IsPrinterEnabled()
		{
			return m_IsPrinterEnabled;
		}
		
		//================================================================================
		//
		//================================================================================
		public void EnablePrinter()
		{
			m_IsPrinterEnabled = true;
		}
		
		//================================================================================
		//
		//================================================================================
		public void DisablePrinter()
		{
			m_IsPrinterEnabled = false;
		}
		
		//================================================================================
		//
		//================================================================================
		public void TogglePrinter()
		{
			m_IsPrinterEnabled = !m_IsPrinterEnabled;
		}


        //================================================================================
        // EdgeOfCloudNine
        //================================================================================
        public bool EOCN_IsSecondTime
        {
            get { return m_EOCN_IsSecondTime; }
            set { m_EOCN_IsSecondTime = value; }
        }

        public bool EOCN_IsCloudVisible
        {
            get { return m_EOCN_IsCloudVisible; }
            set { m_EOCN_IsCloudVisible = value; }
        }

		//================================================================================
		// CloudSpellingChallenge
		//================================================================================
		
		public int CSC_WinsCount{
			get { return m_CSC_WinsCount; }
			set { m_CSC_WinsCount = value; }
		}

        //================================================================================
        // CloudNineGateway
        //================================================================================
        public bool CNG_IsFirstClickWelcomeSign
        {
            get { return m_CNG_IsFirstClickWelcomeSign; }
            set { m_CNG_IsFirstClickWelcomeSign = value; }
        }

        public bool CNG_IsFirstClickPaigeWithoutBell
        {
            get { return m_CNG_IsFirstClickPaigeWithoutBell; }
            set { m_CNG_IsFirstClickPaigeWithoutBell = value; }
        }

        public bool CNG_IsFirstClickPaigeWithBell
        {
            get { return m_CNG_IsFirstClickPaigeWithBell; }
            set { m_CNG_IsFirstClickPaigeWithBell = value; }
        }

        public bool CNG_IsFirstClickPaigeAfterOpeningGate
        {
            get { return m_CNG_IsFirstClickPaigeAfterOpeningGate; }
            set { m_CNG_IsFirstClickPaigeAfterOpeningGate = value; }
        }

        public bool CNG_IsFirstClickReaderWithoutBell
        {
            get { return m_CNG_IsFirstClickReaderWithoutBell; }
            set { m_CNG_IsFirstClickReaderWithoutBell = value; }
        }

        public bool CNG_IsFirstClickReaderWithBell
        {
            get { return m_CNG_IsFirstClickReaderWithBell; }
            set { m_CNG_IsFirstClickReaderWithBell = value; }
        }

        public bool CNG_IsFirstClickReaderAfterOpeningGate
        {
            get { return m_CNG_IsFirstClickReaderAfterOpeningGate; }
            set { m_CNG_IsFirstClickReaderAfterOpeningGate = value; }
        }

        //================================================================================
        // DowntownCloudNine
        //================================================================================
        public DCN_BackTypeEnum DCN_BackType
        {
            get { return m_DCN_BackType; }
            set { m_DCN_BackType = value; }
        }

        public int DCN_BackAfterIrvinsHouseQueenSpeech
        {
            get { return m_DCN_BackAfterIrvinsHouseQueenSpeech; }
            set { m_DCN_BackAfterIrvinsHouseQueenSpeech = value; }
        }

        public int DCN_EnteredFromCatapult
        {
            get { return m_DCN_EnteredFromCatapultCount; }
            set { m_DCN_EnteredFromCatapultCount = value; }
        }

        public bool DCN_IsFirstClickCloudNineArtGallery
        {
            get { return m_DCN_IsFirstClickCloudNineArtGallery; }
            set { m_DCN_IsFirstClickCloudNineArtGallery = value; }
        }

        public bool DCN_BackAfterOneItem
        {
            get { return m_DCN_BackAfterOneItem; }
            set { m_DCN_BackAfterOneItem = value; }
        }

        public bool DCN_BackAfterTwoItems
        {
            get { return m_DCN_BackAfterTwoItems; }
            set { m_DCN_BackAfterTwoItems = value; }
        }

        public bool DCN_BackAfterThreeItems
        {
            get { return m_DCN_BackAfterThreeItems; }
            set { m_DCN_BackAfterThreeItems = value; }
        }

        public void DCN_VisitedRaingearIsland()
        {
            if (m_DCN_BackType == DCN_BackTypeEnum.DidNotVisitIslandFirstTimeOnly || m_DCN_BackType == DCN_BackTypeEnum.DidNotVisitIsland)
                m_DCN_BackType = DCN_BackTypeEnum.AfterVisitingIslandFirstTimeOnly;
        }

        public void DCN_VisitedIrvinsHouse()
        {
            if (m_DCN_BackType != DCN_BackTypeEnum.AfterVisitingIrvinsHouseFirstTimeOnly && m_DCN_BackType != DCN_BackTypeEnum.AfterVisitingIrvinsHouse)
                m_DCN_BackType = DCN_BackTypeEnum.AfterVisitingIrvinsHouseFirstTimeOnly;
        }

        //================================================================================
        // CloudSheepCrossing
        //================================================================================
        public bool CSC_IsFirstWhistle
        {
            get { return m_CSC_IsFirstWhistle; }
            set { m_CSC_IsFirstWhistle = value; }
        }

        public bool CSC_IsFirstSheepClick
        {
            get { return m_CSC_IsFirstSheepClick; }
            set { m_CSC_IsFirstSheepClick = value; }
        }

        //================================================================================
        // RaingearIsland
        //================================================================================
        public int RGIR_Direction
        {
            get { return m_RGIR_Direction; }
            set { m_RGIR_Direction = value; }
        }

        //================================================================================
        // NewspaperCarrierScene
        //================================================================================
        public bool NCS_IsSecondTime
        {
            get { return m_NCS_IsSecondTime; }
            set { m_NCS_IsSecondTime = value; }
        }

        public bool NCS_IsCarryInScene
        {
            get { return m_NCS_IsCarryInScene; }
            set { m_NCS_IsCarryInScene = value; }
        }

        public bool NCS_IsFirstClickRainbow
        {
            get { return m_NCS_IsFirstClickRainbow; }
            set { m_NCS_IsFirstClickRainbow = value; }
        }

        public bool NCS_IsFirstClickCarry
        {
            get { return m_NCS_IsFirstClickCarry; }
            set { m_NCS_IsFirstClickCarry = value; }
        }

        public bool NCS_IsFirstTimeWithWagon
        {
            get { return m_NCS_IsFirstTimeWithWagon; }
            set { m_NCS_IsFirstTimeWithWagon = value; }
        }

        //================================================================================
        // IrvinsHouse
        //================================================================================
        public int IH_GameState
        {
            get { return m_IH_GameState; }
            set { m_IH_GameState = value; }
        }

        public int IH_ReEntryCount
        {
            get { return m_IH_ReEntryCount; }
            set { m_IH_ReEntryCount = value; }
        }

        public bool IH_IsFirstFromRaingearThrowingMachine
        {
            get { return m_IH_IsFirstFromRaingearThrowingMachine; }
            set { m_IH_IsFirstFromRaingearThrowingMachine = value; }
        }

        //================================================================================
        // RaingearThrowingMachine
        //================================================================================
        public int RTM_VisitCount
        {
            get { return m_RTM_VisitCount; }
            set { m_RTM_VisitCount = value; }
        }

        public int RTM_UsedCatapultCount
        {
            get { return m_RTM_UsedCatapultCount; }
            set { m_RTM_UsedCatapultCount = value; }
        }

        public bool RTM_IsFluffySleeping
        {
            get { return m_RTM_IsFluffySleeping; }
            set { m_RTM_IsFluffySleeping = value; }
        }
        
        public bool RTM_IsCatapultReady
        {
            get { return m_RTM_IsCatapultReady; }
            set { m_RTM_IsCatapultReady = value; }
        }

        public bool RTM_IsFirstSandwich
        {
            get { return m_RTM_IsFirstSandwich; }
            set { m_RTM_IsFirstSandwich = value; }
        }

        //================================================================================
        // RockHead
        //================================================================================
        public int RH_GameState
        {
            get { return m_RH_GameState; }
            set { m_RH_GameState = value; }
        }

        public bool RH_IsFirstTimeFromRainbow
        {
            get { return m_RH_IsFirstTimeFromRainbow; }
            set { m_RH_IsFirstTimeFromRainbow = value; }
        }

        public bool RH_DidTalkToRockHead
        {
            get { return m_RH_DidTalkToRockHead; }
            set { m_RH_DidTalkToRockHead = value; }
        }

        public int RH_RockClickCount
        {
            get { return m_RH_RockClickCount; }
            set { m_RH_RockClickCount = value; }
        }

        //================================================================================
        // CloudNineArtGallery
        //================================================================================
        public int CNAG_GameState
        {
            get { return m_CNAG_GameState; }
            set { m_CNAG_GameState = value; }
        }

        public bool CNAG_DidSaySS4Speech
        {
            get { return m_CNAG_DidSaySS4Speech; }
            set { m_CNAG_DidSaySS4Speech = value; }
        }

        public bool CNAG_DidSayAct4Speech
        {
            get { return m_CNAG_DidSayAct4Speech; }
            set { m_CNAG_DidSayAct4Speech = value; }
        }

        public bool CNAG_IsFirstEditSpeech
        {
            get { return m_CNAG_IsFirstEditSpeech; }
            set { m_CNAG_IsFirstEditSpeech = value; }
        }

        public bool CNAG_IsFromSample
        {
            get { return m_CNAG_IsFromSample; }
            set { m_CNAG_IsFromSample = value; }
        }

        public int CNAG_VisitCount
        {
            get { return m_CNAG_VisitCount; }
            set { m_CNAG_VisitCount = value; }
        }

        //================================================================================
        // AmazingArtGallery
        //================================================================================
        public int AAG_NextClickCount
        {
            get { return m_AAG_NextClickCount; }
            set { m_AAG_NextClickCount = value; }
        }

        public bool AAG_PaigeClicked
        {
            get { return m_AAG_PaigeClicked; }
            set { m_AAG_PaigeClicked = value; }
        }

        public int AAG_Enter1Count
        {
            get { return m_AAG_Enter1Count; }
            set { m_AAG_Enter1Count = value; }
        }

        public int AAG_Enter2Count
        {
            get { return m_AAG_Enter2Count; }
            set { m_AAG_Enter2Count = value; }
        }

        public int AAG_Enter3Count
        {
            get { return m_AAG_Enter3Count; }
            set { m_AAG_Enter3Count = value; }
        }

        public bool AAG_PaintUsed
        {
            get { return m_AAG_PaintUsed; }
            set { m_AAG_PaintUsed = value; }
        }

        public bool AAG_EraseUsed
        {
            get { return m_AAG_EraseUsed; }
            set { m_AAG_EraseUsed = value; }
        }

        public bool AAG_StampUsed
        {
            get { return m_AAG_StampUsed; }
            set { m_AAG_StampUsed = value; }
        }

        public bool AAG_FillUsed
        {
            get { return m_AAG_FillUsed; }
            set { m_AAG_FillUsed = value; }
        }

		public string AAG_framePath //mycode --rafael
		{
			get { return m_AAG_framePath;}
			set { m_AAG_framePath = value;}
		}

        public bool AAG_BombUsed
        {
            get { return m_AAG_BombUsed; }
            set { m_AAG_BombUsed = value; }
        }

        public bool AAG_TwoPagesUsed
        {
            get { return m_AAG_TwoPagesUsed; }
            set { m_AAG_TwoPagesUsed = value; }
        }

        public bool AAG_PlayUsed
        {
            get { return m_AAG_PlayUsed; }
            set { m_AAG_PlayUsed = value; }
        }

        //================================================================================
        // RaingearForestMath
        //================================================================================
        public int RFM_RoundsCompleted
        {
            get { return m_RFM_RoundsCompleted; }
            set { m_RFM_RoundsCompleted = value; }
        }
        
        //================================================================================
        // FlowerpotPhonics
        //================================================================================
        public int FP_GameState
        {
            get { return m_FP_GameState; }
            set { m_FP_GameState = value; }
        }

        public bool FP_WagonHere
        {
            get { return m_FP_WagonHere; }
            set { m_FP_WagonHere = value; }
        }

        //================================================================================
        //
        //================================================================================
        public Map.MapOpenedType CurrentMapOpenedType
        {
            get { return m_MapOpenedType; }
            set { m_MapOpenedType = value; }
        }

        //================================================================================
		//
		//================================================================================
		public bool LoadData()
		{
			KishiTechUnity.KishiTechDebug.KTDebug.Instance().Log("Calling PlayerData.LoadData()...");
			KishiTechUnity.KishiTechDebug.KTDebug.Instance().Log("Persistent data path: " + Application.persistentDataPath);
			KishiTechUnity.KishiTechDebug.KTDebug.Instance().Log("Player name is " + m_PlayerName);

			string playerName = m_IsPracticeMode ? PRACTICE_MODE_FILENAME : m_PlayerName;

			if (ES2.Exists(playerName + ".dat"))
			{
				// Loading data sequentially (without tags) for faster save/load data - loading must be in the same sequence.
				using(ES2Reader reader = ES2Reader.Create(playerName + ".dat"))
				{
					reader.Read<string>(); // We don't need to save player name, since we already got that in sign-in screen.
					for (int i = 0; i < (int)ItemEnum.Quantity; ++i)
						m_Items[i] = (ItemState)reader.Read<int>();
					m_SandwichCount = reader.Read<int>();
					m_RedMarbleCount = reader.Read<int>();
					m_OrangeMarbleCount = reader.Read<int>();
					m_YellowMarbleCount = reader.Read<int>();
					m_GreenMarbleCount = reader.Read<int>();
					m_BlueMarbleCount = reader.Read<int>();
                    m_UsedRedMarbleCount = reader.Read<int>();
                    m_UsedOrangeMarbleCount = reader.Read<int>();
                    m_UsedYellowMarbleCount = reader.Read<int>();
                    m_UsedGreenMarbleCount = reader.Read<int>();
                    m_UsedBlueMarbleCount = reader.Read<int>();
                    m_Visited = reader.ReadArray<bool>();
					m_CurrentLocation = (Location)reader.Read<int>();
                    m_PreviousLocation = (Location)reader.Read<int>();
					m_BlockedLocation = reader.ReadArray<bool>();
					m_ActivityLevel = reader.ReadArray<int>();
					m_IsActivityLocked = reader.ReadArray<bool>();
					m_IsActivityAutoLevel = reader.ReadArray<bool>();
					for (int i = 0; i < (int)Activity.Quantity - 2; ++i)
					{
						m_ProgressLevel1[i] = (ProgressType)reader.Read<int>();
						m_ProgressLevel2[i] = (ProgressType)reader.Read<int>();
						m_ProgressLevel3[i] = (ProgressType)reader.Read<int>();
					}
					m_RaingearRescueProgressLevels = reader.ReadArray<int>();
					m_AmazingArtGalleryPagesCreated = reader.Read<int>();
					m_IsVideoLocked = reader.ReadArray<bool>();
					m_IsBackgroundMusicEnabled = reader.Read<bool>();
					m_IsPrinterEnabled = reader.Read<bool>();
                    m_EOCN_IsSecondTime = reader.Read<bool>();
                    m_EOCN_IsCloudVisible = reader.Read<bool>();
					m_CSC_WinsCount = reader.Read<int>();
                    m_CNG_IsFirstClickWelcomeSign = reader.Read<bool>();
                    m_CNG_IsFirstClickPaigeWithoutBell = reader.Read<bool>();
                    m_CNG_IsFirstClickPaigeWithBell = reader.Read<bool>();
                    m_CNG_IsFirstClickPaigeAfterOpeningGate = reader.Read<bool>();
                    m_CNG_IsFirstClickReaderWithoutBell = reader.Read<bool>();
                    m_CNG_IsFirstClickReaderWithBell = reader.Read<bool>();
                    m_CNG_IsFirstClickReaderAfterOpeningGate = reader.Read<bool>();
                    m_DCN_BackType = (DCN_BackTypeEnum)reader.Read<int>();
                    m_DCN_BackAfterIrvinsHouseQueenSpeech = reader.Read<int>();
                    m_DCN_EnteredFromCatapultCount = reader.Read<int>();
                    m_DCN_IsFirstClickCloudNineArtGallery = reader.Read<bool>();
                    m_DCN_BackAfterOneItem = reader.Read<bool>();
                    m_DCN_BackAfterTwoItems = reader.Read<bool>();
                    m_DCN_BackAfterThreeItems = reader.Read<bool>();
                    m_CSC_IsFirstWhistle = reader.Read<bool>();
                    m_CSC_IsFirstSheepClick = reader.Read<bool>();
                    m_RGIR_Direction = reader.Read<int>();
                    m_NCS_IsSecondTime = reader.Read<bool>();
                    m_NCS_IsCarryInScene = reader.Read<bool>();
                    m_NCS_IsFirstClickRainbow = reader.Read<bool>();
                    m_NCS_IsFirstClickCarry = reader.Read<bool>();
                    m_NCS_IsFirstTimeWithWagon = reader.Read<bool>();
                    m_IH_GameState = reader.Read<int>();
                    m_IH_ReEntryCount = reader.Read<int>();
                    m_IH_IsFirstFromRaingearThrowingMachine = reader.Read<bool>();
                    m_RTM_VisitCount = reader.Read<int>();
                    m_RTM_UsedCatapultCount = reader.Read<int>();
                    m_RTM_IsFluffySleeping = reader.Read<bool>();
                    m_RTM_IsCatapultReady = reader.Read<bool>();
                    m_RTM_IsFirstSandwich = reader.Read<bool>();
                    m_RH_GameState = reader.Read<int>();
                    m_RH_IsFirstTimeFromRainbow = reader.Read<bool>();
                    m_RH_DidTalkToRockHead = reader.Read<bool>();
                    m_RH_RockClickCount = reader.Read<int>();
                    m_CNAG_GameState = reader.Read<int>();
                    m_CNAG_DidSaySS4Speech = reader.Read<bool>();
                    m_CNAG_DidSayAct4Speech = reader.Read<bool>();
                    m_CNAG_IsFirstEditSpeech = reader.Read<bool>();
                    m_CNAG_IsFromSample = reader.Read<bool>();
                    m_CNAG_VisitCount = reader.Read<int>();
                    m_AAG_NextClickCount = reader.Read<int>();
                    m_AAG_PaigeClicked = reader.Read<bool>();
                    m_AAG_Enter1Count = reader.Read<int>();
                    m_AAG_Enter2Count = reader.Read<int>();
                    m_AAG_Enter3Count = reader.Read<int>();
                    m_AAG_PaintUsed = reader.Read<bool>();
                    m_AAG_EraseUsed = reader.Read<bool>();
                    m_AAG_StampUsed = reader.Read<bool>();
                    m_AAG_FillUsed = reader.Read<bool>();
					m_AAG_framePath = reader.Read<string>(); //mycode --rafael
                    m_AAG_BombUsed = reader.Read<bool>();
                    m_AAG_TwoPagesUsed = reader.Read<bool>();
                    m_AAG_PlayUsed = reader.Read<bool>();
                    m_RFM_RoundsCompleted = reader.Read<int>();
                    m_FP_GameState = reader.Read<int>();
                    m_FP_WagonHere = reader.Read<bool>();
                    m_MapOpenedType = (Map.MapOpenedType)reader.Read<int>();
                }

				return true;
			}

			KishiTechUnity.KishiTechDebug.KTDebug.Instance().Log("There is no save data for \'" + m_PlayerName + "\'!");
			return false;

			/*
			for (int i = 0; i < (int)ItemEnum.Quantity; ++i)
				m_Items[i] = (ItemState)ES2.Load<int>(m_PlayerName + ".dat?tag=it" + i);

			m_SandwichCount = ES2.Load<int>(m_PlayerName + ".dat?tag=sa");
			m_RedMarbleCount = ES2.Load<int>(m_PlayerName + ".dat?tag=re");
			m_OrangeMarbleCount = ES2.Load<int>(m_PlayerName + ".dat?tag=or");
			m_YellowMarbleCount = ES2.Load<int>(m_PlayerName + ".dat?tag=ye");
			m_GreenMarbleCount = ES2.Load<int>(m_PlayerName + ".dat?tag=gr");
			m_BlueMarbleCount = ES2.Load<int>(m_PlayerName + ".dat?tag=bl");
			
			for (int i = 0; i < (int)Location.Quantity; ++i)
				m_Visited[i] = ES2.Load<bool>(m_PlayerName + ".dat?tag=vi" + i);
			
			m_CurrentLocation = (Location)ES2.Load<int>(m_PlayerName + ".dat?tag=cu");
			
			m_IsCloudVisible = ES2.Load<bool>(m_PlayerName + ".dat?tag=is");
			
			for (int i = 0; i < (int)Location.Quantity; ++i)
				m_Blocked[i] = ES2.Load<bool>(m_PlayerName + ".dat?tag=bl" + i);
			*/
		}
		
		//================================================================================
		//
		//================================================================================
		public void SaveData()
		{
			KishiTechUnity.KishiTechDebug.KTDebug.Instance().Log("Calling PlayerData.SaveData()...");
			KishiTechUnity.KishiTechDebug.KTDebug.Instance().Log("Persistent data path: " + Application.persistentDataPath);
			KishiTechUnity.KishiTechDebug.KTDebug.Instance().Log("Player name is " + m_PlayerName);

			string playerName = m_IsPracticeMode ? PRACTICE_MODE_FILENAME : m_PlayerName;

			// Saving data sequentially (without tags) for faster save/load data - loading must be in the same sequence.
			using(ES2Writer writer = ES2Writer.Create(playerName + ".dat"))
			{
				writer.Write(m_PlayerName);
				for (int i = 0; i < (int)ItemEnum.Quantity; ++i)
					writer.Write((int)m_Items[i]);
				writer.Write(m_SandwichCount);
				writer.Write(m_RedMarbleCount);
				writer.Write(m_OrangeMarbleCount);
				writer.Write(m_YellowMarbleCount);
				writer.Write(m_GreenMarbleCount);
				writer.Write(m_BlueMarbleCount);
                writer.Write(m_UsedRedMarbleCount);
                writer.Write(m_UsedOrangeMarbleCount);
                writer.Write(m_UsedYellowMarbleCount);
                writer.Write(m_UsedGreenMarbleCount);
                writer.Write(m_UsedBlueMarbleCount);
                writer.Write(m_Visited);
				writer.Write((int)m_CurrentLocation);
                writer.Write((int)m_PreviousLocation);
				writer.Write(m_BlockedLocation);
				writer.Write(m_ActivityLevel);
				writer.Write(m_IsActivityLocked);
				writer.Write(m_IsActivityAutoLevel);
				for (int i = 0; i < (int)Activity.Quantity - 2; ++i)
				{
					writer.Write((int)m_ProgressLevel1[i]);
					writer.Write((int)m_ProgressLevel2[i]);
					writer.Write((int)m_ProgressLevel3[i]);
				}
				writer.Write(m_RaingearRescueProgressLevels);
				writer.Write(m_AmazingArtGalleryPagesCreated);
				writer.Write(m_IsVideoLocked);
				writer.Write(m_IsBackgroundMusicEnabled);
				writer.Write(m_IsPrinterEnabled);
                writer.Write(m_EOCN_IsSecondTime);
                writer.Write(m_EOCN_IsCloudVisible);
				writer.Write(m_CSC_WinsCount);
                writer.Write(m_CNG_IsFirstClickWelcomeSign);
                writer.Write(m_CNG_IsFirstClickPaigeWithoutBell);
                writer.Write(m_CNG_IsFirstClickPaigeWithBell);
                writer.Write(m_CNG_IsFirstClickPaigeAfterOpeningGate);
                writer.Write(m_CNG_IsFirstClickReaderWithoutBell);
                writer.Write(m_CNG_IsFirstClickReaderWithBell);
                writer.Write(m_CNG_IsFirstClickReaderAfterOpeningGate);
                writer.Write((int)m_DCN_BackType);
                writer.Write(m_DCN_BackAfterIrvinsHouseQueenSpeech);
                writer.Write(m_DCN_EnteredFromCatapultCount);
                writer.Write(m_DCN_IsFirstClickCloudNineArtGallery);
                writer.Write(m_DCN_BackAfterOneItem);
                writer.Write(m_DCN_BackAfterTwoItems);
                writer.Write(m_DCN_BackAfterThreeItems);
                writer.Write(m_CSC_IsFirstWhistle);
                writer.Write(m_CSC_IsFirstSheepClick);
                writer.Write(m_RGIR_Direction);
                writer.Write(m_NCS_IsSecondTime);
                writer.Write(m_NCS_IsCarryInScene);
                writer.Write(m_NCS_IsFirstClickRainbow);
                writer.Write(m_NCS_IsFirstClickCarry);
                writer.Write(m_NCS_IsFirstTimeWithWagon);
                writer.Write(m_IH_GameState);
                writer.Write(m_IH_ReEntryCount);
                writer.Write(m_IH_IsFirstFromRaingearThrowingMachine);
                writer.Write(m_RTM_VisitCount);
                writer.Write(m_RTM_UsedCatapultCount);
                writer.Write(m_RTM_IsFluffySleeping);
                writer.Write(m_RTM_IsCatapultReady);
                writer.Write(m_RTM_IsFirstSandwich);
                writer.Write(m_RH_GameState);
                writer.Write(m_RH_IsFirstTimeFromRainbow);
                writer.Write(m_RH_DidTalkToRockHead);
                writer.Write(m_RH_RockClickCount);
                writer.Write(m_CNAG_GameState);
                writer.Write(m_CNAG_DidSaySS4Speech);
                writer.Write(m_CNAG_DidSayAct4Speech);
                writer.Write(m_CNAG_IsFirstEditSpeech);
                writer.Write(m_CNAG_IsFromSample);
                writer.Write(m_CNAG_VisitCount);
                writer.Write(m_AAG_NextClickCount);
                writer.Write(m_AAG_PaigeClicked);
                writer.Write(m_AAG_Enter1Count);
                writer.Write(m_AAG_Enter2Count);
                writer.Write(m_AAG_Enter3Count);
                writer.Write(m_AAG_PaintUsed);
                writer.Write(m_AAG_EraseUsed);
                writer.Write(m_AAG_StampUsed);
                writer.Write(m_AAG_FillUsed);
				writer.Write(m_AAG_framePath); //mycode --rafael
                writer.Write(m_AAG_BombUsed);
                writer.Write(m_AAG_TwoPagesUsed);
                writer.Write(m_AAG_PlayUsed);
                writer.Write(m_RFM_RoundsCompleted);
                writer.Write(m_FP_GameState);
                writer.Write(m_FP_WagonHere);
                writer.Write((int)m_MapOpenedType);

                writer.Save(false); // false means we are not using tags, since we are saving data sequentially.
			}

			/*
			ES2.Save(m_PlayerName, m_PlayerName + ".dat?tag=pl");

			for (int i = 0; i < (int)ItemEnum.Quantity; ++i)
				ES2.Save((int)m_Items[i], m_PlayerName + ".dat?tag=it" + i);

			ES2.Save(m_SandwichCount, m_PlayerName + ".dat?tag=sa");
			ES2.Save(m_RedMarbleCount, m_PlayerName + ".dat?tag=re");
			ES2.Save(m_OrangeMarbleCount, m_PlayerName + ".dat?tag=or");
			ES2.Save(m_YellowMarbleCount, m_PlayerName + ".dat?tag=ye");
			ES2.Save(m_GreenMarbleCount, m_PlayerName + ".dat?tag=gr");
			ES2.Save(m_BlueMarbleCount, m_PlayerName + ".dat?tag=bl");

			for (int i = 0; i < (int)Location.Quantity; ++i)
				ES2.Save(m_Visited[i], m_PlayerName + ".dat?tag=vi" + i);

			ES2.Save((int)m_CurrentLocation, m_PlayerName + ".dat?tag=cu");

			ES2.Save(m_IsCloudVisible, m_PlayerName + ".dat?tag=is");

			for (int i = 0; i < (int)Location.Quantity; ++i)
				ES2.Save(m_Blocked[i], m_PlayerName + ".dat?tag=bl" + i);
			*/
		}

		//================================================================================
		//
		//================================================================================
		public void SaveImage(Texture2D image, string name)
		{
			if (m_IsPracticeMode || image == null)
			{
				return;
			}
			string path = Application.persistentDataPath + "/" + m_PlayerName + "/" + name + ".png";
			
			using(ES2Writer writer = ES2Writer.Create(path))
			{
				writer.WriteRaw(image.EncodeToPNG());
				writer.Save(false);
			}
		}
		
		//================================================================================
		//
		//================================================================================
		public Texture2D LoadImage(string name, Vector2 size)
		{
			if (m_IsPracticeMode)
			{
				return null;
			}
			
			string path = Application.persistentDataPath + "/" + m_PlayerName + "/" + name + ".png";
			
			try
			{
				using(ES2Reader reader = ES2Reader.Create(path))
				{
					byte[] bytes = reader.ReadRaw();
					if (bytes.Length > 0)
					{
						Texture2D newTexture = new Texture2D((int)size.x, (int)size.y);
						newTexture.LoadImage(bytes);
						return newTexture;
					}
				}
			}
			catch(System.Exception e)
			{
                KishiTechUnity.KishiTechDebug.KTDebug.Instance().Log(e.Message);
			}
			
			return null;
		}

        //================================================================================
        //
        //================================================================================
        public int GetUsedRedMarbleCount()
        {
            return m_UsedRedMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public void IncUsedRedMarbleCount()
        {
            ++m_UsedRedMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public void DecUsedRedMarbleCount()
        {
            --m_UsedRedMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public int GetUsedYellowMarbleCount()
        {
            return m_UsedYellowMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public void IncUsedYellowMarbleCount()
        {
            ++m_UsedYellowMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public void DecUsedYellowMarbleCount()
        {
            --m_UsedYellowMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public int GetUsedBlueMarbleCount()
        {
            return m_UsedBlueMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public void IncUsedBlueMarbleCount()
        {
            ++m_UsedBlueMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public void DecUsedBlueMarbleCount()
        {
            --m_UsedBlueMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public int GetUsedGreenMarbleCount()
        {
            return m_UsedGreenMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public void IncUsedGreenMarbleCount()
        {
            ++m_UsedGreenMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public void DecUsedGreenMarbleCount()
        {
            --m_UsedGreenMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public int GetUsedOrangeMarbleCount()
        {
            return m_UsedOrangeMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public void IncUsedOrangeMarbleCount()
        {
            ++m_UsedOrangeMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public void DecUsedOrangeMarbleCount()
        {
            --m_UsedOrangeMarbleCount;
        }

        //================================================================================
        //
        //================================================================================
        public void CheatAllItemsInInventory()
        {
            for (int i = 0; i < (int)ItemEnum.Quantity; ++i)
                m_Items[i] = ItemState.Inventory;
        }

	} // public class PlayerData

} // namespace ReaderRabbit