ActionInput.c

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
		{
			change = true;
			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;
		}
		
		m_SelectAction = null;
		array<ActionBase_Basic> possible_actions;
		ActionBase action;
		int i;

		m_MainItem = null;
		if (player) 
		{
			CachedEquipmentStorageQuery query = new CachedEquipmentStorageQuery();
			query.m_Category = ECachedEquipmentItemCategory.NVG;
			query.m_Placement = ECachedEquipmentPlacement.ATTACHMENT;
			query.m_MaximumDepth = 2;
			
			array<Entity> nvgs = player.GetCachedEquipment().GetEntitiesByCategory(query);
			Object nvgParent = null;
			foreach (Entity nvg : nvgs)
			{
				nvgParent = EntityAI.Cast(nvg).GetHierarchyParent();
				break;
			}

			if (nvgParent)
			{
				target_new = new ActionTarget(nvgParent, 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
{	
};