state

type Condition[Input any] func(Input) bool

type Effector[Input any, Effect any] func(Input) Effect

type InitializeSub int

type Logic[Subject any, Input any, StateData any, TransitionData any, Effect any] struct {
	// The logic that would return true if the given state is done and the non-live transitions out of it should be evaluted for the next state.
	IsDone func(*Subject, State[Subject, Input, StateData, TransitionData, Effect]) bool
	// Starts the given state on the subject, possible from a transition and possible where an unfinished state needs to be outroed so that it may eventually return true for IsDone and
	// be removed from the active states.
	Start func(*Subject, State[Subject, Input, StateData, TransitionData, Effect], *Transition[Input, TransitionData], *State[Subject, Input, StateData, TransitionData, Effect]) bool
	// The logic invoked to apply the active states on the subject. See other Applied properties.
	Apply func(*Subject, []State[Subject, Input, StateData, TransitionData, Effect])
	// If non-zero, no more than this many states should be sent to be applied to the subject.
	AppliedMax int
	// If non-nil and there's an applied max that will affect the applied states - this function will sort the states so the preferred states are applied.
	AppliedPriority func(a State[Subject, Input, StateData, TransitionData, Effect], b State[Subject, Input, StateData, TransitionData, Effect]) bool
	// If true all active states in all sub machines should be passed to apply - otherwise just the active states in the root machine are sent.
	AppliedDeep bool
	// If true only this number of states can be active at a time. Once a queue of possible active states is determined from transitions
	// only the states that can fit will be added to the active states.
	ActiveMax int
	// If non-nil and there's an active max this will sort the states in the queue to prefer the ones at the top.
	ActivePriority func(a State[Subject, Input, StateData, TransitionData, Effect], b State[Subject, Input, StateData, TransitionData, Effect]) bool
	// If true all states in the machine are always active and no transition logic is done. Only state updating.
	ActiveFully bool
	// If true when active states are removed - should the current order of the active states be preserved or does order not matter?
	ActiveOrdered bool
	// If true after transitions are evaluated in an update - should we add any to the active states so they are available in the apply?
	// If not the active queue will be processed at the start of the next update.
	ProcessQueueImmediately bool
	// Timing for when (if at all) a sub machine should be initialized (active states be determined).
	InitializeSub InitializeSub
}

type Machine[Subject any, Input any, StateData any, TransitionData any, Effect any] struct {
	Definition  *MachineDefinition[Subject, Input, StateData, TransitionData, Effect]
	Active      id.DenseMap[State[Subject, Input, StateData, TransitionData, Effect], uint16, uint8]
	ActiveQueue []State[Subject, Input, StateData, TransitionData, Effect]
	Applicable  []State[Subject, Input, StateData, TransitionData, Effect]
}

type MachineDefinition[Subject any, Input any, StateData any, TransitionData any, Effect any] struct {
	Logic       Logic[Subject, Input, StateData, TransitionData, Effect]
	States      id.DenseMap[StateDefinition[Subject, Input, StateData, TransitionData, Effect], uint16, uint8]
	Transitions []Transition[Input, TransitionData]
}

type State[Subject any, Input any, StateData any, TransitionData any, Effect any] struct {
	Definition *StateDefinition[Subject, Input, StateData, TransitionData, Effect]
	Effect     Effect
	Sub        *Machine[Subject, Input, StateData, TransitionData, Effect]
}

type StateDefinition[Subject any, Input any, StateData any, TransitionData any, Effect any] struct {
	ID             id.Identifier
	Data           StateData
	EffectGet      func(Input) Effect
	EffectConstant Effect
	EffectLive     bool
	Transitions    []Transition[Input, TransitionData]
	Sub            *MachineDefinition[Subject, Input, StateData, TransitionData, Effect]
}

type Transition[Input any, TransitionData any] struct {
	// The start state if any.
	Start id.Identifier
	// The ending state.
	End id.Identifier
	// The condition that determines whether we should take this transition.
	// This is optional and when not specified it's considered to be true.
	Condition func(Input) bool
	// If the transition should be evaluated on each update.
	Live bool
	// The data associated with this transition - used for applying it to the subject.
	Data TransitionData
}

type UserData struct {
	// contains filtered or unexported fields
}

type UserDataPropertyBase interface {
	Bytes() int
	Write(data UserData)
	SetIndex(index int)
}

type UserDataPropertyTyped[V any] interface {
	UserDataPropertyBase
	Get(data UserData) V
	Set(data UserData, value V)
}