actioninput.c

Go to the documentation of this file.

enum ActionInputType
{
 AIT_CONTINUOUS, //React to hold input and release after it
 AIT_SINGLE, //React to click input - single use actions
 AIT_DOUBLECLICK, //React to double click input - single use actions
 AIT_HOLDSINGLE, //React to hold input - single use actions
 AIT_CLICKCONTINUOUS, //React to click input for start and click for end
 AIT_NOINPUTCONTROL,
 AIT_INVENTORYINPUT, //Inventory specific actions
}
 
class ForcedActionData
{
 ActionBase m_Action;
 ref ActionTarget m_Target;
 ItemBase m_Item;
}
 
class ActionInput : ActionInput_Basic
{
 UAIDWrapper m_input; //Input ID automaticly generated from name.
 int m_InputType; //Use from action manager for handling input
 int m_Priority;
 bool m_DetectFromItem; //Can be used action from item in hands?
 bool m_DetectFromTarget; //Can be used action from target in vicinity?
 bool m_DetectFromPlayer; //Can be used action from player?
 bool m_Enabled;
 bool m_JustActivate;
 bool m_HasTarget;
 
 PlayerBase m_Player;
 
 ref ActionTarget m_ForcedTarget;
 
 ref ForcedActionData m_ForcedActionData;
 
 ref ActionTarget m_Target;
 ItemBase m_MainItem;
 int m_ConditionMask;
 
 bool m_Active;
 
 void ActionInput()
 {
 m_Active = false;
 m_Enabled = true;
 m_ForcedTarget = null;
 m_ForcedActionData = null;
 
 m_HasTarget = false;
 
 m_JustActivate = false;
 m_DetectFromTarget = false;
 m_DetectFromItem = true;
 m_DetectFromPlayer = true;
 
 m_Priority = 100;
 }
 
 void Init(PlayerBase player, ActionManagerClient am)
 {
 m_Player = player;
 
 if ( LogManager.IsActionLogEnable())
 {
 Debug.ActionLog("n/a",this.ToString(), "n/a","Init()", player.ToString());
 }
 
 }
 
 void SetEnablity(bool value)
 {
 m_Enabled = value;
 }
 
 protected void SetInput(string input_name)
 {
 m_input = GetUApi().GetInputByName(input_name).GetPersistentWrapper();
 
 if ( LogManager.IsActionLogEnable())
 {
 if (m_input && m_input.InputP())
 Debug.ActionLog("(+) input set to " + input_name ,this.ToString(), "n/a","SetInput()", "n/a");
 else
 Debug.ActionLog("(-) input is not set to " + input_name ,this.ToString(), "n/a","SetInput()","n/a");
 }
 }
 
 int GetInputType()
 {
 return m_InputType;
 }
 
 UAInput GetUAInput()
 {
 return m_input.InputP();
 }
 
 bool JustActivate()
 {
 return m_JustActivate;
 }
 
 bool IsActive()
 {
 return m_Active;
 }
 
 bool WasEnded()
 {
 return !m_Active;
 }
 
 void Update()
 {
 if( !m_Enabled )
 {
 m_Active = false;
 m_JustActivate = false;
 return;
 }
 
 switch ( m_InputType )
 {
 case ActionInputType.AIT_CONTINUOUS:
 m_JustActivate = false;
 if(m_Active)
 {
 m_Active = m_input.InputP().LocalHold();
 }
 else
 {
 m_Active = m_input.InputP().LocalHoldBegin();
 m_JustActivate = m_Active;
 }
 break;
 case ActionInputType.AIT_SINGLE:
 m_Active = m_input.InputP().LocalClick();
 m_JustActivate = m_Active;
 break;
 case ActionInputType.AIT_DOUBLECLICK:
 m_Active = m_input.InputP().LocalDoubleClick();
 m_JustActivate = m_Active;
 break;
 break;
 case ActionInputType.AIT_HOLDSINGLE:
 m_Active = m_input.InputP().LocalHoldBegin();
 m_JustActivate = m_Active;
 break;
 break;
 case ActionInputType.AIT_CLICKCONTINUOUS:
 m_JustActivate = false;
 if(m_Active)
 {
 if ( m_input.InputP().LocalClick() )
 {
 m_Active = false;
 }
 }
 else
 {
 m_Active = m_input.InputP().LocalClick();
 m_JustActivate = m_Active;
 }
 break;
 break;
 default:
 break;
 }
 }
 
 void Reset()
 {
 m_Active = false;
 ActionsSelectReset();
 }
 
 void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
 { 
 }
 
 ActionBase GetAction()
 {
 return NULL;
 }
 
 ActionTarget GetUsedActionTarget()
 {
 return m_Target;
 }
 
 ItemBase GetUsedMainItem()
 {
 return m_MainItem;
 }
 
 array<ActionBase> GetPossibleActions()
 {
 return NULL;
 }
 
 ActionBase GetPossibleAction()
 {
 return NULL;
 }
 
 int GetPossibleActionIndex()
 {
 return -1;
 }
 
 bool HasTarget()
 {
 return false;
 }
 
 void OnActionStart()
 {
 ActionsSelectReset();
 }
 
 void OnActionEnd()
 {
 Reset();
 }
 
 void ActionsSelectReset()
 {}
 
 void ForceAction(ActionBase action, ActionTarget target, ItemBase item )
 {
 m_ForcedActionData = new ForcedActionData;
 m_ForcedActionData.m_Action = action;
 m_ForcedActionData.m_Target = target;
 m_ForcedActionData.m_Item = item;
 }
 
 void ForceActionTarget( ActionTarget target )
 {
 m_ForcedTarget = target;
 }
 
 void ClearForcedAction()
 {
 m_ForcedActionData = null;
 }
 
 void ClearForcedTarget()
 {
 m_ForcedTarget = NULL;
 }
 
 bool ForceActionCheck(PlayerBase player)
 {
 if (m_ForcedActionData)
 {
 if (m_ForcedActionData.m_Action.Can(player, m_ForcedActionData.m_Target, m_ForcedActionData.m_Item))
 {
 m_MainItem = m_ForcedActionData.m_Item;
 m_Target = m_ForcedActionData.m_Target;
 return true;
 }
 }
 return false;
 }
 
 void SelectNextAction()
 {
 }
 
 void SelectPrevAction()
 {}
 
 int GetPossibleActionsCount()
 {
 return -1;
 }
 
 bool HasInput()
 {
 return m_input != NULL;
 }
 
 int GetPriority()
 {
 return m_Priority;
 }
}
 
class StandardActionInput : ActionInput
{
 ref array<ActionBase> m_SelectActions;
 int m_selectedActionIndex;
 
 void StandardActionInput(PlayerBase player)
 {
 m_selectedActionIndex = 0;
 m_SelectActions = new array<ActionBase>;
 }
 
 override void ForceAction(ActionBase action, ActionTarget target, ItemBase item )
 {
 super.ForceAction(action, target, item);
 
 m_selectedActionIndex = 0;
 }
 
 void _GetSelectedActions( Object action_source_object, out array<ActionBase> select_actions_all, out bool has_any_action_target)
 {
 if ( !action_source_object )
 return;
 
 array<ActionBase_Basic> possible_actions;
 array<ref ActionBase> variant_actions;
 action_source_object.GetActions(this.Type(), possible_actions);
 ActionBase action;
 
 if(possible_actions)
 {
 for (int i = 0; i < possible_actions.Count(); i++)
 {
 action = ActionBase.Cast(possible_actions.Get(i));
 
 if ( action.HasVariants() )
 {
 action.UpdateVariants( m_MainItem, m_Target.GetObject(), m_Target.GetComponentIndex() );
 action.GetVariants( variant_actions);
 for (int j = 0; j < variant_actions.Count(); j++)
 {
 action = variant_actions[j];
 if ( action.Can(m_Player, m_Target, m_MainItem, m_ConditionMask) )
 {
 select_actions_all.Insert(action);
 if (action.HasTarget())
 has_any_action_target = true;
 }
 }
 }
 else
 {
 if ( action.Can(m_Player, m_Target, m_MainItem, m_ConditionMask) )
 {
 select_actions_all.Insert(action);
 if (action.HasTarget())
 has_any_action_target = true;
 }
 }
 }
 }
 }
 
 override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
 {
 if ( ForceActionCheck(player))
 {
 m_SelectActions.Clear();
 m_SelectActions.Insert(m_ForcedActionData.m_Action);
 return;
 }
 
 if(m_ForcedTarget)
 {
 target = m_ForcedTarget;
 }
 
 array<ActionBase> select_actions_all = new array<ActionBase>;
 int i, last_index;
 bool change = false;
 m_HasTarget = false;
 
 m_MainItem = item;
 m_Target = target;
 m_ConditionMask = action_condition_mask;
 
 
 if( m_DetectFromItem )
 {
 _GetSelectedActions( item, select_actions_all, m_HasTarget);
 }
 
 
 if( m_DetectFromTarget )
 { 
 _GetSelectedActions( target.GetObject(), select_actions_all, m_HasTarget);
 _GetSelectedActions( target.GetParent(), select_actions_all, m_HasTarget);
 }
 
 if( m_DetectFromPlayer )
 {
 _GetSelectedActions( player, select_actions_all, m_HasTarget);
 }
 
 if ( select_actions_all.Count() )
 {
 last_index = 0;
 for ( i = 0; i < select_actions_all.Count(); i++ )
 {
 ActionBase action = select_actions_all[i];
 if ( m_HasTarget )
 {
 if ( action.HasTarget() )
 {
 if ( m_SelectActions.Count() > last_index )
 {
 if ( m_SelectActions[last_index] != action )
 {
 change = true;
 m_SelectActions[last_index] = action;
 }
 }
 else
 {
 change = true;
 m_SelectActions.Insert(action);
 }
 action.OnActionInfoUpdate(player, target, item);
 last_index++;
 }
 }
 else
 {
 if ( m_SelectActions.Count() > last_index )
 {
 if ( m_SelectActions[last_index] != action )
 {
 change = true;
 m_SelectActions[last_index++] = action;
 }
 }
 else
 {
 change = true;
 m_SelectActions.Insert(action);
 }
 action.OnActionInfoUpdate(player, target, item);
 last_index++;
 }
 }
 }
 else
 {
 m_selectedActionIndex = 0;
 m_SelectActions.Clear();
 }
 
 if (m_SelectActions.Count() > last_index)
 {
 change = true;
 for (i = last_index; i < m_SelectActions.Count(); i++)
 {
 m_SelectActions.Remove(last_index);
 }
 }
 
 if ( change )
 {
 m_selectedActionIndex = 0;
 m_Player.GetActionManager().SelectFirstActionCategory();
 }
 }
 
 override array<ActionBase> GetPossibleActions()
 {
 return m_SelectActions;
 }
 
 override int GetPossibleActionsCount()
 {
 return m_SelectActions.Count();
 }
 
 override bool HasTarget()
 {
 return m_HasTarget;
 }
 
 override int GetPossibleActionIndex()
 {
 return m_selectedActionIndex;
 }
 
 override ActionBase GetAction()
 {
 if (m_SelectActions.Count() > 0)
 return m_SelectActions[m_selectedActionIndex];
 return null;
 }
 
 override void ActionsSelectReset()
 {
 m_SelectActions.Clear();
 m_selectedActionIndex = 0;
 }
 
 override void SelectNextAction()
 {
 if(m_SelectActions.Count())
 {
 m_selectedActionIndex++;
 if(m_SelectActions.Count() <= m_selectedActionIndex )
 {
 m_selectedActionIndex = 0;
 }
 }
 }
 
 override void SelectPrevAction()
 {
 if(m_SelectActions.Count())
 {
 m_selectedActionIndex--;
 if(0 > m_selectedActionIndex )
 {
 m_selectedActionIndex = m_SelectActions.Count() - 1;
 }
 }
 }
 
}
 
class ContinuousInteractActionInput : StandardActionInput
{
 void ContinuousInteractActionInput(PlayerBase player)
 {
 SetInput("UAAction");
 m_Priority = 60;
 m_InputType = ActionInputType.AIT_CONTINUOUS;
 m_DetectFromTarget = true;
 m_DetectFromItem = false;
 m_DetectFromPlayer = true;
 }
};
 
class InteractActionInput : ContinuousInteractActionInput
{
 void InteractActionInput(PlayerBase player)
 {
 m_InputType = ActionInputType.AIT_SINGLE;
 m_Priority = 80;
 }
 
 override void OnActionStart()
 {
 super.OnActionStart();
 m_Active = false;
 }
 
 override bool WasEnded()
 {
 return false;
 }
};
 
class NoIndicationActionInputBase : ActionInput
{
 void NoIndicationActionInputBase(PlayerBase player)
 {
 m_DetectFromTarget = false;
 }
 
 override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
 {
 m_MainItem = item;
 m_Target = target;
 m_ConditionMask = action_condition_mask;
 }
 
 override ActionBase GetAction()
 {
 if ( ForceActionCheck(m_Player) )
 return m_ForcedActionData.m_Action;
 
 if(m_MainItem)
 {
 array<ActionBase_Basic> possible_actions;
 ActionBase action;
 
 m_MainItem.GetActions(this.Type(), possible_actions);
 if(possible_actions)
 {
 for (int i = 0; i < possible_actions.Count(); i++)
 {
 action = ActionBase.Cast(possible_actions.Get(i));
 if ( action.Can(m_Player, m_Target, m_MainItem, m_ConditionMask) )
 {
 return action;
 }
 }
 }
 
 }
 return NULL;
 }
 
 override ActionBase GetPossibleAction()
 {
 return GetAction();
 }
}
 
 
 
class ContinuousDefaultActionInput : StandardActionInput
{
 protected ActionBase m_SelectAction; //Do nothing only for back compatibilit, relevant only for inherited class
 void ContinuousDefaultActionInput(PlayerBase player)
 {
 SetInput("UADefaultAction");
 m_InputType = ActionInputType.AIT_CONTINUOUS;
 m_Priority = 20;
 m_DetectFromTarget = false;
 m_DetectFromItem = true;
 m_DetectFromPlayer = true;
 
 m_SelectAction = null;
 }
 
 override ActionBase GetPossibleAction()
 {
 return m_SelectAction;
 }
 
 override void ActionsSelectReset()
 {
 super.ActionsSelectReset();
 m_SelectAction = NULL;
 }
};
 
class DefaultActionInput : ContinuousDefaultActionInput
{
 void DefaultActionInput(PlayerBase player)
 {
 m_InputType = ActionInputType.AIT_SINGLE;
 m_Priority = 40;
 }
 
 override void OnActionStart()
 {
 super.OnActionStart();
 m_Active = false;
 }
 
 override bool WasEnded()
 {
 return false;
 }
};
 
class DropActionInput : NoIndicationActionInputBase
{
 void DropActionInput(PlayerBase player)
 {
 SetInput("UADropitem");
 m_InputType = ActionInputType.AIT_HOLDSINGLE;
 }
};
 
class CarHornShortActionInput : ContinuousDefaultActionInput
{
 ref ActionTarget targetNew;
 
 void CarHornShortActionInput(PlayerBase player)
 {
 SetInput("UACarHorn");
 m_InputType = ActionInputType.AIT_SINGLE;
 m_Priority = 100;
 m_DetectFromItem = false;
 m_DetectFromTarget = false;
 m_DetectFromPlayer = false;
 }
 
 override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
 {
 if (ForceActionCheck(player))
 {
 m_SelectAction = m_ForcedActionData.m_Action;
 return;
 }
 
 m_SelectAction = null;
 array<ActionBase_Basic> possibleActions;
 ActionBase action;
 int i;
 
 m_MainItem = null;
 if (player && player.IsInVehicle())
 {
 HumanCommandVehicle vehCommand = player.GetCommand_Vehicle();
 if (vehCommand)
 {
 Transport trans = vehCommand.GetTransport();
 if (trans)
 {
 targetNew = new ActionTarget(trans, null, -1, vector.Zero, -1);
 ForceActionTarget(targetNew);
 }
 }
 
 if (!targetNew)
 {
 ClearForcedTarget();
 }
 }
 
 target = m_ForcedTarget;
 m_Target = m_ForcedTarget;
 
 if (target && target.GetObject())
 {
 target.GetObject().GetActions(this.Type(), possibleActions);
 if (possibleActions)
 {
 for (i = 0; i < possibleActions.Count(); i++)
 {
 action = ActionBase.Cast(possibleActions.Get(i));
 if (action.Can(player, target, m_MainItem, action_condition_mask))
 {
 m_SelectAction = action;
 return;
 }
 }
 }
 }
 }
 
 override ActionBase GetAction()
 {
 return m_SelectAction;
 }
}
 
class CarHornLongActionInput : CarHornShortActionInput
{
 void CarHornLongActionInput(PlayerBase player)
 {
 SetInput("UACarHorn");
 m_InputType = ActionInputType.AIT_CONTINUOUS;
 m_Priority = 101;
 m_DetectFromItem = false;
 m_DetectFromTarget = false;
 m_DetectFromPlayer = false;
 }
}
 
class ToggleLightsActionInput : DefaultActionInput
{
 ref ActionTarget target_new;
 
 void ToggleLightsActionInput(PlayerBase player)
 {
 SetInput("UAToggleHeadlight");
 m_InputType = ActionInputType.AIT_SINGLE;
 m_Priority = 100;
 }
 
 override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
 {
 if( ForceActionCheck(player) )
 {
 m_SelectAction = m_ForcedActionData.m_Action;
 return;
 }
 //ForceActionTarget(player.m_PlayerLightManager.
 
 m_SelectAction = NULL;
 array<ActionBase_Basic> possible_actions;
 ActionBase action;
 int i;
 
 m_MainItem = NULL;
 if ( player && !player.IsInVehicle() ) 
 {
 Clothing headgear = Clothing.Cast(player.FindAttachmentBySlotName("Headgear"));
 Clothing eyewear = Clothing.Cast(player.FindAttachmentBySlotName("Eyewear"));
 //TODO - extend this to allow for a switchable control over all possible light sources (depth 0 or 1 only?)
 
 if ( headgear && headgear.GetLightSourceItem() )
 {
 target_new = new ActionTarget(headgear, null, -1, vector.Zero, -1);
 ForceActionTarget(target_new);
 }
 else if ( eyewear && eyewear.GetLightSourceItem() )
 {
 target_new = new ActionTarget(eyewear, null, -1, vector.Zero, -1);
 ForceActionTarget(target_new);
 }
 else
 ClearForcedTarget();
 }
 else if ( player && player.IsInVehicle() )
 {
 HumanCommandVehicle vehCommand = player.GetCommand_Vehicle();
 if( vehCommand )
 {
 Transport trans = vehCommand.GetTransport();
 if( trans )
 {
 target_new = new ActionTarget(trans, null, -1, vector.Zero, -1);
 ForceActionTarget(target_new);
 }
 }
 
 if ( !target_new )
 ClearForcedTarget();
 }
 
 target = m_ForcedTarget;
 m_Target = m_ForcedTarget;
 
 if(target && target.GetObject())
 {
 target.GetObject().GetActions(this.Type(), possible_actions);
 if(possible_actions)
 {
 for (i = 0; i < possible_actions.Count(); i++)
 {
 action = ActionBase.Cast(possible_actions.Get(i));
 if ( action.Can(player, target, m_MainItem, action_condition_mask) )
 {
 m_SelectAction = action;
 return;
 }
 }
 }
 }
 }
 
 override ActionBase GetAction()
 {
 return m_SelectAction;
 }
};
 
class ToggleNVGActionInput : DefaultActionInput
{
 ref ActionTarget target_new;
 
 void ToggleNVGActionInput(PlayerBase player)
 {
 SetInput("UAToggleNVG");
 m_InputType = ActionInputType.AIT_HOLDSINGLE;
 m_Priority = 100;
 }
 
 override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
 {
 if( ForceActionCheck(player) )
 {
 m_SelectAction = m_ForcedActionData.m_Action;
 return;
 }
 //ForceActionTarget(player.m_PlayerLightManager.
 
 m_SelectAction = NULL;
 array<ActionBase_Basic> possible_actions;
 ActionBase action;
 int i;
 
 m_MainItem = NULL;
 if ( player ) 
 {
 Mich2001Helmet helmet = Mich2001Helmet.Cast(player.FindAttachmentBySlotName("Headgear"));
 NVGHeadstrap headstrap = NVGHeadstrap.Cast(player.FindAttachmentBySlotName("Eyewear"));
 if ( helmet )
 {
 //m_MainItem = Headtorch_ColorBase.Cast(player.FindAttachmentBySlotName("Headgear"));
 target_new = new ActionTarget(helmet, null, -1, vector.Zero, -1);
 ForceActionTarget(target_new);
 }
 else if ( headstrap )
 {
 target_new = new ActionTarget(headstrap, null, -1, vector.Zero, -1);
 ForceActionTarget(target_new);
 }
 else
 ClearForcedTarget();
 }
 
 target = m_ForcedTarget;
 m_Target = m_ForcedTarget;
 
 if(target && target.GetObject())
 {
 target.GetObject().GetActions(this.Type(), possible_actions);
 if(possible_actions)
 {
 for (i = 0; i < possible_actions.Count(); i++)
 {
 action = ActionBase.Cast(possible_actions.Get(i));
 if ( action.Can(player, target, m_MainItem, action_condition_mask) )
 {
 m_SelectAction = action;
 return;
 }
 }
 }
 }
 }
 
 override ActionBase GetAction()
 {
 return m_SelectAction;
 }
};
 
class ContinuousWeaponManipulationActionInput : NoIndicationActionInputBase
{
 void ContinuousWeaponManipulationActionInput(PlayerBase player)
 {
 SetInput("UAReloadMagazine");
 m_InputType = ActionInputType.AIT_CONTINUOUS;
 }
};
 
class WeaponManipulationActionInput : NoIndicationActionInputBase
{ 
 void WeaponManipulationActionInput(PlayerBase player)
 {
 SetInput("UAReloadMagazine");
 m_InputType = ActionInputType.AIT_SINGLE;
 }
};
 
class ExternalControlledActionInput : NoIndicationActionInputBase
{ 
 void ExternalControlledActionInput(PlayerBase player)
 {
 //SetInput("UAReloadMagazine");
 m_InputType = ActionInputType.AIT_NOINPUTCONTROL;
 }
};
 
class InventoryOnlyActionInput : NoIndicationActionInputBase
{ 
 void InventoryOnlyActionInput(PlayerBase player)
 {
 //SetInput("UAReloadMagazine");
 m_InputType = ActionInputType.AIT_INVENTORYINPUT;
 }
};
 
class QuickaBarActionInput : ExternalControlledActionInput
{ 
};