Elin Decompiled Documentation EA 23.102 Nightly
Loading...
Searching...
No Matches
EInput.cs
Go to the documentation of this file.
1using System;
2using System.Collections.Generic;
3using UnityEngine;
4using UnityEngine.EventSystems;
5using UnityEngine.UI;
6
7public class EInput : MonoBehaviour
8{
9 [Serializable]
10 public class KeyMap
11 {
13
14 public KeyCode key;
15
16 public bool required;
17
18 public int GetGroup()
19 {
20 if (action == EAction.Examine)
21 {
22 return 1;
23 }
24 if (action == EAction.GetAll)
25 {
26 return 2;
27 }
28 return 0;
29 }
30 }
31
32 [Serializable]
33 public class KeyMapManager
34 {
35 public KeyMap cancel = new KeyMap
36 {
37 action = EAction.CancelUI
38 };
39
40 public KeyMap axisUp = new KeyMap
41 {
42 action = EAction.AxisUp
43 };
44
45 public KeyMap axisDown = new KeyMap
46 {
47 action = EAction.AxisDown
48 };
49
50 public KeyMap axisLeft = new KeyMap
51 {
52 action = EAction.AxisLeft
53 };
54
55 public KeyMap axisRight = new KeyMap
56 {
57 action = EAction.AxisRight
58 };
59
61 {
62 action = EAction.AxisUpLeft
63 };
64
66 {
67 action = EAction.AxisUpRight
68 };
69
71 {
72 action = EAction.AxisDownLeft
73 };
74
76 {
77 action = EAction.AxisDownRight
78 };
79
80 public KeyMap journal = new KeyMap
81 {
82 action = EAction.MenuJournal
83 };
84
85 public KeyMap chara = new KeyMap
86 {
87 action = EAction.MenuChara
88 };
89
90 public KeyMap inventory = new KeyMap
91 {
92 action = EAction.MenuInventory
93 };
94
95 public KeyMap ability = new KeyMap
96 {
97 action = EAction.MenuAbility
98 };
99
100 public KeyMap log = new KeyMap
101 {
102 action = EAction.Log
103 };
104
105 public KeyMap fire = new KeyMap
106 {
107 action = EAction.Fire
108 };
109
110 public KeyMap wait = new KeyMap
111 {
112 action = EAction.Wait
113 };
114
116 {
117 action = EAction.AutoCombat
118 };
119
121 {
122 action = EAction.EmptyHand
123 };
124
126 {
127 action = EAction.MouseLeft
128 };
129
131 {
132 action = EAction.MouseRight
133 };
134
136 {
137 action = EAction.MouseMiddle
138 };
139
140 public KeyMap report = new KeyMap
141 {
142 action = EAction.Report
143 };
144
146 {
147 action = EAction.QuickSave
148 };
149
151 {
152 action = EAction.QuickLoad
153 };
154
156 {
157 action = EAction.SwitchHotbar
158 };
159
160 public KeyMap examine = new KeyMap
161 {
162 action = EAction.Examine
163 };
164
165 public KeyMap getAll = new KeyMap
166 {
167 action = EAction.GetAll
168 };
169
170 public KeyMap dump = new KeyMap
171 {
172 action = EAction.Dump
173 };
174
175 public KeyMap mute = new KeyMap
176 {
177 action = EAction.Mute
178 };
179
180 public KeyMap meditate = new KeyMap
181 {
182 action = EAction.Meditate
183 };
184
185 public KeyMap search = new KeyMap
186 {
187 action = EAction.Search
188 };
189
190 public List<KeyMap> List()
191 {
192 return new List<KeyMap>
193 {
197 };
198 }
199 }
200
201 public class KeyboardPress
202 {
203 public float timer;
204
205 public int count;
206
207 public bool consumed;
208
209 public Func<KeyMap> func;
210
211 public EAction Action => func().action;
212
213 public bool IsRepeating => count > 1;
214
215 public bool Update(bool forcePress = false)
216 {
217 if (Input.GetKey(func().key) || forcePress)
218 {
219 if (consumed)
220 {
221 return false;
222 }
223 if (count == 1)
224 {
225 timer += delta;
226 if (timer < 0.5f)
227 {
228 return false;
229 }
230 }
231 else
232 {
233 timer = 0f;
234 }
235 count++;
236 return true;
237 }
238 consumed = false;
239 count = 0;
240 return false;
241 }
242
243 public void Consume()
244 {
245 consumed = true;
246 }
247 }
248
249 public static KeyboardPress keyFire = new KeyboardPress();
250
251 public static KeyboardPress keyWait = new KeyboardPress();
252
253 public static Func<string, string> LangGetter;
254
255 public static EInput Instance;
256
257 public static EventSystem eventSystem;
258
259 public static EAction action;
260
261 public static bool isShiftDown;
262
263 public static bool isCtrlDown;
264
265 public static bool isAltDown;
266
267 public static bool requireConfirmReset;
268
269 public static bool requireAxisReset;
270
271 public static bool hasAxisMoved;
272
273 public static bool hasShiftChanged;
274
275 public static bool haltInput;
276
277 public static bool isInputFieldActive;
278
279 public static bool firstAxisPressed;
280
281 public static bool axisReleased;
282
283 public static int hotkey;
284
285 public static int functionkey;
286
287 public static int skipFrame;
288
289 public static int wheel;
290
291 public static int missClickButton;
292
293 private static float waitInput;
294
295 private static float durationAxis;
296
297 private static float durationFirstAxis;
298
299 private static float durationAxisRelease;
300
301 private static float durationAxisDiagonal;
302
303 private static float waitReleaseKeyTimer;
304
305 private static Vector2 lastAxis;
306
307 private static Vector2 firstAxis;
308
309 private static Vector2 prevAxis;
310
311 public static bool hasMouseMoved;
312
313 public static bool axisXChanged;
314
315 public static bool axisYChanged;
316
317 public static bool waitReleaseAnyKey;
318
319 public static List<ButtonState> buttons = new List<ButtonState>();
320
321 public static float delta;
322
323 public static float antiMissClick;
324
325 public static float missClickDuration;
326
327 public static float dragHack;
328
329 public static float ignoreWheelDuration;
330
331 public static Vector2 axis;
332
333 public static Vector2 forbidAxis;
334
335 public static Vector2 axisDiagonal;
336
337 public static Vector3 mpos;
338
339 public static Vector3 mposWorld;
340
341 public static Vector3 dragStartPos;
342
343 public static Vector3 dragStartPos2;
344
345 public static Vector3 lastMousePos;
346
347 public static Vector3 dragAmount;
348
349 public static ButtonState leftMouse;
350
351 public static ButtonState rightMouse;
352
354
355 public static ButtonState mouse3;
356
357 public static ButtonState mouse4;
358
360
361 public static ButtonState buttonCtrl;
362
363 public static bool rightScroll;
364
365 public static bool disableKeyAxis;
366
367 public static KeyMapManager keys = new KeyMapManager();
368
369 public static Vector3 uiMousePosition;
370
371 public float repeatThresh = 0.3f;
372
373 public float repeatSpeed = 0.05f;
374
375 public static bool isConfirm => action == EAction.Confirm;
376
377 public static bool isCancel
378 {
379 get
380 {
381 if (action != EAction.Cancel)
382 {
383 return action == EAction.CancelUI;
384 }
385 return true;
386 }
387 }
388
389 public static bool isPrev => action == EAction.Prev;
390
391 public static bool isNext => action == EAction.Next;
392
393 public static bool IsConsumed => skipFrame > 0;
394
395 public static GameObject selectedGO => eventSystem.currentSelectedGameObject;
396
397 public static void WaitInput(float time)
398 {
399 waitInput = time;
400 }
401
402 private void Awake()
403 {
404 Instance = this;
405 Init();
406 }
407
408 public static void Init()
409 {
410 leftMouse = AddButton(0);
413 mouse3 = AddButton(3);
414 mouse4 = AddButton(4);
415 leftMouse.dragMargin = 32f;
416 middleMouse.clickDuration = 0.3f;
417 middleMouse.clickCriteria = ButtonState.ClickCriteria.ByDuration;
418 middleMouse.ignoreWheel = true;
419 middleMouse.id = "middle";
420 mouse3.clickDuration = 0.3f;
421 mouse3.clickCriteria = ButtonState.ClickCriteria.ByDuration;
422 mouse4.clickDuration = 0.3f;
423 mouse4.clickCriteria = ButtonState.ClickCriteria.ByDuration;
425 {
426 mouse = -1,
427 clickCriteria = ButtonState.ClickCriteria.ByDuration
428 };
429 buttons.Add(buttonCtrl);
431 }
432
433 public static void SetKeyMap(KeyMapManager _keys)
434 {
435 keys = _keys;
436 leftMouse.keymap = keys.mouseLeft;
437 rightMouse.keymap = keys.mouseRight;
438 middleMouse.keymap = keys.mouseMiddle;
439 buttonCtrl.keymap = keys.switchHotbar;
440 keyFire.func = () => keys.fire;
441 keyWait.func = () => keys.wait;
442 }
443
444 public static ButtonState AddButton(int mouse)
445 {
446 ButtonState buttonState = new ButtonState
447 {
448 mouse = mouse
449 };
450 buttons.Add(buttonState);
451 return buttonState;
452 }
453
454 public static void DisableIME()
455 {
456 ToggleIME(on: false);
457 }
458
459 public static void ToggleIME(bool on)
460 {
461 Input.imeCompositionMode = (on ? IMECompositionMode.On : IMECompositionMode.Off);
462 }
463
464 public static void UpdateOnlyAxis()
465 {
466 isShiftDown = Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift);
467 isCtrlDown = Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl);
468 isAltDown = Input.GetKey(KeyCode.LeftAlt) || Input.GetKey(KeyCode.RightAlt);
469 axis = Vector2.zero;
470 hasAxisMoved = (hasMouseMoved = false);
471 UpdateAxis();
472 Consume(3);
473 }
474
475 public static void Update()
476 {
479 dragHack += delta;
480 mpos = Input.mousePosition;
481 if ((bool)Camera.main)
482 {
483 mposWorld = Camera.main.ScreenToWorldPoint(mpos);
484 }
485 mposWorld.z = 0f;
486 action = EAction.None;
487 axis = Vector2.zero;
488 hasAxisMoved = (hasMouseMoved = false);
489 wheel = 0;
490 if (!Application.isFocused)
491 {
492 return;
493 }
494 GameObject gameObject = EventSystem.current?.currentSelectedGameObject;
495 if ((bool)gameObject && gameObject.activeInHierarchy)
496 {
497 isInputFieldActive = gameObject.GetComponent<InputField>();
498 }
499 else
500 {
501 isInputFieldActive = false;
502 }
503 isShiftDown = Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift);
504 isCtrlDown = Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl);
505 isAltDown = Input.GetKey(KeyCode.LeftAlt) || Input.GetKey(KeyCode.RightAlt);
507 {
508 waitReleaseKeyTimer -= Time.deltaTime;
509 if (waitReleaseKeyTimer < 0f)
510 {
511 waitReleaseAnyKey = false;
512 }
513 else
514 {
515 if (!Input.inputString.IsEmpty() || IsAnyKeyDown(includeAxis: true, _skipframe: false))
516 {
517 return;
518 }
519 waitReleaseAnyKey = false;
520 }
521 }
522 if (haltInput)
523 {
524 Consume(consumeAxis: true);
525 return;
526 }
528 {
529 if (Input.GetKey(keys.wait.key) || Input.GetKey(KeyCode.Keypad5))
530 {
531 Consume(consumeAxis: true);
532 return;
533 }
534 requireConfirmReset = false;
535 }
537 if (lastMousePos != mpos)
538 {
540 hasMouseMoved = true;
541 }
542 if (skipFrame > 0)
543 {
544 skipFrame--;
545 return;
546 }
547 if (waitInput > 0f)
548 {
549 Consume(consumeAxis: true);
550 waitInput -= Time.unscaledDeltaTime;
551 return;
552 }
553 if (Input.GetMouseButtonDown(0))
554 {
555 missClickButton = 0;
557 }
558 if (Input.GetMouseButtonDown(1))
559 {
560 if (missClickDuration > 0f && missClickButton == 0)
561 {
562 Consume();
563 rightMouse.consumed = false;
564 skipFrame = 5;
565 return;
566 }
567 missClickButton = 1;
569 }
570 foreach (ButtonState button in buttons)
571 {
572 button.Update();
573 }
574 if (ignoreWheelDuration < 0f)
575 {
576 float num = Input.GetAxis("Mouse ScrollWheel");
577 wheel = ((num < 0f) ? (-1) : ((num > 0f) ? 1 : 0));
578 if (Input.GetKeyDown(KeyCode.PageUp))
579 {
580 wheel = 1;
581 }
582 if (Input.GetKeyDown(KeyCode.PageDown))
583 {
584 wheel = -1;
585 }
586 }
588 {
589 return;
590 }
591 UpdateAxis();
593 {
594 if (axis == Vector2.zero)
595 {
596 requireAxisReset = false;
597 }
598 else
599 {
600 axis = Vector2.zero;
601 }
602 }
603 if (forbidAxis != Vector2.zero && axis == forbidAxis)
604 {
605 axis = Vector2.zero;
606 }
607 else
608 {
609 forbidAxis = Vector2.zero;
610 }
612 if (hotkey == -1 && action == EAction.None)
613 {
614 action = GetAction();
615 }
617 }
618
619 public static bool IsAnyKeyDown(bool includeAxis = true, bool _skipframe = true)
620 {
621 if (_skipframe && skipFrame > 0)
622 {
623 return false;
624 }
625 if (isConfirm || isCancel)
626 {
627 return true;
628 }
629 if (includeAxis && axis != Vector2.zero)
630 {
631 return true;
632 }
633 foreach (ButtonState button in buttons)
634 {
635 if (button.clicked)
636 {
637 return true;
638 }
639 }
640 for (int i = 97; i < 122; i++)
641 {
642 if (Input.GetKey(i.ToEnum<KeyCode>()))
643 {
644 return true;
645 }
646 }
647 return false;
648 }
649
650 public static void WaitReleaseKey()
651 {
652 waitReleaseAnyKey = true;
653 waitReleaseKeyTimer = 2.5f;
654 }
655
656 public static void Consume(int _skipFrame)
657 {
658 Consume(consumeAxis: false, _skipFrame);
659 }
660
661 public static void Consume(bool consumeAxis = false, int _skipFrame = 1)
662 {
663 wheel = 0;
664 action = EAction.None;
665 functionkey = -1;
666 hotkey = -1;
667 if (_skipFrame > skipFrame)
668 {
669 skipFrame = _skipFrame;
670 }
671 if (consumeAxis)
672 {
673 axis = (lastAxis = Vector2.zero);
674 requireAxisReset = true;
675 durationAxis = 0f;
676 }
677 foreach (ButtonState button in buttons)
678 {
679 button.Consume();
680 }
681 }
682
683 public static void ConsumeWheel()
684 {
685 wheel = 0;
686 }
687
688 public static void SetAxis(int x, int y)
689 {
690 axis.x = x;
691 axis.y = y;
692 }
693
694 public static void ModAxisX(int x)
695 {
696 axis.x += x;
697 axisXChanged = true;
698 }
699
700 public static void ModAxisY(int y)
701 {
702 axis.y += y;
703 axisYChanged = true;
704 }
705
706 private static void UpdateAxis()
707 {
709 {
710 return;
711 }
712 axisXChanged = (axisYChanged = false);
713 if (Input.GetKey(keys.axisUp.key))
714 {
715 ModAxisY(1);
716 }
717 if (Input.GetKey(keys.axisDown.key))
718 {
719 ModAxisY(-1);
720 }
721 if (Input.GetKey(keys.axisLeft.key))
722 {
723 ModAxisX(-1);
724 }
725 if (Input.GetKey(keys.axisRight.key))
726 {
727 ModAxisX(1);
728 }
729 if (axis == Vector2.zero && !disableKeyAxis)
730 {
731 if (Input.GetKey(keys.axisUp.key) || Input.GetKey(KeyCode.UpArrow))
732 {
733 ModAxisY(1);
734 }
735 if (Input.GetKey(keys.axisDown.key) || Input.GetKey(KeyCode.DownArrow))
736 {
737 ModAxisY(-1);
738 }
739 if (Input.GetKey(keys.axisLeft.key) || Input.GetKey(KeyCode.LeftArrow))
740 {
741 ModAxisX(-1);
742 }
743 if (Input.GetKey(keys.axisRight.key) || Input.GetKey(KeyCode.RightArrow))
744 {
745 ModAxisX(1);
746 }
747 }
748 if (axis == Vector2.zero)
749 {
750 if (Input.GetKey(KeyCode.Keypad8))
751 {
752 ModAxisY(1);
753 }
754 if (Input.GetKey(KeyCode.Keypad2))
755 {
756 ModAxisY(-1);
757 }
758 if (Input.GetKey(KeyCode.Keypad4))
759 {
760 ModAxisX(-1);
761 }
762 if (Input.GetKey(KeyCode.Keypad6))
763 {
764 ModAxisX(1);
765 }
766 }
767 if (Input.GetKey(keys.axisUpLeft.key))
768 {
769 SetAxis(-1, 1);
770 }
771 if (Input.GetKey(keys.axisUpRight.key))
772 {
773 SetAxis(1, 1);
774 }
775 if (Input.GetKey(keys.axisDownLeft.key))
776 {
777 SetAxis(-1, -1);
778 }
779 if (Input.GetKey(keys.axisDownRight.key))
780 {
781 SetAxis(1, -1);
782 }
783 if (Input.GetKey(KeyCode.Keypad1))
784 {
785 SetAxis(-1, -1);
786 }
787 if (Input.GetKey(KeyCode.Keypad3))
788 {
789 SetAxis(1, -1);
790 }
791 if (Input.GetKey(KeyCode.Keypad7))
792 {
793 SetAxis(-1, 1);
794 }
795 if (Input.GetKey(KeyCode.Keypad9))
796 {
797 SetAxis(1, 1);
798 }
799 if (axis.x == 0f && axisXChanged)
800 {
801 axis.x = 0f - prevAxis.x;
802 }
803 else
804 {
805 prevAxis.x = axis.x;
806 }
807 if (axis.y == 0f && axisYChanged)
808 {
809 axis.y = 0f - prevAxis.y;
810 }
811 else
812 {
813 prevAxis.y = axis.y;
814 }
815 if (Input.GetKey(KeyCode.LeftAlt) && (axis.x == 0f || axis.y == 0f))
816 {
817 axis = Vector2.zero;
818 }
819 if (axis != Vector2.zero && !firstAxisPressed)
820 {
821 firstAxisPressed = true;
822 firstAxis = axis;
823 durationFirstAxis = 0.06f;
824 }
826 {
828 if (durationFirstAxis > 0f)
829 {
830 if (!(axis == Vector2.zero))
831 {
832 axis = Vector2.zero;
833 return;
834 }
835 axis = firstAxis;
836 }
837 else if (axis == Vector2.zero)
838 {
839 firstAxisPressed = false;
840 }
841 }
842 if (axis.x != 0f && axis.y != 0f)
843 {
844 axisDiagonal.x = axis.x;
845 axisDiagonal.y = axis.y;
847 if (durationAxisDiagonal > 0f)
848 {
850 }
851 }
852 else
853 {
855 if (durationAxisDiagonal < 0f)
856 {
858 }
859 }
860 if (axis == Vector2.zero)
861 {
863 if (durationAxisRelease < 0.5f + durationAxisDiagonal * 0.1f)
864 {
865 return;
866 }
867 lastAxis = Vector2.zero;
868 }
869 else
870 {
872 }
873 if (durationAxisDiagonal > 1f)
874 {
875 if (axis != Vector2.zero)
876 {
877 axis.x = axisDiagonal.x;
878 axis.y = axisDiagonal.y;
879 }
880 lastAxis = Vector2.zero;
881 return;
882 }
884 if (axis != Vector2.zero && axis != lastAxis)
885 {
886 durationAxis = 0.25f;
887 lastAxis = axis;
888 }
889 else if (durationAxis > 0f)
890 {
891 axis = lastAxis;
892 }
893 }
894
895 public static int GetHotkeyDown()
896 {
897 int result = -1;
898 if (Input.GetKeyDown(KeyCode.Alpha1))
899 {
900 result = 0;
901 }
902 else if (Input.GetKeyDown(KeyCode.Alpha2))
903 {
904 result = 1;
905 }
906 else if (Input.GetKeyDown(KeyCode.Alpha3))
907 {
908 result = 2;
909 }
910 else if (Input.GetKeyDown(KeyCode.Alpha4))
911 {
912 result = 3;
913 }
914 else if (Input.GetKeyDown(KeyCode.Alpha5))
915 {
916 result = 4;
917 }
918 else if (Input.GetKeyDown(KeyCode.Alpha6))
919 {
920 result = 5;
921 }
922 else if (Input.GetKeyDown(KeyCode.Alpha7))
923 {
924 result = 6;
925 }
926 else if (Input.GetKeyDown(KeyCode.Alpha8))
927 {
928 result = 7;
929 }
930 else if (Input.GetKeyDown(KeyCode.Alpha9))
931 {
932 result = 8;
933 }
934 return result;
935 }
936
937 public static int GetFunctionkeyDown()
938 {
939 int result = -1;
940 if (Input.GetKeyDown(KeyCode.F1))
941 {
942 result = 0;
943 }
944 else if (Input.GetKeyDown(KeyCode.F2))
945 {
946 result = 1;
947 }
948 else if (Input.GetKeyDown(KeyCode.F3))
949 {
950 result = 2;
951 }
952 else if (Input.GetKeyDown(KeyCode.F4))
953 {
954 result = 3;
955 }
956 else if (Input.GetKeyDown(KeyCode.F5))
957 {
958 result = 4;
959 }
960 else if (Input.GetKeyDown(KeyCode.F6))
961 {
962 result = 5;
963 }
964 else if (Input.GetKeyDown(KeyCode.F7))
965 {
966 result = 6;
967 }
968 else if (Input.GetKeyDown(KeyCode.F8))
969 {
970 result = 7;
971 }
972 return result;
973 }
974
975 public static int GetHotkey()
976 {
977 int result = -1;
978 if (Input.GetKey(KeyCode.Alpha1))
979 {
980 result = 0;
981 }
982 else if (Input.GetKey(KeyCode.Alpha2))
983 {
984 result = 1;
985 }
986 else if (Input.GetKey(KeyCode.Alpha3))
987 {
988 result = 2;
989 }
990 else if (Input.GetKey(KeyCode.Alpha4))
991 {
992 result = 3;
993 }
994 else if (Input.GetKey(KeyCode.Alpha5))
995 {
996 result = 4;
997 }
998 else if (Input.GetKey(KeyCode.Alpha6))
999 {
1000 result = 5;
1001 }
1002 else if (Input.GetKey(KeyCode.Alpha7))
1003 {
1004 result = 6;
1005 }
1006 else if (Input.GetKey(KeyCode.Alpha8))
1007 {
1008 result = 7;
1009 }
1010 else if (Input.GetKey(KeyCode.Alpha9))
1011 {
1012 result = 8;
1013 }
1014 return result;
1015 }
1016
1017 private static EAction GetAction()
1018 {
1019 string inputString = Input.inputString;
1020 if (Input.GetKeyDown(KeyCode.Escape))
1021 {
1022 return EAction.Cancel;
1023 }
1024 if (Input.GetKeyDown(keys.wait.key) || Input.GetKey(KeyCode.Keypad5))
1025 {
1026 return EAction.Wait;
1027 }
1028 if (Input.GetKeyDown(keys.emptyHand.key))
1029 {
1030 return EAction.EmptyHand;
1031 }
1032 if (Input.GetKeyDown(keys.autoCombat.key))
1033 {
1034 return EAction.AutoCombat;
1035 }
1036 if (Input.GetKeyDown(keys.examine.key))
1037 {
1038 return EAction.Examine;
1039 }
1040 if (Input.GetKeyDown(keys.getAll.key))
1041 {
1042 return EAction.GetAll;
1043 }
1044 if (Input.GetKeyDown(keys.dump.key))
1045 {
1046 return EAction.Dump;
1047 }
1048 if (Input.GetKeyDown(keys.mute.key))
1049 {
1050 return EAction.Mute;
1051 }
1052 if (Input.GetKeyDown(keys.meditate.key))
1053 {
1054 return EAction.Meditate;
1055 }
1056 if (Input.GetKeyDown(keys.search.key))
1057 {
1058 return EAction.Search;
1059 }
1060 if (keyFire.Update())
1061 {
1062 return keyFire.Action;
1063 }
1064 if (keyWait.Update())
1065 {
1066 return keyWait.Action;
1067 }
1068 if (!isShiftDown)
1069 {
1070 if (Input.GetKeyDown(keys.chara.key))
1071 {
1072 return EAction.MenuChara;
1073 }
1074 if (Input.GetKeyDown(keys.journal.key))
1075 {
1076 return EAction.MenuJournal;
1077 }
1078 if (Input.GetKeyDown(keys.inventory.key))
1079 {
1080 return EAction.MenuInventory;
1081 }
1082 if (Input.GetKeyDown(keys.ability.key))
1083 {
1084 return EAction.MenuAbility;
1085 }
1086 if (Input.GetKeyDown(keys.log.key))
1087 {
1088 return EAction.Log;
1089 }
1090 if (Input.GetKeyDown(keys.report.key))
1091 {
1092 return EAction.Report;
1093 }
1094 if (Input.GetKeyDown(keys.quickSave.key))
1095 {
1096 return EAction.QuickSave;
1097 }
1098 if (Input.GetKeyDown(keys.quickLoad.key))
1099 {
1100 return EAction.QuickLoad;
1101 }
1102 }
1103 if (!(inputString == "?"))
1104 {
1105 if (inputString == "g")
1106 {
1107 return EAction.ShowGrid;
1108 }
1109 return EAction.None;
1110 }
1111 return EAction.Help;
1112 }
1113
1114 public static void RestoreDefaultKeys()
1115 {
1116 }
1117
1118 public static void Select(GameObject go)
1119 {
1120 eventSystem.SetSelectedGameObject(null);
1121 eventSystem.SetSelectedGameObject(go);
1122 }
1123}
EAction
Definition: EAction.cs:2
void Update()
Definition: ButtonState.cs:80
bool clicked
Definition: ButtonState.cs:37
void Consume()
Definition: ButtonState.cs:184
KeyMap inventory
Definition: EInput.cs:90
KeyMap mouseMiddle
Definition: EInput.cs:135
KeyMap axisUpRight
Definition: EInput.cs:65
KeyMap axisUpLeft
Definition: EInput.cs:60
KeyMap axisDownLeft
Definition: EInput.cs:70
List< KeyMap > List()
Definition: EInput.cs:190
KeyMap axisDownRight
Definition: EInput.cs:75
KeyMap axisRight
Definition: EInput.cs:55
KeyMap switchHotbar
Definition: EInput.cs:155
KeyCode key
Definition: EInput.cs:14
bool required
Definition: EInput.cs:16
int GetGroup()
Definition: EInput.cs:18
EAction action
Definition: EInput.cs:12
Func< KeyMap > func
Definition: EInput.cs:209
bool Update(bool forcePress=false)
Definition: EInput.cs:215
Definition: EInput.cs:8
static float durationAxis
Definition: EInput.cs:295
static bool IsAnyKeyDown(bool includeAxis=true, bool _skipframe=true)
Definition: EInput.cs:619
static bool isCancel
Definition: EInput.cs:378
static Vector2 forbidAxis
Definition: EInput.cs:333
static int GetFunctionkeyDown()
Definition: EInput.cs:937
static void WaitReleaseKey()
Definition: EInput.cs:650
static GameObject selectedGO
Definition: EInput.cs:395
static Vector2 lastAxis
Definition: EInput.cs:305
static void WaitInput(float time)
Definition: EInput.cs:397
static int wheel
Definition: EInput.cs:289
static float durationAxisDiagonal
Definition: EInput.cs:301
static float antiMissClick
Definition: EInput.cs:323
static bool hasMouseMoved
Definition: EInput.cs:311
static Vector3 uiMousePosition
Definition: EInput.cs:369
static ButtonState middleMouse
Definition: EInput.cs:353
static bool hasShiftChanged
Definition: EInput.cs:273
static bool IsConsumed
Definition: EInput.cs:393
static bool isCtrlDown
Definition: EInput.cs:263
static bool axisReleased
Definition: EInput.cs:281
static bool requireAxisReset
Definition: EInput.cs:269
float repeatSpeed
Definition: EInput.cs:373
static Vector3 dragAmount
Definition: EInput.cs:347
static void Consume(int _skipFrame)
Definition: EInput.cs:656
static bool axisYChanged
Definition: EInput.cs:315
static KeyMapManager keys
Definition: EInput.cs:367
static bool disableKeyAxis
Definition: EInput.cs:365
static EInput Instance
Definition: EInput.cs:255
static void UpdateAxis()
Definition: EInput.cs:706
static bool isAltDown
Definition: EInput.cs:265
static float dragHack
Definition: EInput.cs:327
static bool requireConfirmReset
Definition: EInput.cs:267
static bool rightScroll
Definition: EInput.cs:363
static bool isInputFieldActive
Definition: EInput.cs:277
static ButtonState mouse4
Definition: EInput.cs:357
static Vector2 axis
Definition: EInput.cs:331
float repeatThresh
Definition: EInput.cs:371
static bool firstAxisPressed
Definition: EInput.cs:279
static EventSystem eventSystem
Definition: EInput.cs:257
static float ignoreWheelDuration
Definition: EInput.cs:329
static void UpdateOnlyAxis()
Definition: EInput.cs:464
static Func< string, string > LangGetter
Definition: EInput.cs:253
static bool isNext
Definition: EInput.cs:391
static ButtonState buttonCtrl
Definition: EInput.cs:361
static ButtonState leftMouse
Definition: EInput.cs:349
static float waitReleaseKeyTimer
Definition: EInput.cs:303
static void Update()
Definition: EInput.cs:475
static List< ButtonState > buttons
Definition: EInput.cs:319
static void ConsumeWheel()
Definition: EInput.cs:683
static bool isShiftDown
Definition: EInput.cs:261
static void Select(GameObject go)
Definition: EInput.cs:1118
static Vector2 prevAxis
Definition: EInput.cs:309
static void SetKeyMap(KeyMapManager _keys)
Definition: EInput.cs:433
static bool isConfirm
Definition: EInput.cs:375
static Vector3 dragStartPos
Definition: EInput.cs:341
static bool isPrev
Definition: EInput.cs:389
static Vector3 lastMousePos
Definition: EInput.cs:345
static ButtonState buttonScroll
Definition: EInput.cs:359
static ButtonState AddButton(int mouse)
Definition: EInput.cs:444
static float durationAxisRelease
Definition: EInput.cs:299
static int missClickButton
Definition: EInput.cs:291
static ButtonState rightMouse
Definition: EInput.cs:351
static int functionkey
Definition: EInput.cs:285
static float durationFirstAxis
Definition: EInput.cs:297
static void ToggleIME(bool on)
Definition: EInput.cs:459
static ButtonState mouse3
Definition: EInput.cs:355
static float waitInput
Definition: EInput.cs:293
static int skipFrame
Definition: EInput.cs:287
static bool axisXChanged
Definition: EInput.cs:313
static Vector3 mpos
Definition: EInput.cs:337
static void Consume(bool consumeAxis=false, int _skipFrame=1)
Definition: EInput.cs:661
void Awake()
Definition: EInput.cs:402
static EAction GetAction()
Definition: EInput.cs:1017
static void ModAxisX(int x)
Definition: EInput.cs:694
static Vector3 mposWorld
Definition: EInput.cs:339
static bool waitReleaseAnyKey
Definition: EInput.cs:317
static void DisableIME()
Definition: EInput.cs:454
static bool haltInput
Definition: EInput.cs:275
static float delta
Definition: EInput.cs:321
static Vector3 dragStartPos2
Definition: EInput.cs:343
static KeyboardPress keyFire
Definition: EInput.cs:249
static void SetAxis(int x, int y)
Definition: EInput.cs:688
static void Init()
Definition: EInput.cs:408
static Vector2 axisDiagonal
Definition: EInput.cs:335
static float missClickDuration
Definition: EInput.cs:325
static int GetHotkey()
Definition: EInput.cs:975
static int hotkey
Definition: EInput.cs:283
static KeyboardPress keyWait
Definition: EInput.cs:251
static bool hasAxisMoved
Definition: EInput.cs:271
static void ModAxisY(int y)
Definition: EInput.cs:700
static Vector2 firstAxis
Definition: EInput.cs:307
static int GetHotkeyDown()
Definition: EInput.cs:895
static EAction action
Definition: EInput.cs:259
static void RestoreDefaultKeys()
Definition: EInput.cs:1114