Add a new node type DataLeaf

[tavurth]

Is your feature request related to a problem? Please describe.

I have the following:

However I would much prefer:

BeeHaveTree
└── GoToOwnRoomAction
    └── SequenceStarComposite
        ├── HasOwnership
        │   └── DataLeaf (OwnBedroom)
        └── GoTo
            └── DataLeaf (OwnBedroom)

Describe the solution you'd like
I want the character to GoTo some place, but I don't want to have to specify that place in code every time.
I want to describe a list of places:

OwnBedroom
OwnLivingRoom
OwnBathroom

And then apply these as a child of the GoTo action to modify it's behaviour.

DataLeaf.gd

@tool
@icon("res://addons/beehave/icons/action.svg")
class_name DataLeaf
extends Node2D

func get_value(_actor, _blackboard: Blackboard) -> Variant:
	var path = str(get_script().get_path())
	push_warning("%s has no getter, please override this" % path)

	return null

OwnRoom.gd

class_name OwnBedroom
extends DataLeaf

func get_value(actor, _blackboard: Blackboard) -> Variant:
	return Ownership.find_first_of_type(actor, "bedroom")

Which has allowed me to simplify my logic as follows:

has_own.gd

extends ConditionLeaf

@onready var target_node: DataLeaf = get_child(0)


func tick(actor: Node, blackboard: Blackboard) -> int:
	var has_ownership = target_node.get_value(actor, blackboard)

	if has_ownership:
		return SUCCESS

	return FAILURE

own_bedroom.gd

class_name OwnBedroom
extends DataLeaf


func get_value(actor, _blackboard: Blackboard) -> Variant:
	return Ownership.find_first_of_type(actor, "bedroom")

go_to.gd

class_name GoTo
extends ActionLeaf

@onready var target_node: DataLeaf = get_child(0)


func tick(actor: Node, blackboard: Blackboard) -> int:
	var move_target = target_node.get_value(actor, blackboard)

	if move_target == null:
		return FAILURE

	if not actor.has_target():
		actor.move_to(move_target.get_global_position())

	if not actor.navigation.is_navigation_finished():
		return RUNNING

	return SUCCESS


func interrupt(actor: Node, _blackboard: Blackboard) -> void:
	actor.stop()

Another example use case for the DataLeaf, stateless:

AvailableWorkstation.gd

class_name AvailableWorkstation
extends DataLeaf


func sort_by_distance(a: Node, b: Node, actor: CharacterBody2D) -> bool:
	return (\
		actor.position.distance_squared_to(a.position)\
		<\
		actor.position.distance_squared_to(b.position)\
	)


func is_available(workstation: Node, actor: CharacterBody2D) -> bool:
	return workstation.is_available(actor)


func get_value(actor: CharacterBody2D, _blackboard: Blackboard) -> Variant:
	var workstations = get_tree()\
		.get_nodes_in_group("workstation")\
		.filter(is_available.bind(actor))
	
	workstations\
		.sort_custom(sort_by_distance.bind(actor))

	if not len(workstations):
		return null

	return workstations[0]

SetUsed.gd

@tool
class_name SetUsed
extends DataActionLeaf


func tick(actor: Node, blackboard: Blackboard) -> int:
	var target = target_node.get_value(actor, blackboard)
	if not target:
		return FAILURE

	target.set_used_by(actor)
	return SUCCESS

Would be nice to see the DataLeaf on the flow chart, perhaps I will implement that in future.

[tavurth]

Forked from, since apparently this is not a currently accepted addition:

#184

[tavurth]

class_name SomewhereNearby
extends DataLeaf


func get_main_map() -> Variant:
	var maps = NavigationServer2D.get_maps()
	if not len(maps):
		push_error("Could not find main navigation map")
		return null

	return maps[0]


func get_value(_actor: CharacterBody2D, _blackboard: Blackboard) -> Variant:
	var map = get_main_map()
	if map == null:
		return null

	var random_position = Vector2(
		randi_range(-10, 10),
		randi_range(-10, 10),
	)

	return NavigationServer2D.map_get_closest_point(map, random_position)

[tavurth]

I did find some problems with this approach, in general if the function to collect a possible data item is slow, then it's still better to memoize the value in the Blackboard as follows:

available_workstation.gd

class_name AvailableWorkstation
extends DataLeaf


func is_available(workstation: Node, actor: CharacterBody2D) -> bool:
	return workstation.is_available(actor)


func available_workstations(actor: CharacterBody2D) -> Array[Node]:
	return get_tree()\
		.get_nodes_in_group("workstation")\
		.filter(is_available.bind(actor))


func setup(actor: Node, _blackboard: Blackboard) -> Variant:
	return ArrayUtils.random_closest_n(
		actor, 5, available_workstations(actor)
	)

set_target.gd

@tool
class_name SetTarget
extends DataActionLeaf


func tick(actor: Node, blackboard: Blackboard) -> int:
	super.tick(actor, blackboard)

	var target = target_node.get_value()
	if not target:
		return FAILURE

	blackboard.set_for_actor(actor, "target", target)

	return SUCCESS

set_used_memo.gd

@tool
class_name SetUsedMemo
extends ActionLeaf


func tick(actor: Node, blackboard: Blackboard) -> int:
	super.tick(actor, blackboard)

	var target = blackboard.get_for_actor(actor, "target", null)
	if not target:
		return FAILURE

	target.set_used(actor)

	return SUCCESS

setup is called on before_run in the DataActionLeaf or the DataConditionalLeaf

DataLeaf then memoizes this value.