node

package
v0.0.0-...-dcab76a Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Feb 9, 2020 License: MIT, MIT Imports: 4 Imported by: 1

Documentation

Index

Constants

View Source
const (
	StateTransition = -1
	StateExecuting  = iota
	StateFinish
)

* BevRunningStatus

View Source
const (
	NodeReady
	NodeRunning
	NodeFinish
)

* TerminalNodeStaus

View Source
const (
	ConstInfiniteLoop          int = -1
	ConstMaxChildNodeCnt       int = 16
	ConstInvalidChildNodeIndex int = 16
)

* Other const variables

Variables

This section is empty.

Functions

func PrintbevTree

func PrintbevTree(root IBevNode, blk int)

Types

type BevNode

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

* BevNode

func NewBevNode

func NewBevNode(parentNode IBevNode, nodePrecondition p.IPrecondition) *BevNode

func (*BevNode) AddChildNode

func (node *BevNode) AddChildNode(childNode IBevNode) *BevNode

func (*BevNode) Evaluate

func (node *BevNode) Evaluate(input interface{}) bool

func (*BevNode) GetDebugName

func (node *BevNode) GetDebugName() string

func (*BevNode) GetLastActiveNode

func (node *BevNode) GetLastActiveNode() IBevNode

func (*BevNode) GetNodePrecondition

func (node *BevNode) GetNodePrecondition() p.IPrecondition

func (*BevNode) PrintChild

func (root *BevNode) PrintChild(blk int, dofun ChildrenJobFunc)

func (*BevNode) Reconstruct

func (node *BevNode) Reconstruct(parentNode IBevNode)

func (*BevNode) SetActiveNode

func (node *BevNode) SetActiveNode(activeNode IBevNode)

func (*BevNode) SetDebugName

func (node *BevNode) SetDebugName(debugName string) *BevNode

func (*BevNode) SetNodePrecondition

func (node *BevNode) SetNodePrecondition(nodePrecondition p.IPrecondition) *BevNode

func (*BevNode) Tick

func (node *BevNode) Tick(input interface{}, output interface{}) BevRunningStatus

func (*BevNode) Transition

func (node *BevNode) Transition(input interface{})

type BevReverse

type BevReverse struct {
	IBevNode
}

* Wrapper used to reverse the evaluate result of node

func NewReverse

func NewReverse(node IBevNode) *BevReverse

func (*BevReverse) Evaluate

func (w *BevReverse) Evaluate(input interface{}) bool

type BevRunningStatus

type BevRunningStatus int

type BevSelector

type BevSelector struct {
	IBevSelector
}

func NewSelector

func NewSelector(node IBevSelector) *BevSelector

func (*BevSelector) Evaluate

func (w *BevSelector) Evaluate(input interface{}) bool

type BevTerminal

type BevTerminal struct {
	IBevTerminal
	// contains filtered or unexported fields
}

func NewTerminal

func NewTerminal(node IBevTerminal) *BevTerminal

func (*BevTerminal) Evaluate

func (w *BevTerminal) Evaluate(input interface{}) bool

func (*BevTerminal) Tick

func (node *BevTerminal) Tick(input interface{}, output interface{}) BevRunningStatus

func (*BevTerminal) Transition

func (node *BevTerminal) Transition(input interface{})

type ChildrenJobFunc

type ChildrenJobFunc func(v IBevNode, blk int)

type IBevNode

type IBevNode interface {
	AddChildNode(childNode IBevNode) *BevNode
	GetNodePrecondition() p.IPrecondition
	SetNodePrecondition(nodePrecondition p.IPrecondition) *BevNode
	GetDebugName() string
	SetDebugName(debugName string) *BevNode
	GetLastActiveNode() IBevNode
	SetActiveNode(activeNode IBevNode)
	Evaluate(input interface{}) bool
	Transition(input interface{})
	Tick(input interface{}, output interface{}) BevRunningStatus
	Reconstruct(parentNode IBevNode)
	PrintChild(blk int, callback ChildrenJobFunc)
}

*

type IBevSelector

type IBevSelector interface {
	IBevNode
}

* Wrapper for Selector * https://groups.google.com/d/msg/golang-nuts/BKztgPqN87M/iUfZQIcNYfYJ

type IBevTerminal

type IBevTerminal interface {
	IBevNode
	Enter(input interface{})
	Execute(input interface{}, output interface{}) BevRunningStatus
	Exit(input interface{}, exitStatus BevRunningStatus)
}

* Wrapper for Terminal

type LoopSelector

type LoopSelector struct {
	*BevNode
	// contains filtered or unexported fields
}

*

func NewLoopSelector

func NewLoopSelector(parentNode IBevNode, nodePrecondition p.IPrecondition, totalLoopCount int) *LoopSelector

func (*LoopSelector) Evaluate

func (node *LoopSelector) Evaluate(input interface{}) bool

func (*LoopSelector) Tick

func (node *LoopSelector) Tick(input interface{}, output interface{}) BevRunningStatus

func (*LoopSelector) Transition

func (node *LoopSelector) Transition(input interface{})

type NonePrioritySelector

type NonePrioritySelector struct {
	*PrioritySelector
}

*

func NewNonePrioritySelector

func NewNonePrioritySelector(parentNode IBevNode, nodePrecondition p.IPrecondition) *NonePrioritySelector

func (*NonePrioritySelector) Evaluate

func (node *NonePrioritySelector) Evaluate(input interface{}) bool

type ParallelSelector

type ParallelSelector struct {
	*BevNode
}

*

func NewParallelSelector

func NewParallelSelector(parentNode IBevNode, nodePrecondition p.IPrecondition) *ParallelSelector

func (*ParallelSelector) Evaluate

func (node *ParallelSelector) Evaluate(input interface{}) bool

func (*ParallelSelector) Tick

func (node *ParallelSelector) Tick(input interface{}, output interface{}) BevRunningStatus

func (*ParallelSelector) Transition

func (node *ParallelSelector) Transition(input interface{})

type PrioritySelector

type PrioritySelector struct {
	*BevNode
	// contains filtered or unexported fields
}

*

func NewPrioritySelector

func NewPrioritySelector(parentNode IBevNode, nodePrecondition p.IPrecondition) *PrioritySelector

func (*PrioritySelector) Evaluate

func (node *PrioritySelector) Evaluate(input interface{}) bool

func (*PrioritySelector) Tick

func (node *PrioritySelector) Tick(input interface{}, output interface{}) BevRunningStatus

func (*PrioritySelector) Transition

func (node *PrioritySelector) Transition(input interface{})

type RandomSelector

type RandomSelector struct {
	*PrioritySelector
}

*

func NewRandomSelector

func NewRandomSelector(parentNode IBevNode, nodePrecondition p.IPrecondition) *RandomSelector

func (*RandomSelector) Evaluate

func (node *RandomSelector) Evaluate(input interface{}) bool

type SequenceSelector

type SequenceSelector struct {
	*BevNode
	// contains filtered or unexported fields
}

*

func NewSequenceSelector

func NewSequenceSelector(parentNode IBevNode, nodePrecondition p.IPrecondition) *SequenceSelector

func (*SequenceSelector) Evaluate

func (node *SequenceSelector) Evaluate(input interface{}) bool

func (*SequenceSelector) Tick

func (node *SequenceSelector) Tick(input interface{}, output interface{}) BevRunningStatus

func (*SequenceSelector) Transition

func (node *SequenceSelector) Transition(input interface{})

type TerminalNode

type TerminalNode struct {
	*BevNode
}

*

func NewTerminalNode

func NewTerminalNode(parentNode IBevNode, nodePrecondition p.IPrecondition) *TerminalNode

func (*TerminalNode) Enter

func (node *TerminalNode) Enter(input interface{})

func (*TerminalNode) Execute

func (node *TerminalNode) Execute(input interface{}, output interface{}) BevRunningStatus

func (*TerminalNode) Exit

func (node *TerminalNode) Exit(input interface{}, exitStatus BevRunningStatus)

type TerminalNodeStaus

type TerminalNodeStaus int

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL