actioninput.c

Go to the documentation of this file.

enum ActionInputType
{
    AIT_CONTINUOUS,             //React to hold input and release after it
    AIT_SINGLE,                 //React to click input - single use actions
    AIT_DOUBLECLICK,            //React to double click input - single use actions
    AIT_HOLDSINGLE,             //React to hold input - single use actions
    AIT_CLICKCONTINUOUS,        //React to click input for start and click for end
    AIT_NOINPUTCONTROL,
    AIT_INVENTORYINPUT,         //Inventory specific actions
}
 
class ForcedActionData
{
    ActionBase m_Action;
    ref ActionTarget m_Target;
    ItemBase m_Item;
}
 
class ActionInput : ActionInput_Basic
{
    UAIDWrapper m_input;            //Input ID automaticly generated from name.
    int m_InputType;            //Use from action manager for handling input
    int m_Priority;
    bool m_DetectFromItem;      //Can be used action from item in hands?
    bool m_DetectFromTarget;    //Can be used action from target in vicinity?
    bool m_DetectFromPlayer;    //Can be used action from player?
    bool m_Enabled;
    bool m_JustActivate;
    bool m_HasTarget;
    
    PlayerBase m_Player;
    
    ref ActionTarget m_ForcedTarget;
    
    ref ForcedActionData m_ForcedActionData;
    
    ref ActionTarget m_Target;
    ItemBase m_MainItem;
    int m_ConditionMask;
    
    bool m_Active;
    
    void ActionInput()
    {
        m_Active = false;
        m_Enabled = true;
        m_ForcedTarget = null;
        m_ForcedActionData = null;
        
        m_HasTarget = false;
        
        m_JustActivate = false;
        m_DetectFromTarget = false;
        m_DetectFromItem = true;
        m_DetectFromPlayer = true;
        
        m_Priority = 100;
    }
    
    void Init(PlayerBase player, ActionManagerClient am)
    {
        m_Player = player;
        
        if ( LogManager.IsActionLogEnable())
        {
            Debug.ActionLog("n/a",this.ToString(), "n/a","Init()", player.ToString());
        }
        
    }
    
    void SetEnablity(bool value)
    {
        m_Enabled = value;
    }
    
    protected void SetInput(string input_name)
    {
        m_input = GetUApi().GetInputByName(input_name).GetPersistentWrapper();
        
        if ( LogManager.IsActionLogEnable())
        {
            if (m_input && m_input.InputP())
                Debug.ActionLog("(+) input set to " + input_name ,this.ToString(), "n/a","SetInput()", "n/a");
            else
                Debug.ActionLog("(-) input is not set to " + input_name ,this.ToString(), "n/a","SetInput()","n/a");
        }
    }
    
    int GetInputType()
    {
        return m_InputType;
    }
    
    UAInput GetUAInput()
    {
        return m_input.InputP();
    }
    
    bool JustActivate()
    {
        return m_JustActivate;
    }
 
    bool IsActive()
    {
        return m_Active;
    }
        
    bool WasEnded()
    {
        return !m_Active;
    }
    
    void Update()
    {
        if( !m_Enabled )
        {
            m_Active = false;
            m_JustActivate = false;
            return;
        }
        
        switch ( m_InputType )
        {
            case ActionInputType.AIT_CONTINUOUS:
                m_JustActivate = false;
                if(m_Active)
                {
                    m_Active = m_input.InputP().LocalHold();
                }
                else
                {
                    m_Active = m_input.InputP().LocalHoldBegin();
                    m_JustActivate = m_Active;
                }
                break;
            case ActionInputType.AIT_SINGLE:
                m_Active = m_input.InputP().LocalClick();
                m_JustActivate = m_Active;
                break;
            case ActionInputType.AIT_DOUBLECLICK:
                m_Active = m_input.InputP().LocalDoubleClick();
                m_JustActivate = m_Active;
                break;
            break;
            case ActionInputType.AIT_HOLDSINGLE:
                m_Active = m_input.InputP().LocalHoldBegin();
                m_JustActivate = m_Active;
                break;
            break;
            case ActionInputType.AIT_CLICKCONTINUOUS:
                m_JustActivate = false;
                if(m_Active)
                {
                    if ( m_input.InputP().LocalClick() )
                    {
                        m_Active = false;
                    }
                }
                else
                {
                    m_Active = m_input.InputP().LocalClick();
                    m_JustActivate = m_Active;
                }
                break;
            break;
            default:
                break;
        }
    }
    
    void Reset()
    {
        m_Active = false;
        ActionsSelectReset();
    }
    
    void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
    {   
    }
    
    ActionBase GetAction()
    {
        return NULL;
    }
    
    ActionTarget GetUsedActionTarget()
    {
        return m_Target;
    }
    
    ItemBase GetUsedMainItem()
    {
        return m_MainItem;
    }
    
    array<ActionBase> GetPossibleActions()
    {
        return NULL;
    }
    
    ActionBase GetPossibleAction()
    {
        return NULL;
    }
    
    int GetPossibleActionIndex()
    {
        return -1;
    }
    
    bool HasTarget()
    {
        return false;
    }
    
    void OnActionStart()
    {
        ActionsSelectReset();
    }
    
    void OnActionEnd()
    {
        Reset();
    }
    
    void ActionsSelectReset()
    {}
    
    void ForceAction(ActionBase action, ActionTarget target, ItemBase item )
    {
        m_ForcedActionData = new ForcedActionData;
        m_ForcedActionData.m_Action = action;
        m_ForcedActionData.m_Target = target;
        m_ForcedActionData.m_Item = item;
    }
    
    void ForceActionTarget( ActionTarget target )
    {
        m_ForcedTarget = target;
    }
    
    void ClearForcedAction()
    {
        m_ForcedActionData = null;
    }
    
    void ClearForcedTarget()
    {
        m_ForcedTarget = NULL;
    }
    
    bool ForceActionCheck(PlayerBase player)
    {
        if (m_ForcedActionData)
        {
            if (m_ForcedActionData.m_Action.Can(player, m_ForcedActionData.m_Target, m_ForcedActionData.m_Item))
            {
                m_MainItem = m_ForcedActionData.m_Item;
                m_Target = m_ForcedActionData.m_Target;
                return true;
            }
        }
        return false;
    }
    
    void SelectNextAction()
    {
    }
    
    void SelectPrevAction()
    {}
    
    int GetPossibleActionsCount()
    {
        return -1;
    }
    
    bool HasInput()
    {
        return m_input != NULL;
    }
    
    int GetPriority()
    {
        return m_Priority;
    }
}
 
class StandardActionInput : ActionInput
{
    ref array<ActionBase>   m_SelectActions;
    int                     m_selectedActionIndex;
    
    void StandardActionInput(PlayerBase player)
    {
        m_selectedActionIndex = 0;
        m_SelectActions = new array<ActionBase>;
    }
    
    override void ForceAction(ActionBase action, ActionTarget target, ItemBase item )
    {
        super.ForceAction(action, target, item);
 
        m_selectedActionIndex = 0;
    }
    
    void _GetSelectedActions( Object action_source_object, out array<ActionBase> select_actions_all, out bool has_any_action_target)
    {
        if ( !action_source_object )
            return;
        
        array<ActionBase_Basic> possible_actions;
        array<ref ActionBase> variant_actions;
        action_source_object.GetActions(this.Type(), possible_actions);
        ActionBase action;
        
        if(possible_actions)
        {
            for (int i = 0; i < possible_actions.Count(); i++)
            {
                action = ActionBase.Cast(possible_actions.Get(i));
                        
                if ( action.HasVariants() )
                {
                    action.UpdateVariants( m_MainItem, m_Target.GetObject(), m_Target.GetComponentIndex() );
                    action.GetVariants( variant_actions);
                    for (int j = 0; j < variant_actions.Count(); j++)
                    {
                        action = variant_actions[j];
                        if ( action.Can(m_Player, m_Target, m_MainItem, m_ConditionMask) )
                        {
                            select_actions_all.Insert(action);
                            if (action.HasTarget())
                                has_any_action_target = true;
                        }
                    }
                }
                else
                {
                    if ( action.Can(m_Player, m_Target, m_MainItem, m_ConditionMask) )
                    {
                        select_actions_all.Insert(action);
                        if (action.HasTarget())
                            has_any_action_target = true;
                    }
                }
            }
        }
    }
    
    override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
    {
        if ( ForceActionCheck(player))
        {
            m_SelectActions.Clear();
            m_SelectActions.Insert(m_ForcedActionData.m_Action);
            return;
        }
        
        if(m_ForcedTarget)
        {
            target = m_ForcedTarget;
        }
 
        array<ActionBase> select_actions_all = new array<ActionBase>;
        int i, last_index;
        bool change = false;
        m_HasTarget = false;
        
        m_MainItem = item;
        m_Target = target;
        m_ConditionMask = action_condition_mask;
        
        
        if( m_DetectFromItem )
        {
            _GetSelectedActions( item, select_actions_all, m_HasTarget);
        }
        
 
        if( m_DetectFromTarget )
        {   
            _GetSelectedActions( target.GetObject(), select_actions_all, m_HasTarget);
            _GetSelectedActions( target.GetParent(), select_actions_all, m_HasTarget);
        }
        
        if( m_DetectFromPlayer )
        {
            _GetSelectedActions( player, select_actions_all, m_HasTarget);
        }
        
        if (select_actions_all.Count())
        {
            last_index = 0;
            for ( i = 0; i < select_actions_all.Count(); i++ )
            {
                ActionBase action = select_actions_all[i];
                if ( m_HasTarget )
                {
                    if ( action.HasTarget() )
                    {
                        if ( m_SelectActions.Count() > last_index )
                        {
                            if ( m_SelectActions[last_index] != action )
                            {
                                change = true;
                                m_SelectActions[last_index] = action;
                            }
                        }
                        else
                        {
                            change = true;
                            m_SelectActions.Insert(action);
                        }
                        action.OnActionInfoUpdate(player, target, item);
                        last_index++;
                    }
                }
                else
                {
                    if ( m_SelectActions.Count() > last_index )
                    {
                        if ( m_SelectActions[last_index] != action )
                        {
                            change = true;
                            m_SelectActions[last_index++] = action;
                        }
                    }
                    else
                    {
                        change = true;
                        m_SelectActions.Insert(action);
                    }
                    action.OnActionInfoUpdate(player, target, item);
                    last_index++;
                }
            }
        }
        else
        {
            change = true;
            m_selectedActionIndex = 0;
            m_SelectActions.Clear();
        }
        
        if (m_SelectActions.Count() > last_index)
        {
            change = true;
            for (i = last_index; i < m_SelectActions.Count(); i++)
            {
                m_SelectActions.Remove(last_index);
            }
        }
        
        if ( change )
        {
            m_selectedActionIndex = 0;
            m_Player.GetActionManager().SelectFirstActionCategory();
        }
    }
    
    override array<ActionBase> GetPossibleActions()
    {
        return m_SelectActions;
    }
    
    override int GetPossibleActionsCount()
    {
        return m_SelectActions.Count();
    }
    
    override bool HasTarget()
    {
        return m_HasTarget;
    }
    
    override int GetPossibleActionIndex()
    {
        return m_selectedActionIndex;
    }
    
    override ActionBase GetAction()
    {
        if (m_SelectActions.Count() > 0)
            return m_SelectActions[m_selectedActionIndex];
        return null;
    }
    
    override void ActionsSelectReset()
    {
        m_SelectActions.Clear();
        m_selectedActionIndex = 0;
    }
    
    override void SelectNextAction()
    {
        if(m_SelectActions.Count())
        {
            m_selectedActionIndex++;
            if(m_SelectActions.Count() <= m_selectedActionIndex )
            {
                m_selectedActionIndex = 0;
            }
        }
    }
    
    override void SelectPrevAction()
    {
        if(m_SelectActions.Count())
        {
            m_selectedActionIndex--;
            if(0 > m_selectedActionIndex )
            {
                m_selectedActionIndex = m_SelectActions.Count() - 1;
            }
        }
    }
 
}
 
class ContinuousInteractActionInput : StandardActionInput
{
    void ContinuousInteractActionInput(PlayerBase player)
    {
        SetInput("UAAction");
        m_Priority = 60;
        m_InputType = ActionInputType.AIT_CONTINUOUS;
        m_DetectFromTarget = true;
        m_DetectFromItem = false;
        m_DetectFromPlayer = true;
    }
};
 
class InteractActionInput : ContinuousInteractActionInput
{
    void InteractActionInput(PlayerBase player)
    {
        m_InputType = ActionInputType.AIT_SINGLE;
        m_Priority = 80;
    }
    
    override void OnActionStart()
    {
        super.OnActionStart();
        m_Active = false;
    }
    
    override bool WasEnded()
    {
        return false;
    }
};
 
class NoIndicationActionInputBase : ActionInput
{
    void NoIndicationActionInputBase(PlayerBase player)
    {
        m_DetectFromTarget = false;
    }
    
    override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
    {
        m_MainItem = item;
        m_Target = target;
        m_ConditionMask = action_condition_mask;
    }
    
    override ActionBase GetAction()
    {
        if ( ForceActionCheck(m_Player) )
            return m_ForcedActionData.m_Action;
        
        if(m_MainItem)
        {
            array<ActionBase_Basic> possible_actions;
            ActionBase action;
            
            m_MainItem.GetActions(this.Type(), possible_actions);
            if(possible_actions)
            {
                for (int i = 0; i < possible_actions.Count(); i++)
                {
                    action = ActionBase.Cast(possible_actions.Get(i));
                    if ( action.Can(m_Player, m_Target, m_MainItem, m_ConditionMask) )
                    {
                        return action;
                    }
                }
            }
        
        }
        return NULL;
    }
 
    override ActionBase GetPossibleAction()
    {
        return GetAction();
    }
}
 
 
 
class ContinuousDefaultActionInput : StandardActionInput
{
    protected ActionBase m_SelectAction; //Do nothing only for back compatibilit, relevant only for inherited class
    void ContinuousDefaultActionInput(PlayerBase player)
    {
        SetInput("UADefaultAction");
        m_InputType = ActionInputType.AIT_CONTINUOUS;
        m_Priority = 20;
        m_DetectFromTarget = false;
        m_DetectFromItem = true;
        m_DetectFromPlayer = true;
        
        m_SelectAction = null;
    }
    
    override ActionBase GetPossibleAction()
    {
        return m_SelectAction;
    }
    
    override void ActionsSelectReset()
    {
        super.ActionsSelectReset();
        m_SelectAction = NULL;
    }
};
 
class DefaultActionInput : ContinuousDefaultActionInput
{
    void DefaultActionInput(PlayerBase player)
    {
        m_InputType = ActionInputType.AIT_SINGLE;
        m_Priority = 40;
    }
    
    override void OnActionStart()
    {
        super.OnActionStart();
        m_Active = false;
    }
    
    override bool WasEnded()
    {
        return false;
    }
};
 
class DropActionInput : NoIndicationActionInputBase
{
    void DropActionInput(PlayerBase player)
    {
        SetInput("UADropitem");
        m_InputType = ActionInputType.AIT_HOLDSINGLE;
    }
};
 
class CarHornShortActionInput : ContinuousDefaultActionInput
{
    ref ActionTarget targetNew;
 
    void CarHornShortActionInput(PlayerBase player)
    {
        SetInput("UACarHorn");
        m_InputType         = ActionInputType.AIT_SINGLE;
        m_Priority          = 100;
        m_DetectFromItem    = false;
        m_DetectFromTarget  = false;
        m_DetectFromPlayer  = false;
    }
    
    override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
    {
        if (ForceActionCheck(player))
        {
            m_SelectAction = m_ForcedActionData.m_Action;
            return;
        }
        
        m_SelectAction = null;
        array<ActionBase_Basic> possibleActions;
        ActionBase action;
        int i;
 
        m_MainItem = null;
        if (player && player.IsInVehicle())
        {
            HumanCommandVehicle vehCommand = player.GetCommand_Vehicle();
            if (vehCommand)
            {
                Transport trans = vehCommand.GetTransport();
                if (trans)
                {
                    targetNew = new ActionTarget(trans, null, -1, vector.Zero, -1);
                    ForceActionTarget(targetNew);
                }
            }
            
            if (!targetNew)
            {
                ClearForcedTarget();
            }
        }
        
        target = m_ForcedTarget;
        m_Target = m_ForcedTarget;
        
        if (target && target.GetObject())
        {
            target.GetObject().GetActions(this.Type(), possibleActions);
            if (possibleActions)
            {
                for (i = 0; i < possibleActions.Count(); i++)
                {
                    action = ActionBase.Cast(possibleActions.Get(i));
                    if (action.Can(player, target, m_MainItem, action_condition_mask))
                    {
                        m_SelectAction = action;
                        return;
                    }
                }
            }
        }
    }
    
    override ActionBase GetAction()
    {
        return m_SelectAction;
    }
}
 
class CarHornLongActionInput : CarHornShortActionInput
{
    void CarHornLongActionInput(PlayerBase player)
    {
        SetInput("UACarHorn");
        m_InputType         = ActionInputType.AIT_CONTINUOUS;
        m_Priority          = 101;
        m_DetectFromItem    = false;
        m_DetectFromTarget  = false;
        m_DetectFromPlayer  = false;
    }
}
 
class ToggleLightsActionInput : DefaultActionInput
{
    ref ActionTarget target_new;
    
    void ToggleLightsActionInput(PlayerBase player)
    {
        SetInput("UAToggleHeadlight");
        m_InputType = ActionInputType.AIT_SINGLE;
        m_Priority = 100;
    }
    
    override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
    {
        if( ForceActionCheck(player) )
        {
            m_SelectAction = m_ForcedActionData.m_Action;
            return;
        }
        //ForceActionTarget(player.m_PlayerLightManager.
        
        m_SelectAction = NULL;
        array<ActionBase_Basic> possible_actions;
        ActionBase action;
        int i;
 
        m_MainItem = NULL;
        if ( player && !player.IsInVehicle() ) 
        {
            Clothing headgear = Clothing.Cast(player.FindAttachmentBySlotName("Headgear"));
            Clothing eyewear = Clothing.Cast(player.FindAttachmentBySlotName("Eyewear"));
            //TODO - extend this to allow for a switchable control over all possible light sources (depth 0 or 1 only?)
            
            if ( headgear && headgear.GetLightSourceItem() )
            {
                target_new = new ActionTarget(headgear, null, -1, vector.Zero, -1);
                ForceActionTarget(target_new);
            }
            else if ( eyewear && eyewear.GetLightSourceItem() )
            {
                target_new = new ActionTarget(eyewear, null, -1, vector.Zero, -1);
                ForceActionTarget(target_new);
            }
            else
                ClearForcedTarget();
        }
        else if ( player && player.IsInVehicle() )
        {
            HumanCommandVehicle vehCommand = player.GetCommand_Vehicle();
            if( vehCommand )
            {
                Transport trans = vehCommand.GetTransport();
                if( trans )
                {
                    target_new = new ActionTarget(trans, null, -1, vector.Zero, -1);
                    ForceActionTarget(target_new);
                }
            }
            
            if ( !target_new )
                ClearForcedTarget();
        }
        
        target = m_ForcedTarget;
        m_Target = m_ForcedTarget;
        
        if(target && target.GetObject())
        {
            target.GetObject().GetActions(this.Type(), possible_actions);
            if(possible_actions)
            {
                for (i = 0; i < possible_actions.Count(); i++)
                {
                    action = ActionBase.Cast(possible_actions.Get(i));
                    if ( action.Can(player, target, m_MainItem, action_condition_mask) )
                    {
                        m_SelectAction = action;
                        return;
                    }
                }
            }
        }
    }
    
    override ActionBase GetAction()
    {
        return m_SelectAction;
    }
};
 
class ToggleNVGActionInput : DefaultActionInput
{
    ref ActionTarget target_new;
    
    void ToggleNVGActionInput(PlayerBase player)
    {
        SetInput("UAToggleNVG");
        m_InputType = ActionInputType.AIT_HOLDSINGLE;
        m_Priority = 100;
    }
    
    override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
    {
        if( ForceActionCheck(player) )
        {
            m_SelectAction = m_ForcedActionData.m_Action;
            return;
        }
        
        m_SelectAction = null;
        array<ActionBase_Basic> possible_actions;
        ActionBase action;
        int i;
 
        m_MainItem = null;
        if (player) 
        {
            CachedEquipmentStorageQuery query = new CachedEquipmentStorageQuery();
            query.m_Category = ECachedEquipmentItemCategory.NVG;
            query.m_Placement = ECachedEquipmentPlacement.ATTACHMENT;
            query.m_MaximumDepth = 2;
            
            array<Entity> nvgs = player.GetCachedEquipment().GetEntitiesByCategory(query);
            Object nvgParent = null;
            foreach (Entity nvg : nvgs)
            {
                nvgParent = EntityAI.Cast(nvg).GetHierarchyParent();
                break;
            }
 
            if (nvgParent)
            {
                target_new = new ActionTarget(nvgParent, null, -1, vector.Zero, -1);
                ForceActionTarget(target_new);
            }
            else
                ClearForcedTarget();
        }
        
        target = m_ForcedTarget;
        m_Target = m_ForcedTarget;
        
        if(target && target.GetObject())
        {
            target.GetObject().GetActions(this.Type(), possible_actions);
            if(possible_actions)
            {
                for (i = 0; i < possible_actions.Count(); i++)
                {
                    action = ActionBase.Cast(possible_actions.Get(i));
                    if ( action.Can(player, target, m_MainItem, action_condition_mask) )
                    {
                        m_SelectAction = action;
                        return;
                    }
                }
            }
        }
    }
    
    override ActionBase GetAction()
    {
        return m_SelectAction;
    }
};
 
class ContinuousWeaponManipulationActionInput : NoIndicationActionInputBase
{
    void ContinuousWeaponManipulationActionInput(PlayerBase player)
    {
        SetInput("UAReloadMagazine");
        m_InputType = ActionInputType.AIT_CONTINUOUS;
    }
};
 
class WeaponManipulationActionInput : NoIndicationActionInputBase
{   
    void WeaponManipulationActionInput(PlayerBase player)
    {
        SetInput("UAReloadMagazine");
        m_InputType = ActionInputType.AIT_SINGLE;
    }
};
 
class ExternalControlledActionInput : NoIndicationActionInputBase
{   
    void ExternalControlledActionInput(PlayerBase player)
    {
        //SetInput("UAReloadMagazine");
        m_InputType = ActionInputType.AIT_NOINPUTCONTROL;
    }
};
 
class InventoryOnlyActionInput : NoIndicationActionInputBase
{   
    void InventoryOnlyActionInput(PlayerBase player)
    {
        //SetInput("UAReloadMagazine");
        m_InputType = ActionInputType.AIT_INVENTORYINPUT;
    }
};
 
class QuickaBarActionInput : ExternalControlledActionInput
{   
};