ClockBase.c

Go to the documentation of this file.

enum EAlarmClockState
{
  UNSET,
  SET,
  RINGING,
  //-----------
  COUNT
}
 
class ClockBase : Inventory_Base
{
  float m_AlarmTime01;
  int m_State = EAlarmClockState.UNSET;
  static const float UPDATE_TICK_RATE = 1; // Clock update tick frequency
  ref Timer m_TimerUpdate;
  float m_RingingDuration;
  int m_StatePrev = -1;
 
  EffectSound m_RingingSoundLoop;
  EffectSound m_TurnOnSound;
  EffectSound m_DestoryedSound;
  EffectSound m_HitSound;
  EffectSound m_WorkingSound;
 
  const float RINGING_DURATION_MAX = 60;//in secs, at or past this value, the clock stops ringing
 
  void ClockBase()
  {
    Init();
  }
 
  void ~ClockBase()
  {
    SEffectManager.DestroyEffect(m_WorkingSound);
    SEffectManager.DestroyEffect(m_HitSound);
    SEffectManager.DestroyEffect(m_DestoryedSound);
    SEffectManager.DestroyEffect(m_TurnOnSound);
    SEffectManager.DestroyEffect(m_RingingSoundLoop);
  }
 
  void Init()
  {
    RegisterNetSyncVariableInt("m_State", 0, EAlarmClockState.COUNT - 1);
  }
 
  override void SetActions()
  {
    super.SetActions();
 
    AddAction(ActionAttachExplosivesTrigger);
  }
 
  protected int GetAlarmInMin()
  {
    int alarm_hand_in_mins = ConvertAlarmHand01ToMins12h(m_AlarmTime01);
 
    int pass, hour, minute;
    GetGame().GetWorld().GetDate(pass, pass, pass, hour, minute);
 
    int curr_time_in_minutes = ConvertTimeToMins12h(hour, minute);
    int ring_in_mins = GetTimeDiffInMins12h(curr_time_in_minutes, alarm_hand_in_mins);
    return ring_in_mins;
  }
 
  static int ConvertAlarmHand01ToMins12h(float time01)
  {
    return Math.Lerp(0, 12 * 60, time01);
  }
 
  static int ConvertAlarmHand01ToMins(float time01, int mins_max/*what's the upper range in minutes we are trying to map the time01 to*/)
  {
    return Math.Lerp(0, mins_max, time01);
  }
 
  static float ConvertMins12hToAlarmHand01(int mins)
  {
    return Math.InverseLerp(0, 12 * 60, mins);
  }
 
 
  static int ConvertTimeToMins12h(int hour, int minute)
  {
    if (hour >= 12)
      hour -= 12;
    return hour * 60 + minute;
  }
 
  static int GetTimeDiffInMins12h(int from_mins, int to_mins)
  {
    if (to_mins > from_mins)
      return to_mins - from_mins;
    else if (to_mins < from_mins)
      return ((12 * 60) - from_mins) + to_mins;
    else return 0;
  }
 
  string GetToggleSound()
  {
    return "";
  }
  string GetRingingSound()
  {
    return "";
  }
  string GetHitSound()
  {
    return "";
  }
  string GetDestroyedSound()
  {
    return "";
  }
  string GetWorkingSound()
  {
    return "";
  }
 
  override void EEKilled(Object killer)
  {
    super.EEKilled(killer);
    TurnOff();
  }
 
  override void EEHitByRemote(int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos)
  {
    super.EEHitByRemote(damageType, source, component, dmgZone, ammo, modelPos);
    PlaySoundSet(m_HitSound, GetHitSound(), 0, 0);
  }
 
  override void OnDamageDestroyed(int oldLevel)
  {
    super.OnDamageDestroyed(oldLevel);
 
    if (GetGame().IsClient())
    {
      OnRingingStopClient();
 
      if (oldLevel != -1)
        PlaySoundSet(m_DestoryedSound, GetDestroyedSound(), 0, 0);
    }
  }
 
  protected void OnRingingStartServer()
  {
    ActivateParent();
  }
 
  protected void OnRingingStartClient()
  {
    PlaySoundSetLoop(m_RingingSoundLoop, GetRingingSound(), 0, 0);
 
    if (m_WorkingSound)
      SEffectManager.DestroyEffect(m_WorkingSound);
  }
 
  protected void OnRingingStopServer();
 
  protected void OnRingingStopClient()
  {
    SEffectManager.DestroyEffect(m_RingingSoundLoop);
  }
 
  void SetAlarmInXMins(int in_mins)
  {
    int pass, hour, minute;
    GetGame().GetWorld().GetDate(pass, pass, pass, hour, minute);
    int mins12h = ConvertTimeToMins12h(hour, minute) + in_mins;
    float time01 = ConvertMins12hToAlarmHand01(mins12h);
    SetAlarmTimeServer(time01);
    Arm();
  }
 
  float GetRingingDurationMax()
  {
    return RINGING_DURATION_MAX;
  }
 
 
  protected void SetupTimerServer()
  {
    m_TimerUpdate = new Timer();
    m_TimerUpdate.Run(UPDATE_TICK_RATE, this, "OnUpdate", null, true);
  }
 
  protected void SetState(EAlarmClockState state)
  {
    m_State = state;
    SetSynchDirty();
  }
 
  protected void Disarm()
  {
    SetState(EAlarmClockState.UNSET);
  }
 
  protected void Arm()
  {
    SetupTimerServer();
    SetState(EAlarmClockState.SET);
    m_RingingDuration = 0;
  }
 
  protected void ActivateParent()
  {
    if (GetHierarchyParent())
    {
      ItemBase parent = ItemBase.Cast(GetHierarchyParent());
      if (parent)
        parent.OnActivatedByItem(this);
    }
  }
 
  protected void MakeRingingStart()
  {
    if (!m_TimerUpdate)
      SetupTimerServer();
    SetState(EAlarmClockState.RINGING);
 
    OnRingingStartServer();
  }
 
  protected void MakeRingingStop()
  {
    SetState(EAlarmClockState.UNSET);
 
    OnRingingStopServer();
  }
 
  void TurnOnClient();
 
  void TurnOffClient();
 
  override void OnVariablesSynchronized()
  {
    super.OnVariablesSynchronized();
 
    if (m_State != m_StatePrev)//state changed
    {
      if (m_StatePrev == EAlarmClockState.RINGING)
        OnRingingStopClient();
      else if (m_State == EAlarmClockState.RINGING)
        OnRingingStartClient();
      if (m_State == EAlarmClockState.SET)
      {
        if (m_StatePrev != -1 || IsInitialized())
          PlaySoundSet(m_TurnOnSound, GetToggleSound(), 0, 0);
        if (GetWorkingSound())
          PlaySoundSet(m_WorkingSound, GetWorkingSound(), 0, 0, true);
      }
      else if (m_State == EAlarmClockState.UNSET)
      {
        if (m_StatePrev == EAlarmClockState.SET)
        {
          if (m_WorkingSound)
            SEffectManager.DestroyEffect(m_WorkingSound);
          if (m_StatePrev != -1 || IsInitialized())
            PlaySoundSet(m_TurnOnSound, GetToggleSound(), 0, 0);
        }
      }
      m_StatePrev = m_State;
    }
  }
 
 
  //---------------------------------------------------------------------------------------------------------
  //---------------------------------------------- Public methods -------------------------------------------
  //---------------------------------------------------------------------------------------------------------
 
  bool IsRinging()
  {
    return (m_State == EAlarmClockState.RINGING);
  }
 
  bool IsAlarmOn()
  {
    return (m_State == EAlarmClockState.SET);
  }
 
  void TurnOn()
  {
    Arm();
  }
 
  void TurnOff()
  {
    if (IsRinging())
      MakeRingingStop();
    else
      Disarm();
 
    m_TimerUpdate = null;
  }
 
  void SetAlarmTimeServer(float time01)
  {
    SetAnimationPhaseNow("ClockAlarm", time01);
    m_AlarmTime01 = time01;
  }
}