heatcomfortanimhandler.c

Go to the documentation of this file.

class HeatComfortAnimHandler
{
    const float TICK_INTERVAL  = 2;
    
    float m_TimeSinceLastTick;
    float m_ProcessTimeAccuFreeze;
    float m_ProcessTimeAccuFreezeRattle;
    float m_ProcessTimeAccuHot;
    
    PlayerBase m_Player;
    
    float m_EventTimeFreezeRattle = -1;         // -1 = symptom effect needs to be triggered for first time
    float m_EventTimeFreeze = -1;           
    float m_EventTimeHot = -1;  
    
    protected ref HumanMovementState m_MovementState = new HumanMovementState();
    
    const float TIME_INTERVAL_HC_MINUS_LOW_MIN  = 12;   // Freezing and rattle symptoms interval minimum, lerped according to heat confort
    const float TIME_INTERVAL_HC_MINUS_HIGH_MIN = 25; 
    
    const float TIME_INTERVAL_HC_MINUS_LOW_MAX  = 20;   // Interval maximum, lerped according to heat confort
    const float TIME_INTERVAL_HC_MINUS_HIGH_MAX = 40;
    
    const float TIME_INTERVAL_HC_PLUS_LOW_MIN   = 12;   // Ditto for heat symptoms
    const float TIME_INTERVAL_HC_PLUS_HIGH_MIN  = 25;
    
    const float TIME_INTERVAL_HC_PLUS_LOW_MAX   = 20;
    const float TIME_INTERVAL_HC_PLUS_HIGH_MAX  = 40;
    
    void HeatComfortAnimHandler(PlayerBase player)
    {
        m_Player = player;
    }
 
    void Update(float delta_time, HumanMovementState hms)
    {
        m_TimeSinceLastTick += delta_time;
 
        if (m_TimeSinceLastTick > TICK_INTERVAL)
        {
            if (g_Game.IsServer())
                Process(m_TimeSinceLastTick);
            
            m_TimeSinceLastTick = 0;
        }
    }
 
    void Process(float delta_time)
    {
        float hc = m_Player.GetStatHeatComfort().Get();
 
        if (hc >= PlayerConstants.THRESHOLD_HEAT_COMFORT_PLUS_WARNING)          // Yellow zone
        {
            m_ProcessTimeAccuHot += delta_time;
            
            if (m_EventTimeHot < 0 || m_ProcessTimeAccuHot >= m_EventTimeHot)
                ProcessHot(hc);
        }
        else if (Math.IsInRange(hc, PlayerConstants.THRESHOLD_HEAT_COMFORT_MINUS_WARNING, PlayerConstants.THRESHOLD_HEAT_COMFORT_PLUS_WARNING))
        {
            // White zone, reset the timers
            
            if (m_EventTimeHot > -1 && hc <= 0)
                m_EventTimeHot = -1;
            
            if (m_EventTimeFreeze > -1 && hc >= 0)
                m_EventTimeFreeze = -1;
            
            if (m_EventTimeFreezeRattle > -1)
                m_EventTimeFreezeRattle = -1;
    
        }
        else if (hc <= PlayerConstants.THRESHOLD_HEAT_COMFORT_MINUS_WARNING)    // Light blue zone
        {
            if (hc <= PlayerConstants.THRESHOLD_HEAT_COMFORT_MINUS_CRITICAL)    // Deep blue blinking zone, rattling is layerd on top of freezing
            {
                m_ProcessTimeAccuFreezeRattle += delta_time;
                
                if (m_EventTimeFreezeRattle < 0 || m_ProcessTimeAccuFreezeRattle >= m_EventTimeFreezeRattle)
                    ProcessFreezeRattle(hc);    
            }
            
            m_ProcessTimeAccuFreeze += delta_time;
            
            if (m_EventTimeFreeze < 0 || m_ProcessTimeAccuFreeze >= m_EventTimeFreeze)  
                ProcessFreeze(hc);  
        }
        
    //  Debug.Log("HeatComfort: " + hc);
    }
 
    private void ProcessHot(float hcValue)
    {
        m_Player.GetSymptomManager().QueueUpPrimarySymptom(SymptomIDs.SYMPTOM_HOT);     
        m_EventTimeHot = GetEventTime(hcValue, PlayerConstants.THRESHOLD_HEAT_COMFORT_PLUS_EMPTY, PlayerConstants.THRESHOLD_HEAT_COMFORT_PLUS_WARNING, TIME_INTERVAL_HC_PLUS_LOW_MIN, TIME_INTERVAL_HC_PLUS_HIGH_MIN, TIME_INTERVAL_HC_PLUS_LOW_MAX, TIME_INTERVAL_HC_PLUS_HIGH_MAX);
        m_ProcessTimeAccuHot = 0;
        
    //  Debug.Log("HeatComfort: " + hcValue + ", HOT in: " + m_EventTimeHot + "s"); 
    }
    
    private void ProcessFreeze(float hcValue)
    {
        m_Player.GetSymptomManager().QueueUpPrimarySymptom(SymptomIDs.SYMPTOM_FREEZE);  
        m_EventTimeFreeze = GetEventTime(hcValue, PlayerConstants.THRESHOLD_HEAT_COMFORT_MINUS_EMPTY, PlayerConstants.THRESHOLD_HEAT_COMFORT_MINUS_WARNING, TIME_INTERVAL_HC_MINUS_LOW_MIN, TIME_INTERVAL_HC_MINUS_HIGH_MIN, TIME_INTERVAL_HC_MINUS_LOW_MAX, TIME_INTERVAL_HC_MINUS_HIGH_MAX);
        m_ProcessTimeAccuFreeze = 0;    
    
    //  Debug.Log("HeatComfort: " + hcValue + ", FREEZE in: " + m_EventTimeFreeze + "s");
    }
    
    private void ProcessFreezeRattle(float hcValue)
    {
        m_Player.GetSymptomManager().QueueUpPrimarySymptom(SymptomIDs.SYMPTOM_FREEZE_RATTLE);
        m_EventTimeFreezeRattle = GetEventTime(hcValue, -1, PlayerConstants.THRESHOLD_HEAT_COMFORT_MINUS_CRITICAL, TIME_INTERVAL_HC_MINUS_LOW_MIN, TIME_INTERVAL_HC_MINUS_HIGH_MIN, TIME_INTERVAL_HC_MINUS_LOW_MAX, TIME_INTERVAL_HC_MINUS_HIGH_MAX);
        m_ProcessTimeAccuFreezeRattle = 0;  
        
    //  Debug.Log("HeatComfort: " + hcValue + ", RATTLE in: " + m_EventTimeFreezeRattle + "s");
    }
 
    private float GetEventTime(float hcValue, float threshold_low, float thresholdHigh, float lowMin, float highMin, float lowMax, float highMax)
    {
        float inv_value = Math.Clamp(Math.InverseLerp(threshold_low, thresholdHigh, hcValue), 0, 1);
        float valueMin = Math.Lerp(lowMin, highMin, inv_value);
        float value_max = Math.Lerp(lowMax, highMax, inv_value);
        
        return Math.RandomFloatInclusive(valueMin, value_max);
    }
}