EasterEgg.c

Go to the documentation of this file.

enum eCaptureState
{
  CAPTURE = 0,
  RELEASE = 1,
  STASIS = 2,
  CAPTUREFX = 3,
  RELEASEFX = 4,
 
  //Keep this last value at the end, add any new states before
  END
}
 
class EasterEgg : Inventory_Base
{
  //Capture parameters
  private DayZCreatureAI m_StoredCreature = null;
  private string m_CreatureType;
  private int m_CreatureHash = 0; //Used for sync
  private int m_CaptureState = eCaptureState.STASIS;
  private const vector CAPTURE_VELOCITY = { 0, 0, 0 };
 
  //VFX
  protected Particle m_ParCapture;
  private float m_ParScale = 1;
  private const float PARTICLE_SCALE_MULT = 0.1; //Used because we use DistanceSqr to get relevant scale
 
  //SFX
  protected EffectSound m_CaptureSound; //Egg SFX
  protected EffectSound m_CreatureSound; //Creature specific SFX
  protected bool m_DangerSound = false; //Used to determine if release animal is dangerous and play sound accordingly
 
  protected ref map<int, string> m_CreatureSoundMap; //Store all possible creature sound sets mapped to their respective hash
  protected int m_CaptureSoundHash; //Used to find capture sound set in map
  protected int m_ReleaseSoundHash; //Used to find release sound set in map
 
 
  void EasterEgg()
  {
    m_CreatureType = "";
    SetEventMask(EntityEvent.CONTACT | EntityEvent.TOUCH);
    SetFlags(EntityFlags.TRIGGER, false);
    RegisterNetSyncVariableInt("m_CaptureState", 0, eCaptureState.END);
    RegisterNetSyncVariableInt("m_CreatureHash", 0, 0);
    RegisterNetSyncVariableFloat("m_ParScale", 0, 0, 0.1);
    RegisterNetSyncVariableBool("m_DangerSound");
    RegisterNetSyncVariableInt("m_CaptureSoundHash", 0, 0);
    RegisterNetSyncVariableInt("m_ReleaseSoundHash", 0, 0);
 
    RegisterSoundSetMap();
  }
 
  void ~EasterEgg()
  {
    if (m_ParCapture)
      m_ParCapture.Stop();
  }
 
  // ------------------------------
  // CORE EXECUTION DEPENDING ON CURRENT STATE
  // ------------------------------
  void ContactEvent(IEntity other, vector pos)
  {
    switch (m_CaptureState)
    {
    case eCaptureState.CAPTURE:
      DayZCreatureAI capAnimal = DayZCreatureAI.Cast(other);
      if (capAnimal && capAnimal.IsAlive())
      {
        if (GetGame().IsServer())
          Capture(capAnimal);
      }
      else
        m_CaptureState = eCaptureState.STASIS; //We did not capture anything, go back to stasis
      break;
 
    case eCaptureState.RELEASE:
      Release(pos);
      PlayVFX();
      PlaySFX(eCaptureState.RELEASE);
      break;
 
    case eCaptureState.CAPTUREFX:
    case eCaptureState.RELEASEFX:
      //Intermediate state to play FX on next client side contact event
      //Creates slight delay but saves network traffic
      if (m_CreatureHash != 0)
      {
        //Make sure to go back in stasis
        m_CaptureState = eCaptureState.STASIS;
        SetSynchDirty();
      }
      break;
 
    case eCaptureState.STASIS:
      //Do nothing here, feel free to add logic for fun fumble effects when nothing happens :)
 
      break;
 
    default: //default in case state is somehow not initialized
 
      break;
    }
  }
 
  //Used for capture
  override void EOnTouch(IEntity other, int extra)
  {
    ContactEvent(other, GetPosition());
  }
 
  //Used for release
  override void EOnContact(IEntity other, Contact extra)
  {
    ContactEvent(other, extra.Position);
  }
 
  override void OnInventoryExit(Man player)
  {
    //Do not execute on simple drop as it may cause issues
    PlayerBase player_PB = PlayerBase.Cast(player);
    if (player_PB && player_PB.GetThrowing().IsThrowingAnimationPlaying())
    {
      if (m_CreatureType != "")
        m_CaptureState = eCaptureState.RELEASE;
      else
        m_CaptureState = eCaptureState.CAPTURE;
    }
    else
      m_CaptureState = eCaptureState.STASIS;
 
    //Make sure state is properly synchronized or VFX might bug out
    SetSynchDirty();
  }
 
  override void OnInventoryEnter(Man player)
  {
    //Make sure to stop particles once in inventory
    if (GetGame().IsClient() && m_ParCapture)
    {
      m_ParCapture.Stop();
      m_ParCapture.Delete();
    }
  }
 
  override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
  {
    super.EEItemLocationChanged(oldLoc, newLoc);
 
    //DestroyEg();
  }
 
  // ------------------------------
  // CAPTURE AND RELEASE LOGIC
  // ------------------------------
  private void Capture(DayZCreatureAI capAnimal)
  {
    if (!IsAlive())
    {
      if (m_ParCapture)
        m_ParCapture.Delete();
      Delete();
      return;
    }
 
    m_StoredCreature = capAnimal;
    m_CreatureType = m_StoredCreature.GetType();
    m_CreatureHash = m_CreatureType.Hash();
    m_CaptureState = eCaptureState.CAPTUREFX;
    m_DangerSound = m_StoredCreature.IsDanger();
    m_CaptureSoundHash = m_StoredCreature.CaptureSound().Hash();
    m_ReleaseSoundHash = m_StoredCreature.ReleaseSound().Hash();
 
    //Resize particle upon capture as there is enough delay to be sure value is synced
    ResizeParticle(capAnimal);
 
    SetSynchDirty();
 
    capAnimal.Delete();
    SetQuantity(GetQuantityMax());
    SetVelocity(this, CAPTURE_VELOCITY);
  }
 
  private void Release(vector pos)
  {
    if (GetGame().IsServer())
    {
      m_CaptureState = eCaptureState.RELEASEFX;
      m_CreatureHash = 0;
      SetSynchDirty();
 
      GetGame().CreateObject(m_CreatureType, pos, false, true);
      m_CreatureType = "";
 
      DecreaseHealth("", "", GetMaxHealth() * 0.4);
      SetQuantity(GetQuantityMin(), false);
      SetVelocity(this, CAPTURE_VELOCITY);
 
      if (!IsAlive())
      {
        if (m_ParCapture)
          m_ParCapture.Delete();
        Delete();
      }
    }
  }
 
  // ------------------------------
  // CAPTURE AND RELEASE EFFECTS
  // ------------------------------
  private void PlayVFX()
  {
    if (!GetGame().IsDedicatedServer())
    {
      if (!m_ParCapture && m_CaptureState != eCaptureState.STASIS)
      {
        //Ideally play a one time effect such as an explosion
        m_ParCapture = ParticleManager.GetInstance().PlayInWorld(ParticleList.EASTER_EGG_ACTIVATE, GetPosition());
 
        //Resize, -1 signifies ALL emitors
        m_ParCapture.SetParameter(-1, EmitorParam.SIZE, m_ParScale);
        m_ParCapture.SetWiggle(7, 0.3);
      }
    }
  }
 
  private void ResizeParticle(DayZCreatureAI capAnimal)
  {
    //Determine particle scale depending on captured animal scale
    vector mins, maxs;
    capAnimal.GetWorldBounds(mins, maxs);
    m_ParScale = vector.DistanceSq(mins, maxs);
 
    //Multiply to rescale down as fed values can be really large
    m_ParScale *= PARTICLE_SCALE_MULT;
  }
 
  private void PlaySFX(int releaseCase = eCaptureState.CAPTURE)
  {
    if (!GetGame().IsDedicatedServer())
    {
      string soundSet = "";
      if (releaseCase == eCaptureState.CAPTURE)
      {
        PlaySoundSet(m_CaptureSound, "EasterEgg_Catch_SoundSet", 0, 0);
 
        m_CreatureSoundMap.Find(m_CaptureSoundHash, soundSet);
        PlaySoundSet(m_CreatureSound, soundSet, 0, 0);
      }
      else
      {
        if (!m_DangerSound)
        {
          PlaySoundSet(m_CaptureSound, "EasterEgg_Spawn_SoundSet", 0, 0);
 
          m_CreatureSoundMap.Find(m_ReleaseSoundHash, soundSet);
          PlaySoundSet(m_CreatureSound, soundSet, 0, 0);
        }
        else
        {
          PlaySoundSet(m_CaptureSound, "EasterEgg_Spawn_Danger_SoundSet", 0, 0);
 
          m_CreatureSoundMap.Find(m_ReleaseSoundHash, soundSet);
          PlaySoundSet(m_CreatureSound, soundSet, 0, 0);
        }
      }
    }
  }
 
 
  override void OnVariablesSynchronized()
  {
    if (m_CaptureState == eCaptureState.CAPTUREFX)
    {
      PlayVFX();
      PlaySFX();
    }
    else if (m_CaptureState == eCaptureState.RELEASEFX)
    {
      PlayVFX();
      PlaySFX(eCaptureState.RELEASE);
    }
  }
 
  // ------------------------------
  // SOUNDSET MAP REGISTRATION
  // ------------------------------
  void RegisterSoundSetMap()
  {
    //Register all possible creature sounds in map with their respective hash
    string soundSet;
    m_CreatureSoundMap = new map<int, string>;
 
    //Cow sounds
    soundSet = "CattleMooA_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
    soundSet = "CattleBellow_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
 
    //Deer sounds
    soundSet = "DeerRoar_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
    soundSet = "DeerBleat_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
 
    //Goat sounds
    soundSet = "GoatBleat_A_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
    soundSet = "GoatBleat_B_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
 
    //Hare sounds
    soundSet = "HareChirp_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
    soundSet = "HareSquawk_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
 
    //Hen sounds
    soundSet = "HenCluck_X_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
    soundSet = "HenScream_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
 
    //Hog sounds
    soundSet = "HogGrunt_G_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
    soundSet = "HogSqueal_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
 
    //Sheep sounds
    soundSet = "SheepBleat_G_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
    soundSet = "SheepBleat_E_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
 
    //Wolf sounds
    soundSet = "WolfBark_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
    soundSet = "WolfWhimper_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
 
    //Zmb F sounds
    soundSet = "ZmbF_Normal_CallToArmsShort_Soundset";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
    soundSet = "ZmbF_Normal_HeavyHit_Soundset";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
 
    //Zmb M sounds
    soundSet = "ZmbM_Normal_CallToArmsShort_Soundset";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
    soundSet = "ZmbM_Normal_HeavyHit_Soundset";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
 
    //Bear sounds
    soundSet = "BearRoarShort_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
    soundSet = "BearSnarl_SoundSet";
    m_CreatureSoundMap.Insert(soundSet.Hash(), soundSet);
  }
 
 
  // ------------------------------
  // STORAGE SAVING AND LOADING
  // ------------------------------
  override void OnStoreSave(ParamsWriteContext ctx)
  {
    super.OnStoreSave(ctx);
 
    ctx.Write(m_CaptureState);
    ctx.Write(m_CreatureType);
    ctx.Write(m_ParScale);
    ctx.Write(m_DangerSound);
    ctx.Write(m_CaptureSoundHash);
    ctx.Write(m_ReleaseSoundHash);
  }
 
  override bool OnStoreLoad(ParamsReadContext ctx, int version)
  {
    if (!super.OnStoreLoad(ctx, version))
      return false;
 
    if (!ctx.Read(m_CaptureState))
      return false;
 
    if (!ctx.Read(m_CreatureType))
      return false;
 
    if (!ctx.Read(m_ParScale))
      return false;
 
    if (!ctx.Read(m_DangerSound))
      return false;
 
    if (!ctx.Read(m_CaptureSoundHash))
      return false;
 
    if (!ctx.Read(m_ReleaseSoundHash))
      return false;
 
    return true;
  }
 
  //Protection against dupers  during 1.12
  private void DestroyEg()
  {
    Delete();
  }
};