session controller added.

coderDarren · coderDarren · commit bc39fb5cd9a2 · 2020-02-22T15:13:45.000-05:00
diff --git a/Audio/AudioController.cs b/Audio/AudioController.cs
@@ -21,7 +21,20 @@ private enum AudioAction {
                 RESTART
             }
 
-            private struct AudioJob {
+            [System.Serializable]
+            public class AudioObject {
+                public AudioType type;
+                public AudioClip clip;
+            }
+
+            [System.Serializable]
+            public class AudioTrack
+            {
+                public AudioSource source;
+                public AudioObject[] audio;
+            }
+
+            private class AudioJob {
                 public AudioAction action;
                 public AudioType type;
                 public bool fade;
@@ -78,24 +91,46 @@ private void Dispose() {
             }
 
             private void AddJob(AudioJob _job) {
-                // cancel the job if one exists with the same type
-                if (m_JobTable.ContainsKey(_job.type)) {
-                    Log("Stopping job on ["+_job.type+"] for new operation: "+_job.action);
-                    IEnumerator _runningJob = (IEnumerator)m_JobTable[_job.type];
-                    StopCoroutine(_runningJob);
-                    m_JobTable.Remove(_job.type);
-                }
-
-                if (GetAudioTrack(_job.type, _job.action.ToString()) == null) {
-                    return;
-                }
+                // cancel any job that might be using this job's audio source
+                RemoveConflictingJobs(_job.type);
 
                 IEnumerator _jobRunner = RunAudioJob(_job);
                 m_JobTable.Add(_job.type, _jobRunner);
                 StartCoroutine(_jobRunner);
                 Log("Starting job on ["+_job.type+"] with operation: "+_job.action);
             }
 
+            private void RemoveJob(AudioType _type) {
+                if (!m_JobTable.ContainsKey(_type)) {
+                    Log("Trying to stop a job ["+_type+"] that is not running.");
+                    return;
+                }
+                IEnumerator _runningJob = (IEnumerator)m_JobTable[_type];
+                StopCoroutine(_runningJob);
+                m_JobTable.Remove(_type);
+            }
+
+            private void RemoveConflictingJobs(AudioType _type) {
+                // cancel the job if one exists with the same type
+                if (m_JobTable.ContainsKey(_type)) {
+                    RemoveJob(_type);
+                }
+
+                // cancel jobs that share the same audio track
+                AudioType _conflictAudio = AudioType.None;
+                foreach (DictionaryEntry _entry in m_JobTable) {
+                    AudioType _audioType = (AudioType)_entry.Key;
+                    AudioTrack _audioTrackInUse = GetAudioTrack(_audioType, "Get Audio Track In Use");
+                    AudioTrack _audioTrackNeeded = GetAudioTrack(_type, "Get Audio Track Needed");
+                    if (_audioTrackInUse.source == _audioTrackNeeded.source) {
+                        _conflictAudio = _audioType;
+                    }
+                }
+                if (_conflictAudio != AudioType.None) {
+                    RemoveJob(_conflictAudio);
+                }
+            }
+
             private IEnumerator RunAudioJob(AudioJob _job) {
                 yield return new WaitForSeconds(_job.delay);
 
diff --git a/Audio/AudioTrack.cs b/Audio/AudioTrack.cs
diff --git a/Session/SessionController.cs b/Session/SessionController.cs
@@ -1,13 +1,88 @@
 ﻿
 using UnityEngine;
+using UnityCore.Menu;
 
 namespace UnityCore {
-    
+
     namespace Session {
 
         public class SessionController : MonoBehaviour
         {
+            public static SessionController instance;
+
+            private long m_SessionStartTime;
+            private bool m_IsPaused;
+            private GameController m_Game;
+            private float m_FPS;
+
+            public long sessionStartTime {
+                get {
+                    return m_SessionStartTime;
+                }
+            }
+
+            public float fps {
+                get {
+                    return m_FPS;
+                }
+            }
             
+#region Unity Functions
+            private void Awake() {
+                Configure();
+            }
+
+            private void OnApplicationFocus(bool _focus) {
+                if (_focus) {
+                    // Open a window to unpause the game
+                    PageController.instance.TurnPageOn(PageType.PausePopup);
+                } else {
+                    // Flag the game paused
+                    m_IsPaused = true;
+                }
+            }
+
+            private void Update() {
+                if (m_IsPaused) return;
+                m_Game.OnUpdate();
+                m_FPS = Time.frameCount / Time.time;
+            }
+#endregion
+
+#region Public Functions
+            public void InitializeGame(GameController _game) {
+                m_Game = _game;
+                m_Game.OnInit();
+            }
+
+            public void UnPause() {
+                m_IsPaused = false;
+            }
+#endregion
+
+#region Private Functions
+            /// <summary>
+            /// Initialize the singleton pattern!
+            /// </summary>
+            private void Configure() {
+                if (!instance) {
+                    instance = this;
+                    StartSession();
+                    DontDestroyOnLoad(gameObject);
+                } else {
+                    Destroy(gameObject);
+                }
+            }
+
+            private void StartSession() {
+                m_SessionStartTime = EpochSeconds();
+            }
+
+            private long EpochSeconds() {
+                var _epoch = new System.DateTimeOffset(System.DateTime.UtcNow);
+                return _epoch.ToUnixTimeSeconds();
+            }
+#endregion
         }
     }
-}
+}
