ticker.go

package behaviortree

import (
	"errors"
	"fmt"
)

/* ============================== TickerType ============================== */
//

type TickerType byte

const (
	TickerTypeUnknown TickerType = 0

	// Leaf node - no child node
	TickerTypeAction    TickerType = 1 // Action node
	TickerTypeCondition TickerType = 2 // Condition node

	// Composite node - at least one child node
	TickerTypeSequence TickerType = 50 // Sequence node
	TickerTypeSelector TickerType = 51 // Selector node
	TickerTypeParallel TickerType = 52 // Parallel node

	// Decorative node - only one child node
	TickerTypeSucceeder          TickerType = 100 // Succeeder node
	TickerTypeFailure            TickerType = 101 // Failure node
	TickerTypeInverter           TickerType = 102 // Inverter node
	TickerTypeRepeater           TickerType = 103 // Repeater node
	TickerTypeRepeatUntilFail    TickerType = 104 // RepeatUntilFail node
	TickerTypeRepeatUntilSucceed TickerType = 105 // RepeatUntilSucceed node

	// Node enumeration maximum
	TickerTypeMax
)

func (t TickerType) String() string {
	switch t {
	case TickerTypeAction:
		return "Action"
	case TickerTypeCondition:
		return "Condition"

	case TickerTypeSequence:
		return "Sequence"
	case TickerTypeSelector:
		return "Selector"
	case TickerTypeParallel:
		return "Parallel"

	case TickerTypeSucceeder:
		return "Succeeder"
	case TickerTypeFailure:
		return "Failure"
	case TickerTypeInverter:
		return "Inverter"
	case TickerTypeRepeater:
		return "Repeater"
	case TickerTypeRepeatUntilFail:
		return "RepeatUntilFail"
	case TickerTypeRepeatUntilSucceed:
		return "RepeatUntilSucceed"
	}
	panic(errors.New("unknown node type"))
}

func (t TickerType) IsLeafNode() bool {
	return t >= TickerTypeAction && t < TickerTypeSequence
}

func (t TickerType) IsCompositeNode() bool {
	return t >= TickerTypeSequence && t < TickerTypeSucceeder
}

func (t TickerType) IsDecoratorNode() bool {
	return t >= TickerTypeSucceeder && t < TickerTypeMax
}

/* ============================== TickStatus ============================== */
//

type TickStatus byte

const (
	TickStatusNotTick TickStatus = iota
	TickStatusSuccess
	TickStatusFailure
	TickStatusRunning
)

func (s TickStatus) String() string {
	switch s {
	case TickStatusNotTick:
		return "NotTick"
	case TickStatusSuccess:
		return "Success"
	case TickStatusFailure:
		return "Failure"
	case TickStatusRunning:
		return "Running"
	}
	panic(errors.New("unknown node status"))
}

func (s TickStatus) IsFinal() bool {
	return s == TickStatusSuccess || s == TickStatusFailure
}

func (s TickStatus) IsTickValid() bool {
	return s == TickStatusSuccess || s == TickStatusFailure || s == TickStatusRunning
}

func (s TickStatus) Invert() TickStatus {
	switch s {
	case TickStatusSuccess:
		return TickStatusFailure
	case TickStatusFailure:
		return TickStatusSuccess
	default:
		return s
	}
}

/* ============================== Ticker ============================== */
//

type Ticker interface {
	Index() int
	Type() TickerType
	Tick() TickStatus
}

/* ============================== action Ticker ============================== */
//

type actionTicker struct {
	bt    *builtTree
	index int
}

var _ Ticker = (*actionTicker)(nil)

func (t *actionTicker) Type() TickerType { return TickerTypeAction }

func (t *actionTicker) Index() int { return t.index }

func (t *actionTicker) Tick() TickStatus {
	t.bt.setTickerTickTime(t.index)
	if status := t.bt.getTickerStatus(t.index); status.IsFinal() {
		return status
	}
	t.bt.setTickerTicked(t.index)

	status := t.bt.getLeafNode(t.index).(ActionNode).Action(t.bt.getContext(), t.bt.getBlackboards(t.index))

	if !status.IsTickValid() {
		panic(fmt.Errorf("invalid tick status: action name: %s", t.bt.getTickerName(t.index)))
	}

	t.bt.setTickerStatus(t.index, status)

	return status
}

/* ============================== condition Ticker ============================== */
//

type conditionTicker struct {
	bt    *builtTree
	index int
}

var _ Ticker = (*conditionTicker)(nil)

func (t *conditionTicker) Type() TickerType { return TickerTypeCondition }

func (t *conditionTicker) Index() int { return t.index }

func (t *conditionTicker) Tick() TickStatus {
	t.bt.setTickerTickTime(t.index)
	if status := t.bt.getTickerStatus(t.index); status.IsFinal() {
		return status
	}
	t.bt.setTickerTicked(t.index)

	status := TickStatusFailure
	if t.bt.getLeafNode(t.index).(ConditionNode).Condition(t.bt.getContext(), t.bt.getBlackboards(t.index)) {
		status = TickStatusSuccess
	}

	t.bt.setTickerStatus(t.index, status)

	return status
}

/* ============================== sequence Ticker ============================== */
//

type sequenceTicker struct {
	bt    *builtTree
	index int

	children []int
}

var _ Ticker = (*sequenceTicker)(nil)

func (t *sequenceTicker) Type() TickerType { return TickerTypeSequence }

func (t *sequenceTicker) Index() int { return t.index }

func (t *sequenceTicker) Tick() TickStatus {
	t.bt.setTickerTickTime(t.index)
	if status := t.bt.getTickerStatus(t.index); status.IsFinal() {
		return status
	}
	t.bt.setTickerTicked(t.index)

	var status TickStatus
	for _, child := range t.children {
		status = t.bt.getTicker(child).Tick()
		if status == TickStatusFailure || status == TickStatusRunning {
			break
		}
	}

	t.bt.setTickerStatus(t.index, status)

	return status
}

/* ============================== selector Ticker ============================== */
//

type selectorTicker struct {
	bt    *builtTree
	index int

	children []int
}

var _ Ticker = (*selectorTicker)(nil)

func (t *selectorTicker) Type() TickerType { return TickerTypeSelector }

func (t *selectorTicker) Index() int { return t.index }

func (t *selectorTicker) Tick() TickStatus {
	t.bt.setTickerTickTime(t.index)
	if status := t.bt.getTickerStatus(t.index); status.IsFinal() {
		return status
	}
	t.bt.setTickerTicked(t.index)

	var status TickStatus
	for _, child := range t.children {
		status = t.bt.getTicker(child).Tick()
		if status == TickStatusSuccess || status == TickStatusRunning {
			break
		}
	}

	t.bt.setTickerStatus(t.index, status)

	return status
}

/* ============================== parallel Ticker ============================== */
//

type parallelTicker struct {
	bt    *builtTree
	index int

	children []int
}

var _ Ticker = (*parallelTicker)(nil)

func (t *parallelTicker) Type() TickerType { return TickerTypeParallel }

func (t *parallelTicker) Index() int { return t.index }

func (t *parallelTicker) Tick() TickStatus {
	t.bt.setTickerTickTime(t.index)
	if status := t.bt.getTickerStatus(t.index); status.IsFinal() {
		return status
	}
	t.bt.setTickerTicked(t.index)

	var hasSuccess, hasFailure bool
	for _, child := range t.children {
		switch t.bt.getTicker(child).Tick() {
		case TickStatusSuccess:
			hasSuccess = true
		case TickStatusFailure:
			hasFailure = true
		}
	}

	var status TickStatus
	if hasSuccess {
		status = TickStatusSuccess
	} else if hasFailure {
		status = TickStatusFailure
	} else {
		status = TickStatusRunning
	}

	t.bt.setTickerStatus(t.index, status)

	return status
}

/* ============================== succeeder Ticker ============================== */
//

type succeederTicker struct {
	bt    *builtTree
	index int

	child int
}

var _ Ticker = (*succeederTicker)(nil)

func (t *succeederTicker) Type() TickerType { return TickerTypeSucceeder }

func (t *succeederTicker) Index() int { return t.index }

func (t *succeederTicker) Tick() TickStatus {
	t.bt.setTickerTickTime(t.index)
	if status := t.bt.getTickerStatus(t.index); status.IsFinal() {
		return status
	}
	t.bt.setTickerTicked(t.index)

	t.bt.getTicker(t.child).Tick()

	t.bt.setTickerStatus(t.index, TickStatusSuccess)

	return TickStatusSuccess
}

/* ============================== failure Ticker ============================== */
//

type failureTicker struct {
	bt    *builtTree
	index int

	child int
}

var _ Ticker = (*failureTicker)(nil)

func (t *failureTicker) Type() TickerType { return TickerTypeFailure }

func (t *failureTicker) Index() int { return t.index }

func (t *failureTicker) Tick() TickStatus {
	t.bt.setTickerTickTime(t.index)
	if status := t.bt.getTickerStatus(t.index); status.IsFinal() {
		return status
	}
	t.bt.setTickerTicked(t.index)

	t.bt.getTicker(t.child).Tick()

	t.bt.setTickerStatus(t.index, TickStatusFailure)

	return TickStatusFailure
}

/* ============================== inverter Ticker ============================== */
//

type inverterTicker struct {
	bt    *builtTree
	index int

	child int
}

var _ Ticker = (*inverterTicker)(nil)

func (t *inverterTicker) Type() TickerType { return TickerTypeInverter }

func (t *inverterTicker) Index() int { return t.index }

func (t *inverterTicker) Tick() TickStatus {
	t.bt.setTickerTickTime(t.index)
	if status := t.bt.getTickerStatus(t.index); status.IsFinal() {
		return status
	}
	t.bt.setTickerTicked(t.index)

	status := t.bt.getTicker(t.child).Tick().Invert()

	t.bt.setTickerStatus(t.index, status)

	return status
}

/* ============================== repeater Ticker ============================== */
//

type repeaterTicker struct {
	bt    *builtTree
	index int

	child int
}

var _ Ticker = (*repeaterTicker)(nil)

func (t *repeaterTicker) Type() TickerType { return TickerTypeRepeater }

func (t *repeaterTicker) Index() int { return t.index }

func (t *repeaterTicker) Tick() TickStatus {
	t.bt.setTickerTickTime(t.index)
	// if status := t.bt.getTickerStatus(t.index); status.IsFinal() {
	// 	return status
	// }
	t.bt.setTickerTicked(t.index)

	if status := t.bt.getTickerStatus(t.index + 1); status.IsFinal() {
		t.bt.resetChildren(t.index)
	}

	t.bt.getTicker(t.child).Tick()

	t.bt.setTickerStatus(t.index, TickStatusRunning)

	return TickStatusRunning
}

/* ============================== repeatUntilFail Ticker ============================== */
//

type repeatUntilFailTicker struct {
	bt    *builtTree
	index int

	child int
}

var _ Ticker = (*repeatUntilFailTicker)(nil)

func (t *repeatUntilFailTicker) Type() TickerType { return TickerTypeRepeatUntilFail }

func (t *repeatUntilFailTicker) Index() int { return t.index }

func (t *repeatUntilFailTicker) Tick() TickStatus {
	t.bt.setTickerTickTime(t.index)
	if status := t.bt.getTickerStatus(t.index); status.IsFinal() {
		return status
	}
	t.bt.setTickerTicked(t.index)

	if status := t.bt.getTickerStatus(t.index + 1); status.IsFinal() {
		t.bt.resetChildren(t.index)
	}

	status := t.bt.getTicker(t.child).Tick()
	if status != TickStatusFailure {
		status = TickStatusRunning
	}

	t.bt.setTickerStatus(t.index, status)

	return status
}

/* ============================== repeatUntilSucceed Ticker ============================== */
//

type repeatUntilSucceedTicker struct {
	bt    *builtTree
	index int

	child int
}

var _ Ticker = (*repeatUntilSucceedTicker)(nil)

func (t *repeatUntilSucceedTicker) Type() TickerType { return TickerTypeRepeatUntilSucceed }

func (t *repeatUntilSucceedTicker) Index() int { return t.index }

func (t *repeatUntilSucceedTicker) Tick() TickStatus {
	t.bt.setTickerTickTime(t.index)
	if status := t.bt.getTickerStatus(t.index); status.IsFinal() {
		return status
	}
	t.bt.setTickerTicked(t.index)

	if status := t.bt.getTickerStatus(t.index + 1); status.IsFinal() {
		t.bt.resetChildren(t.index)
	}

	status := t.bt.getTicker(t.child).Tick()
	if status != TickStatusSuccess {
		status = TickStatusRunning
	}

	t.bt.setTickerStatus(t.index, status)

	return status
}