statebase.c

Go to the documentation of this file.

class SymptomBase
{
    const float MAX_TIME_ACTIVE_SAVEGUARD = 20;
    int m_Priority;
    SoundOnVehicle m_SoundObject;
    bool m_PlayedSound;
    bool m_IsActivated;
    PlayerBase m_Player;
    float m_ServerUpdateInterval = 1;
    float m_ServerUpdateDelta;
    bool m_IsTemplate = true;
    float m_ActivatedTime;
    int m_ID;//ID for the type of Symptom
    int m_UID;//unique ID
    bool m_IsClientOnly;
    bool m_DestroyOnAnimFinish = true;
    bool m_DestroyRequested = false;
    int m_SymptomType = -1;
    bool m_IsPersistent = false;
    SymptomManager m_Manager;
    bool m_SyncToClient = false;
    float m_Duration;
    bool m_AnimPlayRequested;
    int m_MaxCount = -1;//how many symptoms of this type can be queued up at the same time, '-1' for unlimited
 
    SymptomCB m_AnimCallback;
    
    ref array<Param> m_PersistentParams = new array<Param>;
    
    void SymptomBase()
    {
    }
    
    void ~SymptomBase()
    {
 
    }
 
    void Init(SymptomManager manager, PlayerBase player, int uid)
    {
        m_Manager = manager;
        m_Player = player;
        m_UID = uid;
        m_IsTemplate = false;
        OnInit();
    }
    
    int GetMaxCount()
    {
        return m_MaxCount;
    }
    
    int GetUID()
    {
        return m_UID;
    }
 
    void OnOwnerKilled()
    {
        
        
    }
    
    bool CanBeInterupted()
    {
        if (m_AnimPlayRequested) 
        {
            //Print("--------- preventing interrupt ---------");
            return false;
        }
        return true;
    }
    
    bool IsClientOnly()
    {
        return m_IsClientOnly;
    }
    
    
    void SetDuration(float duration)
    {
        m_Duration = duration;
    }
    
    float GetDuration()
    {
        return m_Duration;
    }
    
    string GetName()
    {
        return this.ClassName();        
    }
 
    SymptomManager GetManager()
    {
        return m_Manager;
    }
    
    int GetType()
    {
        return m_ID;
    }
    
    void SetParam(Param p)
    {
    
    }
 
    bool IsSyncToClient()
    {
        return m_SyncToClient;      
    }
    
    bool IsSyncToRemotes()
    {
        return false;
    }
 
    void GetPersistentParams(array<Param> params)
    {
        for (int i = 0; i < m_PersistentParams.Count(); i++)
        {
            params.Insert(m_PersistentParams.Get(i));
        }
    }
 
    void MakeParamObjectPersistent(Param object)
    {
        if ( !GetGame().IsServer() && !GetGame().IsMultiplayer() ) return;
        
        m_PersistentParams.Insert(object);
    }
    
    bool IsPersistent()
    {
        return m_IsPersistent;
    }
    
    bool IsPrimary()
    {
        if ( m_SymptomType == SymptomTypes.PRIMARY)
            return true;
        else return false;
    }
    
    // override this if you want the symptom to be played also while the player is unconscious 
    bool AllowInUnconscious()
    {
        return false;
    }
    
    PlayerBase GetPlayer()
    {
        return m_Player;        
    }
 
    int GetPriority()
    {
        return m_Priority;
    }
    
    bool OnConstructed(SymptomManager manager)
    {
        
    }
    
    void OnDestructed()
    {
        if ( IsActivated() ) Deactivate();
        if ( GetManager() ) m_Manager.OnSymptomExit(this, m_UID);
    }
 
    void Activate()
    {
        m_IsActivated = true;
        if ( GetGame() && GetGame().IsServer() )
        {
            OnGetActivatedServer(m_Player);
            if ( GetGame().IsMultiplayer() )
            {
                if ( IsSyncToClient() ) 
                    SyncToClientActivated( GetType(), GetUID() );
                #ifdef DIAG_DEVELOPER
                GetManager().SendServerDebugToClient();
                #endif
            }
        }
        if ( !GetGame().IsDedicatedServer() )
        {
            OnGetActivatedClient(m_Player);
        }
    }
    
    void Deactivate()
    {
        if ( !GetGame() ) return;
        m_IsActivated = false;
        if ( GetGame().IsServer() ) 
        {
            OnGetDeactivatedServer(m_Player);
            if ( GetGame().IsMultiplayer() && IsSyncToClient() )
            {
                SyncToClientDeactivated( GetType(), GetUID() );
            }
        }
        if ( !GetGame().IsDedicatedServer() )
        {
            OnGetDeactivatedClient(m_Player);
        }
        
    }
    
    bool IsActivated()
    {
        return m_IsActivated;
    }
    
    
    
    void Update(float deltatime)
    {
        if ( GetGame().IsServer() ) 
        {
            m_ServerUpdateDelta += deltatime;
            if (m_ServerUpdateDelta > m_ServerUpdateInterval )
            {
                m_ActivatedTime += m_ServerUpdateDelta;
                OnUpdateServer(m_Player, m_ServerUpdateDelta);
                m_ServerUpdateDelta = 0;
            }
        }
        if ( GetGame().IsClient() )
        {
            OnUpdateClient(m_Player, deltatime);
        }
        if ( GetGame().IsServer() && !GetGame().IsMultiplayer() && !GetGame().IsMissionMainMenu() )
        {
            OnUpdateClient(m_Player, deltatime);
        }
        CheckDestroy();
    }
    
    void PlayAnimationFB(int animation, int stance_mask, float running_time = -1)
    {
        DayZPlayerSyncJunctures.SendPlayerSymptomFB(m_Player, animation, GetType() , stance_mask, running_time );
        m_AnimPlayRequested = true;
    }
    
    void PlayAnimationADD(int type)
    {
        DayZPlayerSyncJunctures.SendPlayerSymptomADD(m_Player, type, GetType());
        m_AnimPlayRequested = true;
    }
        
    void PlaySound(EPlayerSoundEventID id)
    {
        GetPlayer().RequestSoundEvent(id);
        m_PlayedSound = true;
    }
 
    void SyncToClientActivated( int SYMPTOM_id, int uid )
    {
        if ( !GetPlayer() ) return;
        
        CachedObjectsParams.PARAM2_INT_INT.param1 = SYMPTOM_id;
        CachedObjectsParams.PARAM2_INT_INT.param2 = uid;
        GetGame().RPCSingleParam(GetPlayer(), ERPCs.RPC_PLAYER_SYMPTOM_ON, CachedObjectsParams.PARAM2_INT_INT,true,GetPlayer().GetIdentity() );
    }
    
    void SyncToClientDeactivated( int SYMPTOM_id, int uid )
    {
        if ( !GetPlayer() ) return;
        CachedObjectsParams.PARAM2_INT_INT.param1 = SYMPTOM_id;
        CachedObjectsParams.PARAM2_INT_INT.param2 = uid;
        GetGame().RPCSingleParam(GetPlayer(), ERPCs.RPC_PLAYER_SYMPTOM_OFF, CachedObjectsParams.PARAM2_INT_INT,true,GetPlayer().GetIdentity() );
    }
 
    void CheckSoundFinished()
    {
        if (GetGame().IsServer())
        {
            if (m_PlayedSound && m_ActivatedTime >= m_Duration)
                RequestDestroy();
        }
    }
    
    void CheckDestroy()
    {
        CheckSoundFinished();
        if ( IsPrimary() && m_ActivatedTime > MAX_TIME_ACTIVE_SAVEGUARD)
        {
            RequestDestroy();
        }
        
        if (m_DestroyRequested) 
            Destroy();
    }
    
    SmptAnimMetaBase SpawnAnimMetaObject()
    {
        return null;
    }
    
 
    void RequestDestroy()
    {
        m_DestroyRequested = true;
        //if(!IsActivated() ) Destroy();
    }
 
    void Destroy()
    {
        if (!m_IsTemplate)
            OnDestructed();
    }
    
    void AnimationFinish()
    {
        //Print("*********** OnAnimationFinish ************");
        if ( m_DestroyOnAnimFinish ) RequestDestroy();
        OnAnimationFinish();
    }
    
    void AnimationPlayFailed()
    {
        OnAnimationPlayFailed();
        AnimationFinish();
    }
    
    void AnimationStart()
    {
        OnAnimationStart();
    }
    
    protected void OnAnimationFinish();
    protected void OnAnimationStart();
    protected void OnAnimationPlayFailed();
 
    
    void OnInit();
    
    void OnUpdateServer(PlayerBase player, float deltatime);
    bool CanActivate(){return true;}//server only
    void OnUpdateClient(PlayerBase player, float deltatime);
    void OnGetActivatedServer(PlayerBase player);
    void OnGetActivatedClient(PlayerBase player);
    void OnGetDeactivatedServer(PlayerBase player);
    void OnGetDeactivatedClient(PlayerBase player);
}