actionmanagerserver.c

Go to the documentation of this file.

class ActionManagerServer: ActionManagerBase
{ 
 protected ActionBase m_PendingAction;
 ref ActionReciveData m_PendingActionReciveData;
 
 void ActionManagerServer(PlayerBase player)
 {
 m_PendingAction = null;
 m_PendingActionReciveData = null;
 }
 
 //------------------------------------------
 //EVENTS 
 //------------------------------------------
 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);
 }
 }
 }
 
 override bool OnInputUserDataProcess(int userDataType, ParamsReadContext ctx)
 { 
 switch (userDataType)
 {
 case INPUT_UDT_STANDARD_ACTION_START:
 {
 bool success = true;
 
 int actionID = 0;
 if (!ctx.Read(actionID))
 return false;
 
 ActionBase recvAction = GetAction(actionID);
 if (!recvAction)
 return false;
 
 if (!recvAction.ReadFromContext(ctx, m_PendingActionReciveData))
 success = false;
 
 m_PendingAction = recvAction;
 
 if (recvAction.UseAcknowledgment())
 {
 int ackID;
 if (!ctx.Read(ackID))
 success = false;
 
 m_PendingActionAcknowledgmentID = ackID;
 }
 
 break;
 
 }
 
 case INPUT_UDT_STANDARD_ACTION_END_REQUEST:
 {
 //Debug.Log("Action want end request, STS = " + m_Player.GetSimulationTimeStamp());
 int commandID = -10;
 ctx.Read(commandID);
 
 if (commandID == DayZPlayerConstants.CMD_ACTIONINT_INTERRUPT)
 {
 //Print("INPUT_UDT_STANDARD_ACTION_END_REQUEST | CMD_ACTIONINT_INTERRUPT");
 Interrupt();
 }
 else
 {
 //Print("INPUT_UDT_STANDARD_ACTION_END_REQUEST | m_ActionWantEndRequest");
 m_ActionWantEndRequest = true;
 }
 }
 
 case INPUT_UDT_STANDARD_ACTION_INPUT_END:
 {
 //Debug.Log("Action input ended, STS = " + m_Player.GetSimulationTimeStamp());
 m_ActionInputWantEnd = true;
 }
 default:
 return false;
 }
 
 if (!success)
 {
 //Debug.Log("[AM] OnInputUserDataProcess INPUT_UDT_STANDARD_ACTION_START Error");
 if (recvAction.UseAcknowledgment())
 {
 DayZPlayerSyncJunctures.SendActionAcknowledgment(m_Player, m_PendingActionAcknowledgmentID, false);
 }
 else
 {
 Interrupt();
 }
 
 return false;
 }
 return true;
 
 }
 
 override void StartDeliveredAction()
 {
 if (!m_CurrentActionData)
 {
 return;
 }
 
 m_Interrupted = false;
 
 bool accepted = false; 
 ActionBase pickedAction = m_CurrentActionData.m_Action;
 ActionTarget target = m_CurrentActionData.m_Target;
 ItemBase item = m_CurrentActionData.m_MainItem;
 
 if (LogManager.IsActionLogEnable())
 {
 Debug.ActionLog("Item = " + item + ", " + target.DumpToString(), pickedAction.ToString() , "n/a", "DeliveredAction", m_Player.ToString());
 }
 
 if (!m_Player.GetCommandModifier_Action() && !m_Player.GetCommand_Action() && !m_Player.IsSprinting() && pickedAction && pickedAction.Can(m_Player,target,item)) 
 {
 accepted = true;
 if (pickedAction.HasTarget())
 {
 EntityAI targetEntity;
 if (EntityAI.CastTo(targetEntity,target.GetObject()))
 {
 if (!AdvancedCommunication.Cast(targetEntity) && !Building.Cast(targetEntity) && pickedAction.IsLockTargetOnUse())
 {
 //Lock target
 if (!GetGame().AddActionJuncture(m_Player, targetEntity, 10000))
 {
 accepted = false;
 }
 }
 }
 }
 }
 
 if (accepted)
 {
 if (LogManager.IsActionLogEnable())
 {
 Debug.ActionLog("Action accepted", pickedAction.ToString() , "n/a", "CheckDeliveredAction", m_Player.ToString() );
 }
 //Debug.Log("[AM] Action acccepted");
 if (pickedAction.UseAcknowledgment())
 {
 //Unlock target
 m_CurrentActionData.m_State = UA_AM_PENDING;
 DayZPlayerSyncJunctures.SendActionAcknowledgment(m_Player, m_PendingActionAcknowledgmentID, true);
 }
 else
 {
 m_CurrentActionData.m_State = UA_AM_ACCEPTED;
 }
 }
 else
 {
 if (LogManager.IsActionLogEnable())
 {
 Debug.ActionLog("Action rejected", pickedAction.ToString() , "n/a", "CheckDeliveredAction", m_Player.ToString() );
 }
 
 if (pickedAction.UseAcknowledgment())
 {
 DayZPlayerSyncJunctures.SendActionAcknowledgment(m_Player, m_PendingActionAcknowledgmentID, false);
 }
 else
 {
 Interrupt();
 }
 }
 }
 
 override void OnActionEnd()
 {
 //Debug.Log("Action ended - hard, STS = " + m_Player.GetSimulationTimeStamp());
 if (m_CurrentActionData)
 {
 if ( m_CurrentActionData.m_Target )
 {
 EntityAI targetEntity;
 if (targetEntity.CastTo(targetEntity, m_CurrentActionData.m_Target.GetObject()) && !Building.Cast(targetEntity))
 {
 GetGame().ClearJuncture(m_CurrentActionData.m_Player, targetEntity);
 }
 }
 
 super.OnActionEnd();
 }
 }
 
 //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)
 {
 super.Update(pCurrentCommandID);
 int currentCommandID = m_Player.GetCurrentCommandID();
 
 //Debug.Log("m_ActionWantEnd " + m_ActionInputWantEnd);
 
 if (m_PendingAction)
 {
 if (m_CurrentActionData)
 {
 DayZPlayerSyncJunctures.SendActionAcknowledgment(m_Player, m_PendingActionAcknowledgmentID, false);
 }
 else
 {
 m_ActionWantEndRequest = false;
 m_ActionInputWantEnd = false;
 
 bool success = true;
 ActionTarget target = new ActionTarget(null, null, -1, vector.Zero, 0); 
 
 if ( LogManager.IsActionLogEnable() )
 { 
 Debug.ActionLog("n/a", m_PendingAction.ToString() , "n/a", "HandlePendingAction", m_Player.ToString() );
 }
 
 if (!m_PendingAction.SetupAction(m_Player,target,m_Player.GetItemInHands(),m_CurrentActionData))
 {
 success = false;
 }
 //Debug.Log("[AM] Action data synced (" + m_Player + ") success: " + success);
 
 if (success)
 {
 StartDeliveredAction();
 }
 else
 {
 if (m_PendingAction.UseAcknowledgment())
 {
 DayZPlayerSyncJunctures.SendActionAcknowledgment(m_Player, m_PendingActionAcknowledgmentID, false);
 }
 else
 {
 Interrupt();
 }
 }
 }
 
 m_PendingAction = null;
 m_PendingActionReciveData = 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.OnUpdateServer(m_CurrentActionData);
 
 if (m_CurrentActionData.m_RefreshJunctureTimer > 0)
 {
 m_CurrentActionData.m_RefreshJunctureTimer--;
 }
 else
 {
 m_CurrentActionData.m_RefreshJunctureTimer = m_CurrentActionData.m_Action.GetRefreshReservationTimerValue();
 if (m_CurrentActionData.m_Target)
 {
 EntityAI targetEntity;
 if ( targetEntity.CastTo(targetEntity, m_CurrentActionData.m_Target.GetObject()) && !Building.Cast(targetEntity) )
 {
 GetGame().ExtendActionJuncture(m_CurrentActionData.m_Player, targetEntity, 10000);
 }
 }
 }
 }
 
 //Debug.Log("m_CurrentActionData.m_State: " + m_CurrentActionData.m_State +" m_ActionWantEnd: " + m_ActionWantEndRequest );
 switch (m_CurrentActionData.m_State)
 {
 case UA_AM_PENDING:
 break;
 
 case UA_AM_ACCEPTED:
 // check currentCommandID before start or reject 
 
 bool canActionPerform = m_CurrentActionData.m_Action.Can(m_Player, m_CurrentActionData.m_Target, m_CurrentActionData.m_MainItem);
 if (canActionPerform && ActionPossibilityCheck(currentCommandID))
 {
 m_CurrentActionData.m_State = UA_START;
 m_CurrentActionData.m_Action.Start(m_CurrentActionData);
 
 if (m_CurrentActionData.m_Action && m_CurrentActionData.m_Action.IsInstant())
 OnActionEnd();
 }
 else
 {
 Interrupt();
 }
 m_PendingActionAcknowledgmentID = -1;
 break;
 
 case UA_AM_REJECTED:
 OnActionEnd();
 m_PendingActionAcknowledgmentID = -1;
 break;
 
 default:
 if (m_ActionInputWantEnd)
 {
 m_ActionInputWantEnd = false;
 m_CurrentActionData.m_Action.EndInput(m_CurrentActionData);
 }
 
 if (m_ActionWantEndRequest)
 {
 m_ActionWantEndRequest = false;
 m_CurrentActionData.m_Action.EndRequest(m_CurrentActionData);
 }
 break;
 }
 }
 }
 
 override void Interrupt()
 {
 super.Interrupt();
 
 if (m_CurrentActionData)
 DayZPlayerSyncJunctures.SendActionInterrupt(m_Player);
 }
 
 override ActionReciveData GetReciveData()
 {
 return m_PendingActionReciveData;
 }
}