alarmclock.c

Go to the documentation of this file.

class AlarmClock_ColorBase: ClockBase
{
    const string        RINGING_SOUND               = "AlarmClock_Ring_Loop_SoundSet";
    const string        TURN_TOGGLE_SOUND           = "AlarmClock_Turn_Off_SoundSet";
    const string        DESTROYED_SOUND             = "AlarmClock_Destroyed_SoundSet";
    const string        HIT_SOUND                   = "AlarmClock_Hit_SoundSet";
 
    
    static ref NoiseParams  m_NoisePar;
    static NoiseSystem      m_NoiseSystem;
    
    override void Init()
    {
        super.Init();
        if ( GetGame().IsServer() )
        {
            m_NoiseSystem = GetGame().GetNoiseSystem();
            if ( m_NoiseSystem && !m_NoisePar )
            {
                // Create and load noise parameters
                m_NoisePar = new NoiseParams;
                m_NoisePar.LoadFromPath("cfgVehicles " + GetType() + " NoiseAlarmClock");
            }
        }
    }
 
    void ~AlarmClock_ColorBase()
    {
        #ifndef SERVER
        OnRingingStopClient();
        #endif
    }
    
    
    override void SetActions()
    {
        super.SetActions();
        
        AddAction(ActionSetAlarmClock);
        AddAction(ActionTurnOnAlarmClock);
        AddAction(ActionTurnOffAlarmClock);
    }
 
    override string GetToggleSound()
    {
        return TURN_TOGGLE_SOUND;
    }
    
    override string GetRingingSound()
    {
        return RINGING_SOUND;
    }
    
    override string GetDestroyedSound()
    {
        return DESTROYED_SOUND;
    }
    
    override string GetHitSound()
    {
        return HIT_SOUND;
    }
 
    override string GetExplosiveTriggerSlotName()
    {
        return "TriggerAlarmClock";
    }
    
    override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
    {
        outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ACTIVATE_ENTITY, "SetAlarmAhead1Min", FadeColors.LIGHT_GREY));
        outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.LIGHT_GREY));
        
        super.GetDebugActions(outputList);
    }
    
    override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
    {
        if (super.OnAction(action_id, player, ctx))
            return true;
        if (GetGame().IsServer() || !GetGame().IsMultiplayer())
        {
            if (action_id == EActions.ACTIVATE_ENTITY)
            {
                SetAlarmInXMins(1);
            }
            
        }
        return false;
    }
 
    override string GetDebugText()
    {
        string debug_output;
        
        if( GetGame().IsDedicatedServer())
        {
            debug_output = "alarm in: " + GetAlarmInMin().ToString() + " mins" + "\n";
            debug_output +=  "current state: " +  typename.EnumToString(EAlarmClockState, m_State) + "\n";;
            debug_output +=  "ringing for " + m_RingingDuration.ToString()+ " secs" + "\n";
            debug_output +=  "ringing max " + GetRingingDurationMax().ToString()+ " secs" + "\n";
        }
        else
        {
            debug_output = "this is client";
        }
        return debug_output;
    }
    
    void OnUpdate()
    {
        if ( IsAlarmOn() )
        {
            //due to variable server time flow(day-night time accel), it's not possible to simply set a timer for X secs without some convoluted math/code, so we need to check at regular intervals
            int alarm_hand_in_minutes = ConvertAlarmHand01ToMins12h(m_AlarmTime01);
        
            int pass, hour, minute;
            GetGame().GetWorld().GetDate(pass, pass, pass, hour, minute);
            
            int curr_time_in_minutes = ConvertTimeToMins12h(hour, minute);
            
            //Print(GetAlarmInMin());
            
            if ( alarm_hand_in_minutes == curr_time_in_minutes )
            {
                MakeRingingStart();
            }
        }
        
        if ( IsRinging())
        {
            m_RingingDuration += UPDATE_TICK_RATE;
            
            if (m_RingingDuration >= GetRingingDurationMax())
            {
                TurnOff();
            }
            else if ( m_NoiseSystem )
            {
                m_NoiseSystem.AddNoiseTarget( GetPosition(), UPDATE_TICK_RATE, m_NoisePar);
            }
        }
    }
 
    protected void AnimateAlarmHand(float value)
    {
        SetAnimationPhaseNow("ClockAlarm", value);
    }
 
    
    override bool OnStoreLoad( ParamsReadContext ctx, int version )
    {
        if (!super.OnStoreLoad(ctx, version))
            return false;
        
        if (version < 126)
        {
            return true;
        }
 
        EAlarmClockState state;     
        
        if ( !ctx.Read( state ) )
        {
            return false;
        }
 
        float time;
        
        if ( !ctx.Read( time ) )
        {
            return false;
        }
 
        SetAlarmTimeServer(time);
        SetState(state);
        if ( state == EAlarmClockState.SET )
        {
            TurnOn();
        }
        else if (state == EAlarmClockState.RINGING )
        {
            MakeRingingStart();
        }
        
        return true;
    }
    
    override void OnStoreSave(ParamsWriteContext ctx)
    {
        super.OnStoreSave(ctx);
        
        ctx.Write(m_State);
        ctx.Write(m_AlarmTime01);
    }
    
    override void OnDebugSpawn()
    {
        TurnOn();
        MakeRingingStart();
    }
 
};
    
class AlarmClock_Red : AlarmClock_ColorBase {};
class AlarmClock_Blue : AlarmClock_ColorBase {};
class AlarmClock_Green : AlarmClock_ColorBase {};