Land_Underground_Entrance.c

Go to the documentation of this file.

enum EUndegroundEntranceState
{
  UNINITIALIZED,
  CLOSED,//fully closed
  //opening
  OPENING_A,
  OPENING_B,
  OPENING_C,
  OPENING_D,
  OPENING_E,//fully open
  OPENING_F,
  OPENING_G,
  //closing
  CLOSING_A,
  CLOSING_B,
  CLOSING_C,
  CLOSING_D,
  CLOSING_E,
  CLOSING_F,
  CLOSING_G
}
 
enum EUndegroundDoorType
{
  MAIN,
  SMALL,
}
 
class AlarmLight : SpotlightLight
{
  void AlarmLight()
  {
    SetVisibleDuringDaylight(true);
    SetRadiusTo(15);
    SetBrightnessTo(10);
    SetFlareVisible(false);
    SetAmbientColor(1.0, 0.0, 0.0);
    SetDiffuseColor(1.0, 0.0, 0.0);
    SetLifetime(1000);
    SetDisableShadowsWithinRadius(-1);
    SetFadeOutTime(1);
    SetCastShadow(false);
    m_FadeInTime = 0.25;
  }
}
 
//---------------------------------------------------------------------------------------------------------
//------------------------------------ Land_Underground_EntranceBase --------------------------------------
//---------------------------------------------------------------------------------------------------------
 
class Land_Underground_EntranceBase : House
{
  EUndegroundEntranceState m_DoorState = EUndegroundEntranceState.CLOSED;
  EUndegroundEntranceState m_DoorStatePrev = EUndegroundEntranceState.UNINITIALIZED;
  float m_AnimPhase;
  ref AnimationTimer m_AnimTimerDoorServer;
  ref Timer m_NavmeshTimer;
  ref array<Land_Underground_Panel> m_ConnectedPanels;
  EUndegroundDoorType m_DoorType;
 
  EntranceLight m_InteriorLight1;
  EntranceLight m_InteriorLight2;
  EntranceLight m_InteriorLight3;
 
  void Land_Underground_EntranceBase()
  {
    m_DoorType = EUndegroundDoorType.MAIN;
    Land_Underground_Panel.RegisterEntrance(this);
    RegisterNetSyncVariableFloat("m_AnimPhase", 0, 1, 5);
    RegisterNetSyncVariableInt("m_DoorState", 0, EnumTools.GetLastEnumValue(EUndegroundEntranceState));
 
#ifndef SERVER
    GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(CreateLights, 250);
#endif
  }
 
  void CreateLights();
 
  void ~Land_Underground_EntranceBase()
  {
    Land_Underground_Panel.UnregisterEntrance(this);
#ifndef SERVER
    CleanUpOnDeleteClient();
#endif
  }
  //---------------------
 
 
  void CleanUpOnDeleteClient()
  {
    //anything we might have started playing when the door was activated
    CleanUpOnClosedClient();
  }
 
 
  void CleanUpOnClosedClient();
 
  bool CanManipulate(Param param = null)
  {
    return m_DoorState == EUndegroundEntranceState.CLOSED;
  }
 
  void Manipulate(Param param = null)
  {
    OpenServer();
  }
 
  void NavmeshUpdate()
  {
  }
 
  void OnUpdateClient(float timeSlice);
 
  override void EOnPostSimulate(IEntity other, float timeSlice)
  {
#ifndef SERVER
    OnUpdateClient(timeSlice);
#endif
  }
 
  void OnUpdateServer()
  {
    m_AnimPhase = m_AnimTimerDoorServer.GetValue() / AdjustTime(GetOpeningTime());// make 0..1
    SetAnimationPhaseNow("EntranceDoor", m_AnimPhase);
 
    GetGame().GetWorld().UpdatePathgraphDoorByAnimationSourceName(this, "EntranceDoor");
 
    SetSynchDirty();
  }
 
  void GetConnectedPanels(array<Land_Underground_Panel> panels)
  {
    if (!Land_Underground_Panel.m_Panels)
      return;
    foreach (Land_Underground_Panel p: Land_Underground_Panel.m_Panels)
    {
      if (p.GetClosestDoor() == this)
        panels.Insert(p);
    }
  }
 
  // checks whether we want to play this effect even when we are at a different(more advanced) state, as this effect is supposed to be playing over multiple states and was supposed to start during some earlier state switch
  // param 'state' is the state this effect is supposed to be played in, and 'lastValidState' is the latests state where we still want to play this effect provided previous state for the client is UNINITIALIZED
  // meaning the client just connected in/the item entered their multiplayer bubble
  bool CheckShouldPlayPersistent(EUndegroundEntranceState state, EUndegroundEntranceState lastValidState)
  {
    return m_DoorState == state || (IsInitDoorStateSync() && m_DoorState > state && m_DoorState <= lastValidState);
  }
 
  float AdjustTime(float originalTime, float adjustedTime = -1)
  {
#ifdef DIAG_DEVELOPER
    float timeAccel = 1;
 
    if (adjustedTime != -1)
      return adjustedTime;
    if (FeatureTimeAccel.GetFeatureTimeAccelEnabled(ETimeAccelCategories.UNDERGROUND_ENTRANCE))
    {
      timeAccel = FeatureTimeAccel.GetFeatureTimeAccelValue();
      return originalTime / timeAccel;
    }
#endif
    return originalTime;
  }
 
  float GetOpeningTime()
  {
    return 30;
  }
 
  void RequestLatentTransition(float time, EUndegroundEntranceState targetState = EUndegroundEntranceState.UNINITIALIZED)
  {
    if (targetState == EUndegroundEntranceState.UNINITIALIZED)
      targetState = m_DoorState + 1;
    GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(SetDoorStateServer, time * 1000, false, targetState);
  }
 
  void SetDoorStateServer(EUndegroundEntranceState newState)
  {
    m_DoorState = newState;
    OnDoorStateChangedServer(newState);
    SetSynchDirty();
  }
 
  void OnDoorStateChangedServer(EUndegroundEntranceState newState);
 
  void OnDoorStateChangedClient(EUndegroundEntranceState newState, EUndegroundEntranceState prevState)
  {
    if (newState > EUndegroundEntranceState.CLOSED)
      SetEventMask(EntityEvent.POSTSIMULATE);
    else
    {
      ClearEventMask(EntityEvent.POSTSIMULATE);
      CleanUpOnClosedClient();
    }
 
    HandleAudioPlayback(newState, prevState);
    HandleVisualPlayback(newState, prevState);
 
    if (!m_ConnectedPanels)
    {
      m_ConnectedPanels = new array<Land_Underground_Panel>();
      GetConnectedPanels(m_ConnectedPanels);
    }
    foreach (Land_Underground_Panel p: m_ConnectedPanels)
      p.OnDoorStateChangedClient(newState, prevState);
  }
 
  void OpenServer(bool force = false)
  {
    GetGame().RegisterNetworkStaticObject(this);
    if (m_DoorState == EUndegroundEntranceState.CLOSED || force)
      SetDoorStateServer(EUndegroundEntranceState.OPENING_A);
  }
 
  void HandleVisualPlayback(EUndegroundEntranceState newState, EUndegroundEntranceState prevState);
  void HandleAudioPlayback(EUndegroundEntranceState newState, EUndegroundEntranceState prevState);
 
  void OnFinishedTimerServer();
 
  override void OnVariablesSynchronized()
  {
    super.OnVariablesSynchronized();
 
    if (m_DoorState != m_DoorStatePrev)
    {
      OnDoorStateChangedClient(m_DoorState, m_DoorStatePrev);
      m_DoorStatePrev = m_DoorState;
    }
  }
 
  bool IsInitDoorStateSync()
  {
    return m_DoorStatePrev == EUndegroundEntranceState.UNINITIALIZED;
  }
 
 
#ifdef DEVELOPER
  override string GetDebugText()
  {
    string debug_output;
 
    if (GetGame().IsDedicatedServer())
    {
      debug_output += "current state: " + typename.EnumToString(EUndegroundEntranceState, m_DoorState) + "\n";
      /*
        if(GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ))
        debug_output +=  "next stage timer: " + GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ).GetRemainingTimeByName(this, "SetDoorStateServer").ToString();
      */
    }
    else
      debug_output += "current state: " + typename.EnumToString(EUndegroundEntranceState, m_DoorState) + "\n";
    return debug_output;
  }
 
  override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
  {
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ACTIVATE_ENTITY, "Open", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.DEACTIVATE_ENTITY, "Close", 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)
      {
        if (m_DoorState == EUndegroundEntranceState.CLOSED)
          OpenServer(true);
      }
      else if (action_id == EActions.DEACTIVATE_ENTITY)
      {
        // just for debug controls
        if (!m_AnimTimerDoorServer)
          m_AnimTimerDoorServer = new AnimationTimer();
 
        if (m_DoorState == EUndegroundEntranceState.OPENING_G)
        {
          GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Remove(SetDoorStateServer);
          SetDoorStateServer(EUndegroundEntranceState.CLOSING_A);
        }
      }
    }
    return false;
  }
#endif
}
 
 
//---------------------------------------------------------------------------------------------------------
//-------------------------------------- Land_Underground_Entrance ----------------------------------------
//---------------------------------------------------------------------------------------------------------
 
class Land_Underground_Entrance : Land_Underground_EntranceBase
{
  EffectSound m_SirenSound;
  EffectSound m_DoorEngineSoundIn;
  EffectSound m_DoorEngineSoundLoop;
  EffectSound m_DoorEngineSoundOut;
  EffectSound m_LockingSound;
  EffectSound m_DoorMovementSoundIn;
  EffectSound m_DoorMovementSoundLoop;
  EffectSound m_DoorMovementSoundOut;
 
 
  AlarmLight m_AlarmLight;
 
  const string SIREN_SOUNDSET = "UndergroundDoor_Alarm_Loop_SoundSet";
  const string ENGINE_SOUNDSET_LOOP_IN = "UndergroundDoor_ElectricMotor_Start_SoundSet";
  const string ENGINE_SOUNDSET_LOOP = "UndergroundDoor_ElectricMotor_Loop_SoundSet";
  const string ENGINE_SOUNDSET_LOOP_OUT = "UndergroundDoor_ElectricMotor_End_SoundSet";
  const string LOCKING_SOUNDSET = "UndergroundDoor_Lock_SoundSet";
  const string DOORMOVING_SOUNDSET_LOOP = "UndergroundDoor_DoorOpen_Loop_SoundSet";
  const string DOORMOVING_SOUNDSET_LOOP_OUT = "UndergroundDoor_DoorOpen_End_SoundSet";
  const string DOORMOVING_SOUNDSET_LOOP_IN = "UndergroundDoor_DoorOpen_Start_SoundSet";
 
  const float LIGHT_ROT_SPEED = -400;
 
  override void CreateLights()
  {
    m_InteriorLight1 = EntranceLight.Cast(ScriptedLightBase.CreateLightAtObjMemoryPoint(EntranceLightMain1, this, "InteriorLightPos1"));
    m_InteriorLight2 = EntranceLight.Cast(ScriptedLightBase.CreateLightAtObjMemoryPoint(EntranceLightMain2, this, "InteriorLightPos2"));
  }
 
  override void CleanUpOnClosedClient()
  {
    SEffectManager.DestroySound(m_SirenSound);
    SEffectManager.DestroySound(m_LockingSound);
    SEffectManager.DestroySound(m_DoorMovementSoundIn);
    SEffectManager.DestroySound(m_DoorMovementSoundOut);
    SEffectManager.DestroySound(m_DoorMovementSoundLoop);
    SEffectManager.DestroySound(m_DoorEngineSoundIn);
    SEffectManager.DestroySound(m_DoorEngineSoundOut);
    SEffectManager.DestroySound(m_DoorEngineSoundLoop);
 
    if (m_AlarmLight && GetGame())
      m_AlarmLight.Destroy();
  }
 
  override void OnDoorStateChangedServer(EUndegroundEntranceState newState)
  {
    switch (newState)
    {
    case EUndegroundEntranceState.OPENING_A:
      RequestLatentTransition(AdjustTime(3));
      break;
    case EUndegroundEntranceState.OPENING_B:
      RequestLatentTransition(AdjustTime(2));
      break;
    case EUndegroundEntranceState.OPENING_C:
      RequestLatentTransition(AdjustTime(1));
      break;
    case EUndegroundEntranceState.OPENING_D:
      m_AnimTimerDoorServer = new AnimationTimer();
      m_AnimTimerDoorServer.Run(AdjustTime(GetOpeningTime()), this, "OnUpdateServer", "OnFinishedTimerServer", 0, false,/*1/ AdjustTime(1)*/ 1);
      m_NavmeshTimer = new Timer();
      m_NavmeshTimer.Run(3, this, "NavmeshUpdate", NULL, true);
      RequestLatentTransition(AdjustTime(GetOpeningTime()));
      break;
    case EUndegroundEntranceState.OPENING_E:
      m_AnimTimerDoorServer.Stop();
      NavmeshUpdate();
      m_NavmeshTimer = null;
      RequestLatentTransition(AdjustTime(3));
      break;
    case EUndegroundEntranceState.OPENING_F:
      RequestLatentTransition(AdjustTime(3));
      break;
    case EUndegroundEntranceState.OPENING_G:
      RequestLatentTransition(AdjustTime(300));
      break;
    case EUndegroundEntranceState.CLOSING_A:
      RequestLatentTransition(AdjustTime(3));
      break;
    case EUndegroundEntranceState.CLOSING_B:
      RequestLatentTransition(AdjustTime(3));
      break;
    case EUndegroundEntranceState.CLOSING_C:
      m_NavmeshTimer = new Timer();
      m_NavmeshTimer.Run(3, this, "NavmeshUpdate", NULL, true);
      m_AnimTimerDoorServer.Run(0, this, "OnUpdateServer", "OnFinishedTimerServer", AdjustTime(GetOpeningTime()), false, /*1/ AdjustTime(1)*/ 1);
      RequestLatentTransition(AdjustTime(GetOpeningTime()));
      break;
    case EUndegroundEntranceState.CLOSING_D:
      NavmeshUpdate();
      m_NavmeshTimer = null;
      RequestLatentTransition(AdjustTime(2));
      break;
    case EUndegroundEntranceState.CLOSING_E:
      RequestLatentTransition(AdjustTime(1));
      break;
    case EUndegroundEntranceState.CLOSING_F:
      RequestLatentTransition(AdjustTime(3));
      break;
    case EUndegroundEntranceState.CLOSING_G:
      RequestLatentTransition(0.25, EUndegroundEntranceState.CLOSED);
      break;
    }
  }
 
  vector GetLightPosition()
  {
    vector pos;
    if (MemoryPointExists("SirenLightPos"))
    {
      pos = GetMemoryPointPos("SirenLightPos");
      pos = ModelToWorld(pos);
    }
    else
      ErrorEx("GetLightPosition could not locate memory point 'SirenLightPos'");
    return pos;
  }
 
  void SoundEnded(Effect eff)
  {
    if (eff == m_DoorMovementSoundIn)
    {
      PlaySoundSetAtMemoryPointLooped(m_DoorMovementSoundLoop, DOORMOVING_SOUNDSET_LOOP, "DoorEngineSoundPos");
      m_DoorMovementSoundIn = null;
    }
    else if (eff == m_DoorEngineSoundIn)
    {
      PlaySoundSetAtMemoryPointLooped(m_DoorEngineSoundLoop, ENGINE_SOUNDSET_LOOP, "DoorEngineSoundPos");
      m_DoorEngineSoundIn = null;
    }
  }
 
  //do note that one-time effects are played even if the client connects and misses the state switch, ie. they are not connected the exact moment when the effect is supposed to be played(just after a state switch), but connect sometime later
  //we can prevent such effects from playing by checking for IsInitDoorStateSync(), but that seems unnecessary as the issue is really small
  override void HandleAudioPlayback(EUndegroundEntranceState newState, EUndegroundEntranceState prevState)
  {
    //Print("HandleAudioVisualPlayback " + newState + ", " + prevState);
    //opening
    if (CheckShouldPlayPersistent(EUndegroundEntranceState.OPENING_A, EUndegroundEntranceState.OPENING_F))
      PlaySoundSetAtMemoryPointLooped(m_SirenSound, SIREN_SOUNDSET, "SirenSoundPos", 0.5, 0.5);
    if (newState == EUndegroundEntranceState.OPENING_B)
    {
      if (prevState == EUndegroundEntranceState.OPENING_A)//if they connected already during B, do not play the in
      {
        PlaySoundSetAtMemoryPoint(m_DoorEngineSoundIn, ENGINE_SOUNDSET_LOOP_IN, "DoorEngineSoundPos");
        if (m_DoorEngineSoundIn)
          m_DoorEngineSoundIn.Event_OnEffectEnded.Insert(SoundEnded);
      }
    }
 
    if (CheckShouldPlayPersistent(EUndegroundEntranceState.OPENING_B, EUndegroundEntranceState.OPENING_E))
    {
      if (!m_DoorEngineSoundLoop && !m_DoorEngineSoundIn)//missed playing of the IN soundset which automatically triggers playing of the loop(connected after ?)
        PlaySoundSetAtMemoryPointLooped(m_DoorEngineSoundLoop, ENGINE_SOUNDSET_LOOP, "DoorEngineSoundPos");
    }
    if (newState == EUndegroundEntranceState.OPENING_C)
      PlaySoundSetAtMemoryPoint(m_LockingSound, LOCKING_SOUNDSET, "DoorEngineSoundPos");
    if (newState == EUndegroundEntranceState.OPENING_D)
    {
      if (prevState == EUndegroundEntranceState.OPENING_C)//if they connected already during C, do not play the in
      {
        PlaySoundSetAtMemoryPoint(m_DoorMovementSoundIn, DOORMOVING_SOUNDSET_LOOP_IN, "DoorEngineSoundPos");
        if (m_DoorMovementSoundIn)
          m_DoorMovementSoundIn.Event_OnEffectEnded.Insert(SoundEnded);
      }
      else if (!m_DoorMovementSoundIn && !m_DoorMovementSoundLoop)//missed playing of the IN soundset which automatically triggers playing of the loop(connected after ?)
        PlaySoundSetAtMemoryPointLooped(m_DoorMovementSoundLoop, DOORMOVING_SOUNDSET_LOOP, "DoorEngineSoundPos");
    }
 
    if (newState == EUndegroundEntranceState.OPENING_E)
    {
      StopSoundSet(m_DoorMovementSoundLoop);
      PlaySoundSetAtMemoryPoint(m_DoorMovementSoundOut, DOORMOVING_SOUNDSET_LOOP_OUT, "DoorEngineSoundPos");
    }
    if (newState == EUndegroundEntranceState.OPENING_F)
    {
      StopSoundSet(m_DoorEngineSoundLoop);
      PlaySoundSetAtMemoryPoint(m_DoorEngineSoundOut, ENGINE_SOUNDSET_LOOP_OUT, "DoorEngineSoundPos");
    }
    if (newState == EUndegroundEntranceState.OPENING_G)
      StopSoundSet(m_SirenSound);
 
    //closing
    if (CheckShouldPlayPersistent(EUndegroundEntranceState.CLOSING_A, EUndegroundEntranceState.CLOSING_F))
      PlaySoundSetAtMemoryPointLooped(m_SirenSound, SIREN_SOUNDSET, "SirenSoundPos", 0.5, 0.5);
    if (CheckShouldPlayPersistent(EUndegroundEntranceState.CLOSING_B, EUndegroundEntranceState.CLOSING_E))
    {
      if (prevState == EUndegroundEntranceState.CLOSING_A)//if they connected already during B, do not play the in
      {
        PlaySoundSetAtMemoryPoint(m_DoorEngineSoundIn, ENGINE_SOUNDSET_LOOP_IN, "DoorEngineSoundPos");
        if (m_DoorEngineSoundIn)
          m_DoorEngineSoundIn.Event_OnEffectEnded.Insert(SoundEnded);
      }
    }
    if (newState == EUndegroundEntranceState.CLOSING_C)
    {
      if (prevState == EUndegroundEntranceState.CLOSING_B)//if they connected already during C, do not play the in
      {
        PlaySoundSetAtMemoryPoint(m_DoorMovementSoundIn, DOORMOVING_SOUNDSET_LOOP_IN, "DoorEngineSoundPos");
        if (m_DoorMovementSoundIn)
          m_DoorMovementSoundIn.Event_OnEffectEnded.Insert(SoundEnded);
      }
      else if (!m_DoorMovementSoundIn && !m_DoorMovementSoundLoop)//missed playing of the IN soundset which automatically triggers playing of the loop(connected after ?)
        PlaySoundSetAtMemoryPointLooped(m_DoorMovementSoundLoop, DOORMOVING_SOUNDSET_LOOP, "DoorEngineSoundPos");
    }
    if (newState == EUndegroundEntranceState.CLOSING_D)
    {
      StopSoundSet(m_DoorMovementSoundLoop);
      PlaySoundSetAtMemoryPoint(m_DoorMovementSoundOut, DOORMOVING_SOUNDSET_LOOP_OUT, "DoorEngineSoundPos");
    }
    if (newState == EUndegroundEntranceState.CLOSING_E)
      PlaySoundSetAtMemoryPoint(m_LockingSound, LOCKING_SOUNDSET, "DoorEngineSoundPos");
    if (newState == EUndegroundEntranceState.CLOSING_F)
    {
      StopSoundSet(m_DoorEngineSoundLoop);
      PlaySoundSetAtMemoryPoint(m_DoorEngineSoundOut, ENGINE_SOUNDSET_LOOP_OUT, "DoorEngineSoundPos");
    }
    if (newState == EUndegroundEntranceState.CLOSING_G || newState == EUndegroundEntranceState.CLOSED)
      StopSoundSet(m_SirenSound);
  }
 
  override void OnUpdateClient(float timeSlice)
  {
    SetAnimationPhaseNow("EntranceDoor", m_AnimPhase);
    if (m_AlarmLight)
    {
      vector newOri = m_AlarmLight.GetOrientation() + Vector(timeSlice * LIGHT_ROT_SPEED, 0, 0);
      m_AlarmLight.SetOrientation(newOri);
    }
  }
 
  override void HandleVisualPlayback(EUndegroundEntranceState newState, EUndegroundEntranceState prevState)
  {
    if (CheckShouldPlayPersistent(EUndegroundEntranceState.OPENING_A, EUndegroundEntranceState.OPENING_F) || CheckShouldPlayPersistent(EUndegroundEntranceState.CLOSING_A, EUndegroundEntranceState.CLOSING_F))
      m_AlarmLight = AlarmLight.Cast(ScriptedLightBase.CreateLight(AlarmLight, GetLightPosition()));
    if (newState == EUndegroundEntranceState.CLOSING_G || newState == EUndegroundEntranceState.CLOSED || newState == EUndegroundEntranceState.OPENING_G)
    {
      if (m_AlarmLight)
        m_AlarmLight.Destroy();
    }
  }
 
}