Abstracts event handling (input, screen and sound) to an internal

package.

Author: danmrichards

.gitignore

@@ -8,24 +8,13 @@ import (
 	"time"
 
 	"github.com/danmrichards/chip8/internal/chip8"
-	"github.com/danmrichards/chip8/internal/sound"
+	"github.com/danmrichards/chip8/internal/event"
 	"github.com/faiface/pixel"
-	"github.com/faiface/pixel/imdraw"
 	"github.com/faiface/pixel/pixelgl"
-	"golang.org/x/image/colornames"
 )
 
 var (
-	vm     *chip8.VM
-	window *pixelgl.Window
-
-	// TODO: Abstract this.
-	keys = map[byte]pixelgl.Button{
-		0x1: pixelgl.Key1, 0x2: pixelgl.Key2, 0x3: pixelgl.Key3, 0xC: pixelgl.Key4,
-		0x4: pixelgl.KeyQ, 0x5: pixelgl.KeyW, 0x6: pixelgl.KeyE, 0xD: pixelgl.KeyR,
-		0x7: pixelgl.KeyA, 0x8: pixelgl.KeyS, 0x9: pixelgl.KeyD, 0xE: pixelgl.KeyF,
-		0xA: pixelgl.KeyZ, 0x0: pixelgl.KeyX, 0xB: pixelgl.KeyC, 0xF: pixelgl.KeyV,
-	}
+	vm *chip8.VM
 
 	rom   string
 	debug bool
@@ -67,15 +56,16 @@ func run() {
 		VSync:  true,
 	}
 
-	var err error
-	window, err = pixelgl.NewWindow(cfg)
+	window, err := pixelgl.NewWindow(cfg)
 	if err != nil {
-		log.Fatal("Could not create window:", err)
+		log.Fatal("Could not create event:", err)
 	}
 
 	vm = chip8.New()
 	vm.Debug = debug
 
+	eh := event.NewHandler(window, vm)
+
 	rom, err := os.Open(rom)
 	if err != nil {
 		log.Fatalln("Could not open ROM:", err)
@@ -85,7 +75,8 @@ func run() {
 		log.Fatal("Could not load ROM:", err)
 	}
 
-	go eventHandler()
+	// Handle input, screen and sound events.
+	go eh.Handle()
 
 	// Emulation loop.
 	for !window.Closed() {
@@ -100,65 +91,8 @@ func run() {
 			log.Fatal(err)
 		}
 
-		inputHandler()
-
 		// A bit dirty, but block the next cycle until a tick. This prevents
 		// the emulator from running too quickly.
 		<-tick.C
 	}
 }
-
-func eventHandler() {
-	for !window.Closed() {
-		select {
-		case <-vm.Draw():
-			drawScreen()
-		case <-vm.Beep():
-			if err := sound.Beep(); err != nil {
-				log.Printf("Error playing beep: %q\n", err)
-			}
-		default:
-		}
-	}
-}
-
-// TODO: Abstract this.
-func drawScreen() {
-	window.Clear(colornames.Black)
-
-	imd := imdraw.New(nil)
-	imd.Color = pixel.RGB(0.14, 0.8, 0.26)
-
-	scrW := window.Bounds().W()
-	scrH := window.Bounds().H()
-
-	// Calculate the screen ratio.
-	rW, rH := scrW/64, scrH/32
-
-	for x := 0; x < 64; x++ {
-		for y := 0; y < 32; y++ {
-			if !vm.PixelSet((31-y)*64 + x) {
-				continue
-			}
-
-			// Scale the pixel co-ords.
-			sX := rW * float64(x)
-			sY := rH * float64(y)
-
-			imd.Push(pixel.V(sX, sY))
-			imd.Push(pixel.V(sX+rW, sY+rH))
-			imd.Rectangle(0)
-		}
-	}
-
-	imd.Draw(window)
-	window.Update()
-}
-
-func inputHandler() {
-	for i, key := range keys {
-		if window.Pressed(key) {
-			vm.KeyDown(i)
-		}
-	}
-}

Makefile

@@ -11,4 +11,5 @@ require (
 	github.com/gobuffalo/packr v1.19.0
 	github.com/hajimehoshi/oto v0.2.1 // indirect
 	golang.org/x/image v0.0.0-20181109232246-249dc8530c0e
+	golang.org/x/tools v0.0.0-20181204185109-3832e276fb48 // indirect
 )

README.md

@@ -42,3 +42,5 @@ golang.org/x/mobile v0.0.0-20180806140643-507816974b79/go.mod h1:z+o9i4GpDbdi3rU
 golang.org/x/net v0.0.0-20181102091132-c10e9556a7bc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180806082429-34b17bdb4300/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/tools v0.0.0-20181204185109-3832e276fb48 h1:N6OJ2izGAYOu7TF6EHpWtlM+vFxWtFJoj/BxJI7UhSQ=
+golang.org/x/tools v0.0.0-20181204185109-3832e276fb48/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

cmd/chip8/main.go

@@ -0,0 +1,94 @@
+package event
+
+import (
+	"log"
+
+	"github.com/danmrichards/chip8/internal/chip8"
+	"github.com/danmrichards/chip8/internal/sound"
+	"github.com/faiface/pixel"
+	"github.com/faiface/pixel/imdraw"
+	"github.com/faiface/pixel/pixelgl"
+	"golang.org/x/image/colornames"
+)
+
+var keys = map[byte]pixelgl.Button{
+	0x1: pixelgl.Key1, 0x2: pixelgl.Key2, 0x3: pixelgl.Key3, 0xC: pixelgl.Key4,
+	0x4: pixelgl.KeyQ, 0x5: pixelgl.KeyW, 0x6: pixelgl.KeyE, 0xD: pixelgl.KeyR,
+	0x7: pixelgl.KeyA, 0x8: pixelgl.KeyS, 0x9: pixelgl.KeyD, 0xE: pixelgl.KeyF,
+	0xA: pixelgl.KeyZ, 0x0: pixelgl.KeyX, 0xB: pixelgl.KeyC, 0xF: pixelgl.KeyV,
+}
+
+// Handler is responsible for handling input and output for the vm.
+type Handler struct {
+	window *pixelgl.Window
+	vm     *chip8.VM
+}
+
+// NewHandler returns a new event handler.
+func NewHandler(win *pixelgl.Window, vm *chip8.VM) Handler {
+	return Handler{
+		window: win,
+		vm:     vm,
+	}
+}
+
+// Handle continually loops while the VM window is open; handling events.
+// Events are handled with a non-blocking select. Draw and sound events are
+// handled independently with input being treated as the default event to check.
+func (h *Handler) Handle() {
+	for !h.window.Closed() {
+		select {
+		case <-h.vm.Draw():
+			h.draw()
+		case <-h.vm.Beep():
+			if err := sound.Beep(); err != nil {
+				log.Printf("Error playing beep: %q\n", err)
+			}
+		default:
+			h.input()
+		}
+	}
+}
+
+// input iterates over the keyset, checking if any of them are pressed and
+// updates the vm accordingly.
+func (h *Handler) input() {
+	for i, key := range keys {
+		if h.window.Pressed(key) {
+			h.vm.KeyDown(i)
+		}
+	}
+}
+
+// draw updates the window based on the current state of the VM graphics array.
+func (h *Handler) draw() {
+	h.window.Clear(colornames.Black)
+
+	imd := imdraw.New(nil)
+	imd.Color = pixel.RGB(0.14, 0.8, 0.26)
+
+	scrW := h.window.Bounds().W()
+	scrH := h.window.Bounds().H()
+
+	// Calculate the screen ratio.
+	rW, rH := scrW/64, scrH/32
+
+	for x := 0; x < 64; x++ {
+		for y := 0; y < 32; y++ {
+			if !h.vm.PixelSet((31-y)*64 + x) {
+				continue
+			}
+
+			// Scale the pixel co-ords.
+			sX := rW * float64(x)
+			sY := rH * float64(y)
+
+			imd.Push(pixel.V(sX, sY))
+			imd.Push(pixel.V(sX+rW, sY+rH))
+			imd.Rectangle(0)
+		}
+	}
+
+	imd.Draw(h.window)
+	h.window.Update()
+}

go.mod

@@ -25,7 +25,12 @@ func Beep() error {
 		return err
 	}
 
-	speaker.Init(format.SampleRate, format.SampleRate.N(time.Second/10))
+	if err = speaker.Init(
+		format.SampleRate,
+		format.SampleRate.N(time.Second/10),
+	); err != nil {
+		return err
+	}
 
 	done := make(chan struct{})
 	speaker.Play(beep.Seq(s, beep.Callback(func() {