trapspawnbase.c

Go to the documentation of this file.

class TrapSpawnBase extends ItemBase
{
    int                             m_InitWaitTime;             //After this time after deployment, the trap is activated
    int                             m_UpdateWaitTime;           //Time when timer will be called again until success or not succes catch is done
    float                           m_DefectRate;               //Added damage after trap activation
    bool                            m_IsFoldable;
    bool                            m_CanCatch = false;
    float                           m_MinimalDistanceFromPlayersToCatch;
    
    float                           m_BaitCatchProb; // The probability (0-100) to catch something when bait is attached
    float                           m_NoBaitCatchProb; // The probability (0-100) to catch something when no bait is attached
    float                           m_FinalCatchProb; // The selected catch probability (0-100) -> Will be overriden no need to allocate
    
    vector                          m_PreyPos; // The position where prey will be spawned -> Will be overriden later
    
    protected EntityAI              m_Bait;
 
    protected bool                  m_IsActive;
    protected bool                  m_IsDeployed;
    protected bool                  m_IsInProgress;
    
    ref Timer                       m_Timer;
    
    string                          m_AnimationPhaseSet;
    string                          m_AnimationPhaseTriggered;
    string                          m_AnimationPhaseUsed;
 
    const string                    m_PlaceableWaterType 
    protected ref array<string>     m_PlaceableWaterSurfaceList;
 
    bool m_WaterSurfaceForSetup;    //if trap can be installed on water surface (cannot be detected via getsurfacetype)
    ref multiMap<string, float> m_CatchesPond;  //array of catches that can be catched in trap - string key, float catch_chance
    ref multiMap<string, float> m_CatchesSea;   //array of catches that can be catched in trap - string key, float catch_chance
    ref multiMap<string, float> m_CatchesGroundAnimal;  //array of catches that can be catched in trap - string key, float catch_chance
    
    protected ref EffectSound   m_DeployLoopSound;
    
    // ===============================================================
    // =====================  DEPRECATED  ============================
    // ===============================================================
    ref Timer                       m_PrevTimer;
    bool                            m_NeedInstalation;
    bool                            m_BaitNeeded;
    bool                            m_IsUsable;
    private ItemBase                m_Catch;
    ref Timer                       m_AlignCatchTimer;
    string                          m_InfoSetup;
    // ===============================================================
    
    void TrapSpawnBase()
    {
        m_DefectRate                            = 10;           //Added damage after trap activation
        m_UpdateWaitTime                        = 10;
        m_InitWaitTime                          = 10;
        m_NeedInstalation                       = true;
        m_BaitNeeded                            = true;
        m_IsFoldable                            = false;
        m_MinimalDistanceFromPlayersToCatch     = 0;
 
        m_BaitCatchProb                         = 95;
        m_NoBaitCatchProb                       = 50;
        
        m_AnimationPhaseSet                     = "";
        m_AnimationPhaseTriggered               = "";
        m_AnimationPhaseUsed                    = "";
        
        m_CatchesPond                           = NULL;
        m_CatchesSea                            = NULL;
        m_CatchesGroundAnimal                   = NULL;
        
        m_PlaceableWaterSurfaceList             = new array<string>();
        m_PlaceableWaterSurfaceList.Insert(UAWaterType.SEA);
        m_PlaceableWaterSurfaceList.Insert(UAWaterType.FRESH);
        
        RegisterNetSyncVariableBool("m_IsSoundSynchRemote");
        RegisterNetSyncVariableBool("m_IsDeploySound");
        RegisterNetSyncVariableBool("m_IsActive");
        RegisterNetSyncVariableBool("m_IsDeployed");
    }
 
    void ~TrapSpawnBase()
    {
        SEffectManager.DestroyEffect( m_DeployLoopSound );
    }
    
    override void OnStoreSave( ParamsWriteContext ctx )
    {
        super.OnStoreSave( ctx );
        
        ctx.Write( m_IsActive );
        
        ctx.Write( m_IsInProgress );
        
        ctx.Write( m_IsDeployed );
    }
    
    override bool OnStoreLoad( ParamsReadContext ctx, int version )
    {   
        if ( !super.OnStoreLoad(ctx, version) )
            return false;
        
        bool b_is_active = false;
        if ( !ctx.Read( b_is_active ) )
            b_is_active = false;
        
        bool b_is_in_progress = false;
        if ( !ctx.Read( b_is_in_progress ) )
            b_is_in_progress = false;
        
        bool b_is_deployed = false;
        if ( !ctx.Read( b_is_deployed ) )
            b_is_deployed = false;
        
        if ( b_is_active )
        {
            SetActive();
        }
        
        if ( b_is_in_progress && !b_is_active )
        {
            StartActivate( NULL );
        }
        
        SetDeployed( b_is_deployed );
 
        return true;
    }
 
    override void OnVariablesSynchronized()
    {
        super.OnVariablesSynchronized();
        
        if ( IsDeploySound() && IsDeployed() )
        {
            PlayDeploySound();
        }
        
        if ( CanPlayDeployLoopSound() )
        {
            PlayDeployLoopSound();
        }
                    
        if ( m_DeployLoopSound && !CanPlayDeployLoopSound() )
        {
            StopDeployLoopSound();
        }
    }
    
    bool IsActive()
    {
        return m_IsActive;
    }
    
    bool IsDeployed()
    {
        return m_IsDeployed;
    }
    
    void SetDeployed( bool newState )
    {
        m_IsDeployed = newState;
        
        if ( newState == true )
        {
            if ( m_AnimationPhaseSet != "" && m_AnimationPhaseTriggered != "" )
            {
                SetAnimationPhase( m_AnimationPhaseSet, 1 );
                SetAnimationPhase( m_AnimationPhaseTriggered, 0 );
                SetAnimationPhase( m_AnimationPhaseUsed, 1 );
            }
        }
        else
        {
            if ( m_AnimationPhaseSet != "" && m_AnimationPhaseTriggered != "" )
            {
                SetAnimationPhase( m_AnimationPhaseSet, 0 );
                SetAnimationPhase( m_AnimationPhaseTriggered, 1 );
                SetAnimationPhase( m_AnimationPhaseUsed, 1 );
            }
        }
        
        SetSynchDirty();
    }
 
    override bool IsTakeable()
    {
        return true;
    }
 
    bool IsPlaceableAtPosition( vector position )
    {
        string surface_type;
        GetGame().SurfaceGetType3D( position[0], position[1], position[2], surface_type);
 
        // check surface
        return GetGame().IsSurfaceDigable(surface_type);
    }
 
    void SetupTrap()
    { 
        if ( GetGame().IsServer() )
        {
            if ( GetHierarchyRootPlayer() && GetHierarchyRootPlayer().CanDropEntity( this ) )
            {
                SetupTrapPlayer( PlayerBase.Cast( GetHierarchyRootPlayer() ) );
            }
        }
    }
 
    void SetupTrapPlayer( PlayerBase player, bool set_position = true )
    { 
        if ( GetGame().IsServer() )
        {
            if ( set_position )
            {
                vector trapPos = player.GetPosition() + ( player.GetDirection() * 0.5 );
                trapPos[1] = GetGame().SurfaceRoadY( trapPos[0], trapPos[2] );
                SetPosition( trapPos );
            }
            
            SetDeployed( true );
        }
    }
    
    void Fold()
    {
        if ( GetGame().IsServer() && m_IsFoldable == true )
        {
            SetInactive();
        }
    }
 
    // Deal damage to trap on specific events
    void AddDefect()
    {
        if ( GetGame().IsServer() )
        {
            DecreaseHealth( "", "", m_DefectRate );
        }
    }
    
    void StartActivate( PlayerBase player )     { }
    
    // IsTakeable is used to hide tooltips as well, so we use a custom method instead
    // Used to prevent players from taking traps which should be set for catching
    bool CanBeTaken()
    {
        if ( !IsDeployed() || ( GetInventory().AttachmentCount() == 0 && IsDeployed() ) )
        {
            return true;
        }
        
        return false;
    }
 
    override bool CanPutInCargo( EntityAI parent )
    {
        super.CanPutInCargo( parent );
        return CanBeTaken();
    }
    
    override bool CanPutIntoHands( EntityAI parent )
    {
        super.CanPutIntoHands( parent );
        return CanBeTaken();
    }
    
    // Set animation phases according to state
    void SetActive()
    {
        if ( GetGame().IsServer() && !IsActive() )
        {
            m_IsActive = true;
 
            if ( m_AnimationPhaseSet != "" && m_AnimationPhaseTriggered != "" )
            {
                SetAnimationPhase( m_AnimationPhaseSet, 1 );
                SetAnimationPhase( m_AnimationPhaseTriggered, 0 );
                SetAnimationPhase( m_AnimationPhaseUsed, 1 );
            }
 
            // When activated we start timer for catch check
            m_Timer = new Timer( CALL_CATEGORY_GAMEPLAY );
            m_Timer.Run( m_InitWaitTime, this, "SpawnCatch" );
            
            SetSynchDirty();
        }
    }
 
    void SetInactive()
    {
        if ( GetGame().IsServer() )
        {
            // We stop timers as the trap is no longer active, then update visuals
            m_IsActive = false;
            if ( m_Timer )
            {
                m_Timer.Stop();
            }
            
            SetDeployed( false );
            
            SetSynchDirty();
        }
    }
 
    void SetUsed()
    {
        if ( GetGame().IsServer() )
        {
            // We updated state, visuals and stop timers
            m_IsActive = false;
            m_IsDeployed = false;
            if ( m_Timer )
            {
                m_Timer.Stop();
            }
            
            if ( m_AnimationPhaseSet != "" && m_AnimationPhaseTriggered != "" )
            {
                SetAnimationPhase( m_AnimationPhaseSet, 1 );
                SetAnimationPhase( m_AnimationPhaseTriggered, 1 );
                SetAnimationPhase( m_AnimationPhaseUsed, 0 );
            }
            
            SetSynchDirty();
        }
    }
    
    // Used to check catch conditions and spawn relevant prey
    void SpawnCatch()
    {
        // Only server side, let's make sure
        if ( GetGame().IsClient() )
            return;
        
        // If we can't get CEApi we won't be able to test proximity
        if ( !GetCEApi() )
            return;
        
        int i;
        m_Bait = null;
        
        // We check if we have bait and can catch
        m_CanCatch = SetCanCatch( m_Bait );
        
        SetIsDeploySound( false );
        SetSynchDirty();
        
        // We check the distance from players through CEApi if that check is enabled
        if ( m_MinimalDistanceFromPlayersToCatch > 0 )
        {
            if ( !GetCEApi().AvoidPlayer( GetPosition(), m_MinimalDistanceFromPlayersToCatch ) && m_CanCatch )
            {
                m_CanCatch = false;
                
                // We could not catch yet, let's retest until we can
                if ( m_Timer )
                    m_Timer.Stop();
                
                m_Timer = new Timer( CALL_CATEGORY_GAMEPLAY );
                m_Timer.Run( m_UpdateWaitTime, this, "SpawnCatch" );
                
                return; // No need to go further, let's just wait for next check
            }
        }
        
        // We get the probability to catch depending on bait presence
        if ( m_Bait )
            m_FinalCatchProb = m_BaitCatchProb;
        else
            m_FinalCatchProb = m_NoBaitCatchProb;
        
        // We get the position of prey when it will spawn
        m_PreyPos = GetPosition();
        if ( MemoryPointExists("Prey_Position") )
        {
            m_PreyPos = ModelToWorld( GetMemoryPointPos("Prey_Position") );
        }
    }
 
    // Used to set if the given trap can catch a prey in it's current state
    // Also outs the current bait to check for specific catches if required
    bool SetCanCatch( out EntityAI bait )
    {
        int slotIdx = InventorySlots.GetSlotIdFromString("Trap_Bait");
        bait = GetInventory().FindAttachment( slotIdx );
        
        if ( bait )
        {
            Edible_Base edibleBait = Edible_Base.Cast( bait );
            if ( edibleBait )
            {
                if ( !edibleBait.GetFoodStage().IsFoodBurned() && !edibleBait.GetFoodStage().IsFoodRotten() )
                    return true;
                else
                    return false; // We have invalid bait, no catch
            }
        }
        // We are allowed to catch with no bait
        return true;
    }
    
    // Used to set the quantity of the catch ( later used when preparing fish )
    void CatchSetQuant( ItemBase catch )
    {
        if ( catch.HasQuantity() )
        {
            // Random quantity between 50% and 100%
            float coef = Math.RandomFloatInclusive(0.5, 1.0);
            float item_quantity = catch.GetQuantityMax() * coef;
            item_quantity = Math.Round(item_quantity);
            catch.SetQuantity( item_quantity );
        }
    }
 
    override void OnItemLocationChanged( EntityAI old_owner, EntityAI new_owner ) 
    {
        super.OnItemLocationChanged( old_owner, new_owner );
        
        if ( GetGame().IsServer() )
        {
            // throw trap from vicinity if the trap does not need installation ( action required )
            if ( new_owner == NULL && m_NeedInstalation == false )
            {
                SetActive();
            }
            else if ( old_owner == NULL && new_owner != NULL )
            {
                if ( m_IsFoldable )
                {
                    Fold();
                }
                else
                {
                    SetInactive();
                }
            }
        }
    }
    
    // Generic water check, no real distinction between pond or sea
    bool IsSurfaceWater(vector position)
    {
        string surfaceType;
        GetGame().SurfaceGetType3D(position[0], position[1], position[2], surfaceType);
        
        return Surface.AllowedWaterSurface(position[1] + 0.1, surfaceType, m_PlaceableWaterSurfaceList);
    }
    
    // Can only receive attachment if deployed
    override bool CanDisplayAttachmentSlot( int slot_id )
    {
        super.CanDisplayAttachmentSlot( slot_id );
        return IsDeployed();
    }
    
    override bool CanReceiveAttachment( EntityAI attachment, int slotId )
    {
        super.CanReceiveAttachment( attachment, slotId );
        return IsDeployed();
    }
    
    override void EEItemAttached( EntityAI item, string slot_name )
    {
        super.EEItemAttached( item, slot_name );
        
        // In the case the trap was still deployed, enable "quick re-arm" by attaching
        if ( IsDeployed() && slot_name == "Trap_Bait" )
        {
            SetActive();
        }
    }
    
    //================================================================
    // ADVANCED PLACEMENT
    //================================================================
    
    override void OnPlacementComplete(Man player, vector position = "0 0 0", vector orientation = "0 0 0")
    {
        super.OnPlacementComplete(player, position, orientation);
        
        if (GetGame().IsServer())
        {
            vector rotation_matrix[3];
            float direction[4];
            Math3D.YawPitchRollMatrix(orientation, rotation_matrix);
            Math3D.MatrixToQuat(rotation_matrix, direction);
            InventoryLocation source = new InventoryLocation;
            InventoryLocation destination = new InventoryLocation;
            
            if (GetInventory().GetCurrentInventoryLocation(source))
            {       
                destination.SetGroundEx(this, position, direction);
                if (GetGame().IsMultiplayer())
                    player.ServerTakeToDst(source, destination);
                else // singleplayer
                    player.GetInventory().TakeToDst(InventoryMode.LOCAL, source, destination);
            }
            
            SetupTrapPlayer(PlayerBase.Cast(player), false);
            SetIsDeploySound(true);
            SetActive();
        }
    }
    
    void PlayDeployLoopSound()
    {       
        if ( !GetGame().IsDedicatedServer() )
        {       
            if ( !m_DeployLoopSound || !m_DeployLoopSound.IsSoundPlaying() )
            {
                m_DeployLoopSound = SEffectManager.PlaySound( GetLoopDeploySoundset(), GetPosition() );
            }
        }
    }
    
    void StopDeployLoopSound()
    {
        if ( !GetGame().IsDedicatedServer() )
        {   
            m_DeployLoopSound.SetSoundFadeOut(0.5);
            m_DeployLoopSound.SoundStop();
        }
    }
    
    // We add the action to deploy a trap laid on ground
    override void SetActions()
    {
        super.SetActions();
        
        AddAction(ActionActivateTrap);
        AddAction(ActionDeployHuntingTrap);
    }
    
    
    // ===============================================================
    // =====================  DEPRECATED  ============================
    // ===============================================================
    
    bool CanPutInInventory( EntityAI  player ) { }
    
    void AlignCatch( ItemBase obj, string catch_name ) { }
    
    bool IsPlaceable()
    {
        if ( GetGame().IsServer() )
        {
            if ( GetHierarchyRootPlayer() != NULL && GetHierarchyRootPlayer().GetHumanInventory().GetEntityInHands() == this )
            {
                PlayerBase player = PlayerBase.Cast( GetHierarchyRootPlayer() );
                
                vector player_pos = player.GetPosition();
                vector aim_pos = player.GetAimPosition();
                
                if ( vector.DistanceSq(player_pos, aim_pos) <= ( 1.5 * 1.5 ) )
                {
                    return IsPlaceableAtPosition( aim_pos );
                }
            }
        }
        
        return false;
    }
    
    override bool CanBePlaced( Man player, vector position )
    {
        return IsPlaceableAtPosition(position);
    }
 
    // ===============================================================
}