node_multi.go

package scaff

import "github.com/hajimehoshi/ebiten/v2"

// Struct for defining a new multi child node.
//
// ID should be a unique id for the node, but also probably be readable as it shows up in error messages.
//
// DefaultProps are the props as they are by default. Make sure to also specify any embedded struct pointers.
//
// PropsCreator should be the function passed in by users of your node (as in it should probably be an argument of the function creating your node).
//
// Create is the function actually specifying your node. You can overwrite all of the functions of the node interface there, with some exceptions that we implement for you.
type MultiNodeCreate[P ChildProps[NodeBuilder]] struct {
	ID           string
	DefaultProps P
	PropsCreator func(t *Tracker, props *P)
	Create       func(props *MultiChildProps[P])
}

// MultiNode lets you create a node with multiple children. Simply implement the ChildProps interface on the props you want to have for your node.
func MultiNode[P ChildProps[NodeBuilder]](create MultiNodeCreate[P]) NodeBuilder {
	node := &MultiChildNode[P]{
		id:         create.ID,
		multiProps: &MultiChildProps[P]{},
	}
	if create.Create != nil {
		create.Create(node.multiProps)
	}

	return func(context *BuildContext) Node {
		node.tracker = NewTracker()
		node.context = context

		// Fill the props
		props := create.DefaultProps
		if create.PropsCreator != nil {
			create.PropsCreator(node.Tracker(), &props)

			node.builders = props.GetBuilders()
		}
		node.props = props

		// Call props change hook (in case registered)
		if node.multiProps.OnPropsChanged != nil {
			node.multiProps.OnPropsChanged(node)
		}

		return node
	}
}

type MultiChildProps[P any] struct {
	OnLoad         func(node *MultiChildNode[P], parent Node)
	OnUnload       func(node *MultiChildNode[P])
	OnPropsChanged func(node *MultiChildNode[P])
	OnUpdate       func(node *MultiChildNode[P], c *Context) error
	OnHandleEvent  func(node *MultiChildNode[P], c *Context, event Event) error
	OnDraw         func(node *MultiChildNode[P], c *Context, image *ebiten.Image)
}

// Just for making sure we implement the Node interface
var _ Node = &MultiChildNode[any]{}

type MultiChildNode[P any] struct {
	parent   Node
	children []Node
	builders []NodeBuilder

	tracker *Tracker
	context *BuildContext

	id         string
	props      P
	multiProps *MultiChildProps[P]
}

func (s *MultiChildNode[P]) ID() string {
	return s.id
}

func (s *MultiChildNode[P]) Props() P {
	return s.props
}

func (s *MultiChildNode[P]) Load(parent Node) {
	s.parent = parent

	// Actually load the children and build them
	if s.builders != nil {
		s.children = make([]Node, len(s.builders))
		for i, builder := range s.builders {
			s.children[i] = builder(s.context)
			s.children[i].Load(s)
		}
	}

	if s.multiProps.OnLoad != nil {
		s.multiProps.OnLoad(s, parent)
	}
}

func (s *MultiChildNode[P]) PropsChanged() {

}

func (s *MultiChildNode[P]) HandleEvent(c *Context, event Event) TracedError {

	// First handle event on this node
	if s.multiProps.OnHandleEvent != nil {
		if err := s.multiProps.OnHandleEvent(s, c, event); err != nil {
			return NewTracedError(s, err)
		}
	}

	// Then pass event to children
	return s.HandleEventChild(c, event)
}

func (s *MultiChildNode[P]) Tracker() *Tracker {
	return s.tracker
}

func (s *MultiChildNode[P]) Update(c *Context) TracedError {

	// First call the update handler on the props for this node
	if s.multiProps.OnUpdate != nil {
		if err := s.multiProps.OnUpdate(s, c); err != nil {
			return NewTracedError(s, err)
		}
	}

	// Forward the update to the children
	for _, child := range s.children {
		if err := child.Update(c); err != nil {
			return err
		}
	}

	// If any of the children are dirty, rebuild them
	for i, child := range s.children {
		if child.Tracker().Changed() {
			child.Unload()
			s.children[i] = s.builders[i](s.context)
			s.children[i].Load(s)
		}
	}

	return nil
}

func (s *MultiChildNode[P]) Unload() {
	if s.multiProps.OnUnload != nil {
		s.multiProps.OnUnload(s)
	}

	// Unload the children properly
	for _, child := range s.children {
		child.Unload()
	}

	s.tracker.Clear()
	s.tracker = nil // Cut tracker off from tree for GC
}

func (s *MultiChildNode[P]) Draw(c *Context, image *ebiten.Image) {
	if s.multiProps.OnDraw != nil {
		s.multiProps.OnDraw(s, c, image)
	} else {

		// Default implementation: just draw children
		s.DrawChild(c, image)
	}
}

func (s *MultiChildNode[P]) Parent() Node {
	return s.parent
}

func (s *MultiChildNode[P]) Children() []Node {
	return s.children
}

func (s *MultiChildNode[P]) HandleEventChild(c *Context, event Event) TracedError {
	// Event should always be passed to the children as well so it doesn't get missed (even if already handled)
	for _, child := range s.children {
		if err := child.HandleEvent(c, event); err != nil {
			return err
		}
	}

	return nil
}

// Draw the children of the node
func (s *MultiChildNode[P]) DrawChild(c *Context, image *ebiten.Image) {
	for _, child := range s.children {
		child.Draw(c, image)
	}
}