From 24aef28a0dd9b424a82bf3a9f8b3d8d1520a3c58 Mon Sep 17 00:00:00 2001 From: Noah Petherbridge Date: Tue, 17 Nov 2020 18:22:48 -0800 Subject: [PATCH] Centralize Keybinds, Improve Menus * pkg/keybinds holds central functions to check global keybinds, like DebugOverlay (F3), Undo (Ctrl-Z), GotoPlay/GotoEdit (p/e), etc. * The Tools menu in the editor mode lists out more options to select various drawing tools (line, pencil, etc.) - and showing the hotkey for each tool. --- pkg/doodle.go | 12 +++--- pkg/editor_scene.go | 29 +++++++++----- pkg/editor_ui.go | 39 +++++++++++++++++++ pkg/keybind/keybind.go | 88 ++++++++++++++++++++++++++++++++++++++++++ pkg/play_scene.go | 3 +- 5 files changed, 153 insertions(+), 18 deletions(-) create mode 100644 pkg/keybind/keybind.go diff --git a/pkg/doodle.go b/pkg/doodle.go index 3f1a437..431f082 100644 --- a/pkg/doodle.go +++ b/pkg/doodle.go @@ -9,6 +9,7 @@ import ( "git.kirsle.net/apps/doodle/pkg/balance" "git.kirsle.net/apps/doodle/pkg/branding" "git.kirsle.net/apps/doodle/pkg/enum" + "git.kirsle.net/apps/doodle/pkg/keybind" "git.kirsle.net/apps/doodle/pkg/log" "git.kirsle.net/apps/doodle/pkg/modal" "git.kirsle.net/apps/doodle/pkg/native" @@ -135,21 +136,18 @@ func (d *Doodle) Run() error { ev.Enter = false } else { // Global event handlers. - if ev.Escape { + if keybind.Shutdown(ev) { d.ConfirmExit() continue } - if ev.KeyDown("F1") { + if keybind.Help(ev) { // TODO: launch the guidebook. native.OpenURL(balance.GuidebookPath) - ev.SetKeyDown("F1", false) - } else if ev.KeyDown("F3") { + } else if keybind.DebugOverlay(ev) { DebugOverlay = !DebugOverlay - ev.SetKeyDown("F3", false) - } else if ev.KeyDown("F4") { + } else if keybind.DebugCollision(ev) { DebugCollision = !DebugCollision - ev.SetKeyDown("F4", false) } // Is a UI modal active? diff --git a/pkg/editor_scene.go b/pkg/editor_scene.go index 3a4818d..43de340 100644 --- a/pkg/editor_scene.go +++ b/pkg/editor_scene.go @@ -10,6 +10,7 @@ import ( "git.kirsle.net/apps/doodle/pkg/doodads" "git.kirsle.net/apps/doodle/pkg/drawtool" "git.kirsle.net/apps/doodle/pkg/enum" + "git.kirsle.net/apps/doodle/pkg/keybind" "git.kirsle.net/apps/doodle/pkg/level" "git.kirsle.net/apps/doodle/pkg/log" "git.kirsle.net/apps/doodle/pkg/modal" @@ -195,31 +196,39 @@ func (s *EditorScene) Loop(d *Doodle, ev *event.State) error { } // Undo/Redo key bindings. - if ev.Ctrl { - if ev.KeyDown("z") { - s.UI.Canvas.UndoStroke() - } else if ev.KeyDown("y") { - s.UI.Canvas.RedoStroke() - } + if keybind.Undo(ev) { + s.UI.Canvas.UndoStroke() + } else if keybind.Redo(ev) { + s.UI.Canvas.RedoStroke() } s.UI.Loop(ev) // Switching to Play Mode? - if ev.KeyDown("p") { + if keybind.GotoPlay(ev) { s.Playtest() - } else if ev.KeyDown("l") { + } else if keybind.LineTool(ev) { d.Flash("Line Tool selected.") s.UI.Canvas.Tool = drawtool.LineTool s.UI.activeTool = s.UI.Canvas.Tool.String() - } else if ev.KeyDown("f") { + } else if keybind.PencilTool(ev) { d.Flash("Pencil Tool selected.") s.UI.Canvas.Tool = drawtool.PencilTool s.UI.activeTool = s.UI.Canvas.Tool.String() - } else if ev.KeyDown("r") { + } else if keybind.RectTool(ev) { d.Flash("Rectangle Tool selected.") s.UI.Canvas.Tool = drawtool.RectTool s.UI.activeTool = s.UI.Canvas.Tool.String() + } else if keybind.EllipseTool(ev) { + d.Flash("Ellipse Tool selected.") + s.UI.Canvas.Tool = drawtool.EllipseTool + s.UI.activeTool = s.UI.Canvas.Tool.String() + } else if keybind.EraserTool(ev) { + d.Flash("Eraser Tool selected.") + s.UI.Canvas.Tool = drawtool.EraserTool + s.UI.activeTool = s.UI.Canvas.Tool.String() + } else if keybind.DoodadDropper(ev) { + s.UI.doodadWindow.Show() } return nil diff --git a/pkg/editor_ui.go b/pkg/editor_ui.go index ad9a286..832d392 100644 --- a/pkg/editor_ui.go +++ b/pkg/editor_ui.go @@ -594,6 +594,45 @@ func (u *EditorUI) SetupMenuBar(d *Doodle) *ui.MenuBar { }) } + // Draw Tools + toolMenu.AddItemAccel("Pencil Tool", "F", func() { + u.Canvas.Tool = drawtool.PencilTool + u.activeTool = u.Canvas.Tool.String() + d.Flash("Pencil Tool selected.") + }) + toolMenu.AddItemAccel("Line Tool", "L", func() { + u.Canvas.Tool = drawtool.LineTool + u.activeTool = u.Canvas.Tool.String() + d.Flash("Line Tool selected.") + }) + toolMenu.AddItemAccel("Rectangle Tool", "R", func() { + u.Canvas.Tool = drawtool.RectTool + u.activeTool = u.Canvas.Tool.String() + d.Flash("Rectangle Tool selected.") + }) + toolMenu.AddItemAccel("Ellipse Tool", "C", func() { + u.Canvas.Tool = drawtool.EllipseTool + u.activeTool = u.Canvas.Tool.String() + d.Flash("Ellipse Tool selected.") + }) + toolMenu.AddItemAccel("Eraser Tool", "x", func() { + u.Canvas.Tool = drawtool.EraserTool + u.activeTool = u.Canvas.Tool.String() + d.Flash("Eraser Tool selected.") + }) + + if u.Scene.DrawingType == enum.LevelDrawing { + toolMenu.AddItemAccel("Doodads", "d", func() { + log.Info("Open the DoodadDropper") + u.doodadWindow.Show() + }) + toolMenu.AddItem("Link Tool", func() { + u.Canvas.Tool = drawtool.LinkTool + u.activeTool = u.Canvas.Tool.String() + d.Flash("Link Tool selected. Click a doodad in your level to link it to another.") + }) + } + //////// // Help menu helpMenu := menu.AddMenu("Help") diff --git a/pkg/keybind/keybind.go b/pkg/keybind/keybind.go new file mode 100644 index 0000000..8b277ba --- /dev/null +++ b/pkg/keybind/keybind.go @@ -0,0 +1,88 @@ +// 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" + +// Shutdown (Escape) signals the game to start closing down. +func Shutdown(ev *event.State) bool { + return ev.Escape +} + +// 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 +} + +// 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") +} + +// 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("d") +} diff --git a/pkg/play_scene.go b/pkg/play_scene.go index 1c4a5bc..18e150f 100644 --- a/pkg/play_scene.go +++ b/pkg/play_scene.go @@ -6,6 +6,7 @@ import ( "git.kirsle.net/apps/doodle/pkg/balance" "git.kirsle.net/apps/doodle/pkg/collision" "git.kirsle.net/apps/doodle/pkg/doodads" + "git.kirsle.net/apps/doodle/pkg/keybind" "git.kirsle.net/apps/doodle/pkg/level" "git.kirsle.net/apps/doodle/pkg/log" "git.kirsle.net/apps/doodle/pkg/physics" @@ -391,7 +392,7 @@ func (s *PlayScene) Loop(d *Doodle, ev *event.State) error { } // Switching to Edit Mode? - if s.CanEdit && ev.KeyDown("e") { + if s.CanEdit && keybind.GotoEdit(ev) { s.EditLevel() return nil }