Dayz Explorer  1.24.157551 (v105080)
Dayz Code Explorer by Zeroy
actioninput.c
Go to the documentation of this file.
2 {
3  AIT_CONTINUOUS, //React to hold input and release after it
4  AIT_SINGLE, //React to click input - single use actions
5  AIT_DOUBLECLICK, //React to double click input - single use actions
6  AIT_HOLDSINGLE, //React to hold input - single use actions
7  AIT_CLICKCONTINUOUS, //React to click input for start and click for end
9  AIT_INVENTORYINPUT, //Inventory specific actions
10 }
11 
12 class ForcedActionData
13 {
17 }
18 
20 {
21  UAIDWrapper m_input; //Input ID automaticly generated from name.
22  int m_InputType; //Use from action manager for handling input
23  int m_Priority;
24  bool m_DetectFromItem; //Can be used action from item in hands?
25  bool m_DetectFromTarget; //Can be used action from target in vicinity?
26  bool m_DetectFromPlayer; //Can be used action from player?
27  bool m_Enabled;
28  bool m_JustActivate;
29  bool m_HasTarget;
30 
31  PlayerBase m_Player;
32 
33  ref ActionTarget m_ForcedTarget;
34 
35  ref ForcedActionData m_ForcedActionData;
36 
37  ref ActionTarget m_Target;
38  ItemBase m_MainItem;
39  int m_ConditionMask;
40 
41  bool m_Active;
42 
43  void ActionInput()
44  {
45  m_Active = false;
46  m_Enabled = true;
47  m_ForcedTarget = null;
48  m_ForcedActionData = null;
49 
50  m_HasTarget = false;
51 
52  m_JustActivate = false;
53  m_DetectFromTarget = false;
54  m_DetectFromItem = true;
55  m_DetectFromPlayer = true;
56 
57  m_Priority = 100;
58  }
59 
60  void Init(PlayerBase player, ActionManagerClient am)
61  {
62  m_Player = player;
63 
64  if ( LogManager.IsActionLogEnable())
65  {
66  Debug.ActionLog("n/a",this.ToString(), "n/a","Init()", player.ToString());
67  }
68 
69  }
70 
71  void SetEnablity(bool value)
72  {
73  m_Enabled = value;
74  }
75 
76  protected void SetInput(string input_name)
77  {
78  m_input = GetUApi().GetInputByName(input_name).GetPersistentWrapper();
79 
80  if ( LogManager.IsActionLogEnable())
81  {
82  if (m_input && m_input.InputP())
83  Debug.ActionLog("(+) input set to " + input_name ,this.ToString(), "n/a","SetInput()", "n/a");
84  else
85  Debug.ActionLog("(-) input is not set to " + input_name ,this.ToString(), "n/a","SetInput()","n/a");
86  }
87  }
88 
89  int GetInputType()
90  {
91  return m_InputType;
92  }
93 
94  UAInput GetUAInput()
95  {
96  return m_input.InputP();
97  }
98 
99  bool JustActivate()
100  {
101  return m_JustActivate;
102  }
103 
104  bool IsActive()
105  {
106  return m_Active;
107  }
108 
109  bool WasEnded()
110  {
111  return !m_Active;
112  }
113 
114  void Update()
115  {
116  if( !m_Enabled )
117  {
118  m_Active = false;
119  m_JustActivate = false;
120  return;
121  }
122 
123  switch ( m_InputType )
124  {
125  case ActionInputType.AIT_CONTINUOUS:
126  m_JustActivate = false;
127  if(m_Active)
128  {
129  m_Active = m_input.InputP().LocalHold();
130  }
131  else
132  {
133  m_Active = m_input.InputP().LocalHoldBegin();
134  m_JustActivate = m_Active;
135  }
136  break;
137  case ActionInputType.AIT_SINGLE:
138  m_Active = m_input.InputP().LocalClick();
139  m_JustActivate = m_Active;
140  break;
141  case ActionInputType.AIT_DOUBLECLICK:
142  m_Active = m_input.InputP().LocalDoubleClick();
143  m_JustActivate = m_Active;
144  break;
145  break;
146  case ActionInputType.AIT_HOLDSINGLE:
147  m_Active = m_input.InputP().LocalHoldBegin();
148  m_JustActivate = m_Active;
149  break;
150  break;
151  case ActionInputType.AIT_CLICKCONTINUOUS:
152  m_JustActivate = false;
153  if(m_Active)
154  {
155  if ( m_input.InputP().LocalClick() )
156  {
157  m_Active = false;
158  }
159  }
160  else
161  {
162  m_Active = m_input.InputP().LocalClick();
163  m_JustActivate = m_Active;
164  }
165  break;
166  break;
167  default:
168  break;
169  }
170  }
171 
172  void Reset()
173  {
174  m_Active = false;
175  ActionsSelectReset();
176  }
177 
178  void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
179  {
180  }
181 
182  ActionBase GetAction()
183  {
184  return NULL;
185  }
186 
187  ActionTarget GetUsedActionTarget()
188  {
189  return m_Target;
190  }
191 
192  ItemBase GetUsedMainItem()
193  {
194  return m_MainItem;
195  }
196 
197  array<ActionBase> GetPossibleActions()
198  {
199  return NULL;
200  }
201 
202  ActionBase GetPossibleAction()
203  {
204  return NULL;
205  }
206 
207  int GetPossibleActionIndex()
208  {
209  return -1;
210  }
211 
212  bool HasTarget()
213  {
214  return false;
215  }
216 
217  void OnActionStart()
218  {
219  ActionsSelectReset();
220  }
221 
222  void OnActionEnd()
223  {
224  Reset();
225  }
226 
227  void ActionsSelectReset()
228  {}
229 
230  void ForceAction(ActionBase action, ActionTarget target, ItemBase item )
231  {
232  m_ForcedActionData = new ForcedActionData;
233  m_ForcedActionData.m_Action = action;
234  m_ForcedActionData.m_Target = target;
235  m_ForcedActionData.m_Item = item;
236  }
237 
238  void ForceActionTarget( ActionTarget target )
239  {
240  m_ForcedTarget = target;
241  }
242 
243  void ClearForcedAction()
244  {
245  m_ForcedActionData = null;
246  }
247 
248  void ClearForcedTarget()
249  {
250  m_ForcedTarget = NULL;
251  }
252 
253  bool ForceActionCheck(PlayerBase player)
254  {
255  if (m_ForcedActionData)
256  {
257  if (m_ForcedActionData.m_Action.Can(player, m_ForcedActionData.m_Target, m_ForcedActionData.m_Item))
258  {
259  m_MainItem = m_ForcedActionData.m_Item;
260  m_Target = m_ForcedActionData.m_Target;
261  return true;
262  }
263  }
264  return false;
265  }
266 
267  void SelectNextAction()
268  {
269  }
270 
271  void SelectPrevAction()
272  {}
273 
274  int GetPossibleActionsCount()
275  {
276  return -1;
277  }
278 
279  bool HasInput()
280  {
281  return m_input != NULL;
282  }
283 
284  int GetPriority()
285  {
286  return m_Priority;
287  }
288 }
289 
291 {
294 
296  {
299  }
300 
301  override void ForceAction(ActionBase action, ActionTarget target, ItemBase item )
302  {
303  super.ForceAction(action, target, item);
304 
306  }
307 
308  void _GetSelectedActions( Object action_source_object, out array<ActionBase> select_actions_all, out bool has_any_action_target)
309  {
310  if ( !action_source_object )
311  return;
312 
313  array<ActionBase_Basic> possible_actions;
314  array<ref ActionBase> variant_actions;
315  action_source_object.GetActions(this.Type(), possible_actions);
316  ActionBase action;
317 
318  if(possible_actions)
319  {
320  for (int i = 0; i < possible_actions.Count(); i++)
321  {
322  action = ActionBase.Cast(possible_actions.Get(i));
323 
324  if ( action.HasVariants() )
325  {
326  action.UpdateVariants( m_MainItem, m_Target.GetObject(), m_Target.GetComponentIndex() );
327  action.GetVariants( variant_actions);
328  for (int j = 0; j < variant_actions.Count(); j++)
329  {
330  action = variant_actions[j];
331  if ( action.Can(m_Player, m_Target, m_MainItem, m_ConditionMask) )
332  {
333  select_actions_all.Insert(action);
334  if (action.HasTarget())
335  has_any_action_target = true;
336  }
337  }
338  }
339  else
340  {
341  if ( action.Can(m_Player, m_Target, m_MainItem, m_ConditionMask) )
342  {
343  select_actions_all.Insert(action);
344  if (action.HasTarget())
345  has_any_action_target = true;
346  }
347  }
348  }
349  }
350  }
351 
352  override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
353  {
354  if ( ForceActionCheck(player))
355  {
356  m_SelectActions.Clear();
357  m_SelectActions.Insert(m_ForcedActionData.m_Action);
358  return;
359  }
360 
361  if(m_ForcedTarget)
362  {
363  target = m_ForcedTarget;
364  }
365 
366  array<ActionBase> select_actions_all = new array<ActionBase>;
367  int i, last_index;
368  bool change = false;
369  m_HasTarget = false;
370 
371  m_MainItem = item;
372  m_Target = target;
373  m_ConditionMask = action_condition_mask;
374 
375 
376  if( m_DetectFromItem )
377  {
378  _GetSelectedActions( item, select_actions_all, m_HasTarget);
379  }
380 
381 
382  if( m_DetectFromTarget )
383  {
384  _GetSelectedActions( target.GetObject(), select_actions_all, m_HasTarget);
385  _GetSelectedActions( target.GetParent(), select_actions_all, m_HasTarget);
386  }
387 
388  if( m_DetectFromPlayer )
389  {
390  _GetSelectedActions( player, select_actions_all, m_HasTarget);
391  }
392 
393  if ( select_actions_all.Count() )
394  {
395  last_index = 0;
396  for ( i = 0; i < select_actions_all.Count(); i++ )
397  {
398  ActionBase action = select_actions_all[i];
399  if ( m_HasTarget )
400  {
401  if ( action.HasTarget() )
402  {
403  if ( m_SelectActions.Count() > last_index )
404  {
405  if ( m_SelectActions[last_index] != action )
406  {
407  change = true;
408  m_SelectActions[last_index] = action;
409  }
410  }
411  else
412  {
413  change = true;
414  m_SelectActions.Insert(action);
415  }
416  action.OnActionInfoUpdate(player, target, item);
417  last_index++;
418  }
419  }
420  else
421  {
422  if ( m_SelectActions.Count() > last_index )
423  {
424  if ( m_SelectActions[last_index] != action )
425  {
426  change = true;
427  m_SelectActions[last_index++] = action;
428  }
429  }
430  else
431  {
432  change = true;
433  m_SelectActions.Insert(action);
434  }
435  action.OnActionInfoUpdate(player, target, item);
436  last_index++;
437  }
438  }
439  }
440  else
441  {
443  m_SelectActions.Clear();
444  }
445 
446  if (m_SelectActions.Count() > last_index)
447  {
448  change = true;
449  for (i = last_index; i < m_SelectActions.Count(); i++)
450  {
451  m_SelectActions.Remove(last_index);
452  }
453  }
454 
455  if ( change )
456  {
458  m_Player.GetActionManager().SelectFirstActionCategory();
459  }
460  }
461 
463  {
464  return m_SelectActions;
465  }
466 
467  override int GetPossibleActionsCount()
468  {
469  return m_SelectActions.Count();
470  }
471 
472  override bool HasTarget()
473  {
474  return m_HasTarget;
475  }
476 
477  override int GetPossibleActionIndex()
478  {
479  return m_selectedActionIndex;
480  }
481 
483  {
484  if (m_SelectActions.Count() > 0)
486  return null;
487  }
488 
489  override void ActionsSelectReset()
490  {
491  m_SelectActions.Clear();
493  }
494 
495  override void SelectNextAction()
496  {
497  if(m_SelectActions.Count())
498  {
500  if(m_SelectActions.Count() <= m_selectedActionIndex )
501  {
503  }
504  }
505  }
506 
507  override void SelectPrevAction()
508  {
509  if(m_SelectActions.Count())
510  {
512  if(0 > m_selectedActionIndex )
513  {
515  }
516  }
517  }
518 
519 }
520 
522 {
524  {
525  SetInput("UAAction");
526  m_Priority = 60;
527  m_InputType = ActionInputType.AIT_CONTINUOUS;
528  m_DetectFromTarget = true;
529  m_DetectFromItem = false;
530  m_DetectFromPlayer = true;
531  }
532 };
533 
535 {
536  void InteractActionInput(PlayerBase player)
537  {
538  m_InputType = ActionInputType.AIT_SINGLE;
539  m_Priority = 80;
540  }
541 
542  override void OnActionStart()
543  {
544  super.OnActionStart();
545  m_Active = false;
546  }
547 
548  override bool WasEnded()
549  {
550  return false;
551  }
552 };
553 
555 {
557  {
558  m_DetectFromTarget = false;
559  }
560 
561  override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
562  {
563  m_MainItem = item;
564  m_Target = target;
565  m_ConditionMask = action_condition_mask;
566  }
567 
568  override ActionBase GetAction()
569  {
570  if ( ForceActionCheck(m_Player) )
571  return m_ForcedActionData.m_Action;
572 
573  if(m_MainItem)
574  {
575  array<ActionBase_Basic> possible_actions;
576  ActionBase action;
577 
578  m_MainItem.GetActions(this.Type(), possible_actions);
579  if(possible_actions)
580  {
581  for (int i = 0; i < possible_actions.Count(); i++)
582  {
583  action = ActionBase.Cast(possible_actions.Get(i));
584  if ( action.Can(m_Player, m_Target, m_MainItem, m_ConditionMask) )
585  {
586  return action;
587  }
588  }
589  }
590 
591  }
592  return NULL;
593  }
594 
595  override ActionBase GetPossibleAction()
596  {
597  return GetAction();
598  }
599 }
600 
601 
602 
604 {
605  protected ActionBase m_SelectAction; //Do nothing only for back compatibilit, relevant only for inherited class
607  {
608  SetInput("UADefaultAction");
609  m_InputType = ActionInputType.AIT_CONTINUOUS;
610  m_Priority = 20;
611  m_DetectFromTarget = false;
612  m_DetectFromItem = true;
613  m_DetectFromPlayer = true;
614 
615  m_SelectAction = null;
616  }
617 
619  {
620  return m_SelectAction;
621  }
622 
623  override void ActionsSelectReset()
624  {
625  super.ActionsSelectReset();
627  }
628 };
629 
631 {
632  void DefaultActionInput(PlayerBase player)
633  {
634  m_InputType = ActionInputType.AIT_SINGLE;
635  m_Priority = 40;
636  }
637 
638  override void OnActionStart()
639  {
640  super.OnActionStart();
641  m_Active = false;
642  }
643 
644  override bool WasEnded()
645  {
646  return false;
647  }
648 };
649 
651 {
652  void DropActionInput(PlayerBase player)
653  {
654  SetInput("UADropitem");
655  m_InputType = ActionInputType.AIT_HOLDSINGLE;
656  }
657 };
658 
660 {
661  ref ActionTarget targetNew;
662 
664  {
665  SetInput("UACarHorn");
666  m_InputType = ActionInputType.AIT_SINGLE;
667  m_Priority = 100;
668  m_DetectFromItem = false;
669  m_DetectFromTarget = false;
670  m_DetectFromPlayer = false;
671  }
672 
673  override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
674  {
675  if (ForceActionCheck(player))
676  {
677  m_SelectAction = m_ForcedActionData.m_Action;
678  return;
679  }
680 
681  m_SelectAction = null;
682  array<ActionBase_Basic> possibleActions;
683  ActionBase action;
684  int i;
685 
686  m_MainItem = null;
687  if (player && player.IsInVehicle())
688  {
689  HumanCommandVehicle vehCommand = player.GetCommand_Vehicle();
690  if (vehCommand)
691  {
692  Transport trans = vehCommand.GetTransport();
693  if (trans)
694  {
695  targetNew = new ActionTarget(trans, null, -1, vector.Zero, -1);
696  ForceActionTarget(targetNew);
697  }
698  }
699 
700  if (!targetNew)
701  {
702  ClearForcedTarget();
703  }
704  }
705 
706  target = m_ForcedTarget;
707  m_Target = m_ForcedTarget;
708 
709  if (target && target.GetObject())
710  {
711  target.GetObject().GetActions(this.Type(), possibleActions);
712  if (possibleActions)
713  {
714  for (i = 0; i < possibleActions.Count(); i++)
715  {
716  action = ActionBase.Cast(possibleActions.Get(i));
717  if (action.Can(player, target, m_MainItem, action_condition_mask))
718  {
719  m_SelectAction = action;
720  return;
721  }
722  }
723  }
724  }
725  }
726 
727  override ActionBase GetAction()
728  {
729  return m_SelectAction;
730  }
731 }
732 
734 {
736  {
737  SetInput("UACarHorn");
738  m_InputType = ActionInputType.AIT_CONTINUOUS;
739  m_Priority = 101;
740  m_DetectFromItem = false;
741  m_DetectFromTarget = false;
742  m_DetectFromPlayer = false;
743  }
744 }
745 
747 {
748  ref ActionTarget target_new;
749 
751  {
752  SetInput("UAToggleHeadlight");
753  m_InputType = ActionInputType.AIT_SINGLE;
754  m_Priority = 100;
755  }
756 
757  override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
758  {
759  if( ForceActionCheck(player) )
760  {
761  m_SelectAction = m_ForcedActionData.m_Action;
762  return;
763  }
764  //ForceActionTarget(player.m_PlayerLightManager.
765 
766  m_SelectAction = NULL;
767  array<ActionBase_Basic> possible_actions;
768  ActionBase action;
769  int i;
770 
771  m_MainItem = NULL;
772  if ( player && !player.IsInVehicle() )
773  {
774  Clothing headgear = Clothing.Cast(player.FindAttachmentBySlotName("Headgear"));
775  Clothing eyewear = Clothing.Cast(player.FindAttachmentBySlotName("Eyewear"));
776  //TODO - extend this to allow for a switchable control over all possible light sources (depth 0 or 1 only?)
777 
778  if ( headgear && headgear.GetLightSourceItem() )
779  {
780  target_new = new ActionTarget(headgear, null, -1, vector.Zero, -1);
781  ForceActionTarget(target_new);
782  }
783  else if ( eyewear && eyewear.GetLightSourceItem() )
784  {
785  target_new = new ActionTarget(eyewear, null, -1, vector.Zero, -1);
786  ForceActionTarget(target_new);
787  }
788  else
789  ClearForcedTarget();
790  }
791  else if ( player && player.IsInVehicle() )
792  {
793  HumanCommandVehicle vehCommand = player.GetCommand_Vehicle();
794  if( vehCommand )
795  {
796  Transport trans = vehCommand.GetTransport();
797  if( trans )
798  {
799  target_new = new ActionTarget(trans, null, -1, vector.Zero, -1);
800  ForceActionTarget(target_new);
801  }
802  }
803 
804  if ( !target_new )
805  ClearForcedTarget();
806  }
807 
808  target = m_ForcedTarget;
809  m_Target = m_ForcedTarget;
810 
811  if(target && target.GetObject())
812  {
813  target.GetObject().GetActions(this.Type(), possible_actions);
814  if(possible_actions)
815  {
816  for (i = 0; i < possible_actions.Count(); i++)
817  {
818  action = ActionBase.Cast(possible_actions.Get(i));
819  if ( action.Can(player, target, m_MainItem, action_condition_mask) )
820  {
821  m_SelectAction = action;
822  return;
823  }
824  }
825  }
826  }
827  }
828 
829  override ActionBase GetAction()
830  {
831  return m_SelectAction;
832  }
833 };
834 
836 {
837  ref ActionTarget target_new;
838 
839  void ToggleNVGActionInput(PlayerBase player)
840  {
841  SetInput("UAToggleNVG");
842  m_InputType = ActionInputType.AIT_HOLDSINGLE;
843  m_Priority = 100;
844  }
845 
846  override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
847  {
848  if( ForceActionCheck(player) )
849  {
850  m_SelectAction = m_ForcedActionData.m_Action;
851  return;
852  }
853  //ForceActionTarget(player.m_PlayerLightManager.
854 
855  m_SelectAction = NULL;
856  array<ActionBase_Basic> possible_actions;
857  ActionBase action;
858  int i;
859 
860  m_MainItem = NULL;
861  if ( player )
862  {
863  Mich2001Helmet helmet = Mich2001Helmet.Cast(player.FindAttachmentBySlotName("Headgear"));
864  NVGHeadstrap headstrap = NVGHeadstrap.Cast(player.FindAttachmentBySlotName("Eyewear"));
865  if ( helmet )
866  {
867  //m_MainItem = Headtorch_ColorBase.Cast(player.FindAttachmentBySlotName("Headgear"));
868  target_new = new ActionTarget(helmet, null, -1, vector.Zero, -1);
869  ForceActionTarget(target_new);
870  }
871  else if ( headstrap )
872  {
873  target_new = new ActionTarget(headstrap, null, -1, vector.Zero, -1);
874  ForceActionTarget(target_new);
875  }
876  else
877  ClearForcedTarget();
878  }
879 
880  target = m_ForcedTarget;
881  m_Target = m_ForcedTarget;
882 
883  if(target && target.GetObject())
884  {
885  target.GetObject().GetActions(this.Type(), possible_actions);
886  if(possible_actions)
887  {
888  for (i = 0; i < possible_actions.Count(); i++)
889  {
890  action = ActionBase.Cast(possible_actions.Get(i));
891  if ( action.Can(player, target, m_MainItem, action_condition_mask) )
892  {
893  m_SelectAction = action;
894  return;
895  }
896  }
897  }
898  }
899  }
900 
901  override ActionBase GetAction()
902  {
903  return m_SelectAction;
904  }
905 };
906 
908 {
910  {
911  SetInput("UAReloadMagazine");
912  m_InputType = ActionInputType.AIT_CONTINUOUS;
913  }
914 };
915 
917 {
919  {
920  SetInput("UAReloadMagazine");
921  m_InputType = ActionInputType.AIT_SINGLE;
922  }
923 };
924 
926 {
928  {
929  //SetInput("UAReloadMagazine");
930  m_InputType = ActionInputType.AIT_NOINPUTCONTROL;
931  }
932 };
933 
935 {
937  {
938  //SetInput("UAReloadMagazine");
939  m_InputType = ActionInputType.AIT_INVENTORYINPUT;
940  }
941 };
942 
944 {
945 };
946 
947 
ItemBase
Definition: inventoryitem.c:730
GetPossibleActionsCount
override int GetPossibleActionsCount()
Definition: actioninput.c:467
m_SelectAction
NoIndicationActionInputBase m_SelectAction
UAIDWrapper
Definition: uainput.c:14
m_Target
ref ActionTarget m_Target
Definition: actionbase.c:17
ToggleLightsActionInput
Definition: actioninput.c:746
LogManager
Definition: debug.c:734
UAInput
Definition: uainput.c:23
m_selectedActionIndex
int m_selectedActionIndex
Definition: actioninput.c:293
CarHornLongActionInput
ToggleLightsActionInput CarHornLongActionInput
ContinuousInteractActionInput
Definition: actioninput.c:521
AIT_CONTINUOUS
@ AIT_CONTINUOUS
Definition: actioninput.c:3
m_Priority
int m_Priority
Definition: bioslobbyservice.c:34
GetPossibleAction
override ActionBase GetPossibleAction()
Definition: actioninput.c:618
m_SelectActions
ActionInput m_SelectActions
ActionInputType
ActionInputType
Definition: actioninput.c:1
CarHornShortActionInput
Definition: actioninput.c:659
AIT_NOINPUTCONTROL
@ AIT_NOINPUTCONTROL
Definition: actioninput.c:8
m_ConditionMask
int m_ConditionMask
Definition: actionbase.c:60
ActionInput_Basic
Definition: actioninput_basic.c:1
AIT_SINGLE
@ AIT_SINGLE
Definition: actioninput.c:4
DefaultActionInput
Definition: actioninput.c:630
_GetSelectedActions
void _GetSelectedActions(Object action_source_object, out array< ActionBase > select_actions_all, out bool has_any_action_target)
Definition: actioninput.c:308
m_Item
ItemBase m_Item
Definition: actioninput.c:16
ToggleNVGActionInput
Definition: actioninput.c:835
ToString
proto string ToString()
m_Enabled
bool m_Enabled
Definition: traptrigger.c:2
SelectPrevAction
override void SelectPrevAction()
Definition: actioninput.c:507
ForceAction
override void ForceAction(ActionBase action, ActionTarget target, ItemBase item)
Definition: actioninput.c:301
PlayerBase
Definition: playerbaseclient.c:1
vector
Definition: enconvert.c:105
ExternalControlledActionInput
Definition: actioninput.c:925
Clothing
Definition: armband_colorbase.c:1
ActionTarget
class ActionTargets ActionTarget
InteractActionInput
Definition: actioninput.c:534
GetAction
override ActionBase GetAction()
Definition: actioninput.c:482
Object
Definition: objecttyped.c:1
m_Player
DayZPlayer m_Player
Definition: hand_events.c:42
Transport
Base native class for all motorized wheeled vehicles.
Definition: car.c:79
ActionInput
Definition: actioninput.c:19
HumanCommandVehicle
Definition: human.c:689
ActionManagerClient
Definition: actionmanagerclient.c:4
UpdatePossibleActions
override void UpdatePossibleActions(PlayerBase player, ActionTarget target, ItemBase item, int action_condition_mask)
Definition: actioninput.c:352
array
Result for an object found in CGame.IsBoxCollidingGeometryProxy.
Definition: isboxcollidinggeometryproxyclasses.c:27
SetInput
void SetInput(ActionInput ai)
Definition: actionbase.c:208
WeaponManipulationActionInput
Definition: actioninput.c:916
AIT_INVENTORYINPUT
@ AIT_INVENTORYINPUT
Definition: actioninput.c:9
ContinuousWeaponManipulationActionInput
Definition: actioninput.c:907
ActionsSelectReset
override void ActionsSelectReset()
Definition: actioninput.c:489
ActionBase
void ActionBase()
Definition: actionbase.c:73
QuickaBarActionInput
Definition: actioninput.c:943
StandardActionInput
void StandardActionInput(PlayerBase player)
Definition: actioninput.c:295
AIT_CLICKCONTINUOUS
@ AIT_CLICKCONTINUOUS
Definition: actioninput.c:7
targetNew
ref ActionTarget targetNew
Definition: actioninput.c:624
Debug
Definition: debug.c:13
NoIndicationActionInputBase
Definition: actioninput.c:554
Type
string Type
Definition: jsondatacontaminatedarea.c:11
DropActionInput
Definition: actioninput.c:650
GetUApi
proto native UAInputAPI GetUApi()
GetPossibleActionIndex
override int GetPossibleActionIndex()
Definition: actioninput.c:477
HasTarget
override bool HasTarget()
Definition: actioninput.c:472
InventoryOnlyActionInput
Definition: actioninput.c:934
m_Action
enum ActionInputType m_Action
m_Target
ref ActionTarget m_Target
Definition: actioninput.c:15
GetPossibleActions
override array< ActionBase > GetPossibleActions()
Definition: actioninput.c:462
SelectNextAction
override void SelectNextAction()
Definition: actioninput.c:495
AIT_DOUBLECLICK
@ AIT_DOUBLECLICK
Definition: actioninput.c:5
ContinuousDefaultActionInput
void ContinuousDefaultActionInput(PlayerBase player)
Definition: actioninput.c:606
m_MainItem
enum ActionConditionMask m_MainItem
AIT_HOLDSINGLE
@ AIT_HOLDSINGLE
Definition: actioninput.c:6