Make debug renderer more effecient

Author: necrophonic

Diff for: gopher-maze-2/cmd/maze/main.go

@@ -10,7 +10,7 @@ import (
 func main() {
 	ctx := context.Background()
 
-	g := game.New(true)
+	g := game.New()
 
 	// Start rendering loop
 	go g.Loop(ctx)

Diff for: gopher-maze-2/internal/developer/developer.go

@@ -3,35 +3,43 @@ package developer
 
 import (
 	"fmt"
-	"log"
 	"time"
 )
 
+type Stack interface {
+	Add(string)
+	Addf(string, ...string)
+	Get(int) string
+	Window() []string
+}
+
 // DebugStack implements a stack of debugging messages that can be rendered via
 // a sliding window to the terminal. Should be instantiated via NewDebugStack()
 type DebugStack struct {
-	size uint8
-	msgs []string
+	clean      bool
+	size       uint8
+	msgs       []string
+	lastWindow []string
 }
 
 // NewDebugStack initialises an empty debug stack with its
 // window set to the size of `windowSize`.
-func NewDebugStack(enable bool, windowSize uint8) *DebugStack {
+func NewDebugStack(windowSize uint8) *DebugStack {
 	return &DebugStack{
-		size: windowSize,
-		msgs: make([]string, windowSize),
+		clean:      false,
+		size:       windowSize,
+		msgs:       make([]string, windowSize),
+		lastWindow: make([]string, windowSize),
 	}
 }
 
-// Add appends a new message to the debug stack. The message is also echoed to
-// the STDOUT log.
+// Add appends a new message to the debug stack.
 func (ds *DebugStack) Add(msg string) {
 	ds.msgs = append(ds.msgs, fmt.Sprintf("[%s] %s", time.Now().Format("15:04:05"), msg))
-	log.Println(msg)
+	ds.clean = false
 }
 
-// Add appends a new message to the debug stack (formatted). The message is
-// also echoed to the STDOUT log.
+// Add appends a new message to the debug stack (formatted).
 func (ds *DebugStack) Addf(format string, msg ...string) {
 	ds.Add(fmt.Sprintf(format, msg))
 }
@@ -40,14 +48,36 @@ func (ds *DebugStack) Addf(format string, msg ...string) {
 // (if it exists). If the index isn't populated or is out
 // of range then an empty string is returned instead.
 func (ds *DebugStack) Get(i int) string {
+	window := ds.lastWindow
+	if !ds.clean {
+		// If the debug stack has changed
+		// then rebuild the window.
+		window = ds.Window()
+	}
+	if i >= len(window) {
+		return ""
+	}
+	return window[i]
+}
+
+// Window returns a whole debug window
+func (ds *DebugStack) Window() []string {
 	upper := len(ds.msgs)
 	lower := upper - int(ds.size)
 	if lower < 0 {
 		lower = 0
 	}
 	window := ds.msgs[lower:upper]
-	if i >= len(window) {
-		return ""
-	}
-	return window[i]
+	ds.clean = true
+	ds.lastWindow = window
+	return window
 }
+
+// NullStack is used when we want to disable debugging stacks. It essentially
+// returns no-ops for every func.
+type NullStack struct{}
+
+func (*NullStack) Add(string)             {}
+func (*NullStack) Addf(string, ...string) {}
+func (*NullStack) Get(int) string         { return "" }
+func (*NullStack) Window() []string       { return nil }

Diff for: gopher-maze-2/internal/developer/developer_test.go

@@ -14,7 +14,7 @@ func TestDebugStack(t *testing.T) {
 	stackSize := uint8(3)
 
 	t.Run("Create a new debug stack", func(t *testing.T) {
-		ds = developer.NewDebugStack(true, stackSize)
+		ds = developer.NewDebugStack(stackSize)
 		assert.NotNil(t, ds)
 	})
 
@@ -46,12 +46,12 @@ func TestDebugStack(t *testing.T) {
 	})
 
 	t.Run("Attempt fetch on empty stack", func(t *testing.T) {
-		ds = developer.NewDebugStack(true, stackSize)
+		ds = developer.NewDebugStack(stackSize)
 		assert.Equal(t, ds.Get(0), "")
 	})
 
 	t.Run("Attempt fetch on disbled stack", func(t *testing.T) {
-		ds = developer.NewDebugStack(false, stackSize)
+		ds = developer.NewDebugStack(stackSize)
 		assert.Equal(t, ds.Get(0), "")
 	})
 

Diff for: gopher-maze-2/internal/game/game.go

@@ -11,12 +11,16 @@ import (
 	"github.com/necrophonic/3d-gopher-maze/gopher-maze-2/internal/terminal"
 )
 
-var ds *developer.DebugStack
+var ds developer.Stack
 
 func init() {
-	// TODO make debug switchable via env vars
-	ds = developer.NewDebugStack(true, 11)
-	ds.Add("[debug enabled]")
+	debug := os.Getenv("DEBUG")
+	if debug == "true" {
+		ds = developer.NewDebugStack(11)
+		ds.Add("[debug enabled]")
+	} else {
+		ds = &developer.NullStack{}
+	}
 }
 
 type (
@@ -37,9 +41,9 @@ type (
 )
 
 // New initialises a new game with defaults
-func New(debug bool) *Game {
+func New() *Game {
 	return &Game{
-		Tick:   100_000 * time.Microsecond,
+		Tick:   100 * time.Millisecond,
 		Player: NewPlayer(),
 	}
 }

Diff for: gopher-maze-2/internal/game/render.go

@@ -1,35 +1,63 @@
 package game
 
 import (
-	"strings"
+	"bytes"
+	"text/template"
 )
 
-const (
-	windowHoriz       = "═"
-	windowTopLeft     = "╔"
-	windowTopRight    = "╗"
-	windowBottomLeft  = "╚"
-	windowBottomRight = "╝"
-	windowSide        = "║"
-)
+// const (
+// 	windowHoriz       = "═"
+// 	windowTopLeft     = "╔"
+// 	windowTopRight    = "╗"
+// 	windowBottomLeft  = "╚"
+// 	windowBottomRight = "╝"
+// 	windowSide        = "║"
+// )
 
-const (
-	windowWidth  = 22
-	windowHeight = 9
-)
+// const (
+// 	windowWidth  = 22
+// 	windowHeight = 9
+// )
 
 // Render contructs the terminal view. If debug is enabled, the debug stack
 // is rendered alongside the viewport.
 func (g *Game) Render() (string, error) {
 	// Build the output
-	rendered := ""
+	// rendered := ""
+
+	// rendered += windowTopLeft + strings.Repeat(windowHoriz, windowWidth+2) + windowTopRight + "   " + ds.Get(0) + "\n"
+	// for i := 0; i < windowHeight; i++ {
+	// 	// TODO - content!
+	// 	rendered += windowSide + " " + strings.Repeat(" ", windowWidth) + " " + windowSide + "   " + ds.Get(i+1) + "\n"
+	// }
+	// rendered += windowBottomLeft + strings.Repeat(windowHoriz, windowWidth+2) + windowBottomRight + "   " + ds.Get(windowHeight+1) + "\n"
+
+	buf := &bytes.Buffer{}
 
-	rendered += windowTopLeft + strings.Repeat(windowHoriz, windowWidth+2) + windowTopRight + "   " + ds.Get(0) + "\n"
-	for i := 0; i < windowHeight; i++ {
-		// TODO - content!
-		rendered += windowSide + " " + strings.Repeat(" ", windowWidth) + " " + windowSide + "   " + ds.Get(i+1) + "\n"
+	err := tmplScreen11_9.Execute(buf, nil)
+	if err != nil {
+		return "", err
 	}
-	rendered += windowBottomLeft + strings.Repeat(windowHoriz, windowWidth+2) + windowBottomRight + "   " + ds.Get(windowHeight+1) + "\n"
 
-	return rendered, nil
+	return buf.String(), nil
 }
+
+var funcs = template.FuncMap{
+	"getDebugLine": func(i int) string {
+		return ds.Get(i)
+	},
+}
+
+var tmplScreen11_9 = template.Must(template.New("screen").Funcs(funcs).Parse(`
+  ╔════════════════════════╗   {{ getDebugLine 0 }}
+  ║                        ║   {{ getDebugLine 1 }}
+  ║                        ║   {{ getDebugLine 2 }}
+  ║                        ║   {{ getDebugLine 3 }}
+  ║                        ║   {{ getDebugLine 4 }}
+  ║                        ║   {{ getDebugLine 5 }}
+  ║                        ║   {{ getDebugLine 6 }}
+  ║                        ║   {{ getDebugLine 7 }}
+  ║                        ║   {{ getDebugLine 8 }}
+  ║                        ║   {{ getDebugLine 9 }}
+  ╚════════════════════════╝   {{ getDebugLine 10 }}
+`))