SpookyAreaMisc.c

Go to the documentation of this file.

//-------------------------------------------------------------
class SpookyEventWind : SpookyEventBase
{
  override protected void Init()
  {
    SetCoolDown(65);
    m_SoundSet = "SpookyArea_WhistlingWind_SoundSet";
  }
 
  override protected bool CanDo(PlayerBase player, TStringVectorMap surfaceTypes)
  {
    return player.IsSoundInsideBuilding();
  }
 
  override protected void Do(PlayerBase player)
  {
    //put additional code here
  }
}
//-------------------------------------------------------------
class SpookyEventWhisper : SpookyEventBase
{
  override protected void Init()
  {
    SetCoolDown(80);
    m_SoundSet = "SpookyArea_Whispering_SoundSet";
  }
 
  override protected void Do(PlayerBase player)
  {
    //put additional code here
  }
 
}
//-------------------------------------------------------------
class SpookyEventSteps : SpookyEventBase
{
  override protected void Init()
  {
    SetCoolDown(40);
    m_SoundSet = "SpookyArea_RunOnConcrete_SoundSet";
    m_Surfaces = {"stone", "gravel", "concrete", "wood", "asphalt", "tiles", "textile"};
  }
 
  override protected void Do(PlayerBase player)
  {
    //put additional code here
  }
}
//-------------------------------------------------------------
class SpookyEventRustle : SpookyEventBase
{
  override protected void Init()
  {
    SetCoolDown(60);
    m_SoundSet = "SpookyArea_IntenseFoliageRustle_SoundSet";
    m_Surfaces = {"grass", "dirt", "forest", "soil"};
  }
 
  override protected bool CanDo(PlayerBase player, TStringVectorMap surfaceTypes)
  {
    return !player.IsSoundInsideBuilding();
  }
 
  override protected void Do(PlayerBase player)
  {
    vector soundPos = GetSoundPos(player);
 
    string secondarySoundSet = "SpookyArea_Hedgehog_SoundSet";
 
    if (Math.RandomBool())
      secondarySoundSet = "SpookyArea_Badger_Voice_SoundSet";
 
    EffectSound sound = SEffectManager.PlaySound(secondarySoundSet, soundPos);
    sound.SetAutodestroy(true);
  }
}
 
 
//-------------------------------------------------------------
//-------------------------------------------------------------
//-------------------------------------------------------------
 
class SpookyEventBase
{
  //internal params, do not set manually
  protected float m_PerformedTimestamp;//internal, marks the time this event was last performed so that it can guruantee the cooldown period before playing it again
  protected int m_Cooldown;//how much time needs to elapse between this event can be performed again in seconds
  //the params bellow can be set in the 'Init' method
  protected string m_SoundSet;//if set, will play this soundset when performing the event
  protected ref TStringArray m_Surfaces;//if set, the player needs to detect this surface for the event to be considered valid
  protected vector m_MatchingSurfacePos;//position of the first matching surface
 
  void SpookyEventBase()
  {
    Init();
  }
 
  protected void Init();
 
 
  protected vector GetMatchingSurfacePos(TStringArray surfaces, TStringVectorMap gatheredSurfaces)
  {
    for (int i = 0; i < gatheredSurfaces.Count(); i++)
    {
      string currSurface = gatheredSurfaces.GetKey(i);
      foreach (string s: surfaces)
      {
        if (currSurface.Contains(s))
          return gatheredSurfaces.Get(currSurface);
      }
    }
 
    return vector.Zero;
  }
 
  protected void SetCoolDown(float secs)
  {
    m_Cooldown = secs * 1000;
  }
 
  protected bool HasSurfaces()
  {
    return (m_Surfaces && m_Surfaces.Count() > 0);
  }
 
  protected bool CanDo(PlayerBase player, TStringVectorMap surfaceTypes)
  {
    return true;
  }
 
  protected void Do(PlayerBase player);
 
  //internal, do not override, use 'CanDo' instead
  bool CanPerform(PlayerBase player, float currentTime, TStringVectorMap surfaceTypes)
  {
    bool surfaceCheckResult = 1;
 
    if (HasSurfaces())
    {
      m_MatchingSurfacePos = GetMatchingSurfacePos(m_Surfaces, surfaceTypes);
      surfaceCheckResult = m_MatchingSurfacePos != vector.Zero;
    }
 
 
    return (currentTime > (m_PerformedTimestamp + m_Cooldown) && surfaceCheckResult && CanDo(player, surfaceTypes));
  }
 
  //internal, do not override, use 'Do' instead
  void Perform(PlayerBase player, float currentTime, TStringVectorMap gatheredSurfaces)
  {
#ifdef DIAG_DEVELOPER
    if (DiagMenu.GetBool(DiagMenuIDs.TRIGGER_DEBUG))
      Print("Performing " + this);
#endif
    m_PerformedTimestamp = currentTime;
 
    if (m_SoundSet)
    {
      vector soundPos = GetSoundPos(player);
      EffectSound sound = SEffectManager.PlaySound(m_SoundSet, soundPos);
      sound.SetAutodestroy(true);
 
#ifdef DIAG_DEVELOPER
      if (DiagMenu.GetBool(DiagMenuIDs.TRIGGER_DEBUG))
        Debug.DrawSphere(soundPos, 0.15, Colors.YELLOW, ShapeFlags.NOZBUFFER);
#endif
    }
 
    Do(player);
  }
 
  protected vector GetSoundPos(PlayerBase player)
  {
    vector soundPos;
 
    if (HasSurfaces())
      soundPos = m_MatchingSurfacePos;
    else
    {
      float distance = Math.RandomFloatInclusive(5, 15);
      vector randomDir = vector.RandomDir2D() * distance;
      vector playerPos = player.GetPosition();
      soundPos = playerPos + randomDir;
    }
 
    return soundPos;
  }
}
 
//----------------------------------------------------------------------------------------------------------
 
class SpookyTriggerEventsHandler
{
  protected ref array<ref SpookyEventBase> m_SoundEvents;
  protected PlayerBase m_Player;
  protected float m_TimeAccu;
  protected const float CONSECUTIVE_EVENTS_COOLDOWN = 20;//min delay in seconds before two events
  protected const float EVENT_CHECK_FREQUENCY = 2;//when not in cooldown, the rate at which we query the events
  protected const float FIRST_EVENT_CHECK_DELAY = 15;//the delay between the first event check when we first enter the contaminated area
  protected const float SURFACE_CHECK_POINT_DISTANCE = 2;//additional checks for surface are performed at this distance from the player
  protected float m_NextEventCheck = FIRST_EVENT_CHECK_DELAY;
 
  void SpookyTriggerEventsHandler(notnull PlayerBase player)
  {
    if (!m_SoundEvents)
    {
      m_SoundEvents = new array<ref SpookyEventBase>();
      RegisterEvents();
    }
 
    m_Player = player;
  }
 
  void ~SpookyTriggerEventsHandler()
  {
    m_SoundEvents = null;
  }
 
  protected void RegisterEvents()
  {
    m_SoundEvents.Insert(new SpookyEventWind());
    m_SoundEvents.Insert(new SpookyEventWhisper());
    m_SoundEvents.Insert(new SpookyEventSteps());
    m_SoundEvents.Insert(new SpookyEventRustle());
 
  }
 
  void Update(float deltaTime)
  {
    m_TimeAccu += deltaTime;
    if (m_TimeAccu > m_NextEventCheck)
    {
      if (SelectEvent())
        m_NextEventCheck = CONSECUTIVE_EVENTS_COOLDOWN;
      else
        m_NextEventCheck = EVENT_CHECK_FREQUENCY;
      m_TimeAccu = 0;
    }
  }
 
  protected void GatherSurfaces(notnull TStringVectorMap gatheredGurfaces)
  {
    gatheredGurfaces.Clear();
 
    vector playerPos = m_Player.GetPosition();
    TVectorArray positions = new TVectorArray();
 
    positions.Insert(playerPos);
    positions.Insert(playerPos + ("0 0 1" * SURFACE_CHECK_POINT_DISTANCE));
    positions.Insert(playerPos + ("0 0 -1" * SURFACE_CHECK_POINT_DISTANCE));
    positions.Insert(playerPos + ("1 0 0" * SURFACE_CHECK_POINT_DISTANCE));
    positions.Insert(playerPos + ("-1 0 0" * SURFACE_CHECK_POINT_DISTANCE));
 
    foreach (vector pos : positions)
    {
      string surfaceType;
      GetGame().SurfaceGetType3D(pos[0], pos[1], pos[2], surfaceType);
 
      if (!gatheredGurfaces.Contains(surfaceType))
        gatheredGurfaces.Insert(surfaceType, pos);
    }
 
#ifdef DIAG_DEVELOPER
    if (DiagMenu.GetBool(DiagMenuIDs.TRIGGER_DEBUG))
    {
      foreach (vector p: positions)
        Debug.DrawLine(p, p + "0 10 0", COLOR_BLUE, ShapeFlags.NOZBUFFER);
    }
#endif
 
  }
 
  protected bool SelectEvent()
  {
    TStringVectorMap gatheredSurfaces = new TStringVectorMap();
    GatherSurfaces(gatheredSurfaces);//this can be optimized by calling this on demand from an event, as none events might be eligible at this point, so we might be doing this in vain
 
#ifdef DIAG_DEVELOPER
    if (DiagMenu.GetBool(DiagMenuIDs.TRIGGER_DEBUG))
    {
      for (int i = 0; i < gatheredSurfaces.Count(); i++)
      {
        Print(gatheredSurfaces.GetKey(i));
        Print(gatheredSurfaces.Get(gatheredSurfaces.GetKey(i)));
 
      }
      Print("--------------------------------------------------------------------");
    }
#endif
 
    array<ref SpookyEventBase> validEvents = new array<ref SpookyEventBase>();
    float currentTime = GetGame().GetTime();
    foreach (SpookyEventBase spookyEvent: m_SoundEvents)
    {
      if (spookyEvent.CanPerform(m_Player, currentTime, gatheredSurfaces))
        validEvents.Insert(spookyEvent);
    }
 
    //validEvents.Debug();
    SpookyEventBase selectedEvent;
 
    if (validEvents.Count() > 0)
    {
      int randIndex = Math.RandomIntInclusive(0, validEvents.Count() - 1);
      selectedEvent = validEvents[randIndex];
    }
    if (selectedEvent)
    {
      selectedEvent.Perform(m_Player, currentTime, gatheredSurfaces);
      return true;
    }
    return false;
 
  }
 
}
 
class SpookyPlayerStalker : ScriptedEntity
{
 
  protected ref UniversalTemperatureSource m_UTSource;
  protected ref UniversalTemperatureSourceSettings m_UTSSettings;
  protected ref UniversalTemperatureSourceLambdaConstant m_UTSLConstant;
 
 
  override void EEInit()
  {
    super.EEInit();
 
    if (GetGame().IsServer() || !GetGame().IsMultiplayer())
    {
      m_UTSSettings = new UniversalTemperatureSourceSettings();
      m_UTSSettings.m_Updateable = true;
      m_UTSSettings.m_UpdateInterval = 3;
      m_UTSSettings.m_TemperatureMin = -20;
      m_UTSSettings.m_TemperatureMax = -20;
      m_UTSSettings.m_RangeFull = 2;
      m_UTSSettings.m_RangeMax = 2;
      m_UTSSettings.m_TemperatureCap = -20;
      m_UTSSettings.m_ManualUpdate = false;
 
      m_UTSLConstant = new UniversalTemperatureSourceLambdaConstant();
      m_UTSource = new UniversalTemperatureSource(this, m_UTSSettings, m_UTSLConstant);
      m_UTSource.SetActive(true);
    }
 
  }
 
}