actionmanagerclient.c

Go to the documentation of this file.

typedef map<typename,ref array<ActionBase_Basic>> TInputActionMap;
typedef map<typename,ref ActionInput> TTypeNameActionInputMap;
 
class ActionManagerClient: ActionManagerBase 
{
 
 //Last send AcknowledgmentID (client can send more requests before recive ackfor first action)
 protected int m_LastAcknowledgmentID;
 protected bool m_ActionPossible;
 protected ref array<ref InventoryLocation> m_ReservedInventoryLocations;
 protected ref InventoryActionHandler m_InventoryActionHandler;
 protected ref InventoryLocation m_HandInventoryLocationTest;
 protected ref TTypeNameActionInputMap m_RegistredInputsMap;
 protected ref array<ActionInput> m_OrederedAllActionInput;
 protected ref array<ActionInput> m_OrderedStandartActionInputs;
 protected ref array<ActionInput> m_DefaultOrderOfActionInputs;
 protected int m_SelectedActionInputToSrollIndex;
 
 protected ref ActionData m_PendingActionData;
 
 protected bool m_ActionWantEndRequest_Send; //Request to server was sended
 protected bool m_ActionInputWantEnd_Send; 
 
 void ActionManagerClient(PlayerBase player) 
 {
 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;
 }
 
 //pCurrentCommandID is command ID at time of call command handler, some called methods can change actual true value (need call m_Player.GetCurrentCommandID() for actual command ID)
 override void Update(int pCurrentCommandID)
 {
 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 
 
 }
 
 void RegisterInputs(PlayerBase player)
 {
 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();
 }
 
 }
 
 //Set order of inputs base of priority (output -> m_OrederedAllActionInput)
 void SetActioninputOrder()
 {
 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();
 }
 
 //Order for user action inputs - will be dynamically change base on context (more complex handling viz set m_OrderedStandartActionInputs in UpdateActionCategoryPriority())
 void SetDefaultInputsOrder()
 {
 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;
 }
 }
 }
 }
 
 static ActionVariantManager GetVariantManager(typename actionName)
 {
 ActionBase action = GetAction(actionName);
 if (action)
 {
 return action.GetVariantManager();
 }
 //VME ACTION not exist typo most likely
 return null;
 }
 
 override void RequestEndAction()
 {
 if (!m_ActionWantEndRequest_Send)
 {
 m_ActionWantEndRequest = true;
 }
 }
 
 override void EndActionInput()
 {
 if (!m_ActionInputWantEnd_Send)
 {
 m_ActionInputWantEnd = true;
 }
 }
 
 void InputsUpdate()
 {
 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;
 }
 }
 }
 }
 }
 }
 
 void ProcessActionRequestEnd()
 {
 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);
 }
 }
 }
 
 void ProcessActionInputEnd()
 {
 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);
 }
 }
 }
 }
 
 ActionBase GetPossibleAction(typename inputType)
 {
 ActionInput action_input = m_RegistredInputsMap.Get(inputType);
 if (action_input)
 {
 return action_input.GetAction();
 }
 return NULL;
 }
 
 array<ActionBase> GetPossibleActions(typename inputType)
 {
 ActionInput action_input = m_RegistredInputsMap.Get(inputType);
 if (action_input)
 {
 return action_input.GetPossibleActions();
 }
 return NULL;
 }
 
 int GetPossibleActionIndex(typename inputType)
 {
 ActionInput action_input = m_RegistredInputsMap.Get(inputType);
 if (action_input)
 {
 return action_input.GetPossibleActionIndex();
 }
 return -1;
 }
 
 int GetPossibleActionCount(typename inputType)
 {
 ActionInput action_input = m_RegistredInputsMap.Get(inputType);
 if (action_input)
 {
 return action_input.GetPossibleActionsCount();
 }
 return 0;
 }
 
 //--------------------------------------------------------
 // Alows to set different action to current contextual one
 //-------------------------------------------------------- 
 void InjectAction(ActionBase action, ActionTarget target, ItemBase item)
 {
 ActionInput ai = action.GetInput();
 ai.ForceAction(action, target, item);
 }
 
 void InjectAction(typename actionType, ActionTarget target, ItemBase item)
 {
 ActionBase action = GetAction(actionType);
 InjectAction(action, target, item);
 }
 
 void EjectAction(ActionBase action)
 {
 ActionInput ai = action.GetInput();
 ai.ClearForcedAction();
 }
 
 void EjectAction(typename actionType)
 {
 ActionBase action = GetAction(actionType);
 EjectAction(action);
 }
 
 void ForceTarget(Object targetObject)
 {
 Object parent = null;
 EntityAI targetEntity = EntityAI.Cast(targetObject);
 if (targetEntity)
 parent = targetEntity.GetHierarchyParent();
 m_ForceTarget = new ActionTarget(targetObject, parent, -1, vector.Zero, -1);
 }
 
 void ClearForceTarget()
 {
 m_ForceTarget = NULL;
 }
 
 
 //-------------------------------------------------------------------------
 override ActionTarget FindActionTarget()
 {
 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;
 }
 
 ItemBase FindActionItem()
 {
 ItemBase item;
 if (m_Player && m_Player.GetItemInHands() && m_Player.GetItemInHands().IsItemBase()) 
 {
 item = m_Player.GetItemInHands();
 }
 return item;
 }
 
 protected bool HasHandInventoryReservation()
 {
 m_HandInventoryLocationTest.SetHands(m_Player,m_Player.GetItemInHands());
 if (m_Player.GetHumanInventory().HasInventoryReservation(m_Player.GetItemInHands(),m_HandInventoryLocationTest))
 return true;
 return false;
 }
 
 protected void FindContextualUserActions(int pCurrentCommandID)
 {
 // 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);
 }
 }
 
 //TOOD MW In progress
 protected bool LockInventory(ActionData action_data)
 {
 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;
 }
 void UnlockInventory(ActionData action_data)
 {
 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);
 }
 
 protected void ActionStart(ActionBase action, ActionTarget target, ItemBase item, Param extra_data = NULL)
 {
 if (!m_CurrentActionData && action) 
 {
 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();
 }
 }
 }
 
 void HandleInputsOnActionStart(ActionBase action)
 {
 for (int i = 0; i < m_OrederedAllActionInput.Count();i++)
 {
 ActionInput ain = m_OrederedAllActionInput[i];
 if (action.GetInput() == ain)
 {
 ain.OnActionStart();
 }
 else
 {
 ain.Reset();
 }
 }
 }
 
 void HandleInputsOnActionEnd()
 {
 ResetInputsState();
 }
 
 void ResetInputsState()
 {
 for (int i = 0; i < m_OrederedAllActionInput.Count();i++)
 {
 ActionInput ain = m_OrederedAllActionInput[i];
 ain.Reset();
 }
 }
 
 void ResetInputsActions()
 {
 for (int i = 0; i < m_OrederedAllActionInput.Count();i++)
 {
 ActionInput ain = m_OrederedAllActionInput[i];
 ain.ActionsSelectReset();
 }
 }
 
 override void OnJumpStart()
 {
 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);
 }
 }
 }
 
 //Instant Action (Debug Actions) ---------------------------------
 override void OnInstantAction(typename user_action_type, Param data = NULL)
 {
 ActionBase action = GetAction(user_action_type);
 if (action)
 {
 ActionStart(action,NULL,NULL, data);
 }
 }
 
#ifdef BOT
 void PerformAction(int user_action_id, ActionTarget target, ItemBase item, Param extraData = NULL)
 {
 ActionStart(GetAction(user_action_id), target, item, extraData);
 }
#endif
 
 void PerformActionStart(ActionBase action, ActionTarget target, ItemBase item, Param extra_data = NULL)
 {
 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);
 }
 
 override void OnActionEnd()
 {
 if (m_CurrentActionData)
 {
 UnlockInventory(m_CurrentActionData);
 if (m_CurrentActionData.m_Action.RemoveForceTargetAfterUse())
 m_InventoryActionHandler.DeactiveAction();
 
 super.OnActionEnd();
 HandleInputsOnActionEnd();
 }
 }
 
 void SetInventoryAction(ActionBase action_name, ItemBase target_item, ItemBase main_item)
 {
 m_InventoryActionHandler.SetAction(action_name, target_item, main_item);
 }
 
 void SetInventoryAction(ActionBase action_name, ActionTarget target, ItemBase main_item)
 {
 m_InventoryActionHandler.SetAction(action_name, target, main_item);
 }
 
 void UnsetInventoryAction()
 {
 m_InventoryActionHandler.DeactiveAction();
 }
 
 override typename GetSelectedActionCategory()
 {
 return m_OrderedStandartActionInputs[m_SelectedActionInputToSrollIndex].Type();
 }
 
 void UpdateActionCategoryPriority()
 {
 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++;
 }
 }
 }
 
 override void SelectFirstActionCategory()
 {
 UpdateActionCategoryPriority();
 m_SelectedActionInputToSrollIndex = 0;
 
 for (int index = 0; index < m_OrderedStandartActionInputs.Count(); index++)
 {
 if (m_OrderedStandartActionInputs[index].GetPossibleActionsCount() > 1)
 {
 m_SelectedActionInputToSrollIndex = index;
 break;
 }
 }
 }
 
 override void SelectNextActionCategory()
 {
 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;
 }
 } 
 }
 
 override void SelectPrevActionCategory()
 {
 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;
 }
 }
 }
 
 
 override void SelectNextAction()
 {
 ActionInput ai;
 if (m_SelectedActionInputToSrollIndex < m_OrderedStandartActionInputs.Count())
 {
 ai = m_OrderedStandartActionInputs[m_SelectedActionInputToSrollIndex];
 if (ai && ai.GetPossibleActionsCount() > 1)
 {
 ai.SelectNextAction();
 }
 } 
 }
 
 override void SelectPrevAction()
 {
 ActionInput ai;
 if (m_SelectedActionInputToSrollIndex < m_OrderedStandartActionInputs.Count())
 {
 ai = m_OrderedStandartActionInputs[m_SelectedActionInputToSrollIndex];
 if (ai && ai.GetPossibleActionsCount() > 1)
 {
 ai.SelectPrevAction();
 }
 }
 }
 
 bool CanPerformActionFromQuickbar(ItemBase mainItem, ItemBase targetItem)
 { 
 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;
 }
 
 void PerformActionFromQuickbar(ItemBase mainItem, ItemBase targetItem)
 {
 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;
 }
 }
 }
 }
 
 }
 }
 
 //TODO Variants support ???
 bool CanPerformActionFromInventory(ItemBase mainItem, ItemBase targetItem)
 { 
 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;
 }
 
 //TODO Variants support ???
 void PerformActionFromInventory(ItemBase mainItem, ItemBase targetItem)
 {
 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;
 }
 }
 }
 }
 }
 }
 
 bool CanSetActionFromInventory(ItemBase mainItem, ItemBase targetItem)
 {
 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;
 }
 
 //TODO fix for variants
 void SetActionFromInventory(ItemBase mainItem, ItemBase targetItem)
 {
 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;
 }
 }
 }
 }
 } 
 }
 
 override void Interrupt()
 {
 super.Interrupt();
 
 if (m_CurrentActionData)
 m_Interrupted = true;
 }
 
 void RequestInterruptAction()
 {
 if (ScriptInputUserData.CanStoreInputUserData())
 {
 ScriptInputUserData ctx = new ScriptInputUserData;
 ctx.Write(INPUT_UDT_STANDARD_ACTION_END_REQUEST);
 ctx.Write(DayZPlayerConstants.CMD_ACTIONINT_INTERRUPT);
 ctx.Send();
 }
 }
 
 private ref ActionTarget m_ForceTarget;
 private ref ActionTargets m_Targets;
};