Reset decorators correctly (#392)

Reset decorators correctly (cooldown, delayer)

Author: bitbrain

addons/beehave/nodes/decorators/cooldown.gd

@@ -6,6 +6,7 @@ class_name CooldownDecorator
 ## The Cooldown Decorator will return 'FAILURE' for a set amount of time
 ## after executing its child.
 ## The timer resets the next time its child is executed and it is not `RUNNING`
+## or when the node is interrupted (such as when the behavior tree changes branches).
 
 ## The wait time in seconds
 @export var wait_time := 0.0
@@ -48,3 +49,9 @@ func tick(actor: Node, blackboard: Blackboard) -> int:
 			blackboard.set_value(cache_key, wait_time, str(actor.get_instance_id()))
 
 	return response
+
+func interrupt(actor: Node, blackboard: Blackboard) -> void:
+	# Reset the cooldown when the branch changes
+	blackboard.set_value(cache_key, 0.0, str(actor.get_instance_id()))
+		
+	super(actor, blackboard)

addons/beehave/nodes/decorators/delayer.gd

@@ -6,6 +6,7 @@ class_name DelayDecorator
 ## The Delay Decorator will return 'RUNNING' for a set amount of time
 ## before executing its child.
 ## The timer resets when both it and its child are not `RUNNING`
+## or when the node is interrupted (such as when the behavior tree changes branches).
 
 ## The wait time in seconds
 @export var wait_time := 0.0
@@ -48,3 +49,9 @@ func tick(actor: Node, blackboard: Blackboard) -> int:
 			blackboard.set_value(cache_key, 0.0, str(actor.get_instance_id()))
 
 	return response
+
+func interrupt(actor: Node, blackboard: Blackboard) -> void:
+	# Reset the delay timer when the branch changes
+	blackboard.set_value(cache_key, 0.0, str(actor.get_instance_id()))
+	
+	super(actor, blackboard)

addons/beehave/nodes/decorators/limiter.gd

@@ -5,6 +5,7 @@ class_name LimiterDecorator extends Decorator
 ## The limiter will execute its `RUNNING` child `x` amount of times. When the number of
 ## maximum ticks is reached, it will return a `FAILURE` status code.
 ## The count resets the next time that a child is not `RUNNING`
+## or when the node is interrupted (such as when the behavior tree changes branches).
 
 @onready var cache_key = "limiter_%s" % self.get_instance_id()
 
@@ -28,11 +29,13 @@ func tick(actor: Node, blackboard: Blackboard) -> int:
 			blackboard.set_value("last_condition", child, str(actor.get_instance_id()))
 			blackboard.set_value("last_condition_status", response, str(actor.get_instance_id()))
 
-		if child is ActionLeaf and response == RUNNING:
+		if response == RUNNING:
 			running_child = child
-			blackboard.set_value("running_action", child, str(actor.get_instance_id()))
-
-		if response != RUNNING:
+			if child is ActionLeaf:
+				blackboard.set_value("running_action", child, str(actor.get_instance_id()))
+		else:
+			# If the child is no longer running, reset the counter for next time
+			_reset_counter(actor, blackboard)
 			child.after_run(actor, blackboard)
 
 		return response
@@ -43,11 +46,25 @@ func tick(actor: Node, blackboard: Blackboard) -> int:
 
 
 func before_run(actor: Node, blackboard: Blackboard) -> void:
-	blackboard.set_value(cache_key, 0, str(actor.get_instance_id()))
+	# Initialize the counter to 0 when we first start running
+	_reset_counter(actor, blackboard)
 	if get_child_count() > 0:
 		get_child(0).before_run(actor, blackboard)
 
 
+func interrupt(actor: Node, blackboard: Blackboard) -> void:
+	# The tree is changing branches, so the count should reset
+	_reset_counter(actor, blackboard)
+	
+	# Call super, which may affect our blackboard values
+	super(actor, blackboard)
+
+
+# Resets the counter in the blackboard
+func _reset_counter(actor: Node, blackboard: Blackboard) -> void:
+	blackboard.set_value(cache_key, 0, str(actor.get_instance_id()))
+
+
 func get_class_name() -> Array[StringName]:
 	var classes := super()
 	classes.push_back(&"LimiterDecorator")

addons/beehave/nodes/decorators/repeater.gd

@@ -1,6 +1,7 @@
 ## The repeater will execute its child until it returns `SUCCESS` a certain amount of times.
 ## When the number of maximum ticks is reached, it will return a `SUCCESS` status code.
 ## If the child returns `FAILURE`, the repeater will return `FAILURE` immediately.
+## The counter resets when the node is interrupted (such as when the behavior tree changes branches).
 @tool
 @icon("../../icons/repeater.svg")
 class_name RepeaterDecorator extends Decorator
@@ -52,6 +53,13 @@ func tick(actor: Node, blackboard: Blackboard) -> int:
 		return SUCCESS
 
 
+func interrupt(actor: Node, blackboard: Blackboard) -> void:
+	# Reset the internal counter when the node is interrupted
+	current_count = 0
+		
+	super(actor, blackboard)
+
+
 func get_class_name() -> Array[StringName]:
 	var classes := super()
 	classes.push_back(&"LimiterDecorator")

addons/beehave/nodes/decorators/time_limiter.gd

@@ -5,6 +5,7 @@ class_name TimeLimiterDecorator extends Decorator
 ## The Time Limit Decorator will give its `RUNNING` child a set amount of time to finish
 ## before interrupting it and return a `FAILURE` status code.
 ## The timer resets the next time that a child is not `RUNNING`
+## or when the node is interrupted (such as when the behavior tree changes branches).
 
 @export var wait_time := 0.0
 
@@ -48,6 +49,13 @@ func before_run(actor: Node, blackboard: Blackboard) -> void:
 		get_child(0).before_run(actor, blackboard)
 
 
+func interrupt(actor: Node, blackboard: Blackboard) -> void:
+	# Reset the timer when the node is interrupted
+	blackboard.set_value(cache_key, 0.0, str(actor.get_instance_id()))
+		
+	super(actor, blackboard)
+
+
 func get_class_name() -> Array[StringName]:
 	var classes := super()
 	classes.push_back(&"TimeLimiterDecorator")

test/composites/mock_composite.gd

@@ -9,4 +9,4 @@ func interrupt(actor: Node, blackboard: Blackboard) -> void:
 	interrupted.emit(actor, blackboard)
 
 func tick(_actor: Node, _blackboard: Blackboard) -> int:
-	return final_result
+	return final_result

test/composites/mock_composite.gd.uid

@@ -0,0 +1 @@
+uid://ddeb0yatovjv

test/nodes/decorators/cooldown_test.gd

@@ -129,4 +129,20 @@ func test_after_run_not_called_during_cooldown() -> void:
 	# Wait a bit but not enough to complete cooldown
 	await runner.simulate_frames(1, 500)
 	assert_that(tree.tick()).is_equal(BeehaveNode.FAILURE)
-	assert_bool(action.after_run_called).is_false()  # Should not call after_run during cooldown
+	assert_bool(action.after_run_called).is_false()  # Should not call after_run during cooldown
+
+func test_cooldown_reset_on_interrupt() -> void:
+	cooldown.wait_time = 1.0
+	action.final_result = BeehaveNode.SUCCESS
+	
+	# First tick should execute child and start cooldown
+	assert_that(tree.tick()).is_equal(BeehaveNode.SUCCESS)
+	
+	# Second tick should be in cooldown
+	assert_that(tree.tick()).is_equal(BeehaveNode.FAILURE)
+	
+	# Interrupt should reset the cooldown
+	tree.interrupt()
+	
+	# After interrupt, the cooldown should be reset and the action should execute normally
+	assert_that(tree.tick()).is_equal(BeehaveNode.SUCCESS)

test/nodes/decorators/delayer_test.gd

@@ -94,3 +94,36 @@ func test_after_run_not_called_during_delay() -> void:
 	await runner.simulate_frames(1, 500)
 	assert_that(tree.tick()).is_equal(BeehaveNode.RUNNING)
 	assert_bool(action.after_run_called).is_false()
+
+func test_delay_reset_on_interrupt() -> void:
+	delayer.wait_time = 1.0
+	action.final_result = BeehaveNode.SUCCESS
+	
+	# First tick should start the delay
+	assert_that(tree.tick()).is_equal(BeehaveNode.RUNNING)
+	
+	# Simulate partial progress through the delay
+	await runner.simulate_frames(1, 500)
+	assert_that(tree.tick()).is_equal(BeehaveNode.RUNNING)
+	
+	# Interrupt should reset the delay
+	tree.interrupt()
+	
+	# Verify the blackboard value is reset
+	var cache_key = "time_limiter_%s" % delayer.get_instance_id()
+	var blackboard_value = tree.blackboard.get_value(cache_key, -1, str(tree.actor.get_instance_id()))
+	assert_that(blackboard_value).is_equal(0.0) # This should pass if our reset works
+	
+	# First tick after interrupt should start a new delay from the beginning
+	assert_that(tree.tick()).is_equal(BeehaveNode.RUNNING)
+	
+	# Set running_child to null to force a reinitialize on next tick
+	# This simulates what would happen in a real tree when switching branches
+	delayer.running_child = null
+	
+	# Manually "complete" the delay by setting it past the wait time
+	cache_key = "time_limiter_%s" % delayer.get_instance_id()
+	tree.blackboard.set_value(cache_key, 1.1, str(tree.actor.get_instance_id()))  # Set it past wait_time
+	
+	# Now when we tick, it should execute the child and return SUCCESS
+	assert_that(tree.tick()).is_equal(BeehaveNode.SUCCESS)

test/nodes/decorators/limiter_test.gd

@@ -62,3 +62,26 @@ func test_clear_running_child_after_run() -> void:
 	tree.tick()
 	assert_that(action.count).is_equal(2)
 	assert_that(limiter.running_child).is_equal(null)
+
+func test_counter_reset_on_interrupt() -> void:
+	limiter.max_count = 3
+	action.status = BeehaveNode.RUNNING
+	
+	# Tick once to advance the counter
+	var tree_status = tree.tick()
+	# Verify counter was advanced
+	assert_that(tree_status).is_equal(BeehaveNode.RUNNING)
+	assert_that(action.count).is_equal(1)
+	
+	# Interrupt should reset the counter
+	tree.interrupt()
+	
+	# Verify the counter was reset by checking if we can tick again
+	# If counter was reset, we should be able to tick max_count times again
+	action.status = BeehaveNode.RUNNING
+	for i in range(limiter.max_count):
+		var status = tree.tick()
+		assert_that(status).is_equal(BeehaveNode.RUNNING)
+	
+	# After max_count ticks, it should now fail (proving counter started from 0)
+	assert_that(tree.tick()).is_equal(BeehaveNode.FAILURE)