okay giant ux refactor to hopefully make it cleaner

common/control/v1/mouse.go

@@ -0,0 +1,8 @@
+package control
+
+const (
+	MouseLeft MouseButton = iota
+	MouseRight
+)
+
+type MouseButton int

common/elements/v1/blocks/block.go

@@ -0,0 +1,73 @@
+package blocks
+
+import (
+	"image/color"
+
+	"git.vezzani.net/ben/games/common/elements/v1"
+	"git.vezzani.net/ben/games/common/elements/v1/mouse"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/vector"
+)
+
+func New(ops ...OptFunc) elements.InitFunc {
+	return func() elements.Element {
+		b := Block{}
+		for i := range ops {
+			ops[i](&b)
+		}
+		return &b
+	}
+}
+
+type Block struct {
+	anchor          elements.Point
+	backgroundColor *color.Color
+	mouse.NopHandler
+	width, height int
+	name          string
+}
+
+func (b *Block) SetAnchor(a elements.Point) {
+	d := b.anchor.Delta(a)
+	for i := range b.Children() {
+		b.Children()[i].SetAnchor(b.Children()[i].Anchor().Add(d))
+	}
+	b.anchor = a
+}
+
+func (b *Block) Bounds() elements.Bounds {
+	return elements.Bounds{
+		Min:    b.anchor,
+		Width:  b.width,
+		Height: b.height,
+	}
+}
+
+func (b *Block) Anchor() elements.Point {
+	return b.anchor
+}
+
+func (b *Block) Size() (w, h int) {
+	return b.width, b.height
+}
+
+func (b *Block) Draw(image *ebiten.Image) {
+	bnd := b.Bounds()
+	if b.backgroundColor != nil {
+		vector.DrawFilledRect(
+			image,
+			float32(b.anchor.X),
+			float32(b.anchor.Y),
+			float32(bnd.Width),
+			float32(bnd.Height),
+			*b.backgroundColor,
+			true,
+		)
+	}
+	return
+}
+
+func (b *Block) Children() []elements.Element {
+	return nil
+}

common/elements/v1/blocks/options.go

@@ -0,0 +1,23 @@
+package blocks
+
+import "image/color"
+
+type OptFunc func(*Block)
+
+func Size(w, h int) OptFunc {
+	return func(b *Block) {
+		b.width, b.height = w, h
+	}
+}
+
+func BackgroundColor(c color.Color) OptFunc {
+	return func(b *Block) {
+		b.backgroundColor = &c
+	}
+}
+
+func Name(n string) OptFunc {
+	return func(b *Block) {
+		b.name = n
+	}
+}

common/elements/v1/buttons/button.go

@@ -0,0 +1,84 @@
+package buttons
+
+import (
+	"image/color"
+
+	"git.vezzani.net/ben/games/common/elements/v1"
+	"git.vezzani.net/ben/games/common/elements/v1/blocks"
+	"git.vezzani.net/ben/games/common/elements/v1/mouse"
+	"git.vezzani.net/ben/games/common/ux/v1"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/text"
+	"golang.org/x/image/font"
+)
+
+func New(ops ...OptFunc) elements.InitFunc {
+	return func() elements.Element {
+		b := Button{
+			Block: blocks.Block{},
+			font:  ux.FontFace,
+			color: ux.FontColor,
+		}
+		for op := range ops {
+			ops[op](&b)
+		}
+
+		return &b
+	}
+}
+
+type Button struct {
+	blocks.Block
+
+	label string
+	font  font.Face
+	color color.Color
+
+	onClick     func(ms mouse.State)
+	onMouseDown func(ms mouse.State)
+	onMouseUp   func(ms mouse.State)
+}
+
+func (b *Button) Draw(screen *ebiten.Image) {
+	b.Block.Draw(screen)
+	b.drawLabel(screen)
+}
+
+func (b *Button) drawLabel(screen *ebiten.Image) {
+	if b.label != "" {
+		strBounds, _ := font.BoundString(b.font, b.label)
+
+		textWidth := strBounds.Max.X - strBounds.Min.X
+		textHeight := strBounds.Max.Y - strBounds.Min.Y
+
+		bnd := b.Bounds()
+		tx := bnd.Min.X + (bnd.Width / 2) - (textWidth / 2).Round()
+		ty := bnd.Min.Y + (bnd.Height / 2) - (textHeight / 2).Round()
+
+		text.Draw(screen, b.label, b.font, tx, ty, b.color)
+
+	}
+}
+
+func (b *Button) HandleMouseEvent(ms mouse.State) bool {
+	bnd := b.Bounds()
+
+	if !bnd.Contains(ms.Point()) {
+		return false
+	}
+	
+	switch {
+	case b.onClick != nil && (ms.RightClicked || ms.LeftClicked):
+		b.onClick(ms)
+		return true
+	case b.onMouseUp != nil && (ms.RightChanged && !ms.RightDown || ms.LeftChanged && !ms.LeftDown):
+		b.onMouseUp(ms)
+		return true
+	case b.onMouseDown != nil && (ms.RightChanged && ms.RightDown || ms.LeftChanged && ms.LeftDown):
+		b.onMouseDown(ms)
+		return true
+	}
+
+	return false
+}

common/elements/v1/buttons/options.go

@@ -0,0 +1,50 @@
+package buttons
+
+import (
+	"image/color"
+
+	"git.vezzani.net/ben/games/common/elements/v1/blocks"
+	"git.vezzani.net/ben/games/common/elements/v1/mouse"
+)
+
+type OptFunc func(button *Button)
+
+type Option interface {
+	OptFunc | blocks.OptFunc
+}
+
+func OnClick(f func(ms mouse.State)) OptFunc {
+	return func(button *Button) {
+		button.onClick = f
+	}
+}
+
+func OnMouseDown(f func(ms mouse.State)) OptFunc {
+	return func(button *Button) {
+		button.onMouseDown = f
+	}
+}
+
+func OnMouseUp(f func(ms mouse.State)) OptFunc {
+	return func(button *Button) {
+		button.onMouseUp = f
+	}
+}
+
+func BlockOpt(o blocks.OptFunc) OptFunc {
+	return func(s *Button) {
+		o(&s.Block)
+	}
+}
+
+func Label(s string) OptFunc {
+	return func(button *Button) {
+		button.label = s
+	}
+}
+
+func LabelColor(color color.Color) OptFunc {
+	return func(button *Button) {
+		button.color = color
+	}
+}

common/elements/v1/element.go

@@ -0,0 +1,42 @@
+package elements
+
+import (
+	"github.com/hajimehoshi/ebiten/v2"
+)
+
+type InitFunc func() Element
+
+type Element interface {
+	Draw(*ebiten.Image)
+	SetAnchor(Point)
+	Anchor() Point
+	Size() (w, h int)
+	Children() []Element
+}
+
+type Point struct {
+	X, Y int
+}
+
+func (p Point) Delta(p2 Point) Point {
+	return Point{
+		X: p2.X - p.X,
+		Y: p2.Y - p.Y,
+	}
+}
+
+func (p Point) Add(p2 Point) Point {
+	return Point{
+		X: p.X + p2.X,
+		Y: p.Y + p2.Y,
+	}
+}
+
+type Bounds struct {
+	Min           Point
+	Width, Height int
+}
+
+func (b *Bounds) Contains(p Point) bool {
+	return p.X >= b.Min.X && p.X <= b.Min.X+b.Width && p.Y >= b.Min.Y && p.Y <= b.Min.Y+b.Height
+}

common/elements/v1/mouse/mouse.go

@@ -0,0 +1,93 @@
+package mouse
+
+import (
+	"git.vezzani.net/ben/games/common/elements/v1"
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/inpututil"
+)
+
+type NopHandler struct{}
+
+func (n NopHandler) HandleMouseEvent(s State) bool {
+	return false
+}
+
+type EventHandler interface {
+	HandleMouseEvent(s State) bool
+}
+
+type State struct {
+	X, Y                      int
+	LeftDown, RightDown       bool
+	LeftChanged, RightChanged bool
+	LeftClicked, RightClicked bool
+	Clicked                   bool
+}
+
+func (s *State) Point() elements.Point {
+	return elements.Point{
+		X: s.X,
+		Y: s.Y,
+	}
+}
+
+func Handler(e elements.Element) func() bool {
+	newState := StateBuilder()
+	ms := newState()
+	return func() bool {
+		ms = newState()
+		return propagateMouse(e, ms)
+	}
+}
+
+func propagateMouse(e elements.Element, ms State) bool {
+	for _, c := range e.Children() {
+		if propagateMouse(c, ms) {
+			return true
+		}
+	}
+
+	if e, ok := e.(EventHandler); ok {
+		return e.HandleMouseEvent(ms)
+	}
+
+	return false
+}
+
+func StateBuilder() func() State {
+	prevState := State{}
+	state := State{}
+	return func() State {
+		state = prevState
+		state.X, state.Y = ebiten.CursorPosition()
+
+		if inpututil.IsMouseButtonJustPressed(ebiten.MouseButtonLeft) {
+			state.LeftDown = true
+		}
+		if inpututil.IsMouseButtonJustPressed(ebiten.MouseButtonRight) {
+			state.RightDown = true
+		}
+		if inpututil.IsMouseButtonJustReleased(ebiten.MouseButtonLeft) {
+			state.LeftDown = false
+			if !state.RightDown {
+				state.Clicked = true
+			}
+		}
+		if inpututil.IsMouseButtonJustReleased(ebiten.MouseButtonRight) {
+			state.RightDown = false
+			if !state.LeftDown {
+				state.Clicked = true
+			}
+		}
+
+		state.Clicked = state.Clicked && !prevState.Clicked
+
+		state.LeftChanged = state.LeftDown != prevState.LeftDown
+		state.RightChanged = state.RightDown != prevState.RightDown
+		state.LeftClicked = state.LeftChanged && state.LeftDown
+		state.RightClicked = state.RightChanged && state.RightDown
+
+		prevState = state
+		return state
+	}
+}

common/elements/v1/stacks/options.go

@@ -0,0 +1,19 @@
+package stacks
+
+import (
+	"git.vezzani.net/ben/games/common/elements/v1"
+)
+
+type OptFunc func(*Stack)
+
+func Children(children ...elements.InitFunc) OptFunc {
+	return func(s *Stack) {
+		s.childrenInit = children
+	}
+}
+
+func Horizontal() OptFunc {
+	return func(s *Stack) {
+		s.horizontal = true
+	}
+}

common/elements/v1/stacks/stack.go

@@ -0,0 +1,83 @@
+package stacks
+
+import (
+	"git.vezzani.net/ben/games/common/elements/v1"
+	"git.vezzani.net/ben/games/common/elements/v1/mouse"
+
+	"github.com/hajimehoshi/ebiten/v2"
+)
+
+func New(ops ...OptFunc) elements.InitFunc {
+	return func() elements.Element {
+		s := Stack{}
+		for op := range ops {
+			ops[op](&s)
+		}
+
+		s.children = make([]elements.Element, len(s.childrenInit))
+		var cw, ch int
+		anchor := s.anchor
+		for i := range s.childrenInit {
+			s.children[i] = s.childrenInit[i]()
+			s.children[i].SetAnchor(anchor)
+			cw, ch = s.children[i].Size()
+			if s.horizontal {
+				anchor.X += cw
+			} else {
+				anchor.Y += ch
+			}
+		}
+
+		return &s
+	}
+}
+
+type Stack struct {
+	mouse.NopHandler
+	anchor       elements.Point
+	horizontal   bool
+	childrenInit []elements.InitFunc
+	children     []elements.Element
+}
+
+func (s *Stack) SetAnchor(a elements.Point) {
+	d := s.anchor.Delta(a)
+	for i := range s.Children() {
+		s.Children()[i].SetAnchor(s.Children()[i].Anchor().Add(d))
+	}
+	s.anchor = a
+}
+
+func (s *Stack) Anchor() elements.Point {
+	return s.anchor
+}
+
+func (s *Stack) Size() (w, h int) {
+	var cw, ch int
+	for i := range s.children {
+		cw, ch = s.children[i].Size()
+		if s.horizontal {
+			w += cw
+			if h < ch {
+				h = ch
+			}
+		} else {
+			h += ch
+			if w < cw {
+				w = cw
+			}
+		}
+	}
+
+	return
+}
+
+func (s *Stack) Draw(image *ebiten.Image) {
+	for i := range s.children {
+		s.children[i].Draw(image)
+	}
+}
+
+func (s *Stack) Children() []elements.Element {
+	return s.children
+}

common/sprites/v1/sprite.go

@@ -0,0 +1,147 @@
+package sprites
+
+import (
+	"image"
+
+	"git.vezzani.net/ben/games/common/ux/v1"
+	"github.com/hajimehoshi/ebiten/v2"
+)
+
+var (
+	updateCount int
+)
+
+func Update() {
+	updateCount++
+}
+
+type animation struct {
+	RowNumber uint8
+	TickCount uint8
+	Scale     float32
+}
+
+type subImager interface {
+	image.Image
+	SubImage(r image.Rectangle) image.Image
+}
+
+type Sprite struct {
+	width, height int
+	imgData       subImager
+	animations    map[string]animation
+
+	baseAnim    *animation
+	currentAnim *animation
+
+	animationStartedAt int
+	animationStopAt    int
+	animateOnce        bool
+}
+
+func (s *Sprite) baseAnimation() animation {
+	if s.baseAnim != nil {
+		return *s.baseAnim
+	}
+
+	for i := range s.animations {
+		if s.animations[i].RowNumber == 0 {
+			a := s.animations[i]
+			s.baseAnim = &a
+			return a
+		}
+	}
+
+	return animation{}
+}
+
+func (s *Sprite) getAnimation() animation {
+	if s.currentAnim != nil {
+		return *s.currentAnim
+	}
+	return s.baseAnimation()
+}
+
+func (s *Sprite) Image(ops imageOptions) image.Image {
+	anim := s.getAnimation()
+
+	xOffset := updateCount % int(anim.TickCount) * s.width
+	yOffset := int(anim.RowNumber) * s.height
+
+	r := image.Rect(xOffset, yOffset, s.width, s.height).Intersect(s.imgData.Bounds())
+
+	return s.imgData.SubImage(r)
+}
+
+func (s *Sprite) Draw(screen *ebiten.Image, options ...ImageOption) {
+	if s.getAnimation().RowNumber == 0 {
+	}
+
+	ops := imageOptions{
+		scaleX: ux.Scale,
+		scaleY: ux.Scale,
+	}
+
+	for _, o := range options {
+		o(&ops)
+	}
+
+	geom := ebiten.GeoM{}
+	geom.Translate(ops.x, ops.y)
+	geom.Scale(ops.scaleX, ops.scaleY)
+	geom.Rotate(ops.rotateTheta)
+
+	screen.DrawImage(
+		ebiten.NewImageFromImage(
+			s.Image(ops),
+		),
+		&ebiten.DrawImageOptions{
+			GeoM: geom,
+		},
+	)
+}
+
+func (s *Sprite) StartAnimation(id string, once bool) {
+	if a, ok := s.animations[id]; ok {
+		s.currentAnim = &a
+	}
+	if once {
+		s.animateOnce = true
+		s.animationStopAt = updateCount + int(s.currentAnim.TickCount)
+	}
+	s.animationStartedAt = updateCount
+}
+
+func (s *Sprite) StopAnimation() {
+	s.currentAnim = nil
+	s.animationStartedAt = 0
+	s.animationStopAt = 0
+	s.animateOnce = false
+}
+
+type imageOptions struct {
+	x, y           float64
+	scaleX, scaleY float64
+	rotateTheta    float64
+}
+
+type ImageOption func(options *imageOptions)
+
+func ToScale(x, y float64) ImageOption {
+	return func(o *imageOptions) {
+		o.scaleX *= x
+		o.scaleY *= y
+	}
+}
+
+func AtPosition(x, y float64) ImageOption {
+	return func(o *imageOptions) {
+		o.x, o.y = x, y
+	}
+}
+
+func Rotate(theta float64) ImageOption {
+	return func(o *imageOptions) {
+		o.rotateTheta = theta
+	}
+}

common/ux/v1/ux.go

@@ -0,0 +1,15 @@
+package ux
+
+import (
+	"image/color"
+
+	"golang.org/x/image/font"
+	"golang.org/x/image/font/basicfont"
+)
+
+var (
+	FontFace        font.Face   = basicfont.Face7x13
+	FontColor       color.Color = color.Black
+	BackgroundColor color.Color = color.White
+	Scale           float64     = 1.0
+)

games/minesweeper/v1/main.go

@@ -3,12 +3,12 @@ package main
 import (
 	"log"
 
-	"git.vezzani.net/ben/games/games/minesweeper/game"
+	"git.vezzani.net/ben/games/games/minesweeper/v1/game"
 	"github.com/hajimehoshi/ebiten/v2"
 )
 
 func main() {
-	g := game.New(10, 10, 50)
+	g := game.New(10, 10, 15)
 	w, h := g.Layout(0, 0)
 	ebiten.SetWindowSize(w, h)
 	ebiten.SetWindowTitle("Minesweeper")

go.mod

@@ -1,17 +1,22 @@
 module git.vezzani.net/ben/games
 
-go 1.24
+go 1.25
 
 require (
+	github.com/ebitenui/ebitenui v0.7.1
 	github.com/hajimehoshi/ebiten/v2 v2.8.8
-	golang.org/x/image v0.20.0
+	golang.org/x/image v0.25.0
 )
 
 require (
-	github.com/ebitengine/gomobile v0.0.0-20240911145611-4856209ac325 // indirect
+	github.com/ebitengine/gomobile v0.0.0-20250209143333-6071a2a2351c // indirect
 	github.com/ebitengine/hideconsole v1.0.0 // indirect
-	github.com/ebitengine/purego v0.8.0 // indirect
+	github.com/ebitengine/purego v0.8.2 // indirect
+	github.com/frustra/bbcode v0.0.0-20201127003707-6ef347fbe1c8 // indirect
+	github.com/go-text/typesetting v0.3.0 // indirect
 	github.com/jezek/xgb v1.1.1 // indirect
-	golang.org/x/sync v0.8.0 // indirect
-	golang.org/x/sys v0.25.0 // indirect
+	golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 // indirect
+	golang.org/x/sync v0.12.0 // indirect
+	golang.org/x/sys v0.31.0 // indirect
+	golang.org/x/text v0.23.0 // indirect
 )

go.sum

@@ -1,22 +1,44 @@
-github.com/ebitengine/gomobile v0.0.0-20240911145611-4856209ac325 h1:Gk1XUEttOk0/hb6Tq3WkmutWa0ZLhNn/6fc6XZpM7tM=
-github.com/ebitengine/gomobile v0.0.0-20240911145611-4856209ac325/go.mod h1:ulhSQcbPioQrallSuIzF8l1NKQoD7xmMZc5NxzibUMY=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/ebitengine/gomobile v0.0.0-20250209143333-6071a2a2351c h1:nCxkoQoJMcVLc5aoMp3ULbfyEMcQjxopBKgNQVBQFXE=
+github.com/ebitengine/gomobile v0.0.0-20250209143333-6071a2a2351c/go.mod h1:yMh1VvLL71zDgHlVlIXXJIGmv36QcJ9ZD2gtIGYAp3I=
 github.com/ebitengine/hideconsole v1.0.0 h1:5J4U0kXF+pv/DhiXt5/lTz0eO5ogJ1iXb8Yj1yReDqE=
 github.com/ebitengine/hideconsole v1.0.0/go.mod h1:hTTBTvVYWKBuxPr7peweneWdkUwEuHuB3C1R/ielR1A=
-github.com/ebitengine/purego v0.8.0 h1:JbqvnEzRvPpxhCJzJJ2y0RbiZ8nyjccVUrSM3q+GvvE=
-github.com/ebitengine/purego v0.8.0/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
+github.com/ebitengine/purego v0.8.2 h1:jPPGWs2sZ1UgOSgD2bClL0MJIqu58nOmIcBuXr62z1I=
+github.com/ebitengine/purego v0.8.2/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
+github.com/ebitenui/ebitenui v0.7.1 h1:5ZOaonRs4EsO9LtVVJr1zXNBXadUA9ktaZQLg9QgWao=
+github.com/ebitenui/ebitenui v0.7.1/go.mod h1:QiJoDflkWoBv4V/LKErS3cgzTZHrXDQyqajef7IA8vM=
+github.com/frustra/bbcode v0.0.0-20201127003707-6ef347fbe1c8 h1:sdIsYe6Vv7KIWZWp8KqSeTl+XlF17d+wHCC4lbxFcYs=
+github.com/frustra/bbcode v0.0.0-20201127003707-6ef347fbe1c8/go.mod h1:0QBxkXxN+o4FyZgLI9FHY/oUizheze3+bNY/kgCKL+4=
+github.com/go-text/typesetting v0.3.0 h1:OWCgYpp8njoxSRpwrdd1bQOxdjOXDj9Rqart9ML4iF4=
+github.com/go-text/typesetting v0.3.0/go.mod h1:qjZLkhRgOEYMhU9eHBr3AR4sfnGJvOXNLt8yRAySFuY=
+github.com/go-text/typesetting-utils v0.0.0-20241103174707-87a29e9e6066 h1:qCuYC+94v2xrb1PoS4NIDe7DGYtLnU2wWiQe9a1B1c0=
+github.com/go-text/typesetting-utils v0.0.0-20241103174707-87a29e9e6066/go.mod h1:DDxDdQEnB70R8owOx3LVpEFvpMK9eeH1o2r0yZhFI9o=
 github.com/hajimehoshi/bitmapfont/v3 v3.2.0 h1:0DISQM/rseKIJhdF29AkhvdzIULqNIIlXAGWit4ez1Q=
 github.com/hajimehoshi/bitmapfont/v3 v3.2.0/go.mod h1:8gLqGatKVu0pwcNCJguW3Igg9WQqVXF0zg/RvrGQWyg=
 github.com/hajimehoshi/ebiten/v2 v2.8.8 h1:xyMxOAn52T1tQ+j3vdieZ7auDBOXmvjUprSrxaIbsi8=
 github.com/hajimehoshi/ebiten/v2 v2.8.8/go.mod h1:durJ05+OYnio9b8q0sEtOgaNeBEQG7Yr7lRviAciYbs=
 github.com/jezek/xgb v1.1.1 h1:bE/r8ZZtSv7l9gk6nU0mYx51aXrvnyb44892TwSaqS4=
 github.com/jezek/xgb v1.1.1/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
+github.com/matryer/is v1.4.1 h1:55ehd8zaGABKLXQUe2awZ99BD/PTc2ls+KV/dXphgEQ=
+github.com/matryer/is v1.4.1/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=
 github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
 github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
-golang.org/x/image v0.20.0 h1:7cVCUjQwfL18gyBJOmYvptfSHS8Fb3YUDtfLIZ7Nbpw=
-golang.org/x/image v0.20.0/go.mod h1:0a88To4CYVBAHp5FXJm8o7QbUl37Vd85ply1vyD8auM=
-golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
-golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
-golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224=
-golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 h1:nDVHiLt8aIbd/VzvPWN6kSOPE7+F/fNFDSXLVYkE/Iw=
+golang.org/x/exp v0.0.0-20250305212735-054e65f0b394/go.mod h1:sIifuuw/Yco/y6yb6+bDNfyeQ/MdPUy/hKEMYQV17cM=
+golang.org/x/image v0.25.0 h1:Y6uW6rH1y5y/LK1J8BPWZtr6yZ7hrsy6hFrXjgsc2fQ=
+golang.org/x/image v0.25.0/go.mod h1:tCAmOEGthTtkalusGp1g3xa2gke8J6c2N565dTyl9Rs=
+golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
+golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
+golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

tools/component_test/editor.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"git.vezzani.net/ben/games/common/elements/v1"
+	"git.vezzani.net/ben/games/common/elements/v1/blocks"
+	"git.vezzani.net/ben/games/common/elements/v1/buttons"
+	"git.vezzani.net/ben/games/common/elements/v1/mouse"
+	"git.vezzani.net/ben/games/common/elements/v1/stacks"
+	"git.vezzani.net/ben/games/common/sprites/v1"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"golang.org/x/image/colornames"
+)
+
+var root = stacks.New(
+	stacks.Horizontal(),
+	//stacks.BlockOpt(blocks.BackgroundColor(color.White)),
+	//stacks.BlockOpt(blocks.Name("parent")),
+	stacks.Children(
+		stacks.New(
+			//stacks.BlockOpt(blocks.Name("left")),
+			stacks.Children(
+				buttons.New(
+					buttons.BlockOpt(blocks.Size(100, 100)),
+					buttons.Label("hello"),
+					buttons.BlockOpt(blocks.BackgroundColor(colornames.Green)),
+					buttons.OnClick(func(ms mouse.State) {
+						println("green")
+					}),
+				),
+				blocks.New(
+					blocks.Size(100, 100),
+					blocks.BackgroundColor(colornames.Yellow),
+				),
+			),
+		),
+		stacks.New(
+			//stacks.BlockOpt(blocks.Name("right")),
+			stacks.Children(
+				blocks.New(
+					blocks.Size(100, 100),
+					blocks.BackgroundColor(colornames.Blue),
+				),
+				blocks.New(
+					blocks.Size(100, 100),
+					blocks.BackgroundColor(colornames.Red),
+				),
+			),
+		),
+	),
+)
+
+func newEditor() *editor {
+	return &editor{}
+}
+
+type editor struct {
+	root        elements.Element
+	bounds      elements.Bounds
+	handleMouse func() bool
+}
+
+func (e *editor) Update() error {
+	sprites.Update()
+	e.handleMouse()
+	return nil
+}
+
+func (e *editor) Draw(screen *ebiten.Image) {
+	e.root.Draw(screen)
+}
+
+func (e *editor) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
+	if e.bounds.Width != outsideWidth || e.bounds.Height != outsideHeight {
+		e.bounds = elements.Bounds{
+			Min:    elements.Point{},
+			Width:  outsideWidth,
+			Height: outsideHeight,
+		}
+		e.root = root()
+		e.handleMouse = mouse.Handler(e.root)
+	}
+
+	return outsideWidth, outsideHeight
+}

tools/component_test/main.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"github.com/hajimehoshi/ebiten/v2"
+)
+
+func main() {
+	ebiten.SetWindowSize(480, 320)
+	ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
+	ebiten.SetWindowTitle("Component/Layout Test")
+	e := newEditor()
+	if err := ebiten.RunGame(e); err != nil {
+		panic(err)
+	}
+}

tools/spritedit/editor.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"image/color"
+
+	"git.vezzani.net/ben/games/common/elements/v1"
+	"git.vezzani.net/ben/games/common/elements/v1/blocks"
+	"git.vezzani.net/ben/games/common/elements/v1/stacks"
+	"git.vezzani.net/ben/games/common/sprites/v1"
+	"github.com/hajimehoshi/ebiten/v2"
+	"golang.org/x/image/colornames"
+)
+
+var menu = stacks.New(
+	stacks.BlockOpt(blocks.BackgroundColor(color.White)),
+	stacks.BlockOpt(blocks.Size(100, 200)),
+	stacks.Children(
+		blocks.New(blocks.BackgroundColor(colornames.Green)),
+		blocks.New(),
+	),
+)
+
+func newEditor() *editor {
+	return &editor{}
+}
+
+type editor struct {
+}
+
+func (e *editor) Update() error {
+	sprites.Update()
+
+	return nil
+}
+
+func (e *editor) Draw(screen *ebiten.Image) {
+	b := screen.Bounds()
+	menu(elements.Bounds{
+		ZX: float64(b.Min.X),
+		ZY: float64(b.Min.Y),
+		WX: float64(b.Max.X),
+		WY: float64(b.Max.Y),
+	}).Draw(screen)
+}
+
+func (e *editor) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
+	return outsideWidth, outsideHeight
+}

tools/spritedit/main.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"github.com/hajimehoshi/ebiten/v2"
+)
+
+func main() {
+	ebiten.SetWindowSize(480, 320)
+	ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
+	ebiten.SetWindowTitle("Sprite Editor")
+	e := newEditor()
+	if err := ebiten.RunGame(e); err != nil {
+		panic(err)
+	}
+}