TouhouGD/addons/beehave/nodes/beehave_tree.gd

## Controls the flow of execution of the entire behavior tree.
@tool
@icon("../icons/tree.svg")
class_name BeehaveTree extends Node

enum {
    SUCCESS,
    FAILURE,
    RUNNING
}

signal tree_enabled
signal tree_disabled

## Wether this behavior tree should be enabled or not.
@export var enabled: bool = true:
    set(value):
        enabled = value
        set_physics_process(enabled)

        if value:
            tree_enabled.emit()
        else:
            interrupt()
            tree_disabled.emit()

    get:
        return enabled

## An optional node path this behavior tree should apply to.
@export_node_path var actor_node_path : NodePath

## Custom blackboard node. An internal blackboard will be used
## if no blackboard is provided explicitly.
@export var blackboard:Blackboard:
    set(b):
        blackboard = b
        if blackboard and _internal_blackboard:
            remove_child(_internal_blackboard)
            _internal_blackboard.free()
            _internal_blackboard = null
        elif not blackboard and not _internal_blackboard:
            _internal_blackboard = Blackboard.new()
            add_child(_internal_blackboard, false, Node.INTERNAL_MODE_BACK)
    get:
        return blackboard if blackboard else _internal_blackboard

## When enabled, this tree is tracked individually
## as a custom monitor.
@export var custom_monitor = false:
    set(b):
        custom_monitor = b
        if custom_monitor and _process_time_metric_name != '':
            Performance.add_custom_monitor(_process_time_metric_name, _get_process_time_metric_value)
            BeehaveGlobalMetrics.register_tree(self)
        else:
            if _process_time_metric_name != '':
                # Remove tree metric from the engine
                Performance.remove_custom_monitor(_process_time_metric_name)
                BeehaveGlobalMetrics.unregister_tree(self)

            BeehaveDebuggerMessages.unregister_tree(get_instance_id())

var actor : Node
var status : int = -1

var _internal_blackboard: Blackboard
var _process_time_metric_name : String
var _process_time_metric_value : float = 0.0
var _can_send_message: bool = false

func _ready() -> void:
    if Engine.is_editor_hint():
        return

    if self.get_child_count() > 0 and not self.get_child(0) is BeehaveNode:
        push_warning("Beehave error: Root %s should have only one child of type BeehaveNode (NodePath: %s)" % [self.name, self.get_path()])
        disable()
        return

    if not blackboard:
        _internal_blackboard = Blackboard.new()
        add_child(_internal_blackboard, false, Node.INTERNAL_MODE_BACK)

    actor = get_parent()
    if actor_node_path:
        actor = get_node(actor_node_path)

    # Get the name of the parent node name for metric
    var parent_name = actor.name
    _process_time_metric_name = "beehave [microseconds]/process_time_%s-%s" % [parent_name, get_instance_id()]

    # Register custom metric to the engine
    if custom_monitor:
        Performance.add_custom_monitor(_process_time_metric_name, _get_process_time_metric_value)
        BeehaveGlobalMetrics.register_tree(self)

    set_physics_process(enabled)
    BeehaveGlobalDebugger.register_tree(self)
    BeehaveDebuggerMessages.register_tree(_get_debugger_data(self))


func _physics_process(delta: float) -> void:
    if Engine.is_editor_hint():
        return

    # Start timing for metric
    var start_time = Time.get_ticks_usec()

    blackboard.set_value("can_send_message", _can_send_message)

    if _can_send_message:
        BeehaveDebuggerMessages.process_begin(get_instance_id())

    if self.get_child_count() == 1:
        tick()

    if _can_send_message:
        BeehaveDebuggerMessages.process_end(get_instance_id())

    # Check the cost for this frame and save it for metric report
    _process_time_metric_value = Time.get_ticks_usec() - start_time


func tick() -> int:
    var child := self.get_child(0)
    if status != RUNNING:
        child.before_run(actor, blackboard)

    status = child.tick(actor, blackboard)
    if _can_send_message:
        BeehaveDebuggerMessages.process_tick(child.get_instance_id(), status)
        BeehaveDebuggerMessages.process_tick(get_instance_id(), status)

    # Clear running action if nothing is running
    if status != RUNNING:
        blackboard.set_value("running_action", null, str(actor.get_instance_id()))
        child.after_run(actor, blackboard)

    return status


func _get_configuration_warnings() -> PackedStringArray:
    var warnings:PackedStringArray = []

    if get_children().any(func(x): return not (x is BeehaveNode)):
        warnings.append("All children of this node should inherit from BeehaveNode class.")

    if get_child_count() != 1:
        warnings.append("BeehaveTree should have exactly one child node.")

    return warnings


## Returns the currently running action
func get_running_action() -> ActionLeaf:
    return blackboard.get_value("running_action", null, str(actor.get_instance_id()))


## Returns the last condition that was executed
func get_last_condition() -> ConditionLeaf:
    return blackboard.get_value("last_condition", null, str(actor.get_instance_id()))


## Returns the status of the last executed condition
func get_last_condition_status() -> String:
    if blackboard.has_value("last_condition_status", str(actor.get_instance_id())):
        var status = blackboard.get_value("last_condition_status", null, str(actor.get_instance_id()))
        if status == SUCCESS:
            return "SUCCESS"
        elif status == FAILURE:
            return "FAILURE"
        else:
            return "RUNNING"
    return ""

## interrupts this tree if anything was running
func interrupt() -> void:
    if self.get_child_count() != 0:
        var first_child = self.get_child(0)
        if "interrupt" in first_child:
            first_child.interrupt(actor, blackboard)


## Enables this tree.
func enable() -> void:
    self.enabled = true


## Disables this tree.
func disable() -> void:
    self.enabled = false


func _exit_tree() -> void:
    if custom_monitor:
        if _process_time_metric_name != '':
            # Remove tree metric from the engine
            Performance.remove_custom_monitor(_process_time_metric_name)
            BeehaveGlobalMetrics.unregister_tree(self)

        BeehaveDebuggerMessages.unregister_tree(get_instance_id())


# Called by the engine to profile this tree
func _get_process_time_metric_value() -> int:
    return _process_time_metric_value


func _get_debugger_data(node: Node) -> Dictionary:
    if not node is BeehaveTree and not node is BeehaveNode:
        return {}
    var data := { path = node.get_path(), name = node.name, type = node.get_class_name(), id = str(node.get_instance_id()) }
    if node.get_child_count() > 0:
        data.children = []
    for child in node.get_children():
        var child_data := _get_debugger_data(child)
        if not child_data.is_empty():
            data.children.push_back(child_data)
    return data


func get_class_name() -> Array[StringName]:
    return [&"BeehaveTree"]