tools.c

Go to the documentation of this file.

 
//--------------------------------------------------------------------------
const int CALL_CATEGORY_SYSTEM = 0; // Runs always
const int CALL_CATEGORY_GUI = 1; // Runs always (on client)
const int CALL_CATEGORY_GAMEPLAY = 2; // Runs unless ingame menu is opened
 
const int CALL_CATEGORY_COUNT = 3;
 
// -------------------------------------------------------------------------
class CallQueueContext
{
  Class m_target;
  string m_function;
  ref Param m_params;
  bool m_valid;
 
  void CallQueueContext(Class target, string fn, Param params)
  {
    m_target = target;
    m_function = fn;
    m_params = params;
    m_valid = true;
  }
 
  void Call()
  {
    CallParams(m_params);
  }
 
  void CallParams(Param params)
  {
    if (params)
      GetGame().GameScript.CallFunctionParams(m_target, m_function, NULL, params);
    else
      GetGame().GameScript.CallFunction(m_target, m_function, NULL, 0);
  }
 
  void Invalidate()
  {
    m_valid = false;
  }
 
  bool IsValid()
  {
    return m_valid;
  }
};
 
//--------------------------------------------------------------------------
class CallQueue extends array<ref CallQueueContext>
{
  private bool m_processing;
 
  void CallQueue()
  {
    m_processing = false;
  }
 
  void Tick()
  {
    if (m_processing) return;
 
    m_processing = true;
 
    while (Count() > 0)
    {
      CallQueueContext ctx = Get(0);
      if (!ctx.IsValid())
        Remove(0);
      else
      {
        Remove(0);
        ctx.Call();
      }
    }
 
    m_processing = false;
  }
 
  void Call(Class obj, string fn_name, Param params = NULL)
  {
    Insert(new CallQueueContext(obj, fn_name, params));
  }
 
 
  void RemoveCalls(Class obj)
  {
    if (Count())
    {
      for (int i = Count() - 1; i >= 0; i--)
      {
        CallQueueContext ctx = Get(i);
        if (ctx.m_target == obj)
          ctx.Invalidate();
      }
    }
  }
};
 
//--------------------------------------------------------------------------
class DragQueue extends CallQueue
{
  private ref Param3<int, int, bool> m_mouse_params; // x,y, is_holding_mb
 
  void DragQueue()
  {
    m_mouse_params = new Param3<int, int, bool>(0, 0, true);
  }
 
  override void Tick()
  {
    if (m_processing) return;
 
    m_processing = true;
 
    int last_index = 0;
    int mouse_x;
    int mouse_y;
    bool is_holding = false;
    CallQueueContext ctx;
 
    if (GetMouseState(MouseState.LEFT) & 0x80000000)
      is_holding = true;
 
    GetMousePos(mouse_x, mouse_y);
 
    if (!is_holding || mouse_x != m_mouse_params.param1 || mouse_y != m_mouse_params.param2)
    {
      m_mouse_params.param1 = mouse_x;
      m_mouse_params.param2 = mouse_y;
      m_mouse_params.param3 = is_holding;
 
      while (Count() > last_index)
      {
        ctx = Get(last_index);
        if (!ctx.IsValid())
          Remove(last_index);
        else
        {
          ctx.CallParams(m_mouse_params);
          last_index++;
        }
      }
    }
 
    // clear queue when mouse button is released
    if (!is_holding)
      Clear();
 
    m_processing = false;
  }
}
 
//--------------------------------------------------------------------------
class TimerBase: Managed
{
  protected bool m_running;
  protected bool m_loop;
  protected float m_duration;
  protected float m_time;
  protected array<TimerBase> m_timerQueue;
  protected float m_RunTime;
 
  void ~TimerBase()
  {
    if (!m_timerQueue) return;
 
    SetRunning(false);
  }
 
 
  void Pause()
  {
    SetRunning(false);
  }
 
  void Continue()
  {
    SetRunning(true);
  }
 
  void Stop()
  {
    SetRunning(false);
    m_time = 0;
  }
 
  bool IsRunning()
  {
    return m_running;
  }
 
  void Tick(float timeslice)
  {
    if (IsRunning())
    {
      m_RunTime += timeslice;
      m_time = m_time + timeslice;
 
      if (m_time >= m_duration)
      {
        if (m_loop)
          m_time = m_time - m_duration;
        else
        {
          SetRunning(false);
          m_time = 0;
        }
 
        OnTimer();
      }
      else
        OnUpdate();
    }
  }
 
  void OnTimerQueueDestoryed()
  {
    m_timerQueue = NULL;
  }
 
  float GetTime()
  {
    return m_time;
  }
 
  float GetDuration()
  {
    return m_duration;
  }
 
  float GetRemaining()
  {
    return m_duration - m_time;
  }
 
  float GetRunTime()
  {
    return m_RunTime;
  }
 
  protected void OnInit(int category)
  {
    m_duration = 1;
    m_loop = false;
    m_time = 0;
    m_running = false;
    if (GetGame())
      m_timerQueue = GetGame().GetTimerQueue(category);
    else
      ErrorEx("Attempting to Init a timer when the game does not exist (GetGame() == null)");
  }
 
  protected void OnStart(float duration, bool loop)
  {
    m_RunTime = 0;
    m_duration = duration;
    m_loop = loop;
    m_time = 0;
    SetRunning(true);
  }
 
  protected void OnUpdate() {}
  protected void OnTimer() {}
  protected void SetRunning(bool running)
  {
    int index = -1;
 
    if (m_running == running) return;
 
    m_running = running;
    if (m_timerQueue == NULL) return;
 
    if (running)
    {
      if (m_timerQueue.Find(this) == -1)
        m_timerQueue.Insert(this);
    }
    else
    {
      index = m_timerQueue.Find(this);
      if (index != -1)
        m_timerQueue.Remove(index);
    }
  }
};
 
//--------------------------------------------------------------------------
class TimerQueue extends array<TimerBase>
{
  private bool m_processing;
 
  // -------------------------------------------------------------------------
  void TimerQueue()
  {
    m_processing = false;
  }
 
  // -------------------------------------------------------------------------
  void ~TimerQueue()
  {
    if (Count())
    {
      for (int i = Count() - 1; i >= 0; i--)
        Get(i).OnTimerQueueDestoryed();
 
      Clear();
    }
  }
 
  // -------------------------------------------------------------------------
  void Tick(float timeslice)
  {
    if (m_processing) return;
 
    m_processing = true;
 
    if (Count())
    {
      for (int i = Count() - 1; i >= 0; i--)
        Get(i).Tick(timeslice);
    }
 
    m_processing = false;
  }
};
 
//--------------------------------------------------------------------------
class WidgetFadeTimer extends TimerBase
{
  private Widget m_widget;
  bool m_fadeIn;
  float m_alpha;
 
  void WidgetFadeTimer()
  {
    OnInit(CALL_CATEGORY_GUI);
    m_fadeIn = true;
  }
 
  void FadeIn(Widget w, float time, bool continue_ = false)
  {
    m_alpha = w.GetAlpha();
 
    if (continue_ && m_alpha > 0.95)
    {
      w.SetAlpha(1.0);
      w.Show(true);
      return;
    }
 
    m_widget = w;
    m_fadeIn = true;
 
    OnStart(time, false);
 
    if (m_widget)
    {
      m_alpha = m_widget.GetAlpha();
      m_widget.SetAlpha(0);
      m_widget.Show(true);
    }
 
    if (continue_)
      m_time = m_alpha * time;
  }
 
  void FadeOut(Widget w, float time, bool continue_ = false)
  {
    m_alpha = w.GetAlpha();
 
    if (continue_ && m_alpha < 0.05)
    {
      w.SetAlpha(0);
      w.Show(false);
      return;
    }
 
    m_widget = w;
    m_fadeIn = false;
 
    OnStart(time, false);
 
    if (m_widget && !continue_)
    {
      m_alpha = 1.0;
      m_widget.SetAlpha(m_alpha);
      m_widget.Show(true);
    }
 
    if (continue_)
      m_time = (1.0 - m_alpha) * time;
  }
 
  override private void OnTimer()
  {
    if (m_widget)
    {
      if (m_fadeIn)
        m_widget.SetAlpha(1);
      else
      {
        m_widget.SetAlpha(0);
        m_widget.Show(false);
      }
    }
  }
 
  override private void OnUpdate()
  {
    float timeDiff = m_time / m_duration;
    float progress;
    if (m_widget)
    {
      if (m_fadeIn)
        progress = timeDiff;
      else
      {
        progress = Math.Lerp(m_alpha, 0, timeDiff);
        progress = Math.Clamp(progress, 0, 1);
      }
 
      m_widget.SetAlpha(progress);
    }
  }
};
 
//--------------------------------------------------------------------------
class Timer extends TimerBase
{
  protected Managed m_target;
  protected string m_function;
  protected ref Param m_params;
 
  void Timer(int category = CALL_CATEGORY_SYSTEM)
  {
    OnInit(category);
  }
 
  void Run(float duration, Managed obj, string fn_name, Param params = NULL, bool loop = false)
  {
    m_target = obj;
    m_function = fn_name;
 
    m_params = params;
    OnStart(duration, loop);
  }
 
  override protected void OnTimer()
  {
    if (m_params)
    {
      GetGame().GameScript.CallFunctionParams(m_target, m_function, NULL, m_params);
      m_params = NULL;
    }
    else
      GetGame().GameScript.CallFunction(m_target, m_function, NULL, 0);
  }
 
  override void Stop()
  {
    super.Stop();
    m_params = NULL;
  }
};
 
 
//--------------------------------------------------------------------------
class AnimationTimer : TimerBase
{
  private bool m_Active;
  private float m_TargetValue;
  private float m_TargetValueOriginal;
  private float m_Value;
  protected Managed m_TargetObject;
  protected string m_UpdateFunction;
  protected string m_FinishedFunction;
  protected ref Param m_Params;
 
  void AnimationTimer(int category = CALL_CATEGORY_SYSTEM)
  {
    OnInit(category);
  }
 
  void ~AnimationTimer()
  {
    SetRunning(false);
  }
 
  void Run(float targetVal, Managed obj, string updateFunc, string finishedFunc, float startingVal = 0, bool loop = false, float speed = 1.0, Param params = null, int category = CALL_CATEGORY_SYSTEM)
  {
    SetRunning(true);
    m_TargetObject = obj;
    m_UpdateFunction = updateFunc;
    m_FinishedFunction = finishedFunc;
    m_TargetValueOriginal = targetVal;
    m_TargetValue = targetVal;
    m_time = speed;
    m_loop = loop;
    m_Active = true;
    m_Params = params;
    m_Value = startingVal;
  }
 
  float GetValue()
  {
    return m_Value;
  }
 
  override bool IsRunning()
  {
    return m_Active;
  }
  override void Tick(float timeslice)
  {
    if (!m_Active)
      return;
 
 
    float diff = Math.AbsFloat(m_TargetValue - m_Value);
    float step = m_time * timeslice;
 
    if (diff < step)
    {
      m_Value = m_TargetValue;
      if (!m_loop)
        m_Active = false;
      else
      {
        if (m_TargetValue == m_TargetValueOriginal)
          m_TargetValue = 0;
        else
          m_TargetValue = m_TargetValueOriginal;
 
      }
      GetGame().GameScript.CallFunction(m_TargetObject, m_FinishedFunction, NULL, m_Params);
    }
    else
    {
      if (m_TargetValue > m_Value)
        m_Value += step;
      else
        m_Value -= step;
    }
 
    GetGame().GameScript.CallFunction(m_TargetObject, m_UpdateFunction, NULL, m_Params);
  }
};
 
class AnimatorTimer
{
  private bool m_active = false;
  private bool m_loop = false;
  private float m_target_value = 0;
  private float m_value = 0;
  private float m_time = 0;
 
  void Animate(float val, float speed = 1.0)
  {
    m_target_value = val;
    m_loop = false;
    m_time = speed;
    m_active = true;
  }
 
  void AnimateLoop(float speed = 1.0)
  {
    m_value = 0;
    m_target_value = 0;
    m_loop = true;
    m_time = speed;
    m_active = true;
  }
 
  float GetValue()
  {
    return m_value;
  }
 
  float GetTargetValue()
  {
    return m_target_value;
  }
 
  void SetValue(float val)
  {
    m_value = val;
    m_target_value = val;
  }
 
  bool IsRunning()
  {
    return m_active;
  }
  void Tick(float timeslice)
  {
    if (!m_active) return;
 
    if (m_loop)
    {
      m_target_value += m_time * Math.PI2 * timeslice;
      while (m_target_value > Math.PI2) m_target_value -= Math.PI2;
 
      m_value = Math.Sin(m_target_value);
    }
    else
    {
      float diff = Math.AbsFloat(m_target_value - m_value);
      float step = m_time * timeslice;
 
      if (diff < step)
      {
        m_value = m_target_value;
        m_active = false;
      }
      else
      {
        if (m_target_value > m_value)
          m_value += step;
        else
          m_value -= step;
      }
    }
  }
};
 
class multiMap<Class K, Class V>
{
  private ref array<ref array<V> > m_values;
  private ref array<K> m_keys;
 
  bool HasKey(K key)
  {
    int index = -1;
    if (m_keys)
      index = m_keys.Find(key);
 
    if (index != -1)
      return true;
 
    return false;
  }
 
  array<V> Get(K key)
  {
    int index = -1;
    if (m_keys)
      index = m_keys.Find(key);
 
    if (index != -1)
      return m_values.Get(index);
 
    return NULL;
  }
 
  array<V> GetByIndex(int index)
  {
    return m_values.Get(index);
  }
 
  K GetKeyByIndex(int index)
  {
    return m_keys.Get(index);
  }
 
  void Insert(K key, V value)
  {
    int index = -1;
 
    if (!m_keys)
    {
      m_keys = new array<K>;
      m_values = new array<ref array<V> >;
    }
    else
      index = m_keys.Find(key);
 
    if (index == -1)
    {
      array<V> value_array = new array<V>;
      value_array.Insert(value);
 
      m_keys.Insert(key);
      m_values.Insert(value_array);
 
    }
    else
      m_values.Get(index).Insert(value);
  }
 
  void RemoveByIndex(int index)
  {
    m_keys.Remove(index);
    m_values.Remove(index);
  }
 
  void Remove(K key)
  {
    int index = -1;
    if (m_keys)
      index = m_keys.Find(key);
 
    if (index != -1)
      RemoveByIndex(index);
  }
 
  int Count()
  {
    if (m_keys)
      return m_keys.Count();
 
    return 0;
  }
 
  void Clear()
  {
    if (m_keys && m_values)
    {
      m_keys.Clear();
      m_values.Clear();
    }
 
  }
 
  void ~multiMap()
  {
    Clear();
  }
};
 
// at last one template definition should be here, for template initialization in this script module
typedef map<string, string> TStringMap;
 
int GetTemperatureColor(int temperature)
{
  int alpha = 255;
  int red = 153;
  int green = 153;
  int blue = 153;
  if (temperature < 20)
  {
    temperature = temperature - 20;
    temperature = Math.Clamp(temperature, -50, 50);
    temperature = Math.AbsInt(temperature);
 
    red = Math.Clamp(red - ((red / 50) * temperature), 0, 255);
    green = Math.Clamp(green - ((green / 50) * temperature), 0, 255);
    blue = Math.Clamp(blue + ((blue / 50) * temperature), 0, 255);
  }
  else if (temperature > 20)
  {
    temperature = Math.Clamp(temperature, -100, 100);
    blue = Math.Clamp(blue - ((blue / 100) * temperature), 0, 255);
    green = Math.Clamp(green - ((green / 100) * temperature), 0, 255);
    red = Math.Clamp(red + ((red / 100) * temperature), 0, 255);
  }
 
  int color = ARGB(alpha, red, green, blue);
  return color;
}
 
bool GetProfileValueBool(string name, bool def = false)
{
  string value;
  if (GetGame().GetProfileString(name, value))
  {
    if (value == "true" || value == "1")
      return true;
    else
      return false;
  }
  else
    return def;
}
 
void SetProfileValueBool(string name, bool value)
{
  if (value)
    GetGame().SetProfileString(name, "1");
  else
    GetGame().SetProfileString(name, "0");
}
 
 
int GetNumberOfSetBits(int i)//leaving here for legacy/modding reasons
{
  return Math.GetNumberOfSetBits(i);
}