actionbase.c

Go to the documentation of this file.

enum ActionConditionMask
{
 ACM_NO_EXEPTION = 0,
 ACM_IN_VEHICLE = 1,
 ACM_ON_LADDER = 2,
 ACM_SWIMMING = 4,
 ACM_RESTRAIN = 8,
 ACM_RAISED = 16,
 ACM_ON_BACK = 32,
 ACM_THROWING = 64,
 ACM_LEANING = 128,
 ACM_BROKEN_LEGS = 256,
}
class ActionReciveData
{
 ItemBase m_MainItem;
 ref ActionTarget m_Target;
}
 
class ActionData
{
 void ActionData()
 {
 m_State = UA_NONE;
 }
 
 ref ActionBase m_Action;
 ItemBase m_MainItem;
 ActionBaseCB m_Callback;
 ref CABase m_ActionComponent;
 int m_State;
 ref ActionTarget m_Target;
 PlayerBase m_Player;
 int m_PossibleStanceMask;
 ref array<ref InventoryLocation> m_ReservedInventoryLocations;
 int m_RefreshReservationTimer;
 int m_RefreshJunctureTimer;
 bool m_WasExecuted;
 bool m_WasActionStarted;
 bool m_ReciveEndInput;
}
 
class ActionBase : ActionBase_Basic
{ 
 //STATIC DATA
 protected int m_RefreshReservationTimerValue = 140;
 // Configurable action parameters
 protected string m_Sound; //sound played at the beggining of action
 protected string m_Text;
 
 protected bool m_LockTargetOnUse; //this parameter sets wheter player can perform actions on target while other player is already performing action on it. defaulted as true
 protected bool m_FullBody; //tells whether action is full body or additive
 protected int m_StanceMask;
 protected ref TStringArray m_Sounds; //User action sound is picked from this array randomly
 ref CCIBase m_ConditionItem; //Condition Component
 ref CCTBase m_ConditionTarget; //Condition Component
 protected ActionInput m_Input;
 protected int m_ActionID;
 protected int m_VariantID;
 int m_ConditionMask;
 protected ref ActionVariantManager m_VariantManager;
 
 //RUNTIME DATA
 protected ref Param1<string> m_MessageParam; //used for passing messages from server to client
 //protected ref Param2<int,int> m_MessagesParam;
 
 //SOFT SKILLS
 protected float m_SpecialtyWeight;
 
 //-----------------------------------------------------
 // Action events and methods
 //-----------------------------------------------------
 void ActionBase() 
 {
 // definable
 m_StanceMask = DayZPlayerConstants.STANCEMASK_ERECT | DayZPlayerConstants.STANCEMASK_CROUCH | DayZPlayerConstants.STANCEMASK_PRONE;
 m_FullBody = false;
 m_Sound = "";
 m_Text = "default action text";
 m_LockTargetOnUse = HasTarget();
 // dont override
 m_MessageParam = new Param1<string>("");
 //m_MessagesParam = new Param2<int,int>(0,0);
 m_Sounds = new TStringArray;
 m_Input = null;
 m_ActionID = 0;
 InitConditionMask();
 }
 
 bool IsLockTargetOnUse()
 {
 return m_LockTargetOnUse;
 }
 
 void InitConditionMask()
 {
 m_ConditionMask = ActionConditionMask.ACM_NO_EXEPTION;
 if (CanBeUsedInVehicle())
 {
 m_ConditionMask |= ActionConditionMask.ACM_IN_VEHICLE;
 }
 
 if (CanBeUsedOnLadder())
 {
 m_ConditionMask |= ActionConditionMask.ACM_ON_LADDER;
 }
 
 if (CanBeUsedSwimming())
 {
 m_ConditionMask |= ActionConditionMask.ACM_SWIMMING;
 }
 
 if (CanBeUsedInRestrain())
 {
 m_ConditionMask |= ActionConditionMask.ACM_RESTRAIN;
 }
 
 if (CanBeUsedRaised())
 {
 m_ConditionMask |= ActionConditionMask.ACM_RAISED;
 }
 
 if (CanBeUsedOnBack())
 {
 m_ConditionMask |= ActionConditionMask.ACM_ON_BACK;
 }
 
 if (CanBeUsedThrowing())
 {
 m_ConditionMask |= ActionConditionMask.ACM_THROWING;
 }
 
 if (CanBeUsedLeaning())
 {
 m_ConditionMask |= ActionConditionMask.ACM_LEANING;
 }
 
 if (CanBeUsedWithBrokenLegs())
 {
 m_ConditionMask |= ActionConditionMask.ACM_BROKEN_LEGS;
 }
 }
 
 bool SetupAction(PlayerBase player, ActionTarget target, ItemBase item, out ActionData action_data, Param extra_data = NULL )
 {
 action_data = CreateActionData();
 action_data.m_Action = this;
 action_data.m_Player = player;
 action_data.m_Target = target;
 action_data.m_MainItem = item;
 action_data.m_PossibleStanceMask = GetStanceMask(player);
 action_data.m_ReservedInventoryLocations = new array<ref InventoryLocation>;
 action_data.m_RefreshReservationTimer = m_RefreshReservationTimerValue;
 action_data.m_WasExecuted = false;
 action_data.m_WasActionStarted = false;
 action_data.m_ReciveEndInput = false;
 
 ActionReciveData action_recive_data = player.GetActionManager().GetReciveData();
 if ( action_recive_data )
 {
 HandleReciveData(action_recive_data,action_data);
 
 if ( UseMainItem() && MainItemAlwaysInHands() )
 {
 if ( player.GetItemInHands() != action_data.m_MainItem )
 {
 return false;
 }
 }
 }
 
 if ( !Post_SetupAction( action_data ) )
 return false;
 
 if ( (!GetGame().IsDedicatedServer()) && !IsInstant() )
 {
 if (!InventoryReservation(action_data))
 {
 ClearInventoryReservationEx(action_data);
 return false;
 }
 
 if ( LogManager.IsActionLogEnable() )
 {
 for ( int i = 0; i < action_data.m_ReservedInventoryLocations.Count(); i++)
 {
 Debug.ActionLog( InventoryLocation.DumpToStringNullSafe( action_data.m_ReservedInventoryLocations[i] ), action_data.m_Action.ToString() , "n/a", "LockInventoryList", action_data.m_Player.ToString() );
 }
 }
 }
 
 return true;
 }
 
 bool Post_SetupAction( ActionData action_data )
 {
 return true;
 }
 
 void ActionCleanup( ActionData action_data )
 {}
 
 typename GetInputType()
 {
 return DefaultActionInput;
 }
 
 void SetInput( ActionInput ai)
 {
 m_Input = ai;
 }
 
 ActionData CreateActionData()
 {
 return new ActionData;
 }
 
 void CreateConditionComponents() //Instantiates components, called once from ActionManager on actions construction
 {
 m_ConditionItem = new CCIDummy;
 m_ConditionTarget = new CCTDummy;
 }
 
 Object GetDisplayInteractObject(PlayerBase player, ActionTarget target)
 {
 return null;
 }
 
 bool HasTarget()
 {
 return true;
 }
 
 bool HasProgress()
 {
 return true;
 }
 
 //Action isn't synchronize to server 
 bool IsLocal()
 {
 return false;
 }
 
 //Action not using animation/callback action are executed instantly (OnStart)
 bool IsInstant()
 {
 return false;
 }
 
 bool IsUsingProxies()
 {
 return false;
 }
 
 bool RemoveForceTargetAfterUse()
 {
 return true;
 }
 
 int GetActionCategory()
 {
 return AC_UNCATEGORIZED;
 }
 
 bool IsEat()
 {
 return false;
 }
 
 bool IsDrink()
 {
 return false;
 }
 
 bool IsShaveSelf()
 {
 return false;
 }
 
 string GetText() //text game displays in HUD hint 
 {
 return m_Text;
 }
 
 bool CanBePerformedFromQuickbar()
 {
 return false;
 }
 
 bool CanBePerformedFromInventory()
 {
 return false;
 }
 
 bool CanBeSetFromInventory()
 {
 return !CanBePerformedFromInventory();
 }
 
 bool CanBeUsedInRestrain()
 {
 return false;
 }
 
 bool CanBeUsedInVehicle()
 {
 return false;
 }
 
 bool CanBeUsedOnBack()
 {
 return false;
 }
 
 bool CanBeUsedSwimming()
 {
 return false;
 }
 
 bool CanBeUsedOnLadder()
 {
 return false;
 }
 
 bool CanBeUsedRaised()
 {
 return false;
 }
 
 bool CanBeUsedThrowing()
 {
 return false;
 }
 
 bool CanBeUsedLeaning()
 {
 return true;
 }
 
 bool CanBeUsedWithBrokenLegs()
 {
 return true;
 }
 
 bool IsDeploymentAction()
 {
 return false;
 }
 
 bool UseMainItem()
 {
 return true;
 }
 
 bool MainItemAlwaysInHands()
 {
 return true;
 }
 
 protected bool ActionConditionContinue( ActionData action_data ) //condition for action
 {
 return ActionCondition(action_data.m_Player,action_data.m_Target,action_data.m_MainItem);
 }
 
 protected bool ActionCondition( PlayerBase player, ActionTarget target, ItemBase item ) //condition for action
 {
 return true;
 }
 
 void ApplyModifiers(ActionData action_data);
 
 int GetRefreshReservationTimerValue()
 {
 return m_RefreshReservationTimerValue;
 }
 
 void WriteToContext(ParamsWriteContext ctx, ActionData action_data)
 {
 int componentIndex = -1;
 int proxyBoneIdx = -1;
 vector cursorHitPos = vector.Zero;
 
 array<string> selectionNames = new array<string>();
 
 Object targetObject = null;
 Object targetParent = null;
 
 if (UseMainItem())
 {
 ctx.Write(action_data.m_MainItem);
 }
 
 if (HasTarget() && !IsUsingProxies())
 {
 // callback data
 targetObject = action_data.m_Target.GetObject();
 ctx.Write(targetObject);
 targetParent = action_data.m_Target.GetParent();
 ctx.Write(targetParent);
 componentIndex = action_data.m_Target.GetComponentIndex();
 ctx.Write(componentIndex);
 cursorHitPos = action_data.m_Target.GetCursorHitPos();
 ctx.Write(cursorHitPos);
 }
 else if( HasTarget() && IsUsingProxies() )
 {
 Entity entParent = Entity.Cast(action_data.m_Target.GetParent());
 if (entParent)
 {
 action_data.m_Target.GetObject().GetActionComponentNameList(action_data.m_Target.GetComponentIndex(), selectionNames);
 for (int s = 0; s < selectionNames.Count(); s++)
 {
 proxyBoneIdx = entParent.GetBoneIndex(selectionNames[s]);
 if( proxyBoneIdx > -1 )
 {
 break;
 }
 }
 }
 
 ctx.Write(proxyBoneIdx);
 targetParent = action_data.m_Target.GetParent();
 ctx.Write(targetParent);
 componentIndex = action_data.m_Target.GetComponentIndex();
 ctx.Write(componentIndex);
 cursorHitPos = action_data.m_Target.GetCursorHitPos();
 ctx.Write(cursorHitPos);
 }
 }
 
 bool ReadFromContext(ParamsReadContext ctx, out ActionReciveData action_recive_data )
 {
 if ( !action_recive_data )
 {
 action_recive_data = new ActionReciveData;
 }
 Object actionTargetObject = null;
 Object actionTargetParent = null;
 int componentIndex = -1;
 int proxyBoneIdx = -1;
 vector cursorHitPos = vector.Zero;
 ItemBase mainItem = null;
 
 ref ActionTarget target;
 
 if ( UseMainItem() )
 {
 if ( !ctx.Read(mainItem) )
 return false;
 }
 
 if ( HasTarget() && !IsUsingProxies() )
 { 
 if ( !ctx.Read(actionTargetObject) )
 return false;
 
 if ( !ctx.Read(actionTargetParent))
 return false;
 
 if ( !ctx.Read(componentIndex) )
 return false;
 
 if ( !ctx.Read(cursorHitPos) )
 return false;
 
 target = new ActionTarget(actionTargetObject, actionTargetParent, componentIndex, cursorHitPos, 0);
 
 action_recive_data.m_Target = target;
 }
 else if( HasTarget() && IsUsingProxies() )
 {
 if ( !ctx.Read(proxyBoneIdx) )
 return false;
 
 if ( !ctx.Read(actionTargetParent))
 return false;
 
 if ( !ctx.Read(componentIndex) )
 return false;
 
 if ( !ctx.Read(cursorHitPos) )
 return false;
 
 if ( proxyBoneIdx > -1 )
 {
 Entity entParent = Entity.Cast(actionTargetParent);
 
 if (entParent)
 {
 actionTargetObject = entParent.GetBoneObject(proxyBoneIdx); 
 }
 }
 else
 {
 return false;
 }
 
 target = new ActionTarget(actionTargetObject, actionTargetParent, componentIndex, cursorHitPos, 0);
 
 action_recive_data.m_Target = target;
 }
 
 action_recive_data.m_MainItem = mainItem;
 return true;
 }
 
 void HandleReciveData(ActionReciveData action_recive_data, ActionData action_data)
 {
 action_data.m_MainItem = action_recive_data.m_MainItem;
 
 if(HasTarget())
 {
 if (action_recive_data.m_Target)
 {
 action_data.m_Target = action_recive_data.m_Target;
 }
 else
 {
 Error("Action target not created.");
 action_data.m_Target = new ActionTarget(NULL, NULL, -1, vector.Zero, 0);
 }
 }
 }
 
 //----------------------------------------------------------------------------------------------
 // Core methods don't override unless you know what you are doing
 //---------------------------------------------------------------------------------------------- 
 // COMMANDS ----------------------------------------------------------------------- 
 protected int GetStanceMask(PlayerBase player)
 {
 if ( HasProneException() )
 {
 if ( player.IsPlayerInStance(DayZPlayerConstants.STANCEMASK_RAISEDERECT | DayZPlayerConstants.STANCEMASK_RAISEDCROUCH | DayZPlayerConstants.STANCEMASK_RAISEDPRONE))
 return -1;
 else if ( player.IsPlayerInStance(DayZPlayerConstants.STANCEMASK_CROUCH | DayZPlayerConstants.STANCEMASK_ERECT))
 return DayZPlayerConstants.STANCEMASK_CROUCH | DayZPlayerConstants.STANCEMASK_ERECT;
 else
 return DayZPlayerConstants.STANCEMASK_PRONE;
 }
 return m_StanceMask;
 }
 
 bool IsFullBody(PlayerBase player)
 {
 if ( HasProneException() )
 {
 return !( player.IsPlayerInStance(DayZPlayerConstants.STANCEMASK_CROUCH | DayZPlayerConstants.STANCEMASK_ERECT) );
 }
 return m_FullBody;
 }
 
 // if it is set to true if action have special fullbody animation for prone and additive for crouch and erect
 protected bool HasProneException()
 {
 return false;
 }
 
 // ACTION LOGIC -------------------------------------------------------------------
 // called from actionmanager.c
 void Start( ActionData action_data ) //Setup on start of action
 {
 action_data.m_State = UA_START;
 
 if ( LogManager.IsActionLogEnable() )
 {
 Debug.ActionLog("Time stamp: " + action_data.m_Player.GetSimulationTimeStamp(), this.ToString() , "n/a", "OnStart", action_data.m_Player.ToString() );
 }
 
 OnStart(action_data);
 
 if ( GetGame().IsServer() )
 {
 OnStartServer(action_data);
 
 string soundCat = GetSoundCategory(action_data);
 if (soundCat)
 action_data.m_Player.SetSoundCategoryHash(soundCat.Hash());
 }
 else
 {
 OnStartClient(action_data);
 } 
 
 InformPlayers(action_data.m_Player,action_data.m_Target,UA_START);
 }
 
 void End( ActionData action_data )
 {
 if ( action_data.m_Player )
 {
 OnEnd(action_data);
 
 if ( GetGame().IsServer() )
 {
 OnEndServer(action_data);
 }
 else
 {
 OnEndClient(action_data);
 }
 
 action_data.m_Player.GetActionManager().OnActionEnd();
 }
 }
 
 void Interrupt(ActionData action_data)
 {
 End(action_data);
 }
 
 void OnEndInput(ActionData action_data)
 {}
 
 void EndInput(ActionData action_data)
 {
 action_data.m_ReciveEndInput = true;
 OnEndInput(action_data);
 }
 
 void OnEndRequest(ActionData action_data)
 {}
 
 void EndRequest(ActionData action_data)
 {
 OnEndRequest(action_data);
 }
 
 bool CanReceiveAction(ActionTarget target)
 {
 bool result = true;
 PlayerBase target_player = PlayerBase.Cast(target.GetObject());
 
 if (target_player)
 {
 result = !target_player.IsJumpInProgress();
 result = result && !(target_player.GetCommand_Ladder() || target_player.GetCommand_Vehicle() || target_player.GetCommand_Swim());
 }
 
 return result;
 }
 
 static int ComputeConditionMask( PlayerBase player, ActionTarget target, ItemBase item )
 {
 int mask = 0;
 if ( player.GetCommand_Vehicle() )
 {
 mask |= ActionConditionMask.ACM_IN_VEHICLE;
 }
 
 if ( player.GetCommand_Ladder() )
 {
 mask |= ActionConditionMask.ACM_ON_LADDER;
 }
 
 if ( player.IsRestrained() )
 {
 mask |= ActionConditionMask.ACM_RESTRAIN;
 }
 
 if ( player.GetCommand_Swim() )
 {
 mask |= ActionConditionMask.ACM_SWIMMING;
 }
 
 if ( player.IsRaised() )
 {
 mask |= ActionConditionMask.ACM_RAISED;
 }
 
 if ( player.GetCommand_Move() && player.GetCommand_Move().IsOnBack() )
 {
 mask |= ActionConditionMask.ACM_ON_BACK;
 }
 
 if ( player.GetThrowing().IsThrowingModeEnabled())
 {
 mask |= ActionConditionMask.ACM_THROWING;
 }
 
 if (player.IsLeaning())
 {
 mask |= ActionConditionMask.ACM_LEANING;
 }
 
 if (player.GetBrokenLegs() == eBrokenLegs.BROKEN_LEGS)
 {
 mask |= ActionConditionMask.ACM_BROKEN_LEGS;
 }
 
 return mask;
 }
 
 bool Can( PlayerBase player, ActionTarget target, ItemBase item, int condition_mask )
 {
 if ( ( (condition_mask & m_ConditionMask) != condition_mask ) || ( !IsFullBody(player) && !player.IsPlayerInStance(GetStanceMask(player)) ) || player.IsRolling() )
 return false;
 
 if ( HasTarget() )
 {
 if(!FirearmActionBase.Cast(this))
 {
 EntityAI entity = EntityAI.Cast(target.GetObject());
 if ( entity && !target.GetObject().IsMan() )
 {
 Man man = entity.GetHierarchyRootPlayer();
 if ( man && man != player )
 return false;
 }
 }
 
 if ( m_ConditionTarget && !m_ConditionTarget.Can(player, target))
 return false;
 }
 
 if ( m_ConditionItem && !m_ConditionItem.Can(player, item))
 return false;
 
 if ( !ActionCondition(player, target, item) )
 return false;
 
 if ( IsFullBody(player) )
 {
 int stanceIdx = DayZPlayerUtils.ConvertStanceMaskToStanceIdx(GetStanceMask(player));
 if (stanceIdx != -1 && !DayZPlayerUtils.PlayerCanChangeStance(player, stanceIdx ))
 return false;
 }
 
 return true;
 }
 
 bool Can(PlayerBase player, ActionTarget target, ItemBase item)
 {
 int condition_mask = ComputeConditionMask(player, target, item);
 
 return Can( player, target, item, condition_mask);
 }
 
 protected bool CanContinue( ActionData action_data )
 {
 if (!action_data.m_Player.IsPlayerInStance(action_data.m_PossibleStanceMask) || !m_ConditionItem || !m_ConditionItem.CanContinue(action_data.m_Player,action_data.m_MainItem) || !m_ConditionTarget || !m_ConditionTarget.CanContinue(action_data.m_Player,action_data.m_Target))
 return false;
 
 return ActionConditionContinue(action_data);
 }
 
 bool HasVariants()
 {
 return m_VariantManager != null;
 }
 
 int GetVariantsCount()
 {
 if (m_VariantManager)
 return m_VariantManager.GetActionsCount();
 
 return 0;
 }
 
 int GetVariants(out array<ref ActionBase> variants)
 {
 if (m_VariantManager)
 return m_VariantManager.GetActions(variants);
 
 return 0;
 }
 
 void SetVariantID(int ID)
 {
 m_VariantID = ID;
 }
 
 int GetVariantID()
 {
 return m_VariantID;
 }
 
 void UpdateVariants(Object item, Object target, int componet_index)
 {
 if ( m_VariantManager )
 {
 m_VariantManager.UpdateVariants(item, target, componet_index);
 }
 }
 
 ActionVariantManager GetVariantManager()
 {
 if ( !m_VariantManager )
 m_VariantManager = new ActionVariantManager(this.Type());
 return m_VariantManager;
 }
 
 // call only on client side for lock inventory before action
 // return if has successfuly reserved inventory
 bool InventoryReservation(ActionData action_data)
 {
 if ((IsLocal() || !UseAcknowledgment()) && IsInstant())
 return true;
 
 //action_data.m_ReservedInventoryLocations = new array<ref InventoryLocation>;
 bool success = true;
 InventoryLocation targetInventoryLocation = NULL;
 InventoryLocation handInventoryLocation = NULL;
 
 // lock target if it has target
 if (HasTarget())
 {
 ItemBase targetItem;
 if ( ItemBase.CastTo(targetItem,action_data.m_Target.GetObject()) )
 {
 targetInventoryLocation = new InventoryLocation;
 targetItem.GetInventory().GetCurrentInventoryLocation(targetInventoryLocation);
 if ( action_data.m_Player.GetInventory().HasInventoryReservation( targetItem, targetInventoryLocation) )
 {
 success = false;
 }
 else
 {
 action_data.m_Player.GetInventory().AddInventoryReservationEx( targetItem, targetInventoryLocation, GameInventory.c_InventoryReservationTimeoutMS);
 }
 }
 } 
 
 handInventoryLocation = new InventoryLocation;
 handInventoryLocation.SetHands(action_data.m_Player,action_data.m_Player.GetItemInHands());
 
 if (action_data.m_Player.GetInventory().HasInventoryReservation( action_data.m_Player.GetItemInHands(), handInventoryLocation))
 {
 if (HasTarget())
 {
 action_data.m_Player.GetInventory().ClearInventoryReservation(targetItem, targetInventoryLocation);
 }
 
 success = false;
 }
 else
 {
 action_data.m_Player.GetInventory().AddInventoryReservationEx( action_data.m_Player.GetItemInHands(), handInventoryLocation, GameInventory.c_InventoryReservationTimeoutMS);
 }
 
 if (success)
 {
 if (targetInventoryLocation)
 action_data.m_ReservedInventoryLocations.Insert(targetInventoryLocation);
 
 if (handInventoryLocation)
 action_data.m_ReservedInventoryLocations.Insert(handInventoryLocation);
 }
 
 return success;
 }
 
 void ClearInventoryReservationEx(ActionData action_data)
 {
 if (action_data.m_ReservedInventoryLocations)
 {
 InventoryLocation il;
 for ( int i = 0; i < action_data.m_ReservedInventoryLocations.Count(); i++)
 {
 il = action_data.m_ReservedInventoryLocations.Get(i);
 EntityAI entity = il.GetItem();
 action_data.m_Player.GetInventory().ClearInventoryReservationEx( il.GetItem() , il );
 }
 
 action_data.m_ReservedInventoryLocations.Clear();
 }
 }
 
 void RefreshReservations(ActionData action_data)
 {
 if (action_data.m_ReservedInventoryLocations)
 {
 InventoryLocation il;
 for (int i = 0; i < action_data.m_ReservedInventoryLocations.Count(); i++)
 {
 il = action_data.m_ReservedInventoryLocations.Get(i);
 EntityAI entity = il.GetItem();
 action_data.m_Player.GetInventory().ExtendInventoryReservationEx(il.GetItem() , il, 10000);
 }
 }
 }
 
 // action need first have permission from server before can start
 bool UseAcknowledgment()
 {
 return true;
 }
 
 protected void InformPlayers( PlayerBase player, ActionTarget target, int state );
 
 void SendMessageToClient( Object reciever, string message ) //sends given string to client, don't use if not nescessary
 {
 PlayerBase man;
 if (GetGame().IsServer() && Class.CastTo(man, reciever) && m_MessageParam && reciever.IsAlive() && message != "")
 {
 m_MessageParam.param1 = message;
 GetGame().RPCSingleParam(man, ERPCs.RPC_USER_ACTION_MESSAGE, m_MessageParam, true, man.GetIdentity());
 }
 }
 
 // ActionCondition Rules
 // ------------------------------------------------------
 protected bool IsDamageDestroyed(ActionTarget target)
 {
 return target.GetObject() && target.GetObject().IsDamageDestroyed();
 }
 
 protected bool IsBuilding(ActionTarget target)
 {
 return target.GetObject() && target.GetObject().IsBuilding();
 }
 
 protected bool IsTransport(ActionTarget target)
 {
 return target.GetObject() && target.GetObject().IsTransport();
 }
 
 protected bool IsInReach(PlayerBase player, ActionTarget target, float maxDistance = 1.0)
 {
 Object obj = target.GetObject();
 if (!obj)
 return false;
 
 float distanceRoot, distanceHead;
 vector modelPos, worldPos, playerHeadPos;
 
 // we're using sq distance in comparison
 maxDistance = maxDistance * maxDistance;
 
 // get position of Head bone
 MiscGameplayFunctions.GetHeadBonePos(player, playerHeadPos);
 
 array<string> componentNames = new array<string>();
 obj.GetActionComponentNameList(target.GetComponentIndex(), componentNames);
 foreach (string componentName : componentNames)
 {
 if (componentName.Contains("doorstwin"))
 continue;
 
 modelPos = obj.GetSelectionPositionMS(componentName);
 worldPos = obj.ModelToWorld(modelPos);
 
 break;
 }
 
 distanceRoot = vector.DistanceSq(worldPos, player.GetPosition());
 distanceHead = vector.DistanceSq(worldPos, playerHeadPos);
 
 return distanceRoot <= maxDistance || distanceHead <= maxDistance;
 }
 // ------------------------------------------------------
 
 
 
 // SOUNDS ------------------------------------------------------
 SoundOnVehicle PlayActionSound( PlayerBase player )
 {
 if ( GetGame().IsServer() && player )
 {
 if ( m_Sound != "" )
 {
 return GetGame().CreateSoundOnObject(player, m_Sound, 6, false);
 }
 else if ( m_Sounds && m_Sounds.Count() > 0 )
 {
 int rand_num = Math.RandomInt(0, m_Sounds.Count());
 return GetGame().CreateSoundOnObject(player, m_Sounds.Get(rand_num), 6, false);
 }
 }
 
 return NULL;
 }
 
 void OnActionInfoUpdate( PlayerBase player, ActionTarget target, ItemBase item )
 {
 }
 
 //sound category matches with a soundtable category in config, selects correct soundset
 string GetSoundCategory(ActionData action_data)
 {
 return "";
 }
 
 // EVENTS ------------------------------------------------
 void OnUpdate(ActionData action_data)
 {}
 
 void OnUpdateClient(ActionData action_data)
 {
 if ( !GetGame().IsDedicatedServer() )
 {
 if (action_data.m_RefreshReservationTimer > 0)
 {
 action_data.m_RefreshReservationTimer--;
 }
 else
 {
 action_data.m_RefreshReservationTimer = m_RefreshReservationTimerValue;
 RefreshReservations(action_data);
 }
 }
 }
 
 void OnUpdateServer(ActionData action_data)
 {}
 
 void OnStart(ActionData action_data)
 {
 if (action_data.m_Player != NULL && action_data.m_Player.IsPlacingLocal() && !IsDeploymentAction())
 action_data.m_Player.PlacingCancelLocal();
 }
 
 void OnStartClient(ActionData action_data)
 {}
 
 void OnStartServer(ActionData action_data)
 {
 
 }
 
 void OnEnd(ActionData action_data)
 {
 
 }
 
 void OnEndClient(ActionData action_data)
 {}
 
 void OnEndServer(ActionData action_data)
 {
 }
 
 // SOFT SKILLS ------------------------------------------------
 float GetSpecialtyWeight()
 {
 if(m_SpecialtyWeight == 0)
 {
#ifdef DEVELOPER
 //Print("UserAction does not use SoftSkills");
#endif
 } 
 
 return m_SpecialtyWeight; 
 }
 
 int GetState( ActionData action_data )
 {
 return action_data.m_State;
 }
 
 float GetProgress( ActionData action_data )
 {
 return -1;
 }
 
 ActionInput GetInput()
 {
 return m_Input;
 }
 
 void SetID(int actionId)
 {
 m_ActionID = actionId;
 }
 
 int GetID()
 {
 return m_ActionID;
 }
 
 string GetAdminLogMessage(ActionData action_data)
 {
 return "";
 }
};