steering_behaviors 1.0.0

data/lib/steering_behaviors/evade.rb

@@ -0,0 +1,42 @@
+##
+# 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::Evade
+  extend SteeringBehaviors::Common
+
+  # Evade a moving target by anticipating its future position. Calculates where it thinks
+  # the target will be, and leverages 'flee' to calculate how to best escape.
+  # See http://www.red3d.com/cwr/steer/
+  #
+  # * *Args*    :
+  #   - +evading_kinematic+ -> evading kinematic
+  #   - +enemy_kinematic+ -> kinematic of the thing to evade
+  # * *Returns* :
+  #   - a steering force
+  #
+  def self.steer(evading_kinematic, enemy_kinematic)
+    offset          = enemy_kinematic.position_vec - evading_kinematic.position_vec
+    direct_distance = offset.length
+    unit_offset     = offset / direct_distance
+
+    parallelness = evading_kinematic.heading_vec.dot(enemy_kinematic.heading_vec)
+    forwardness  = unit_offset.dot(evading_kinematic.heading_vec)
+
+    gen, tf = compute_time_factor(forwardness, parallelness)
+
+    direct_travel_time     = direct_distance / evading_kinematic.speed
+    direct_travel_time_2   = direct_distance / (evading_kinematic.speed + enemy_kinematic.speed)
+    estimated_time_enroute = direct_travel_time_2 * tf
+
+    # printf "#{ipos.entity}'s target #{qpos.entity} is '#{gen}'. fness: %0.3f pness: %0.3f f: %0.3f p: %0.3f tf: %0.3f\n", forwardness, parallelness, f, p, tf
+    predicted_pos_vec = enemy_kinematic.position_vec + (enemy_kinematic.velocity_vec * estimated_time_enroute)
+
+    return [predicted_pos_vec, SteeringBehaviors::Flee.steer(evading_kinematic, predicted_pos_vec)]
+  end
+
+end

data/lib/steering_behaviors/flee.rb

@@ -0,0 +1,24 @@
+##
+# 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::Flee
+
+  # Flee a specific position via the best possible route.
+  # See http://www.red3d.com/cwr/steer/
+  #
+  # * *Args*    :
+  #   - +kinematic+ -> the thing that is fleeing
+  #   - +flee_position+ -> the position-vector that we want to flee from
+  # * *Returns* :
+  #   - the calculated steering force
+  #
+  def self.steer(kinematic, flee_position)
+    best_velocity_to_target = (kinematic.position_vec - flee_position).normalize * kinematic.max_speed
+    best_velocity_to_target - kinematic.velocity_vec
+  end
+end

data/lib/steering_behaviors/match.rb

@@ -0,0 +1,28 @@
+##
+# 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::Match
+
+  # Matches the target's course and speed.
+  #
+  # * *Args*    :
+  #   - +hunter_kinematic+ -> my moving thing
+  #   - +quarry_kinematic+ -> kinematic of the target
+  # * *Returns* :
+  #   - the steering force
+  #
+  def self.steer(hunter_kinematic, quarry_kinematic)
+    course_diff = ( ( quarry_kinematic.heading_vec.radians - hunter_kinematic.heading_vec.radians + 3*Math::PI ) % (2*Math::PI) ) - Math::PI
+
+    speed_diff = quarry_kinematic.speed - hunter_kinematic.speed
+
+    target_local = SteeringBehaviors::Vector.new(course_diff * quarry_kinematic.speed, speed_diff)
+    target_local.rotate!(hunter_kinematic.heading_vec.radians)
+  end
+
+end

data/lib/steering_behaviors/orthogonal.rb

@@ -0,0 +1,31 @@
+##
+# 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::Orthogonal
+
+  # Moves at a 90-degree angle to the target's course.
+  #
+  # * *Args*    :
+  #   - +hunter_kinematic+ -> my moving thing
+  #   - +quarry_kinematic+ -> kinematic of the target
+  # * *Returns* :
+  #   -
+  #
+  def self.steer(hunter_kinematic, quarry_kinematic)
+    option_a = SteeringBehaviors::Vector.new(quarry_kinematic.heading_vec.y, -quarry_kinematic.heading_vec.x)
+    option_b = SteeringBehaviors::Vector.new(-quarry_kinematic.heading_vec.y, quarry_kinematic.heading_vec.x)
+
+    da = option_a.delta(hunter_kinematic.heading_vec)
+    db = option_b.delta(hunter_kinematic.heading_vec)
+
+    best_hdg_vec = (da < db ? option_a : option_b)
+
+    desired_velocity = best_hdg_vec * hunter_kinematic.velocity_vec.length
+  end
+
+end

data/lib/steering_behaviors/pursue.rb

@@ -0,0 +1,45 @@
+##
+# 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::Pursue
+  extend SteeringBehaviors::Common
+
+  # Pursue a moving target by anticipating its future position. Calculates where it thinks
+  # the target will be, and leverages 'seek' to calculate how to get there.
+  # See http://www.red3d.com/cwr/steer/
+  #
+  # * *Args*    :
+  #   - +hunter_kinematic+ -> pursuing kinematic
+  #   - +quarry_kinematic+ -> kinematic of the target
+  # * *Returns* :
+  #   -
+  # * *Raises* :
+  #   - ++ ->
+  #
+  def self.steer(hunter_kinematic, quarry_kinematic)
+    offset          = quarry_kinematic.position_vec - hunter_kinematic.position_vec
+    direct_distance = offset.length
+    unit_offset     = offset / direct_distance
+
+    parallelness = hunter_kinematic.heading_vec.dot(quarry_kinematic.heading_vec)
+    forwardness  = unit_offset.dot(hunter_kinematic.heading_vec)
+
+    gen, tf = compute_time_factor(forwardness, parallelness)
+
+    direct_travel_time     = direct_distance / hunter_kinematic.speed
+    direct_travel_time_2   = direct_distance / (hunter_kinematic.speed + quarry_kinematic.speed)
+    estimated_time_enroute = direct_travel_time_2 * tf
+
+    # printf "#{ipos.entity}'s target #{qpos.entity} is '#{gen}'. fness: %0.3f pness: %0.3f f: %0.3f p: %0.3f tf: %0.3f\n", forwardness, parallelness, f, p, tf
+    predicted_pos_vec = quarry_kinematic.position_vec + (quarry_kinematic.velocity_vec * estimated_time_enroute)
+
+    return [predicted_pos_vec, SteeringBehaviors::Seek.steer(hunter_kinematic, predicted_pos_vec)]
+  end
+
+
+end

data/lib/steering_behaviors/seek.rb

@@ -0,0 +1,24 @@
+##
+# 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::Seek
+
+  # Seek a specific position; unlike 'arrive', will not slow down to stop at that pos.
+  # See http://www.red3d.com/cwr/steer/
+  #
+  # * *Args*    :
+  #   - +kinematic+ -> my seeking thing
+  #   - +goal_position+ -> the position-vector where we want to go
+  # * *Returns* :
+  #   - the calculated steering force
+  #
+  def self.steer(kinematic, goal_position)
+    desired_velocity = (goal_position - kinematic.position_vec).normalize * kinematic.max_speed
+    desired_velocity - kinematic.velocity_vec
+  end
+end

data/lib/steering_behaviors/steering.rb

@@ -0,0 +1,56 @@
+##
+# 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::Steering
+
+  # Given a steering force vector, alter course and velocity accordingly.
+  # Takes turn rate limitations, mass, and other limits into account, and
+  # directly alters the provided Mobile component.
+  #
+  # * *Args*    :
+  #   - +kinematic+ -> the kinematic thing
+  #   - +steering_force+ -> force vector supplied by a steering behavior
+  #   - +delta+ -> time delta (in seconds) used for scaling the result
+  #   - +accelerative+ -> whether you want the steering to change the thing's velocity (default true)
+  #
+  def self.feel_the_force(kinematic, steering_force, delta, accelerative=true) #, mobile, position)
+    acceleration = steering_force / kinematic.mass
+
+    # Compute the new, proposed velocity vector.
+    desired_velocity = kinematic.velocity_vec + (acceleration * delta)
+
+    desired_velocity.truncate!(kinematic.speed) if !accelerative
+    desired_velocity.truncate!(kinematic.max_speed)
+
+    # If this timeslice's proposed velocity-vector exceeds the turn rate,
+    # come up with a revised velociy-vec that doesn't exceed the rate -- and use that.
+    angle             = Math.acos kinematic.heading_vec.dot(desired_velocity.normalize)
+    max_course_change = kinematic.max_turn * delta
+
+    if angle.abs > max_course_change
+      direction    = SteeringBehaviors::Vector.sign(kinematic.velocity_vec, desired_velocity) # -1==CCW, 1==CW
+      limited_crse = kinematic.heading_vec.radians - max_course_change * direction
+
+      # printf "Current %0.4f. Angle %0.4f %s exceeds max change %0.4f. Desired course [%0.4f], limited course [%0.4f]\n",
+      #   kinematic.heading_vec.radians,
+      #   angle,
+      #   (direction==1 ? 'CW' : 'CCW'),
+      #   max_course_change,
+      #   desired_velocity.radians,
+      #   limited_crse
+
+      kinematic.velocity_vec = SteeringBehaviors::Vector.new(
+        Math.sin(limited_crse) * kinematic.speed,
+        Math.cos(limited_crse) * kinematic.speed
+      )
+    else
+      kinematic.velocity_vec = desired_velocity
+    end
+  end
+
+end

data/lib/steering_behaviors/vector.rb

@@ -0,0 +1,185 @@
+##
+# 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::Vector
+  attr_reader :x, :y
+
+  def initialize(x=0,y=0)
+    @x = x.to_f
+    @y = y.to_f
+  end
+
+  def ==(other)
+    self.class == other.class && @x==other.x && @y==other.y
+  end
+  alias_method :eql?, :==
+
+  def x=(x)
+    @x = x.to_f
+  end
+
+  def y=(y)
+    @y = y.to_f
+  end
+
+  def length
+    Math.sqrt(@x**2 + @y**2)
+  end
+
+  def +(v)
+    SteeringBehaviors::Vector.new(@x + v.x, @y + v.y)
+  end
+
+  def /(n)
+    SteeringBehaviors::Vector.new(@x/n, @y/n)
+  end
+
+  def *(n)
+    SteeringBehaviors::Vector.new(@x*n, @y*n)
+  end
+
+  def -(v)
+    SteeringBehaviors::Vector.new(@x - v.x, @y - v.y)
+  end
+
+  def delta(other)
+    (( ( other.radians - self.radians + Math::PI + 2*Math::PI ) % (2*Math::PI) ) - Math::PI).abs
+  end
+
+  def normalize!
+    orig_length = length
+    return self if orig_length == 1.0 || orig_length == 0
+
+    @x /= orig_length
+    @y /= orig_length
+
+    self
+  end
+
+  def normalize
+    orig_length = length
+    return self if orig_length == 1.0 || orig_length == 0
+
+    SteeringBehaviors::Vector.new(@x/orig_length, @y/orig_length)
+  end
+
+  def truncate!(max)
+    return self if length < max
+
+    self.normalize!
+    self.x *= max
+    self.y *= max
+
+    self
+  end
+
+  # A · B = A.x * B.x + A.y * B.y
+  def dot(b)
+    val = @x*b.x + @y*b.y
+    val = 1.0 if val > 1.0
+    val = -1.0 if val < -1.0
+
+    val
+  end
+
+  def perpendicular
+    SteeringBehaviors::Vector.new(@y, -@x)
+  end
+
+  def compass_bearing(y_down_more_positive=false)
+    if y_down_more_positive
+      up = SteeringBehaviors::Vector.new(0, -1)
+    else
+      up = SteeringBehaviors::Vector.new(0, 1)
+    end
+
+    theta = Math.acos(self.normalize.dot(up))
+
+    theta *= -1 if @x < 0
+    degs = SteeringBehaviors::Vector.rad2deg(theta)
+    degs += 360 if degs < 0
+
+    degs
+  end
+
+  def sign(other)
+    SteeringBehaviors::Vector.sign(self, other)
+  end
+
+  def radians
+    theta = Math.acos(@y/length)
+    if @x < 0
+      theta *= -1
+    end
+
+    theta % (2 * Math::PI)
+  end
+
+  def from_compass_bearing!(brg)
+    rad = SteeringBehaviors::Vector.deg2rad(brg)
+    self.x = Math.sin(rad)
+    self.y = Math.cos(rad)
+  end
+
+  def rotate!(radians)
+    circle_cos = Math.cos(-radians)
+    circle_sin = Math.sin(-radians)
+
+    x_rot = circle_cos * x - circle_sin * y
+    y_rot = circle_sin * x + circle_cos * y
+
+    self.x, self.y = x_rot, y_rot
+    self
+  end
+
+  def rotate(radians)
+    circle_cos = Math.cos(-radians)
+    circle_sin = Math.sin(-radians)
+
+    x_rot = circle_cos * x - circle_sin * y
+    y_rot = circle_sin * x + circle_cos * y
+
+    SteeringBehaviors::Vector.new(x_rot, y_rot)
+  end
+
+  def self.sign(v1, v2)
+    if v1.y * v2.x > v1.x*v2.y
+      return -1 # clockwise
+    else
+      return 1 # anti-clockwise
+    end
+  end
+
+  # def self.position_to_world_coords(point, heading_vec, pos)
+  #   local_angle = heading_vec.radians + point.radians
+
+  #   x = Math.sin(local_angle) * point.length
+  #   y = Math.cos(local_angle) * point.length
+
+  #   world_point = SteeringBehaviors::Vector.new(x,y) + pos
+  #   world_point
+  # end
+
+  def self.deg2rad(d)
+    d * 0.017453292519943295 # Math::PI / 180.0
+  end
+
+  def self.rad2deg(r)
+    r * 57.29577951308232 # 180.0 / Math::PI
+  end
+
+  def self.from_compass_bearing(brg)
+    rad = SteeringBehaviors::Vector.deg2rad(brg)
+    SteeringBehaviors::Vector.new(Math.sin(rad), Math.cos(rad))
+  end
+
+  def to_s
+    format("Vector {[%.7f, %.7f] len %0.7f}", @x, @y, length)
+  end
+
+end