public MainWindow()
{
InitializeComponent();
var keyHandler = new KeyHandler(this, DisplayControl);
KeyDown += keyHandler.OnKeyDown;
}
public Daleks() : super("Daleks") {
setSize(1020, 820);
setResizable(false);
this.addWindowListener(new FrameListener());
var menuBar = new MenuBar();
this.setMenuBar(menuBar);
var menu = new Menu("File");
menuBar.add(menu);
var menuItem = new MenuItem("New Game");
menu.add(menuItem);
menuItem.addActionListener(p => newGame());
menuItem = new MenuItem("-");
menu.add(menuItem);
menuItem = new MenuItem("Exit");
menu.add(menuItem);
menuItem.addActionListener(p => dispose());
this.setLayout(new BorderLayout());
this.add(status = new Label("To start: File > New Game"), BorderLayout.SOUTH);
this.keyHandler = new KeyHandler(this);
this.addKeyListener(keyHandler);
this.timer = new Timer(true);
}
public void Run()
{
Log.InfoFormat("Starting timer with a sample rate of {0} ms", _sampleRateMilliseconds);
var timer = new Timer();
timer.AutoReset = true;
timer.Interval = _sampleRateMilliseconds;
timer.Elapsed += (s, e) => Tick();
timer.Start();
var keyHandler = new KeyHandler();
keyHandler.WaitForExit();
}
public void TickChatSystem()
{
if (IsChatVisible())
{
if (OpenTK.Input.Keyboard.GetState().IsKeyDown(OpenTK.Input.Key.Escape)) // TODO: Better method for this!
{
CloseChat();
return;
}
if (!WVis)
{
KeyHandler.GetKBState();
WVis = true;
}
ChatBox.Selected = true;
}
}
public static bool HandleKeys(KeyHandler handler)
{
if (Interactive)
{
while (Console.KeyAvailable)
{
ConsoleKey key = Console.ReadKey(true).Key;
if (!handler(key))
{
return(false);
}
}
}
return(true);
}
/// <summary>
/// Maps a key
/// </summary>
/// <param name="keyCombination">The combo</param>
/// <param name="keyHandler">The handler</param>
public KeyboardMapper Map(KeyCombination keyCombination, KeyHandler keyHandler)
{
#if DEBUG
if (DebugMode)
{
Debug.Log("KeyboardMapper.Map: " + keyCombination);
}
#endif
if (!_mappings.ContainsKey(keyCombination))
{
_mappings.Add(keyCombination, new List <KeyHandler>());
}
_mappings[keyCombination].Add(keyHandler);
return(this);
}
/// <summary>
/// Constructs the player object.
/// </summary>
/// <param name="game"></param>
/// <param name="GameScreen"></param>
/// <param name="keyBinds"></param>
public Player(GameRoot game, GameScreen GameScreen, KeyBinds keyBinds) : base(game, GameScreen)
{
this.KeyBinds = keyBinds;
this.keyHandler = new KeyHandler();
// The players texture is set here instead of load
// content because the StartPosition requires the textures size
this.Texture = GameRoot.ResourceManager.GetTexture("BluePlayer");
this.shootingSound = GameRoot.ResourceManager.GetSound("PlayerShoot");
this.damageSound = GameRoot.ResourceManager.GetSound("Destroy");
this.MaxHealth = 150;
this.Health = MaxHealth;
this.Speed = 450.0f;
this.exhaustAnimation = new Animation(GameRoot, GameScreen, GameRoot.ResourceManager.GetTexture("ExhaustAnimation"), 0.075f, true);
this.GameScreen.Components.Add(exhaustAnimation);
}
// Check if player is in combat without pressing any keys.
// Player might be targetting something else than the enemy target.
private void RunTargetSwitchHandler()
{
var now = DateTime.Now;
_timeSinceLastAttackInCombat = now;
Task.Run(() => {
while (_isInCombat)
{
if ((now - _timeSinceLastAttackInCombat).Seconds > 1)
{
KeyHandler.PressKey(Keys.Tab);
}
Thread.Sleep(500);
}
});
}
private void setHotkey(string key)
{
try {
if (gkh != null)
{
gkh.Unregiser();
}
KeysConverter kc = new KeysConverter();
Keys mykey = (Keys)kc.ConvertFromString(key);
gkh = new KeyHandler(mykey, this);
gkh.Register();
defaultHotkeyLabel.Text = "Default Hotkey: " + key;
}
catch (Exception) {
MessageBox.Show("Please try a real key");
}
}
public static Player CreatePlayer(Transform Parent, Vector2 Position)
{
GameObject NewObject = GameObject.CreatePrimitive(PrimitiveType.Sphere);
NewObject.transform.parent = Parent;
NewObject.transform.localScale = new Vector3(.5f, .5f, .5f);
NewObject.transform.position = Parent.position + Parent.rotation *
new Vector3(Position.x / Parent.localScale.x, Position.y / Parent.localScale.y, -.5f / Parent.localScale.z);
NewObject.GetComponent <Renderer>().material.color = Color.black;
Player NewPlayer = NewObject.AddComponent <Player>();
KeyHandler Resetter = NewObject.AddComponent <KeyHandler>();
Resetter.Key = KeyCode.R;
Resetter.Event = new UnityEngine.Events.UnityEvent();
Resetter.Event.AddListener(NewPlayer.RandomizePosition);
return(NewPlayer);
}
protected override void SetupBehaviour()
{
EventManager.On("CombatChanged", (Event ev) =>
{
_isInCombat = (bool)ev.Data;
});
EventManager.On("KeyPressRequested", (Event ev) =>
{
var keyRequest = (KeyPressRequest)ev.Data;
if (keyRequest.ModifierKey != Keys.None)
{
KeyHandler.ModifiedKeypress(keyRequest.ModifierKey, keyRequest.Key);
if (keyRequest.ModifierKey == Keys.LControlKey && keyRequest.Key == Keys.D1)
{
_isFollowing = true;
}
if (keyRequest.ModifierKey == Keys.LControlKey && keyRequest.Key == Keys.D9)
{
KeyHandler.PressKey(Keys.S, 1500);
}
if (keyRequest.ModifierKey == Keys.LControlKey && keyRequest.Key == Keys.D2)
{
if (!_isFollowing)
{
return;
}
_isFollowing = false;
KeyHandler.PressKey(Keys.S, 10);
}
}
else
{
KeyHandler.PressKey(keyRequest.Key);
}
});
EventManager.On("WrongFacing", (Event _) =>
{
KeyHandler.PressKey(Keys.D, 75);
});
}
/// <summary>
/// Repeatedly prompts the user for a key press, until any of the specified escape keys
/// are pressed.
/// <para/>
/// If the pressed key if available in the specified handlers, the corresponding handler
/// is called. If not, it is ignored and the loop continues.
/// </summary>
/// <param name="handlers">Collection of keys to handle and their handlers.</param>
/// <param name="postKeyPress">
/// Optional action to run after any key press, not counting the ignored keys and escape
/// keys.
/// </param>
/// <param name="escapeKeys">
/// The keys that will break the loop. If not specified, defaults to the escape key.
/// </param>
public static void WaitForKeysLoop(IEnumerable <KeyHandler> handlers,
Action <ConsoleKey> postKeyPress = null, IEnumerable <ConsoleKey> escapeKeys = null)
{
if (handlers is null)
{
throw new ArgumentNullException(nameof(handlers));
}
List <KeyHandler> handlersList = handlers.ToList();
if (handlersList.Count == 0)
{
throw new ArgumentException("Specify at least one handler.", nameof(handlers));
}
// If the escapeKeys parameter is not specified, default it to the Escape key.
if (escapeKeys is null)
{
escapeKeys = new[] { ConsoleKey.Escape }
}
;
// Ensure that none of the escape keys are specified in the handlers.
if (handlersList.Any(h => escapeKeys.Any(k => k == h.Key)))
{
throw new ArgumentException("Specified escape keys should not be specified in the handlers.",
nameof(escapeKeys));
}
List <ConsoleKey> escapeKeysList = escapeKeys.ToList();
ConsoleKey key = Console.ReadKey(intercept: true).Key;
while (!escapeKeysList.Any(k => k == key))
{
KeyHandler handler = handlersList.FirstOrDefault(h => h.Key == key);
if (handler != null)
{
handler.Action?.Invoke(key);
postKeyPress?.Invoke(key);
}
key = Console.ReadKey(intercept: true).Key;
}
}
}
public TheAppContext()
{
ourKeyHandler = new KeyHandler();
// Initialize Tray Icon
trayIcon = new NotifyIcon()
{
Icon = Resources.AppIcon,
ContextMenu = new ContextMenu(new MenuItem[] {
new MenuItem("Reload Settings", ReloadSettings),
new MenuItem("Exit", Exit)
}),
Visible = true
};
Form1 f1 = new Form1();
f1.ShowDialog();
}
public static void OnKeyPressed(this Widget w, KeyHandler handler)
{
if (Program.WidgetKeyHandlers.ContainsKey(w))
{
Console.WriteLine("Warning: overwriting key handler for widget");
}
Program.WidgetKeyHandlers[w] = e =>
{
if (w.CPointer != IntPtr.Zero)
{
return(handler(e));
}
Program.WidgetKeyHandlers.Remove(w);
return(true);
};
}
public MainPage()
{
this.InitializeComponent();
Window.Current.CoreWindow.KeyDown += CoreWindow_KeyDown;
Window.Current.CoreWindow.KeyUp += CoreWindow_KeyUp;
keyHandler = new KeyHandler(this);
cameraServer = new CameraServer(UpdateImageAsync); // Not using MVVM here, directly using imperative code to change image source
MovementController movementController = new MovementController();
Task.Factory.StartNew(movementController.MonitorForMovement);
StreamSocketListener listener = new StreamSocketListener();
listener.BindEndpointAsync(new HostName(SELF_IP_ADDRESS), SELF_CAMERA_PORT); // It's okay to not use await here because we can register an event handler before the endpoint is bounded
listener.ConnectionReceived += Listener_ConnectionReceived;
}
public UnityVehicleCmdGenerator(UserInputManager.Lib.UserInputManager manager)
{
_lastCmd = new VehicleCmd();
_inputManager = manager;
// 界面不会影响车辆控制
var keyhandler = new KeyHandler(Layer.Ui, BlockType.None);
_inputManager.RegisterKeyhandler(keyhandler);
keyhandler.BindKeyAction(UserInputKey.MoveVertical, data => _lastCmd.MoveVertical = data.Axis);
keyhandler.BindKeyAction(UserInputKey.MoveHorizontal, data => _lastCmd.MoveHorizontal = data.Axis);
keyhandler.BindKeyAction(UserInputKey.VehicleSpeedUp, data => _lastCmd.IsSpeedup = true);
keyhandler.BindKeyAction(UserInputKey.VehicleBrake, data => _lastCmd.IsHandbrake = true);
keyhandler.BindKeyAction(UserInputKey.VehicleHorn, data => _lastCmd.IsHornOn = true);
keyhandler.BindKeyAction(UserInputKey.VehicleLeftShift, data => _lastCmd.IsLeftShift = true);
keyhandler.BindKeyAction(UserInputKey.VehicleRightShift, data => _lastCmd.IsRightShift = true);
keyhandler.BindKeyAction(UserInputKey.VehicleStunt, data => _lastCmd.IsStunt = true);
}
void Update()
{
if (uiHandler != null)
{
bool open = KeyHandler.IsKeyDown("Inventory_Open");
bool close = KeyHandler.IsKeyDown("GUI_Close");
if (open && !inventoryOpen)
{
inventoryOpen = true;
OpenInventory();
}
else if ((open && inventoryOpen) || (open || close))
{
inventoryOpen = false;
CloseInventory();
}
}
}
void Page_Loaded(object sender, RoutedEventArgs e)
{
this.Focus();
Page.Keyhandler = new KeyHandler();
Page.Keyhandler.Attach(this);
//Page.MouseHandler = new MouseHandler();
//Page.MouseHandler.Attach(this);
Page.SceneLoop = new SceneLoop();
Page.SceneLoop.Attach(this.mainCanvas);
view = new TankView();
view.Ended += new EventHandler(view_Ended);
this.mainCanvas.Children.Add(view);
}
private static void Init()
{
if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO) != 0)
{
throw new SdlException(nameof(SDL.SDL_Init));
}
if (SDL_ttf.TTF_Init() != 0)
{
throw new SdlException(nameof(SDL_ttf.TTF_Init));
}
_window = SDL.SDL_CreateWindow("Langton`s Ant", 0, 0, 640, 480, SDL.SDL_WindowFlags.SDL_WINDOW_SHOWN);
if (_window == IntPtr.Zero)
{
throw new SdlException(nameof(SDL.SDL_CreateWindow));
}
_renderer = SDL.SDL_CreateRenderer(
_window, -1,
SDL.SDL_RendererFlags.SDL_RENDERER_ACCELERATED | SDL.SDL_RendererFlags.SDL_RENDERER_PRESENTVSYNC);
if (_renderer == IntPtr.Zero)
{
throw new SdlException(nameof(SDL.SDL_CreateRenderer));
}
_font = SDL_ttf.TTF_OpenFont(_fontPath, 14);
KeydownHandler = new KeyHandler();
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_ESCAPE, () => _quit = true);
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_F5, LoadWorld);
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_F2, () => _speed -= 10);
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_F3, () => _speed += 10);
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_F4, () => _speed = 0);
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_z, () => GetWorldRenderer().AddZoom(-10));
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_x, () => GetWorldRenderer().AddZoom(10));
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_c, () => GetWorldRenderer().ResetZoom());
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_RIGHT, () => GetWorldRenderer().MoveZoom(10, 0));
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_UP, () => GetWorldRenderer().MoveZoom(0, -10));
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_LEFT, () => GetWorldRenderer().MoveZoom(-10, 0));
KeydownHandler.Add(SDL.SDL_Keycode.SDLK_DOWN, () => GetWorldRenderer().MoveZoom(0, 10));
}
public void TestBackwardsTab()
{
_keyHandler.Handle(Tab);
// Nothing happens when no auto complete handler is set
Assert.Equal("Hello", _keyHandler.Text);
_keyHandler = new KeyHandler(new Console2(), _history, _autoCompleteHandler);
"Hi ".Select(c => c.ToConsoleKeyInfo()).ToList().ForEach(_keyHandler.Handle);
// Bring up the first Autocomplete
_keyHandler.Handle(Tab);
_completions.Reverse().ToList().ForEach(completion => {
_keyHandler.Handle(ShiftTab);
Assert.Equal($"Hi {completion}", _keyHandler.Text);
});
}
public static void CreateHook(KeyHandler _kh)
{
Process _this = Process.GetCurrentProcess();
ProcessModule mod = _this.MainModule;
hd = HookFunc;
kh = _kh;
hhk = API.SetWindowsHookEx(13, hd, API.GetModuleHandle(mod.ModuleName), 0);
Console.WriteLine("CreateHook HAS RUN");
//13 is the parameter specifying that we're gonna do a low-level keyboard hook
//MessageBox.Show(Marshal.GetLastWin32Error().ToString()); //for debugging
//Note that this could be a Console.WriteLine(), as well. I just happened
//to be debugging this in a Windows Application
//to get the errors, in VS 2005+ (possibly before) do Tools -> Error Lookup
}
protected override void SetupBehaviour()
{
EventManager.On(HWnd, "KeyPressRequested", (Event ev) =>
{
var keyRequest = (KeyPressRequest)ev.Data;
if (keyRequest.ModifierKey != Keys.None)
{
if (keyRequest.ModifierKey == Keys.F1)
{
var converter = TypeDescriptor.GetConverter(typeof(Keys));
var key = (Keys)converter.ConvertFromString("F" + keyRequest.Key.ToString().Replace("D", ""));
if (key == Keys.F8)
{
_isFollowing = true;
}
else if (key == Keys.F9)
{
if (_isFollowing)
{
_isFollowing = false;
KeyHandler.PressKey(Keys.S, 10);
}
}
KeyHandler.PressKey(key);
}
else
{
KeyHandler.ModifiedKeypress(keyRequest.ModifierKey, keyRequest.Key);
}
}
else
{
KeyHandler.PressKey(keyRequest.Key);
}
});
EventManager.On(HWnd, "WrongFacing", (Event _) =>
{
KeyHandler.PressKey(Keys.D, 75);
});
}
private void InitKeyBinding()
{
var handler = new KeyHandler(UiConstant.maxMapWindowLayer, BlockType.None);
handler.BindKeyAction(UserInputKey.ShowMaxMap, (data) =>
{
ShowMap(!_adapter.Enable);
});
_adapter.RegisterOpenKey(handler);
keyReceive = new KeyHandler(UiConstant.maxMapWindowKeyBlockLayer, BlockType.All);
keyReceive.BindKeyAction(UserInputKey.HideWindow, (data) =>
{
if (_adapter.Enable)
{
ShowMap(!_adapter.Enable);
}
});
}
private void InitKeyBinding()
{
var handler = new KeyHandler(UiConstant.rangingWindowLayer, BlockType.None);
handler.BindKeyAction(UserInputKey.CheckRanging, (data) =>
{
Debug.Log("CheckRanging..........................");
var selfPlayer = adapter.GetPlayerEntity();
if (selfPlayer.gamePlay.IsObserving())
{
return;
}
var playerTrans = selfPlayer.characterContoller.Value.transform;
var cameraPos = selfPlayer.cameraObj.MainCamera.transform.position;
var cameraForword = selfPlayer.cameraObj.MainCamera.transform.forward;
RaycastHit hit;
int bricksLayer = LayerMask.NameToLayer("Player"); //不检测player层级的东西
int layerMask = 1 << bricksLayer;
layerMask = ~layerMask;
if (Physics.Raycast(cameraPos, cameraForword, out hit, int.MaxValue, layerMask))
{
var hitPos = hit.point;
var distance = Vector3.Distance(hitPos, playerTrans.position);
distance = Mathf.Max(distance, 1);
//Debug.Log("name:" + hit.collider.gameObject.name);
if (adapter.RangeInfo == null)
{
adapter.RangeInfo = new RangingInfo((long)distance, hitPos);
}
else
{
adapter.RangeInfo.distance = (long)distance;
adapter.RangeInfo.contactPos = hitPos;
}
}
RefreshGui();
});
adapter.RegisterKeyReceive(handler);
}
public void Page_Loaded(object o, EventArgs e)
{
// Required to initialize variables
_splash = new Splash();
canvas.Children.Add(_splash);
_splash.SetValue(Canvas.ZIndexProperty, 20000);
KeyHandler = new KeyHandler();
KeyHandler.Attach(this);
Focus();
gameLoop = new GameLoop();
gameLoop.Attach(parentCanvas);
gameLoop.Update += gameLoop_Update;
Fps fps = new Fps();
canvas.Children.Add(fps);
fps.SetValue(Canvas.ZIndexProperty, 1000);
_mainMenu = new MainMenu();
canvas.Children.Add(_mainMenu);
_mainMenu.MenuItemSelected += mainMenu_MenuItemSelected;
Page_SizeChanged(null, null);
}
/// <summary>
/// Reads the specified prompt.
/// </summary>
/// <param name="prompt">The prompt.</param>
/// <param name="default">The default.</param>
/// <returns></returns>
public static string Read(string prompt = "", string @default = "")
{
Console.Write(prompt);
KeyHandler keyHandler = new KeyHandler(new Console2(), _history, AutoCompletionHandler);
string text = GetText(keyHandler);
if (string.IsNullOrWhiteSpace(text) && !string.IsNullOrWhiteSpace(@default))
{
text = @default;
}
else
{
if (HistoryEnabled)
{
_history.Add(text);
}
}
return(text);
}
/// <summary>
/// The primary tick entry point from the OpenGL window.
/// </summary>
/// <param name="sender">The sending object</param>
/// <param name="e">The frame event details, including delta timing</param>
static void Window_UpdateFrame(object sender, FrameEventArgs e)
{
Delta = ((double)Ticker.ElapsedTicks) / ((double)Stopwatch.Frequency);
Ticker.Reset();
Ticker.Start();
try
{
GlobalTickTime += Delta;
MouseHandler.Tick();
KeyHandler.Tick();
UIConsole.Tick();
ClientCommands.Tick();
ClientNetworkBase.Tick();
TickWorld();
}
catch (Exception ex)
{
SysConsole.Output(OutputType.ERROR, "Error / updateframe: " + ex.ToString());
}
}
private void InitKeyReveiver()
{
keyReveiver = new KeyHandler(UiConstant.weaponBagWindowKeyBlockLayer, BlockType.All);
for (int i = 0; i < _haveBagForIndexList.Count; i++)
{
if (_haveBagForIndexList[i])
{
var index = i - 1;
keyReveiver.BindKeyAction(UserInputKey.Switch1 + index,
(data) => {
btnGroupTab.SetSelect(index);
CloseView();
});
keyReveiver.BindKeyAction(UserInputKey.HideWindow,
(data) => {
CloseView();
});
}
}
_pointerKeyHandler = new PointerKeyHandler(UiConstant.weaponBagWindowKeyBlockLayer, BlockType.All);
}
public KeyHandlerTests()
{
_completions = new string[] { "World", "Angel", "Love" };
_history = new List <string>(new string[] { "dotnet run", "git init", "clear" });
_keyHandler = new KeyHandler(new Console2(), _history, null);
_keyInfo = new ConsoleKeyInfo('H', ConsoleKey.H, false, false, false);
_keyHandler.Handle(_keyInfo);
_keyInfo = new ConsoleKeyInfo('e', ConsoleKey.E, false, false, false);
_keyHandler.Handle(_keyInfo);
_keyInfo = new ConsoleKeyInfo('l', ConsoleKey.L, false, false, false);
_keyHandler.Handle(_keyInfo);
_keyInfo = new ConsoleKeyInfo('l', ConsoleKey.L, false, false, false);
_keyHandler.Handle(_keyInfo);
_keyInfo = new ConsoleKeyInfo('o', ConsoleKey.O, false, false, false);
_keyHandler.Handle(_keyInfo);
}
protected override void MouseLeftDown()
{
MDown = true;
Selected = true;
/* KeyHandlerState khs = */ KeyHandler.GetKBState();
int xs = GetX();
for (int i = 0; i < Text.Length; i++)
{
if (xs + Fonts.MeasureFancyText(Text.Substring(0, i)) > MouseHandler.MouseX())
{
MinCursor = i;
MaxCursor = i;
MStart = i;
return;
}
}
MinCursor = Text.Length;
MaxCursor = Text.Length;
MStart = Text.Length;
}
private void InitKeyReveiver()
{
var keyhandler = new KeyHandler(UiConstant.chatWindowLayer, BlockType.None);
keyhandler.BindKeyAction(UserInputKey.SendChatMessage, (data) =>
{
if (ChatListState != EUIChatListState.Send)
{
SwitchToSendState();
}
});
_switchKeyHandler = new KeyHandler(UiConstant.chatWindowKeyBlockLayer, BlockType.All);
_switchKeyHandler.BindKeyAction(UserInputKey.SendChatMessage, (data) => { SendMessage(); });
_switchKeyHandler.BindKeyAction(UserInputKey.SwitchChatChannel, (data) =>
{
SwitchChannel();
UpdateChannel();
});
_chatState.RegisterOpenKey(keyhandler);
}
static private KeyHandler globalKeyHandler; // handles global keys like fullscreen and exit
static void Main()
{
var settings = new RLSettings
{
BitmapFile = "font14x14.png",
CharWidth = 14,
CharHeight = 14,
Width = 80,
Height = 45,
ResizeType = RLResizeType.ResizeCells, // Display more tiles on screen if the console gets bigger, dont just increase size of existing
Scale = 1f,
StartWindowState = RLWindowState.Normal,
WindowBorder = RLWindowBorder.Resizable,
Title = "Apprentice"
};
Engine.Init(settings);
// Generate new world
World = new GameWorld(30, 30, 50, 50);
// For now we just spawn player at random position in the demi-plane
Coord playerSpawn = Map.RandomOpenPosition(World.DemiPlane, SingletonRandom.DefaultRNG);
Player = new Player(playerSpawn);
World.DemiPlane.Add(Player); // Changes active map too
// Global key commands setup
globalKeyHandler = new GlobalKeyHandler();
globalKeyHandler.StartHandling();
// UI setup
GameScreen = new GameScreen();
SpellsPanel = new SpellsPanel(Screen.SizeC(0), Screen.SizeC(0), Screen.WidthMinus(0), Screen.HeightMinus(0));
MessageRecallPanel = new MessageRecallPanel(Screen.SizeC(0), Screen.SizeC(0), Screen.WidthMinus(0), Screen.HeightMinus(0));
// Show UI and get game underway
GameScreen.Show();
Engine.Run();
}
protected override void SetupBehaviour()
{
EventManager.On(HWnd, "KeyPressRequested", (Event ev) =>
{
var keyRequest = (KeyPressRequest)ev.Data;
if (keyRequest.ModifierKey != Keys.None)
{
if (keyRequest.ModifierKey == Keys.F1)
{
var converter = TypeDescriptor.GetConverter(typeof(Keys));
var key = (Keys)converter.ConvertFromString("F" + keyRequest.Key.ToString().Replace("D", ""));
KeyHandler.PressKey(key);
return;
}
KeyHandler.ModifiedKeypress(keyRequest.ModifierKey, keyRequest.Key);
}
else
{
KeyHandler.PressKey(keyRequest.Key);
}
});
}
public void TickChatSystem()
{
if (IsChatVisible())
{
ChatBottomLastTick = ChatIsAtBottom();
if (ChatBox.TriedToEscape)
{
CloseChat();
return;
}
if (!WVis)
{
KeyHandler.GetKBState();
WVis = true;
}
ChatBox.Selected = true;
}
else
{
ChatBottomLastTick = true;
}
}
public KeyHandlerTests()
{
_autoCompleteHandler = new AutoCompleteHandler();
_completions = _autoCompleteHandler.GetSuggestions("", 0);
_history = new List <string>(new string[] { "dotnet run", "git init", "clear" });
_keyHandler = new KeyHandler(new Console2(), _history, null);
_keyInfo = new ConsoleKeyInfo('H', ConsoleKey.H, false, false, false);
_keyHandler.Handle(_keyInfo);
_keyInfo = new ConsoleKeyInfo('e', ConsoleKey.E, false, false, false);
_keyHandler.Handle(_keyInfo);
_keyInfo = new ConsoleKeyInfo('l', ConsoleKey.L, false, false, false);
_keyHandler.Handle(_keyInfo);
_keyInfo = new ConsoleKeyInfo('l', ConsoleKey.L, false, false, false);
_keyHandler.Handle(_keyInfo);
_keyInfo = new ConsoleKeyInfo('o', ConsoleKey.O, false, false, false);
_keyHandler.Handle(_keyInfo);
}
/// <summary>
/// Returns true if the specified mapping exists
/// </summary>
/// <param name="keyCombination">The combo to check for</param>
/// <param name="keyHandler">The handler to check for</param>
/// <returns></returns>
public bool Maps(KeyCombination keyCombination, KeyHandler keyHandler)
{
if (_mappings.ContainsKey(keyCombination))
return _mappings[keyCombination].Contains(keyHandler);
return false;
}
/// <summary>
/// Maps a key
/// </summary>
/// <param name="keyCombination">The combo</param>
/// <param name="keyHandler">The handler</param>
public KeyboardMapper Map(KeyCombination keyCombination, KeyHandler keyHandler)
{
#if DEBUG
if (DebugMode)
Debug.Log("KeyboardMapper.Map: " + keyCombination);
#endif
if (!_mappings.ContainsKey(keyCombination))
_mappings.Add(keyCombination, new List<KeyHandler>());
_mappings[keyCombination].Add(keyHandler);
return this;
}
public Handler(ConsoleKeyInfo myConsoleKeyInfo, KeyHandler myKeyHandler)
{
CKI = myConsoleKeyInfo;
KeyHandler = myKeyHandler;
}
public static Handler Control (char c, KeyHandler h, bool resetCompletion = true)
{
return new Handler ((char) (c - 'A' + 1), h, resetCompletion);
}
void EditLoop ()
{
ConsoleKeyInfo cki;
while (!done){
cki = Console.ReadKey (true);
bool handled = false;
foreach (Handler handler in handlers){
ConsoleKeyInfo t = handler.CKI;
if (t.Key == cki.Key && t.Modifiers == cki.Modifiers){
handled = true;
handler.KeyHandler ();
last_handler = handler.KeyHandler;
break;
} else if (t.KeyChar == cki.KeyChar && t.Key == ConsoleKey.Zoom){
handled = true;
handler.KeyHandler ();
last_handler = handler.KeyHandler;
break;
}
}
if (handled){
if (searching != 0){
if (last_handler != CmdReverseSearch){
searching = 0;
SetPrompt (prompt);
}
}
continue;
}
if (cki.KeyChar != (char) 0)
HandleChar (cki.KeyChar);
}
}
public static Handler Control (char c, KeyHandler h)
{
return new Handler ((char) (c - 'A' + 1), h);
}
public Handler (char c, KeyHandler h)
{
KeyHandler = h;
// Use the "Zoom" as a flag that we only have a character.
CKI = new ConsoleKeyInfo (c, ConsoleKey.Zoom, false, false, false);
}
public Handler (ConsoleKey key, KeyHandler h, bool resetCompletion = true)
{
CKI = new ConsoleKeyInfo ((char) 0, key, false, false, false);
KeyHandler = h;
ResetCompletion = resetCompletion;
}
protected void AddKeyHandler(Keys key, KeyHandler handler)
{
KeyHandlers[key] = (object)handler;
}
void EditLoop ()
{
ConsoleKeyInfo cki;
while (!done){
ConsoleModifiers mod;
cki = Console.ReadKey (true);
mod = cki.Modifiers;
bool handled = false;
if (_tabExpander.Running)
{
_tabExpander.Start(text.ToString());
bool skipKeyHandling = _tabExpander.HandleKey(cki);
RenderTabExpander();
max_rendered = _tabExpander.GetExpandedCommand().Length;
if (skipKeyHandling)
{
continue;
}
}
foreach (Handler handler in handlers){
ConsoleKeyInfo t = handler.CKI;
if ((t.Key == cki.Key && t.Modifiers == mod) ||
(t.KeyChar == cki.KeyChar && t.Key == ConsoleKey.Zoom)
){
if (_tabExpander.Running)
{
_tabExpander.Abort(true);
RenderTabExpander();
}
handled = true;
handler.KeyHandler ();
last_handler = handler.KeyHandler;
break;
}
}
if (handled){
if (searching != 0){
if (last_handler != CmdReverseSearch){
searching = 0;
SetPrompt (prompt);
}
}
continue;
}
if (cki.KeyChar != (char)0)
{
if (_tabExpander.Running && _tabExpander.HasSelection)
{
_tabExpander.Accept();
RenderTabExpander();
}
HandleChar(cki.KeyChar);
}
}
}
public static Handler Alt(Char myChar, ConsoleKey myConsoleKey, KeyHandler myKeyHandler)
{
var cki = new ConsoleKeyInfo((char) myChar, myConsoleKey, false, true, false);
return new Handler (cki, myKeyHandler);
}
public static Handler Control(Char myChar, KeyHandler myKeyHandler)
{
return new Handler((char) (myChar - 'A' + 1), myKeyHandler);
}
/// <summary>
/// Unmaps a key
/// </summary>
/// <param name="keyCombination">The combo</param>
/// <param name="keyHandler">The handler</param>
public KeyboardMapper Unmap(KeyCombination keyCombination, KeyHandler keyHandler)
{
#if DEBUG
if (DebugMode)
Debug.Log("KeyboardMapper.Unmap: " + keyCombination);
#endif
if (_mappings.ContainsKey(keyCombination))
{
_mappings[keyCombination].Remove(keyHandler);
if (_mappings[keyCombination].Count == 0)
_mappings.Remove(keyCombination);
}
if (_oneShotMappings.ContainsKey(keyCombination))
{
_oneShotMappings[keyCombination].Remove(keyHandler);
if (_oneShotMappings[keyCombination].Count == 0)
_oneShotMappings.Remove(keyCombination);
}
return this;
}
public Handler (ConsoleKey key, KeyHandler h)
{
CKI = new ConsoleKeyInfo ((char) 0, key, false, false, false);
KeyHandler = h;
}
public Handler(ConsoleKey myKey, KeyHandler myKeyHandler)
{
CKI = new ConsoleKeyInfo ((char) 0, myKey, false, false, false);
KeyHandler = myKeyHandler;
}
public Handler (ConsoleKeyInfo cki, KeyHandler h)
{
CKI = cki;
KeyHandler = h;
}
public static void CreateHook(KeyHandler _kh)
{
Process _this = Process.GetCurrentProcess();
ProcessModule mod = _this.MainModule;
hd = HookFunc;
kh = _kh;
hhk = API.SetWindowsHookEx(13, hd, API.GetModuleHandle(mod.ModuleName), 0);
//13 is the parameter specifying that we're gonna do a low-level keyboard hook
//MessageBox.Show(Marshal.GetLastWin32Error().ToString()); //for debugging
//Note that this could be a Console.WriteLine(), as well. I just happened
//to be debugging this in a Windows Application
//to get the errors, in VS 2005+ (possibly before) do Tools -> Error Lookup
}
public static Handler Alt (char c, ConsoleKey k, KeyHandler h)
{
ConsoleKeyInfo cki = new ConsoleKeyInfo ((char) c, k, false, true, false);
return new Handler (cki, h);
}
private void Form1_Load(object sender, EventArgs e)
{
KeyHandler ghk;
ghk = new KeyHandler(Keys.F1, this);
ghk.Register();
}
public Handler (ConsoleKeyInfo cki, KeyHandler h, bool resetCompletion = true)
{
CKI = cki;
KeyHandler = h;
ResetCompletion = resetCompletion;
}
public Handler (char c, KeyHandler h, bool resetCompletion = true)
{
KeyHandler = h;
// Use the "Zoom" as a flag that we only have a character.
CKI = new ConsoleKeyInfo (c, ConsoleKey.Zoom, false, false, false);
ResetCompletion = resetCompletion;
}
public void Run()
{
CameraCapture.Start();
var keyHandler = new KeyHandler();
keyHandler.KeyEvent += keyHandler_KeyEvent;
keyHandler.WaitForExit();
Stop();
}
public Handler(Char myChar, KeyHandler myKeyHandler)
{
KeyHandler = myKeyHandler;
// Use the "Zoom" as a flag that we only have a character.
CKI = new ConsoleKeyInfo(myChar, ConsoleKey.Zoom, false, false, false);
}
private KeyHandler SetupKeyHandler()
{
// Reinstantiate the handler.
m_keyHandler = new KeyHandler();
// Start at the end
KeyAction quit = new KeyAction(this.Quit, null, null);
m_keyHandler.AddAction("q", quit);
// Scrolling
KeyAction scrollup = new KeyAction(null, null, GetRenderer().Camera.ScrollUp);
m_keyHandler.AddAction("uparrow", scrollup);
KeyAction scrolldown = new KeyAction(null, null, GetRenderer().Camera.ScrollDown);
m_keyHandler.AddAction("downarrow", scrolldown);
KeyAction scrollleft = new KeyAction(null, null, GetRenderer().Camera.ScrollLeft);
m_keyHandler.AddAction("leftarrow", scrollleft);
KeyAction scrollright = new KeyAction(null, null, GetRenderer().Camera.ScrollRight);
m_keyHandler.AddAction("rightarrow", scrollright);
return m_keyHandler;
}
private void EditLoop()
{
ConsoleKeyInfo cki;
while (!done) {
ConsoleModifiers mod;
cki = Console.ReadKey(true);
if (cki.Key == ConsoleKey.Escape) {
cki = Console.ReadKey(true);
mod = ConsoleModifiers.Alt;
} else
mod = cki.Modifiers;
var handled = false;
foreach (var handler in handlers) {
var t = handler.CKI;
if (t.Key == cki.Key && t.Modifiers == mod) {
handled = true;
handler.KeyHandler();
last_handler = handler.KeyHandler;
break;
}
if (t.KeyChar == cki.KeyChar && t.Key == ConsoleKey.Zoom) {
handled = true;
handler.KeyHandler();
last_handler = handler.KeyHandler;
break;
}
}
if (handled) {
if (searching != 0) {
if (last_handler != CmdReverseSearch) {
searching = 0;
SetPrompt(Prompt);
}
}
continue;
}
if (cki.KeyChar != (char) 0)
HandleChar(cki.KeyChar);
}
}
