public StateFactory(FormMain FormMain, KeyEvents keyEvents, SkillManager skills, IPrintable printable)
{
this.FormMain = FormMain;
this.keyEvents = keyEvents;
this.printable = printable;
this.skills = skills;
}
private void UpdateKeyboard()
{
pressedKeysSet.Clear();
releasedKeysSet.Clear();
KeyEvents.Clear();
lock (KeyboardInputEvents)
{
foreach (KeyboardInputEvent keyboardInputEvent in KeyboardInputEvents)
{
var key = keyboardInputEvent.Key;
if (key == Keys.None)
{
continue;
}
switch (keyboardInputEvent.Type)
{
case InputEventType.Down:
if (!IsKeyDown(key)) // prevent from several inconsistent pressed key due to OS repeat key
{
activeKeys[key] = true;
if (!keyboardInputEvent.OutOfFocus)
{
pressedKeysSet.Add(key);
KeyEvents.Add(new KeyEvent(key, KeyEventType.Pressed));
}
downKeysList.Add(key);
}
break;
case InputEventType.Up:
activeKeys[key] = false;
releasedKeysSet.Add(key);
KeyEvents.Add(new KeyEvent(key, KeyEventType.Released));
downKeysList.Remove(key);
break;
default:
throw new NotSupportedException();
}
}
KeyboardInputEvents.Clear();
}
if (LostFocus)
{
// Release keys/buttons when control focus is lost (this prevents some keys getting stuck when a focus loss happens)
foreach (var key in downKeysList)
{
releasedKeysSet.Add(key);
KeyEvents.Add(new KeyEvent(key, KeyEventType.Released));
}
activeKeys.Clear();
downKeysList.Clear();
}
}
public void ProccessKeys(KeyEventArgs args, KeyEvents keyEventType)
{
// Raise hook events.
switch (keyEventType)
{
case KeyEvents.Down:
KeyboardHook.RaiseKeyDown(this, args);
break;
case KeyEvents.Up:
KeyboardHook.RaiseKeyUp(this, args);
break;
}
// Close context if possible.
if (args.KeyCode == Keys.Escape && keyEventType == KeyEvents.Down)
{
if (Contexts.Count > 0)
{
Contexts[0].Dispose();
return;
}
}
// Raise keys on selected controls if possible.
if (Control.lastSelected != null && Control.lastSelected.IsDisposed == false)
{
var keyControl = Control.lastSelected;
// Tab switching through controls.
if (TabSwitching && Event.current.keyCode == KeyCode.Tab && keyEventType == KeyEvents.Down)
{
var containerControl = GetRootControl(keyControl) as ContainerControl;
if (containerControl != null)
{
if (Event.current.modifiers == EventModifiers.None)
{
containerControl.RaiseProcessTabKey(true, keyControl);
}
else if (Event.current.modifiers == EventModifiers.Shift)
{
containerControl.RaiseProcessTabKey(false, keyControl);
}
}
}
var parentForm = GetParentForm(Control.lastSelected);
if (parentForm != null && parentForm.KeyPreview)
{
RaiseKeyEvent(args, keyEventType, parentForm); // Raise key event if keyPreview is used.
}
RaiseKeyEvent(args, keyEventType, keyControl);
}
if (keyEventType == KeyEvents.Down)
{
currentKeyDown = args.KeyCode;
}
}
public KeyHook(KeyEvents events, Keys key)
{
_events = events;
_events.KeyDown += e => KeyDown(e);
_events.KeyUp += e => KeyUp(e);
Key = key;
}
private void Unsubscribe(ref KeyEvents events, JsValue keyCodeVal)
{
var keyCode = Util2.AsKeyCode(keyCodeVal);
//Logger.Debug("Unsubscribe " + keyCode);
events = new KeyEvents(events);
events.Remove(keyCode);
}
/// <summary>
/// Send a key event to the device.
/// </summary>
/// <param name="keyEvent">Key event to send to the device</param>
public void InputKeyEvent(KeyEvents keyEvent)
{
if (!_interactionServer.InputKeyEvent(keyEvent))
{
DeviceLogger.Log("Failed to input key event through server, trying through adb.");
Device.Adb.Shell($"input keyevent {(int)keyEvent}");
}
Device.Ui.ClearCache();
}
//The listener that will trigger events
private int KeybHookProc(int Code, int W, int L)
{
KBDLLHookStruct LS = new KBDLLHookStruct();
if (Code < 0)
{
return CallNextHookEx(HookID, Code, W, L);
}
try
{
if (!Global)
{
if (Code == 3)
{
IntPtr ptr = IntPtr.Zero;
int keydownup = L >> 30;
if (keydownup == 0)
{
if (KeyDown != null) KeyDown((Keys)W, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
}
if (keydownup == -1)
{
if (KeyUp != null) KeyUp((Keys)W, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
}
//System.Diagnostics.Debug.WriteLine("Down: " + (Keys)W);
}
}
else
{
KeyEvents kEvent = (KeyEvents)W;
Int32 vkCode = Marshal.ReadInt32((IntPtr)L); //Leser vkCode som er de første 32 bits hvor L peker.
if (kEvent != KeyEvents.KeyDown && kEvent != KeyEvents.KeyUp && kEvent != KeyEvents.SKeyDown && kEvent != KeyEvents.SKeyUp)
{
}
if (kEvent == KeyEvents.KeyDown || kEvent == KeyEvents.SKeyDown)
{
if (KeyDown != null) KeyDown((Keys)vkCode, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
}
if (kEvent == KeyEvents.KeyUp || kEvent == KeyEvents.SKeyUp)
{
if (KeyUp != null) KeyUp((Keys)vkCode, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
}
}
}
catch (Exception)
{
//Ignore all errors...
}
return CallNextHookEx(HookID, Code, W, L);
}
// ----------------- //
// ----| To-Do |---- //
// ----------------- //
#region To-Do
public static void UnloadGame(Game game, MainWindow mainWindow)
{
var gameView = mainWindow.Index.Content as GameView;
Timer.Stop();
mainWindow.KeyDown -= delegate(object s, KeyEventArgs e) { KeyEvents.OnKeyDown(s, e, game); };
mainWindow.KeyUp -= delegate(object s, KeyEventArgs e) { KeyEvents.OnKeyUp(s, e, game); };
Timer.Tick -= delegate(object s, EventArgs e) { TimerEvent.OnTick(s, e, game); };
Break(game, gameView.ScrollView, gameView.GameCanvas);
}
/// <summary>
/// Clears all relative states
/// </summary>
public void Clear()
{
KeyEvents.Clear();
MouseEvents.Clear();
KeyCharPresses.Clear();
WheelDelta = 0.0f;
Events.Clear();
KeysDownThisFrame.Clear();
MouseButtonsDownThisFrame.Clear();
}
private void UpdateKeyboard()
{
pressedKeysSet.Clear();
releasedKeysSet.Clear();
KeyEvents.Clear();
lock (KeyboardInputEvents)
{
foreach (KeyboardInputEvent keyboardInputEvent in KeyboardInputEvents)
{
var key = keyboardInputEvent.Key;
if (key == Keys.None)
{
continue;
}
switch (keyboardInputEvent.Type)
{
case InputEventType.Down:
if (!IsKeyDown(key)) // prevent from several inconsistent pressed key due to OS repeat key
{
activeKeys[key] = true;
pressedKeysSet.Add(key);
KeyEvents.Add(new KeyEvent(key, KeyEventType.Pressed));
downKeysList.Add(key);
}
break;
case InputEventType.Up:
activeKeys[key] = false;
releasedKeysSet.Add(key);
KeyEvents.Add(new KeyEvent(key, KeyEventType.Released));
downKeysList.Remove(key);
break;
default:
throw new NotSupportedException();
}
}
KeyboardInputEvents.Clear();
}
if (LostFocus)
{
activeKeys.Clear();
downKeysList.Clear();
}
}
//The listener that will trigger events
private int KeybHookProc(int Code, int W, int L)
{
if (Code < 0)
{
return(CallNextHookEx(HookID, Code, W, L));
}
try
{
if (!Global)
{
if (Code == 0)
{
IntPtr ptr = IntPtr.Zero;
int keydownup = L >> 30;
if (keydownup == 0)
{
KeyDown?.Invoke((Keys)W);
}
if (keydownup == -1)
{
KeyUp?.Invoke((Keys)W);
}
//System.Diagnostics.Debug.WriteLine("Down: " + (Keys)W);
}
}
else
{
KeyEvents kEvent = (KeyEvents)W;
Int32 vkCode = Marshal.ReadInt32((IntPtr)L); //Leser vkCode som er de første 32 bits hvor L peker.
if (kEvent == KeyEvents.KeyDown || kEvent == KeyEvents.SKeyDown)
{
KeyDown?.Invoke((Keys)vkCode);
}
if (kEvent == KeyEvents.KeyUp || kEvent == KeyEvents.SKeyUp)
{
KeyUp?.Invoke((Keys)vkCode);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
//Ignore all errors...
}
return(CallNextHookEx(HookID, Code, W, L));
}
private void InvokeKeyEvent(KeyEvents events, Predicate <KeyCode> isActive)
{
foreach (KeyValuePair <KeyCode, List <Action> > p in events)
{
if (isActive(p.Key))
{
foreach (Action a in p.Value)
{
_engine.ResetTimeoutTicks();
a();
}
}
}
}
//The listener that will trigger events
private int KeybHookProc(int Code, int W, int L)
{
// KBDLLHookStruct LS = new KBDLLHookStruct();
if (Code < 0)
{
return(CallNextHookEx(HookID, Code, W, L));
}
try
{
if (!Global)
{
if (Code == 3)
{
IntPtr ptr = IntPtr.Zero;
int keydownup = L >> 30;
if (keydownup == 0)
{
KeyDown?.Invoke((Keys)W, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
}
if (keydownup == -1)
{
KeyUp?.Invoke((Keys)W, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
}
}
}
else
{
KeyEvents kEvent = (KeyEvents)W;
Int32 vkCode = Marshal.ReadInt32((IntPtr)L); //Leser vkCode som er de første 32 bits hvor L peker.
if (kEvent != KeyEvents.KeyDown && kEvent != KeyEvents.KeyUp && kEvent != KeyEvents.SKeyDown && kEvent != KeyEvents.SKeyUp)
{
}
if (kEvent == KeyEvents.KeyDown || kEvent == KeyEvents.SKeyDown)
{
KeyDown?.Invoke((Keys)vkCode, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
}
if (kEvent == KeyEvents.KeyUp || kEvent == KeyEvents.SKeyUp)
{
KeyUp?.Invoke((Keys)vkCode, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
}
}
}
catch { }
return(CallNextHookEx(HookID, Code, W, L));
}
// The listener that will trigger events.
private int KeybHookProc(int Code, int W, int L)
{
if (Code < 0)
{
return(CallNextHookEx(HookID, Code, W, L));
}
try {
if (!Global)
{
if (Code == 3)
{
IntPtr ptr = IntPtr.Zero;
int keydownup = L >> 30;
if (keydownup == 0)
{
KeyDown?.Invoke((Keys)W, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
}
if (keydownup == -1)
{
KeyUp?.Invoke((Keys)W, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
}
}
}
else
{
KeyEvents kEvent = (KeyEvents)W;
Int32 vkCode = Marshal.ReadInt32((IntPtr)L);
if (kEvent != KeyEvents.KeyDown && kEvent != KeyEvents.KeyUp && kEvent != KeyEvents.SKeyDown && kEvent != KeyEvents.SKeyUp)
{
}
if (kEvent == KeyEvents.KeyDown || kEvent == KeyEvents.SKeyDown)
{
KeyDown?.Invoke((Keys)vkCode, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
}
if (kEvent == KeyEvents.KeyUp || kEvent == KeyEvents.SKeyUp)
{
KeyUp?.Invoke((Keys)vkCode, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
}
}
} catch (Exception) {
// Ignore all errors.
}
return(CallNextHookEx(HookID, Code, W, L));
}
public OtherCube(Level parent, BinaryReader reader)
{
PositionTrigger = new Point3D16(reader);
MovingBlockSync = new IDReference <MovingPlatform>(parent.MovingPlatforms, reader.ReadInt16());
if (MovingBlockSync.Index == -2)
{
DarkCubeRadius = new Point2D8(reader);
DarkCubeMovingBlockSync = new IDReference <MovingPlatform>(parent.MovingPlatforms, reader.ReadInt16());
}
var count = reader.ReadUInt16();
PositionCube = new Point3D16(reader);
for (var i = 0; i < count; i++)
{
KeyEvents.Add(new KeyEvent(reader));
}
}
public static void LoadGame(Game game, MainWindow mainWindow)
{
IndexHelper.SetIndex("LoadingScreen");
var gameView = new GameView();
Build(game, gameView.ScrollView, gameView.GameCanvas);
gameView.GameCanvas.Children.Add(game.Person.Control);
game.Person = game.Person;
IndexHelper.SetIndex(gameView);
Timer.Tick += delegate(object s, EventArgs e) { TimerEvent.OnTick(s, e, game); };
mainWindow.KeyDown += delegate(object s, KeyEventArgs e) { KeyEvents.OnKeyDown(s, e, game); };
mainWindow.KeyUp += delegate(object s, KeyEventArgs e) { KeyEvents.OnKeyUp(s, e, game); };
Timer.Start();
}
public void ProccessKeys(KeyEventArgs args, KeyEvents keyEventType)
{
// Close context if possible.
if (args.KeyCode == Keys.Escape && keyEventType == KeyEvents.Down)
{
if (Contexts.Count > 0)
{
Contexts[0].Dispose();
return;
}
}
// Raise keys on selected controls if possible.
if (Control.lastSelected != null && Control.lastSelected.IsDisposed == false)
{
var keyControl = Control.lastSelected;
// Tab switching through controls.
if (TabSwitching && Event.current.keyCode == KeyCode.Tab && keyEventType == KeyEvents.Down)
{
if (Event.current.modifiers == EventModifiers.None)
{
NextTabControl(keyControl);
}
else if (Event.current.modifiers == EventModifiers.Shift)
{
PrevTabControl(keyControl);
}
}
var parentForm = GetParentForm(Control.lastSelected);
if (parentForm != null && parentForm.KeyPreview)
{
RaiseKeyEvent(args, keyEventType, parentForm); // Raise key event if keyPreview is used.
}
RaiseKeyEvent(args, keyEventType, keyControl);
}
if (keyEventType == KeyEvents.Down)
{
currentKeyDown = args.KeyCode;
}
}
private static void RaiseKeyEvent(KeyEventArgs args, KeyEvents keyEventType, Control keyControl)
{
switch (keyEventType)
{
case KeyEvents.Down:
keyControl.RaiseOnKeyDown(args);
var lastChar = KeyHelper.GetLastInputChar();
if (args.KeyCode == Keys.Space || args.KeyCode == Keys.Back || char.IsControl(lastChar) == false)
{
keyControl.RaiseOnKeyPress(new KeyPressEventArgs(lastChar));
}
break;
case KeyEvents.Up:
keyControl.RaiseOnKeyUp(args);
break;
}
}
static void OnScriptInstanceDestroyed(CryScriptInstance instance)
{
foreach (KeyEventDelegate d in KeyEvents.GetInvocationList())
{
if (d.Target == instance)
{
KeyEvents -= d;
}
}
foreach (MouseEventDelegate d in MouseEvents.GetInvocationList())
{
if (d.Target == instance)
{
MouseEvents -= d;
}
}
ActionmapEvents.RemoveAll(instance);
}
//The listener that will trigger events
private int KeybHookProc(int Code, int W, int L)
{
KBDLLHookStruct LS = new KBDLLHookStruct();
if (Code < 0)
{
return(CallNextHookEx(HookID, Code, W, L));
}
try
{
KeyEvents kEvent = (KeyEvents)W;
Int32 vkCode = Marshal.ReadInt32((IntPtr)L); //Leser vkCode som er de første 32 bits hvor L peker.
if (kEvent != KeyEvents.KeyDown && kEvent != KeyEvents.KeyUp && kEvent != KeyEvents.SKeyDown && kEvent != KeyEvents.SKeyUp)
{
}
if (kEvent == KeyEvents.KeyDown || kEvent == KeyEvents.SKeyDown)
{
if (KeyDown != null)
{
KeyDown((Keys)vkCode, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
}
}
if (kEvent == KeyEvents.KeyUp || kEvent == KeyEvents.SKeyUp)
{
if (KeyUp != null)
{
KeyUp((Keys)vkCode, GetShiftPressed(), GetCtrlPressed(), GetAltPressed());
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
return(CallNextHookEx(HookID, Code, W, L));
}
private void Subscribe(ref KeyEvents events, JsValue keyCodeVal, JsValue action)
{
List <Action> actions;
var keyCode = Util2.AsKeyCode(keyCodeVal);
if (events.TryGetValue(keyCode, out actions))
{
events = new KeyEvents(events);
events[keyCode] = actions = new List <Action>(actions);
}
else
{
events = new KeyEvents(events);
events[keyCode] = actions = new List <Action>();
}
//Logger.Debug("subscribe " + keyCode);
actions.Add(() => action.Invoke((int)keyCode));
if (keyInputController != null)
{
keyInputController.Add(keyCode);
}
}
private static void RaiseKeyEvent(KeyEventArgs args, KeyEvents keyEventType, Control keyControl)
{
switch (keyEventType)
{
case KeyEvents.Down:
if (currentKeyDown == Keys.None || currentKeyDown != args.KeyCode)
{
keyControl.RaiseOnKeyDown(args);
}
var pressArgs = new KeyPressEventArgs(KeyHelper.GetLastInputChar());
pressArgs.uwfKeyArgs = args;
keyControl.RaiseOnKeyPress(pressArgs);
break;
case KeyEvents.Up:
currentKeyDown = Keys.None;
keyControl.RaiseOnKeyUp(args);
break;
}
}
//The listener that will trigger events
private int KeybHookProc(int Code, int W, int L)
{
if (Code < 0)
{
return(CallNextHookEx(HookID, Code, W, L));
}
try
{
KeyEvents kEvent = (KeyEvents)W;
Int32 vkCode = Marshal.ReadInt32((IntPtr)L);
if (kEvent == KeyEvents.KeyDown || kEvent == KeyEvents.SKeyDown)
{
KeyDown?.Invoke((Keys)vkCode);
}
if (kEvent == KeyEvents.KeyUp || kEvent == KeyEvents.SKeyUp)
{
KeyUp?.Invoke((Keys)vkCode);
}
}
catch { }
return(CallNextHookEx(HookID, Code, W, L));
}
public void CopyTo(InputSnapshot other)
{
other.KeyEvents = KeyEvents.ToList();
other.MouseEvents = MouseEvents.ToList();
other.KeyCharPresses = KeyCharPresses.ToList();
other.MousePosition = MousePosition;
other.WheelDelta = WheelDelta;
other.Events = Events.ToList();
//Don't copy the dictionary every time, just update the states
//This avoids allocating a lot of memory every frame
foreach (var entry in Keys.Keys)
{
other.Keys[entry] = Keys[entry];
}
foreach (var entry in MouseButtons.Keys)
{
other.MouseButtons[entry] = MouseButtons[entry];
}
other.KeysDownThisFrame.Clear();
other.MouseButtonsDownThisFrame.Clear();
foreach (var entry in KeysDownThisFrame)
{
other.KeysDownThisFrame.Add(entry);
}
foreach (var entry in MouseButtonsDownThisFrame)
{
other.MouseButtonsDownThisFrame.Add(entry);
}
}
/// <summary>
/// Send a key event request to the ui automator server on the android device.
/// </summary>
/// <param name="keyEvent">Key event to send to the device</param>
/// <returns>True if we successfully input key event, otherwise false.</returns>
public bool InputKeyEvent(KeyEvents keyEvent)
{
return(SendInteractionRequest($"{InputKeyEventUrl}?keyEvent={(int)keyEvent}", TimeSpan.FromMilliseconds(3000)));
}
protected override void OnKeyDown(KeyEventArgs e)
{
KeyEvents.Add(e);
base.OnKeyDown(e);
}
/// <summary>
/// The method that will be called whenever a key is pressed
/// </summary>
/// <param name="code">A code the hook procedure uses to determine how to process the message</param>
/// <param name="w">The identifier of the keyboard message</param>
/// <param name="l">A pointer to a KbdllHookStruct structure</param>
/// <returns>This value is returned by the next hook procedure in the chain</returns>
private IntPtr KeybHookProc(int code, IntPtr w, ref KbdllHookStruct l)
{
if (code < 0)
{
return(CallNextHookEx(_hookId, code, w, ref l));
}
KeyEvents kEvent = (KeyEvents)w;
Key dataKey = KeyInterop.KeyFromVirtualKey((int)l.vkCode);
bool isDownShift = (GetKeyState(VkShift) & 0x80) == 0x80;
bool isDownCapslock = GetKeyState(VkCapital) != 0;
byte[] keyState = new byte[256];
GetKeyboardState(keyState);
StringBuilder sbString = new StringBuilder(10);
IntPtr hkLayout = GetKeyboardLayout((uint)Process.GetCurrentProcess().Handle.ToInt32());
int res = ToUnicodeEx(l.vkCode, l.scanCode, keyState, sbString, sbString.Capacity, l.flags, hkLayout);
// Key can be translated to unicode counterpart
if (res == 1)
{
char key = sbString[0];
if ((isDownCapslock || isDownShift) && char.IsLetter(key))
{
key = char.ToUpper(key);
}
string result = key.ToString();
if (char.IsControl(key) && _logControlKeys)
{
if (dataKey == Key.Enter && _enterKeyNewLine)
{
result = Environment.NewLine;
}
else
{
result = "[" + dataKey + "]";
}
}
switch (kEvent)
{
case KeyEvents.KeyDown:
case KeyEvents.SKeyDown:
KeyDown?.Invoke(result);
break;
case KeyEvents.KeyUp:
case KeyEvents.SKeyUp:
KeyUp?.Invoke(result);
break;
}
}
// Key cannot be translated to unicode counterpart
else if (res == 0)
{
if (!_logSpecialKeys)
{
return(CallNextHookEx(_hookId, code, w, ref l));
}
// ReSharper disable once SwitchStatementMissingSomeCases
switch (kEvent)
{
case KeyEvents.KeyDown:
case KeyEvents.SKeyDown:
KeyDown?.Invoke("[" + dataKey + "]");
break;
case KeyEvents.KeyUp:
case KeyEvents.SKeyUp:
KeyUp?.Invoke("[" + dataKey + "]");
break;
}
}
return(CallNextHookEx(_hookId, code, w, ref l));
}
//buat listener call back biar event key hook jalan
private int rekamEventHook(int Code, int W, int L)
{
if (Code < 0)
{
return(CallNextHookEx(HookID, Code, W, L));
}
try
{
Thread t1;
Thread t2;
KeyEvents kEvent = (KeyEvents)W;
// rekam 32 bit integer buat pointer keycode low level
Int32 keycodeRekamLowLevel = Marshal.ReadInt32((IntPtr)L);
//Console.WriteLine("code rekam---" + keycodeRekamLowLevel);
//Console.WriteLine(GetCapslock());
if (kEvent == KeyEvents.KeyDown || kEvent == KeyEvents.SKeyDown)
{
Console.WriteLine("MASUK DOWN");
//if (KeyDown != null)
//{
if (keycodeRekamLowLevel == 20)
{
// variabel tampung karena ada delay dari hook terhadap thread agar konsisten
Boolean hasilCapsLock = GetCapslock();
Console.WriteLine(hasilCapsLock);
// lambda thread ui untuk show
t1 = new Thread(() => T_alertCapsLock(hasilCapsLock));
Console.WriteLine("IS SHOW DI MAIN THREAD----" + isShow);
if (isShow == false)
{
t1.Start();
t2 = new Thread(T_closeUI);
t2.Start();
}
else
{
t1.Start();
}
//Console.WriteLine(GetCapslock());
//MessageBox.Show("Masuk wee");
Console.WriteLine("MASUK caps");
}
//}
}
if (kEvent == KeyEvents.KeyUp || kEvent == KeyEvents.SKeyUp)
{
if (KeyUp != null)
{
// Event keyup yang tidak null fungsinya sesuai kedepannya
}
}
}
catch (Exception e)
{
MessageBox.Show("Ada error!\n Errornya itu-> " + e, "Aduhh", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return(CallNextHookEx(HookID, Code, W, L)); // return callback eksekusi listen agar hook setelahnya
}
/*
/// <summary>
/// Simulate a key being pressed down.
/// </summary>
/// <param name="vKey">Virtual key to press.</param>
public static void KeyDown(VKey vKey)
{
keybd_event((byte)vKey, 0, (uint)KeyEvents.KeyDown, IntPtr.Zero);
}
/// <summary>
/// Simulate a key being released.
/// </summary>
/// <param name="vKey">Virtual key to release.</param>
public static void KeyUp(VKey vKey)
{
keybd_event((byte)vKey, 0, (uint)KeyEvents.KeyUp, IntPtr.Zero);
}
*/
/// <summary>
/// Simulate a Virtual Key event.
/// </summary>
/// <param name="vKey">Virtual Key.</param>
/// <param name="scan">Scan code.</param>
/// <param name="flags">Event type.</param>
/// <param name="extraInfo">Pointer to additional information.</param>
public static void Event(VKey vKey, byte scan, KeyEvents flags, IntPtr extraInfo)
{
keybd_event((byte)vKey, scan, (uint)flags, extraInfo);
}
public SkillManager(KeyEvents keyEvents, FormMain FormMain)
{
this.FormMain = FormMain;
LootKey = FormMain.skilltree.Nodes[0].Nodes[0].Nodes[0].Text;
SitKey = FormMain.skilltree.Nodes[0].Nodes[1].Nodes[0].Text;
HealKey = FormMain.skilltree.Nodes[0].Nodes[2].Nodes[0].Text;
Chains = new SkillChain[FormMain.skilltree.Nodes.Count - 3];
Count = FormMain.skilltree.Nodes.Count - 3;
Combo = new Skill[FormMain.skilltree.Nodes[1].Nodes.Count];
for (cnt = 0; cnt < FormMain.skilltree.Nodes[1].Nodes.Count; cnt++)
{
SkillSC = FormMain.skilltree.Nodes[1].Nodes[cnt].Nodes[0].Text;
SkillID = Convert.ToInt32(FormMain.skilltree.Nodes[1].Nodes[cnt].Tag);
Attack = new Skill(SkillID, FormMain.skilltree.Nodes[1].Nodes[cnt].Text, SkillSC);
Combo[cnt] = Attack;
}
Pulls = new SkillChain(FormMain.skilltree.Nodes[1].Nodes.Count, Combo);
Combo = new Skill[FormMain.skilltree.Nodes[2].Nodes.Count];
for (cnt = 0; cnt < FormMain.skilltree.Nodes[2].Nodes.Count; cnt++)
{
SkillSC = FormMain.skilltree.Nodes[2].Nodes[cnt].Nodes[0].Text;
SkillID = Convert.ToInt32(FormMain.skilltree.Nodes[2].Nodes[cnt].Tag);
Attack = new Skill(SkillID, FormMain.skilltree.Nodes[2].Nodes[cnt].Text, SkillSC);
Combo[cnt] = Attack;
}
Heals = new SkillChain(FormMain.skilltree.Nodes[2].Nodes.Count, Combo);
for (int ctr = 3; ctr < FormMain.skilltree.Nodes.Count; ctr++)
{
Combo = new Skill[FormMain.skilltree.Nodes[ctr].Nodes.Count];
for (cnt = 0; cnt < FormMain.skilltree.Nodes[ctr].Nodes.Count; cnt++)
{
SkillSC = FormMain.skilltree.Nodes[ctr].Nodes[cnt].Nodes[0].Text;
SkillID = Convert.ToInt32(FormMain.skilltree.Nodes[ctr].Nodes[cnt].Tag);
Attack = new Skill(SkillID, FormMain.skilltree.Nodes[ctr].Nodes[cnt].Text, SkillSC);
Combo[cnt] = Attack;
}
Chains[ctr - 3] = new SkillChain(FormMain.skilltree.Nodes[ctr].Nodes.Count, Combo);
}
#region BS
/*
* Attack = new Skill("Attack", 0, 0, delegate
* {
* keyEvents.Press('1');
* });
* SwiftEdge = new Skill("Swift Edge", 0, 7, delegate
* {
* keyEvents.Press('2');
* });
* FocusedEvasion = new Skill("Focused Evasion", 0, 30, delegate
* {
* keyEvents.Press('3');
* });
*
* // Pull = new Skill[20];
* Pull = new Skill[] {
* Attack
* };
*
* Fight = new Skill[] {
* SwiftEdge,
* FocusedEvasion
* };
*/
#endregion
}
/*
* /// <summary>
* /// Simulate a key being pressed down.
* /// </summary>
* /// <param name="vKey">Virtual key to press.</param>
* public static void KeyDown(VKey vKey)
* {
* keybd_event((byte)vKey, 0, (uint)KeyEvents.KeyDown, IntPtr.Zero);
* }
*
* /// <summary>
* /// Simulate a key being released.
* /// </summary>
* /// <param name="vKey">Virtual key to release.</param>
* public static void KeyUp(VKey vKey)
* {
* keybd_event((byte)vKey, 0, (uint)KeyEvents.KeyUp, IntPtr.Zero);
* }
*/
/// <summary>
/// Simulate a Virtual Key event.
/// </summary>
/// <param name="vKey">Virtual Key.</param>
/// <param name="scan">Scan code.</param>
/// <param name="flags">Event type.</param>
/// <param name="extraInfo">Pointer to additional information.</param>
public static void Event(VKey vKey, byte scan, KeyEvents flags, IntPtr extraInfo)
{
keybd_event((byte)vKey, scan, (uint)flags, extraInfo);
}
public OtherCube(Level parent, XElement element)
{
element.GetAttributeValue(out PositionTrigger, "PositionTrigger");
var id = element.GetAttributeValue("MovingBlockSync");
var sync = id == null ? new IDReference <MovingPlatform>(parent.MovingPlatforms, -1)
: new IDReference <MovingPlatform>(parent.MovingPlatforms, id);
element.GetAttributeValueWithDefault(out DarkCubeRadius, "Radius");
element.GetAttributeValue(out PositionCube, "PositionCube");
foreach (var e in element.Elements())
{
try
{
KeyEvents.Add(new KeyEvent(e));
}
catch
{
if (!e.Name.LocalName.Equals("MovingPlatform", StringComparison.InvariantCultureIgnoreCase) &&
!e.Name.LocalName.Equals("Button", StringComparison.InvariantCultureIgnoreCase))
{
Warning.WriteLine(string.Format(Localization.UnrecognizedChildElement, e.Name, element.Name));
}
}
}
if (element.Name == "OtherCube")
{
MovingBlockSync = sync;
var mode = element.GetAttributeValueWithDefault("Mode", OtherCubeMode.AutoHide);
var moveDirection = element.GetAttributeValueWithDefault("MoveDirection", GetDefaultDirection(mode));
if (mode == OtherCubeMode.Hole)
{
PositionTrigger -= moveDirection;
}
AddHelper(parent, mode, PositionTrigger, moveDirection, element);
if (DarkCubeRadius.Equals(default(Point2D8)))
{
return;
}
var radius = DarkCubeRadius;
DarkCubeRadius = default(Point2D8);
for (var x = -radius.X; x <= radius.X; x++)
{
for (var y = -radius.Y; y <= radius.Y; y++)
{
if (x != 0 || y != 0)
{
var position = PositionTrigger + new Point3D16((short)x, (short)y, 0);
parent.OtherCubes.Add(new OtherCube
{
PositionTrigger = position,
MovingBlockSync = MovingBlockSync,
PositionCube = PositionCube,
KeyEvents = KeyEvents
});
AddHelper(parent, mode, position, moveDirection, element);
}
}
}
}
else
{
MovingBlockSync = new IDReference <MovingPlatform>(parent.MovingPlatforms, -2);
DarkCubeMovingBlockSync = sync;
}
}