behavior_tree 0.1.10 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da63d959db3394cf36424a76f36a06d4b30c3ccd97e2f8a0c2dbfabff0b55819
-  data.tar.gz: d433e361299388c9ad10c2c51f20a71a39dc66927939b748486633f3d3cad645
+  metadata.gz: 6eb178547f7b18faf513a60dc91f785a977e5fe7e2884d77ec8f365dd37e55da
+  data.tar.gz: 64e1f312b7028ec33749389e8ee13329c33712d35dc85afc9a0ebe84a5edf8a2
 SHA512:
-  metadata.gz: 4d7bc4c9956c6b9228bff0c87f843543ab933ad1e58a94f47f83421426eebd56cf91d6e15325eef15359716dce0ac56c6fff0aac0b5ba90b18a077d2a02a25f2
-  data.tar.gz: 53b998db96a7976336ecb1fc3e6e0315def2c97485aeedfb40fd3d03abc1ec654b781e32f7bc1df14a413f9a3ca8fceb83ec3241f46dd3b1db73d2ac0d1e8444
+  metadata.gz: 2f553d35fc13a331543cd1df25a169f20c1bbf0cf8fef526b081e5243411087cd7a0f0cdc797e59e78e83cb070a228c98cbf21fe32cd3206162f9dda1ab8b0c2
+  data.tar.gz: 43e2ec00bf7cc6f860dc35852853fbb7e6ae879267ca2848acd7c7c8428c7fefbf6e60ec18f4f79db53cc3bf3623528a413224324cba8f57b1b027397af471c5

data/CODE_OF_CONDUCT.md

@@ -59,7 +59,7 @@ representative at an online or offline event.
 ## Enforcement
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at felovilches@gmail.com.
+reported to the community leaders responsible for enforcement at developer@chrisvilches.com.
 All complaints will be reviewed and investigated promptly and fairly.
 
 All community leaders are obligated to respect the privacy and security of the

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    behavior_tree (0.1.10)
+    behavior_tree (1.1.0)
       colorize (~> 0.8.1)
 
 GEM

data/LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Felo Vilches
+Copyright (c) 2021 Chris Vilches
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -5,7 +5,11 @@
 A robust and customizable Ruby gem for creating Behavior Trees, used in games, AI, robotics, and more.
 
 <p align="center">
-  <img src="https://github.com/FeloVilches/ruby-behavior-tree/blob/main/assets/logo.png?raw=true" />
+  <img src="https://github.com/ChrisVilches/ruby-behavior-tree/blob/main/assets/logo.png?raw=true" />
+</p>
+
+<p align="center">
+  <img src="https://github.com/ChrisVilches/ruby-behavior-tree/blob/main/assets/tree_animation.gif?raw=true" />
 </p>
 
 ## Quick start
@@ -157,8 +161,8 @@ another_tree.print
   * [Custom condition](#custom-condition)
 - [Node API](#node-api)
   * [Status](#status)
-  * [tick!](#tick-)
-  * [halt!](#halt-)
+  * [tick!](#tick)
+  * [halt!](#halt)
   * [Status related callbacks and hooks](#status-related-callbacks-and-hooks)
 - [Add custom nodes to the DSL](#add-custom-nodes-to-the-dsl)
 - [Troubleshoot and debug your trees](#troubleshoot-and-debug-your-trees)
@@ -181,6 +185,8 @@ In simple words, it's a modular way to describe your program's control flow, in
 
 ### Ticking the tree
 
+The tick is the most important part of using a behavior tree. When you tick the root node of a tree, it will propagate it by ticking its children, which in turn will tick their children. Tasks (leaf nodes) are executed when the tick reaches them. Non-leaf nodes would execute their own logic when they are ticked (e.g. decoration logic, executing a sequence, etc).
+
 ```ruby
 my_tree.tick!
 
@@ -191,7 +197,7 @@ my_tree.tick!
 
 Each node has a status, which can have three possible values:
 
-1. `success` which is usually returned by a task when it completes successfully, by conditional nodes when the condition they evaluate is true, or when nodes have never been set to run. Since this is the default status of all nodes, a node is in `success` status if it has never been ticked, or if it has been halted (using `halt!`).
+1. `success` which is returned in certain situations depending on the node type, but usually indicating that the operation they are in charge of was completed. Tasks usually return `success` when they execute/complete successfully, sequences return `success` when the entire sequence is executed successfully, and so on. Since this is the default status of all nodes, a node is in `success` status if it has never been ticked, or if it has been halted (using `halt!`).
 2. `running` which is returned by nodes that are currently executing.
 3. `failure` which is returned to signal that execution failed.
 
@@ -259,11 +265,11 @@ end
 
 #### Control nodes
 
-A control node decides the flow of the execution. In simpler words, it uses a certain logic to decide which branch to execute. This is where most of the similarities with a simple `if-else` come from.
+A control node decides the flow of the execution. In simpler words, it uses a certain logic to decide which branch to execute. It could be one branch, multiple branches, or all of them.
 
 A control node cannot be a leaf (i.e. it must have children).
 
-There are two types of control nodes, and custom ones can be easily created ([see examples of custom control nodes](#custom-control-node)).
+By default, there are two types of control nodes, and custom ones can be easily created. (See: [Examples of custom control nodes](#custom-control-node)).
 
 1. **Sequence:**
   a. Begins executing the first child node.
@@ -277,7 +283,7 @@ There are two types of control nodes, and custom ones can be easily created ([se
   d. If child returns `failure`, then continue with the next child.
   e. If no node ever returned `success`, then return `failure`.
 
-[Learn about "halting nodes" and what it means.](#halt-)
+[Learn about "halting nodes" and what it means.](#halt)
 
 When a control node is ticked, by default it traverses children and ticks them using this logic:
 
@@ -327,7 +333,7 @@ By default the decorator nodes present in this library are:
 | Repeater | `BehaviorTree::Decorators::Repeater` | `repeater` or  `rep` | Ticks the child again N times while it's returning `success`. |
 | Retry | `BehaviorTree::Decorators::Retry` | `re_try` | Ticks the child again N times while it's returning `failure`. |
 
-**Example #1: Creating a tree with many decorators**
+**Example #1: Creating a tree with some decorators**
 
 ```ruby
 my_tree = BehaviorTree::Builder.build do
@@ -523,7 +529,7 @@ class AllOrNothing < ControlNodeBase
 end
 ```
 
-Note that under the hood, `tick_each_children` uses the strategy defined (i.e. `shuffle` method), and traverses its children while also ticking them. You don't need to send `tick!` manually to the child. The code defined in `on_tick` is executed *right after* the child is ticked.
+Note that under the hood, `tick_each_children` uses the strategy defined (i.e. `shuffle` method), and traverses its children while also ticking them. You don't need to send `tick!` manually to the child. The code in the block given to `tick_each_children` is executed *right after* the child is ticked.
 
 ### Custom decorator
 
@@ -560,7 +566,7 @@ class CustomCondition < BehaviorTree::Decorators::Condition
 end
 ```
 
-Or using inline logic in the DSL. When using the DSL, before starting the block (i.e. where the child is defined), you must pass a `lambda` which receives two parameters (both optional), `context` and `node` (the `self` of the condition node).
+Or create condition nodes using inline lambdas in the DSL. When using the DSL, before starting the block (i.e. where the child is defined), you must pass a `lambda` which receives two parameters (both optional), `context` and `node` (which is the `self` of the condition node).
 
 ```ruby
 my_tree = BehaviorTree::Builder.build do
@@ -583,7 +589,7 @@ my_tree.print
 #       └─task success (0 ticks)
 ```
 
-**Note:** Other behavior tree implementations prefer the use of `sequence` control nodes, and placing conditional nodes as a leaves, but with the role of simply returning `failure` or `success`. Since sequences execute the next node only if the previous one succeeded, this also works as a conditional node. In this implementation, however, both patterns are available and you are free to choose which one to use.
+**Note:** Other behavior tree implementations prefer the use of `sequence` control nodes, and placing conditional nodes as leaves, but with the role of simply returning `failure` or `success`. Since sequences execute the next node only if the previous one succeeded, it would also behave like a conditional node, preventing the next nodes in the sequence from executing if the condition failed. In this implementation, however, both patterns are available and you are free to choose which one to use.
 
 ## Node API
 
@@ -698,12 +704,16 @@ The second line of the output is the `puts` of the actual task logic. The third
 
 **on_started_running**
 
-Similar to `on_status_change`, but only triggers when the node has been set to `running`.
+Similar to `on_status_change`, but only triggers when the node has been set to `running` (changed from a status other than `running`.
+
+In some implementations, this is called `initialization`.
 
 **on_finished_running**
 
 Similar to `on_status_change`, but only triggers when the node has been set to a status other than `running`.
 
+In some implementations, this is called `shutdown`.
+
 ## Add custom nodes to the DSL
 
 You can register new nodes to be used in the DSL, take for example the following code:
@@ -790,7 +800,7 @@ my_tree.print
 The above code generates the following output:
 
 <p align="center">
-  <img src="https://github.com/FeloVilches/ruby-behavior-tree/blob/main/assets/printed_tree.jpg?raw=true" width="400"/>
+  <img src="https://github.com/ChrisVilches/ruby-behavior-tree/blob/main/assets/printed_tree.jpg?raw=true" width="400"/>
 </p>
 
 In the example above, you can see that the bottom nodes haven't been ticked at all. Node starvation might occur for various reasons, such as having a `force_failure` node as one of the children of a `sequence` (the nodes after the `force_failure` would all be prevented from executing).
@@ -830,7 +840,7 @@ Keep in mind this is only for development purposes, and the generated trees don'
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/FeloVilches/ruby-behavior-tree. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/FeloVilches/ruby-behavior-tree/blob/main/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/ChrisVilches/ruby-behavior-tree. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/ChrisVilches/ruby-behavior-tree/blob/main/CODE_OF_CONDUCT.md).
 
 
 ## License
@@ -839,4 +849,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Behavior Tree project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/FeloVilches/ruby-behavior-tree/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the Behavior Tree project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/ChrisVilches/ruby-behavior-tree/blob/main/CODE_OF_CONDUCT.md).

data/lib/behavior_tree/concerns/node_iterators/prioritize_running.rb

@@ -5,15 +5,21 @@ module BehaviorTree
     # If there's at least one node with 'running' status, then iterate starting from there, in order.
     # Else, iterate all nodes.
     module PrioritizeRunning
+      private
+
       def prioritize_running
-        idx = @children.find_index { |child| child.status.running? }.to_i
+        @first_running_idx = children.find_index { |child| child.status.running? }.to_i if must_recompute_idx?
 
         Enumerator.new do |y|
-          @children[idx..].each do |child|
+          children[@first_running_idx..].each do |child|
             y << child
           end
         end
       end
+
+      def must_recompute_idx?
+        !@first_running_idx || !children[@first_running_idx].status.running?
+      end
     end
   end
 end

data/lib/behavior_tree/concerns/tree_structure/printer.rb

@@ -7,6 +7,10 @@ module BehaviorTree
     # Algorithm to print tree.
     module Printer
       def print
+        puts to_s
+      end
+
+      def to_s
         lines = []
         lines << '∅' # Style for the root node.
         lines += tree_lines
@@ -15,8 +19,7 @@ module BehaviorTree
         lines << uniq_nodes_string
         lines << size_string
         lines << tree_tick_count_string
-
-        puts lines.join "\n"
+        lines.join "\n"
       end
 
       private
@@ -34,7 +37,7 @@ module BehaviorTree
           space = (0...depth).map { |d| vertical_lines_continues.include?(d) ? '│     ' : '      ' }.join
           connector = last_child ? '└─' : '├─'
 
-          "#{space}#{connector}#{class_simple_name(node)} #{status_string(node)} #{tick_count_string(node)}"
+          "#{space}#{connector}#{resolve_display_name(node)} #{status_string(node)} #{tick_count_string(node)}"
         end
       end
 
@@ -83,22 +86,11 @@ module BehaviorTree
            .downcase
       end
 
-      def class_simple_name(node)
-        pretty_name snake_case(node.class.name.split('::').last)
-      end
-
-      # Changes the name of some classes (maps it to a better name).
-      # Mapping is simply based on taste.
-      def pretty_name(name)
-        case name
-        when 'task_base'
-          'task'
-        when 'force_success'
-          'forcesuccess'
-        when 'force_failure'
-          'forcefailure'
+      def resolve_display_name(node)
+        if node.respond_to?(:display_name)
+          node.display_name
         else
-          name
+          snake_case(node.class.name.split('::').last)
         end
       end
     end

data/lib/behavior_tree/decorator_nodes/force_failure.rb

@@ -4,6 +4,10 @@ module BehaviorTree
   module Decorators
     # Returns always failure when the child is not running.
     class ForceFailure < DecoratorBase
+      def display_name
+        'forcefailure'
+      end
+
       protected
 
       def status_map

data/lib/behavior_tree/decorator_nodes/force_success.rb

@@ -4,6 +4,10 @@ module BehaviorTree
   module Decorators
     # Returns always success when the child is not running.
     class ForceSuccess < DecoratorBase
+      def display_name
+        'forcesuccess'
+      end
+
       protected
 
       def status_map

data/lib/behavior_tree/tasks/task_base.rb

@@ -25,6 +25,10 @@ module BehaviorTree
       end
     end
 
+    def display_name
+      'task'
+    end
+
     private
 
     attr_reader :context

data/lib/behavior_tree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BehaviorTree
-  VERSION = '0.1.10'
+  VERSION = '1.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: behavior_tree
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 1.1.0
 platform: ruby
 authors:
 - Felo Vilches
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-07-16 00:00:00.000000000 Z
+date: 2023-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -24,7 +24,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.1
-description:
+description: 
 email:
 - felovilches@gmail.com
 executables: []
@@ -82,7 +82,7 @@ homepage: https://github.com/FeloVilches/Ruby-Behavior-Tree
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -97,8 +97,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key:
+rubygems_version: 3.3.7
+signing_key: 
 specification_version: 4
 summary: A robust and customizable Ruby gem for creating Behavior Trees.
 test_files: []