AnimatedActionBase.c

Go to the documentation of this file.

class ActionBaseCB : HumanCommandActionCallback
{
    protected ActionData                m_ActionData;
    protected SoundOnVehicle            m_SoundObject;//object of sound playing on entity
    protected bool                      m_Canceled;//helps prevent doubled calling of actionbase End method
    protected bool                      m_Interrupted;//force callback to wait till action syncs its interruption
        
        
    void ActionBaseCB()
    {
    }
    
    int GetPossileStanceMask()
    {
        return m_ActionData.m_PossibleStanceMask;
    }
    
    //Command events
    override void OnFinish(bool pCanceled)  
    {
        if ( LogManager.IsActionLogEnable() )
        {
            if ( m_ActionData)
                Debug.ActionLog("Time stamp: " + m_ActionData.m_Player.GetSimulationTimeStamp(), m_ActionData.m_Action.ToString() , "n/a", "OnFinish", m_ActionData.m_Player.ToString() );
            else
                Debug.ActionLog("n/a", this.ToString() , "n/a", "OnFinish", "n/a" );
        }
        if ( m_SoundObject ) 
        {
            GetGame().ObjectDelete(m_SoundObject);
        }
        if ( m_ActionData && m_ActionData.m_Player )
        {
            if ( pCanceled ) 
            {
                m_ActionData.m_State = m_ActionData.m_ActionComponent.Interrupt(m_ActionData);
            }
            
            AnimatedActionBase action = AnimatedActionBase.Cast(m_ActionData.m_Action);
            
            if(action)
                action.End(m_ActionData);
        }
    }
    
    void SetCommand( int command_uid )
    {       
        InternalCommand(command_uid);
    }
 
    //---------------------------------------------------------------
    //Action Component handlers
    void CreateActionComponent() 
    {
        m_ActionData.m_ActionComponent = new CADummy;
    }
    
    void InitActionComponent()
    {
    }
    
    void ProgressActionComponent()
    {
        if ( m_ActionData.m_ActionComponent )
        { 
            m_ActionData.m_State = m_ActionData.m_ActionComponent.Execute(m_ActionData);
        }
    }   
    
    void EndActionComponent()
    {
    }   
    
    void Interrupt()
    {
        if ( GetGame().IsServer() )
        {
            if ( LogManager.IsActionLogEnable() )
            {
                Debug.ActionLog("n/a", this.ToString() , "n/a", "Interrupt", m_ActionData.m_Player.ToString() );    
            }
            if ( GetGame().IsMultiplayer() )
            {
                DayZPlayerSyncJunctures.SendActionInterrupt(m_ActionData.m_Player);
            }
        }
        else
        {
            if (ScriptInputUserData.CanStoreInputUserData())
            {
                ScriptInputUserData ctx = new ScriptInputUserData;
                ctx.Write(INPUT_UDT_STANDARD_ACTION_END_REQUEST);
                ctx.Write(DayZPlayerConstants.CMD_ACTIONINT_INTERRUPT);
                ctx.Send();
            }
        }
        m_Interrupted = true;
    }
    
    void SetActionData(ActionData action_data )
    {
        m_ActionData = action_data;
    }
    
    override bool IsUserActionCallback()
    {
        return true;
    }
    
    float GetActionComponentProgress()
    {
        if ( m_ActionData.m_ActionComponent )
        {
            return m_ActionData.m_ActionComponent.GetProgress();
        }
        return 0;
    }
    
    int GetActionState()
    {
        return m_ActionData.m_State;
    }
    
    ActionTarget GetTarget()
    {
        return m_ActionData.m_Target;
    }
};
 
 
 
class AnimatedActionBase : ActionBase
{   
    protected int                   m_CommandUID;   //tells which command should be used for callback
    protected int                   m_CommandUIDProne;
    protected typename              m_CallbackClass; //tells which callback should be instantiated
 
    
    //-----------------------------------------------------
    //  Action events and methods
    //-----------------------------------------------------
    void AnimatedActionBase() 
    {
        // definable
        m_CallbackClass = ActionBaseCB;
    }
    
    protected void OnAlternativeEndServer( PlayerBase player ) //method called when action has not met conditions in action component
    {
    }
    protected void OnAlternativeEndClient( PlayerBase player ) //method called when action has not met conditions in action component
    {
    }
    
    protected void OnInterruptServer( PlayerBase player ) //method called when action has not met conditions in action component
    {
    }
    protected void OnInterruptClient( PlayerBase player ) //method called when action has not met conditions in action component
    {
    }
    
    protected void OnExecute( ActionData action_data )
    {
    }
    
    protected void OnExecuteServer( ActionData action_data )
    {
    }
    
    protected void OnExecuteClient( ActionData action_data )
    {
    }
    
    //TODO MW - add comment 
    void OnAnimationEvent( ActionData action_data )
    {
        if (action_data && !action_data.m_WasExecuted)
        {
            ActionBase action = action_data.m_Action;
            
            if (action && ( !action.UseMainItem() || action_data.m_MainItem ) && ( !action.HasTarget() || action_data.m_Target ))
            {
                if ( LogManager.IsActionLogEnable() )
                {
                    Debug.ActionLog("Time stamp: " + action_data.m_Player.GetSimulationTimeStamp(), this.ToString() , "n/a", "OnExecute", action_data.m_Player.ToString() );
                }
                OnExecute(action_data);
            
                if (GetGame().IsServer())
                    OnExecuteServer(action_data);
                else
                    OnExecuteClient(action_data);
 
                action_data.m_WasExecuted = true;
                action_data.m_WasActionStarted  = true;
            }
        }
    }
    
    override bool ActionConditionContinue( ActionData action_data ) //condition for action
    {
        return ActionCondition(action_data.m_Player,action_data.m_Target,action_data.m_MainItem);
    }
    
    override bool ActionCondition( PlayerBase player, ActionTarget target, ItemBase item ) //condition for action
    {
        return true;
    }
    
    //TODO MW - add comment 
    protected int GetActionCommand( PlayerBase player )
    {
        if ( HasProneException() )
        {
            if ( player.IsPlayerInStance(DayZPlayerConstants.STANCEMASK_CROUCH | DayZPlayerConstants.STANCEMASK_ERECT))
                return m_CommandUID;
            else
                return m_CommandUIDProne;
        }
        return m_CommandUID;
    }
    
    protected typename GetCallbackClassTypename()
    {
        return m_CallbackClass; 
    }
    
    // if it is set to true if action have special fullbody animation for prone and additive for crouch and erect
    override bool HasProneException()
    {
        return false;
    }
    
    //TODO MW - add comment 
    protected void CreateAndSetupActionCallback( ActionData action_data )
    {
        //Print("ActionBase.c | CreateAndSetupActionCallback | DBG ACTION CALLBACK CREATION CALLED");
        ActionBaseCB callback;
        if (  IsFullBody(action_data.m_Player) )
        {
            Class.CastTo(callback, action_data.m_Player.StartCommand_Action(GetActionCommand(action_data.m_Player),GetCallbackClassTypename(),GetStanceMask(action_data.m_Player)));    
            //Print("ActionBase.c | CreateAndSetupActionCallback |  DBG command starter");      
        }
        else
        {
            Class.CastTo(callback, action_data.m_Player.AddCommandModifier_Action(GetActionCommand(action_data.m_Player),GetCallbackClassTypename()));
            //Print("ActionBase.c | CreateAndSetupActionCallback |  DBG command modif starter: "+callback.ToString()+"   id:"+GetActionCommand().ToString());
            
        }
        callback.SetActionData(action_data); 
        callback.InitActionComponent(); //jtomasik - tohle mozna patri do constructoru callbacku?
        action_data.m_Callback = callback;
    }
        
        
        
    //  ACTION LOGIC -------------------------------------------------------------------
    // called from actionmanager.c
    override void Start( ActionData action_data ) //Setup on start of action
    {
        super.Start( action_data );
        //Debug.Log("[Action DEBUG] Start time stamp: " + action_data.m_Player.GetSimulationTimeStamp());
 
        if( !IsInstant() )
        {
            CreateAndSetupActionCallback(action_data);
        }
        /*Debug
        SendMessageToClient( player, "ActionBase.c : Start");
        Print("ActionBase.c : Start");
        */
    }
    
    // THIS Interrupt is use for ACTUAL handling of intrrupt on action side - WARNING Interrupt without parametr is used for initialize interrupt
    override void Interrupt( ActionData action_data )
    {
        if ( action_data.m_Callback )
        {
            action_data.m_Callback.Cancel();
        }
        else
        {
            End( action_data );
        }
    }
    
    void OnJumpStart()
    {
        
    }
        
    // called from ActionBaseCB.c
    void Do( ActionData action_data, int state )
    {
        if ( state == UA_ERROR || !action_data.m_Callback || !action_data.m_Player || !action_data.m_ActionComponent ) //jtomasik - tohle mozna muze byt v CancelCondtion metodu callbacku?
        {
#ifdef DIAG_DEVELOPER
            if ( LogManager.IsActionLogEnable() )
            {
                Debug.ActionLog("ABRUPT CANCEL, CONDITIONS NOT MET", this.ToString() , "n/a", "Do", action_data.m_Player.ToString() );
            }
#endif
            if ( action_data.m_Callback && action_data.m_Player )
            {           
                action_data.m_Callback.Interrupt();
            }
            else
            {
                Debug.ActionLog("PLAYER LOST", this.ToString() , "n/a", "Do", action_data.m_Player.ToString() );
            }   
        }
        else
        {
            switch ( state )
            {
                case UA_PROCESSING: 
                    if ( CanContinue(action_data) )
                    {   
                        action_data.m_Callback.ProgressActionComponent();
                        InformPlayers(action_data.m_Player, action_data.m_Target, UA_PROCESSING);
                    }
                    else
                    {
                        action_data.m_Callback.Interrupt();
                        InformPlayers(action_data.m_Player, action_data.m_Target, UA_CANCEL);
                        Do(action_data, UA_CANCEL);
                    }
                    break;
                
                case UA_FINISHED:
                    InformPlayers(action_data.m_Player,action_data.m_Target,UA_FINISHED);
                    action_data.m_Callback.EndActionComponent();
                    break;
                
                case UA_CANCEL:
                    InformPlayers(action_data.m_Player,action_data.m_Target,UA_CANCEL);
                    action_data.m_Callback.EndActionComponent();
                    break;  
                
                case UA_INITIALIZE:
                    if ( !CanContinue(action_data) )
                    {                       
                        action_data.m_Callback.Interrupt();
                        InformPlayers(action_data.m_Player, action_data.m_Target, UA_CANCEL);
                        Do(action_data, UA_CANCEL);
                    }
                default:
                    Debug.ActionLog("Action component returned wrong value", this.ToString() , "n/a", "Do", action_data.m_Player.ToString() );
                    action_data.m_Callback.Interrupt();
                    break;
            }
        }
    }
    
    // called from ActionBaseCB.c 
    override void End( ActionData action_data )
    {
        if ( action_data.m_Player ) 
        {
            if ( GetGame().IsServer() )
            {
                OnEndServer(action_data);
                action_data.m_Player.SetSoundCategoryHash(0);
            }
            else
            {
                OnEndClient(action_data);
            }
            OnEnd(action_data);
            
            // Xbox Achievemnts
            if ( action_data.m_WasActionStarted )
            {
                if ( IsEat() )
                {
                    GetGame().GetAnalyticsClient().OnActionEat();
                }
                else if ( IsDrink() )
                {
                    GetGame().GetAnalyticsClient().OnActionDrink();
                }
                
                action_data.m_WasActionStarted = false;
            }
            
            action_data.m_Player.GetActionManager().OnActionEnd();
            
            
        }
        else
        {
            if ( LogManager.IsActionLogEnable() )
            {
                Debug.ActionLog("Ation could not be finished right at the end", this.ToString() , "n/a", "End", action_data.m_Player.ToString() );
            }
            action_data.m_Callback.Interrupt();
        }
    }
    
    override float GetProgress( ActionData action_data )
    {
        if ( action_data.m_ActionComponent )
        {    
            return action_data.m_ActionComponent.GetProgress();
        }
        return 0;
    }
};