steering_behaviors 1.0.0

data/lib/steering_behaviors/wander.rb

@@ -0,0 +1,26 @@
+##
+# Copyright 2013, Prylis Incorporated.
+#
+# This file is part of The Ruby Steering Behaviors Library.
+# http://github.com/cpowell/steering-behaviors
+# You can redistribute and/or modify this software only in accordance with
+# the terms found in the "LICENSE" file included with the framework.
+
+class SteeringBehaviors::Wander
+
+  # Wander about in a 'random walk' way. Speeds up and slows down, too.
+  # See http://www.red3d.com/cwr/steer/
+  #
+  # * *Args*    :
+  #   - +kinematic+ -> the wandering thing
+  #   - +erraticism+ -> how erratic the wandering effect will be
+  # * *Returns* :
+  #   - the calculated steering force
+  #
+  def self.steer(kinematic, erraticism)
+    kinematic.steering_target += SteeringBehaviors::Vector.new(rand(-1.0..1.0)*erraticism, rand(-1.0..1.0)*erraticism)
+    kinematic.steering_target.normalize!
+
+    kinematic.steering_target.rotate(kinematic.heading_vec.radians)
+  end
+end

data/test/all_suite.rb

@@ -0,0 +1,7 @@
+# This is a whole test suite.
+#
+# $ ruby test/all_suite.rb
+# or just
+# $ rake test
+
+require "test/vector_test"

data/test/vector_test.rb

@@ -0,0 +1,362 @@
+gem 'minitest'
+require 'minitest/autorun'
+
+$:.push File.expand_path('../../lib/', __FILE__)
+require 'steering_behaviors'
+require 'steering_behaviors/vector.rb'
+
+# ruby ./test/vector_test.rb
+
+class VectorTest < MiniTest::Unit::TestCase
+  def setup
+    @v = SteeringBehaviors::Vector.new(0, 1.0)
+  end
+
+  def test_setters
+    @v.x=5
+    assert_equal(5, @v.x)
+
+    @v.y=10
+    assert_equal(10, @v.y)
+  end
+
+  def test_equality
+    @v2 = SteeringBehaviors::Vector.new(0, 1.0)
+    assert_equal(@v, @v2)
+
+    @v2 = SteeringBehaviors::Vector.new(5, 1.0)
+    refute_equal(@v, @v2)
+  end
+
+  def test_length_calculation
+    assert_equal(1, @v.length)
+
+    @v.x=10
+    @v.y=10
+    assert_equal(14.142135623730951, @v.length)
+
+    @v.x=-10
+    assert_equal(14.142135623730951, @v.length)
+  end
+
+  def test_addition
+    @v2 = SteeringBehaviors::Vector.new(5, -5)
+    @v+= @v2
+
+    assert_equal(5, @v.x)
+    assert_equal(-4, @v.y)
+    assert_equal(6.4031242374328485, @v.length)
+  end
+
+  def test_subtraction
+    @v2 = SteeringBehaviors::Vector.new(5, -5)
+    @v-= @v2
+
+    assert_equal(-5, @v.x)
+    assert_equal(6, @v.y)
+
+    assert_equal(7.810249675906654, @v.length)
+  end
+
+  def test_multiplication
+    @v *= 10
+    assert_equal(0, @v.x)
+    assert_equal(10.0, @v.y)
+
+    @v *= 0.5
+    assert_equal(0, @v.x)
+    assert_equal(5.0, @v.y)
+
+    assert_equal(5.0, @v.length)
+  end
+
+  def test_division
+    @v /= 2
+    assert_equal(0, @v.x)
+    assert_equal(0.5, @v.y)
+
+    @v /= 0.2
+    assert_equal(0, @v.x)
+    assert_equal(2.5, @v.y)
+
+    assert_equal(2.5, @v.length)
+  end
+
+  def test_delta
+    other = SteeringBehaviors::Vector.new(1.0, 0)
+    assert_equal(Math::PI/2, @v.delta(other))
+
+    assert_equal(Math::PI/2, other.delta(@v))
+
+    other = SteeringBehaviors::Vector.new(0.1, 1.0)
+    assert_in_delta(0.1, other.delta(@v), 0.01)
+
+    other = SteeringBehaviors::Vector.new(-0.1, 1.0)
+    assert_in_delta(0.1, other.delta(@v), 0.01)
+
+    other = SteeringBehaviors::Vector.new(-0.1, -1.0)
+    assert_in_delta(3.04, other.delta(@v), 0.01)
+
+    other = SteeringBehaviors::Vector.new(0.1, -1.0)
+    assert_in_delta(3.04, other.delta(@v), 0.01)
+  end
+
+  def test_bang_normalization
+    res=@v.normalize!
+    assert_equal(@v, res)
+    assert_equal(1.0, @v.length)
+
+    @v = SteeringBehaviors::Vector.new(0, 0)
+    assert_equal(0, @v.length)
+    res=@v.normalize!
+    assert_equal(@v, res)
+    assert_equal(0.0, @v.length)
+
+    @v = SteeringBehaviors::Vector.new(1.0, 0)
+    assert_equal(1, @v.length)
+    res=@v.normalize!
+    assert_equal(@v, res)
+    assert_equal(1.0, @v.length)
+
+    @v = SteeringBehaviors::Vector.new(0, 1.0)
+    assert_equal(1, @v.length)
+    res=@v.normalize!
+    assert_equal(@v, res)
+    assert_equal(1.0, @v.length)
+
+    @v = SteeringBehaviors::Vector.new(10, 10)
+    assert_equal(14.142135623730951, @v.length)
+    res=@v.normalize!
+    assert_equal(@v, res)
+    assert_in_delta(1.0, @v.length, 0.01)
+
+    @v = SteeringBehaviors::Vector.new(3, 4)
+    assert_equal(5, @v.length)
+    res=@v.normalize!
+    assert_equal(@v, res)
+    assert_equal(1.0, @v.length)
+
+    @v = SteeringBehaviors::Vector.new(0.5, 1.0)
+    res=@v.normalize!
+    assert_in_delta(1.0, @v.length, 0.01)
+  end
+
+  def test_normalization
+    res=@v.normalize
+    assert_equal(1.0, @v.length)
+
+    @v = SteeringBehaviors::Vector.new(0, 0)
+    assert_equal(0, @v.length)
+    res=@v.normalize
+    assert_equal(@v, res)
+    assert_equal(0.0, res.length)
+
+    @v = SteeringBehaviors::Vector.new(1.0, 0)
+    assert_equal(1, @v.length)
+    res=@v.normalize
+    assert_equal(@v, res)
+    assert_equal(1.0, res.length)
+
+    @v = SteeringBehaviors::Vector.new(0, 1.0)
+    assert_equal(1, @v.length)
+    res=@v.normalize
+    assert_equal(@v, res)
+    assert_equal(1.0, res.length)
+
+    @v = SteeringBehaviors::Vector.new(10, 10)
+    assert_equal(14.142135623730951, @v.length)
+    res=@v.normalize
+    refute_equal(@v, res)
+    assert_in_delta(14.142, @v.length, 0.01)
+    assert_in_delta(1.0, res.length, 0.01)
+
+    @v = SteeringBehaviors::Vector.new(3, 4)
+    assert_equal(5, @v.length)
+    res=@v.normalize
+    refute_equal(@v, res)
+    assert_equal(5.0, @v.length)
+    assert_equal(1.0, res.length)
+  end
+
+  def test_truncation
+    res = @v.truncate!(500)
+    assert_equal(1.0, res.length)
+
+    @v = SteeringBehaviors::Vector.new(10, 10)
+    assert_equal(14.142135623730951, @v.length)
+    res = @v.truncate!(15)
+    assert_equal(14.142135623730951, res.length)
+
+    res = @v.truncate!(9)
+    assert_equal(9.0, res.length)
+  end
+
+  def test_dot_product
+    @v1 = SteeringBehaviors::Vector.new(0.5, 1)
+    @v2 = SteeringBehaviors::Vector.new(1.0, 0.5)
+    assert_equal(1.0, @v1.dot(@v2))
+
+    @v1 = SteeringBehaviors::Vector.new(1.0, 0)
+    @v2 = SteeringBehaviors::Vector.new(0, 1.0)
+    assert_equal(0, @v1.dot(@v2))
+
+    @v1 = SteeringBehaviors::Vector.new(0, 1.0)
+    @v2 = SteeringBehaviors::Vector.new(-1.0, 0)
+    assert_equal(0, @v1.dot(@v2))
+
+    @v1 = SteeringBehaviors::Vector.new(0, 1.0)
+    @v2 = SteeringBehaviors::Vector.new(0.707, 0.707)
+    @v2.normalize!
+    assert_equal(0.7071067811865476, @v1.dot(@v2))
+
+    @v1 = SteeringBehaviors::Vector.new(1.0, 0)
+    @v2 = SteeringBehaviors::Vector.new(-0.707, 0.707)
+    @v2.normalize!
+    assert_equal(-0.7071067811865476, @v1.dot(@v2))
+
+    @v1 = SteeringBehaviors::Vector.new(1.0, 0)
+    @v2 = SteeringBehaviors::Vector.new(-0.707, -0.707)
+    @v2.normalize!
+    assert_equal(-0.7071067811865476, @v1.dot(@v2))
+
+    @v1 = SteeringBehaviors::Vector.new(0.5, 0.866)
+    @v1.normalize!
+    @v2 = SteeringBehaviors::Vector.new(0.866, 0.5)
+    @v2.normalize!
+    assert_equal(0.86603810567665, @v1.dot(@v2))
+  end
+
+  def test_perpendicular
+    @v2 = @v.perpendicular
+    assert_equal(1.0, @v2.x)
+    assert_equal(0, @v2.y)
+  end
+
+  def test_instance_sign
+    v1 = SteeringBehaviors::Vector.from_compass_bearing(45)
+    v2 = SteeringBehaviors::Vector.from_compass_bearing(115)
+
+    assert_equal(-1, v1.sign(v2))
+    assert_equal(1, v2.sign(v1))
+  end
+
+  def test_compass_bearing
+    @v = SteeringBehaviors::Vector.new(5, 5)
+    assert_in_delta(45, @v.compass_bearing, 0.1)
+
+    @v = SteeringBehaviors::Vector.new(-2, 10)
+    assert_in_delta(349, @v.compass_bearing, 0.5)
+
+    @v = SteeringBehaviors::Vector.new(5, 5)
+    assert_in_delta(135, @v.compass_bearing(true), 0.1)
+
+    @v = SteeringBehaviors::Vector.new(-2, 10)
+    assert_in_delta(191, @v.compass_bearing(true), 0.5)
+  end
+
+  def test_radians
+    assert_equal(0, @v.radians)
+
+    @v = SteeringBehaviors::Vector.new(1.0, 0)
+    assert_equal(Math::PI/2, @v.radians)
+
+    @v = SteeringBehaviors::Vector.new(0, 1.0)
+    assert_equal(0, @v.radians)
+
+    @v = SteeringBehaviors::Vector.new(0.707, -0.707)
+    assert_equal(Math::PI/4*3, @v.radians)
+
+    @v = SteeringBehaviors::Vector.new(-0.707, 0.707)
+    assert_equal(Math::PI/4*7, @v.radians)
+  end
+
+  def test_bang_from_compass_bearing
+    @v.from_compass_bearing!(45)
+    assert_in_delta(0.707, @v.x, 0.001)
+    assert_in_delta(0.707, @v.y, 0.001)
+
+    @v.from_compass_bearing!(135)
+    assert_in_delta(0.707, @v.x, 0.001)
+    assert_in_delta(-0.707, @v.y, 0.001)
+
+    @v.from_compass_bearing!(270)
+    assert_in_delta(-1.0, @v.x, 0.001)
+    assert_in_delta(0, @v.y, 0.001)
+  end
+
+  def test_bang_rotate
+    assert_equal(0, @v.radians)
+    @v.rotate!(Math::PI)
+    assert_equal(Math::PI, @v.radians)
+    assert_in_delta(0.0, @v.x, 0.0001)
+    assert_equal(-1.0, @v.y)
+
+    @v.rotate!(Math::PI/2)
+    assert_equal(Math::PI*1.5, @v.radians)
+    assert_in_delta(-1.0, @v.x, 0.0001)
+    assert_in_delta(0, @v.y, 0.0001)
+  end
+
+  def test_rotate
+    assert_equal(0, @v.radians)
+    v2 = @v.rotate(Math::PI)
+    assert_equal(0, @v.radians)
+    assert_equal(Math::PI, v2.radians)
+    assert_in_delta(0.0, v2.x, 0.0001)
+    assert_equal(-1.0, v2.y)
+
+    v3 = v2.rotate(Math::PI/2)
+    assert_equal(Math::PI*1.5, v3.radians)
+    assert_in_delta(-1.0, v3.x, 0.0001)
+    assert_in_delta(0, v3.y, 0.0001)
+  end
+
+  def test_rotate_never_returns_negative_rads
+    assert_equal(0, @v.radians)
+
+    new_vec = @v.rotate(-Math::PI/2)
+    assert_equal(3.0/2*Math::PI, new_vec.radians)
+
+    new_vec.rotate!(-Math::PI)
+    assert_in_delta(Math::PI/2.0, new_vec.radians, 0.0001)
+
+    new_vec.rotate!(2.0*Math::PI)
+    assert_in_delta(Math::PI/2.0, new_vec.radians, 0.0001)
+
+    new_vec.rotate!(-2.0*Math::PI)
+    assert_in_delta(Math::PI/2.0, new_vec.radians, 0.0001)
+  end
+
+  def test_degree_to_radian_conversion
+    assert_equal Math::PI/4, SteeringBehaviors::Vector.deg2rad(45)
+    assert_equal Math::PI/2, SteeringBehaviors::Vector.deg2rad(90)
+    assert_equal Math::PI, SteeringBehaviors::Vector.deg2rad(180)
+    assert_equal Math::PI*14/8, SteeringBehaviors::Vector.deg2rad(315)
+  end
+
+  def test_radian_to_degree_conversion
+    assert_equal 45, SteeringBehaviors::Vector.rad2deg(Math::PI/4)
+    assert_equal 90, SteeringBehaviors::Vector.rad2deg(Math::PI/2)
+    assert_equal 180, SteeringBehaviors::Vector.rad2deg(Math::PI)
+    assert_equal 315, SteeringBehaviors::Vector.rad2deg(Math::PI*14/8)
+  end
+
+  def test_class_from_compass_bearing
+    v = SteeringBehaviors::Vector.from_compass_bearing(349)
+    assert_equal(-0.19080899537654467, v.x)
+    assert_equal(0.981627183447664, v.y)
+
+    v = SteeringBehaviors::Vector.from_compass_bearing(270)
+    assert_in_delta(-1.0, v.x, 0.0001)
+    assert_in_delta(0, v.y, 0.0001)
+  end
+
+  def test_class_sign
+    v1 = SteeringBehaviors::Vector.from_compass_bearing(45)
+    v2 = SteeringBehaviors::Vector.from_compass_bearing(115)
+
+    assert_equal(-1, SteeringBehaviors::Vector.sign(v1, v2))
+    assert_equal(1, SteeringBehaviors::Vector.sign(v2, v1))
+  end
+
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: steering_behaviors
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 1.0.0
+platform: ruby
+authors:
+- Chris Powell
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-07-25 00:00:00.000000000 Z
+dependencies: []
+description: |
+  If you're building a game, you need your game agents and characters to move on their own. A standard way of doing this is with 'steering behaviors'. The seminal paper by Craig Reynolds established a core set of steering behaviors that could be utilized for a variety of common movement tasks and natural behaviors. This Ruby library can accomplish many/most of those tasks for your Ruby / JRuby game. The basic behaviors can be layered for more complicated and advanced behaviors, such as flocking and crowd movement.
+email: cpowell@prylis.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/steering_behaviors.rb
+- lib/steering_behaviors/align.rb
+- lib/steering_behaviors/arrive.rb
+- lib/steering_behaviors/broadside.rb
+- lib/steering_behaviors/common.rb
+- lib/steering_behaviors/evade.rb
+- lib/steering_behaviors/flee.rb
+- lib/steering_behaviors/match.rb
+- lib/steering_behaviors/orthogonal.rb
+- lib/steering_behaviors/pursue.rb
+- lib/steering_behaviors/seek.rb
+- lib/steering_behaviors/steering.rb
+- lib/steering_behaviors/vector.rb
+- lib/steering_behaviors/wander.rb
+- CHANGELOG.md
+- LICENSE
+- Rakefile
+- README.md
+- test/all_suite.rb
+- test/vector_test.rb
+homepage: http://github.com/cpowell/steering-behaviors
+licenses:
+- LGPL
+post_install_message:
+rdoc_options:
+- --main
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: Steering behaviors in Ruby for autonomous game agents, useful for realistic character movement and emulating real-world and natural behaviors.
+test_files: []