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;
g_Game.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 (g_Game.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;
g_Game.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;
}
}