Rect.y += EditorGUIUtility.singleLineHeight ĮditorGUI.PropertyField(new Rect(rect.x, rect.y, rect.width, EditorGUI.GetPropertyHeight(unityEvent)), unityEvent) Var delay = element.FindPropertyRelative("Delay") ĮditorGUI.PropertyField(new Rect(rect.x, rect.y, rect.width, EditorGUIUtility.singleLineHeight), delay) Var unityEvent = element.FindPropertyRelative("unityEvent") Var element = EventDelayPairs.GetArrayElementAtIndex(index) List = new ReorderableList(serializedObject, EventDelayPairs)ĮditorGUI.LabelField(rect, "DelayedEvents") ĭrawElementCallback = (rect, index, sel, act) => Private SerializedProperty EventDelayPairs ĮventDelayPairs = serializedObject.FindProperty("EventDelayPairs") Private IEnumerator InvokeDelayed(UnityEvent unityEvent, float delay) StartCoroutine(InvokeDelayed(eventDelayPair.unityEvent, eventDelayPair.Delay)) Var validPairs = Mathf.Min(events.Count, delays.Count) įoreach (var eventDelayPair in EventDelayPairs) Or via the inspector (like in a UI.Button.onClick).įor multiple events I just came up with a quick and dirty solution so you can simply define multiple events via the inspector and add various callbacks and stuff: public class GlobalTimer : MonoBehaviour Than you have only one invoked method and can add callbacks to that timer like (() => seconds is done now.", globalTimerReference.Delay) Unity allows to use Start as IEnumerator instead of a void
#Unity get file time update
In your case for only raising one or multiple events it might be better to stick with the one Update() method instead and invoke an event or something like that.īut - why not simply have one single Coroutine instead of the Update at all: public class GlobalTimer : MonoBehaviour Afaik it isn't really noticable until you have like maybe 10.000 Coroutines running (don't nail me on numbers here ) ). Whether one Update or multiple Coroutines are more performant depends a lot on the specific usecase. ltaTime afaik is not affacted by the Time.timescale so in order to allow faster replay you would have to do private void Update () The actual time suspended is equal to the given time multiplied by Time.timeScale.
Time.fixedDeltaTime = 0.02f * Time.timeScale įor the Coroutine this works without you having to change anything because WaitForSeconds is affected by the Time.timescale: The fixed delta time will now be 0.02 frames per real-time second Also adjust fixed delta time according to timescale Toggles the time scale between 1 (normal) and 0.5 (twice as fast) You use either of the two ways and simply change Time.timescale if you want to view it faster/slower etc in the example by pressing Space: public class Example : MonoBehaviour The question is how do I manage it? Either first way or second way or third way (by you)?īecause I also want to speed up the time too which seems impossible within co-routine once it registers. Now using the above script I can get the Timer variable in another script and can execute my task based on time in the update method. Or get timer variable in other script and compare time on update Timer += ltaTime //ltaTime will increase the value with 1 every second. One Global script for Timer: function Update () As each script managing its own co-routine(Maybe I am wrong) This kind of script attach to every object that requires action after a certain time: Yield return new WaitForSeconds(120f) // wait two minutes Now i am considering two approaches (other approaches are also welcome which is the purpose of the question)Įach Object (Train) script manage its time by WaitForSeconds: void Start()
0 kommentar(er)
