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;
 
    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_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;
    }
        
    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_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)
    {
        float alpha = w.GetAlpha();
        
        if (continue_ && alpha > 0.95)
        {
            w.SetAlpha(1.0);
            w.Show(true);
            return;
        }   
        
        m_widget = w;
        m_fadeIn = true;
    
        OnStart(time, false);
    
        if (m_widget)
        {
            alpha = m_widget.GetAlpha();
            m_widget.SetAlpha(0);
            m_widget.Show(true);
        }
    
        if (continue_)
        {
            m_time = 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 = Math.Max( 0.0, timeDiff );
    
        if ( m_widget )
        {
            if ( m_fadeIn )
            {
                m_widget.SetAlpha( timeDiff );
            }
            else
            {
                m_widget.SetAlpha( m_alpha - timeDiff );
            }
        }
    }
};
 
//--------------------------------------------------------------------------
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);
}