Quest.cs

using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;

public class Quest : IEquatable<Quest> {

    public Quest() { }

    public int m_questID = 0;

    public string m_questName = "";

    public QuestState m_questState = QuestState.Unavailable;

    public int m_levelRequirement = 0;

    public List<int> m_prerequisiteQuestsByID = new List<int>();
    public List<QuestItemDetails> m_prerequisiteItemsByID = new List<QuestItemDetails>();

    public int m_questEntityID = -1;

    public bool m_openOnAvailable = false;
    public bool m_openOnCanComplete = false;

    public string m_questAvailableText = "";
    public string m_questActiveText = "";
    public string m_questCompleteText = "";
    public string m_questIncompleteText = "";

    public string m_introSubtitleID = "";
    public string m_outroSubtitleID = "";

    public bool m_progress = false;

    public List<QuestItemDetails> m_requiredItemsByID = new List<QuestItemDetails>();
    public List<QuestItemDetails> m_rewardItemsByID = new List<QuestItemDetails>();

    public int m_questDuration = 0;
    public int m_questCooldown = 0;
    public bool m_questExpires = false;
    public string m_questExpiryDate = "";

    public string m_questAvailableTimestamp = "";
    public string m_questActiveTimestamp = "";
    public string m_questCompleteTimestamp = "";
    public string m_questFailedTimestamp = "";

    public bool Equals(Quest other)
    {
        return (m_questID == other.m_questID);
    }

    public DateTime GetExpiryDate()
    {
        return DateTime.ParseExact(m_questExpiryDate, "MMM d, yyyy", null).AddDays(1);
    }
}

public class Quests
{
    public Quests() { }
    public Quest[] m_questData;
    public int[] m_entryPointsByID;
}

[Serializable]
public class QuestItemDetails : IEquatable<QuestItemDetails>, IComparable<QuestItemDetails>
{
    public QuestItemDetails() { }
    public int m_quantity = 1;
    public string m_itemID = "";
    public string m_altText = "";
    public int m_awardedByEntityID = -1;
    public float m_frequency = 1f;
    public string m_orderModifier = "";
    public float m_progress = 0f;

    public bool Equals(QuestItemDetails other)
    {
        return (m_itemID == other.m_itemID);
    }

    public int CompareTo(QuestItemDetails other)
    {
        return m_itemID.CompareTo(other.m_itemID);
    }
}

public enum QuestState { 
    Unavailable = 0,
    Available = 1,
    Active = 2,
    CanComplete = 3,
    Complete = 4,
    Incomplete = 5,
    CanFail = 6,
    Failed = 7
}

public class QuestAttribute : PropertyAttribute
{
    public QuestAttribute()
    {

    }
}
                    

QuestEditorWindow.cs

using UnityEditor;
using UnityEngine;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using JsonFx.Json;

[InitializeOnLoad]
public class QuestEditorWindow : EditorWindow
{

    static QuestEditorWindow()
    {
        Init();
    }

    private static QuestEditorWindow s_instance;

    [MenuItem("Secret Relics/Quest Editor")]
    public static void OpenWindow()
    {
        EditorWindow.GetWindow(
            typeof(QuestEditorWindow),
            false,
            "Quest Editor"
            );
    }

    public static void DeleteQuestByID(int id)
    {
        if (m_hasInit)
        {
            m_questData.m_quests.RemoveAll(item => item.m_questID == id);
            foreach (QuestData qd in m_questData.m_quests)
            {
                qd.m_prerequisiteQuestsByID.RemoveAll(item => item == id);
            }
            m_questData.BuildQuestDictionary(true);
        }
    }

    public static QuestData GetQuestByID(int id)
    {
        if (m_hasInit)
        {
            m_questData.BuildQuestDictionary();
            if (m_questData.m_questDictionary.ContainsKey(id))
            {
                return m_questData.m_questDictionary[id];
            }
            else
            {
                string s = "Could not find Quest with ID: " + id + " Total QuestData: " + m_questData.m_questDictionary.Count.ToString();
                foreach (KeyValuePair<int, QuestData> kvp in m_questData.m_questDictionary)
                {
                    s += "\n ID: " + kvp.Key.ToString();
                }
                Debug.Log(s);
            }
        }
        return null;
    }

    public static QuestEntityData GetQuestEntityByID(int id)
    {
        if (m_hasInit)
        {
            m_questData.BuildQuestEntityDictionary();
            if (m_questData.m_questEntityDictionary.ContainsKey(id))
            {
                return m_questData.m_questEntityDictionary[id];
            }
            else
            {
                Debug.LogError("Could not find Quest Entity with ID: " + id);
            }
        }

        return null;
    }

    public static MapEntityData GetMapEntityByID(int id)
    {
        if (m_hasInit)
        {
            m_questData.BuildMapEntityDictionary();
            if (m_questData.m_mapEntityDictionary.ContainsKey(id))
            {
                return m_questData.m_mapEntityDictionary[id];
            }

            MapEntityData med = GetQuestEntityByID(id) as MapEntityData;
            if (med != null)
            {
                return med;
            }
        }

        Debug.LogError("Could not find Map Entity with ID: " + id);
        return null;
    }

    public static string[] GetQuestNameArray()
    {
        if (m_hasInit)
        {
            m_questData.BuildQuestDictionary();
            return m_questData.m_questNameArray;
        }

        Debug.Log("<color=red>Could not build Quest Name Array</color>");
        QuestEditorWindow.Init();
        return new string[] { "none selected" };
    }

    public static int[] GetQuestIDArray()
    {
        if (m_hasInit)
        {
            m_questData.BuildQuestDictionary();
            return m_questData.m_questIDArray;
        }

        Debug.Log("<color=red>Could not build Quest ID Array</color>");
        QuestEditorWindow.Init();
        return new int[] { -1 };
    }

    public static string[] GetQuestEntityNameArray()
    {
        if (m_hasInit)
        {
            m_questData.BuildQuestEntityDictionary();
            return m_questData.m_questEntityNameArray;
        }

        Debug.Log("<color=red>Could not build Quest Entity Name Array</color>");
        QuestEditorWindow.Init();
        return new string[] { "none selected" };
    }

    public static int[] GetQuestEntityIDArray()
    {
        if (m_hasInit)
        {
            m_questData.BuildQuestEntityDictionary();
            return m_questData.m_questEntityIDArray;
        }

        Debug.Log("<color=red>Could not build Quest Entity ID Array</color>");
        QuestEditorWindow.Init();
        return new int[]{-1};
    }

    public static string[] GetMapEntityNameArray()
    {
        if (m_hasInit)
        {
            m_questData.BuildMapEntityDictionary();
            return m_questData.m_mapEntityNameArray;
        }

        Debug.Log("<color=red>Could not build Map Entity Name Array</color>");
        QuestEditorWindow.Init();
        return new string[] { "none selected" };
    }

    public static int[] GetMapEntityIDArray()
    {
        if (m_hasInit)
        {
            m_questData.BuildMapEntityDictionary();
            return m_questData.m_mapEntityIDArray;
        }

        Debug.Log("<color=red>Could not build Map Entity ID Array</color>");
        QuestEditorWindow.Init();
        return new int[] { -1 };
    }

    public static string[] GetAllEntityNameArray()
    {
        if (m_hasInit)
        {
            m_questData.BuildQuestEntityDictionary();
            m_questData.BuildMapEntityDictionary();
            return m_questData.m_allEntityNameArray;
        }

        Debug.Log("<color=red>Could not build All Entity Name Array</color>");
        QuestEditorWindow.Init();
        return new string[] { "none selected" };
    }

    public static int[] GetAllEntityIDArray()
    {
        if (m_hasInit)
        {
            m_questData.BuildQuestEntityDictionary();
            m_questData.BuildMapEntityDictionary();
            return m_questData.m_allEntityIDArray;
        }

        Debug.Log("<color=red>Could not build All Entity ID Array</color>");
        QuestEditorWindow.Init();
        return new int[] { -1 };
    }


    public static InventoryItem GetItemByID(string id)
    {
        if (m_hasInit)
        {
            InventoryItem foundItem = null;
            foreach (var item in m_allItems.m_inventoryItems)
            {
                if (item.m_ID.Equals(id))
                {
                    foundItem = item;
                    break;
                }
            }
            return foundItem;
        }

        return null;
    }

    public static void ForceReInit()
    {
        m_hasInit = false;
        Init();
    }

    private void OnDestory()
    {
        SaveEditorPrefrences();
    }

    private void OnLostFocus()
    {
        SaveEditorPrefrences();
    }

    private void OnFocus()
    {
        QuestEditorWindow.Init();
        CheckEntities();
    }

    private void OnDidOpenScene()
    {
        m_startScene = "";
    }

    public void CheckEntities()
    {
        if (Application.isPlaying || EditorApplication.isPlaying)
        {
            Debug.Log("Did not Check Entities");
            return;
        }

        if (!File.Exists(Application.dataPath.Substring(0, Application.dataPath.IndexOf("/Assets") + 1) + m_questData.m_gameMapPath))
        {
            Debug.LogError("Could not check entities in " + m_questData.m_gameMapPath);
            return;
        }

        if (m_startScene != EditorApplication.currentScene && EditorApplication.currentScene != m_questData.m_gameMapPath && !Application.isPlaying)
        {
            EditorUtilityx.InScene(m_questData.m_gameMapPath, UpdateEntities);
            m_startScene = EditorApplication.currentScene;
        }
        else if (EditorApplication.currentScene == m_questData.m_gameMapPath)
        {
            UpdateEntities(EditorApplication.currentScene);
            m_startScene = EditorApplication.currentScene;
        }
    }

    public void UpdateEntities(string scenePath)
    {
        MapEntityManager mem = FindObjectOfType<MapEntityManager>() as MapEntityManager;
        
        if (mem == null)
        {
            Debug.LogError("Could not find MapEntityManager in " + scenePath);
            return;
        }

        if (m_questData.m_questEntities == null)
        {
            m_questData.m_questEntities = new List<QuestEntityData>();
        }

        if (m_questData.m_mapEntities == null)
        {
            m_questData.m_mapEntities = new List<MapEntityData>();
        }
        
        List<int> validQuestEntityIDs = new List<int>();
        List<int> validMapEntityIDs = new List<int>();

        foreach (MapEntity me in mem.m_mapEntities)
        {
            if (me.EntityType != typeof(QuestEntity))
            {
                MapEntityData med = new MapEntityData();
                med.m_name = me.name;
                med.m_ID = me.m_id;

                validMapEntityIDs.Add(me.m_id);

                int mIndex = m_questData.m_mapEntities.FindIndex(item => item.m_ID == med.m_ID);

                if (mIndex >= 0)
                {
                    m_questData.m_mapEntities[mIndex] = med;
                }
                else
                {
                    m_questData.m_mapEntities.Add(med);
                    m_questData.AddMapEntityToDictionary(med);
                }

                continue;
            }

            QuestEntity qe = me as QuestEntity;

            QuestEntityData qed = new QuestEntityData();
            qed.m_name = qe.name;
            qed.m_ID = qe.m_id;
            
            validQuestEntityIDs.Add(qe.m_id);

            int qIndex = m_questData.m_questEntities.FindIndex(item => item.m_ID == qed.m_ID);

            if (qIndex >= 0)
            {
                m_questData.m_questEntities[qIndex] = qed;
            }
            else
            {
                m_questData.m_questEntities.Add(qed);
                m_questData.AddQuestEntityToDictionary(qed);
            }

        }
        m_questData.m_questEntities.RemoveAll(item => !validQuestEntityIDs.Contains(item.m_ID));
        m_questData.m_mapEntities.RemoveAll(item => !validMapEntityIDs.Contains(item.m_ID));
        m_questData.BuildQuestEntityDictionary(true);
        m_questData.BuildMapEntityDictionary(true);
    }

    private Rect m_questGraphSmallRect
    {
        get
        {
            m_questGraphSmallRectx.width = 0;
            m_questGraphSmallRectx.height = 0;

            foreach (QuestData qd in m_questData.m_quests)
            {
                if (qd.m_editorSmallRect.x + qd.m_editorSmallRect.width > m_questGraphSmallRectx.width)
                {
                    m_questGraphSmallRectx.width = qd.m_editorSmallRect.x + qd.m_editorSmallRect.width + 200f;
                }

                if (qd.m_editorSmallRect.y + qd.m_editorSmallRect.height > m_questGraphSmallRectx.height)
                {
                    m_questGraphSmallRectx.height = qd.m_editorSmallRect.y + qd.m_editorSmallRect.height + 200f;
                }
            }

            return m_questGraphSmallRectx;
        }
    }
    private static Rect m_questGraphSmallRectx;

    private static InventoryItemList m_allItems = null;
    private static QuestManagerData m_questData = null;
    private static bool m_hasInit = false;
    private static string m_startScene = "";
    private static GUISkin m_editorSkin = null;
    private static void Init()
    {		
        if (m_hasInit)
        {
            return;
        }

        if (m_editorSkin == null)
        {
            m_editorSkin = (GUISkin)(Resources.LoadAssetAtPath("Assets/GameScripts/Quests/Editor/_Data/QuestEditorWindowSkin.guiskin", typeof(GUISkin)));
        }

        if (m_allItems == null)
        {
            m_allItems = EditorCustomAssets.GetOrCreateAsset<InventoryItemList>("Assets/InventoryItems/AllItems.asset", true);
        }

        if (m_questData == null)
        {
            m_questData = EditorCustomAssets.GetOrCreateAsset<QuestManagerData>("Assets/GameScripts/Quests/Editor/_Data/QuestManagerData.asset", true);
            if (m_questData == null)
            {
                return; // QuestData can be null when Unity is recompiling or trying to play
            }
        }
        
        if (string.IsNullOrEmpty(m_questData.m_gameMapPath))
        {
            m_questData.m_gameMapPath = "Assets/Scenes/GameMap.unity";
        }

        if (m_questData.m_quests == null || m_questData.m_quests.Count <= 0)
        {
            m_questData.m_quests = new List<QuestData>();
        }

        if (m_questData.m_questDictionary == null || m_questData.m_questDictionary.Count <= 0)
        {
            m_questData.BuildQuestDictionary(true);
        }

        if (m_questData.m_questEntityDictionary == null || m_questData.m_questEntityDictionary.Count <= 0)
        {
            m_questData.BuildQuestEntityDictionary();
        }

        if (m_questData.m_mapEntityDictionary == null || m_questData.m_mapEntityDictionary.Count <= 0)
        {
            m_questData.BuildMapEntityDictionary();
        }
        
        if (m_questData.m_quests == null || m_questData.m_quests.Count <= 0 ||
            m_questData.m_questDictionary == null || m_questData.m_questDictionary.Count <= 0 ||
            m_questData.m_questEntityDictionary == null || m_questData.m_questEntityDictionary.Count <= 0 ||
            m_questData.m_mapEntityDictionary == null || m_questData.m_mapEntityDictionary.Count <= 0)
        {
            Debug.Log("<color=white>The <color=#FF6600>Quest Editor</color> has not been initialized. Open the <color=#FF6600>Quest Editor</color> to have all <color=#336600>[Quest]</color> and <color=#336600>[QuestEntity]</color> properties displayed correctly</color>");
        }
        else
        {
            Debug.Log("<color=white>The <color=#FF6600>Quest Editor</color> has been </color><color=green>initialized.</color>");
            m_hasInit = true;
        }

    }

    private static IEnumerator _DelayedReInit(float delay)
    {
        Debug.Log("Started Delayed Init");
        float runningTime = 0f;
        while (runningTime < delay)
        {
            runningTime += Time.deltaTime;
            yield return null;
        }
        Debug.Log("Force ReInit Delayed Init!");
        ForceReInit();
    }

    private void LoadEditorPrefrences()
    { 
        
    }

    private void SaveEditorPrefrences()
    { 
    
    }

    private void OnGUI()
    {
        QuestEditorWindow.Init();

        wantsMouseMove = true;

        if (m_editorSkin == null)
        {
            m_editorSkin = (GUISkin)(Resources.LoadAssetAtPath("Assets/GameScripts/Quests/Editor/_Data/QuestEditorWindowSkin.guiskin", typeof(GUISkin)));
        }
        GUI.skin = m_editorSkin;

        BeginWindows();
        
        // Quest List
        m_questlistRect = GUI.Window(0, new Rect(0, 0, m_questlistRect.width, position.height), DrawQuestList, "Quest List");
        
        // Toolbar
        GUI.Window(1, new Rect(m_questlistRect.width, 0, position.width - m_questlistRect.width, 50), DrawToolbar, "Toolbar");
        
        // Quest Graph
        DrawQuestGraph();

        // Cancel - Adding Prerequesite Quest Event
        if (Event.current.type == EventType.MouseDown &&
            Event.current.button == 1 &&
            QuestData.m_addingPrerequisiteQuest)
        {
            QuestData.m_addingPrerequisiteQuest = false;
        }

        EndWindows();

    }

    private void Update()
    {
        UpdateQuestList();
    }

    #region Toolbar

    private void Draw(int windowIndex)
    {
        GUI.DragWindow();
    }

    private void DrawToolbar(int windowIndex)
    {
        GUILayout.BeginHorizontal();
        if (GUILayout.Button("New Quest"))
        {
            m_questData.NewQuest(m_questgraphScrollPos.x, m_questgraphScrollPos.y);
        }

        GUILayout.FlexibleSpace();

        if (GUILayout.Button("Re-Init"))
        {
            ForceReInit();
        }

        if (GUILayout.Button("Save"))
        {
            m_questData.Save();

            AssetDatabase.SaveAssets();
            EditorUtility.SetDirty(m_questData);

            /* // Might be needed to make the saving work better - used in item builder
            EditorUtility.FocusProjectWindow();
            Selection.activeObject = item;
            */
        }

        GUILayout.EndHorizontal();
    }

    #endregion

    #region Quest List

    private Vector2 m_questlistScrollPos = Vector2.zero;
    private Rect m_questlistRect = new Rect(0, 0, 200, 100);
    private void DrawQuestList(int windowIndex)
    {
        m_questlistScrollPos = GUILayout.BeginScrollView(m_questlistScrollPos);
        GUILayout.BeginVertical();

        GUILayout.EndVertical();
        GUILayout.EndScrollView();

        GUI.DragWindow();
    }

    private void UpdateQuestList()
    {
        if (m_questlistRect.x != 0)
        {
            m_questlistRect.width += m_questlistRect.x;
            m_questlistRect.width = Mathf.Clamp(m_questlistRect.width, 100, 500);
            m_questlistRect.x = 0;
        }

        m_questlistRect.y = -20;
        m_questlistRect.height = position.height;
    }

    #endregion

    #region Quest Graph

    private Vector2 m_questgraphScrollPos = Vector2.zero;
    private Vector2 m_questEditorScrollPos = Vector2.zero;
    private Rect m_viewRect = new Rect(0, 0, 0, 0);
    private void DrawQuestGraph()
    {
        m_questgraphScrollPos = GUI.BeginScrollView(new Rect(m_questlistRect.width, 46, position.width - m_questlistRect.width - (QuestData.m_selectedQuestData != null ? QuestData.m_selectedQuestData.m_editorRect.width + 16 : 0), position.height - 46), m_questgraphScrollPos, m_questGraphSmallRect);

        Vector2 offset = Vector2.zero;
        offset.x = -m_questlistRect.width;


        Handles.BeginGUI();
        
        // Draw Lines
        foreach (QuestData qd in m_questData.m_quests)
        {
            if (qd != QuestData.m_selectedQuestData)
            {
                foreach (int qID in qd.m_prerequisiteQuestsByID)
                {
                    float tangentModifier = 1;
                    QuestData targetQuest = GetQuestByID(qID);

                    if (targetQuest == null) // Fail safe for QuestWindow Init
                    {
                        //Debug.Log("Quest Graph NULL Quest");
                        ForceReInit();
                        GUI.EndScrollView();
                        Handles.EndGUI();
                        return;
                    }

                    if (qd.m_editorSmallRect.center.y > targetQuest.m_editorSmallRect.center.y)
                    {
                        tangentModifier = -1;
                    }

                    Handles.DrawBezier(qd.m_editorSmallRect.center, targetQuest.m_editorSmallRect.center,
                        qd.m_editorSmallRect.center + (tangentModifier * 50f * Vector2.up),
                        targetQuest.m_editorSmallRect.center + (tangentModifier * -50 * Vector2.up),
                        targetQuest == QuestData.m_selectedQuestData ? Color.yellow : Color.grey, null, 2f);
                }
            }			
        }

        // Draw Lines for Selected Quest
        if (QuestData.m_selectedQuestData != null)
        {
            foreach (int qID in QuestData.m_selectedQuestData.m_prerequisiteQuestsByID)
            {
                float tangentModifier = 1;
                QuestData targetQuest = GetQuestByID(qID);

                if (targetQuest == null) // Fail safe for QuestWindow Init
                {
                    //Debug.Log("Quest Graph NULL Quest");
                    ForceReInit();
                    GUI.EndScrollView();
                    Handles.EndGUI();
                    return;
                }

                if (QuestData.m_selectedQuestData.m_editorSmallRect.center.y > targetQuest.m_editorSmallRect.center.y)
                {
                    tangentModifier = -1;
                }

                Handles.DrawBezier(QuestData.m_selectedQuestData.m_editorSmallRect.center, targetQuest.m_editorSmallRect.center,
                    QuestData.m_selectedQuestData.m_editorSmallRect.center + (tangentModifier * 50f * Vector2.up),
                    targetQuest.m_editorSmallRect.center + (tangentModifier * -50 * Vector2.up),
                    Color.green, null, 2f);
            }
        }

        // Draw Adding Prerequisite Line
        if (QuestData.m_addingPrerequisiteQuest)
        {
            float tangentModifier = 1;
            if (QuestData.m_selectedQuestData.m_editorSmallRect.center.y > Event.current.mousePosition.y)
            {
                tangentModifier = -1;
            }
            Handles.DrawBezier(QuestData.m_selectedQuestData.m_editorSmallRect.center, Event.current.mousePosition,
                QuestData.m_selectedQuestData.m_editorSmallRect.center + (tangentModifier * 50f * Vector2.up),
                Event.current.mousePosition + (tangentModifier * -50 * Vector2.up), 
                Color.cyan, null, 5f);
        }
        
        Handles.EndGUI();

        bool setDirty = false;
        m_viewRect.width = position.width;
        m_viewRect.height = position.height;
        m_viewRect.x = m_questgraphScrollPos.x;
        m_viewRect.y = m_questgraphScrollPos.y;
        foreach (QuestData qd in m_questData.m_quests)
        {
            if (qd != QuestData.m_selectedQuestData && 
                (m_viewRect.Contains(qd.m_editorSmallRect.GetPosition()) || m_viewRect.Contains(qd.m_editorSmallRect.GetPosition() + qd.m_editorSmallRect.GetSize())))
            {
                qd.DrawSmallQuestWindow();
                
                if (qd.m_setDirty)
                {
                    setDirty = true;
                }
            }
        }
        if (QuestData.m_selectedQuestData != null &&
                (m_viewRect.Contains(QuestData.m_selectedQuestData.m_editorSmallRect.GetPosition()) || m_viewRect.Contains(QuestData.m_selectedQuestData.m_editorSmallRect.GetPosition() + QuestData.m_selectedQuestData.m_editorSmallRect.GetSize())))
        {
            QuestData.m_selectedQuestData.DrawSmallQuestWindow();
            if (QuestData.m_selectedQuestData == null || QuestData.m_selectedQuestData.m_setDirty)
            {
                setDirty = true;
            }
        }

        if (setDirty && m_questData != null)
        {
            EditorUtility.SetDirty(m_questData);
        }

        Repaint();

        GUI.EndScrollView();

        m_questEditorScrollPos = GUI.BeginScrollView(new Rect(position.width - (QuestData.m_selectedQuestData != null ? QuestData.m_selectedQuestData.m_editorRect.width + 16 : 0), 46, (QuestData.m_selectedQuestData != null ? QuestData.m_selectedQuestData.m_editorRect.width + 16 : 0), position.height - 46), m_questEditorScrollPos, (QuestData.m_selectedQuestData != null ? QuestData.m_selectedQuestData.m_editorRect : new Rect(0,0,0,0)));

        if (QuestData.m_selectedQuestData != null)
        {
            QuestData.m_selectedQuestData.DrawQuestWindow();
        }
        
        GUI.EndScrollView();
    }

    #endregion
}
                    

SpriteSequenceController.cs

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class SpriteSequenceController : MonoBehaviour, IMetaStateControlled {

    public bool m_isBiDirectional = false;
    protected bool m_useAltState = false;

    protected int GetNewCoroutineID()
    {
        return ++m_currentCoroutineID;
    }
    protected int CurrentCoroutineID
    {
        get
        {
            return m_currentCoroutineID;
        }
    }
    protected int m_currentCoroutineID;

    protected int m_prevStateIndex = 0;
    
    private Sprite m_refSprite;
    private Sprite m_sprite
    {
        get
        {
            if (m_refSprite == null)
            {
                m_refSprite = GetComponent<Sprite>();
            }

            return m_refSprite;
        }
    }

    private SpriteAnimation m_refSpriteAnim;
    private SpriteAnimation m_spriteAnimation
    {
        get
        {
            if (m_refSpriteAnim == null)
            {
                m_refSpriteAnim = gameObject.GetComponent<SpriteAnimation>();
            }

            return m_refSpriteAnim;
        }
    }

    // Metastate Controlled

    private void setCurrentSpriteAnimationState(int index)
    {
        SpriteSequenceControllerInfo ssci = CurrentStateInfo();

        if (m_spriteAnimation.m_sequence != null)
        {
            m_spriteAnimation.Stop(); // Stop The Animation
        }
        
        if (ssci.m_spriteSequences[index] == null)  // Remove the sprite!
        {
            m_spriteAnimation.m_sequence = null;
            
            m_spriteAnimation.m_secondsPerFrame = 0.5f;
            m_spriteAnimation.m_fadingFactor = 0f;

            m_spriteAnimation.m_syncAnim = null;
            m_spriteAnimation.m_syncClip = null;

            m_spriteAnimation.m_loop = false;
            m_spriteAnimation.m_useOffsets = false;

            m_delayTransition = false;

            m_sprite.FadeToSpriteUV(null, ssci.m_fadingFactor[index]);
            return;
        }

        if (ssci.m_fixPosition[index]) //Move the sprite to the relative coordinates
        {
            transform.localPosition = ssci.m_fixedPosition[index];
        }

        m_spriteAnimation.m_sequence = ssci.m_spriteSequences[index];

        m_spriteAnimation.m_secondsPerFrame = ssci.m_secondsPerFrame[index];
        m_spriteAnimation.m_fadingFactor = ssci.m_fadingFactor[index];

        m_spriteAnimation.m_syncAnim = ssci.m_syncAnim[index];
        m_spriteAnimation.m_syncClip = ssci.m_syncClip[index];

        m_spriteAnimation.m_loop = ssci.m_loop[index];
        m_spriteAnimation.m_useOffsets = ssci.m_useOffsets[index];

        m_delayTransition = ssci.m_delayTransition[index];

        m_spriteAnimation.Play();   // Start the new Anim

        if (m_spriteAnimation.m_loop &&
            m_spriteAnimation.m_syncAnim != null &&
            m_spriteAnimation.m_syncClip != null)
        {
            StartCoroutine(_LoopWatch());
        }
    }

    private IEnumerator _LoopWatch()
    {
        AnimationState playingState = m_spriteAnimation.m_syncAnim[m_spriteAnimation.m_syncClip.name];
        bool isPlaying = m_spriteAnimation.m_syncAnim.IsPlaying(playingState.name);
        while (m_spriteAnimation.m_loop && 
                m_spriteAnimation.m_syncAnim != null && 
                m_spriteAnimation.m_syncClip != null)
        {
            if (isPlaying != m_spriteAnimation.m_syncAnim.IsPlaying(playingState.name))
            {
                isPlaying = m_spriteAnimation.m_syncAnim.IsPlaying(playingState.name);
                if (isPlaying)
                {
                    m_spriteAnimation.Play();
                    yield return new WaitForSeconds(m_spriteAnimation.Duration);
                }
            }

            yield return null;
        }
    }

    private IEnumerator _PlaySpriteSequences()
    {
        int id = GetNewCoroutineID();
        SpriteSequenceControllerInfo ssci = CurrentStateInfo();

        for (int i = 0; i < ssci.TotalSpriteSequences; ++i)
        {
            if (id != CurrentCoroutineID)
            {
                yield break;
            }

            setCurrentSpriteAnimationState(i);
            if (m_spriteAnimation.m_sequence != null)
            {
                if (m_refSpriteAnim.m_syncAnim != null)
                {
                    AnimationState playingState = m_refSpriteAnim.m_syncAnim[m_refSpriteAnim.m_syncClip.name];
                    while (playingState != null && !m_refSpriteAnim.m_syncAnim.IsPlaying(playingState.name))
                    {
                        if (id != CurrentCoroutineID)
                        {
                            yield break;
                        }
                        yield return null;
                    }
                }

                yield return new WaitForSeconds(m_spriteAnimation.Duration);
            }
            else
            {
                yield return null;
            }
        }
    }

    private bool m_setCurrentState = false; // Setting initial state or state change?

    public SpriteSequenceControllerInfo[] m_stateInfo = new SpriteSequenceControllerInfo[0];
    public SpriteSequenceControllerInfo[] m_altStateInfo = new SpriteSequenceControllerInfo[0];

    public MetaState Controller
    {
        get
        {
            if ((Application.isEditor && !Application.isPlaying) || !m_controller)
            {
                m_controller = MetaState.FindController(transform);
            }
            return m_controller;
        }
        set
        {
            m_controller = value;
        }
    }
    protected MetaState m_controller;


    public void AllowTransition()
    {
        if (!m_allowTransition)
        {
            m_allowTransition = true;
        }
    }

    protected bool m_delayTransition = false; // Should Delay Next Transition
    protected bool m_allowTransition = true;
    protected IEnumerator _DelayTransition()
    {
        m_allowTransition = false;
        while (!m_allowTransition)
        {
            yield return null;
        }

        if (m_prevStateIndex > Controller.State)
        {
            m_useAltState = true;
        }
        else
        {
            m_useAltState = false;
        }

        StartCoroutine(_PlaySpriteSequences());

        m_prevStateIndex = Controller.State;

        yield break;
    }

    public void OnMetaStateChange()
    {
        if (Controller == null)
        {
            Debug.LogWarning(name + " cannot handle callback without MetaState component");
            return;
        }
        if (Controller.State >= m_stateInfo.Length)
        {
            Debug.LogWarning(name + " lacks info for state " + Controller.State + ", is it synced?");
            return;
        }

        if (m_delayTransition)
        { 
            StartCoroutine(_DelayTransition());
            return;
        }

        // Start MetaStateChange
        

        if (!m_setCurrentState) // First time (Play last animation of current state)
        {
            SpriteSequenceControllerInfo ssci = CurrentStateInfo();
            int sIndex = ssci.TotalSpriteSequences - 1;
            setCurrentSpriteAnimationState(sIndex);
            
            if (ssci.m_spriteSequences[sIndex] != null && !ssci.m_loop[sIndex])
            {
                m_spriteAnimation.Stop();
                if (ssci.m_useOffsets[sIndex])
                {
                    int curFrame = ssci.m_spriteSequences[sIndex].sprites.Length - 1;
                    m_spriteAnimation.transform.localPosition = new Vector3(
                        ssci.m_spriteSequences[sIndex].offsets[curFrame].x,
                        ssci.m_spriteSequences[sIndex].offsets[curFrame].y,
                        m_spriteAnimation.transform.localPosition.z
                        );
                }
            }

            m_setCurrentState = true;
        }
        else // Actual state change (play chain)
        {
            if (m_prevStateIndex > Controller.State)
            {
                // Going Backwards
                m_useAltState = true;
            }
            else
            {
                // Going Forwards
                m_useAltState = false;
            }

            StartCoroutine(_PlaySpriteSequences());
        }

        m_prevStateIndex = Controller.State;
    }

    public void SyncToMetaState()
    {
        if (Controller != null)
        {
            Controller.StandardSync(this, ref m_stateInfo);
            Controller.StandardSync(this, ref m_altStateInfo);
        }
    }

    public SpriteSequenceControllerInfo CurrentStateInfo()
    {
        if (m_useAltState && m_isBiDirectional)
        {
            return m_altStateInfo[Controller.State];
        }

        return m_stateInfo[Controller.State];
    }

    // End MetaState Controlled
}

[System.Serializable]
public class SpriteSequenceControllerInfo : IMetaStateLinked
{
    public int StateID
    {
        get
        {
            return msiID;
        }
        set
        {
            msiID = value;
        }
    }

    public int TotalSpriteSequences
    {
        get
        {
            return m_totalSpriteSequences;
        }

        set
        {
            if (value < 0)
            {
                value = 0;
            }

            if (value < m_totalSpriteSequences)
            {
                m_spriteSequences.RemoveRange(value, m_totalSpriteSequences - value);

                m_secondsPerFrame.RemoveRange(value, m_totalSpriteSequences - value);
                m_fadingFactor.RemoveRange(value, m_totalSpriteSequences - value);

                m_syncAnim.RemoveRange(value, m_totalSpriteSequences - value);
                m_syncClip.RemoveRange(value, m_totalSpriteSequences - value);

                m_loop.RemoveRange(value, m_totalSpriteSequences - value);
                m_useOffsets.RemoveRange(value, m_totalSpriteSequences - value);
                m_delayTransition.RemoveRange(value, m_totalSpriteSequences - value);

                m_fixPosition.RemoveRange(value, m_totalSpriteSequences - value);
                m_fixedPosition.RemoveRange(value, m_totalSpriteSequences - value);
            }
            else if (value > m_totalSpriteSequences)
            {
                // Less optimal, but safer for changes to info class (allows increment-decrement fix)

                while (m_spriteSequences.Count < value)
                {
                    m_spriteSequences.Add(null);
                }

                while (m_secondsPerFrame.Count < value)
                {
                    m_secondsPerFrame.Add(0.5f);
                }

                while (m_fadingFactor.Count < value)
                {
                    m_fadingFactor.Add(0.0f);
                }

                while (m_syncAnim.Count < value)
                {
                    m_syncAnim.Add(null);
                }

                while (m_syncClip.Count < value)
                {
                    m_syncClip.Add(null);
                }

                while (m_loop.Count < value)
                {
                    m_loop.Add(false);
                }

                while (m_useOffsets.Count < value)
                {
                    m_useOffsets.Add(false);
                }

                while (m_delayTransition.Count < value)
                {
                    m_delayTransition.Add(false);
                }

                while (m_fixPosition.Count < value)
                {
                    m_fixPosition.Add(false);
                }

                while (m_fixedPosition.Count < value)
                {
                    m_fixedPosition.Add(Vector3.zero);
                }
            }

            m_totalSpriteSequences = value;
        }
    }

    public int msiID;
    public int m_totalSpriteSequences;
    public List<SpriteSequence> m_spriteSequences = new List<SpriteSequence>();

    public List<float> m_secondsPerFrame = new List<float>();
    public List<float> m_fadingFactor = new List<float>();

    public List<Animation> m_syncAnim = new List<Animation>();
    public List<AnimationClip> m_syncClip = new List<AnimationClip>();

    public List<bool> m_loop = new List<bool>();
    public List<bool> m_useOffsets = new List<bool>();

    public List<bool> m_delayTransition = new List<bool>();

    public List<bool> m_fixPosition = new List<bool>();
    public List<Vector3> m_fixedPosition = new List<Vector3>();
}
                        

SpriteSequenceControllerEditor.cs

using UnityEngine;
using UnityEditor;
using System.Collections;
using System.Collections.Generic;

[CustomEditor(typeof(SpriteSequenceController))]
public class SpriteSequenceControllerEditor : Editor {

    protected SpriteSequenceControllerInfo[] copy;
    protected SpriteSequenceControllerInfo[] altCopy;

    protected bool m_showAlt = false;

    private List<List<float>> scrubPos = new List<List<float>>();

    public override void OnInspectorGUI()
    {
        SpriteSequenceController selectedTarget = target as SpriteSequenceController;
        MetaState metaState = selectedTarget.Controller;
        Sprite sprite = selectedTarget.GetComponent<Sprite>();
        SpriteAnimation spriteAnim = selectedTarget.GetComponent<SpriteAnimation>();

        if (Event.current.type == EventType.Layout)
        {
            copy = selectedTarget.m_stateInfo;
            altCopy = selectedTarget.m_altStateInfo;
        }

        if (copy == null || altCopy == null)
        {
            return;
        }

        if (metaState == null || sprite == null || spriteAnim == null)
        {
            GUIUtilityx.PushColor(Color.yellow);
            if (metaState == null)
            {
                GUILayout.Box("No MetaState", GUILayout.ExpandWidth(true));
            }
            if (sprite == null)
            {
                GUILayout.Box("No Sprite", GUILayout.ExpandWidth(true));
            }
            if (spriteAnim == null)
            {
                GUILayout.Box("No Sprite Animation", GUILayout.ExpandWidth(true));
            }
            GUIUtilityx.PopColor();
        }
        else
        {
            selectedTarget.SyncToMetaState();
            GUILayout.BeginHorizontal();
            GUILayout.BeginVertical();
            
            selectedTarget.m_isBiDirectional = EditorGUILayout.Toggle("Is BiDirectional", selectedTarget.m_isBiDirectional);

            if (selectedTarget.m_isBiDirectional)
            {
                GUILayout.BeginHorizontal();

                if (!m_showAlt)
                {
                    GUI.enabled = false;
                }

                if (GUILayout.Button("Forward"))
                {
                    m_showAlt = false;
                }

                if (m_showAlt)
                {
                    GUI.enabled = false;
                }
                else
                {
                    GUI.enabled = true;
                }

                if (GUILayout.Button("Backwards"))
                {
                    m_showAlt = true;
                }

                GUI.enabled = true;

                GUILayout.EndHorizontal();
            }
            else
            {
                m_showAlt = false;
            }

            GUILayout.EndVertical();
            GUILayout.EndHorizontal();

            while (scrubPos.Count <= metaState.States.Length)
            {
                scrubPos.Add(new List<float>());
            }

            if (metaState.States.Length <= scrubPos.Count)
            {
                scrubPos.RemoveRange(metaState.States.Length, scrubPos.Count - metaState.States.Length);
            }

            if (m_showAlt)
            {
                DrawBackwards(metaState, selectedTarget, sprite);
            }
            else
            {
                DrawForwards(metaState, selectedTarget, sprite);
            }
        }
    }

    protected void DrawForwards(MetaState metaState, SpriteSequenceController selectedTarget, Sprite sprite)
    {
        for (int i = 0; i < copy.Length && i < metaState.States.Length; i++)
        {
            GUILayout.BeginVertical("box");
            GUILayout.Label(metaState.States[i].name);

            DrawInfo(copy[i], selectedTarget, sprite, i);

            GUILayout.EndVertical();
        }
    }

    protected void DrawBackwards(MetaState metaState, SpriteSequenceController selectedTarget, Sprite sprite)
    {
        for (int i = 0; i < altCopy.Length && i < metaState.States.Length; i++)
        {
            GUILayout.BeginVertical("box");
            GUILayout.Label(metaState.States[metaState.States.Length - 1 - i].name);

            DrawInfo(altCopy[metaState.States.Length - 1 - i], selectedTarget, sprite, metaState.States.Length - 1 - i);

            GUILayout.EndVertical();
        }
    }

    protected void DrawInfo(SpriteSequenceControllerInfo info, SpriteSequenceController selectedTarget, Sprite sprite, int i)
    {
        var totalSSeq = EditorGUILayout.IntField("Total Sequences", info.TotalSpriteSequences);
        if (info.TotalSpriteSequences != totalSSeq)
            EditorUtility.SetDirty(selectedTarget);
        info.TotalSpriteSequences = totalSSeq;

        if (totalSSeq <= 0)
        {
            GUIUtilityx.PushColor(Color.yellow);
            GUILayout.Box("Invalid Sequence Count", GUILayout.ExpandWidth(true));
            GUIUtilityx.PopColor();
        }

        while (scrubPos[i].Count <= info.TotalSpriteSequences)
        {
            scrubPos[i].Add(0f);
        }

        if (info.TotalSpriteSequences <= scrubPos[i].Count)
        {
            scrubPos[i].RemoveRange(info.TotalSpriteSequences, scrubPos[i].Count - info.TotalSpriteSequences);
        }

        for (int j = 0; j < info.TotalSpriteSequences; ++j)
        {
            GUILayout.Space(5.0f);
            GUILayout.BeginVertical("box");
            var ss = EditorGUILayoutx.ObjectField<SpriteSequence>("Sprite Sequence", info.m_spriteSequences[j], false);
            if (info.m_spriteSequences[j] != ss)
                EditorUtility.SetDirty(selectedTarget);
            info.m_spriteSequences[j] = ss;

            if (ss == null)
            {
                GUI.enabled = false;
            }

            var spf = EditorGUILayout.FloatField("Seconds Per Frame", info.m_secondsPerFrame[j]);
            if (info.m_secondsPerFrame[j] != spf)
                EditorUtility.SetDirty(selectedTarget);
            info.m_secondsPerFrame[j] = spf;

            var ff = EditorGUILayout.FloatField("Fading Factor", info.m_fadingFactor[j]);
            if (info.m_fadingFactor[j] != ff)
                EditorUtility.SetDirty(selectedTarget);
            info.m_fadingFactor[j] = ff;

            var syncA = EditorGUILayoutx.ObjectField<Animation>("Sync Animation", info.m_syncAnim[j], true);
            if (info.m_syncAnim[j] != syncA)
                EditorUtility.SetDirty(selectedTarget);
            info.m_syncAnim[j] = syncA;

            var syncC = EditorGUILayoutx.ObjectField<AnimationClip>("Sync Clip", info.m_syncClip[j], true);
            if (info.m_syncClip[j] != syncC)
                EditorUtility.SetDirty(selectedTarget);
            info.m_syncClip[j] = syncC;

            if (syncA != null || syncC != null)
            {
                if (syncA == null)
                {
                    GUIUtilityx.PushColor(Color.yellow);
                    GUILayout.Box("Sync Animation Missing", GUILayout.ExpandWidth(true));
                    GUIUtilityx.PopColor();
                }

                if (syncC == null)
                {
                    GUIUtilityx.PushColor(Color.yellow);
                    GUILayout.Box("Sync Clip Missing", GUILayout.ExpandWidth(true));
                    GUIUtilityx.PopColor();
                }
            }
            else if (syncA != null && syncC != null)
            {
                if (syncA[syncC.name] == null)
                {
                    GUIUtilityx.PushColor(Color.yellow);
                    GUILayout.Box("Sync Clip not Attached to Animation", GUILayout.ExpandWidth(true));
                    GUIUtilityx.PopColor();
                }
            }

            GUILayout.BeginHorizontal();
            
            var loop = GUILayout.Toggle(info.m_loop[j], "Loop");
            if (info.m_loop[j] != loop)
                EditorUtility.SetDirty(selectedTarget);
            info.m_loop[j] = loop;

            var offset = GUILayout.Toggle(info.m_useOffsets[j], "Use Offsets");
            if (info.m_useOffsets[j] != offset)
                EditorUtility.SetDirty(selectedTarget);
            info.m_useOffsets[j] = offset;

            var delayT = GUILayout.Toggle(info.m_delayTransition[j], "Delay Transition");
            if (info.m_delayTransition[j] != delayT)
                EditorUtility.SetDirty(selectedTarget);
            info.m_delayTransition[j] = delayT;

            var fixpos = GUILayout.Toggle(info.m_fixPosition[j], "Fix Position");
            if (info.m_fixPosition[j] != fixpos)
                EditorUtility.SetDirty(selectedTarget);
            info.m_fixPosition[j] = fixpos;

            GUILayout.EndHorizontal();

            if (offset && ss != null && ss.sprites.Length != ss.offsets.Length)
            {
                GUIUtilityx.PushColor(Color.yellow);
                GUILayout.Box("Sprite Sequence Offsets do not Match", GUILayout.ExpandWidth(true));
                GUIUtilityx.PopColor();
            }

            if (loop && syncA != null && syncC != null && syncA[syncC.name] != null)
            {
                if (syncC.wrapMode != WrapMode.Loop)
                {
                    GUIUtilityx.PushColor(Color.yellow);
                    GUILayout.Box("Sync Clip does not Loop", GUILayout.ExpandWidth(true));
                    GUIUtilityx.PopColor();
                }
            }

            if (fixpos)
            {
                info.m_useOffsets[j] = false;

                var fpos = EditorGUILayout.Vector3Field("Fix Position", info.m_fixedPosition[j]);
                if (info.m_fixedPosition[j] != fpos)
                    EditorUtility.SetDirty(selectedTarget);
                info.m_fixedPosition[j] = fpos;
            }

            if (syncA != null && syncC != null)
            {
                info.m_secondsPerFrame[j] = syncC.length / ss.sprites.Length;
                info.m_fadingFactor[j] = 0f;
            }

            if (ss != null)
            {
                int curFrame = Mathf.Clamp(Mathf.RoundToInt((scrubPos[i][j]) * (float)ss.sprites.Length), 0, (ss.sprites.Length - 1));

                float prev = scrubPos[i][j];

                float scrubTime = scrubPos[i][j] * info.m_secondsPerFrame[j] * ss.sprites.Length;
                float unityAnimTime = Mathf.Floor(scrubTime) + (((scrubTime - Mathf.Floor(scrubTime)) * 0.6f).ToString("0.00") == "0.60" ? 1f : ((scrubTime - Mathf.Floor(scrubTime)) * 0.6f)); // <-- display time relative to Unity's animation tool

                GUILayout.Label("Scrub: " + (unityAnimTime).ToString("0.00") + " [" + (scrubTime).ToString("0.00") + "s] [" + curFrame + "]");

                scrubPos[i][j] = GUILayout.HorizontalSlider(scrubPos[i][j], 0f, 1f);

                if (prev != scrubPos[i][j])
                {
                    if (syncA != null && syncC != null)
                    {
                        syncA.Stop();
                        syncA[syncC.name].normalizedTime = scrubPos[i][j];
                        syncA[syncC.name].weight = 1f;
                        syncA[syncC.name].enabled = true;
                        syncA.Sample();
                        syncA[syncC.name].enabled = false;
                        syncA[syncC.name].weight = 0f;
                    }

                    for (int l = 0; l < scrubPos.Count; ++l)
                    {
                        for (int k = 0; k < scrubPos[l].Count; ++k)
                        {
                            if (l != i)
                            {
                                scrubPos[l][k] = 0f;
                            }
                            else if (k != j)
                            {
                                scrubPos[l][k] = 0f;
                            }
                        }
                    }

                    curFrame = Mathf.Clamp(Mathf.RoundToInt((scrubPos[i][j]) * (float)ss.sprites.Length), 0, (ss.sprites.Length - 1));
                    sprite.m_spriteUV = ss.sprites[curFrame];
                    sprite.Sync();

                    if (offset)
                    {
                        selectedTarget.transform.localPosition = new Vector3(
                            ss.offsets[curFrame].x,
                            ss.offsets[curFrame].y,
                            selectedTarget.transform.localPosition.z
                        );
                    }
                }
            }

            GUI.enabled = true;
            GUILayout.EndVertical();
        }
    }
}
                        

Hintable.cs

using UnityEngine;
using System.Collections;

public class Hintable : MetastateControlled<HintableInfo> {

    private string m_id;
    private bool m_canGlint = false;
    public string ID { get { return m_id; } }

    public HintType m_hintType = HintType.Standard;
    public HintUsageMode m_hintCost = HintUsageMode.CONSUME;

    // Standard Hints
    public int m_priority = 0;

    // Navigation Hints
    public string m_destination;

    // Use this for initialization
    void Start () {
        m_id = Application.loadedLevelName + gameObject.name;
        HintController.AddHintable(this);
    }
    
    void OnDestroy()
    { 
        HintController.RemoveHintable(m_id);
    }

    public override void OnMetaStateInit()
    {
        OnMetaStateTransition();
        base.OnMetaStateInit();
    }

    public override void OnMetaStateTransition()
    {
        if (m_hintType != HintType.Navigation && GameObjectUtils.FindTransformRoot(transform, "Zoomups") != "Zoomups" && !m_canGlint && CurrentStateInfo().m_hintActive)
        {
            StartCoroutine(_StartGlintTimer());
        }
        else if (m_hintType != HintType.Navigation && !CurrentStateInfo().m_hintActive)
        {
            m_canGlint = false;
        }
    }

    public IEnumerator _StartGlintTimer()
    {
        if (m_canGlint)
        {
            yield break;
        }
        m_canGlint = true;

        while (m_canGlint)
        {
            float delay = Random.Range(0.9f * ProfileOptions.s_glintDelay, 1.1f * ProfileOptions.s_glintDelay);

            yield return new WaitForSeconds(delay);
            if (m_canGlint)
            {
                HintDisplay.TryGlints(CurrentStateInfo().m_hintSteps[0].m_hintPositions);
            }
        }
    }
}

public enum HintType 
{ 
    Standard = 0,
    Navigation = 1,
    Zoomup = 2
}

[System.Serializable]
public class HintableInfo : IMetaStateLinked
{
    public int StateID
    {
        get
        {
            return msiID;
        }
        set
        {
            msiID = value;
        }
    }
    public int msiID; //MetastateInfo ID
    public bool m_hintActive = false;
    public HintStep[] m_hintSteps = new HintStep[0];
}

[System.Serializable]
public class HintStep
{
    public HintTransition m_hintTransition = HintTransition.Burst;
    public InventoryItem m_useItem = null;
    public SubtitledAudio m_hintSubtitle = null;
    public Transform[] m_hintPositions = new Transform[0];
}

public enum HintTransition
{
    Burst = 0,
    Smooth = 1
}
                            

ChallengeMap.cs

using System.IO;
using System.Xml;
using System.Xml.Serialization;
using System.Collections.Generic;
using UnityEngine;

[XmlRoot("world")]
public class ChallengeMap
{
    [XmlIgnoreAttribute]
    public static ChallengeMap s_instance;
    
    [XmlIgnoreAttribute]
    public static ChallengeMapAStar Pathfinder
    {
        get
        {
            return s_instance.m_pathFinder;
        }
    }

    [XmlArray("map"), XmlArrayItem("node")]
    public List<ChallengeMapNode> m_nodes;

    private Dictionary<string, ChallengeMapNode> m_nodesDictionary;

    [XmlIgnoreAttribute]
    public ChallengeMapAStar m_pathFinder = new ChallengeMapAStar();

    public static void Load()
    {
        float starttime = Time.realtimeSinceStartup;

        if (s_instance != null)
        {
            Debug.LogWarning("ChallengeMap has already been loaded");
            return;
        }
        
        TextAsset challengeMap = Resources.Load("ChallengeMap") as TextAsset;

        var serializer = new XmlSerializer(typeof(ChallengeMap));
        s_instance = serializer.Deserialize(new StringReader(challengeMap.text)) as ChallengeMap;

        // Add the nodes to a dictionary for faster lookups
        s_instance.m_nodesDictionary = new Dictionary<string,ChallengeMapNode>();
        foreach (ChallengeMapNode node in s_instance.m_nodes)
        {
            if (!s_instance.m_nodesDictionary.ContainsKey(node.name))
            {
                s_instance.m_nodesDictionary.Add(node.name, node);
            }
            else
            {
                Debug.LogWarning("Duplicate Node in ChallengeMap: " + node.name);
            }
        }

        // Release the memory used up by the list
        s_instance.m_nodes.Clear();
        s_instance.m_nodes.Capacity = 0;

        Debug.Log("ChallangeMap Loaded in " + (Time.realtimeSinceStartup - starttime) + "s");
    }

    public static ChallengeMapNode GetNode(string name)
    {
        if (s_instance == null)
        {
            Debug.LogWarning("ChallengeMap has not been loaded");
            return null;
        }

        if (s_instance.m_nodesDictionary.ContainsKey(name))
        {
            return s_instance.m_nodesDictionary[name];
        }

        return null;
    }

    public static List<string> GetActiveHint(string name)
    {
        if (s_instance == null)
        {
            Debug.LogWarning("ChallengeMap has not been loaded");
            return null;
        }
        ChallengeMapNode node = GetNode(name);
        if (node != null)
        {
            return node.ActiveHint;
        }
        return new List<string>();
    }
}                            
                            

ChallengeMapEditor.cs

using UnityEngine;
using UnityEditor;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using System.Collections;
using System.Collections.Generic;

public class ChallengeMapEditor : Editor 
{
    private const string m_challengeMapPath = "/Gogii/Resources/ChallengeMap.xml";

    private static Dictionary<string, StateVariable> m_varsByName;
    public static StateVariable FindVariable(string name)
    {
        if (m_varsByName == null)
        {
            m_varsByName = new Dictionary<string, StateVariable>();
            GameObject stateManager = (GameObject)Resources.Load("TitleInitPrefabs/_State Manager");
            foreach (StateVariable v in stateManager.GetComponent<StateManager>().m_allVars)
            {
                m_varsByName[v.name.ToLower()] = v;
            }
        }

        if (m_varsByName.ContainsKey(name.ToLower()))
        {
            return m_varsByName[name.ToLower()];
        }
        return null;
    }

    private static List<Hintable> m_navHintables;
    private static List<Hintable> m_standardHintables;

    private static void CollectHintables()
    {
        Hintable[] hintables = FindObjectsOfType(typeof(Hintable)) as Hintable[];

        m_navHintables = new List<Hintable>();
        m_standardHintables = new List<Hintable>();

        foreach (Hintable h in hintables)
        {
            switch (h.m_hintType)
            { 
                case HintType.Standard:
                    m_standardHintables.Add(h);
                    break;
                case HintType.Navigation:
                case HintType.Zoomup:
                    m_navHintables.Add(h);
                    break;
            }
        }
    }

    private static List<string> m_nodes = new List<string>();
    private static void CollectNodes()
    {
        m_nodes.Clear();
        foreach(ChallengeMapNode node in m_newChallengeMap.m_nodes)
        {
            m_nodes.Add(node.name);
        }
    }

    // Remove Paths that do not lead to a node
    private static void CleanUpPaths()
    {
        CollectNodes();
        foreach (ChallengeMapNode node in m_newChallengeMap.m_nodes)
        {
            for (int i = node.m_paths.Count - 1; i >= 0; --i)
            {
                if (!m_nodes.Contains(node.m_paths[i].name))
                {
                    Debug.LogWarning(":::::::::: Node does not exist, path removed: " + node.m_paths[i].name);
                    node.m_paths.RemoveAt(i);
                }
            }
        }
    }


    private static ChallengeMap m_newChallengeMap = null;

    [MenuItem("Gogii/Challenge Map/Build Challenge Map")]
    protected static void BuildChallengeMap()
    {
        EditorUtility.DisplayProgressBar("Buidling Challenge Map", "Initializing new challenge map", 0f);

        string startedInScene = EditorApplication.currentScene;
        m_newChallengeMap = new ChallengeMap();
        m_newChallengeMap.m_nodes = new List<ChallengeMapNode>();

        EditorUtility.DisplayProgressBar("Buidling Challenge Map", "Scanning nodes", 0.2f);

        // Build
        EditorUtilityx.ForEachScene(Paths.kSceneDir+"Nodes/", BuildChallengeMap);

        EditorUtility.DisplayProgressBar("Buidling Challenge Map", "Adding EndGame node", 0.4f);

        // Build EndGame Node
        ChallengeMapNode EndGameNode = BuildNode("EndGame", 1f, 1f);
        EndGameNode.m_paths.Clear();
        EndGameNode.m_challenges.Clear();
        m_newChallengeMap.m_nodes.Add(EndGameNode);

        EditorUtility.DisplayProgressBar("Buidling Challenge Map", "Cleaning paths that lead to non-existing nodes", 0.6f);

        // Cleanup paths to nowhere (Nodes don't exist yet?)
        CleanUpPaths();

        EditorUtility.DisplayProgressBar("Buidling Challenge Map", "Writing to ChallengeMap XML", 0.8f);

        // Serialize
        var serializer = new XmlSerializer(typeof(ChallengeMap));
        StreamWriter sw = new StreamWriter(Application.dataPath + m_challengeMapPath, false, new System.Text.UTF8Encoding(false));
        serializer.Serialize(sw, m_newChallengeMap);
        sw.Close();

        //Refresh the asset database
        AssetDatabase.Refresh();

        // Go back to the scene we were initially in
        if (startedInScene != null && startedInScene.EndsWith(".unity"))
        {
            EditorApplication.OpenScene(startedInScene);
        }

        EditorUtility.ClearProgressBar();
    }

    protected static void BuildChallengeMap(string scenePath)
    {
        // Find the Hintables
        CollectHintables();
        
        // Determine the Current Scene Name
        string[] scenePathTokens = EditorApplication.currentScene.Split(char.Parse("/"));
        string sceneName = scenePathTokens[scenePathTokens.Length - 1].Replace(".unity", "");

        // Determin Current Scene Position
        float x = 0f;
        float y = 0f;
        
        // Build Current Scene Node
        m_newChallengeMap.m_nodes.Add(BuildNode(sceneName, x, y));

        //Build Nodes for Zoomups in Scene
        Zoomup[] zoomups = FindObjectsOfType(typeof(Zoomup)) as Zoomup[];
        foreach (Zoomup z in zoomups)
        {
            m_newChallengeMap.m_nodes.Add(BuildNode(sceneName, x + 0.5f, y + 0.5f, z));
        }        
    }

    private static ChallengeMapNode BuildNode(string nodeName, float x = 0f, float y = 0f, Zoomup zoomup = null)
    {
        // Build Node
        ChallengeMapNode currentNode = new ChallengeMapNode();

        currentNode.name = zoomup == null ? nodeName : nodeName + zoomup.gameObject.name;

        currentNode.x = x;
        currentNode.y = y;

        currentNode.completer = "";
        if ((StateBool)FindVariable("completed " + currentNode.name) != null)
        {
            currentNode.completer = "completed " + currentNode.name;
        }

        // Find all the paths
        currentNode.m_paths = new List<ChallengeMapPath>();
        currentNode.m_paths.AddRange(GetHintablePaths(nodeName, zoomup));

        // Find all the challenges
        currentNode.m_challenges = new List<ChallengeMapChallenge>();
        currentNode.m_challenges.AddRange(GetHintableChallenges(zoomup));

        return currentNode;
    }

    private static List<ChallengeMapPath> GetHintablePaths(string nodeName, Zoomup zoomup = null)
    {
        List<ChallengeMapPath> challengeMapPaths = new List<ChallengeMapPath>();
        List<Hintable> hintables = new List<Hintable>(m_navHintables);
        if (zoomup != null) // If Looking in a zoom remove none zoom hintables
        {
            List<Hintable> hintablesInZoom = new List<Hintable>(zoomup.m_root.GetComponentsInChildren<Hintable>());
            hintables.RemoveAll(item => !hintablesInZoom.Contains(item));

            // Add "back" path
            ChallengeMapPath backPath = new ChallengeMapPath();
            backPath.name = nodeName;
            challengeMapPaths.Add(backPath);
        }
        foreach (Hintable h in hintables)
        {
            if (zoomup == null && GameObjectUtils.FindTransformRoot(h.transform, "Zoomups") == "Zoomups")
            {
                continue;
            }
            ChallengeMapPath currentPath = new ChallengeMapPath();
            currentPath.name = h.m_hintType == HintType.Navigation ? h.m_destination : nodeName + h.m_destination;
            if (h.Controller.States.Length > 1)
            {
                currentPath.m_metastates = new List<ChallengeMapState>();
                for (int i = 0; i < h.Controller.States.Length; ++i)
                {
                    ChallengeMapState currentState = new ChallengeMapState();
                    currentState.index = i;
                    currentState.active = h.m_info[i].m_hintActive;
                    currentState.m_statevarsnames = new List<string>();
                    if (i > 0)
                    {
                        foreach (StateVariableChecker sc in h.Controller.States[i].checks)
                        {
                            if (sc.m_bool != null)
                            {
                                currentState.m_statevarsnames.Add(sc.m_bool.name);
                            }
                        }
                    }
                    if (currentState.m_statevarsnames.Count == 0)
                    {
                        currentState.m_statevarsnames = null;
                    }
                    currentPath.m_metastates.Add(currentState);
                }
            }
            challengeMapPaths.Add(currentPath);
        }

        return challengeMapPaths;
    }

    private static List<ChallengeMapChallenge> GetHintableChallenges(Zoomup zoomup = null)
    {
        List<ChallengeMapChallenge> challengeMapChallenges = new List<ChallengeMapChallenge>();
        List<Hintable> hintables = new List<Hintable>(m_standardHintables);
        if (zoomup != null)
        {
            List<Hintable> hintablesInZoom = new List<Hintable>(zoomup.m_root.GetComponentsInChildren<Hintable>());
            hintables.RemoveAll(item => !hintablesInZoom.Contains(item));
        }
        foreach (Hintable h in hintables)
        {
            if (zoomup == null && GameObjectUtils.FindTransformRoot(h.transform, "Zoomups") == "Zoomups")
            {
                continue;
            }

            if (h.Controller == null)
            {
                Debug.LogWarning(":::::::::: Challenge does not have metastate: " + h.gameObject);
                continue;
            }

            ChallengeMapChallenge currentChallenge = new ChallengeMapChallenge();
            currentChallenge.name = h.gameObject.name;
            currentChallenge.priority = h.m_priority;
            if (h.Controller.States.Length > 1)
            {
                currentChallenge.m_metastates = new List<ChallengeMapState>();
                for (int i = 0; i < h.Controller.States.Length; ++i)
                {
                    ChallengeMapState currentState = new ChallengeMapState();
                    currentState.index = i;
                    currentState.active = h.m_info[i].m_hintActive;
                    currentState.m_statevarsnames = new List<string>();
                    if (i > 0)
                    {
                        foreach (StateVariableChecker sc in h.Controller.States[i].checks)
                        {
                            if (sc.m_bool != null)
                            {
                                currentState.m_statevarsnames.Add(sc.m_bool.name);
                            }
                        }
                    }
                    if (currentState.m_statevarsnames.Count == 0)
                    {
                        currentState.m_statevarsnames = null;
                    }
                    currentChallenge.m_metastates.Add(currentState);
                }
            }
            challengeMapChallenges.Add(currentChallenge);
        }

        return challengeMapChallenges;
    }
}                            
                            

UnityHWCursors.h (Windows)

#include "windows.h"
#include "stdio.h"

#include <vector>
#include <string>

using namespace std;

struct unityCursor
{
    string name;
    HCURSOR cursor;
};

HWND window;
vector<unityCursor> cursors;                                    
                            

UnityHWCursors.cpp (Windows)

#include "UnityHWCursors.h"

extern "C" __declspec( dllexport ) void InitHWCursors()
{
    // Hook into Foreground window
    window = GetForegroundWindow();

    unityCursor cur;
        cur.name = "SYSTEM_HWC";
        cur.cursor = (HCURSOR)::LoadCursorW((HINSTANCE)NULL, IDC_ARROW);

        if (cur.cursor != NULL)
        {
            cursors.push_back(cur);
        }
}

extern "C" __declspec( dllexport ) void AddCursor(char* NAME, char* PATH)
{
    int len = strlen(PATH);
    for(int i = 0; i < len; ++i)	// Fix Path
    {
        if(PATH[i] == '/')
        {
            PATH[i] = '\\';
        }
    }
    
    // Add a cursor - Note: NAME should not repeat and is case sensative
    DWORD size = MultiByteToWideChar(CP_ACP, 0, PATH, -1, NULL, 0);
    wchar_t *path = new wchar_t[size];
    if (path)
    {
        MultiByteToWideChar(CP_ACP, 0, PATH, -1, path, size);

        unityCursor cur;
            cur.name = string(NAME);
            cur.cursor = (HCURSOR)::LoadImageW((HINSTANCE)NULL, path, IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_SHARED);
        
            if (cur.cursor != NULL)
            {
                cursors.push_back(cur);
            }
    }

    delete []path;
}

extern "C" __declspec( dllexport ) void SetHWCursor(char* NAME)
{	
    // Find Cursor
    for (vector<unityCursor>::iterator i = cursors.begin(); i != cursors.end(); ++i)
    {
        if (strcmp(NAME, i->name.c_str()) == 0)
        {
            //Set Cursor by overriding the window class pointer
            SetClassLongA(window, GCLP_HCURSOR, (long)i->cursor);
            SetCursor(i->cursor);
            
            break;
        }
    }
}                                    
                            

UnityHWCursors.h (OSX)

#import <Cocoa/Cocoa.h>
#import <AppKit/AppKit.h>

@interface UnityHWCursors : NSObject
{
    NSApplication* app;
    NSWindow* window;
    NSView* view;
    
    NSString* currentCursorName;
    
    NSMutableArray* cursors;
}

@property (retain) NSApplication* app;
@property (retain) NSWindow* window;
@property (retain) NSView* view;

@property (retain) NSString* currentCursorName;
@property (retain) NSMutableArray* cursors;

- (void)reset;

@end

@interface unityCursor : NSObject
{
    NSString* name;
    NSImage* image;
    NSCursor* cursor;
}
@property (retain) NSString* name;
@property (retain) NSImage* image;
@property (retain) NSCursor* cursor;

@end

@interface TrackingRectObject : NSResponder
{
}

- (void)mouseEntered:(NSEvent *)theEvent;
- (void)mouseExited:(NSEvent *)theEvent;

@end

// Prototypes

void SetHWCursor(const char* NAME);
void LostFocus();
void GotFocus();
void ResetWindow();
                            

UnityHWCursors.m (OSX)

#import "UnityHWCursors.h"

@implementation UnityHWCursors

@synthesize app;
@synthesize window;
@synthesize view;

@synthesize currentCursorName;
@synthesize cursors;

- (id) init
{
    self.app = [NSApplication sharedApplication];
    self.window = [self.app mainWindow];
    self.view = [self.window contentView];

    self.currentCursorName = @"SYSTEM_HWC";
    self.cursors = [[NSMutableArray alloc] initWithCapacity:10];
    
    return self;
}

- (void) dealloc
{
    self.cursors = nil;
    self.currentCursorName = nil;
    
    [super dealloc];
}

- (void) reset
{
    self.app = [NSApplication sharedApplication];
    self.window = [self.app mainWindow];
    self.view = [self.window contentView];
}

@end

UnityHWCursors* uHWC = nil;

@implementation unityCursor

@synthesize name;
@synthesize image;
@synthesize cursor;

- (void) dealloc
{
    self.name = nil;
    self.image = nil;
    self.cursor = nil;
    [super dealloc];
}

@end

@implementation TrackingRectObject

- (void)mouseEntered:(NSEvent *)theEvent
{
    NSLog(@"OnEntered");
    GotFocus();
}

- (void)mouseExited:(NSEvent *)theEvent
{
    NSLog(@"OnExit");
    LostFocus();
}

@end

NSTrackingRectTag pTrackTag;
TrackingRectObject* pTrackMgr = nil;

void InitHWCursors()
{
    if (uHWC == nil)
    {
        uHWC = [[UnityHWCursors alloc] init];
    }
    
    if (pTrackMgr == nil) 
    {
        pTrackMgr = [TrackingRectObject alloc];
        pTrackTag = [uHWC.view addTrackingRect: [uHWC.view visibleRect] owner:pTrackMgr userData:nil assumeInside:NO];
    }
}

void AddCursor(const char* NAME, const char* PATH)
{
    unsigned short cursorFile[20];
    
    NSFileHandle* file = [NSFileHandle fileHandleForReadingAtPath: [NSString stringWithUTF8String:PATH]];
    NSData* data = [file readDataToEndOfFile];
    [data getBytes:cursorFile length: 40];
    
    unsigned short hotSpotX = cursorFile[5];
    unsigned short hotSpotY = cursorFile[6];
    
    [file closeFile];
    
    unityCursor* cur = [unityCursor alloc];
    cur.name = [[NSString alloc] initWithUTF8String:NAME];
    cur.image = [[NSImage alloc] initByReferencingFile: [NSString stringWithUTF8String:PATH]];
    cur.cursor = [[NSCursor alloc] initWithImage: cur.image hotSpot: NSMakePoint(hotSpotX, hotSpotY)];
    
    [uHWC.cursors addObject:cur];
    
}

void SetHWCursor(const char* NAME)
{
    uHWC.currentCursorName = [[NSString alloc] initWithUTF8String:NAME];
    
    if (strcmp(NAME, "SYSTEM_HWC") == 0)
    {
        [[NSCursor arrowCursor] set];
    }
    else 
    {
        for (unityCursor* cur in uHWC.cursors)
        {
            if(strcmp(NAME, [cur.name UTF8String]) == 0)
            {
                [cur.cursor set];
                break;
            }
        }
    }
}

void LostFocus()
{
    NSLog(@"LOST FOCUS");
    NSString* tmpCursor = uHWC.currentCursorName;
    SetHWCursor("SYSTEM_HWC");
    uHWC.currentCursorName = tmpCursor;
}

void GotFocus()
{
    NSLog(@"GOT FOCUS");
    SetHWCursor([uHWC.currentCursorName UTF8String]);
}

void ResetWindow()
{ 
    NSLog(@"RESET WINDOW");
    [uHWC.view removeTrackingRect:pTrackTag];
    [uHWC reset];
    
    pTrackTag = [uHWC.view addTrackingRect: [uHWC.view visibleRect] owner:pTrackMgr userData:nil assumeInside:NO];    
}
                            

ItavioManager.cs

#if UNITY_ANDROID && !UNITY_EDITOR
#define ITAVIO_ANDROID
#endif

#if UNITY_IOS && !UNITY_EDITOR
#define ITAVIO_IOS
#endif

using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;

using itavio.Utilities;
using itavio.MiniJSON;

#if ITAVIO_IOS
using System.Runtime.InteropServices;
#endif

namespace itavio
{
    public class itavioManager : MonoBehaviour
    {
        private const string ITAVIO_CONFIG = "itavioConfig";
        private const string UNITY_CLASS = "ItavioManager";
        private const string INITIALIZE = "initialize";
        private const string GET_BALANCE = "getBalance";
        private const string GET_LIMIT = "getLimit";
        private const string START_DEBIT = "startDebit";
        private const string CANCEL_DEBIT = "cancelDebit";
        private const string COMPLETE_DEBIT = "completeDebit";
        private const string CHECK_FOR_PARENT = "checkForParent";
        private const string SHOW_UNINSTALL_DIALOG = "showUninstallDialog";

        private const int ERR_CODE_INSUFFICIENT_FUNDS = -1;

        public delegate void itavioErrorEventHandler (int code, string message);

        public delegate void itavioBoolEventHandler (bool result);

        public delegate void itavioDoubleEventHandler (double result);

        public static event itavioErrorEventHandler OnError;

        public delegate void itavioMoneyEventHandler (double value, string currencyCode);

        public static event itavioMoneyEventHandler OnGetBalance;
        public static event itavioMoneyEventHandler OnGetLimit;
        public static event itavioBoolEventHandler OnStartDebit;
        public static event itavioBoolEventHandler OnCancelDebit;
        public static event itavioBoolEventHandler OnCompleteDebit;
        public static event itavioBoolEventHandler OnCheckForParent;
        #if UNITY_IOS
        public static event itavioBoolEventHandler OnLinkWithParentApp;
        #endif

        private static object s_startDebitCallback = null;
        private static object[] s_startDebitCallbackArgs = null;

        private static itavioManager s_instance;

        private static itavioManager Instance {
            get {
                if (s_instance == null) {
                    GameObject iM = new GameObject (UNITY_CLASS);
                    iM.transform.position = Vector3.zero;
                    DontDestroyOnLoad (iM);

                    s_instance = iM.AddComponent<itavioManager> ();
                }

                return s_instance;
            }
        }

        /// <summary>
        /// Initialize the ItavioSDK for a target platform
        /// </summary>
        /// <param name="platformName">Name of the target platform</param>
        public static void initialize (string platformName)
        {
            itavioConfigPlatform itavioPlatform = (Resources.Load (ITAVIO_CONFIG) as itavioConfig).GetPlatform (platformName);
            initialize (itavioPlatform);
        }

        /// <summary>
        /// Initialize the ItavioSDK for a target platform
        /// </summary>
        /// <param name="platform">Target platform</param>
        public static void initialize (itavioConfigPlatform platform)
        {
            itavioDbg.Log ("Initializing Platform: " + platform.Name);
#if ITAVIO_ANDROID
            if (Instance.Plugin != null)
            {
                object[] args = new object[] { platform.SecretKeyID, platform.SecretKey, (int)platform.Environment };
                Instance.Plugin.Call<int>(INITIALIZE, args);
            }
#elif ITAVIO_IOS
            if (PluginExists)
            {
                itavioInitialize(platform.SecretKeyID, platform.SecretKey, (int)platform.Environment);
            }
#else   // Unsupported Platform
            if (Instance != null) {
                itavioDbg.LogWarning ("Initialized Stub");
            }
#endif
        }

        /// <summary>
        /// Request the users balance
        /// </summary>
        public static void getBalance ()
        {
            itavioDbg.Log ("Get Balance");
#if ITAVIO_ANDROID
            if (Instance.Plugin != null)
            {
                Instance.Plugin.Call<int>(GET_BALANCE);
            }

#elif ITAVIO_IOS
            if (PluginExists)
            {
                itavioGetBalance();
            }
#else   // Unsupported Platform
            itavioDbg.LogWarning ("Get Balance Stub");
            Instance.onGetBalanceSuccess (Json.Serialize (new Dictionary<string, object> () { { "balance", 5.0 }, { "currencyCode", "CAD"} }));            
#endif
        }

        /// <summary>
        /// Request the users balance
        /// </summary>
        public static void getLimit ()
        {
            itavioDbg.Log ("Get Limit");
            #if ITAVIO_ANDROID
            if (Instance.Plugin != null)
            {
                Instance.Plugin.Call<int>(GET_LIMIT);
            }

            #elif ITAVIO_IOS
            if (PluginExists)
            {
                itavioGetLimit();
            }
            #else   // Unsupported Platform
            itavioDbg.LogWarning ("Get Limit Stub");
            Instance.onGetLimitSuccess (Json.Serialize (new Dictionary<string, object> () { { "limit", 5.0 }, { "currencyCode", "CAD"} }));            
            #endif
        }

        /// <summary>
        /// Start a debit transaction
        /// </summary>
        /// <typeparam name="T">Purchase delegate type</typeparam>
        /// <param name="amount">Amount to debit</param>
        /// <param name="currencyCode">ISO 4217 currency codes</param>
        /// <param name="callback">Purchase delegate</param>
        /// <param name="callbackArgs">Purchase delegate arguments</param>
        public static void startDebit<T> (double amount, string currencyCode, T callback, params object[] callbackArgs) where T : class
        {
            if (!typeof(T).IsSubclassOf (typeof(Delegate))) {
                throw new InvalidOperationException (typeof(T).Name + " is not a delegate type");
            }

            s_startDebitCallback = callback;
            s_startDebitCallbackArgs = callbackArgs;

            itavioDbg.Log ("Start Debit: " + amount + "/" + currencyCode);
#if ITAVIO_ANDROID
            if (Instance.Plugin != null)
            {
                object[] args = new object[] { amount, currencyCode };
                Instance.Plugin.Call<int>(START_DEBIT, args);
            }
#elif ITAVIO_IOS
            if (PluginExists)
            {
                itavioStartDebit(amount, currencyCode);
            }
#else   // Unsupported Platform
            itavioDbg.LogWarning ("Start Debit Stub");
            Instance.onStartDebitSuccess (Json.Serialize (new Dictionary<string, object> () {
                { "enabled", true }, {
                    "hasFunds",
                    true
                }
            }));
#endif
        }

        /// <summary>
        /// Finalize a debit transaction
        /// </summary>
        /// <param name="success">True if completed, false if cancelled</param>
        public static void finalizeDebit (bool success)
        {
            s_startDebitCallback = null;
            s_startDebitCallbackArgs = null;
            switch (success) {
            case true:
                itavioDbg.Log ("Complete Debit");
#if ITAVIO_ANDROID
                    if (Instance.Plugin != null)
                    {
                        Instance.Plugin.Call<int>(COMPLETE_DEBIT);
                    }
#elif ITAVIO_IOS
                    if (PluginExists)
                    {
                        itavioCompleteDebit();
                    }
#else   // Unsupported Platform
                itavioDbg.LogWarning ("Complete Debit Stub");
                Instance.onCompleteDebitSuccess ("");
#endif
                break;
            case false:
                itavioDbg.Log ("Cancel Debit");
#if ITAVIO_ANDROID
                    if (Instance.Plugin != null)
                    {
                        Instance.Plugin.Call<int>(CANCEL_DEBIT);
                    }
#elif ITAVIO_IOS
                    if (PluginExists)
                    {
                        itavioCancelDebit();
                    }
#else   // Unsupported Platform
                itavioDbg.LogWarning ("Cancel Debit Stub");
                Instance.onCancelDebitSuccess ("");
#endif
                break;
            }
        }

        public static void showUninstallDialog (string email)
        {
            itavioDbg.Log ("Show Uninstall Dialog: " + email);
#if ITAVIO_ANDROID
            if (Instance.Plugin != null)
            {
                object[] args = new object[] { email };
                Instance.Plugin.Call<int>(SHOW_UNINSTALL_DIALOG, args);
            }
#elif ITAVIO_IOS
            if (PluginExists)
            {
                itavioShowUninstallDialog(email);
            }
#else   // Unsupported Platform
            itavioDbg.LogWarning ("Check For Parent Stub");
            Instance.onCheckForParentSuccess (Json.Serialize (new Dictionary<string, object> () { { "hasParentApp", true } }));
#endif
        }

        /// <summary>
        /// Check for Itavio parent app
        /// </summary>
        /// <param name="showGetAppDialog">Show the user a dialog prompt to get the parent app if it is not present</param>
        public static void checkForParent (bool showGetAppDialog = false, bool ignoreSuppression = false)
        {
            itavioDbg.Log ("Check For Parent - Show Dialog: " + showGetAppDialog);
#if ITAVIO_ANDROID
            if (Instance.Plugin != null)
            {
                object[] args = new object[] { showGetAppDialog };
                Instance.Plugin.Call(CHECK_FOR_PARENT, args);
            }
#elif ITAVIO_IOS
            if (PluginExists)
            {
                itavioCheckForParent(showGetAppDialog, ignoreSuppression);
            }
#else   // Unsupported Platform
            itavioDbg.LogWarning ("Check For Parent Stub");
            Instance.onCheckForParentSuccess (Json.Serialize (new Dictionary<string, object> () { { "hasParentApp", true } }));
#endif
        }

        public static bool IsLinked {
            get {
#if ITAVIO_IOS
                return itavioHasLink();
#else // Unity Editor
                itavioDbg.LogWarning ("IsLinked Stub");
                return true;
#endif
            }
        }

        /// <summary>
        /// Link the game to the active account in the parent app (triggers an app switch)
        /// </summary>
        /// <param name="showGetAppDialog">If the parent app is missing, show the user a prompt to get the parent app</param>
        public static void linkWithParentApp (bool showGetAppDialog, bool relink = false)
        {
#if ITAVIO_IOS
            itavioLinkWithParentApp(showGetAppDialog, relink);
#else // Unity Editor
            itavioDbg.LogWarning ("Link with Parent Stub");
            Instance.onLinkSuccess ("");
#endif
        }

        private void onLinkSuccess (string message)
        {
#if ITAVIO_IOS
            if (OnLinkWithParentApp != null) {
                OnLinkWithParentApp (true);
            }
#endif			
        }

        private void onLinkError (string message)
        {
            dispatchErrorMessage (message);
        }

        private void onGetBalanceSuccess (string message)
        {
            var dict = Json.Deserialize (message) as Dictionary<string, object>;
            double balance = Convert.ToDouble (dict ["balance"]);
            string currencyCode = Convert.ToString (dict ["currencyCode"]);

            itavioDbg.Log ("onGetBalanceSuccess - Balance: " + balance + currencyCode);
            if (OnGetBalance != null) {
                OnGetBalance (balance, currencyCode);
            }
        }

        private void onGetBalanceError (string message)
        {
            dispatchErrorMessage (message);
        }

        private void onGetLimitSuccess (string message)
        {
            var dict = Json.Deserialize (message) as Dictionary<string, object>;
            double limit = Convert.ToDouble (dict ["limit"]);
            string currencyCode = Convert.ToString (dict ["currencyCode"]);


            itavioDbg.Log ("onGetLimitSuccess - Limit: " + limit + currencyCode);
            if (OnGetLimit != null) {
                OnGetLimit (limit, currencyCode);
            }
        }

        private void onGetLimitError (string message)
        {
            dispatchErrorMessage (message);
        }

        private void onStartDebitSuccess (string message)
        {
            itavioDbg.Log ("onStartDebitSuccess");
            var dict = Json.Deserialize (message) as Dictionary<string, object>;

            bool isEnabled = (bool)dict ["enabled"];
            
            if (OnStartDebit != null) {
                OnStartDebit (isEnabled);
            }

            if (s_startDebitCallback != null && s_startDebitCallbackArgs != null) {
                Delegate a = s_startDebitCallback as Delegate;
                a.DynamicInvoke (s_startDebitCallbackArgs);
            }
        }

        private void onStartDebitError (string message)
        {
            dispatchErrorMessage (message);
        }

        private void onCancelDebitSuccess (string message)
        {
            itavioDbg.Log ("onCancelDebitSuccess");
            if (OnCancelDebit != null) {
                OnCancelDebit (true);
            }
        }

        private void onCancelDebitError (string message)
        {
            dispatchErrorMessage (message);
        }

        private void onCompleteDebitSuccess (string message)
        {
            itavioDbg.Log ("onCompleteDebitSuccess");
            if (OnCompleteDebit != null) {
                OnCompleteDebit (true);
            }
        }

        private void onCompleteDebitError (string message)
        {
            dispatchErrorMessage (message);
        }

        private void onCheckForParentSuccess (string message)
        {
            var dict = Json.Deserialize (message) as Dictionary<string, object>;
            bool hasParent = Convert.ToBoolean (dict ["hasParentApp"]);

            itavioDbg.Log ("onCheckForParentSuccess - Has Parent: " + hasParent);
            if (OnCheckForParent != null) {
                OnCheckForParent (hasParent);
            }
        }

        private void onCheckForParentError (string message)
        {
            dispatchErrorMessage (message);
        }

        private void dispatchErrorMessage (string message)
        {
            int errCode = -1;
            string errMessage = "";

            if (!string.IsNullOrEmpty (message)) {
                Dictionary<string, object> dict = Json.Deserialize (message) as Dictionary<string, object>;
                errCode = Convert.ToInt32 (dict ["code"]);// as int;
                errMessage = dict ["message"] as string;
            }

            itavioDbg.Log ("Error " + errCode + ": " + errMessage);
            if (OnError != null) {
                OnError (errCode, errMessage);
            }
        }

        #if ITAVIO_ANDROID
        
        private AndroidJavaObject activityContext = null;
        private AndroidJavaClass androidClass;

        private AndroidJavaObject Plugin
        {
            get
            {
                AndroidJavaObject pluginInstance = null;

                using (AndroidJavaClass activityClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
                {
                    AndroidJavaObject currentActivity = activityClass.GetStatic<AndroidJavaObject>("currentActivity");
                    activityContext = currentActivity.Call<AndroidJavaObject>("getApplicationContext");
                }
                if (androidClass == null)
                {
                    AndroidJNI.AttachCurrentThread();
                    androidClass = new AndroidJavaClass("com.itavio.android.plugin.unity.UnityBridge");
                    object[] args = new[] { activityContext };
                    pluginInstance = androidClass.CallStatic<AndroidJavaObject>("getInstance");
                }
                else
                {
                    object[] args = new[] { activityContext };
                    pluginInstance = androidClass.CallStatic<AndroidJavaObject>("getInstance");
                }
                return pluginInstance;
            }
        }
        
#elif ITAVIO_IOS
        
        [DllImport("__Internal")]
        private static extern int itavioInitialize(string secretKeyId, string secretKey, int environment);

        [DllImport("__Internal")]
        private static extern void itavioGetBalance();

        [DllImport("__Internal")]
        private static extern void itavioGetLimit();

        [DllImport("__Internal")]
        private static extern void itavioStartDebit(double amount, string currencyCode);

        [DllImport("__Internal")]
        private static extern void itavioCancelDebit();

        [DllImport("__Internal")]
        private static extern void itavioCompleteDebit();

        [DllImport("__Internal")]
        private static extern void itavioCheckForParent(bool showGetAppDialog, bool ignoreSuppression);
        
        [DllImport("__Internal")]
        private static extern bool itavioHasLink();

        [DllImport("__Internal")]
        private static extern void itavioLinkWithParentApp(bool showGetAppDialog, bool relink);

        [DllImport("__Internal")]
        private static extern void itavioShowUninstallDialog(string email);

        private static bool PluginExists { get { return Instance != null; } }

#endif
    }
}