ActionManagerClient Class Reference

Inheritance diagram for ActionManagerClient:

Collaboration diagram for ActionManagerClient:

Protected Member Functions
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 Protected Member Functions
static ActionVariantManager	GetVariantManager (typename actionName)

Protected Attributes
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

Private Attributes
ref ActionTarget	m_ForceTarget
ref ActionTargets	m_Targets

Detailed Description

Definition at line 4 of file ActionManagerClient.c.

Constructor & Destructor Documentation

ActionManagerClient()

void ActionManagerClient::ActionManagerClient ( PlayerBase player )

inlineprotected

Definition at line 24 of file ActionManagerClient.c.

  {
    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;
  }

References m_ActionInputWantEnd_Send, m_ActionWantEndRequest_Send, m_HandInventoryLocationTest, m_InventoryActionHandler, m_LastAcknowledgmentID, m_ReservedInventoryLocations, m_SelectedActionInputToSrollIndex, m_Targets, and RegisterInputs().

Member Function Documentation

ActionStart()

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

inlineprotected

Definition at line 542 of file ActionManagerClient.c.

  {
    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();
      }
    }
  }

References 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(), and UA_AM_PENDING.

Referenced by InputsUpdate(), OnInstantAction(), PerformActionFromInventory(), PerformActionFromQuickbar(), and PerformActionStart().

CanPerformActionFromInventory()

bool ActionManagerClient::CanPerformActionFromInventory ( ItemBase mainItem, ItemBase targetItem )

inlineprotected

Definition at line 955 of file ActionManagerClient.c.

  {
    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;
  }

References ActionTarget, m_Player, and vector::Zero.

CanPerformActionFromQuickbar()

bool ActionManagerClient::CanPerformActionFromQuickbar ( ItemBase mainItem, ItemBase targetItem )

inlineprotected

Definition at line 825 of file ActionManagerClient.c.

  {
    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;
  }

References ActionTarget, m_Player, and vector::Zero.

CanSetActionFromInventory()

bool ActionManagerClient::CanSetActionFromInventory ( ItemBase mainItem, ItemBase targetItem )

inlineprotected

Definition at line 1053 of file ActionManagerClient.c.

  {
    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;
  }

References ActionTarget, m_Player, and vector::Zero.

ClearForceTarget()

void ActionManagerClient::ClearForceTarget ( )

inlineprotected

Definition at line 431 of file ActionManagerClient.c.

  {
    m_ForceTarget = NULL;
  }

References m_ForceTarget.

EjectAction() [1/2]

void ActionManagerClient::EjectAction ( ActionBase action )

inlineprotected

Definition at line 410 of file ActionManagerClient.c.

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

Referenced by EjectAction().

EjectAction() [2/2]

void ActionManagerClient::EjectAction ( typename actionType )

inlineprotected

Definition at line 416 of file ActionManagerClient.c.

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

References EjectAction(), and GetAction().

EndActionInput()

override void ActionManagerClient::EndActionInput ( )

inlineprotected

Definition at line 252 of file ActionManagerClient.c.

  {
    if (!m_ActionInputWantEnd_Send)
      m_ActionInputWantEnd = true;
  }

References m_ActionInputWantEnd, and m_ActionInputWantEnd_Send.

Referenced by InputsUpdate().

FindActionItem()

ItemBase ActionManagerClient::FindActionItem ( )

inlineprotected

Definition at line 466 of file ActionManagerClient.c.

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

References m_Player.

Referenced by FindContextualUserActions().

FindActionTarget()

override ActionTarget ActionManagerClient::FindActionTarget ( )

inlineprotected

Definition at line 438 of file ActionManagerClient.c.

  {
    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;
  }

References ActionTarget, m_ForceTarget, m_Targets, and vector::Zero.

Referenced by FindContextualUserActions(), and ActionTargetsCursor::GetTarget().

FindContextualUserActions()

void ActionManagerClient::FindContextualUserActions ( int pCurrentCommandID )

inlineprotected

Definition at line 482 of file ActionManagerClient.c.

  {
    // 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);
    }
  }

References FindActionItem(), FindActionTarget(), GetGame(), GetRunningAction(), HasHandInventoryReservation(), m_ActionPossible, m_ActionsAvaibale, m_OrederedAllActionInput, m_Player, ResetInputsActions(), and SetActionContext().

Referenced by Update().

ForceTarget()

void ActionManagerClient::ForceTarget ( Object targetObject )

inlineprotected

Definition at line 422 of file ActionManagerClient.c.

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

References ActionTarget, m_ForceTarget, and vector::Zero.

GetPossibleAction()

ActionBase ActionManagerClient::GetPossibleAction ( typename inputType )

inlineprotected

Definition at line 363 of file ActionManagerClient.c.

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

References m_RegistredInputsMap.

GetPossibleActionCount()

int ActionManagerClient::GetPossibleActionCount ( typename inputType )

inlineprotected

Definition at line 387 of file ActionManagerClient.c.

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

References m_RegistredInputsMap.

GetPossibleActionIndex()

int ActionManagerClient::GetPossibleActionIndex ( typename inputType )

inlineprotected

Definition at line 379 of file ActionManagerClient.c.

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

References m_RegistredInputsMap.

GetPossibleActions()

array< ActionBase > ActionManagerClient::GetPossibleActions ( typename inputType )

inlineprotected

Definition at line 371 of file ActionManagerClient.c.

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

References m_RegistredInputsMap.

GetSelectedActionCategory()

override ActionManagerClient::GetSelectedActionCategory ( )

inlineprotected

Definition at line 726 of file ActionManagerClient.c.

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

References m_OrderedStandartActionInputs, and m_SelectedActionInputToSrollIndex.

GetVariantManager()

static ActionVariantManager ActionManagerClient::GetVariantManager ( typename actionName )

inlinestaticprotected

Definition at line 237 of file ActionManagerClient.c.

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

References GetAction().

Referenced by ConstructionActionData::ConstructionActionData(), and CraftingManager::CraftingManager().

HandleInputsOnActionEnd()

void ActionManagerClient::HandleInputsOnActionEnd ( )

inlineprotected

Definition at line 632 of file ActionManagerClient.c.

  {
    ResetInputsState();
  }

References ResetInputsState().

Referenced by OnActionEnd().

HandleInputsOnActionStart()

void ActionManagerClient::HandleInputsOnActionStart ( ActionBase action )

inlineprotected

Definition at line 620 of file ActionManagerClient.c.

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

References m_OrederedAllActionInput.

Referenced by ActionStart().

HasHandInventoryReservation()

bool ActionManagerClient::HasHandInventoryReservation ( )

inlineprotected

Definition at line 474 of file ActionManagerClient.c.

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

References m_HandInventoryLocationTest, and m_Player.

Referenced by FindContextualUserActions().

InjectAction() [1/2]

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

inlineprotected

Definition at line 398 of file ActionManagerClient.c.

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

Referenced by InjectAction().

InjectAction() [2/2]

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

inlineprotected

Definition at line 404 of file ActionManagerClient.c.

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

References GetAction(), and InjectAction().

InputsUpdate()

void ActionManagerClient::InputsUpdate ( )

inlineprotected

Definition at line 258 of file ActionManagerClient.c.

  {
    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;
            }
          }
        }
      }
    }
  }

References ActionStart(), EndActionInput(), m_ActionInputWantEnd, m_ActionsAvaibale, m_CurrentActionData, m_OrederedAllActionInput, and m_Player.

Referenced by Update().

Interrupt()

override void ActionManagerClient::Interrupt ( )

inlineprotected

Definition at line 1186 of file ActionManagerClient.c.

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

References m_CurrentActionData, and m_Interrupted.

LockInventory()

bool ActionManagerClient::LockInventory ( ActionData action_data )

inlineprotected

Definition at line 516 of file ActionManagerClient.c.

  {
    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;
  }

References Debug::ActionLog(), and LogManager::IsActionLogEnable().

OnActionEnd()

override void ActionManagerClient::OnActionEnd ( )

inlineprotected

Definition at line 698 of file ActionManagerClient.c.

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

References HandleInputsOnActionEnd(), m_CurrentActionData, m_InventoryActionHandler, and UnlockInventory().

Referenced by ActionStart(), OnJumpStart(), and Update().

OnInstantAction()

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

inlineprotected

Definition at line 670 of file ActionManagerClient.c.

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

References ActionStart(), and GetAction().

OnJumpStart()

override void ActionManagerClient::OnJumpStart ( )

inlineprotected

Definition at line 655 of file ActionManagerClient.c.

  {
    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);
    }
  }

References m_CurrentActionData, m_PendingActionAcknowledgmentID, OnActionEnd(), UA_AM_ACCEPTED, UA_AM_PENDING, and UA_AM_REJECTED.

PerformActionFromInventory()

void ActionManagerClient::PerformActionFromInventory ( ItemBase mainItem, ItemBase targetItem )

inlineprotected

Definition at line 1002 of file ActionManagerClient.c.

  {
    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;
            }
          }
        }
      }
    }
  }

References ActionStart(), ActionTarget, m_Player, and vector::Zero.

PerformActionFromQuickbar()

void ActionManagerClient::PerformActionFromQuickbar ( ItemBase mainItem, ItemBase targetItem )

inlineprotected

Definition at line 883 of file ActionManagerClient.c.

  {
    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;
            }
          }
        }
      }
 
    }
  }

References ActionStart(), ActionTarget, m_Player, and vector::Zero.

PerformActionStart()

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

inlineprotected

Definition at line 685 of file ActionManagerClient.c.

  {
    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);
  }

References ActionStart(), GetGame(), m_PendingActionData, and m_Player.

ProcessActionInputEnd()

void ActionManagerClient::ProcessActionInputEnd ( )

inlineprotected

Definition at line 331 of file ActionManagerClient.c.

  {
    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);
        }
      }
    }
  }

References Debug::ActionLog(), ScriptInputUserData::CanStoreInputUserData(), GetGame(), INPUT_UDT_STANDARD_ACTION_INPUT_END, LogManager::IsActionLogEnable(), m_ActionInputWantEnd, m_ActionInputWantEnd_Send, m_CurrentActionData, and m_Player.

Referenced by Update().

ProcessActionRequestEnd()

void ActionManagerClient::ProcessActionRequestEnd ( )

inlineprotected

Definition at line 303 of file ActionManagerClient.c.

  {
    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);
      }
    }
  }

References Debug::ActionLog(), ScriptInputUserData::CanStoreInputUserData(), GetGame(), INPUT_UDT_STANDARD_ACTION_END_REQUEST, LogManager::IsActionLogEnable(), m_ActionWantEndRequest, m_ActionWantEndRequest_Send, m_CurrentActionData, and m_Player.

Referenced by Update().

RegisterInputs()

void ActionManagerClient::RegisterInputs ( PlayerBase player )

inlineprotected

Definition at line 130 of file ActionManagerClient.c.

  {
    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();
    }
 
  }

References m_ActionsArray, m_RegistredInputsMap, and SetActioninputOrder().

Referenced by ActionManagerClient().

RequestEndAction()

override void ActionManagerClient::RequestEndAction ( )

inlineprotected

Definition at line 246 of file ActionManagerClient.c.

  {
    if (!m_ActionWantEndRequest_Send)
      m_ActionWantEndRequest = true;
  }

References m_ActionWantEndRequest, and m_ActionWantEndRequest_Send.

Referenced by ActionReadPaper::OnUpdate(), and ActionWritePaper::OnUpdate().

RequestInterruptAction()

void ActionManagerClient::RequestInterruptAction ( )

inlineprotected

client requests action interrupt

Definition at line 1195 of file ActionManagerClient.c.

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

References ScriptInputUserData::CanStoreInputUserData(), and INPUT_UDT_STANDARD_ACTION_END_REQUEST.

ResetInputsActions()

void ActionManagerClient::ResetInputsActions ( )

inlineprotected

Definition at line 646 of file ActionManagerClient.c.

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

References m_OrederedAllActionInput.

Referenced by FindContextualUserActions(), and Update().

ResetInputsState()

void ActionManagerClient::ResetInputsState ( )

inlineprotected

Definition at line 637 of file ActionManagerClient.c.

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

References m_OrederedAllActionInput.

Referenced by HandleInputsOnActionEnd().

SelectFirstActionCategory()

override void ActionManagerClient::SelectFirstActionCategory ( )

inlineprotected

Definition at line 754 of file ActionManagerClient.c.

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

References GetPossibleActionsCount(), m_OrderedStandartActionInputs, m_SelectedActionInputToSrollIndex, and UpdateActionCategoryPriority().

SelectNextAction()

override void ActionManagerClient::SelectNextAction ( )

inlineprotected

Definition at line 803 of file ActionManagerClient.c.

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

References m_OrderedStandartActionInputs, and m_SelectedActionInputToSrollIndex.

SelectNextActionCategory()

override void ActionManagerClient::SelectNextActionCategory ( )

inlineprotected

Definition at line 769 of file ActionManagerClient.c.

  {
    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;
      }
    }
  }

References GetPossibleActionsCount(), m_OrderedStandartActionInputs, and m_SelectedActionInputToSrollIndex.

SelectPrevAction()

override void ActionManagerClient::SelectPrevAction ( )

inlineprotected

Definition at line 814 of file ActionManagerClient.c.

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

References m_OrderedStandartActionInputs, and m_SelectedActionInputToSrollIndex.

SelectPrevActionCategory()

override void ActionManagerClient::SelectPrevActionCategory ( )

inlineprotected

Definition at line 785 of file ActionManagerClient.c.

  {
    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;
      }
    }
  }

References GetPossibleActionsCount(), m_OrderedStandartActionInputs, and m_SelectedActionInputToSrollIndex.

SetActionFromInventory()

void ActionManagerClient::SetActionFromInventory ( ItemBase mainItem, ItemBase targetItem )

inlineprotected

Definition at line 1137 of file ActionManagerClient.c.

  {
    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;
            }
          }
        }
      }
    }
  }

References ActionTarget, m_Player, SetInventoryAction(), and vector::Zero.

SetActioninputOrder()

void ActionManagerClient::SetActioninputOrder ( )

inlineprotected

Definition at line 159 of file ActionManagerClient.c.

  {
    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();
  }

References m_OrederedAllActionInput, m_RegistredInputsMap, and SetDefaultInputsOrder().

Referenced by RegisterInputs().

SetDefaultInputsOrder()

void ActionManagerClient::SetDefaultInputsOrder ( )

inlineprotected

Definition at line 203 of file ActionManagerClient.c.

  {
    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;
        }
      }
    }
  }

References m_DefaultOrderOfActionInputs, m_OrderedStandartActionInputs, m_OrederedAllActionInput, and m_RegistredInputsMap.

Referenced by SetActioninputOrder().

SetInventoryAction() [1/2]

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

inlineprotected

Definition at line 716 of file ActionManagerClient.c.

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

References m_InventoryActionHandler.

SetInventoryAction() [2/2]

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

inlineprotected

Definition at line 711 of file ActionManagerClient.c.

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

References m_InventoryActionHandler.

Referenced by SetActionFromInventory().

UnlockInventory()

void ActionManagerClient::UnlockInventory ( ActionData action_data )

inlineprotected

Definition at line 534 of file ActionManagerClient.c.

  {
    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);
  }

References Debug::ActionLog(), and LogManager::IsActionLogEnable().

Referenced by OnActionEnd().

UnsetInventoryAction()

void ActionManagerClient::UnsetInventoryAction ( )

inlineprotected

Definition at line 721 of file ActionManagerClient.c.

  {
    m_InventoryActionHandler.DeactiveAction();
  }

References m_InventoryActionHandler.

Update()

override void ActionManagerClient::Update ( int pCurrentCommandID )

inlineprotected

Definition at line 40 of file ActionManagerClient.c.

  {
    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
 
  }

References 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, and UA_START.

UpdateActionCategoryPriority()

void ActionManagerClient::UpdateActionCategoryPriority ( )

inlineprotected

Definition at line 731 of file ActionManagerClient.c.

  {
    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++;
      }
    }
  }

References HasTarget(), m_DefaultOrderOfActionInputs, and m_OrderedStandartActionInputs.

Referenced by SelectFirstActionCategory().

Member Data Documentation

m_ActionInputWantEnd_Send

bool ActionManagerClient::m_ActionInputWantEnd_Send

protected

Definition at line 22 of file ActionManagerClient.c.

Referenced by ActionManagerClient(), ActionStart(), EndActionInput(), and ProcessActionInputEnd().

m_ActionPossible

bool ActionManagerClient::m_ActionPossible

protected

Definition at line 9 of file ActionManagerClient.c.

Referenced by FindContextualUserActions(), and Update().

m_ActionWantEndRequest_Send

bool ActionManagerClient::m_ActionWantEndRequest_Send

protected

Definition at line 21 of file ActionManagerClient.c.

Referenced by ActionManagerClient(), ActionStart(), ProcessActionRequestEnd(), and RequestEndAction().

m_DefaultOrderOfActionInputs

ref array<ActionInput> ActionManagerClient::m_DefaultOrderOfActionInputs

protected

Definition at line 16 of file ActionManagerClient.c.

Referenced by SetDefaultInputsOrder(), and UpdateActionCategoryPriority().

m_ForceTarget

ref ActionTarget ActionManagerClient::m_ForceTarget

private

Definition at line 1206 of file ActionManagerClient.c.

Referenced by ClearForceTarget(), FindActionTarget(), and ForceTarget().

m_HandInventoryLocationTest

ref InventoryLocation ActionManagerClient::m_HandInventoryLocationTest

protected

Definition at line 12 of file ActionManagerClient.c.

Referenced by ActionManagerClient(), and HasHandInventoryReservation().

m_InventoryActionHandler

ref InventoryActionHandler ActionManagerClient::m_InventoryActionHandler

protected

Definition at line 11 of file ActionManagerClient.c.

Referenced by ActionManagerClient(), OnActionEnd(), SetInventoryAction(), SetInventoryAction(), UnsetInventoryAction(), and Update().

m_LastAcknowledgmentID

int ActionManagerClient::m_LastAcknowledgmentID

protected

Definition at line 8 of file ActionManagerClient.c.

Referenced by ActionManagerClient(), and ActionStart().

m_OrderedStandartActionInputs

ref array<ActionInput> ActionManagerClient::m_OrderedStandartActionInputs

protected

Definition at line 15 of file ActionManagerClient.c.

Referenced by GetSelectedActionCategory(), SelectFirstActionCategory(), SelectNextAction(), SelectNextActionCategory(), SelectPrevAction(), SelectPrevActionCategory(), SetDefaultInputsOrder(), and UpdateActionCategoryPriority().

m_OrederedAllActionInput

ref array<ActionInput> ActionManagerClient::m_OrederedAllActionInput

protected

Definition at line 14 of file ActionManagerClient.c.

Referenced by FindContextualUserActions(), HandleInputsOnActionStart(), InputsUpdate(), ResetInputsActions(), ResetInputsState(), SetActioninputOrder(), and SetDefaultInputsOrder().

m_PendingActionData

ref ActionData ActionManagerClient::m_PendingActionData

protected

Definition at line 19 of file ActionManagerClient.c.

Referenced by PerformActionStart(), and Update().

m_RegistredInputsMap

ref TTypeNameActionInputMap ActionManagerClient::m_RegistredInputsMap

protected

Definition at line 13 of file ActionManagerClient.c.

Referenced by GetPossibleAction(), GetPossibleActionCount(), GetPossibleActionIndex(), GetPossibleActions(), RegisterInputs(), SetActioninputOrder(), and SetDefaultInputsOrder().

m_ReservedInventoryLocations

ref array<ref InventoryLocation> ActionManagerClient::m_ReservedInventoryLocations

protected

Definition at line 10 of file ActionManagerClient.c.

Referenced by ActionManagerClient().

m_SelectedActionInputToSrollIndex

int ActionManagerClient::m_SelectedActionInputToSrollIndex

protected

Definition at line 17 of file ActionManagerClient.c.

Referenced by ActionManagerClient(), GetSelectedActionCategory(), SelectFirstActionCategory(), SelectNextAction(), SelectNextActionCategory(), SelectPrevAction(), and SelectPrevActionCategory().

m_Targets

ref ActionTargets ActionManagerClient::m_Targets

private

Definition at line 1207 of file ActionManagerClient.c.

Referenced by ActionManagerClient(), FindActionTarget(), and Update().

---

The documentation for this class was generated from the following file:

• scripts/4_World/Classes/UserActionsComponent/ActionManagerClient.c