ActionManagerBase.c

Go to the documentation of this file.

class TSelectableActionInfoArray extends array<ref TSelectableActionInfo>
{
  bool IsSameAs(TSelectableActionInfoArray other)
  {
    if (this.Count() != other.Count())
      return false;
 
    for (int i = 0; i < Count(); ++i)
    {
      TSelectableActionInfo ai1 = this.Get(i);
      TSelectableActionInfo ai2 = other.Get(i);
 
      if (ai1.param2 != ai2.param2)
        return false;
 
      if (ai1.param3 != ai2.param3)
        return false;
    }
 
    return true;
  }
}
 
class ActionManagerBase
{
  PlayerBase m_Player;
 
  protected ActionTarget m_TestedActionTarget;
  protected ItemBase m_TestedActionItem;
 
  protected ActionBase m_PrimaryAction;
  protected ActionTarget m_PrimaryActionTarget;
  protected ItemBase m_PrimaryActionItem;
  protected ActionBase m_SecondaryAction;
  protected ActionTarget m_SecondaryActionTarget;
  protected ItemBase m_SecondaryActionItem;
  bool m_PrimaryActionEnabled;
  bool m_SecondaryActionEnabled;
  bool m_TertiaryActionEnabled;
  ref TSelectableActionInfoArray m_SelectableActions;
  int m_SelectedActionIndex;
  bool m_SelectableActionsHasChanged;
  bool m_Interrupted;
  static ref array<ref ActionBase> m_ActionsArray;
  static ref map<typename, ActionBase> m_ActionNameActionMap;
  protected bool m_ActionWantEndRequest;
  protected bool m_ActionInputWantEnd;
  protected bool m_ActionsEnabled;
  protected bool m_ActionsAvaibale;
 
  //Pending actions waiting for acknowledgment
  protected int m_PendingActionAcknowledgmentID;
 
  protected ref ActionData m_CurrentActionData;
 
  void ActionManagerBase(PlayerBase player)
  {
    m_Player = player;
    if (m_Player)
    {
      m_SelectableActions = new TSelectableActionInfoArray();
      m_SelectedActionIndex = 0;
      m_SelectableActionsHasChanged = false;
 
      m_PendingActionAcknowledgmentID = -1;
 
      m_CurrentActionData = NULL;
      m_Interrupted = false;
 
      ActionConstructor ac = new ActionConstructor();
      if (!m_ActionsArray)
        ac.ConstructActions(m_ActionsArray, m_ActionNameActionMap);
 
      m_ActionWantEndRequest = false;
      m_ActionInputWantEnd = false;
    }
 
    m_ActionsEnabled = true;
    m_ActionsAvaibale = true;
  }
 
  ActionBase GetRunningAction()
  {
    if (m_CurrentActionData)
      return m_CurrentActionData.m_Action;
 
    return null;
  }
 
  ItemBase GetRunningActionMainitem()
  {
    if (m_CurrentActionData)
      return m_CurrentActionData.m_MainItem;
 
    return null;
  }
 
  void EnableActions(bool enable)
  {
    m_ActionsEnabled = enable;
  }
 
  void Update(int pCurrentCommandID)
  {
    if (m_CurrentActionData)
    {
      if (m_Interrupted)
        LocalInterrupt();
      else 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.OnUpdate(m_CurrentActionData);
    }
    else if (m_Interrupted)
      m_Interrupted = false;
  }
 
  void OnSyncJuncture(int pJunctureID, ParamsReadContext pCtx)
  {
    int AcknowledgmentID;
    switch (pJunctureID)
    {
    case DayZPlayerSyncJunctures.SJ_ACTION_ACK_ACCEPT:
      pCtx.Read(AcknowledgmentID);
      if (m_CurrentActionData && AcknowledgmentID == m_PendingActionAcknowledgmentID)
        m_CurrentActionData.m_State = UA_AM_ACCEPTED;
      break;
    case DayZPlayerSyncJunctures.SJ_ACTION_ACK_REJECT:
      pCtx.Read(AcknowledgmentID);
      if (m_CurrentActionData && AcknowledgmentID == m_PendingActionAcknowledgmentID)
        m_CurrentActionData.m_State = UA_AM_REJECTED;
      break;
    case DayZPlayerSyncJunctures.SJ_ACTION_INTERRUPT:
      m_Interrupted = true;
      break;
    }
  }
 
  ActionTarget FindActionTarget();
  void StartDeliveredAction();
 
  static ActionBase GetActionVariant(typename actionName)
  {
    if (m_ActionNameActionMap)
    {
      ActionBase base_action = m_ActionNameActionMap.Get(actionName);
      ActionBase new_action = ActionBase.Cast(actionName.Spawn());
 
      new_action.CreateConditionComponents();
      new_action.SetID(base_action.GetID());
      new_action.SetInput(base_action.GetInput());
 
      return new_action;
    }
    return null;
  }
 
  static ActionBase GetAction(typename actionName)
  {
    if (m_ActionNameActionMap)
      return m_ActionNameActionMap.Get(actionName);
 
    return null;
  }
 
  static ActionBase GetAction(int actionID)
  {
    return m_ActionsArray.Get(actionID);
  }
 
  ActionBase GetContinuousAction()
  {
    return m_PrimaryAction;
  }
 
  ActionBase GetSingleUseAction()
  {
    return m_SecondaryAction;
  }
 
  TSelectableActionInfoArray GetSelectableActions()
  {
    return m_SelectableActions;
  }
 
  int GetSelectedActionIndex()
  {
    return m_SelectedActionIndex;
  }
 
  typename GetSelectedActionCategory();
  void SelectFirstActionCategory();
  void SelectNextActionCategory();
  void SelectPrevActionCategory();
  void SelectNextAction();
  void SelectPrevAction();
  void RequestEndAction();
  void EndActionInput();
 
  bool IsSelectableActionsChanged()
  {
    return m_SelectableActionsHasChanged;
  }
 
  //------------------------------------------------------
  bool ActionPossibilityCheck(int pCurrentCommandID)
  {
    if (!m_ActionsEnabled || m_Player.IsSprinting() || m_Player.IsUnconscious() || m_Player.GetCommandModifier_Action() || m_Player.GetCommand_Action() || m_Player.IsEmotePlaying() || m_Player.GetThrowing().IsThrowingAnimationPlaying() || m_Player.GetDayZPlayerInventory().IsProcessing() || m_Player.IsItemsToDelete())
      return false;
 
    if (m_Player.GetWeaponManager().IsRunning())
      return false;
 
    return (pCurrentCommandID == DayZPlayerConstants.COMMANDID_ACTION || pCurrentCommandID == DayZPlayerConstants.COMMANDID_MOVE || pCurrentCommandID == DayZPlayerConstants.COMMANDID_SWIM || pCurrentCommandID == DayZPlayerConstants.COMMANDID_LADDER || pCurrentCommandID == DayZPlayerConstants.COMMANDID_VEHICLE);
  }
  //------------------------------------------------------
  protected void SetActionContext(ActionTarget target, ItemBase item)
  {
    m_TestedActionTarget = target;
    m_TestedActionItem = item;
  }
 
  //------------------------------------------------------
 
  int GetActionState(ActionBase action)
  {
    if (m_CurrentActionData)
      return m_CurrentActionData.m_State;
    return UA_NONE;
  }
 
  //---------------------------------
  // EVENTS
  //---------------------------------
  void OnContinuousStart();
  void OnContinuousCancel();
  void OnSingleUse();
  void Interrupt();
 
  protected void LocalInterrupt()
  {
    if (m_CurrentActionData && m_CurrentActionData.m_Action)
      m_CurrentActionData.m_Action.Interrupt(m_CurrentActionData);
    else
      m_Interrupted = false;
  }
 
  void OnInteractAction(); //Interact
  void OnInstantAction(typename user_action_type, Param data = null);
 
  void OnActionEnd()
  {
    if (LogManager.IsActionLogEnable())
    {
      if (m_CurrentActionData)
        Debug.ActionLog("n/a", m_CurrentActionData.m_Action.ToString(), "n/a", "OnActionEnd", m_CurrentActionData.m_Player.ToString());
      Debug.ActionLog("Action data cleared ", this.ToString(), "n/a", "ActionEnd", m_CurrentActionData.m_Player.ToString());
    }
    if (m_CurrentActionData)
      m_CurrentActionData.m_Action.ActionCleanup(m_CurrentActionData);
    m_CurrentActionData = NULL;
 
    m_Player.ResetActionEndInput();
  }
 
  void OnJumpStart();
 
  bool OnInputUserDataProcess(int userDataType, ParamsReadContext ctx)
  {
    return false;
  }
 
  float GetActionComponentProgress()
  {
    if (m_CurrentActionData)
      return m_CurrentActionData.m_Action.GetProgress(m_CurrentActionData);
 
    return 0.0;
  }
 
  int GetActionState()
  {
    if (m_CurrentActionData)
      return m_CurrentActionData.m_Action.GetState(m_CurrentActionData);
 
    return UA_NONE;
  }
 
  ActionReciveData GetReciveData()
  {
    return null;
  }
}