ui: basic map scroller

2026-03-06 23:29:06 +02:00
parent 29d188969b
commit 1de621c743
68 changed files with 9861 additions and 118 deletions
@@ -0,0 +1,240 @@
+package world
+
+import (
+	"fmt"
+	"image/color"
+)
+
+// fakeClipRect describes one clip rectangle in canvas pixel coordinates.
+type fakeClipRect struct {
+	X, Y float64
+	W, H float64
+}
+
+// fakeDrawerState stores the active fake drawing state.
+// The state is copied on Save and restored on Restore.
+type fakeDrawerState struct {
+	StrokeColor color.RGBA
+	FillColor   color.RGBA
+	LineWidth   float64
+	Dashes      []float64
+	DashOffset  float64
+	Clips       []fakeClipRect
+}
+
+// clone returns a deep copy of the state.
+func (s fakeDrawerState) clone() fakeDrawerState {
+	out := s
+	out.Dashes = append([]float64(nil), s.Dashes...)
+	out.Clips = append([]fakeClipRect(nil), s.Clips...)
+	return out
+}
+
+// fakeDrawerCommand is one recorded drawer call together with a snapshot
+// of the active fake drawing state at the moment of the call.
+type fakeDrawerCommand struct {
+	Name        string
+	Args        []float64
+	StrokeColor color.RGBA
+	FillColor   color.RGBA
+	LineWidth   float64
+	Dashes      []float64
+	DashOffset  float64
+	Clips       []fakeClipRect
+}
+
+// String returns a compact debug representation useful in assertion failures.
+func (c fakeDrawerCommand) String() string {
+	return fmt.Sprintf(
+		"%s args=%v stroke=%v fill=%v lineWidth=%v dashes=%v dashOffset=%v clips=%v",
+		c.Name,
+		c.Args,
+		c.StrokeColor,
+		c.FillColor,
+		c.LineWidth,
+		c.Dashes,
+		c.DashOffset,
+		c.Clips,
+	)
+}
+
+// fakePrimitiveDrawer is a reusable PrimitiveDrawer test double.
+// It records all calls and emulates stateful behavior, including nested
+// Save/Restore and clip reset semantics.
+type fakePrimitiveDrawer struct {
+	commands []fakeDrawerCommand
+	state    fakeDrawerState
+	stack    []fakeDrawerState
+}
+
+// Ensure fakePrimitiveDrawer implements PrimitiveDrawer.
+var _ PrimitiveDrawer = (*fakePrimitiveDrawer)(nil)
+
+// rgbaColor converts any color.Color into a comparable RGBA value.
+func rgbaColor(c color.Color) color.RGBA {
+	if c == nil {
+		return color.RGBA{}
+	}
+	return color.RGBAModel.Convert(c).(color.RGBA)
+}
+
+// snapshotCommand records one command together with the current state snapshot.
+func (d *fakePrimitiveDrawer) snapshotCommand(name string, args ...float64) {
+	cmd := fakeDrawerCommand{
+		Name:        name,
+		Args:        append([]float64(nil), args...),
+		StrokeColor: d.state.StrokeColor,
+		FillColor:   d.state.FillColor,
+		LineWidth:   d.state.LineWidth,
+		Dashes:      append([]float64(nil), d.state.Dashes...),
+		DashOffset:  d.state.DashOffset,
+		Clips:       append([]fakeClipRect(nil), d.state.Clips...),
+	}
+	d.commands = append(d.commands, cmd)
+}
+
+// Save stores the current fake state.
+func (d *fakePrimitiveDrawer) Save() {
+	d.stack = append(d.stack, d.state.clone())
+	d.snapshotCommand("Save")
+}
+
+// Restore restores the most recently saved fake state.
+func (d *fakePrimitiveDrawer) Restore() {
+	if len(d.stack) == 0 {
+		panic("fakePrimitiveDrawer: Restore without matching Save")
+	}
+
+	d.state = d.stack[len(d.stack)-1]
+	d.stack = d.stack[:len(d.stack)-1]
+	d.snapshotCommand("Restore")
+}
+
+// ResetClip clears the current fake clip stack.
+func (d *fakePrimitiveDrawer) ResetClip() {
+	d.state.Clips = nil
+	d.snapshotCommand("ResetClip")
+}
+
+// ClipRect appends one clip rectangle to the current fake state.
+func (d *fakePrimitiveDrawer) ClipRect(x, y, w, h float64) {
+	d.state.Clips = append(d.state.Clips, fakeClipRect{X: x, Y: y, W: w, H: h})
+	d.snapshotCommand("ClipRect", x, y, w, h)
+}
+
+// SetStrokeColor sets the current fake stroke color.
+func (d *fakePrimitiveDrawer) SetStrokeColor(c color.Color) {
+	d.state.StrokeColor = rgbaColor(c)
+	d.snapshotCommand("SetStrokeColor")
+}
+
+// SetFillColor sets the current fake fill color.
+func (d *fakePrimitiveDrawer) SetFillColor(c color.Color) {
+	d.state.FillColor = rgbaColor(c)
+	d.snapshotCommand("SetFillColor")
+}
+
+// SetLineWidth sets the current fake line width.
+func (d *fakePrimitiveDrawer) SetLineWidth(width float64) {
+	d.state.LineWidth = width
+	d.snapshotCommand("SetLineWidth", width)
+}
+
+// SetDash sets the current fake dash pattern.
+func (d *fakePrimitiveDrawer) SetDash(dashes ...float64) {
+	d.state.Dashes = append([]float64(nil), dashes...)
+	d.snapshotCommand("SetDash", dashes...)
+}
+
+// SetDashOffset sets the current fake dash offset.
+func (d *fakePrimitiveDrawer) SetDashOffset(offset float64) {
+	d.state.DashOffset = offset
+	d.snapshotCommand("SetDashOffset", offset)
+}
+
+// AddPoint records a point path append command.
+func (d *fakePrimitiveDrawer) AddPoint(x, y, r float64) {
+	d.snapshotCommand("AddPoint", x, y, r)
+}
+
+// AddLine records a line path append command.
+func (d *fakePrimitiveDrawer) AddLine(x1, y1, x2, y2 float64) {
+	d.snapshotCommand("AddLine", x1, y1, x2, y2)
+}
+
+// AddCircle records a circle path append command.
+func (d *fakePrimitiveDrawer) AddCircle(cx, cy, r float64) {
+	d.snapshotCommand("AddCircle", cx, cy, r)
+}
+
+// Stroke records a stroke finalization command.
+func (d *fakePrimitiveDrawer) Stroke() {
+	d.snapshotCommand("Stroke")
+}
+
+// Fill records a fill finalization command.
+func (d *fakePrimitiveDrawer) Fill() {
+	d.snapshotCommand("Fill")
+}
+
+// Commands returns a defensive copy of the recorded command log.
+func (d *fakePrimitiveDrawer) Commands() []fakeDrawerCommand {
+	out := make([]fakeDrawerCommand, len(d.commands))
+	copy(out, d.commands)
+	return out
+}
+
+// CommandNames returns only command names in call order.
+func (d *fakePrimitiveDrawer) CommandNames() []string {
+	out := make([]string, 0, len(d.commands))
+	for _, cmd := range d.commands {
+		out = append(out, cmd.Name)
+	}
+	return out
+}
+
+// CommandsByName returns all commands with the given name.
+func (d *fakePrimitiveDrawer) CommandsByName(name string) []fakeDrawerCommand {
+	var out []fakeDrawerCommand
+	for _, cmd := range d.commands {
+		if cmd.Name == name {
+			out = append(out, cmd)
+		}
+	}
+	return out
+}
+
+// LastCommand returns the last recorded command and whether it exists.
+func (d *fakePrimitiveDrawer) LastCommand() (fakeDrawerCommand, bool) {
+	if len(d.commands) == 0 {
+		return fakeDrawerCommand{}, false
+	}
+	return d.commands[len(d.commands)-1], true
+}
+
+// CurrentState returns a defensive copy of the current fake state.
+func (d *fakePrimitiveDrawer) CurrentState() fakeDrawerState {
+	return d.state.clone()
+}
+
+// SaveDepth returns the current Save/Restore nesting depth.
+func (d *fakePrimitiveDrawer) SaveDepth() int {
+	return len(d.stack)
+}
+
+// ResetLog clears only the command log and keeps the current state intact.
+func (d *fakePrimitiveDrawer) ResetLog() {
+	d.commands = nil
+}
+
+func (d *fakePrimitiveDrawer) CopyShift(dx, dy int) {
+	d.snapshotCommand("CopyShift", float64(dx), float64(dy))
+}
+
+func (d *fakePrimitiveDrawer) ClearAll() {
+	d.snapshotCommand("ClearAll")
+}
+
+func (d *fakePrimitiveDrawer) ClearRect(x, y, w, h int) {
+	d.snapshotCommand("ClearRect", float64(x), float64(y), float64(w), float64(h))
+}