fr.jeanf.universal.player 0.8.40 → 0.8.43

package/Runtime/scripts/Extentions/FunctionTimer.cs

@@ -3,86 +3,227 @@ using System.Collections.Generic;
 using jeanf.EventSystem;
 using UnityEngine;
 
-public class FunctionTimer {
-        private static List<FunctionTimer> activeTimerList;
-        private static GameObject initGameObject;
-
-        private static void InitIfNeeded() {
-            if (initGameObject == null) {
-                initGameObject = new GameObject("FunctionTimer_InitGameObject");
-                activeTimerList = new List<FunctionTimer>();
+public class FunctionTimer
+{
+    private static List<FunctionTimer> activeTimerList;
+    private static MonoBehaviourHook timerManager;
+    
+    private static Stack<FunctionTimer> timerPool = new Stack<FunctionTimer>(32);
+    private const int INITIAL_POOL_SIZE = 16;
+
+    private static void InitIfNeeded()
+    {
+        if (timerManager == null)
+        {
+            GameObject initGameObject = new GameObject("FunctionTimer_Manager");
+            UnityEngine.Object.DontDestroyOnLoad(initGameObject);
+            
+            timerManager = initGameObject.AddComponent<MonoBehaviourHook>();
+            activeTimerList = new List<FunctionTimer>(32);
+            
+            for (int i = 0; i < INITIAL_POOL_SIZE; i++)
+            {
+                timerPool.Push(new FunctionTimer());
             }
         }
+    }
 
-        public static FunctionTimer Create(Action action, float timer, string timerName = null) {
-            InitIfNeeded();
-            GameObject gameObject = new GameObject("FunctionTimer", typeof(MonoBehaviourHook));
+    private static FunctionTimer GetFromPool()
+    {
+        if (timerPool.Count > 0)
+        {
+            return timerPool.Pop();
+        }
+        return new FunctionTimer();
+    }
 
-            FunctionTimer functionTimer = new FunctionTimer(action, timer, timerName, gameObject);
+    private static void ReturnToPool(FunctionTimer timer)
+    {
+        timer.Reset();
+        timerPool.Push(timer);
+    }
 
-            gameObject.GetComponent<MonoBehaviourHook>().onUpdate = functionTimer.Update;
+    public static FunctionTimer Create(Action action, float timer, string timerName = null)
+    {
+        InitIfNeeded();
+        
+        FunctionTimer functionTimer = GetFromPool();
+        functionTimer.Initialize(action, timer, timerName);
 
-            activeTimerList.Add(functionTimer);
+        activeTimerList.Add(functionTimer);
 
-            return functionTimer;
-        }
-        private static void RemoveTimer(FunctionTimer functionTimer) {
-            InitIfNeeded();
-            activeTimerList.Remove(functionTimer);
-        }
+        return functionTimer;
+    }
 
-        public static void StopTimer(string timerName) {
-            if (activeTimerList == null || timerName == null) return;
-            
-            for (var i = 0; i < activeTimerList.Count; i++)
+    private static void RemoveTimer(FunctionTimer functionTimer)
+    {
+        if (activeTimerList == null) return;
+        
+        activeTimerList.Remove(functionTimer);
+        
+        ReturnToPool(functionTimer);
+    }
+
+    public static void StopTimer(string timerName)
+    {
+        if (activeTimerList == null || timerName == null) return;
+
+        for (int i = activeTimerList.Count - 1; i >= 0; i--)
+        {
+            if (activeTimerList[i].timerName == timerName)
             {
-                if (activeTimerList[i].timerName != timerName) continue;
-                // Stop this timer
                 activeTimerList[i].DestroySelf();
-                i--;
             }
         }
+    }
+
+    private static void CleanupDestroyedTimers()
+    {
+        if (activeTimerList == null) return;
+        
+        activeTimerList.RemoveAll(t => t.isDestroyed);
+    }
+
+    public static void StopAllTimers()
+    {
+        if (activeTimerList == null) return;
+        
+        for (int i = activeTimerList.Count - 1; i >= 0; i--)
+        {
+            activeTimerList[i].DestroySelf();
+        }
+        
+        activeTimerList.Clear();
+    }
+
+    private class MonoBehaviourHook : MonoBehaviour
+    {
+        private int frameCounter = 0;
+        private const int CLEANUP_INTERVAL = 60;
 
+        private void Update()
+        {
+            if (activeTimerList == null || activeTimerList.Count == 0) return;
 
+            float deltaTime = Time.deltaTime;
 
-        // Dummy class to have access to MonoBehaviour functions
-        private class MonoBehaviourHook : MonoBehaviour {
-            public Action onUpdate;
-            private void Update()
+            for (int i = activeTimerList.Count - 1; i >= 0; i--)
             {
-                onUpdate?.Invoke();
+                if (i >= activeTimerList.Count) continue;
+                
+                FunctionTimer timer = activeTimerList[i];
+                
+                if (timer.isDestroyed) continue;
+
+                timer.timer -= deltaTime;
+                
+                if (timer.timer <= 0f)
+                {
+                    try
+                    {
+                        timer.action?.Invoke();
+                    }
+                    catch (Exception e)
+                    {
+                        Debug.LogError($"[FunctionTimer] Error in timer '{timer.timerName}': {e.Message}");
+                    }
+                    
+                    timer.DestroySelf();
+                }
             }
         }
 
-        private Action action;
-        private float timer;
-        private string timerName;
-        private GameObject gameObject;
-        private bool isDestroyed;
-        private FloatEventChannelSO validationChannel;
-        private float remainingTime;
-
-        private FunctionTimer(Action action, float timer, string timerName, GameObject gameObject) {
-            this.action = action;
-            this.timer = timer;
-            this.timerName = timerName;
-            this.gameObject = gameObject;
-            isDestroyed = false;
+        private void OnDestroy()
+        {
+            StopAllTimers();
+        }
+    }
+
+    private Action action;
+    private float timer;
+    private string timerName;
+    private bool isDestroyed;
+    private FloatEventChannelSO validationChannel; 
+    private float remainingTime;
+
+    private FunctionTimer()
+    {
+        isDestroyed = true;
+    }
+
+    private void Initialize(Action action, float timer, string timerName)
+    {
+        this.action = action;
+        this.timer = timer;
+        this.timerName = timerName;
+        this.isDestroyed = false;
+    }
+
+    private void Reset()
+    {
+        this.action = null;
+        this.timer = 0f;
+        this.timerName = null;
+        this.isDestroyed = true;
+        this.validationChannel = null;
+    }
+
+    private void DestroySelf()
+    {
+        if (isDestroyed) return;
+        
+        isDestroyed = true;
+        
+        RemoveTimer(this);
+    }
+
+    public float RemainingTime => isDestroyed ? 0f : timer;
+    public bool IsActive => !isDestroyed;
+    public string Name => timerName;
+
+    public void AddTime(float additionalTime)
+    {
+        if (!isDestroyed)
+        {
+            timer += additionalTime;
+        }
+    }
+
+    public void SetTime(float newTime)
+    {
+        if (!isDestroyed)
+        {
+            timer = newTime;
         }
+    }
+}
+
+#if UNITY_EDITOR
+public static class FunctionTimerDebug
+{
+    [UnityEditor.MenuItem("Tools/Function Timer/Show Active Timers")]
+    private static void ShowActiveTimers()
+    {
+        var timers = typeof(FunctionTimer)
+            .GetField("activeTimerList", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic)
+            ?.GetValue(null) as List<FunctionTimer>;
 
-        public void Update()
+        if (timers == null || timers.Count == 0)
         {
-            if (isDestroyed) return;
-            timer -= Time.deltaTime;
-            if (!(timer < 0)) return;
-            // Trigger the action
-            action();
-            DestroySelf();
+            Debug.Log("[FunctionTimer] No active timers");
+            return;
         }
 
-        private void DestroySelf() {
-            isDestroyed = true;
-            UnityEngine.Object.Destroy(gameObject);
-            RemoveTimer(this);
+        for (int i = 0; i < timers.Count; i++)
+        {
+            var timer = timers[i];
         }
     }
+
+    [UnityEditor.MenuItem("Tools/Function Timer/Stop All Timers")]
+    private static void StopAllTimersMenu()
+    {
+        FunctionTimer.StopAllTimers();
+    }
+}
+#endif

package/Runtime/scripts/Extentions/FunctionTimerDebugger.cs

@@ -0,0 +1,196 @@
+using System;
+using UnityEngine;
+using System.Collections.Generic;
+using System.Reflection;
+
+/// <summary>
+/// Script helper pour débugger les problèmes de FunctionTimer
+/// Attache ce script à un GameObject dans ta scène pour voir les timers actifs
+/// </summary>
+public class FunctionTimerDebugger : MonoBehaviour
+{
+    [Header("Debug Settings")]
+    [SerializeField] private bool showDebugLogs = true;
+    [SerializeField] private bool showGuiOverlay = true;
+    [SerializeField] private float updateInterval = 0.5f;
+    
+    private float nextUpdateTime;
+    private List<TimerInfo> cachedTimerInfos = new List<TimerInfo>();
+    
+    private struct TimerInfo
+    {
+        public string name;
+        public float remainingTime;
+        public bool isActive;
+        public bool isDestroyed;
+    }
+    
+    private void Update()
+    {
+        if (Time.time >= nextUpdateTime)
+        {
+            nextUpdateTime = Time.time + updateInterval;
+            UpdateTimerInfos();
+        }
+    }
+    
+    private void UpdateTimerInfos()
+    {
+        cachedTimerInfos.Clear();
+        
+        // Utiliser reflection pour accéder à la liste privée
+        var activeTimerListField = typeof(FunctionTimer).GetField("activeTimerList", 
+            BindingFlags.Static | BindingFlags.NonPublic);
+        
+        if (activeTimerListField == null)
+        {
+            if (showDebugLogs)
+                Debug.LogWarning("[FunctionTimerDebugger] Cannot access activeTimerList");
+            return;
+        }
+        
+        var activeTimers = activeTimerListField.GetValue(null) as List<FunctionTimer>;
+        
+        if (activeTimers == null)
+        {
+            if (showDebugLogs)
+                Debug.Log("[FunctionTimerDebugger] No timer list initialized");
+            return;
+        }
+        
+        if (showDebugLogs)
+            Debug.Log($"[FunctionTimerDebugger] Active timers count: {activeTimers.Count}");
+        
+        // Récupérer les infos de chaque timer
+        for (int i = 0; i < activeTimers.Count; i++)
+        {
+            var timer = activeTimers[i];
+            
+            var info = new TimerInfo
+            {
+                name = GetTimerName(timer),
+                remainingTime = GetRemainingTime(timer),
+                isActive = GetIsActive(timer),
+                isDestroyed = GetIsDestroyed(timer)
+            };
+            
+            cachedTimerInfos.Add(info);
+            
+            if (showDebugLogs)
+            {
+                Debug.Log($"  Timer [{i}]: Name='{info.name}', " +
+                         $"Remaining={info.remainingTime:F2}s, " +
+                         $"Active={info.isActive}, " +
+                         $"Destroyed={info.isDestroyed}");
+            }
+        }
+    }
+    
+    private string GetTimerName(FunctionTimer timer)
+    {
+        var field = typeof(FunctionTimer).GetField("timerName", 
+            BindingFlags.Instance | BindingFlags.NonPublic);
+        return (field?.GetValue(timer) as string) ?? "unnamed";
+    }
+    
+    private float GetRemainingTime(FunctionTimer timer)
+    {
+        var field = typeof(FunctionTimer).GetField("timer", 
+            BindingFlags.Instance | BindingFlags.NonPublic);
+        return field != null ? (float)field.GetValue(timer) : 0f;
+    }
+    
+    private bool GetIsActive(FunctionTimer timer)
+    {
+        var prop = typeof(FunctionTimer).GetProperty("IsActive");
+        return prop != null ? (bool)prop.GetValue(timer) : false;
+    }
+    
+    private bool GetIsDestroyed(FunctionTimer timer)
+    {
+        var field = typeof(FunctionTimer).GetField("isDestroyed", 
+            BindingFlags.Instance | BindingFlags.NonPublic);
+        return field != null ? (bool)field.GetValue(timer) : true;
+    }
+    
+    private void OnGUI()
+    {
+        if (!showGuiOverlay) return;
+        
+        GUILayout.BeginArea(new Rect(10, 10, 400, Screen.height - 20));
+        GUILayout.BeginVertical("box");
+        
+        GUILayout.Label($"<b>FunctionTimer Debug</b> ({cachedTimerInfos.Count} timers)", 
+            new GUIStyle(GUI.skin.label) { richText = true, fontSize = 14 });
+        
+        GUILayout.Space(10);
+        
+        if (cachedTimerInfos.Count == 0)
+        {
+            GUILayout.Label("No active timers");
+        }
+        else
+        {
+            for (int i = 0; i < cachedTimerInfos.Count; i++)
+            {
+                var info = cachedTimerInfos[i];
+                
+                Color color = info.isDestroyed ? Color.red : 
+                             info.isActive ? Color.green : Color.yellow;
+                
+                GUI.color = color;
+                GUILayout.Label($"[{i}] {info.name}: {info.remainingTime:F2}s " +
+                               $"(Active: {info.isActive}, Destroyed: {info.isDestroyed})");
+                GUI.color = Color.white;
+            }
+        }
+        
+        GUILayout.Space(10);
+        
+        if (GUILayout.Button("Refresh Now"))
+        {
+            UpdateTimerInfos();
+        }
+        
+        if (GUILayout.Button("Stop All Timers"))
+        {
+            FunctionTimer.StopAllTimers();
+            UpdateTimerInfos();
+        }
+        
+        GUILayout.EndVertical();
+        GUILayout.EndArea();
+    }
+}
+
+/// <summary>
+/// Extension pour faciliter le debug dans ton code
+/// </summary>
+public static class FunctionTimerDebugExtensions
+{
+    /// <summary>
+    /// Crée un timer avec logging automatique
+    /// </summary>
+    public static FunctionTimer CreateDebug(Action action, float time, string name, GameObject caller = null)
+    {
+        string callerName = caller != null ? caller.name : "Unknown";
+        string fullName = $"{name} (from {callerName})";
+        
+        Debug.Log($"[FunctionTimer] Creating timer '{fullName}' for {time}s");
+        
+        return FunctionTimer.Create(() =>
+        {
+            Debug.Log($"[FunctionTimer] Timer '{fullName}' completed!");
+            action?.Invoke();
+        }, time, fullName);
+    }
+    
+    /// <summary>
+    /// Stop avec logging
+    /// </summary>
+    public static void StopTimerDebug(string timerName)
+    {
+        Debug.Log($"[FunctionTimer] Stopping timer '{timerName}'");
+        FunctionTimer.StopTimer(timerName);
+    }
+}

package/Runtime/scripts/Extentions/FunctionTimerDebugger.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2f4a669bdeaf85342bcd6d482ec109d8

package/Runtime/scripts/Hmd/BroadcastControlsStatus.cs

@@ -55,6 +55,7 @@ namespace jeanf.universalplayer
                     activeControlScheme.RaiseEvent();
                     break;
                 case "XR":
+                    playerInput.neverAutoSwitchControlSchemes = true;
                     controlScheme = ControlScheme.XR;
                     activeControlScheme.RaiseEvent();
                     break;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fr.jeanf.universal.player",
 
-  "version": "0.8.40",
+  "version": "0.8.43",
 
   "displayName": "Universal Player",
   "description": "This package contains a universal player working in URP & HDRP for Mouse+Keyboard or VR",