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();
    }
};