ehb_game_lib 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e2dd328f0f04eb106f0d5583057e3327c7e2ed15
+  data.tar.gz: 635f13624ba391b24b80a9403ae987db25d53d80
+SHA512:
+  metadata.gz: 95094355b73f2229f9c976314f12b2ae364f9640e05e32e289bf05731b2bd736382ed508af0876be125d9953dc4eead42e4b3ffda5f2ea503474a682e536334c
+  data.tar.gz: 763dd1a5d99ee835996d3faf697c7668c0bb95fbf6b612794116aa7e0dd5673a0f1907ac44fdb2ca0222896ac130a3a3f36ee88b7745ece671c1f4091ea21d13

data/lib/ehb_game_lib.rb

@@ -0,0 +1,24 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'chingu'
+require 'ehb_game_lib/version'
+require 'ehb_game_lib/globals'
+require 'ehb_game_lib/gfx'
+require 'ehb_game_lib/math/circle'
+require 'ehb_game_lib/math/line'
+require 'ehb_game_lib/math/line_segment'
+require 'ehb_game_lib/math/quadratic_equation'
+require 'ehb_game_lib/math/rectable_object'
+require 'ehb_game_lib/math/vector'
+require 'ehb_game_lib/math/intersection/circle_line'
+require 'ehb_game_lib/math/intersection/circle_line_segment'
+require 'ehb_game_lib/nes/all_colors_palette'
+require 'ehb_game_lib/nes/color'
+require 'ehb_game_lib/nes/palette'
+require 'ehb_game_lib/patches/chingu/basic_game_object'
+require 'ehb_game_lib/patches/gosu/font'
+require 'ehb_game_lib/traits/bounding_line_segment'
+require 'ehb_game_lib/utils/cursor'
+
+module EhbGameLib
+end

data/lib/ehb_game_lib/gfx.rb

@@ -0,0 +1,36 @@
+module EhbGameLib
+  class Gfx
+    class << self
+      def fill_circle(cx, cy, r, color, z)
+        x1 = 0
+        y1 = -r
+        circ = 2 * ::Math::PI * r
+        step = 360 / circ
+        step.step(45, step) do |a|
+          x2 = Gosu.offset_x(a, r)
+          y2 = Gosu.offset_y(a, r)
+          EhbGameLib::Globals.window.draw_quad \
+            cx + x1, cy + y1, color, cx + x2, cy + y2, color,
+            cx - x2, cy + y2, color, cx - x1, cy + y1, color, z
+          EhbGameLib::Globals.window.draw_quad \
+            cx - x1, cy - y1, color, cx - x2, cy - y2, color,
+            cx + x2, cy - y2, color, cx + x1, cy - y1, color, z
+          EhbGameLib::Globals.window.draw_quad \
+            cx + y1, cy + x1, color, cx + y2, cy + x2, color,
+            cx - y2, cy + x2, color, cx - y1, cy + x1, color, z
+          EhbGameLib::Globals.window.draw_quad \
+            cx - y1, cy - x1, color, cx - y2, cy - x2, color,
+            cx + y2, cy - x2, color, cx + y1, cy - x1, color, z
+          x1 = x2
+          y1 = y2
+        end
+        EhbGameLib::Globals.window.draw_quad \
+          cx + x1, cy + y1, color, cx - y1, cy - x1, color,
+          cx + y1, cy - x1, color, cx - x1, cy + y1, color, z
+        EhbGameLib::Globals.window.draw_quad \
+          cx - x1, cy - y1, color, cx + y1, cy + x1, color,
+          cx - y1, cy + x1, color, cx + x1, cy - y1, color, z
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/globals.rb

@@ -0,0 +1,10 @@
+module EhbGameLib
+  # No-global variables bridge to Chingu global variables.
+  class Globals
+    class << self
+      def window
+        $window
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/math/circle.rb

@@ -0,0 +1,38 @@
+module EhbGameLib
+  module Math
+    class Circle
+      attr_reader :center, :radius
+
+      def initialize(cx, cy, radius)
+        @center = Vector.new(cx, cy)
+        @radius = radius
+      end
+
+      def to_s
+        "C: #{center}, R: #{radius}"
+      end
+
+      def ys(x)
+        QuadraticEquation.new(1, -2 * cy, ys_c(x)).roots
+      end
+
+      private
+
+      def ys_c(x)
+        x.abs2 - 2 * x * cx + cx.abs2 + cy.abs2 - r.abs2
+      end
+
+      def cx
+        center.x
+      end
+
+      def cy
+        center.y
+      end
+
+      def r
+        radius
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/math/intersection/circle_line.rb

@@ -0,0 +1,76 @@
+module EhbGameLib
+  module Math
+    module Intersection
+      class CircleLine
+        def initialize(circle, line)
+          @circle = circle
+          @line = line
+        end
+
+        def intersection
+          @intersection ||= intersection_uncached
+        end
+
+        def intersect?
+          !intersection.empty?
+        end
+
+        private
+
+        def intersection_uncached
+          xs.flat_map do |x|
+            @circle.ys(x).map { |y| Vector.new(x, y) }
+          end
+        end
+
+        def xs
+          QuadraticEquation.new(xs_a, xs_b, xs_c).roots
+        end
+
+        def xs_a
+          b.abs2 + a.abs2
+        end
+
+        def xs_b
+          -2 * cx * b.abs2 + 2 * a * (c + cy * b)
+        end
+
+        def xs_c
+          xs_c0 + xs_c1
+        end
+
+        def xs_c0
+          b.abs2 * (cx.abs2 + cy.abs2 - r.abs2)
+        end
+
+        def xs_c1
+          c * (c + 2 * cy * b)
+        end
+
+        def a
+          @line.a
+        end
+
+        def b
+          @line.b
+        end
+
+        def c
+          @line.c
+        end
+
+        def r
+          @circle.radius
+        end
+
+        def cx
+          @circle.center.x
+        end
+
+        def cy
+          @circle.center.y
+        end
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/math/intersection/circle_line_segment.rb

@@ -0,0 +1,24 @@
+module EhbGameLib
+  module Math
+    module Intersection
+      class CircleLineSegment
+        def initialize(circle, line_segment)
+          @circle = circle
+          @line_segment = line_segment
+        end
+
+        def intersection
+          circle_line.intersection.select do |point|
+            @line_segment.point_in_area?(point)
+          end
+        end
+
+        private
+
+        def circle_line
+          @circle_line ||= CircleLine.new(@circle, @line_segment.line)
+        end
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/math/line.rb

@@ -0,0 +1,27 @@
+module EhbGameLib
+  module Math
+    class Line
+      class << self
+        def new_by_coordinates(x0, y0, x1, y1)
+          new(
+            y1 - y0,
+            x0 - x1,
+            y0 * x1 + x0 * y0 - x0 * y1 - y0 * x0
+          )
+        end
+      end
+
+      attr_reader :a, :b, :c
+
+      def initialize(a, b, c)
+        @a = a
+        @b = b
+        @c = c
+      end
+
+      def point_in?(vector)
+        (vector.x * a + vector.y * b + c).zero?
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/math/line_segment.rb

@@ -0,0 +1,35 @@
+module EhbGameLib
+  module Math
+    class LineSegment
+      attr_reader :p0, :p1
+
+      def initialize(x0, y0, x1, y1)
+        @p0 = Vector.new(x0, y0)
+        @p1 = Vector.new(x1, y1)
+      end
+
+      def line
+        @line ||= Line.new_by_coordinates(p0.x, p0.y, p1.x, p1.y)
+      end
+
+      def point_in_area?(vector)
+        x_interval.include?(vector.x) && y_interval.include?(vector.y)
+      end
+
+      private
+
+      def x_interval
+        @x_interval ||= interval(p0.x, p1.x)
+      end
+
+      def y_interval
+        @y_interval ||= interval(p0.y, p1.y)
+      end
+
+      def interval(c0, c1)
+        i = [c0, c1].sort
+        (i[0]..i[1])
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/math/quadratic_equation.rb

@@ -0,0 +1,28 @@
+module EhbGameLib
+  module Math
+    class QuadraticEquation
+      attr_reader :a, :b, :c
+
+      def initialize(a, b, c)
+        @a = a
+        @b = b
+        @c = c
+      end
+
+      def roots
+        return [root(1), root(-1)] if delta > 0.0
+        return [root(1)] if delta == 0.0
+        []
+      end
+
+      def delta
+        @delta ||= b**2 - 4 * a * c
+      end
+
+      def root(signal)
+        signal = signal < 0 ? -1 : 1
+        (-b + signal * ::Math.sqrt(delta)) / (2 * a)
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/math/rectable_object.rb

@@ -0,0 +1,98 @@
+module EhbGameLib
+  module Math
+    module RectableObject
+      H_AXIS = { name: :ax, coord: :x, size: :width, floor: :left, mean: :center,
+                 ceil: :right }.freeze
+      V_AXIS = { name: :ay, coord: :y, size: :height, floor: :top, mean: :middle,
+                 ceil: :bottom }.freeze
+
+      [H_AXIS, V_AXIS].each do |a|
+        class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+          def #{a[:name]}
+            @#{a[:name]} ||= Axis.new(
+              -> { #{a[:coord]} },
+              -> (v) { self.#{a[:coord]} = v },
+              -> { #{a[:size]} }
+            )
+          end
+        RUBY_EVAL
+
+        %i[floor mean ceil].each do |m|
+          class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+            def #{a[m]}
+              #{a[:name]}.#{m}
+            end
+
+            def #{a[m]}=(v)
+              #{a[:name]}.#{m} = v
+            end
+          RUBY_EVAL
+        end
+      end
+
+      def rect
+        ::Chingu::Rect.new(left, top, width, height)
+      end
+
+      class Axis
+        attr_accessor :anchor
+
+        def initialize(coord_get, coord_set, size_get)
+          @coord_get = coord_get
+          @coord_set = coord_set
+          @size_get = size_get
+        end
+
+        def coord
+          @coord_get.call
+        end
+
+        def coord=(v)
+          @coord_set.call(v)
+        end
+
+        def size
+          @size_get.call
+        end
+
+        %w[floor mean ceil].each do |m|
+          class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+            def #{m}
+              coord + #{m}_delta
+            end
+
+            def #{m}=(v)
+              self.coord = v - #{m}_delta
+            end
+          RUBY_EVAL
+        end
+
+        private
+
+        def floor_delta
+          case anchor
+          when :mean then - size / 2
+          when :ceil then - size
+          else 0
+          end
+        end
+
+        def mean_delta
+          case anchor
+          when :mean then 0
+          when :ceil then - size / 2
+          else size / 2
+          end
+        end
+
+        def ceil_delta
+          case anchor
+          when :mean then size / 2
+          when :ceil then 0
+          else size
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/math/vector.rb

@@ -0,0 +1,52 @@
+module EhbGameLib
+  module Math
+    class Vector
+      attr_reader :x, :y
+
+      def initialize(x, y)
+        @x = x
+        @y = y
+      end
+
+      def to_s
+        "#{x}, #{y}"
+      end
+
+      def equal?(other)
+        x == other.x && y == other.y
+      end
+
+      def ==(other)
+        equal?(other)
+      end
+
+      def +(other)
+        self.class.new(x + other.x, y + other.y)
+      end
+
+      def -(other)
+        self.class.new(x - other.x, y - other.y)
+      end
+
+      def *(other)
+        self.class.new(x * other, y * other)
+      end
+
+      def /(other)
+        self.class.new(x / other, y / other)
+      end
+
+      def dot(other)
+        x * other.x + y * other.y
+      end
+
+      def length
+        @length ||= ::Math.sqrt(x * x + y * y)
+      end
+
+      def normalize
+        self / length
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/nes/all_colors_palette.rb

@@ -0,0 +1,29 @@
+module EhbGameLib
+  module Nes
+    class AllColorsPalette
+      def initialize(pal_file)
+        @colors = []
+        File.open(pal_file) do |file|
+          while (b = file.read(3))
+            b = b.bytes.to_a
+            @colors << Gosu::Color.rgba(b[0], b[1], b[2], 0xFF)
+          end
+        end
+        @colors.freeze
+      end
+
+      def gosu_color(i)
+        @colors[i]
+      end
+
+      def draw(x, y)
+        s = 32
+        @colors.each_with_index do |c, i|
+          cx = x + (i % 16) * s
+          cy = y + (i / 16) * s
+          Gosu.draw_rect(cx, cy, s, s, c)
+        end
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/nes/color.rb

@@ -0,0 +1,21 @@
+module EhbGameLib
+  module Nes
+    class Color
+      attr_accessor :color_index
+
+      BLACK = 0x0F
+      YELLOW = 0x28
+      RED = 0x05
+      WHITE = 0x30
+
+      def initialize(all_colors, color_index)
+        @all_colors = all_colors
+        @color_index = color_index
+      end
+
+      def gosu_color
+        @all_colors.gosu_color(color_index)
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/nes/palette.rb

@@ -0,0 +1,19 @@
+module EhbGameLib
+  module Nes
+    class Palette
+      COLORS_COUNT = 16
+
+      def initialize(all_colors)
+        @colors = Array.new(COLORS_COUNT) { |i| ::EhbGameLib::Nes::Color.new(all_colors, i) }
+      end
+
+      def [](index)
+        @colors[index % @colors.length]
+      end
+
+      def []=(index, value)
+        @colors[index % @colors.length].color_index = value
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/patches/chingu/basic_game_object.rb

@@ -0,0 +1,22 @@
+module EhbGameLib
+  module Patches
+    module Chingu
+      module BasicGameObject
+        def destroy
+          super
+          @alive = false
+        end
+
+        def alive?
+          @alive.nil? ? true : false
+        end
+      end
+    end
+  end
+end
+
+unless ::Chingu::BasicGameObject.included_modules.include?(
+  ::EhbGameLib::Patches::Chingu::BasicGameObject
+)
+  ::Chingu::BasicGameObject.prepend(::EhbGameLib::Patches::Chingu::BasicGameObject)
+end

data/lib/ehb_game_lib/patches/gosu/font.rb

@@ -0,0 +1,29 @@
+module EhbGameLib
+  module Patches
+    module Gosu
+      module Font
+        # Draw text with line breaks.
+        def drawm(text, x, y, z, scale_x = 1, scale_y = 1, color = 0xff_ffffff, mode = :default)
+          text.each_line do |line|
+            draw(line.delete("\n"), x, y, z, scale_x, scale_y, color, mode)
+            y += height
+          end
+        end
+
+        def text_height(text)
+          text.lines.count * height
+        end
+
+        def text_width(text)
+          text.lines.map { |l| super(l) }.max
+        end
+      end
+    end
+  end
+end
+
+unless ::Gosu::Font.included_modules.include?(
+  ::EhbGameLib::Patches::Gosu::Font
+)
+  ::Gosu::Font.prepend(::EhbGameLib::Patches::Gosu::Font)
+end

data/lib/ehb_game_lib/traits/bounding_line_segment.rb

@@ -0,0 +1,56 @@
+module EhbGameLib
+  module Traits
+    # Interface required:
+    # attr_reader :last_x, :last_y
+    module BoundingLineSegment
+      def nearest_circle_collision(klasses)
+        return [nil, nil] unless line_segment?
+        min_obj = min_p = min_dist = nil
+        each_circle_collision(klasses) do |object, p|
+          dist = Gosu.distance(last_x, last_y, p.x, p.y)
+          next unless min_dist.nil? || dist < min_dist
+          min_dist = dist
+          min_obj = object
+          min_p = p
+        end
+        [min_obj, min_p]
+      end
+
+      private
+
+      def each_circle_collision(klasses)
+        each_game_object(klasses) do |object|
+          object_intersection(object).intersection.each do |p|
+            yield(object, p)
+          end
+        end
+      end
+
+      def each_game_object(klasses)
+        Array(klasses).each do |klass|
+          (klass.respond_to?(:all) ? klass.all : Array(klass)).each do |object|
+            yield(object)
+          end
+        end
+      end
+
+      def line_segment?
+        last_x.nil? || last_y.nil? || x.nil? || y.nil? ? false : true
+      end
+
+      def line_segment
+        ::EhbGameLib::Math::LineSegment.new(last_x, last_y, x, y)
+      end
+
+      def object_circle(object)
+        ::EhbGameLib::Math::Circle.new(object.x, object.y, object.radius)
+      end
+
+      def object_intersection(object)
+        ::EhbGameLib::Math::Intersection::CircleLineSegment.new(
+          object_circle(object), line_segment
+        )
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/utils/cursor.rb

@@ -0,0 +1,58 @@
+module EhbGameLib
+  module Utils
+    class Cursor
+      def initialize(set)
+        @set = set.to_a
+        @index = nil
+      end
+
+      delegate :count, :each, :inject, :map, to: :set
+
+      def select_last
+        self.index = @set.length - 1
+      end
+
+      def next_element
+        next_previous_element(1)
+      end
+
+      def previous_element
+        next_previous_element(-1)
+      end
+
+      def current
+        index.nil? ? nil : @set[index]
+      end
+
+      def index
+        fix_index
+        @index
+      end
+
+      private
+
+      def fix_index
+        if @set.empty?
+          @index = nil
+        elsif @index.nil?
+          @index = 0
+        elsif @index >= @set.count
+          @index = @set.count - 1
+        elsif @index < 0
+          @index = 0
+        end
+      end
+
+      def index=(value)
+        @index = value
+        fix_index
+      end
+
+      attr_reader :set
+
+      def next_previous_element(steps)
+        self.index = (index + steps) % @set.count
+      end
+    end
+  end
+end

data/lib/ehb_game_lib/version.rb

@@ -0,0 +1,3 @@
+module EhbGameLib
+  VERSION = '0.0.5'.freeze
+end

data/test/lib/ehb_game_lib/math/circle_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+module EhbGameLib
+  module Math
+    class CircleTest < Test::Unit::TestCase
+      test 'ys' do
+        circle = Circle.new(0, 0, 1)
+        assert_equal [], circle.ys(-1.1)
+        assert_equal [0], circle.ys(-1)
+        assert_equal [1, -1], circle.ys(0)
+        assert_equal [0], circle.ys(1)
+        assert_equal [], circle.ys(1.1)
+      end
+    end
+  end
+end

data/test/lib/ehb_game_lib/math/intersection/circle_line_segment_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+module EhbGameLib
+  module Math
+    module Intersection
+      class CircleLineSegmentTest < Test::Unit::TestCase
+        test 'intersect' do
+          @circle = Circle.new(0, 0, 1)
+          assert_equal [], intersection(-1.1, -1, -1.1, 1)
+          assert_equal [Vector.new(-1.0, 0)], intersection(-1.0, -1, -1.0, 1)
+          assert_equal [Vector.new(0, -1)], intersection(0, -1, 0, 0)
+          assert_equal [Vector.new(0, 1), Vector.new(0, -1)], intersection(0, -1, 0, 1)
+          assert_equal [Vector.new(1, 0), Vector.new(-1, 0)], intersection(-2, 0, 2, 0)
+
+          @circle = Circle.new(320, 120, 12)
+          assert_equal [Vector.new(320, 132), Vector.new(320, 108)],
+                       intersection(320.0, 215.0, 320.0, -4785.0)
+
+          @circle = Circle.new(320, 240, 12)
+          assert_equal [Vector.new(332, 240), Vector.new(308, 240)],
+                       intersection(100, 240, 500, 240)
+          assert_equal [Vector.new(332, 240), Vector.new(308, 240)],
+                       intersection(455.0, 240, -4545.0, 240)
+          assert_equal [Vector.new(332, 240), Vector.new(308, 240)],
+                       intersection(455.0, 240.00000000012759, -4545.0, 239.9999999235764)
+        end
+
+        private
+
+        def intersection(seg_x0, seg_y0, seg_x1, seg_y1)
+          CircleLineSegment.new(
+            @circle,
+            ::EhbGameLib::Math::LineSegment.new(seg_x0, seg_y0, seg_x1, seg_y1)
+          ).intersection
+        end
+      end
+    end
+  end
+end

data/test/lib/ehb_game_lib/math/intersection/circle_line_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+module EhbGameLib
+  module Math
+    module Intersection
+      class CircleLineTest < Test::Unit::TestCase
+        test 'intersect' do
+          @circle = Circle.new(0, 0, 1)
+          assert_equal [], intersection(-1.1, -1, -1.1, 1)
+          assert_equal [Vector.new(-1.0, 0)], intersection(-1.0, -1, -1.0, 1)
+          assert_equal [Vector.new(0, 1), Vector.new(0, -1)], intersection(0, -1, 0, 0)
+          assert_equal [Vector.new(0, 1), Vector.new(0, -1)], intersection(0, -1, 0, 1)
+          assert_equal [Vector.new(1, 0), Vector.new(-1, 0)], intersection(-2, 0, 2, 0)
+
+          @circle = Circle.new(320, 120, 12)
+          assert_equal [Vector.new(320, 132), Vector.new(320, 108)],
+                       intersection(320.0, 215.0, 320.0, -4785.0)
+
+          @circle = Circle.new(320, 240, 12)
+          assert_equal [Vector.new(332, 240), Vector.new(308, 240)],
+                       intersection(100, 240, 500, 240)
+          assert_equal [Vector.new(332, 240), Vector.new(308, 240)],
+                       intersection(455.0, 240, -4545.0, 240)
+          assert_equal [Vector.new(332, 240), Vector.new(308, 240)],
+                       intersection(455.0, 240.00000000012759, -4545.0, 239.9999999235764)
+        end
+
+        private
+
+        def intersection(seg_x0, seg_y0, seg_x1, seg_y1)
+          CircleLine.new(@circle, line(seg_x0, seg_y0, seg_x1, seg_y1)).intersection
+        end
+
+        def line(seg_x0, seg_y0, seg_x1, seg_y1)
+          ::EhbGameLib::Math::Line.new_by_coordinates(seg_x0, seg_y0, seg_x1, seg_y1)
+        end
+      end
+    end
+  end
+end

data/test/lib/ehb_game_lib/math/line_segment_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+module EhbGameLib
+  module Math
+    class LineSegmentTest < Test::Unit::TestCase
+      test 'point_in_area?' do
+        line = LineSegment.new(-1, -1, -1, 1)
+        assert_equal true, line.point_in_area?(Vector.new(-1, -1))
+        assert_equal true, line.point_in_area?(Vector.new(-1, 1))
+        assert_equal true, line.point_in_area?(Vector.new(-1, 0))
+        assert_equal false, line.point_in_area?(Vector.new(-1, 2))
+        assert_equal false, line.point_in_area?(Vector.new(-1.1, 2))
+
+        line = LineSegment.new(-1, -1, 1, -1)
+        assert_equal true, line.point_in_area?(Vector.new(-1, -1))
+        assert_equal true, line.point_in_area?(Vector.new(1, -1))
+        assert_equal true, line.point_in_area?(Vector.new(0, -1))
+        assert_equal false, line.point_in_area?(Vector.new(2, -1))
+        assert_equal false, line.point_in_area?(Vector.new(2, -1.1))
+
+        line = LineSegment.new(455.0, 240.00000000012759, -4545.0, 239.9999999235764)
+        assert_equal true, line.point_in_area?(Vector.new(332.0, 240.0))
+        assert_equal true, line.point_in_area?(Vector.new(308.0, 240.0))
+      end
+    end
+  end
+end

data/test/lib/ehb_game_lib/math/line_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+module EhbGameLib
+  module Math
+    class LineTest < Test::Unit::TestCase
+      test 'new_by_coordinates' do
+        l = Line.new_by_coordinates(100, 240, 500, 240)
+        assert_equal(0, l.a)
+        assert_equal(-400, l.b)
+        assert_equal(96_000, l.c)
+
+        l = Line.new_by_coordinates(455.0, 240, -4545.0, 240)
+        assert_equal(0, l.a)
+        assert_equal(5000, l.b)
+        assert_equal(-1_200_000, l.c)
+
+        l = Line.new_by_coordinates(455.0, 240.00000000012759, -4545.0, 239.9999999235764)
+        assert_equal(-7.65511742883973e-08, l.a)
+        assert_equal(5000, l.b)
+        assert_equal(-1_199_999.9999658072, l.c)
+      end
+
+      test 'point_in?' do
+        line = Line.new_by_coordinates(-1, -1, -1, 1)
+        assert_equal true, line.point_in?(Vector.new(-1, -1))
+        assert_equal true, line.point_in?(Vector.new(-1, 1))
+        assert_equal true, line.point_in?(Vector.new(-1, 0))
+        assert_equal true, line.point_in?(Vector.new(-1, 2))
+        assert_equal false, line.point_in?(Vector.new(-1.1, 2))
+
+        line = Line.new_by_coordinates(-1, -1, 1, -1)
+        assert_equal true, line.point_in?(Vector.new(-1, -1))
+        assert_equal true, line.point_in?(Vector.new(1, -1))
+        assert_equal true, line.point_in?(Vector.new(0, -1))
+        assert_equal true, line.point_in?(Vector.new(2, -1))
+        assert_equal false, line.point_in?(Vector.new(2, -1.1))
+      end
+    end
+  end
+end

data/test/lib/ehb_game_lib/math/quadratic_equation_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+module EhbGameLib
+  module Math
+    class QuadraticEquationTest < Test::Unit::TestCase
+      test 'delta' do
+        assert_equal(-8, QuadraticEquation.new(1, 2, 3).delta)
+        assert_equal(0, QuadraticEquation.new(1, 8, 16).delta)
+        assert_equal(16, QuadraticEquation.new(1, 2, -3).delta)
+      end
+
+      test 'roots' do
+        assert_equal([], QuadraticEquation.new(1, 2, 3).roots)
+        assert_equal([-4], QuadraticEquation.new(1, 8, 16).roots)
+        assert_equal([1, -3], QuadraticEquation.new(1, 2, -3).roots)
+      end
+    end
+  end
+end

data/test/lib/ehb_game_lib/math/rectable_object_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+
+module EhbGameLib
+  module Math
+    class RectableObjectTest < Test::Unit::TestCase
+      class Stub
+        include ::EhbGameLib::Math::RectableObject
+
+        attr_accessor :x, :y
+
+        def width
+          10
+        end
+
+        def height
+          10
+        end
+      end
+
+      setup do
+        @o = Stub.new
+      end
+
+      test 'x anchor' do
+        @o.x = 20
+        assert_x_values(20, 20, 25, 30)
+
+        @o.ax.anchor = :mean
+        assert_x_values(20, 15, 20, 25)
+
+        @o.ax.anchor = :ceil
+        assert_x_values(20, 10, 15, 20)
+      end
+
+      test 'y anchor' do
+        @o.y = 20
+        assert_y_values(20, 20, 25, 30)
+
+        @o.ay.anchor = :mean
+        assert_y_values(20, 15, 20, 25)
+
+        @o.ay.anchor = :ceil
+        assert_y_values(20, 10, 15, 20)
+      end
+
+      test 'left set' do
+        @o.ax.anchor = :floor
+        @o.left = 20
+        assert_x_values(20, 20, 25, 30)
+
+        @o.ax.anchor = :mean
+        @o.left = 30
+        assert_x_values(35, 30, 35, 40)
+
+        @o.ax.anchor = :ceil
+        @o.left = 40
+        assert_x_values(50, 40, 45, 50)
+      end
+
+      private
+
+      def assert_x_values(x, left, center, right)
+        assert_equal x, @o.x, 'x'
+        assert_equal left, @o.left, 'left'
+        assert_equal center, @o.center, 'center'
+        assert_equal right, @o.right, 'right'
+      end
+
+      def assert_y_values(y, top, middle, bottom)
+        assert_equal y, @o.y, 'y'
+        assert_equal top, @o.top, 'top'
+        assert_equal middle, @o.middle, 'middle'
+        assert_equal bottom, @o.bottom, 'bottom'
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'ehb_game_lib'
+require 'test/unit'

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: ehb_game_lib
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Eduardo H. Bogoni
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: chingu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: gosu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.42.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.42.0
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- eduardobogoni@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ehb_game_lib.rb
+- lib/ehb_game_lib/gfx.rb
+- lib/ehb_game_lib/globals.rb
+- lib/ehb_game_lib/math/circle.rb
+- lib/ehb_game_lib/math/intersection/circle_line.rb
+- lib/ehb_game_lib/math/intersection/circle_line_segment.rb
+- lib/ehb_game_lib/math/line.rb
+- lib/ehb_game_lib/math/line_segment.rb
+- lib/ehb_game_lib/math/quadratic_equation.rb
+- lib/ehb_game_lib/math/rectable_object.rb
+- lib/ehb_game_lib/math/vector.rb
+- lib/ehb_game_lib/nes/all_colors_palette.rb
+- lib/ehb_game_lib/nes/color.rb
+- lib/ehb_game_lib/nes/palette.rb
+- lib/ehb_game_lib/patches/chingu/basic_game_object.rb
+- lib/ehb_game_lib/patches/gosu/font.rb
+- lib/ehb_game_lib/traits/bounding_line_segment.rb
+- lib/ehb_game_lib/utils/cursor.rb
+- lib/ehb_game_lib/version.rb
+- test/lib/ehb_game_lib/math/circle_test.rb
+- test/lib/ehb_game_lib/math/intersection/circle_line_segment_test.rb
+- test/lib/ehb_game_lib/math/intersection/circle_line_test.rb
+- test/lib/ehb_game_lib/math/line_segment_test.rb
+- test/lib/ehb_game_lib/math/line_test.rb
+- test/lib/ehb_game_lib/math/quadratic_equation_test.rb
+- test/lib/ehb_game_lib/math/rectable_object_test.rb
+- test/test_helper.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: EHB's game library for Ruby
+test_files: []