gosling 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2e286ba691604561ac6676e60e49699cd3167587
+  data.tar.gz: 6e2083451057aa524bed3f13012134e829a55f80
+SHA512:
+  metadata.gz: 6232f177ad08bc4869af947c3c6748c004a052d47ca92247a8d0c54910117a6c8984aa5c5d7d35edb109e31ca5281536fc52c5013928b43bdd958e5edb1c6c44
+  data.tar.gz: 35fe442a079c785663f73640b006171c57872fe0c189bf55c9aa1146fd88c336f4cdabf52db410f3a84361fa862081dff505391c563e9f1f80e16729f1514a5f

data/lib/gosling.rb

@@ -0,0 +1,4 @@
+Dir.glob(File.join(File.dirname(__FILE__), 'gosling/*.rb')).each { |file| require_relative file }
+
+module Gosling
+end

data/lib/gosling/actor.rb

@@ -0,0 +1,235 @@
+require_relative 'transform.rb'
+
+require 'gosu'
+
+module Gosling
+  class Actor
+    attr_reader :transform, :parent, :children, :window
+    attr_accessor :is_visible, :is_tangible, :are_children_visible, :are_children_tangible, :is_mask, :color
+
+    def initialize(window)
+      @window = window
+      @transform = Transform.new
+      @parent = nil
+      @children = []
+      @is_visible = true
+      @is_tangible = true
+      @are_children_visible = true
+      @are_children_tangible = true
+      @is_mask = false
+      @color = Gosu::Color.from_hsv(rand(360), rand(), rand())
+    end
+
+    def inspect
+      "#<#{self.class}:#{self.object_id}>"
+    end
+
+    def parent=(parent)
+      return if parent == @parent
+      unless parent
+        raise Gosling::InheritanceError.new("You should use Actor.remove_child() instead of setting the parent directly.") if @parent.has_child?(self)
+      end
+      @parent = parent
+      if @parent
+        raise Gosling::InheritanceError.new("You should use Actor.add_child() instead of setting the parent directly.") unless @parent.has_child?(self)
+      end
+    end
+
+    def add_child(child)
+      return if @children.include?(child)
+      raise Gosling::InheritanceError.new("An Actor cannot be made a child of itself.") if child == self
+      ancestor = parent
+      until ancestor.nil?
+        raise Gosling::InheritanceError.new("Adding a child's ancestor as a child would create a circular reference.") if child == ancestor
+        ancestor = ancestor.parent
+      end
+
+      child.parent.remove_child(child) if child.parent
+      @children.push(child)
+      child.parent = self
+    end
+
+    def remove_child(child)
+      return unless @children.include?(child)
+
+      @children.delete(child)
+      child.parent = nil
+    end
+
+    def has_child?(child)
+      @children.include?(child)
+    end
+
+    def x
+      @transform.translation[0]
+    end
+
+    def x=(val)
+      array = @transform.translation.to_a
+      array[0] = val
+      @transform.set_translation(Vector.elements(array))
+    end
+
+    def y
+      @transform.translation[1]
+    end
+
+    def y=(val)
+      array = @transform.translation.to_a
+      array[1] = val
+      @transform.set_translation(Vector.elements(array))
+    end
+
+    def pos
+      Vector[x, y, 0]
+    end
+
+    def pos=(val)
+      array = @transform.translation.to_a
+      array[0] = val[0]
+      array[1] = val[1]
+      @transform.set_translation(Vector.elements(array))
+    end
+
+    def center_x
+      @transform.center[0]
+    end
+
+    def center_x=(val)
+      array = @transform.center.to_a
+      array[0] = val
+      @transform.set_center(Vector.elements(array))
+    end
+
+    def center_y
+      @transform.center[1]
+    end
+
+    def center_y=(val)
+      array = @transform.center.to_a
+      array[1] = val
+      @transform.set_center(Vector.elements(array))
+    end
+
+    def scale_x
+      @transform.scale[0]
+    end
+
+    def scale_x=(val)
+      array = @transform.scale.to_a
+      array[0] = val
+      @transform.set_scale(Vector.elements(array))
+    end
+
+    def scale_y
+      @transform.scale[1]
+    end
+
+    def scale_y=(val)
+      array = @transform.scale.to_a
+      array[1] = val
+      @transform.set_scale(Vector.elements(array))
+    end
+
+    def rotation
+      @transform.rotation
+    end
+
+    def rotation=(val)
+      @transform.set_rotation(val)
+    end
+
+    def render(matrix)
+    end
+
+    def draw(matrix = nil)
+      matrix ||= Matrix.identity(3)
+      transform = matrix * @transform.to_matrix
+      render(transform) if @is_visible
+      if @are_children_visible
+        @children.each { |child| child.draw(transform) }
+      end
+    end
+
+    def is_point_in_bounds(point)
+      false
+    end
+
+    def get_actor_at(point)
+      hit = nil
+      if @are_children_tangible
+        @children.reverse_each do |child|
+          hit = child.get_actor_at(point)
+          if hit
+            break if @is_mask
+            return hit
+          end
+        end
+      end
+      hit = self if hit == nil && @is_tangible && is_point_in_bounds(point)
+      hit = @parent if @is_mask && hit == self
+      hit
+    end
+
+    def get_actors_at(point)
+      actors = []
+      if @are_children_tangible
+        @children.reverse_each do |child|
+          actors |= child.get_actors_at(point)
+        end
+      end
+      actors.push(self) if @is_tangible && is_point_in_bounds(point)
+      actors.uniq!
+      if @is_mask
+        actors.map! { |actor| (actor == self) ? @parent : actor }
+      end
+      actors
+    end
+
+    def get_global_transform
+      tf = if parent
+        parent.get_global_transform * @transform.to_matrix
+      else
+        @transform.to_matrix
+      end
+      return tf
+    end
+
+    def get_global_position
+      tf = get_global_transform
+      Transform.transform_point(tf, Vector[@transform.center[0], @transform.center[1], 0])
+    end
+
+    def alpha
+      @color.alpha
+    end
+
+    def alpha=(val)
+      @color.alpha = val
+    end
+
+    def red
+      @color.red
+    end
+
+    def red=(val)
+      @color.red = val
+    end
+
+    def green
+      @color.green
+    end
+
+    def green=(val)
+      @color.green = val
+    end
+
+    def blue
+      @color.blue
+    end
+
+    def blue=(val)
+      @color.blue = val
+    end
+  end
+end

data/lib/gosling/circle.rb

@@ -0,0 +1,48 @@
+require_relative 'actor.rb'
+require_relative 'collision.rb'
+
+module Gosling
+  class Circle < Actor
+    RENDER_VERTEX_COUNT = 16
+
+    attr_reader :radius
+
+    def initialize(window)
+      super(window)
+      @radius = 0
+    end
+
+    def radius=(val)
+      raise ArgumentError.new("Circle.radius cannot be negative") if val < 0
+      @radius = val
+    end
+
+    def get_point_at_angle(radians)
+      raise ArgumentError.new("Expected Numeric, but received #{radians.inspect}!") unless radians.is_a?(Numeric)
+      Vector[Math.cos(radians) * @radius, Math.sin(radians) * @radius, 0]
+    end
+
+    def render(matrix)
+      local_vertices = (0...RENDER_VERTEX_COUNT).map do |i|
+        get_point_at_angle(Math::PI * 2 * i / RENDER_VERTEX_COUNT)
+      end
+      global_vertices = local_vertices.map { |v| Transform.transform_point(matrix, v) }
+      i = 2
+      while i < global_vertices.length
+        v0 = global_vertices[0]
+        v1 = global_vertices[i-1]
+        v2 = global_vertices[i]
+        @window.draw_triangle(
+          v0[0].to_f, v0[1].to_f, @color,
+          v1[0].to_f, v1[1].to_f, @color,
+          v2[0].to_f, v2[1].to_f, @color,
+        )
+        i += 1
+      end
+    end
+
+    def is_point_in_bounds(point)
+      Collision.is_point_in_shape?(point, self)
+    end
+  end
+end

data/lib/gosling/collision.rb

@@ -0,0 +1,126 @@
+require 'singleton'
+
+module Gosling
+  class Collision
+    # 11.4 - 6.7 (get_separation_axes) - 4.7 (project_onto_axis)
+    def self.test(shapeA, shapeB)
+      return false if shapeA.instance_of?(Actor) || shapeB.instance_of?(Actor)
+
+      return false if shapeA === shapeB
+
+      separation_axes = get_separation_axes(shapeA, shapeB)
+
+      separation_axes.each do |axis|
+        projectionA = project_onto_axis(shapeA, axis)
+        projectionB = project_onto_axis(shapeB, axis)
+        return false unless projections_overlap?(projectionA, projectionB)
+      end
+
+      return true
+    end
+
+    def self.is_point_in_shape?(point, shape)
+      raise ArgumentError.new("Collision.get_normal() requires a point and an actor") unless point.is_a?(Vector) && point.size == 3 && shape.is_a?(Actor)
+
+      return false if shape.instance_of?(Actor)
+
+      separation_axes = []
+      if shape.instance_of?(Circle)
+        centers_axis = point - shape.get_global_position
+        separation_axes.push(centers_axis) if centers_axis && centers_axis.magnitude > 0
+      else
+        separation_axes.concat(get_polygon_separation_axes(shape.get_global_vertices))
+      end
+
+      separation_axes.each do |axis|
+        shape_projection = project_onto_axis(shape, axis)
+        point_projection = point.inner_product(axis)
+        return false unless shape_projection.min <= point_projection && point_projection <= shape_projection.max
+      end
+
+      return true
+    end
+
+    def self.get_normal(vector)
+      raise ArgumentError.new("Collision.get_normal() requires a length 3 vector") unless vector.is_a?(Vector) && vector.size == 3
+      raise ArgumentError.new("Cannot determine normal of zero-length vector") if vector.magnitude == 0
+
+      Vector[-vector[1], vector[0], 0]
+    end
+
+    def self.get_polygon_separation_axes(vertices)
+      unless vertices.is_a?(Array) && vertices.reject { |v| v.is_a?(Vector) && v.size == 3 }.empty?
+        raise ArgumentError.new("Collission.get_polygon_separation_axes() expects an array of vectors similar to that produced by Polygon.get_vertices")
+      end
+
+      axes = (0...vertices.length).map do |i|
+        axis = vertices[(i + 1) % vertices.length] - vertices[i]
+        (axis.magnitude > 0) ? get_normal(axis).normalize : nil
+      end
+      axes.compact
+    end
+
+    def self.get_circle_separation_axis(circleA, circleB)
+      unless circleA.is_a?(Actor) && circleB.is_a?(Actor)
+        raise ArgumentError.new("Collision.get_circle_separation_axis() expects two circles")
+      end
+      axis = circleB.get_global_position - circleA.get_global_position
+      (axis.magnitude > 0) ? axis.normalize : nil
+    end
+
+    # 4.8 - 2.6 - 1.6 - .4
+    def self.get_separation_axes(shapeA, shapeB)
+      unless shapeA.is_a?(Actor) && !shapeA.instance_of?(Actor)
+        raise ArgumentError.new("Expected a child of the Actor class, but received #{shapeA.inspect}!")
+      end
+
+      unless shapeB.is_a?(Actor) && !shapeB.instance_of?(Actor)
+        raise ArgumentError.new("Expected a child of the Actor class, but received #{shapeB.inspect}!")
+      end
+
+      separation_axes = []
+
+      unless shapeA.instance_of?(Circle)
+        separation_axes.concat(get_polygon_separation_axes(shapeA.get_global_vertices))
+      end
+
+      unless shapeB.instance_of?(Circle)
+        separation_axes.concat(get_polygon_separation_axes(shapeB.get_global_vertices))
+      end
+
+      if shapeA.instance_of?(Circle) || shapeB.instance_of?(Circle)
+        axis = get_circle_separation_axis(shapeA, shapeB)
+        separation_axes.push(axis) if axis
+      end
+
+      separation_axes.map! { |v| v[0] < 0 ? v * -1 : v }
+      separation_axes.uniq
+    end
+
+    def self.project_onto_axis(shape, axis)
+      raise ArgumentError.new("Expected Actor, but received #{shape.inspect}!") unless shape.is_a?(Actor)
+      raise ArgumentError.new("Expected Vector, but received #{shape.inspect}!") unless axis.is_a?(Vector)
+
+      global_vertices = if shape.instance_of?(Circle)
+        global_tf = shape.get_global_transform
+        local_axis = global_tf.inverse * Vector[axis[0], axis[1], 0]
+        v = shape.get_point_at_angle(Math.atan2(local_axis[1], local_axis[0]))
+        [v, v * -1].map { |vertex| Transform.transform_point(global_tf, vertex) }
+      else
+        shape.get_global_vertices
+      end
+
+      projections = global_vertices.map { |vertex| vertex.inner_product(axis) }.sort
+      [projections.first, projections.last]
+    end
+
+    def self.projections_overlap?(a, b)
+      raise ArgumentError.new("Collision.projections_overlap?() expects arrays") unless a.is_a?(Array) && b.is_a?(Array)
+      raise ArgumentError.new("Collision.projections_overlap?() projection arrays must be length 2") unless a.length == 2 && b.length == 2
+
+      a.sort! if a[0] > a[1]
+      b.sort! if b[0] > b[1]
+      (a[0] <= b[1] && (b[1] <= a[1] || b[0] <= a[0])) || (b[0] <= a[1] && (a[0] <= b[0] || a[1] <= b[1]))
+    end
+  end
+end

data/lib/gosling/image_library.rb

@@ -0,0 +1,17 @@
+require 'singleton'
+
+module Gosling
+  class ImageLibrary
+    @@cache = {}
+
+    include Singleton
+
+    def self.get(filename)
+      raise ArgumentError.new("File not found: '#{filename}' in '#{Dir.pwd}'") unless File.exists?(filename)
+      unless @@cache.has_key?(filename)
+        @@cache[filename] = Gosu::Image.new(filename, tileable: true)
+      end
+      @@cache[filename]
+    end
+  end
+end

data/lib/gosling/inheritance_error.rb

@@ -0,0 +1,4 @@
+module Gosling
+  class InheritanceError < StandardError
+  end
+end