// Package keybind centralizes the global hotkey bindings. // // Whenever the app would need to query a hotkey like "F3" or "Ctrl-Z" // is held down, it should use a method in this file. It can be // expanded later to allow user customizable bindings or something. // // NOTE: arrow key and gameplay controls not yet ported to here. package keybind import "git.kirsle.net/go/render/event" // State returns a version of event.State which is domain specific // to what the game actually cares about. type State struct { State *event.State Shutdown bool // Escape key Help bool // F1 DebugOverlay bool // F3 DebugCollision bool // F4 Undo bool // Ctrl-Z Redo bool // Ctrl-Y NewLevel bool // Ctrl-N Save bool // Ctrl-S SaveAs bool // Shift-Ctrl-S Open bool // Ctrl-O ZoomIn bool // + ZoomOut bool // - ZoomReset bool // 1 Origin bool // 0 GotoPlay bool // p GotoEdit bool // e PencilTool bool LineTool bool RectTool bool EllipseTool bool EraserTool bool DoodadDropper bool ShellKey bool Enter bool Left bool Right bool Up bool Down bool Use bool } // FromEvent converts a render.Event readout of the current keys // being pressed but formats them in the way the game uses them. // For example, WASD and arrow keys both move the player and the // game only cares which direction. func FromEvent(ev *event.State) State { return State{ State: ev, Shutdown: Shutdown(ev), Help: Help(ev), DebugOverlay: DebugOverlay(ev), DebugCollision: DebugCollision(ev), // F4 Undo: Undo(ev), // Ctrl-Z Redo: Redo(ev), // Ctrl-Y NewLevel: NewLevel(ev), // Ctrl-N Save: Save(ev), // Ctrl-S SaveAs: SaveAs(ev), // Shift-Ctrl-S Open: Open(ev), // Ctrl-O ZoomIn: ZoomIn(ev), // + ZoomOut: ZoomOut(ev), // - ZoomReset: ZoomReset(ev), // 1 Origin: Origin(ev), // 0 GotoPlay: GotoPlay(ev), // p GotoEdit: GotoEdit(ev), // e PencilTool: PencilTool(ev), LineTool: LineTool(ev), RectTool: RectTool(ev), EllipseTool: EllipseTool(ev), EraserTool: EraserTool(ev), DoodadDropper: DoodadDropper(ev), ShellKey: ShellKey(ev), Enter: Enter(ev), Left: Left(ev), Right: Right(ev), Up: Up(ev), Down: Down(ev), Use: Use(ev), } } // Shutdown (Escape) signals the game to start closing down. func Shutdown(ev *event.State) bool { result := ev.Escape ev.Escape = false return result } // Help (F1) can be checked one time. func Help(ev *event.State) bool { result := ev.KeyDown("F1") ev.SetKeyDown("F1", false) return result } // DebugOverlay (F3) can be checked one time. func DebugOverlay(ev *event.State) bool { result := ev.KeyDown("F3") ev.SetKeyDown("F3", false) return result } // DebugCollision (F4) can be checked one time. func DebugCollision(ev *event.State) bool { result := ev.KeyDown("F4") ev.SetKeyDown("F4", false) return result } // CloseTopmostWindow (Backspace) func CloseTopmostWindow(ev *event.State) bool { result := ev.KeyDown(`\b`) ev.SetKeyDown(`\b`, false) return result } // CloseAllWindows (Shift+Backspace) func CloseAllWindows(ev *event.State) bool { result := ev.KeyDown(`\b`) && ev.Shift if result { ev.SetKeyDown(`\b`, false) } return result } // NewViewport (V) func NewViewport(ev *event.State) bool { result := ev.KeyDown("v") if result { ev.SetKeyDown("v", false) } return result } // Undo (Ctrl-Z) func Undo(ev *event.State) bool { return ev.Ctrl && ev.KeyDown("z") } // Redo (Ctrl-Y) func Redo(ev *event.State) bool { return ev.Ctrl && ev.KeyDown("y") } // New Level (Ctrl-N) func NewLevel(ev *event.State) bool { return ev.Ctrl && ev.KeyDown("n") } // Save (Ctrl-S) func Save(ev *event.State) bool { var result = ev.Ctrl && ev.KeyDown("s") if result { ev.SetKeyDown("s", false) } return result } // SaveAs (Shift-Ctrl-S) func SaveAs(ev *event.State) bool { return ev.Ctrl && ev.Shift && ev.KeyDown("s") } // Open (Ctrl-O) func Open(ev *event.State) bool { return ev.Ctrl && ev.KeyDown("o") } // ZoomIn (+) func ZoomIn(ev *event.State) bool { return ev.KeyDown("=") || ev.KeyDown("+") } // ZoomOut (-) func ZoomOut(ev *event.State) bool { return ev.KeyDown("-") } // ZoomReset (1) func ZoomReset(ev *event.State) bool { return ev.KeyDown("1") } // Origin (0) -- scrolls the canvas back to 0,0 in Editor Mode. func Origin(ev *event.State) bool { return ev.KeyDown("0") } // GotoPlay (P) play tests the current level in the editor. func GotoPlay(ev *event.State) bool { return ev.KeyDown("p") } // GotoEdit (E) opens the current played level in Edit Mode, if the // player has come from the editor originally. func GotoEdit(ev *event.State) bool { return ev.KeyDown("e") } // LineTool (L) selects the Line Tool in the editor. func LineTool(ev *event.State) bool { return ev.KeyDown("l") } // PencilTool (F) selects the freehand pencil tool in the editor. // GotoPlay (P) play tests the current level in the editor. func PencilTool(ev *event.State) bool { return ev.KeyDown("f") } // RectTool (R) selects the rectangle in the editor. func RectTool(ev *event.State) bool { return ev.KeyDown("r") } // EllipseTool (C) selects this tool in the editor. func EllipseTool(ev *event.State) bool { return ev.KeyDown("c") } // EraserTool (X) selects this tool in the editor. func EraserTool(ev *event.State) bool { return ev.KeyDown("x") } // DoodadDropper (D) opens the doodad dropper in the editor. func DoodadDropper(ev *event.State) bool { return ev.KeyDown("q") } // ShellKey (`) opens the developer console. func ShellKey(ev *event.State) bool { v := ev.KeyDown("`") ev.SetKeyDown("`", false) return v } // Enter key. func Enter(ev *event.State) bool { v := ev.Enter ev.Enter = false return v } // Shift key. func Shift(ev *event.State) bool { return ev.Shift } // Left arrow. func Left(ev *event.State) bool { return ev.Left || ev.KeyDown("a") } // Right arrow. func Right(ev *event.State) bool { return ev.Right || ev.KeyDown("d") } // Up arrow. func Up(ev *event.State) bool { return ev.Up || ev.KeyDown("w") } // Down arrow. func Down(ev *event.State) bool { return ev.Down || ev.KeyDown("s") } // "Use" button. func Use(ev *event.State) bool { return ev.Space || ev.KeyDown("q") } // LeftClick of the primary mouse button. func LeftClick(ev *event.State) bool { return ev.Button1 } // MiddleClick of the mouse for panning the level. func MiddleClick(ev *event.State) bool { return ev.Button2 } // ClearLeftClick sets the primary mouse button state to false. func ClearLeftClick(ev *event.State) { ev.Button1 = false }