Класс ActionManagerClient

Граф наследования:ActionManagerClient:

Защищенные члены
void	ActionManagerClient (PlayerBase player)
override void	Update (int pCurrentCommandID)
void	RegisterInputs (PlayerBase player)
void	SetActioninputOrder ()
void	SetDefaultInputsOrder ()
override void	RequestEndAction ()
override void	EndActionInput ()
void	InputsUpdate ()
void	ProcessActionRequestEnd ()
void	ProcessActionInputEnd ()
ActionBase	GetPossibleAction (typename inputType)
array< ActionBase >	GetPossibleActions (typename inputType)
int	GetPossibleActionIndex (typename inputType)
int	GetPossibleActionCount (typename inputType)
void	InjectAction (ActionBase action, ActionTarget target, ItemBase item)
void	InjectAction (typename actionType, ActionTarget target, ItemBase item)
void	EjectAction (ActionBase action)
void	EjectAction (typename actionType)
void	ForceTarget (Object targetObject)
void	ClearForceTarget ()
override ActionTarget	FindActionTarget ()
ItemBase	FindActionItem ()
bool	HasHandInventoryReservation ()
void	FindContextualUserActions (int pCurrentCommandID)
bool	LockInventory (ActionData action_data)
void	UnlockInventory (ActionData action_data)
void	ActionStart (ActionBase action, ActionTarget target, ItemBase item, Param extra_data=NULL)
void	HandleInputsOnActionStart (ActionBase action)
void	HandleInputsOnActionEnd ()
void	ResetInputsState ()
void	ResetInputsActions ()
override void	OnJumpStart ()
override void	OnInstantAction (typename user_action_type, Param data=NULL)
void	PerformActionStart (ActionBase action, ActionTarget target, ItemBase item, Param extra_data=NULL)
override void	OnActionEnd ()
void	SetInventoryAction (ActionBase action_name, ItemBase target_item, ItemBase main_item)
void	SetInventoryAction (ActionBase action_name, ActionTarget target, ItemBase main_item)
void	UnsetInventoryAction ()
override	GetSelectedActionCategory ()
void	UpdateActionCategoryPriority ()
override void	SelectFirstActionCategory ()
override void	SelectNextActionCategory ()
override void	SelectPrevActionCategory ()
override void	SelectNextAction ()
override void	SelectPrevAction ()
bool	CanPerformActionFromQuickbar (ItemBase mainItem, ItemBase targetItem)
void	PerformActionFromQuickbar (ItemBase mainItem, ItemBase targetItem)
bool	CanPerformActionFromInventory (ItemBase mainItem, ItemBase targetItem)
void	PerformActionFromInventory (ItemBase mainItem, ItemBase targetItem)
bool	CanSetActionFromInventory (ItemBase mainItem, ItemBase targetItem)
void	SetActionFromInventory (ItemBase mainItem, ItemBase targetItem)
override void	Interrupt ()
void	RequestInterruptAction ()
	client requests action interrupt

Защищенные статические члены
static ActionVariantManager	GetVariantManager (typename actionName)

Защищенные данные
int	m_LastAcknowledgmentID
bool	m_ActionPossible
ref array< ref InventoryLocation >	m_ReservedInventoryLocations
ref InventoryActionHandler	m_InventoryActionHandler
ref InventoryLocation	m_HandInventoryLocationTest
ref TTypeNameActionInputMap	m_RegistredInputsMap
ref array< ActionInput >	m_OrederedAllActionInput
ref array< ActionInput >	m_OrderedStandartActionInputs
ref array< ActionInput >	m_DefaultOrderOfActionInputs
int	m_SelectedActionInputToSrollIndex
ref ActionData	m_PendingActionData
bool	m_ActionWantEndRequest_Send
bool	m_ActionInputWantEnd_Send

Закрытые данные
ref ActionTarget	m_ForceTarget
ref ActionTargets	m_Targets

Подробное описание

Конструктор(ы)

ActionManagerClient()

void ActionManagerClient ( PlayerBase player )

inlineprotected

    {
        m_HandInventoryLocationTest = new InventoryLocation;
        m_HandInventoryLocationTest.SetHands(player,null);
        m_LastAcknowledgmentID = 1;
        m_Targets   = new ActionTargets(player);
        m_ReservedInventoryLocations = new array<ref InventoryLocation>;
        m_InventoryActionHandler = new InventoryActionHandler(player);
 
        m_ActionWantEndRequest_Send = false;
        m_ActionInputWantEnd_Send = false;
        RegisterInputs(player);
        m_SelectedActionInputToSrollIndex = 0;
    }

Перекрестные ссылки m_ActionInputWantEnd_Send, m_ActionWantEndRequest_Send, m_HandInventoryLocationTest, m_InventoryActionHandler, m_LastAcknowledgmentID, m_ReservedInventoryLocations, m_SelectedActionInputToSrollIndex, m_Targets и RegisterInputs().

Методы

ActionStart()

void ActionStart ( ActionBase action, ActionTarget target, ItemBase item, Param extra_data = NULL )

inlineprotected

    {
        if (!m_CurrentActionData && action && ActionPossibilityCheck(m_Player.GetCurrentCommandID())) 
        {
            m_ActionWantEndRequest_Send = false;
            m_ActionInputWantEnd_Send = false;
            m_ActionWantEndRequest = false;
            m_ActionInputWantEnd = false;
            
            if (action.CanBePerformedFromQuickbar())
                m_Player.SetActionEndInput(action);
            
            HandleInputsOnActionStart(action);
 
            if (LogManager.IsActionLogEnable())
            {
                if ( target )
                {
                    Debug.ActionLog("Item = " + item + ", " + target.DumpToString(), action.ToString() , "n/a", "ActionStart", m_Player.ToString());
                }
                else
                {
                    Debug.ActionLog("Item = " + item + ", no target", action.ToString() , "n/a", "ActionStart", m_Player.ToString());
                }
            }
            m_Interrupted = false;
            if (GetGame().IsMultiplayer() && !action.IsLocal())
            {
                if (!ScriptInputUserData.CanStoreInputUserData())
                {
                    DPrint("ScriptInputUserData already posted - ActionManagerClient");
                    
                    if (LogManager.IsActionLogEnable())
                    {
                        Debug.ActionLog("Cannot start because ScriptInputUserData is already used", action.ToString() , "n/a", "ActionStart", m_Player.ToString());
                    }
                    return;
                }
            }
            
            if (!action.SetupAction(m_Player, target, item, m_CurrentActionData, extra_data))
            {
                DPrint("Can not inicialize action" + action + " - ActionManagerClient");
                m_CurrentActionData = NULL;
                return;
            }
            
            if (LogManager.IsActionLogEnable())
            {
                Debug.ActionLog("Action data created wait to start", action.ToString() , "n/a", "ActionStart", m_Player.ToString());
            }
 
            if (GetGame().IsMultiplayer() && !action.IsLocal())
            {
                ScriptInputUserData ctx = new ScriptInputUserData;
                ctx.Write(INPUT_UDT_STANDARD_ACTION_START);
                ctx.Write(action.GetID());
 
                action.WriteToContext(ctx, m_CurrentActionData);
                    
                if (action.UseAcknowledgment())
                {
                    m_CurrentActionData.m_State = UA_AM_PENDING;
                    m_PendingActionAcknowledgmentID = ++m_LastAcknowledgmentID;
                        
                    ctx.Write(m_PendingActionAcknowledgmentID);
                }
                    
                ctx.Send();
                    
                if (!action.UseAcknowledgment())
                {
                    action.Start(m_CurrentActionData);
                    if (action.IsInstant())
                        OnActionEnd();
                }
            }
            else
            {
                action.Start(m_CurrentActionData);
                if (action.IsInstant())
                    OnActionEnd();
            }
        }
    }

Перекрестные ссылки Debug::ActionLog(), ActionPossibilityCheck(), ScriptInputUserData::CanStoreInputUserData(), DPrint(), GetGame(), HandleInputsOnActionStart(), INPUT_UDT_STANDARD_ACTION_START, LogManager::IsActionLogEnable(), m_ActionInputWantEnd, m_ActionInputWantEnd_Send, m_ActionWantEndRequest, m_ActionWantEndRequest_Send, m_CurrentActionData, m_Interrupted, m_LastAcknowledgmentID, m_PendingActionAcknowledgmentID, m_Player, OnActionEnd() и UA_AM_PENDING.

Используется в InputsUpdate(), OnInstantAction(), PerformActionFromInventory(), PerformActionFromQuickbar() и PerformActionStart().

CanPerformActionFromInventory()

bool CanPerformActionFromInventory ( ItemBase mainItem, ItemBase targetItem )

inlineprotected

    {   
        ItemBase itemInHand = m_Player.GetItemInHands();
        ActionTarget target;
        target = new ActionTarget(targetItem, null, -1, vector.Zero, -1);
        bool hasTarget = targetItem != NULL;
        
        if (mainItem)
        {
            array<ActionBase_Basic> actions;
            ActionBase picked_action;
            int i;
            
            //First check single use actions
            mainItem.GetActions(DefaultActionInput, actions);
            if (actions)
            {
                for (i = 0; i < actions.Count(); i++)
                {           
                    picked_action = ActionBase.Cast(actions[i]);
                    if (picked_action && picked_action.Can(m_Player,target, itemInHand) && picked_action.CanBePerformedFromInventory())
                    {
                        if (hasTarget == picked_action.HasTarget())
                            return true;
                    }
                }
            }
            
            //Inventory specific actions
            mainItem.GetActions(InventoryOnlyActionInput, actions);
            if (actions)
            {
                for (i = 0; i < actions.Count(); i++)
                {           
                    picked_action = ActionBase.Cast(actions[i]);
                    if (picked_action && picked_action.Can(m_Player,target, itemInHand))
                    {
                        if (hasTarget == picked_action.HasTarget())
                            return true;
                    }
                }
            }
        }
        return false;
    }

Перекрестные ссылки ActionTarget, m_Player и vector::Zero.

CanPerformActionFromQuickbar()

bool CanPerformActionFromQuickbar ( ItemBase mainItem, ItemBase targetItem )

inlineprotected

    {   
        ItemBase itemInHand = m_Player.GetItemInHands();
        ActionTarget target;
        target = new ActionTarget(targetItem, null, -1, vector.Zero, -1);
        bool hasTarget = targetItem != NULL;
        
        if (mainItem)
        {
            array<ActionBase_Basic> actions;
            ActionBase picked_action;
            int i;
            
            mainItem.GetActions(QuickaBarActionInput, actions);
            if (actions)
            {
                for (i = 0; i < actions.Count(); i++)
                {           
                    picked_action = ActionBase.Cast(actions[i]);
                    if (picked_action && picked_action.Can(m_Player,target, itemInHand))
                    {
                        if (hasTarget == picked_action.HasTarget())
                            return true;
                    }
                }
            }           
            //First check continuous actions
            mainItem.GetActions(ContinuousDefaultActionInput, actions);
            if (actions)
            {
                for (i = 0; i < actions.Count(); i++)
                {           
                    picked_action = ActionBase.Cast(actions[i]);
                    if (picked_action && picked_action.Can(m_Player,target, itemInHand) && picked_action.CanBePerformedFromQuickbar())
                    {
                        if (hasTarget == picked_action.HasTarget())
                            return true;
                    }
                }
            }
            //second single use actions
            mainItem.GetActions(DefaultActionInput, actions);
            if (actions)
            {
                for (i = 0; i < actions.Count(); i++)
                {
                    picked_action = ActionBase.Cast(actions[i]);
                    if (picked_action && picked_action.HasTarget() && picked_action.Can(m_Player,target, itemInHand) && picked_action.CanBePerformedFromQuickbar())
                    {
                        if (hasTarget == picked_action.HasTarget())
                            return true;
                    }
                }
            }
        }
        return false;
    }

Перекрестные ссылки ActionTarget, m_Player и vector::Zero.

CanSetActionFromInventory()

bool CanSetActionFromInventory ( ItemBase mainItem, ItemBase targetItem )

inlineprotected

    {
        ItemBase itemInHand = m_Player.GetItemInHands();
        ActionTarget target;
        EntityAI parent = null;
        if (targetItem)
        {
            parent = targetItem.GetHierarchyParent();
        }
        target = new ActionTarget(targetItem, parent, -1, vector.Zero, -1);
        bool hasTarget = targetItem != NULL;
        
        if (mainItem)
        {
            array<ActionBase_Basic> actions;
            array<ref ActionBase> variant_actions;
            ActionBase picked_action;
            int variants_count,v;
            
            //First check single use actions
            mainItem.GetActions(DefaultActionInput, actions);
            if (actions)
            {
                for (int i = 0; i < actions.Count(); i++)
                {           
                    picked_action = ActionBase.Cast(actions[i]);
                    if (picked_action.HasVariants())
                    {
                        picked_action.UpdateVariants(itemInHand, targetItem, -1);
                        picked_action.GetVariants(variant_actions);
                        for (v = 0; v < variant_actions.Count(); v ++)
                        {
                            picked_action = variant_actions[v];
                            if (picked_action && picked_action.CanBeSetFromInventory() && picked_action.Can(m_Player,target, itemInHand))
                            {
                                if (hasTarget == picked_action.HasTarget())
                                    return true;
                            }
                        }
                    }
                    else
                    {
                        if (picked_action && picked_action.CanBeSetFromInventory() && picked_action.Can(m_Player,target, itemInHand))
                        {
                            if (hasTarget == picked_action.HasTarget())
                                return true;
                        }
                    }
                }
            }
            //second continuous actions
            mainItem.GetActions(ContinuousDefaultActionInput, actions);
            if (actions)
            {
                for (int j = 0; j < actions.Count(); j++)
                {
                    picked_action = ActionBase.Cast(actions[j]);
                    if (picked_action.HasVariants())
                    {
                        picked_action.UpdateVariants(itemInHand, targetItem, -1);
                        picked_action.GetVariants(variant_actions);
                        for (v = 0; v < variant_actions.Count(); v ++)
                        {
                            picked_action = variant_actions[v];
                            if (picked_action && picked_action.HasTarget() && picked_action.CanBeSetFromInventory() && picked_action.Can(m_Player,target, itemInHand))
                            {
                                if (hasTarget == picked_action.HasTarget())
                                    return true;
                            }
                        }
                    }
                    else
                    {
                        if (picked_action && picked_action.HasTarget() && picked_action.CanBeSetFromInventory() && picked_action.Can(m_Player,target, itemInHand))
                        {
                            if (hasTarget == picked_action.HasTarget())
                                return true;
                        }
                    }
                }
            }
        }
        return false;
    }

Перекрестные ссылки ActionTarget, m_Player и vector::Zero.

ClearForceTarget()

void ClearForceTarget ( )

inlineprotected

    {
        m_ForceTarget = NULL;
    }

Перекрестные ссылки m_ForceTarget.

EjectAction() [1/2]

void EjectAction ( ActionBase action )

inlineprotected

    {
        ActionInput ai = action.GetInput();
        ai.ClearForcedAction();
    }

Используется в EjectAction().

EjectAction() [2/2]

void EjectAction ( typename actionType )

inlineprotected

    {
        ActionBase action = GetAction(actionType);
        EjectAction(action);
    }

Перекрестные ссылки EjectAction() и GetAction().

EndActionInput()

override void EndActionInput ( )

inlineprotected

    {
        if (!m_ActionInputWantEnd_Send)
        {
            m_ActionInputWantEnd = true;
        }
    }

Перекрестные ссылки m_ActionInputWantEnd и m_ActionInputWantEnd_Send.

Используется в InputsUpdate().

FindActionItem()

ItemBase FindActionItem ( )

inlineprotected

    {
        ItemBase item;
        if (m_Player && m_Player.GetItemInHands() && m_Player.GetItemInHands().IsItemBase()) 
        {
            item = m_Player.GetItemInHands();
        }
        return item;
    }

Перекрестные ссылки m_Player.

Используется в FindContextualUserActions().

FindActionTarget()

override ActionTarget FindActionTarget ( )

inlineprotected

    {
        if (m_ForceTarget)
            return m_ForceTarget;
        
        ActionTarget action_target;
        action_target = NULL;
        int targetsCount = m_Targets.GetTargetsCount();
        if (targetsCount)
        {
            for (int i = 0; i < targetsCount; ++i)
            {
                action_target = m_Targets.GetTarget(i);
                Object targetObject = action_target.GetObject();
                Object targetParent = action_target.GetParent();
                
                if (targetParent)
                {
                    break;
                }
                
                if (targetObject)
                {
                    break;
                }
            }
        }
        else
        {
            action_target = new ActionTarget(null, null, -1, vector.Zero, -1);
        }
        return action_target;
    }

Перекрестные ссылки ActionTarget, m_ForceTarget, m_Targets и vector::Zero.

Используется в FindContextualUserActions() и ActionTargetsCursor::GetTarget().

FindContextualUserActions()

void FindContextualUserActions ( int pCurrentCommandID )

inlineprotected

    {
        // TODO: NEEDS OPTIMIZATION (focus on UpdatePossibleActions > CraftingManager::OnUpdate)
        
        m_ActionsAvaibale = false;
        if (!m_ActionPossible || HasHandInventoryReservation() || GetGame().IsInventoryOpen())
        {
            ResetInputsActions();
            return;
        }
        
        if (!GetRunningAction())
        {   
            ActionBase action;
            ActionTarget    target;
            ItemBase        item;
 
            // Gathering current inputs
            m_ActionsAvaibale = true;
            
            item = FindActionItem();
            target = FindActionTarget();
            
            int actionConditionMask = ActionBase.ComputeConditionMask(m_Player,target,item);
            for (int i = 0; i < m_OrederedAllActionInput.Count();i++)
            {
                ActionInput ain = m_OrederedAllActionInput[i];
                ain.UpdatePossibleActions(m_Player,target,item, actionConditionMask);
            }
            SetActionContext(target,item);
        }
    }

Перекрестные ссылки FindActionItem(), FindActionTarget(), GetGame(), GetRunningAction(), HasHandInventoryReservation(), m_ActionPossible, m_ActionsAvaibale, m_OrederedAllActionInput, m_Player, ResetInputsActions() и SetActionContext().

Используется в Update().

ForceTarget()

void ForceTarget ( Object targetObject )

inlineprotected

    {
        Object parent = null;
        EntityAI targetEntity = EntityAI.Cast(targetObject);
        if (targetEntity)
            parent = targetEntity.GetHierarchyParent();
        m_ForceTarget = new ActionTarget(targetObject, parent, -1, vector.Zero, -1);
    }

Перекрестные ссылки ActionTarget, m_ForceTarget и vector::Zero.

GetPossibleAction()

ActionBase GetPossibleAction ( typename inputType )

inlineprotected

    {
        ActionInput action_input = m_RegistredInputsMap.Get(inputType);
        if (action_input)
        {
            return action_input.GetAction();
        }
        return NULL;
    }

Перекрестные ссылки m_RegistredInputsMap.

GetPossibleActionCount()

int GetPossibleActionCount ( typename inputType )

inlineprotected

    {
        ActionInput action_input = m_RegistredInputsMap.Get(inputType);
        if (action_input)
        {
            return action_input.GetPossibleActionsCount();
        }
        return 0;
    }

Перекрестные ссылки m_RegistredInputsMap.

GetPossibleActionIndex()

int GetPossibleActionIndex ( typename inputType )

inlineprotected

    {
        ActionInput action_input = m_RegistredInputsMap.Get(inputType);
        if (action_input)
        {
            return action_input.GetPossibleActionIndex();
        }
        return -1;
    }

Перекрестные ссылки m_RegistredInputsMap.

GetPossibleActions()

array< ActionBase > GetPossibleActions ( typename inputType )

inlineprotected

    {
        ActionInput action_input = m_RegistredInputsMap.Get(inputType);
        if (action_input)
        {
            return action_input.GetPossibleActions();
        }
        return NULL;
    }

Перекрестные ссылки m_RegistredInputsMap.

GetSelectedActionCategory()

override GetSelectedActionCategory ( )

inlineprotected

    {
        return m_OrderedStandartActionInputs[m_SelectedActionInputToSrollIndex].Type();
    }

Перекрестные ссылки m_OrderedStandartActionInputs и m_SelectedActionInputToSrollIndex.

GetVariantManager()

static ActionVariantManager GetVariantManager ( typename actionName )

inlinestaticprotected

    {
        ActionBase action = GetAction(actionName);
        if (action)
        {
            return action.GetVariantManager();
        }
        //VME ACTION not exist typo most likely
        return null;
    }

Перекрестные ссылки GetAction().

Используется в ConstructionActionData::ConstructionActionData() и CraftingManager::CraftingManager().

HandleInputsOnActionEnd()

void HandleInputsOnActionEnd ( )

inlineprotected

    {
        ResetInputsState();
    }

Перекрестные ссылки ResetInputsState().

Используется в OnActionEnd().

HandleInputsOnActionStart()

void HandleInputsOnActionStart ( ActionBase action )

inlineprotected

    {
        for (int i = 0; i < m_OrederedAllActionInput.Count();i++)
        {
            ActionInput ain = m_OrederedAllActionInput[i];
            if (action.GetInput() == ain)
            {
                ain.OnActionStart();
            }
            else
            {
                ain.Reset();
            }
        }
    }

Перекрестные ссылки m_OrederedAllActionInput.

Используется в ActionStart().

HasHandInventoryReservation()

bool HasHandInventoryReservation ( )

inlineprotected

    {
        m_HandInventoryLocationTest.SetHands(m_Player,m_Player.GetItemInHands());
        if (m_Player.GetHumanInventory().HasInventoryReservation(m_Player.GetItemInHands(),m_HandInventoryLocationTest))
            return true;
        return false;
    }

Перекрестные ссылки m_HandInventoryLocationTest и m_Player.

Используется в FindContextualUserActions().

InjectAction() [1/2]

void InjectAction ( ActionBase action, ActionTarget target, ItemBase item )

inlineprotected

    {
        ActionInput ai = action.GetInput();
        ai.ForceAction(action, target, item);
    }

Используется в InjectAction().

InjectAction() [2/2]

void InjectAction ( typename actionType , ActionTarget target, ItemBase item )

inlineprotected

    {
        ActionBase action = GetAction(actionType);
        InjectAction(action, target, item);
    }

Перекрестные ссылки GetAction() и InjectAction().

InputsUpdate()

void InputsUpdate ( )

inlineprotected

    {
        ActionInput ain;
        if (m_CurrentActionData)
        {
            if (!m_ActionInputWantEnd)
            {
                ActionInput ai = m_CurrentActionData.m_Action.GetInput();
                ai.Update();
                if (m_Player.IsQBControl())
                {
                    if (ai.JustActivate())
                        m_Player.SetActionEndInput(m_CurrentActionData.m_Action);
                }
                else
                {
                    if (ai.WasEnded() && (ai.GetInputType() == ActionInputType.AIT_CONTINUOUS || ai.GetInputType() == ActionInputType.AIT_CLICKCONTINUOUS))
                    {
                        EndActionInput();
                    }
                }
            }
        }
        else
        {
            if (m_ActionsAvaibale)
            {
                for (int i = 0; i < m_OrederedAllActionInput.Count();i++)
                {
                    
                    ain = m_OrederedAllActionInput[i];
                    ain.Update();
                
                    if (ain.JustActivate())
                    {
                        ActionBase action = ain.GetAction();
                        if (action)
                        {
                            ActionStart(action, ain.GetUsedActionTarget(), ain.GetUsedMainItem());
                            break;
                        }
                    }
                }
            }
        }
    }

Перекрестные ссылки ActionStart(), EndActionInput(), m_ActionInputWantEnd, m_ActionsAvaibale, m_CurrentActionData, m_OrederedAllActionInput и m_Player.

Используется в Update().

Interrupt()

override void Interrupt ( )

inlineprotected

    {
        super.Interrupt();
        
        if (m_CurrentActionData)
            m_Interrupted = true;
    }

Перекрестные ссылки m_CurrentActionData и m_Interrupted.

LockInventory()

bool LockInventory ( ActionData action_data )

inlineprotected

    {
        bool success = false;
        if (action_data.m_Action.IsInstant())
        {
            if (LogManager.IsActionLogEnable())
            {
                Debug.ActionLog("(-) Inventory lock - Not Used", action_data.m_Action.ToString() , "n/a", "LockInventory", action_data.m_Player.ToString());
            }
            success = true;
        }
        else
        {
            if (LogManager.IsActionLogEnable())
            {
                Debug.ActionLog("(X) Inventory lock", action_data.m_Action.ToString() , "n/a", "LockInventory", action_data.m_Player.ToString());
            }
            if (action_data.m_Action)
            {
                success = action_data.m_Action.InventoryReservation(action_data);
            }
        }
        return success;
    }

Перекрестные ссылки Debug::ActionLog() и LogManager::IsActionLogEnable().

OnActionEnd()

override void OnActionEnd ( )

inlineprotected

    {
        if (m_CurrentActionData)
        {
            UnlockInventory(m_CurrentActionData);
            if (m_CurrentActionData.m_Action.RemoveForceTargetAfterUse())
                m_InventoryActionHandler.DeactiveAction();
            
            super.OnActionEnd();
            HandleInputsOnActionEnd();
        }
    }

Перекрестные ссылки HandleInputsOnActionEnd(), m_CurrentActionData, m_InventoryActionHandler и UnlockInventory().

Используется в ActionStart(), OnJumpStart() и Update().

OnInstantAction()

override void OnInstantAction ( typename user_action_type , Param data = NULL )

inlineprotected

    {
        ActionBase action = GetAction(user_action_type);
        if (action)
        {
            ActionStart(action,NULL,NULL, data);
        }
    }

Перекрестные ссылки ActionStart() и GetAction().

OnJumpStart()

override void OnJumpStart ( )

inlineprotected

    {
        if (m_CurrentActionData)
        {
            if (m_CurrentActionData.m_State == UA_AM_PENDING || m_CurrentActionData.m_State == UA_AM_REJECTED || m_CurrentActionData.m_State == UA_AM_ACCEPTED)
            {
                OnActionEnd();
                m_PendingActionAcknowledgmentID = -1;
            }
            else
            {
                m_CurrentActionData.m_Action.Interrupt(m_CurrentActionData);
            }
        }
    }

Перекрестные ссылки m_CurrentActionData, m_PendingActionAcknowledgmentID, OnActionEnd(), UA_AM_ACCEPTED, UA_AM_PENDING и UA_AM_REJECTED.

PerformActionFromInventory()

void PerformActionFromInventory ( ItemBase mainItem, ItemBase targetItem )

inlineprotected

    {
        ItemBase itemInHand = m_Player.GetItemInHands();
        ActionTarget target;
        target = new ActionTarget(targetItem, null, -1, vector.Zero, -1);
        bool hasTarget = targetItem != NULL;
        
        if (mainItem)
        {
            ActionBase picked_action;
            array<ActionBase_Basic> actions;
            int i;
            
            //First check single use actions
            mainItem.GetActions(DefaultActionInput, actions);
            if (actions)
            {
                for (i = 0; i < actions.Count(); i++)
                {
                    picked_action = ActionBase.Cast(actions[i]);
                    if (picked_action && picked_action.Can(m_Player,target, itemInHand) && picked_action.CanBePerformedFromInventory())
                    {
                        if (hasTarget == picked_action.HasTarget())
                        {
                            ActionStart(picked_action, target, mainItem);
                            return;
                        }
                    }
                }
            }
            
            //Inventory specific actions
            mainItem.GetActions(InventoryOnlyActionInput, actions);
            if (actions)
            {
                for (i = 0; i < actions.Count(); i++)
                {
                    picked_action = ActionBase.Cast(actions[i]);
                    if (picked_action && picked_action.Can(m_Player,target, itemInHand))
                    {
                        if (hasTarget == picked_action.HasTarget())
                        {
                            ActionStart(picked_action, target, mainItem);
                            return;
                        }
                    }
                }
            }
        }
    }

Перекрестные ссылки ActionStart(), ActionTarget, m_Player и vector::Zero.

PerformActionFromQuickbar()

void PerformActionFromQuickbar ( ItemBase mainItem, ItemBase targetItem )

inlineprotected

    {
        ItemBase itemInHand = m_Player.GetItemInHands();
        ActionTarget target;
        ItemBase parent = null;
        if (targetItem)
            parent = ItemBase.Cast(targetItem.GetHierarchyParent());
        target = new ActionTarget(targetItem, parent, -1, vector.Zero, -1);
        bool hasTarget = targetItem != NULL;
        
        if (mainItem)
        {
            ActionBase picked_action;
            array<ActionBase_Basic> actions;
            int i;
                    
            mainItem.GetActions(QuickaBarActionInput, actions);
            if (actions)
            {
                for (i = 0; i < actions.Count(); i++)
                {
                    picked_action = ActionBase.Cast(actions[i]);
                    if (picked_action && picked_action.HasTarget() && picked_action.Can(m_Player,target, itemInHand))
                    {
                        if (hasTarget == picked_action.HasTarget())
                        {
                            ActionStart(picked_action, target, mainItem);
                            return;
                        }
                    }
                }
            }
            
            //First continuous actions
            mainItem.GetActions(ContinuousDefaultActionInput, actions);
            if (actions)
            {
                for (i = 0; i < actions.Count(); i++)
                {
                    picked_action = ActionBase.Cast(actions[i]);
                    if (picked_action && picked_action.HasTarget() && picked_action.Can(m_Player,target, itemInHand) && picked_action.CanBePerformedFromQuickbar())
                    {
                        if (hasTarget == picked_action.HasTarget())
                        {
                            ActionStart(picked_action, target, mainItem);
                            return;
                        }
                    }
                }
            }
            //Second check single use actions
            mainItem.GetActions(DefaultActionInput, actions);
            if (actions)
            {
                for (i = 0; i < actions.Count(); i++)
                {
                    picked_action = ActionBase.Cast(actions[i]);
                    if (picked_action && picked_action.Can(m_Player,target, itemInHand) && picked_action.CanBePerformedFromQuickbar())
                    {
                        if (hasTarget == picked_action.HasTarget())
                        {
                            ActionStart(picked_action, target, mainItem);
                            return;
                        }
                    }
                }
            }
 
        }
    }

Перекрестные ссылки ActionStart(), ActionTarget, m_Player и vector::Zero.

PerformActionStart()

void PerformActionStart ( ActionBase action, ActionTarget target, ItemBase item, Param extra_data = NULL )

inlineprotected

    {
        if (!GetGame().IsMultiplayer())
        {
            m_PendingActionData = new ActionData;
    
            if (!action.SetupAction(m_Player,target,item,m_PendingActionData,extra_data))
                m_PendingActionData = null;
        }
        else
            ActionStart(action, target, item, extra_data);
    }

Перекрестные ссылки ActionStart(), GetGame(), m_PendingActionData и m_Player.

ProcessActionInputEnd()

void ProcessActionInputEnd ( )

inlineprotected

    {
        if (m_ActionInputWantEnd)
        {
            if (GetGame().IsMultiplayer() && !m_CurrentActionData.m_Action.IsLocal())
            {
                if (!m_ActionInputWantEnd_Send && ScriptInputUserData.CanStoreInputUserData())
                {
                    if (LogManager.IsActionLogEnable())
                    {
                        Debug.ActionLog("Time stamp: " + m_Player.GetSimulationTimeStamp(), m_CurrentActionData.m_Action.ToString() , "n/a", "EndInput", m_CurrentActionData.m_Player.ToString());
                    }
                    ScriptInputUserData ctxi = new ScriptInputUserData;
                    ctxi.Write(INPUT_UDT_STANDARD_ACTION_INPUT_END);
                    ctxi.Send();
                    
                    m_ActionInputWantEnd_Send = true;
                        
                    m_ActionInputWantEnd = false;
                    m_CurrentActionData.m_Action.EndInput(m_CurrentActionData);
                }
            }
            else
            {
                if (!m_ActionInputWantEnd_Send)
                {
                    m_ActionInputWantEnd_Send = true;
                    m_ActionInputWantEnd = false;
                    m_CurrentActionData.m_Action.EndInput(m_CurrentActionData);
                }
            }
        }
    }

Перекрестные ссылки Debug::ActionLog(), ScriptInputUserData::CanStoreInputUserData(), GetGame(), INPUT_UDT_STANDARD_ACTION_INPUT_END, LogManager::IsActionLogEnable(), m_ActionInputWantEnd, m_ActionInputWantEnd_Send, m_CurrentActionData и m_Player.

Используется в Update().

ProcessActionRequestEnd()

void ProcessActionRequestEnd ( )

inlineprotected

    {
        if (m_ActionWantEndRequest)
        {
            if (GetGame().IsMultiplayer() && !m_CurrentActionData.m_Action.IsLocal())
            {
                if (!m_ActionWantEndRequest_Send && ScriptInputUserData.CanStoreInputUserData())
                {
                    if (LogManager.IsActionLogEnable())
                    {   
                        Debug.ActionLog("Time stamp: " + m_Player.GetSimulationTimeStamp(), m_CurrentActionData.m_Action.ToString() , "n/a", "EndRequest", m_CurrentActionData.m_Player.ToString());
                    }
                    ScriptInputUserData ctx = new ScriptInputUserData;
                    ctx.Write(INPUT_UDT_STANDARD_ACTION_END_REQUEST);
                    ctx.Send();
                    
                    m_ActionWantEndRequest_Send = true;
                        
                    m_ActionWantEndRequest = false;
                    m_CurrentActionData.m_Action.EndRequest(m_CurrentActionData);
                }
            }
            else
            {
                m_ActionWantEndRequest = false;
                m_CurrentActionData.m_Action.EndRequest(m_CurrentActionData);
            }
        }
    }

Перекрестные ссылки Debug::ActionLog(), ScriptInputUserData::CanStoreInputUserData(), GetGame(), INPUT_UDT_STANDARD_ACTION_END_REQUEST, LogManager::IsActionLogEnable(), m_ActionWantEndRequest, m_ActionWantEndRequest_Send, m_CurrentActionData и m_Player.

Используется в Update().

RegisterInputs()

void RegisterInputs ( PlayerBase player )

inlineprotected

    {
        if (!m_RegistredInputsMap)
        {
            m_RegistredInputsMap = new TTypeNameActionInputMap;
 
            for (int i = 0; i < m_ActionsArray.Count(); i++)
            {   
                ActionBase action = m_ActionsArray.Get(i);
                typename input_type_name = action.GetInputType();
                ref ActionInput ai;
            
                ai = ActionInput.Cast(m_RegistredInputsMap.Get(input_type_name));
                if (!ai)
                {
                    ai = ActionInput.Cast(input_type_name.Spawn());
                    m_RegistredInputsMap.Insert(input_type_name, ai);
                }
                action.SetInput(ai);
            }
        
            for (int j = 0; j < m_RegistredInputsMap.Count(); j++)
            {
                m_RegistredInputsMap.GetElement(j).Init(player, this);
            }
            SetActioninputOrder();
        }
        
    }

Перекрестные ссылки m_ActionsArray, m_RegistredInputsMap и SetActioninputOrder().

Используется в ActionManagerClient().

RequestEndAction()

override void RequestEndAction ( )

inlineprotected

    {
        if (!m_ActionWantEndRequest_Send)
        {
            m_ActionWantEndRequest = true;
        }
    }

Перекрестные ссылки m_ActionWantEndRequest и m_ActionWantEndRequest_Send.

Используется в ActionReadPaper::OnUpdate() и ActionWritePaper::OnUpdate().

RequestInterruptAction()

void RequestInterruptAction ( )

inlineprotected

client requests action interrupt

    {
        if (ScriptInputUserData.CanStoreInputUserData())
        {
            ScriptInputUserData ctx = new ScriptInputUserData;
            ctx.Write(INPUT_UDT_STANDARD_ACTION_END_REQUEST);
            ctx.Write(DayZPlayerConstants.CMD_ACTIONINT_INTERRUPT);
            ctx.Send();
        }
    }

Перекрестные ссылки ScriptInputUserData::CanStoreInputUserData() и INPUT_UDT_STANDARD_ACTION_END_REQUEST.

ResetInputsActions()

void ResetInputsActions ( )

inlineprotected

    {
        for (int i = 0; i < m_OrederedAllActionInput.Count();i++)
        {
            ActionInput ain = m_OrederedAllActionInput[i];
            ain.ActionsSelectReset();
        }
    }

Перекрестные ссылки m_OrederedAllActionInput.

Используется в FindContextualUserActions() и Update().

ResetInputsState()

void ResetInputsState ( )

inlineprotected

    {
        for (int i = 0; i < m_OrederedAllActionInput.Count();i++)
        {
            ActionInput ain = m_OrederedAllActionInput[i];
            ain.Reset();
        }
    }

Перекрестные ссылки m_OrederedAllActionInput.

Используется в HandleInputsOnActionEnd().

SelectFirstActionCategory()

override void SelectFirstActionCategory ( )

inlineprotected

    {
        UpdateActionCategoryPriority();
        m_SelectedActionInputToSrollIndex = 0;
        
        for (int index = 0; index < m_OrderedStandartActionInputs.Count(); index++)
        {
            if (m_OrderedStandartActionInputs[index].GetPossibleActionsCount() > 1)
            {
                m_SelectedActionInputToSrollIndex = index;
                break;
            }
        }
    }

Перекрестные ссылки GetPossibleActionsCount(), m_OrderedStandartActionInputs, m_SelectedActionInputToSrollIndex и UpdateActionCategoryPriority().

SelectNextAction()

override void SelectNextAction ( )

inlineprotected

    {
        ActionInput ai;
        if (m_SelectedActionInputToSrollIndex < m_OrderedStandartActionInputs.Count())
        {
            ai = m_OrderedStandartActionInputs[m_SelectedActionInputToSrollIndex];
            if (ai && ai.GetPossibleActionsCount() > 1)
            {
                ai.SelectNextAction();
            }
        }   
    }

Перекрестные ссылки m_OrderedStandartActionInputs и m_SelectedActionInputToSrollIndex.

SelectNextActionCategory()

override void SelectNextActionCategory ( )

inlineprotected

    {
        int index;
        
        for (index = m_SelectedActionInputToSrollIndex + 1; index != m_SelectedActionInputToSrollIndex;;)
        {
            if (++index >= m_OrderedStandartActionInputs.Count())
            {
                index = 0;
            }
            if (m_OrderedStandartActionInputs[index].GetPossibleActionsCount() > 1)
            {
                m_SelectedActionInputToSrollIndex = index;
                break;
            }
        }       
    }

Перекрестные ссылки GetPossibleActionsCount(), m_OrderedStandartActionInputs и m_SelectedActionInputToSrollIndex.

SelectPrevAction()

override void SelectPrevAction ( )

inlineprotected

    {
        ActionInput ai;
        if (m_SelectedActionInputToSrollIndex < m_OrderedStandartActionInputs.Count())
        {
            ai = m_OrderedStandartActionInputs[m_SelectedActionInputToSrollIndex];
            if (ai && ai.GetPossibleActionsCount() > 1)
            {
                ai.SelectPrevAction();
            }
        }
    }

Перекрестные ссылки m_OrderedStandartActionInputs и m_SelectedActionInputToSrollIndex.

SelectPrevActionCategory()

override void SelectPrevActionCategory ( )

inlineprotected

    {
        int index;
        
        for (index = m_SelectedActionInputToSrollIndex; index != m_SelectedActionInputToSrollIndex;;)
        {
            if (--index < 0)
            {
                index = m_OrderedStandartActionInputs.Count() - 1;
            }
            
            if (m_OrderedStandartActionInputs[index].GetPossibleActionsCount() > 1)
            {
                m_SelectedActionInputToSrollIndex = index;
                break;
            }
        }
    }

Перекрестные ссылки GetPossibleActionsCount(), m_OrderedStandartActionInputs и m_SelectedActionInputToSrollIndex.

SetActionFromInventory()

void SetActionFromInventory ( ItemBase mainItem, ItemBase targetItem )

inlineprotected

    {
        ItemBase itemInHand = m_Player.GetItemInHands();
        ActionTarget target;
        target = new ActionTarget(targetItem, null, -1, vector.Zero, -1);
        bool hasTarget = targetItem != NULL;
        
        if (mainItem)
        {
            array<ActionBase_Basic> actions;
            ActionBase picked_action;
            
            //First check single use actions
            mainItem.GetActions(DefaultActionInput, actions);
            if (actions)
            {
                for (int i = 0; i < actions.Count(); i++)
                {           
                    picked_action = ActionBase.Cast(actions[i]);
                    if (picked_action && picked_action.Can(m_Player,target, itemInHand) && picked_action.CanBeSetFromInventory())
                    {
                        if (hasTarget == picked_action.HasTarget())
                        {
                            SetInventoryAction(picked_action, target, itemInHand);
                            return;
                        }
                    }
                }
            }
            //second continuous actions
            mainItem.GetActions(ContinuousDefaultActionInput, actions);
            if (actions)
            {
                for (int j = 0; j < actions.Count(); j++)
                {
                    picked_action = ActionBase.Cast(actions[j]);
                    if (picked_action && picked_action.HasTarget() && picked_action.Can(m_Player,target, itemInHand) && picked_action.CanBeSetFromInventory())
                    {
                        if (hasTarget == picked_action.HasTarget())
                        {
                            SetInventoryAction(picked_action, target, itemInHand);
                            return;
                        }
                    }
                }
            }
        }   
    }

Перекрестные ссылки ActionTarget, m_Player, SetInventoryAction() и vector::Zero.

SetActioninputOrder()

void SetActioninputOrder ( )

inlineprotected

    {
        int i, j;
        int priority;
        ActionInput input;
        m_OrederedAllActionInput = new array<ActionInput>;
        
        map<int, ref array<ActionInput>> temp_map_for_sort = new map<int, ref array<ActionInput>>;
        array<int> array_of_priorities_to_sort = new array<int>;
        ref array<ActionInput> same_priority_input_array;
        
        for (i = 0; i < m_RegistredInputsMap.Count(); i++)
        {
            input = m_RegistredInputsMap.GetElement(i);
            priority = input.GetPriority();
            same_priority_input_array = temp_map_for_sort.Get(priority);
            if (same_priority_input_array)
            {
                same_priority_input_array.Insert(input);
                continue;
            }
            
            same_priority_input_array = new array<ActionInput>;
            same_priority_input_array.Insert(input);
            temp_map_for_sort.Insert(priority,same_priority_input_array);
            array_of_priorities_to_sort.Insert(priority);
        }
        array_of_priorities_to_sort.Sort();
        
        for (i = 0; i < array_of_priorities_to_sort.Count(); i++)
        {
            priority = array_of_priorities_to_sort[i];
            same_priority_input_array = temp_map_for_sort.Get(priority);
            for (j = 0; j < same_priority_input_array.Count(); j++)
            {
                input = same_priority_input_array.Get(j);
                m_OrederedAllActionInput.Insert(input);
            }
        }
    
        SetDefaultInputsOrder();
    }

Перекрестные ссылки m_OrederedAllActionInput, m_RegistredInputsMap и SetDefaultInputsOrder().

Используется в RegisterInputs().

SetDefaultInputsOrder()

void SetDefaultInputsOrder ( )

inlineprotected

    {
        int i, j;
        m_DefaultOrderOfActionInputs = new array<ActionInput>;
        m_OrderedStandartActionInputs = new array<ActionInput>;
        ActionInput input = m_RegistredInputsMap.Get(ContinuousDefaultActionInput);
        if (input)
        {
            m_OrderedStandartActionInputs.Insert(input);
        }
 
        input = m_RegistredInputsMap.Get(DefaultActionInput);
        if (input)
        {
            m_OrderedStandartActionInputs.Insert(input);
        }
        
        input = m_RegistredInputsMap.Get(ContinuousInteractActionInput);
        if (input)
        {
            m_OrderedStandartActionInputs.Insert(input);
        }
        
        input = m_RegistredInputsMap.Get(InteractActionInput);
        if (input)
        {
            m_OrderedStandartActionInputs.Insert(input);
        }
        
        for (i = 0; i < m_OrederedAllActionInput.Count(); i++)
        {
            for (j = 0; j < m_OrderedStandartActionInputs.Count(); j++)
            {
                if (m_OrederedAllActionInput[i] == m_OrderedStandartActionInputs[j])
                {
                    m_DefaultOrderOfActionInputs.Insert(m_OrederedAllActionInput[i]);
                    break;
                }
            }
        }
    }

Перекрестные ссылки m_DefaultOrderOfActionInputs, m_OrderedStandartActionInputs, m_OrederedAllActionInput и m_RegistredInputsMap.

Используется в SetActioninputOrder().

SetInventoryAction() [1/2]

void SetInventoryAction ( ActionBase action_name, ActionTarget target, ItemBase main_item )

inlineprotected

    {
        m_InventoryActionHandler.SetAction(action_name, target, main_item);
    }

Перекрестные ссылки m_InventoryActionHandler.

SetInventoryAction() [2/2]

void SetInventoryAction ( ActionBase action_name, ItemBase target_item, ItemBase main_item )

inlineprotected

    {
        m_InventoryActionHandler.SetAction(action_name, target_item, main_item);
    }

Перекрестные ссылки m_InventoryActionHandler.

Используется в SetActionFromInventory().

UnlockInventory()

void UnlockInventory ( ActionData action_data )

inlineprotected

    {
        if (LogManager.IsActionLogEnable())
        {
            Debug.ActionLog("(O) Inventory unlock", action_data.m_Action.ToString() , "n/a", "UnlockInventory", action_data.m_Player.ToString());
        }
        if (action_data.m_Action)
            action_data.m_Action.ClearInventoryReservationEx(action_data);
    }

Перекрестные ссылки Debug::ActionLog() и LogManager::IsActionLogEnable().

Используется в OnActionEnd().

UnsetInventoryAction()

void UnsetInventoryAction ( )

inlineprotected

    {
        m_InventoryActionHandler.DeactiveAction();
    }

Перекрестные ссылки m_InventoryActionHandler.

Update()

override void Update ( int pCurrentCommandID )

inlineprotected

    {
        m_InventoryActionHandler.OnUpdate();
        super.Update(pCurrentCommandID);
        int currentCommandID = m_Player.GetCurrentCommandID();
        m_ActionPossible = ActionPossibilityCheck(currentCommandID);
        
        if (m_PendingActionData) //SP only
        {
            m_CurrentActionData = m_PendingActionData;
            
            m_CurrentActionData.m_Action.Start(m_CurrentActionData);
            
            if (m_CurrentActionData.m_Action.IsInstant())
                OnActionEnd();
            
            m_PendingActionData = null;
        }
        
        if (m_CurrentActionData)
        {
            if (m_CurrentActionData.m_State != UA_AM_PENDING && m_CurrentActionData.m_State != UA_AM_REJECTED && m_CurrentActionData.m_State != UA_AM_ACCEPTED)
                m_CurrentActionData.m_Action.OnUpdateClient(m_CurrentActionData);
            
            switch (m_CurrentActionData.m_State)
            {
                case UA_AM_PENDING:
                    break;
            
                case UA_AM_ACCEPTED:
                    int condition_mask = ActionBase.ComputeConditionMask(m_Player, m_CurrentActionData.m_Target, m_CurrentActionData.m_MainItem);
                    
                    m_CurrentActionData.m_Action.ClearInventoryReservationEx(m_CurrentActionData);
                    bool can_be_action_done = ((condition_mask & m_CurrentActionData.m_Action.m_ConditionMask) == condition_mask);
                    // check currentCommandID before start or reject 
                    if (m_ActionPossible && can_be_action_done && currentCommandID != DayZPlayerConstants.COMMANDID_SWIM)
                    {
                        m_CurrentActionData.m_Action.InventoryReservation(m_CurrentActionData);
                        m_CurrentActionData.m_State = UA_START;
                        m_CurrentActionData.m_Action.Start(m_CurrentActionData);
                        
                        if (m_CurrentActionData.m_Action.IsInstant())
                            OnActionEnd();
                    }
                    else
                    {
                        OnActionEnd();
                    }
                    m_PendingActionAcknowledgmentID = -1;
                    break;
                
                case UA_AM_REJECTED:
                    OnActionEnd();
                    m_PendingActionAcknowledgmentID = -1;
                    break;
            
                default:
                    ProcessActionRequestEnd();
                    ProcessActionInputEnd();
                break;
            }
        }
        
#ifdef DEVELOPER
        if (DeveloperFreeCamera.IsFreeCameraEnabled())
        {
            m_ActionPossible = false;
            ResetInputsActions();
        }
        else
        {
#endif
            if (!m_CurrentActionData)
            {
                bool isMenuOpen = false;    
#ifndef NO_GUI
                isMenuOpen = GetGame().GetUIManager().IsMenuOpen(MENU_INVENTORY);
#endif
                if (m_Player.IsRaised() || isMenuOpen)
                {
                    m_Targets.Clear();
                }
                else
                {
                    m_Targets.Update();
                }
                FindContextualUserActions(currentCommandID);    
            }
        
            InputsUpdate();
#ifdef DEVELOPER
        }
#endif      
 
    }

Перекрестные ссылки ActionPossibilityCheck(), FindContextualUserActions(), GetGame(), InputsUpdate(), DeveloperFreeCamera::IsFreeCameraEnabled(), DayZPlayer::IsRaised(), m_ActionPossible, m_CurrentActionData, m_InventoryActionHandler, m_PendingActionAcknowledgmentID, m_PendingActionData, m_Player, m_Targets, MENU_INVENTORY, OnActionEnd(), ProcessActionInputEnd(), ProcessActionRequestEnd(), ResetInputsActions(), UA_AM_ACCEPTED, UA_AM_PENDING, UA_AM_REJECTED и UA_START.

UpdateActionCategoryPriority()

void UpdateActionCategoryPriority ( )

inlineprotected

    {
        int i;
        int last_target_index = 0;
        for (i = 0; i < m_DefaultOrderOfActionInputs.Count(); i++)
        {
            if (m_DefaultOrderOfActionInputs[i].HasTarget())
            {
                m_OrderedStandartActionInputs[last_target_index] = m_DefaultOrderOfActionInputs[i];
                last_target_index++;
            }
        }
        
        for (i = 0; i < m_DefaultOrderOfActionInputs.Count(); i++)
        {
            if (!m_DefaultOrderOfActionInputs[i].HasTarget())
            {
                m_OrderedStandartActionInputs[last_target_index] = m_DefaultOrderOfActionInputs[i];
                last_target_index++;
            }
        }
    }

Перекрестные ссылки HasTarget(), m_DefaultOrderOfActionInputs и m_OrderedStandartActionInputs.

Используется в SelectFirstActionCategory().

Поля

m_ActionInputWantEnd_Send

bool m_ActionInputWantEnd_Send

protected

Используется в ActionManagerClient(), ActionStart(), EndActionInput() и ProcessActionInputEnd().

m_ActionPossible

bool m_ActionPossible

protected

Используется в FindContextualUserActions() и Update().

m_ActionWantEndRequest_Send

bool m_ActionWantEndRequest_Send

protected

Используется в ActionManagerClient(), ActionStart(), ProcessActionRequestEnd() и RequestEndAction().

m_DefaultOrderOfActionInputs

ref array<ActionInput> m_DefaultOrderOfActionInputs

protected

Используется в SetDefaultInputsOrder() и UpdateActionCategoryPriority().

m_ForceTarget

ref ActionTarget m_ForceTarget

private

Используется в ClearForceTarget(), FindActionTarget() и ForceTarget().

m_HandInventoryLocationTest

ref InventoryLocation m_HandInventoryLocationTest

protected

Используется в ActionManagerClient() и HasHandInventoryReservation().

m_InventoryActionHandler

ref InventoryActionHandler m_InventoryActionHandler

protected

Используется в ActionManagerClient(), OnActionEnd(), SetInventoryAction(), SetInventoryAction(), UnsetInventoryAction() и Update().

m_LastAcknowledgmentID

int m_LastAcknowledgmentID

protected

Используется в ActionManagerClient() и ActionStart().

m_OrderedStandartActionInputs

ref array<ActionInput> m_OrderedStandartActionInputs

protected

Используется в GetSelectedActionCategory(), SelectFirstActionCategory(), SelectNextAction(), SelectNextActionCategory(), SelectPrevAction(), SelectPrevActionCategory(), SetDefaultInputsOrder() и UpdateActionCategoryPriority().

m_OrederedAllActionInput

ref array<ActionInput> m_OrederedAllActionInput

protected

Используется в FindContextualUserActions(), HandleInputsOnActionStart(), InputsUpdate(), ResetInputsActions(), ResetInputsState(), SetActioninputOrder() и SetDefaultInputsOrder().

m_PendingActionData

ref ActionData m_PendingActionData

protected

Используется в PerformActionStart() и Update().

m_RegistredInputsMap

ref TTypeNameActionInputMap m_RegistredInputsMap

protected

Используется в GetPossibleAction(), GetPossibleActionCount(), GetPossibleActionIndex(), GetPossibleActions(), RegisterInputs(), SetActioninputOrder() и SetDefaultInputsOrder().

m_ReservedInventoryLocations

ref array<ref InventoryLocation> m_ReservedInventoryLocations

protected

Используется в ActionManagerClient().

m_SelectedActionInputToSrollIndex

int m_SelectedActionInputToSrollIndex

protected

Используется в ActionManagerClient(), GetSelectedActionCategory(), SelectFirstActionCategory(), SelectNextAction(), SelectNextActionCategory(), SelectPrevAction() и SelectPrevActionCategory().

m_Targets

ref ActionTargets m_Targets

private

Используется в ActionManagerClient(), FindActionTarget() и Update().

---

Объявления и описания членов класса находятся в файле:

• D:/Ishodniki/scripts/4_World/Classes/UserActionsComponent/ActionManagerClient.c