behavior_tree 0.1.7 → 1.0.0

data/Rakefile

@@ -3,6 +3,9 @@
 require 'rubocop/rake_task'
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
+require 'bundler/setup'
+require 'behavior_tree'
+require 'io/console'
 
 RSpec::Core::RakeTask.new(:spec)
 
@@ -12,3 +15,77 @@ desc 'Run RuboCop'
 RuboCop::RakeTask.new(:lint) do |task|
   task.options = ['--fail-level', 'autocorrect']
 end
+
+desc 'Run RuboCop for specs'
+RuboCop::RakeTask.new(:spec_lint) do |task|
+  task.requires << 'rubocop-rspec'
+end
+
+# Utils for the visualize Rake task.
+# NOTE: Don't use it for anything other than the Rake task.
+class VisualizeUtils
+  class << self
+    def random_seed
+      @random_seed ||= if ENV['random_seed'].nil?
+                         (Time.now.to_f * 1000).to_i ^ Process.pid
+                       else
+                         ENV['random_seed'].to_i
+                       end
+    end
+
+    def sleep_time
+      result = ENV['sleep'].nil? ? 0.5 : ENV['sleep'].to_f
+      raise 'Sleep time must be a positive float value' if result <= 0
+
+      result
+    end
+
+    def print_random_seed_info
+      puts ''
+      puts "Generate the same tree by adding: random_seed=#{random_seed}"
+    end
+
+    def random_tree
+      @random_tree ||= BehaviorTree::Builder.build_random_tree(recursion_amount: 2)
+    end
+
+    def update_and_draw
+      $stdout.clear_screen
+      random_tree.print
+      print_random_seed_info
+      random_tree.tick!
+    end
+
+    def setup_console
+      srand(random_seed)
+      $stdout.sync = true
+      $stdout.clear_screen
+
+      trap 'INT' do
+        puts ''
+        exit 0
+      end
+    end
+  end
+end
+
+namespace :visualize do
+  desc 'Visualize a random tree animated (optional parameters sleep=0.5 random_seed=12345678)'
+  task :auto do
+    VisualizeUtils.setup_console
+    loop do
+      VisualizeUtils.update_and_draw
+      sleep VisualizeUtils.sleep_time
+    end
+  end
+
+  desc 'Visualize a random tree, press key to tick (optional parameter random_seed=12345678)'
+  task :manual do
+    VisualizeUtils.setup_console
+    loop do
+      VisualizeUtils.update_and_draw
+      puts 'Press Enter key to tick. Press CTRL+C (SIGINT) to exit.'
+      $stdin.getc
+    end
+  end
+end

data/behavior_tree.gemspec

@@ -3,13 +3,13 @@
 require_relative 'lib/behavior_tree/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = 'behavior_tree' # TODO: Change?
+  spec.name          = 'behavior_tree'
   spec.version       = BehaviorTree::VERSION
   spec.authors       = ['Felo Vilches']
   spec.email         = ['felovilches@gmail.com']
 
-  spec.summary       = 'Behavior Tree (AI) library for Ruby.'
-  spec.homepage      = 'https://github.com/FeloVilches/Ruby-Behavior-Tree' # TODO: Change?
+  spec.summary       = 'A robust and customizable Ruby gem for creating Behavior Trees.'
+  spec.homepage      = 'https://github.com/FeloVilches/Ruby-Behavior-Tree'
   spec.license       = 'MIT'
   spec.required_ruby_version = Gem::Requirement.new('>= 2.6.0')
 
@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   # spec.metadata['changelog_uri'] = 'TODO: Put your gem's CHANGELOG.md URL here.'
 
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features|assets)/}) }
   end
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

data/lib/behavior_tree.rb

@@ -1,32 +1,6 @@
 # frozen_string_literal: true
 
-# Load all files from lib.
-# Gem.find_files('behavior_tree/**/*.rb').each { |path| require path }
-
-# Dir.glob(File.join('**', '*.rb')).sort.each { |file| require_relative file }
-
-# Dir[File.join('.', 'behavior_tree', '**', '*.rb')].sort.each { |file| require_relative file }
+require 'set'
 
-# pp Dir[File.join('.', 'behavior_tree', '**', '*.rb')]
-# require_relative './behavior_tree/tree'
-
-require_relative './behavior_tree/concerns/tree_structure/printer'
-require_relative './behavior_tree/concerns/tree_structure/algorithms'
-require_relative './behavior_tree/tasks/task_base'
-require_relative './behavior_tree/single_child_node'
-require_relative './behavior_tree/decorator_nodes/decorator_base'
-require_relative './behavior_tree/decorator_nodes/repeater'
-require_relative './behavior_tree/decorator_nodes/retry'
-require_relative './behavior_tree/decorator_nodes/inverter'
-require_relative './behavior_tree/decorator_nodes/force_success'
-require_relative './behavior_tree/decorator_nodes/force_failure'
-require_relative './behavior_tree/decorator_nodes/condition'
-require_relative './behavior_tree/errors'
-require_relative './behavior_tree/control_nodes/control_node_base'
-require_relative './behavior_tree/control_nodes/selector'
-require_relative './behavior_tree/control_nodes/sequence'
-require_relative './behavior_tree/node_status'
-require_relative './behavior_tree/tasks/nop'
-require_relative './behavior_tree/builder'
-require_relative './behavior_tree/version'
-require_relative './behavior_tree/tree'
+# Load all files from lib.
+Dir[File.join(__dir__, 'behavior_tree', '**', '*.rb')].sort.each { |file| require_relative file }

data/lib/behavior_tree/builder.rb

@@ -2,6 +2,9 @@
 
 require_relative './concerns/dsl/spell_checker'
 require_relative './concerns/dsl/initial_config'
+require_relative './concerns/dsl/randomizer'
+require_relative './concerns/dsl/registration'
+require_relative './concerns/dsl/utils'
 
 module BehaviorTree
   # DSL for building a tree.
@@ -10,6 +13,9 @@ module BehaviorTree
     class << self
       include Dsl::SpellChecker
       include Dsl::InitialConfig
+      include Dsl::Randomizer
+      include Dsl::Registration
+      include Dsl::Utils
 
       def build(&block)
         # Stack of lists. When a method like 'sequence' is executed, the resulting
@@ -27,33 +33,6 @@ module BehaviorTree
         BehaviorTree::Tree.new tree_main_nodes.first
       end
 
-      # Don't validate class_name, because in some situations the user wants it to be evaluated
-      # in runtime.
-      def register(node_name, class_name, children: :none)
-        valid_children_values = %i[none single multiple]
-        raise "Children value must be in: #{valid_children_values}" unless valid_children_values.include?(children)
-
-        node_name = node_name.to_sym
-        raise RegisterDSLNodeAlreadyExistsError, node_name if @node_type_mapping.key?(node_name)
-
-        @node_type_mapping[node_name] = {
-          class:    class_name,
-          children: children
-        }
-      end
-
-      def register_alias(original, alias_key)
-        unless @node_type_mapping.key?(original)
-          raise "Cannot register alias for '#{original}', since it doesn't exist."
-        end
-        raise RegisterDSLNodeAlreadyExistsError, alias_key if @node_type_mapping.key?(alias_key)
-        raise 'Alias key cannot be empty' if alias_key.to_s.empty?
-
-        @node_type_mapping[original][:alias] = alias_key
-        @node_type_mapping[alias_key] = @node_type_mapping[original].dup
-        @node_type_mapping[alias_key][:alias] = original
-      end
-
       private
 
       def stack(obj)
@@ -79,26 +58,17 @@ module BehaviorTree
         @node_type_mapping.key? method_name
       end
 
-      # Convert a class name with namespace into a constant.
-      # It returns the class itself if it's already a class.
-      # @param class_name [String]
-      # @return [Class]
-      def constantize(class_name)
-        return class_name if class_name.is_a?(Class)
-
-        class_name.split('::').compact.inject(Object) { |o, c| o.const_get c }
-      rescue NameError
-        nil
-      end
-
-      def dynamic_method_with_children(node_class, children, args, block)
+      def exec_with_children(node_class, children_type, args, block)
         stack_children_from_block(block)
-        final_args = [@stack.pop] + args # @stack.pop is already an Array
-        final_args.flatten! unless children == :multiple
+        children_nodes = @stack.pop
+        raise DSLStandardError, "Node #{node_class} has no children." if children_nodes.empty?
+
+        final_args = [children_nodes] + args # @stack.pop is already an Array
+        final_args.flatten! unless children_type == :multiple
         stack node_class.new(*final_args)
       end
 
-      def dynamic_method_leaf(node_class, args, block)
+      def exec_leaf(node_class, args, block)
         stack node_class.new(*args, &block)
       end
 
@@ -114,9 +84,9 @@ module BehaviorTree
 
         # Nodes that have children are executed differently from leaf nodes.
         if children == :none
-          dynamic_method_leaf(node_class, args, block)
+          exec_leaf(node_class, args, block)
         else
-          dynamic_method_with_children(node_class, children, args, block)
+          exec_with_children(node_class, children, args, block)
         end
       end
     end

data/lib/behavior_tree/concerns/dsl/randomizer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module BehaviorTree
+  module Dsl
+    # Generates random trees.
+    module Randomizer
+      def build_random_tree(recursion_amount: 10)
+        raise ArgumentError, 'Recursion amount must be greater than 0' if recursion_amount < 1
+
+        build do
+          send(%i[sel seq].sample) do
+            rand(3..5).times { recurse(recursion_amount).() }
+          end
+        end
+      end
+
+      private
+
+      def recurse(recursions_left)
+        return random_leaf_blocks.sample if recursions_left.zero?
+
+        recursions_left -= 1
+
+        # Repeated values in order to increase the weight for some type of nodes.
+        %i[
+          control decorated condition
+          control decorated condition
+          leaf
+        ].map { |type| send("random_#{type}_blocks", recursions_left) }
+          .concat
+          .flatten
+          .sample
+      end
+
+      def random_control_blocks(recursions_left)
+        [
+          proc { sel { rand(2..3).times { recurse(recursions_left).() } } },
+          proc { seq { rand(2..3).times { recurse(recursions_left).() } } }
+        ]
+      end
+
+      def random_decorated_blocks(recursions_left)
+        [
+          proc { force_success(&recurse(recursions_left)) },
+          proc { force_failure(&recurse(recursions_left)) },
+          proc { inv(&recurse(recursions_left)) },
+          proc { re_try(20, &recurse(recursions_left)) },
+          proc { repeater(20, &recurse(recursions_left)) }
+        ]
+      end
+
+      def random_condition_blocks(recursions_left)
+        [
+          proc {
+            cond(-> { rand > 0.2 }, &recurse(recursions_left))
+          },
+          proc {
+            cond(-> { rand > 0.8 }, &recurse(recursions_left))
+          }
+        ]
+      end
+
+      def random_leaf_blocks(_recursions_left = nil)
+        task = proc do
+          task do
+            # Weights.
+            running_w = 3
+            success_w = 1
+            failure_w = 2
+            new_status = (([:running] * running_w) + ([:success] * success_w) + ([:failure] * failure_w)).sample
+            status.send("#{new_status}!")
+          end
+        end
+        [task]
+      end
+    end
+  end
+end

data/lib/behavior_tree/concerns/dsl/registration.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module BehaviorTree
+  module Dsl
+    # Register DSL commands.
+    module Registration
+      # Don't validate class_name, because in some situations the user wants it to be evaluated
+      # in runtime.
+      def register(node_name, class_name, children: :none)
+        valid_children_values = %i[none single multiple]
+        raise "Children value must be in: #{valid_children_values}" unless valid_children_values.include?(children)
+
+        node_name = node_name.to_sym
+        raise RegisterDSLNodeAlreadyExistsError, node_name if @node_type_mapping.key?(node_name)
+
+        @node_type_mapping[node_name] = {
+          class:    class_name,
+          children: children
+        }
+      end
+
+      def register_alias(original, alias_key)
+        unless @node_type_mapping.key?(original)
+          raise "Cannot register alias for '#{original}', since it doesn't exist."
+        end
+        raise RegisterDSLNodeAlreadyExistsError, alias_key if @node_type_mapping.key?(alias_key)
+        raise 'Alias key cannot be empty' if alias_key.to_s.empty?
+
+        @node_type_mapping[original][:alias] = alias_key
+        @node_type_mapping[alias_key] = @node_type_mapping[original].dup
+        @node_type_mapping[alias_key][:alias] = original
+      end
+    end
+  end
+end

data/lib/behavior_tree/concerns/dsl/spell_checker.rb

@@ -4,6 +4,8 @@ module BehaviorTree
   module Dsl
     # Helpers for spellchecking, and correcting user input in the DSL builder.
     module SpellChecker
+      private
+
       def raise_node_type_not_exists(missing_method)
         suggestion = most_similar_name missing_method
         method_alias = @node_type_mapping.dig suggestion, :alias

data/lib/behavior_tree/concerns/dsl/utils.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module BehaviorTree
+  module Dsl
+    # Helpers for DSL.
+    module Utils
+      private
+
+      # Convert a class name with namespace into a constant.
+      # It returns the class itself if it's already a class.
+      # @param class_name [String]
+      # @return [Class]
+      def constantize(class_name)
+        return class_name if class_name.is_a?(Class)
+
+        class_name.split('::').compact.inject(Object) { |o, c| o.const_get c }
+      rescue NameError
+        nil
+      end
+    end
+  end
+end

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,12 +7,16 @@ module BehaviorTree
     # Algorithm to print tree.
     module Printer
       def print
-        puts '∅' # Style for the root node.
-        tree_lines.each { |line| puts line }
-        puts ''
-        puts cycle_string
-        puts uniq_nodes_string
-        puts size_string
+        lines = []
+        lines << '∅' # Style for the root node.
+        lines += tree_lines
+        lines << ''
+        lines << cycle_string
+        lines << uniq_nodes_string
+        lines << size_string
+        lines << tree_tick_count_string
+
+        puts lines.join "\n"
       end
 
       private
@@ -27,7 +31,7 @@ module BehaviorTree
 
           last_child ? vertical_lines_continues.delete(depth) : vertical_lines_continues << depth
 
-          space = (0...depth).map { |d| vertical_lines_continues.include?(d) ? '│ ' : '  ' }.join
+          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)}"
@@ -66,6 +70,10 @@ module BehaviorTree
         ColorizedString["(#{node.tick_count} ticks)"].colorize(color)
       end
 
+      def tree_tick_count_string
+        "Tree has been ticked #{tick_count} times."
+      end
+
       # Copied from Rails' ActiveSupport.
       def snake_case(str)
         str.gsub(/::/, '/')
@@ -76,7 +84,22 @@ module BehaviorTree
       end
 
       def class_simple_name(node)
-        snake_case(node.class.name.split('::').last)
+        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'
+        else
+          name
+        end
       end
     end
   end