Dayz  1.11.153731
Dayz Code Explorer by Zeroy
tools.c
Go to the documentation of this file.
1 
7 //--------------------------------------------------------------------------
8 const int CALL_CATEGORY_SYSTEM = 0; // Runs always
9 const int CALL_CATEGORY_GUI = 1; // Runs always (on client)
10 const int CALL_CATEGORY_GAMEPLAY = 2; // Runs unless ingame menu is opened
11 
12 const int CALL_CATEGORY_COUNT = 3;
13 
14 // -------------------------------------------------------------------------
16 {
18  string m_function;
20  bool m_valid;
21 
22  void CallQueueContext(Class target, string fn, Param params)
23  {
24  m_target = target;
25  m_function = fn;
26  m_params = params;
27  m_valid = true;
28  }
29 
30  void Call()
31  {
33  }
34 
35  void CallParams(Param params)
36  {
37  if (params)
38  {
40  }
41  else
42  {
44  }
45  }
46 
47  void Invalidate() {
48  m_valid = false;
49  }
50 
51  bool IsValid(){
52  return m_valid;
53  }
54 };
55 
56 //--------------------------------------------------------------------------
66 class CallQueue extends array<ref CallQueueContext>
67 {
68  private bool m_processing;
69 
70  void CallQueue()
71  {
72  m_processing = false;
73  }
74 
78  void Tick()
79  {
80  if (m_processing) return;
81 
82  m_processing = true;
83 
84  while(Count() > 0)
85  {
86  CallQueueContext ctx = Get(0);
87  if (!ctx.IsValid())
88  {
89  Remove(0);
90  }
91  else
92  {
93  Remove(0);
94  ctx.Call();
95  }
96  }
97 
98  m_processing = false;
99  }
100 
108  void Call(Class obj, string fn_name, Param params = NULL)
109  {
110  Insert(new CallQueueContext(obj, fn_name, params));
111  }
112 
113 
118  void RemoveCalls(Class obj)
119  {
120  if (Count())
121  {
122  for (int i = Count() - 1; i >= 0; i--)
123  {
124  CallQueueContext ctx = Get(i);
125  if (ctx.m_target == obj)
126  {
127  ctx.Invalidate();
128  }
129  }
130  }
131  }
132 };
133 
134 //--------------------------------------------------------------------------
153 class DragQueue extends CallQueue
154 {
155  private ref Param3<int, int, bool> m_mouse_params; // x,y, is_holding_mb
156 
157  void DragQueue()
158  {
159  m_mouse_params = new Param3<int, int, bool>(0,0,true);
160  }
161 
165  override void Tick()
166  {
167  if (m_processing) return;
168 
169  m_processing = true;
170 
171  int last_index = 0;
172  int mouse_x;
173  int mouse_y;
174  bool is_holding = false;
175  CallQueueContext ctx;
176 
177  if (GetMouseState(MouseState.LEFT) & 0x80000000)
178  {
179  is_holding = true;
180  }
181 
182  GetMousePos(mouse_x, mouse_y);
183 
184  if (!is_holding || mouse_x != m_mouse_params.param1 || mouse_y != m_mouse_params.param2)
185  {
186  m_mouse_params.param1 = mouse_x;
187  m_mouse_params.param2 = mouse_y;
188  m_mouse_params.param3 = is_holding;
189 
190  while (Count() > last_index)
191  {
192  ctx = Get(last_index);
193  if (!ctx.IsValid())
194  {
195  Remove(last_index);
196  }
197  else
198  {
199  ctx.CallParams(m_mouse_params);
200  last_index++;
201  }
202  }
203  }
204 
205  // clear queue when mouse button is released
206  if (!is_holding)
207  {
208  Clear();
209  }
210 
211  m_processing = false;
212  }
213 }
214 
215 //--------------------------------------------------------------------------
219 class TimerBase: Managed
220 {
221  protected bool m_running;
222  protected bool m_loop;
223  protected float m_duration;
224  protected float m_time;
226 
227  void ~TimerBase()
228  {
229  if (!m_timerQueue) return;
230 
231  SetRunning(false);
232  }
233 
234 
238  void Pause()
239  {
240  SetRunning(false);
241  }
242 
246  void Continue()
247  {
248  SetRunning(true);
249  }
250 
254  void Stop()
255  {
256  SetRunning(false);
257  m_time = 0;
258  }
259 
263  bool IsRunning()
264  {
265  return m_running;
266  }
267 
271  void Tick(float timeslice)
272  {
273  if (IsRunning())
274  {
275  m_time = m_time + timeslice;
276 
277  if (m_time >= m_duration)
278  {
279  if (m_loop)
280  {
282  }
283  else
284  {
285  SetRunning(false);
286  m_time = 0;
287  }
288 
289  OnTimer();
290  }
291  else
292  {
293  OnUpdate();
294  }
295  }
296  }
297 
302  {
303  m_timerQueue = NULL;
304  }
305 
306  float GetTime() {
307  return m_time;
308  }
309 
310  float GetDuration() {
311  return m_duration;
312  }
313 
314  float GetRemaining() {
315  return m_duration - m_time;
316  }
317 
318  protected void OnInit(int category)
319  {
320  m_duration = 1;
321  m_loop = false;
322  m_time = 0;
323  m_running = false;
324  m_timerQueue = GetGame().GetTimerQueue(category);
325  }
326 
327  protected void OnStart(float duration, bool loop)
328  {
329  m_duration = duration;
330  m_loop = loop;
331  m_time = 0;
332  SetRunning(true);
333  }
334 
335  protected void OnUpdate() {}
336  protected void OnTimer() {}
337  protected void SetRunning(bool running)
338  {
339  int index = -1;
340 
341  if (m_running == running) return;
342 
343  m_running = running;
344  if (m_timerQueue == NULL) return;
345 
346  if (running)
347  {
348  index = m_timerQueue.Find(this);
349  if (index == -1)
350  {
351  m_timerQueue.Insert(this);
352  }
353  }
354  else
355  {
356  index = m_timerQueue.Find(this);
357  if (index != -1)
358  {
359  m_timerQueue.Remove(index);
360  }
361  }
362  }
363 };
364 
365 //--------------------------------------------------------------------------
369 class TimerQueue extends array<TimerBase>
370 {
371  private bool m_processing;
372 
373  // -------------------------------------------------------------------------
374  void TimerQueue()
375  {
376  m_processing = false;
377  }
378 
379  // -------------------------------------------------------------------------
380  void ~TimerQueue()
381  {
382  if (Count())
383  {
384  for (int i = Count() - 1; i >= 0; i--)
385  {
386  Get(i).OnTimerQueueDestoryed();
387  }
388 
389  Clear();
390  }
391  }
392 
393  // -------------------------------------------------------------------------
394  void Tick(float timeslice)
395  {
396  if (m_processing) return;
397 
398  m_processing = true;
399 
400  if (Count())
401  {
402  for (int i = Count() - 1; i >= 0; i--)
403  {
404  Get(i).Tick(timeslice);
405  }
406  }
407 
408  m_processing = false;
409  }
410 };
411 
412 //--------------------------------------------------------------------------
416 class WidgetFadeTimer extends TimerBase
417 {
418  private Widget m_widget;
419  bool m_fadeIn;
420  float m_alpha;
421 
423  {
425  m_fadeIn = true;
426  }
427 
434  void FadeIn(Widget w, float time, bool continue_ = false)
435  {
436  float alpha = w.GetAlpha();
437 
438  if (continue_ && alpha > 0.95)
439  {
440  w.SetAlpha(1.0);
441  w.Show(true);
442  return;
443  }
444 
445  m_widget = w;
446  m_fadeIn = true;
447 
448  OnStart(time, false);
449 
450  if (m_widget)
451  {
452  alpha = m_widget.GetAlpha();
453  m_widget.SetAlpha(0);
454  m_widget.Show(true);
455  }
456 
457  if (continue_)
458  {
459  m_time = alpha * time;
460  }
461  }
462 
469  void FadeOut(Widget w, float time, bool continue_ = false)
470  {
471  m_alpha = w.GetAlpha();
472 
473  if (continue_ && m_alpha < 0.05)
474  {
475  w.SetAlpha(0);
476  w.Show(false);
477  return;
478  }
479 
480  m_widget = w;
481  m_fadeIn = false;
482 
483  OnStart(time, false);
484 
485  if (m_widget && !continue_)
486  {
487  m_alpha = 1.0;
488  m_widget.SetAlpha(m_alpha);
489  m_widget.Show(true);
490  }
491 
492  if (continue_)
493  {
494  m_time = (1.0 - m_alpha) * time;
495  }
496  }
497 
498  override private void OnTimer()
499  {
500  if (m_widget)
501  {
502  if (m_fadeIn)
503  {
504  m_widget.SetAlpha(1);
505  }
506  else
507  {
508  m_widget.SetAlpha(0);
509  m_widget.Show(false);
510  }
511  }
512  }
513 
514  override private void OnUpdate()
515  {
516  float timeDiff = m_time / m_duration;
517  float progress = Math.Max( 0.0, timeDiff );
518 
519  if ( m_widget )
520  {
521  if ( m_fadeIn )
522  {
523  m_widget.SetAlpha( timeDiff );
524  }
525  else
526  {
527  m_widget.SetAlpha( m_alpha - timeDiff );
528  }
529  }
530  }
531 };
532 
533 //--------------------------------------------------------------------------
563 class Timer extends TimerBase
564 {
565  protected Managed m_target;
566  protected string m_function;
567  protected ref Param m_params;
568 
569  void Timer(int category = CALL_CATEGORY_SYSTEM)
570  {
571  OnInit(category);
572  }
573 
582  void Run(float duration, Managed obj, string fn_name, Param params = NULL, bool loop = false)
583  {
584  m_target = obj;
585  m_function = fn_name;
586 
587  m_params = params;
588  OnStart(duration, loop);
589  }
590 
591  override protected void OnTimer()
592  {
593  if (m_params)
594  {
595  GetGame().GameScript.CallFunctionParams(m_target, m_function, NULL, m_params);
596  m_params = NULL;
597  }
598  else
599  {
600  GetGame().GameScript.CallFunction(m_target, m_function, NULL, 0);
601  }
602  }
603 
604  override void Stop()
605  {
606  super.Stop();
607  m_params = NULL;
608  }
609 };
610 
611 
612 
613 //--------------------------------------------------------------------------
638 {
639  private bool m_active = false;
640  private bool m_loop = false;
641  private float m_target_value = 0;
642  private float m_value = 0;
643  private float m_time = 0;
644 
650  void Animate(float val, float speed = 1.0)
651  {
652  m_target_value = val;
653  m_loop = false;
654  m_time = speed;
655  m_active = true;
656  }
657 
662  void AnimateLoop(float speed = 1.0)
663  {
664  m_value = 0;
665  m_target_value = 0;
666  m_loop = true;
667  m_time = speed;
668  m_active = true;
669  }
670 
674  float GetValue() {
675  return m_value;
676  }
677 
681  float GetTargetValue() {
682  return m_target_value;
683  }
684 
688  void SetValue(float val) {
689  m_value = val;
690  m_target_value = val;
691  }
692 
693  bool IsRunning()
694  {
695  return m_active;
696  }
700  void Tick(float timeslice)
701  {
702  if ( !m_active ) return;
703 
704  if (m_loop)
705  {
706  m_target_value += m_time * Math.PI2 * timeslice;
708 
710  }
711  else
712  {
713  float diff = Math.AbsFloat(m_target_value - m_value);
714  float step = m_time * timeslice;
715 
716  if (diff < step)
717  {
719  m_active = false;
720  }
721  else
722  {
723  if (m_target_value > m_value)
724  {
725  m_value += step;
726  }
727  else
728  {
729  m_value -= step;
730  }
731  }
732  }
733  }
734 };
735 
756 class multiMap<Class K, Class V>
757 {
758  private ref array<ref array<V> > m_values;
759  private ref array<K> m_keys;
760 
761  bool HasKey(K key)
762  {
763  int index = -1;
764  if (m_keys)
765  {
766  index = m_keys.Find(key);
767  }
768 
769  if (index != -1)
770  {
771  return true;
772  }
773 
774  return false;
775  }
776 
777  array<V> Get(K key)
778  {
779  int index = -1;
780  if (m_keys)
781  {
782  index = m_keys.Find(key);
783  }
784 
785  if (index != -1)
786  {
787  return m_values.Get(index);
788  }
789 
790  return NULL;
791  }
792 
793  array<V> GetByIndex(int index)
794  {
795  return m_values.Get(index);
796  }
797 
798  K GetKeyByIndex(int index)
799  {
800  return m_keys.Get(index);
801  }
802 
803  void Insert(K key, V value)
804  {
805  int index = -1;
806 
807  if (!m_keys)
808  {
809  m_keys = new array<K>;
810  m_values = new array<ref array<V> >;
811  }
812  else
813  {
814  index = m_keys.Find(key);
815  }
816 
817  if (index == -1)
818  {
819  array<V> value_array = new array<V>;
820  value_array.Insert(value);
821 
822  m_keys.Insert(key);
823  m_values.Insert(value_array);
824 
825  }
826  else
827  {
828  m_values.Get(index).Insert(value);
829  }
830  }
831 
832  void RemoveByIndex(int index)
833  {
834  m_keys.Remove(index);
835  m_values.Remove(index);
836  }
837 
838  void Remove(K key)
839  {
840  int index = -1;
841  if (m_keys)
842  {
843  index = m_keys.Find(key);
844  }
845 
846  if (index != -1)
847  {
848  RemoveByIndex(index);
849  }
850  }
851 
852  int Count()
853  {
854  if (m_keys)
855  {
856  return m_keys.Count();
857  }
858 
859  return 0;
860  }
861 
862  void Clear()
863  {
864  if ( m_keys && m_values)
865  {
866  m_keys.Clear();
867  m_values.Clear();
868  }
869 
870  }
871 
872  void ~multiMap()
873  {
874  Clear();
875  }
876 };
877 
878 // at last one template definition should be here, for template initialization in this script module
880 
881 int GetTemperatureColor( int temperature )
882 {
883  int alpha = 255;
884  int red = 153;
885  int green = 153;
886  int blue = 153;
887  if ( temperature < 20 )
888  {
889  temperature = temperature - 20;
890  temperature = Math.Clamp( temperature, -50, 50);
891  temperature = Math.AbsInt(temperature);
892 
893  red = Math.Clamp ( red - ((red/50 )*temperature), 0, 255 );
894  green = Math.Clamp ( green - ((green/50 )*temperature), 0, 255 );
895  blue = Math.Clamp ( blue+((blue/50)*temperature), 0, 255 );
896  }
897  else if ( temperature > 20 )
898  {
899  temperature = Math.Clamp( temperature, -100, 100);
900  blue = Math.Clamp ( blue - ((blue/100 )*temperature), 0, 255 );
901  green = Math.Clamp ( green - ((green/100 )*temperature), 0, 255 );
902  red = Math.Clamp ( red+((red/100)*temperature), 0, 255 );
903  }
904 
905  int color = ARGB( alpha, red, green, blue );
906  return color;
907 }
908 
910 bool GetProfileValueBool(string name, bool def = false)
911 {
912  string value;
913  if (GetGame().GetProfileString(name, value))
914  {
915  if (value == "true" || value == "1")
916  {
917  return true;
918  }
919  else
920  {
921  return false;
922  }
923  }
924  else
925  {
926  return def;
927  }
928 }
929 
931 void SetProfileValueBool(string name, bool value)
932 {
933  if (value)
934  {
935  GetGame().SetProfileString(name, "1");
936  }
937  else
938  {
939  GetGame().SetProfileString(name, "0");
940  }
941 }
942 
943 
945 {
946  i = i - ((i >> 1) & 0x55555555);
947  i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
948  return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
949 }
950 
GetGame
proto native CGame GetGame()
multiMap< Class K, Class V >::Insert
void Insert(K key, V value)
Definition: tools.c:803
CALL_CATEGORY_SYSTEM
const int CALL_CATEGORY_SYSTEM
Definition: tools.c:8
IsRunning
bool IsRunning()
Definition: tools.c:263
multiMap< Class K, Class V >::HasKey
bool HasKey(K key)
Definition: tools.c:761
Continue
void Continue()
Timer continue when it was paused.
Definition: tools.c:246
TimerBase::OnTimer
override protected void OnTimer()
Definition: tools.c:591
CALL_CATEGORY_GAMEPLAY
const int CALL_CATEGORY_GAMEPLAY
Definition: tools.c:10
m_loop
protected bool m_loop
Definition: tools.c:222
Math::PI2
static const float PI2
Definition: EnMath.c:9
GetProfileValueBool
bool GetProfileValueBool(string name, bool def=false)
Return value from profile variable, if variable with given name is not present, default value is retu...
Definition: tools.c:910
array< ref CallQueueContext >::Call
void Call(Class obj, string fn_name, Param params=NULL)
Creates new call request, add it on queue and execute during frame update (depends on call category)
Definition: tools.c:108
Param
Base Param Class with no parameters.
Definition: param.c:11
TimerBase::m_widget
private Widget m_widget
Definition: tools.c:418
TimerBase::m_params
protected ref Param m_params
Definition: tools.c:567
Remove
void Remove(Object object)
Definition: ActionTargets.c:83
Tick
void Tick(float timeslice)
System function, don't call.
Definition: tools.c:271
Math::Clamp
static float Clamp(float value, float min, float max)
Clamps 'value' to 'min' if it is lower than 'min', or to 'max' if it is higher than 'max'.
Definition: EnMath.c:317
multiMap< Class K, Class V >::Remove
void Remove(K key)
Definition: tools.c:838
CallQueue::DragQueue
void DragQueue()
Definition: tools.c:157
array< TimerBase >::Tick
void Tick(float timeslice)
Definition: tools.c:394
TimerBase::FadeIn
void FadeIn(Widget w, float time, bool continue_=false)
Make "fade in" effect on Widget (transparency goes from 0.0 to 1.0)
Definition: tools.c:434
GetMousePos
proto void GetMousePos(out int x, out int y)
CallQueueContext::m_target
Class m_target
Definition: tools.c:17
CallQueue
DragQueue Class provide callbacks while mouse is dragging.
Definition: tools.c:153
m_time
protected float m_time
Definition: tools.c:224
m_duration
protected float m_duration
Definition: tools.c:223
Math::Sin
proto static native float Sin(float angle)
Returns sinus of angle in radians.
Managed
TODO doc.
Definition: EnScript.c:88
multiMap< Class K, Class V >::GetByIndex
array< V > GetByIndex(int index)
Definition: tools.c:793
TimerBase::Timer
void Timer(int category=CALL_CATEGORY_SYSTEM)
Definition: tools.c:569
OnTimerQueueDestoryed
void OnTimerQueueDestoryed()
System function, don't call.
Definition: tools.c:301
TimerBase::FadeOut
void FadeOut(Widget w, float time, bool continue_=false)
Make "fade out" effect on Widget (transparency goes from 1.0 to 0.0)
Definition: tools.c:469
AnimatorTimer::Tick
void Tick(float timeslice)
Ticks the timer, is called by timer subsystem.
Definition: tools.c:700
ScriptModule::CallFunction
proto volatile int CallFunction(Class inst, string function, out void returnVal, void parm)
dynamic call of function when inst == NULL, it's global function call, otherwise it's method of class...
m_timerQueue
protected array< TimerBase > m_timerQueue
Definition: tools.c:225
TimerBase::m_alpha
float m_alpha
Definition: tools.c:420
CALL_CATEGORY_GUI
const int CALL_CATEGORY_GUI
Definition: tools.c:9
AnimatorTimer::m_active
private bool m_active
Definition: tools.c:639
SetRunning
protected void SetRunning(bool running)
Definition: tools.c:337
array< TimerBase >::TimerQueue
void TimerQueue()
Definition: tools.c:374
GetDuration
float GetDuration()
Definition: tools.c:310
map< string, string >
AnimatorTimer::IsRunning
bool IsRunning()
Definition: tools.c:693
CallQueueContext::m_function
string m_function
Definition: tools.c:18
TimerBase
Simple class for fading Widgets.
Definition: tools.c:416
multiMap< Class K, Class V >::m_values
private ref array< ref array< V > > m_values
Definition: tools.c:758
multiMap< Class K, Class V >::Clear
void Clear()
Definition: tools.c:862
GetNumberOfSetBits
int GetNumberOfSetBits(int i)
Definition: tools.c:944
GetRemaining
float GetRemaining()
Definition: tools.c:314
CallQueueContext::IsValid
bool IsValid()
Definition: tools.c:51
CALL_CATEGORY_COUNT
const int CALL_CATEGORY_COUNT
Definition: tools.c:12
GetTime
float GetTime()
Definition: tools.c:306
ScriptModule::CallFunctionParams
proto volatile int CallFunctionParams(Class inst, string function, out void returnVal, Class parms)
array< TimerBase >::~TimerQueue
void ~TimerQueue()
Definition: tools.c:380
name
string name
Definition: PluginDayZInfectedDebug.c:32
array< ref CallQueueContext >::Tick
void Tick()
System function, don't call it.
Definition: tools.c:78
array< ref CallQueueContext >::CallQueue
void CallQueue()
Definition: tools.c:70
TimerBase::m_target
protected Managed m_target
Definition: tools.c:565
array< ref CallQueueContext >::m_processing
private bool m_processing
Definition: tools.c:68
AnimatorTimer::GetValue
float GetValue()
Returns actual animated value.
Definition: tools.c:674
Count
@ Count
Definition: RandomGeneratorSyncManager.c:7
SetProfileValueBool
void SetProfileValueBool(string name, bool value)
Writes bool variable to profile, after write don't forget to call CGame::SaveProfile() to save profil...
Definition: tools.c:931
TimerBase::m_fadeIn
bool m_fadeIn
Definition: tools.c:419
TimerBase::Run
void Run(float duration, Managed obj, string fn_name, Param params=NULL, bool loop=false)
Starts timer.
Definition: tools.c:582
~TimerBase
void ~TimerBase()
Definition: tools.c:227
TimerBase::WidgetFadeTimer
void WidgetFadeTimer()
Definition: tools.c:422
AnimatorTimer::m_value
private float m_value
Definition: tools.c:642
AnimatorTimer::m_target_value
private float m_target_value
Definition: tools.c:641
CallQueueContext::Invalidate
void Invalidate()
Definition: tools.c:47
CGame::GameScript
ScriptModule GameScript
Definition: Game.c:16
multiMap< Class K, Class V >::Count
int Count()
Definition: tools.c:852
GetMouseState
proto native int GetMouseState(MouseState index)
Returns state of mouse button.
CGame::GetTimerQueue
TimerQueue GetTimerQueue(int call_category)
Returns TimerQueue for certain category.
Definition: Game.c:1201
MouseState
MouseState
Definition: EnSystem.c:310
multiMap< Class K, Class V >::Get
array< V > Get(K key)
Definition: tools.c:777
Pause
void Pause()
Pause Timer, internal counter is not restarted, so timer can continue later.
Definition: tools.c:238
AnimatorTimer::SetValue
void SetValue(float val)
Sets both value and target value.
Definition: tools.c:688
array< ref CallQueueContext >::RemoveCalls
void RemoveCalls(Class obj)
Removes all queued calls for object (call this function when object is going to be deleted)
Definition: tools.c:118
multiMap< Class K, Class V >::RemoveByIndex
void RemoveByIndex(int index)
Definition: tools.c:832
GetTemperatureColor
int GetTemperatureColor(int temperature)
Definition: tools.c:881
CallQueueContext
Definition: tools.c:15
Math::Max
static float Max(float x, float y)
Returns bigger of two given values.
Definition: EnMath.c:394
Get
array< ref PlayerStatBase > Get()
Definition: PlayerStatsPCO.c:103
TStringMap
map< string, string > TStringMap
Definition: tools.c:879
m_running
class DragQueue extends CallQueue m_running
TimerBase Class provide just interface for all Timer classes.
multiMap< Class K, Class V >::m_keys
private ref array< K > m_keys
Definition: tools.c:759
CallQueue::Tick
override void Tick()
System function, don't call it.
Definition: tools.c:165
AnimatorTimer::m_loop
private bool m_loop
Definition: tools.c:640
AnimatorTimer::Animate
void Animate(float val, float speed=1.0)
Starts animate value until value reaches target value.
Definition: tools.c:650
TimerBase::OnUpdate
override private void OnUpdate()
Definition: tools.c:514
TimerBase::OnTimer
override private void OnTimer()
Definition: tools.c:498
AnimatorTimer::GetTargetValue
float GetTargetValue()
Returns target value.
Definition: tools.c:681
AnimatorTimer::AnimateLoop
void AnimateLoop(float speed=1.0)
Starts infinite animation loop <-1,1>.
Definition: tools.c:662
TimerBase::Stop
override void Stop()
Definition: tools.c:604
CallQueueContext::m_params
ref Param m_params
Definition: tools.c:19
OnInit
protected void OnInit(int category)
Definition: tools.c:318
AnimatorTimer::m_time
private float m_time
Definition: tools.c:643
CallQueueContext::CallQueueContext
void CallQueueContext(Class target, string fn, Param params)
Definition: tools.c:22
CallQueueContext::m_valid
bool m_valid
Definition: tools.c:20
multiMap< Class K, Class V >::GetKeyByIndex
K GetKeyByIndex(int index)
Definition: tools.c:798
OnStart
protected void OnStart(float duration, bool loop)
Definition: tools.c:327
CallQueueContext::Call
void Call()
Definition: tools.c:30
Widget
Definition: EnWidgets.c:166
array< TimerBase >::m_processing
private bool m_processing
Definition: tools.c:371
Math::AbsFloat
proto static native float AbsFloat(float f)
Returns absolute value.
CGame::SetProfileString
proto native void SetProfileString(string name, string value)
Sets string to profile variable.
array< TimerBase >
TimerQueue Class using for system purpose only.
Definition: tools.c:369
Math
Definition: EnMath.c:6
Class
Super root of all classes in Enforce script.
Definition: EnScript.c:7
multiMap< Class K, Class V >::~multiMap
void ~multiMap()
Definition: tools.c:872
CallQueueContext::CallParams
void CallParams(Param params)
Definition: tools.c:35
ARGB
int ARGB(int a, int r, int g, int b)
Definition: proto.c:322
TimerBase::m_function
protected string m_function
Definition: tools.c:566
AnimatorTimer
AnimatorTimer class.
Definition: tools.c:637
Math::AbsInt
proto static native int AbsInt(int i)
Returns absolute value.
CallQueue::m_mouse_params
private ref Param3< int, int, bool > m_mouse_params
Definition: tools.c:155