refactor key scans and add gamepad button/axes scans

.github/workflows/go.yml

@@ -12,7 +12,7 @@
       "steps": [
         {
           "name": "Set up Go 1.19",
-          "uses": "actions/setup-go@v1",
+          "uses": "actions/setup-go@v7",
           "with": {"go-version": 1.19},
           "id": "go",
         },

.gitignore

@@ -0,0 +1,29 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Code coverage profiles and other test artifacts
+*.out
+coverage.*
+*.coverprofile
+profile.cov
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+go.work.sum
+
+# env file
+.env
+
+# Editor/IDE
+.idea/
+.vscode/

_examples/remap/main.go

@@ -11,14 +11,21 @@ import (
 	input "github.com/quasilyte/ebitengine-input"
 )
 
+const (
+	width  int = 640
+	height int = 480
+)
+
 const (
 	ActionUnknown input.Action = iota
 	ActionPing
-	ActionRemap
+	ActionMove
+	ActionRemapKey
+	ActionRemapAxes
 )
 
 func main() {
-	ebiten.SetWindowSize(640, 480)
+	ebiten.SetWindowSize(width, height)
 
 	if err := ebiten.RunGame(newExampleGame()); err != nil {
 		log.Fatal(err)
@@ -28,18 +35,25 @@ func main() {
 type exampleGame struct {
 	started bool
 
-	k        input.Key
-	prevK    input.Key
-	scanning bool
+	k            input.Key
+	axes         input.Key
+	scanningKey  bool
+	scanningAxes bool
+
+	keyScanner *input.KeyScanner
 
-	keyScanner input.KeyScanner
+	pos       input.Vec
+	character string
 
 	inputHandler *input.Handler
 	inputSystem  input.System
 }
 
 func newExampleGame() *exampleGame {
-	g := &exampleGame{}
+	g := &exampleGame{
+		pos:       input.Vec{X: 200, Y: 200},
+		character: "@",
+	}
 
 	g.inputSystem.Init(input.SystemConfig{
 		DevicesEnabled: input.AnyDevice,
@@ -49,15 +63,34 @@ func newExampleGame() *exampleGame {
 }
 
 func (g *exampleGame) Layout(_, _ int) (int, int) {
-	return 640, 480
+	return width, height
+}
+
+func screenClamp(x, y float64) (float64, float64) {
+	if x < 0 {
+		x = 0
+	}
+	if x >= float64(width) {
+		x = float64(width) - 1
+	}
+	if y < 0 {
+		y = 0
+	}
+	if y >= float64(height) {
+		y = float64(height) - 1
+	}
+	return x, y
 }
 
 func (g *exampleGame) Draw(screen *ebiten.Image) {
-	if g.scanning {
-		ebitenutil.DebugPrint(screen, fmt.Sprintf("keybind: %s\n<scanning the new keybing>", g.k))
+	if g.scanningKey {
+		ebitenutil.DebugPrint(screen, fmt.Sprintf("keybind: %s\naxes: %s\n<scanning the new keybind>", g.k, g.axes))
+	} else if g.scanningAxes {
+		ebitenutil.DebugPrint(screen, fmt.Sprintf("keybind: %s\naxes: %s\n<scanning the new axes>", g.k, g.axes))
 	} else {
-		ebitenutil.DebugPrint(screen, fmt.Sprintf("keybind: %s\npress ctrl+enter to remap", g.k))
+		ebitenutil.DebugPrint(screen, fmt.Sprintf("keybind: %s\naxes: %s\npress ctrl+enter to remap keybind\nor shift+enter to remap axes", g.k, g.axes))
 	}
+	ebitenutil.DebugPrintAt(screen, g.character, int(g.pos.X), int(g.pos.Y))
 }
 
 func (g *exampleGame) Update() error {
@@ -68,49 +101,88 @@ func (g *exampleGame) Update() error {
 		g.started = true
 	}
 
-	g.handleRemap()
+	if !g.scanningKey && !g.scanningAxes {
+		// react to remap actions
+		if g.inputHandler.ActionIsJustPressed(ActionRemapKey) {
+			g.scanningKey = true
+		} else if g.inputHandler.ActionIsJustPressed(ActionRemapAxes) {
+			g.scanningAxes = true
+		}
 
-	if !g.scanning && g.inputHandler.ActionIsJustPressed(ActionPing) {
-		fmt.Printf("ping! (activated with %s keybind)\n", g.k)
+		// react to ping action by "highlighting" the "character"
+		if g.inputHandler.ActionIsJustPressed(ActionPing) {
+			fmt.Printf("ping! (activated with %s keybind)\n", g.k)
+		}
+		if g.inputHandler.ActionIsPressed(ActionPing) {
+			g.character = "***\n*@*\n***"
+		} else {
+			g.character = "@"
+		}
+
+		// react to move action by moving the "character"
+		if info, ok := g.inputHandler.PressedActionInfo(ActionMove); ok {
+			if info.IsMouseWheelEvent() {
+				// mouse wheel moves in reverse direction of draw position
+				g.pos.Y -= info.Pos.Y
+			} else {
+				g.pos.X += info.Pos.X
+				g.pos.Y += info.Pos.Y
+			}
+		}
+
+		// clamp position to screen window size
+		g.pos.X, g.pos.Y = screenClamp(g.pos.X, g.pos.Y)
+	}
+
+	// keep scanning of keys separate from axes to ensure events are isolated to just what is needed
+	if g.scanningKey {
+		g.handleRemapKey()
+	}
+	if g.scanningAxes {
+		g.handleRemapAxes()
 	}
 
 	return nil
 }
 
-func (g *exampleGame) handleRemap() {
-	if !g.scanning {
-		if g.inputHandler.ActionIsJustPressed(ActionRemap) {
-			g.prevK = g.k // Save it for an easier fallback
-			g.scanning = true
-		}
-		return
-	}
-
+func (g *exampleGame) handleRemapKey() {
 	k, status := g.keyScanner.Scan()
-	if status != input.KeyScanUnchanged {
+	if k == input.KeyWithModifier(input.KeyEnter, input.ModControl) ||
+		k == input.KeyWithModifier(input.KeyEnter, input.ModShift) ||
+		k == input.KeyControl || k == input.KeyShift || k == input.KeyEnter {
+		// reject the keys used to start key scanning for the purposes of the example
+	} else if status == input.KeyScanCompleted {
+		// Check for the new key to be available.
+		// Resolve the conflicts here.
+		g.scanningKey = false
 		g.k = k
+		g.inputHandler.Remap(g.makeKeymap())
 	}
+}
+
+func (g *exampleGame) handleRemapAxes() {
+	axes, status := g.keyScanner.ScanAxes()
 	if status == input.KeyScanCompleted {
-		g.scanning = false
 		// Check for the new key to be available.
-		// Resolve the conflicts here; I'll just reject
-		// the combination that is already in use.
-		if g.k == input.KeyWithModifier(input.KeyEnter, input.ModControl) {
-			g.k = g.prevK
-		} else {
-			g.inputHandler.Remap(g.makeKeymap())
-		}
+		// Resolve the conflicts here.
+		g.scanningAxes = false
+		g.axes = axes
+		g.inputHandler.Remap(g.makeKeymap())
 	}
 }
 
 func (g *exampleGame) makeKeymap() input.Keymap {
 	return input.Keymap{
-		ActionPing:  {g.k},
-		ActionRemap: {input.KeyWithModifier(input.KeyEnter, input.ModControl)},
+		ActionPing:      {g.k},
+		ActionMove:      {g.axes},
+		ActionRemapKey:  {input.KeyWithModifier(input.KeyEnter, input.ModControl)},
+		ActionRemapAxes: {input.KeyWithModifier(input.KeyEnter, input.ModShift)},
 	}
 }
 
 func (g *exampleGame) Init() {
 	g.k = input.KeyQ
+	g.axes = input.KeyGamepadLStickMotion
 	g.inputHandler = g.inputSystem.NewHandler(0, g.makeKeymap())
+	g.keyScanner = input.NewKeyScanner(g.inputHandler)
 }

_examples/scroll/main.go

@@ -66,11 +66,11 @@ func (g *exampleGame) Update() error {
 }
 
 func (g *exampleGame) handleScroll() {
-	if info, ok := g.inputHandler.JustPressedActionInfo(ActionFastScrollVertical); ok {
+	if info, ok := g.inputHandler.PressedActionInfo(ActionFastScrollVertical); ok {
 		g.pos.Y += info.Pos.Y * 7
 		return
 	}
-	if info, ok := g.inputHandler.JustPressedActionInfo(ActionScrollVertical); ok {
+	if info, ok := g.inputHandler.PressedActionInfo(ActionScrollVertical); ok {
 		g.pos.Y += info.Pos.Y
 		return
 	}

event.go

@@ -55,6 +55,7 @@ type EventInfo struct {
 
 	Duration int
 	Pos      Vec
+	DeltaPos Vec
 	StartPos Vec
 }
 
@@ -66,6 +67,11 @@ func (e EventInfo) HasPos() bool { return e.hasPos }
 // Use Duration field to get the press duration value.
 func (e EventInfo) HasDuration() bool { return e.hasDuration }
 
+// IsMouseWheelEvent reports whether this event was triggered by a mouse wheel.
+func (e EventInfo) IsMouseWheelEvent() bool {
+	return e.kind == keyWheel || e.kind == keyWheelWithCtrl || e.kind == keyWheelWithShift || e.kind == keyWheelWithCtrlShift
+}
+
 // IsTouchEvent reports whether this event was triggered by a screen touch device.
 //
 // Deprecated: Use Source().IsTouch() instead.