dxopal 1.0.0

data/opal/dxopal/sprite/collision_area.rb

@@ -0,0 +1,288 @@
+require 'dxopal/sprite/collision_checker'
+
+module DXOpal
+  class Sprite
+    # Methods of Sprite related to collision checking
+    module CollisionArea
+      class Base
+        # Sprite corresponds to this hitarea
+        attr_reader :sprite
+
+        # Return a string like "Point", "Rect", etc.
+        # Used for type checking in `collides?` (because Opal's Class#is_a? is not very fast)
+        def type
+          raise "override me"
+        end
+
+        def absolute(poss)
+          ox = @sprite.x
+          oy = @sprite.y
+          return poss.map{|(x, y)| [x+ox, y+oy]} if !@sprite.collision_sync
+          angle = @sprite.angle
+          cx = @sprite.center_x
+          cy = @sprite.center_y
+          sx = @sprite.scale_x
+          sy = @sprite.scale_y
+
+          ret = []
+          %x{
+            var rad = Math.PI / 180.0 * angle;
+            var sin = Math.sin(rad);
+            var cos = Math.cos(rad);
+            poss.forEach(function(pos){
+              var x = pos[0], y = pos[1];
+              x2 = (x - cx) * sx * cos - (y - cy) * sy * sin + cx + ox;
+              y2 = (x - cx) * sx * sin + (y - cy) * sy * cos + cy + oy;
+              ret.push([x2, y2]);
+            });
+          }
+          return ret
+        end
+
+        def absolute1(pos)
+          absolute([pos]).first
+        end
+        
+        def transback(poss, sprite)
+          return poss if !sprite.collision_sync
+          angle = sprite.angle
+          cx = sprite.x + sprite.center_x
+          cy = sprite.y + sprite.center_y
+          sx = sprite.scale_x
+          sy = sprite.scale_y
+
+          ret = []
+          %x{
+            var rad = Math.PI / 180.0 * -angle;
+            var sin = Math.sin(rad);
+            var cos = Math.cos(rad);
+            poss.forEach(function(pos){
+              var x = pos[0], y = pos[1];
+              x2 = ((x - cx) * cos - (y - cy) * sin) / sx + cx;
+              y2 = ((x - cx) * sin + (y - cy) * cos) / sy + cy;
+              ret.push([x2, y2]);
+            });
+          }
+          return ret
+        end
+
+        def transback1(pos, sprite)
+          transback([pos], sprite).first
+        end
+
+        def aabb(poss)
+          x1 = y1 =  Float::INFINITY
+          x2 = y2 = -Float::INFINITY
+          %x{
+            for(var i=0; i<poss.length; i++) {
+              if (poss[i][0] < x1) x1 = poss[i][0];
+              if (poss[i][1] < y1) y1 = poss[i][1];
+              if (poss[i][0] > x2) x2 = poss[i][0];
+              if (poss[i][1] > y2) y2 = poss[i][1];
+            }
+          }
+          return [[x1, y1], [x2, y2]]
+        end
+      end
+
+      class Point < Base
+        def initialize(sprite, x, y)
+          @sprite, @x, @y = sprite, x, y
+          super()
+        end
+
+        def type; :Point; end
+
+        def collides?(other)
+          case other.type
+          when :Point
+            self.absolute_pos == other.absolute_pos
+          when :Circle
+            x, y = *transback1(self.absolute_pos, other.sprite)
+            cx, cy = *other.absolute_norot_pos
+            `Opal.DXOpal.CCk.check_point_circle(x, y, cx, cy, #{other.r})`
+          when :Rect
+            x, y = *transback1(self.absolute_pos, other.sprite)
+            ((x1, y1), (x2, y2)) = *other.absolute_norot_poss
+            `Opal.DXOpal.CCk.check_point_straight_rect(x, y, x1, y1, x2, y2)`
+          when :Triangle
+            x, y = *absolute_pos
+            (x1, y1), (x2, y2), (x3, y3) = *other.absolute_poss
+            `Opal.DXOpal.CCk.check_point_triangle(x, y, x1, y1, x2, y2, x3, y3)`
+          else raise
+          end
+        end
+
+        # Return [x, y]
+        def absolute_pos
+          absolute1([@x, @y])
+        end
+      end
+
+      class Circle < Base
+        def initialize(sprite, x, y, r)
+          @sprite, @x, @y, @r = sprite, x, y, r
+          super()
+        end
+        attr_reader :r
+
+        def type; :Circle; end
+
+        # Return true if this is not an ellipsis
+        def circle?
+          @sprite.scale_x == @sprite.scale_y
+        end
+
+        def collides?(other)
+          case other.type
+          when :Point
+            other.collides?(self)
+          when :Circle
+            collides_circle?(other)
+          when :Rect
+            cx, cy = *self.absolute_norot_pos
+            (x1, y1), (x2, y2), (x3, y3), (x4, y4) = *transback(other.absolute_poss, @sprite)
+            `Opal.DXOpal.CCk.check_circle_tilted_rect(cx, cy, #{@r}, x1, y1, x2, y2, x3, y3, x4, y4)`
+          when :Triangle
+            cx, cy = *self.absolute_norot_pos
+            (x1, y1), (x2, y2), (x3, y3) = *transback(other.absolute_poss, @sprite)
+            `Opal.DXOpal.CCk.check_circle_triangle(cx, cy, #{@r}, x1, y1, x2, y2, x3, y3)`
+          else raise
+          end
+        end
+
+        # Return [x, y]
+        def absolute_pos
+          absolute1([@x, @y])
+        end
+
+        def absolute_norot_pos
+          [@x + @sprite.x, @y + @sprite.y]
+        end
+
+        private
+
+        def collides_circle?(other)
+          x1, y1 = *self.absolute_pos
+          r1 = @r
+          x2, y2 = *other.absolute_pos
+          r2 = other.r
+          if self.circle? && other.circle?
+            `Opal.DXOpal.CCk.check_circle_circle(x1, y1, #{@r}, x2, y2, #{other.r})`
+          else
+            if @sprite.collision_sync
+              scale_x1 = @sprite.scale_x
+              scale_y1 = @sprite.scale_y
+              angle1 = @sprite.angle * Math::PI / 180
+            else
+              scale_x1 = 1
+              scale_y1 = 1
+              angle1 = 0
+            end
+            if other.sprite.collision_sync
+              scale_x2 = other.sprite.scale_x
+              scale_y2 = other.sprite.scale_y
+              angle2 = other.sprite.angle * Math::PI / 180
+            else
+              scale_x2 = 1
+              scale_y2 = 1
+              angle2 = 0
+            end
+            ret = nil
+            %x{
+              var e1 = {
+                fRad_X: scale_x1 * r1,
+                fRad_Y: scale_y1 * r1,
+                fAngle: angle1,
+                fCx: x1,
+                fCy: y1,
+              }
+              var e2 = {
+                fRad_X: scale_x2 * r2,
+                fRad_Y: scale_y2 * r2,
+                fAngle: angle2,
+                fCx: x2,
+                fCy: y2,
+              }
+              ret = Opal.DXOpal.CCk.check_ellipse_ellipse(e1, e2);
+            }
+            ret
+          end
+        end
+      end
+
+      class Rect < Base
+        def initialize(sprite, x1, y1, x2, y2)
+          @sprite, @x1, @y1, @x2, @y2 = sprite, x1, y1, x2, y2
+          @poss = [[x1, y1], [x2, y1], [x2, y2], [x1, y2]]
+          super()
+        end
+
+        def type; :Rect; end
+
+        def inspect
+          "#<CollisionArea::Rect(#{@x1}, #{@y1}, #{@x2}, #{@y2})>"
+        end
+
+        def collides?(other)
+          case other.type
+          when :Point, :Circle
+            other.collides?(self)
+          when :Rect
+            ((ox1, oy1), (ox2, oy2)) = self.absolute_norot_poss
+            ((dx1, dy1), (dx2, dy2)) = aabb(transback(other.absolute_poss, @sprite))
+            return false unless `Opal.DXOpal.CCk.check_rect_rect(ox1, oy1, ox2, oy2, dx1, dy1, dx2, dy2)`
+
+            ((ox1, oy1), (ox2, oy2)) = other.absolute_norot_poss
+            ((dx1, dy1), (dx2, dy2)) = aabb(transback(self.absolute_poss, other.sprite))
+            return false unless `Opal.DXOpal.CCk.check_rect_rect(ox1, oy1, ox2, oy2, dx1, dy1, dx2, dy2)`
+            true
+          when :Triangle
+            (ox1, oy1), (ox2, oy2), (ox3, oy3), (ox4, oy4) = *self.absolute_poss
+            (dx1, dy1), (dx2, dy2), (dx3, dy3) = *other.absolute_poss
+            `Opal.DXOpal.CCk.check_tilted_rect_triangle(ox1, oy1, ox2, oy2, ox3, oy3, ox4, oy4,
+                                                        dx1, dy1, dx2, dy2, dx3, dy3)`
+
+          else raise
+          end
+        end
+
+        def absolute_poss
+          absolute(@poss)
+        end
+
+        def absolute_norot_poss
+          [[@x1 + @sprite.x, @y1 + @sprite.y],
+           [@x2 + @sprite.x, @y2 + @sprite.y]]
+        end
+      end
+
+      class Triangle < Base
+        def initialize(sprite, x1, y1, x2, y2, x3, y3)
+          @sprite = sprite
+          @poss = [[x1, y1], [x2, y2], [x3, y3]]
+          super()
+        end
+
+        def type; :Triangle; end
+
+        def collides?(other)
+          case other.type
+          when :Point, :Circle, :Rect
+            other.collides?(self)
+          when :Triangle
+            (ox1, oy1), (ox2, oy2), (ox3, oy3) = *self.absolute_poss
+            (dx1, dy1), (dx2, dy2), (dx3, dy3) = *other.absolute_poss
+            `Opal.DXOpal.CCk.check_triangle_triangle(ox1, oy1, ox2, oy2, ox3, oy3,
+                                                     dx1, dy1, dx2, dy2, dx3, dy3)`
+          else raise
+          end
+        end
+
+        def absolute_poss
+          absolute(@poss)
+        end
+      end
+    end
+  end
+end

data/opal/dxopal/sprite/collision_check.rb

@@ -0,0 +1,106 @@
+require 'dxopal/sprite/collision_area'
+
+module DXOpal
+  class Sprite
+    # Methods of Sprite related to collision checking
+    module CollisionCheck
+      module ClassMethods
+        # TODO: implement arguments `shot` and `hit`
+        def check(offences, defences, shot=:shot, hit=:hit)
+          if offences.equal?(defences)
+            # any-vs-any mode
+            sprites = offences.select{|x| x.is_a?(Sprite)}
+            n = sprites.length
+            %x{
+              for (var i=0; i<n; i++) {
+                for (var j=i+1; j<n; j++) {
+                  if (sprites[i]['$==='](sprites[j])) {
+                    sprites[i]['$hit']();
+                    sprites[j]['$hit']();
+                  }
+                }
+              }
+            }
+          else
+            # offence-vs-defence mode
+            %x{
+              for (var i=0; i<offences.length; i++) {
+                for (var j=0; j<defences.length; j++) {
+                  if (offences[i]['$==='](defences[j])) {
+                    offences[i]['$shot'](defences[j]);
+                    defences[j]['$hit'](offences[i]);
+                  }
+                }
+              }
+            }
+          end
+        end
+      end
+
+      # Default callback methods of `Sprite.check`
+      def shot(other); end
+      def hit(other); end
+
+      # Called from Sprites#initialize
+      def _init_collision_info(image)
+        @collision ||= nil
+        @collision_enable = true if @collision_enable.nil?
+        @collision_sync = true if @collision_sync.nil?
+        @_collision_area ||=
+          if image
+            CollisionArea::Rect.new(self, 0, 0, image.width, image.height)
+          else
+            nil
+          end
+      end
+      # Whether collision is detected for this object (default: true)
+      attr_accessor :collision_enable
+      # Whether collision areas synchronize with .scale and .angle (default: true)
+      # Setting this to false may improve collision detection performance
+      attr_accessor :collision_sync
+      # Return an array represents its collision area
+      attr_reader :collision
+      # (internal) Return a CollisionArea object
+      attr_reader :_collision_area
+
+      # Set collision area of this sprite
+      def collision=(area_spec)
+        @_collision_area =
+          case area_spec.length
+          when 2 then CollisionArea::Point.new(self, *area_spec)
+          when 3 then CollisionArea::Circle.new(self, *area_spec)
+          when 4 then CollisionArea::Rect.new(self, *area_spec)
+          when 6 then CollisionArea::Triangle.new(self, *area_spec)
+          else 
+            raise "Inlivad area data: #{x.inspect}"
+          end
+        @collision = area_spec
+      end
+
+      # Return true when this sprite collides with other sprite(s)
+      def ===(sprite_or_sprites)
+        return check(sprite_or_sprites).any?
+      end
+
+      # Return list of sprites collides with this sprite
+      def check(sprite_or_sprites)
+        sprites = Array(sprite_or_sprites)
+        return sprites.select{|sprite| _collides?(sprite)}
+      end
+
+      # Return true when this sprite collides with `sprite`
+      def _collides?(sprite)
+        if @_collision_area.nil? || sprite._collision_area.nil?
+          raise "Sprite image not set"
+        end
+        return false if !self._collidable? || !sprite._collidable?
+        return @_collision_area.collides?(sprite._collision_area)
+      end
+
+      # Return true when this sprite may collide
+      def _collidable?
+        return !@vanished && @collision_enable
+      end
+    end
+  end
+end

data/opal/dxopal/sprite/collision_checker.rb

@@ -0,0 +1,169 @@
+# vim: set ft=javascript:
+%x{ (function(){
+
+var intersect = function(x1, y1, x2, y2, x3, y3, x4, y4){
+  return ((x1 - x2) * (y3 - y1) + (y1 - y2) * (x1 - x3)) *
+         ((x1 - x2) * (y4 - y1) + (y1 - y2) * (x1 - x4));
+};
+
+var check_line_line = function(x1, y1, x2, y2, x3, y3, x4, y4){
+  return !((((x1 - x2) * (y3 - y1) + (y1 - y2) * (x1 - x3)) *
+            ((x1 - x2) * (y4 - y1) + (y1 - y2) * (x1 - x4)) > 0.0) ||
+           (((x3 - x4) * (y1 - y3) + (y3 - y4) * (x3 - x1)) *
+            ((x3 - x4) * (y2 - y3) + (y3 - y4) * (x3 - x2)) > 0.0 ));
+};
+
+var check_circle_line = function(x, y, r, x1, y1, x2, y2) {
+  var vx = x2-x1, vy = y2-y1;
+  var cx = x-x1, cy = y-y1;
+
+  if (vx == 0 && vy == 0 )
+    return CCk.check_point_circle(x, y, r, x1, y1);
+
+  var n1 = vx * cx + vy * cy;
+  if (n1 < 0)
+    return cx*cx + cy*cy < r * r;
+
+  var n2 = vx * vx + vy * vy;
+  if (n1 > n2) {
+    var len = (x2 - x)*(x2 - x) + (y2 - y)*(y2 - y);
+    return len < r * r;
+  }
+  else
+  {
+    var n3 = cx * cx + cy * cy;
+    return n3-(n1/n2)*n1 < r * r;
+  }
+};
+
+var CCk = {
+  check_point_circle: function(px, py, cx, cy, cr) {
+    return (cr*cr) >= ((cx-px) * (cx-px) + (cy-py) * (cy-py));
+  },
+
+  check_point_straight_rect: function(x, y, x1, y1, x2, y2) {
+    return ((x) >= (x1) &&
+            (y) >= (y1) &&
+            (x) < (x2) &&
+            (y) < (y2));
+  },
+
+  check_point_triangle: function(x, y, x1, y1, x2, y2, x3, y3){
+    if ((x1 - x3) * (y1 - y2) == (x1 - x2) * (y1 - y3))
+      return false;
+
+    var cx = (x1 + x2 + x3) / 3,
+        cy = (y1 + y2 + y3) / 3;
+
+    if (intersect( x1, y1, x2, y2, x, y, cx, cy ) < 0.0 ||
+        intersect( x2, y2, x3, y3, x, y, cx, cy ) < 0.0 ||
+        intersect( x3, y3, x1, y1, x, y, cx, cy ) < 0.0 ) {
+      return false;
+    }
+    return true;
+  },
+
+  check_circle_circle: function(ox, oy, or, dx, dy, dr) {
+    return ((or+dr) * (or+dr) >= (ox-dx) * (ox-dx) + (oy-dy) * (oy-dy));
+  },
+
+  check_ellipse_ellipse: function(E1, E2) {
+     var DefAng = E1.fAngle-E2.fAngle;
+     var Cos = Math.cos( DefAng );
+     var Sin = Math.sin( DefAng );
+     var nx = E2.fRad_X * Cos;
+     var ny = -E2.fRad_X * Sin;
+     var px = E2.fRad_Y * Sin;
+     var py = E2.fRad_Y * Cos;
+     var ox = Math.cos( E1.fAngle )*(E2.fCx-E1.fCx) + Math.sin(E1.fAngle)*(E2.fCy-E1.fCy);
+     var oy = -Math.sin( E1.fAngle )*(E2.fCx-E1.fCx) + Math.cos(E1.fAngle)*(E2.fCy-E1.fCy);
+
+     var rx_pow2 = 1/(E1.fRad_X*E1.fRad_X);
+     var ry_pow2 = 1/(E1.fRad_Y*E1.fRad_Y);
+     var A = rx_pow2*nx*nx + ry_pow2*ny*ny;
+     var B = rx_pow2*px*px + ry_pow2*py*py;
+     var D = 2*rx_pow2*nx*px + 2*ry_pow2*ny*py;
+     var E = 2*rx_pow2*nx*ox + 2*ry_pow2*ny*oy;
+     var F = 2*rx_pow2*px*ox + 2*ry_pow2*py*oy;
+     var G = (ox/E1.fRad_X)*(ox/E1.fRad_X) + (oy/E1.fRad_Y)*(oy/E1.fRad_Y) - 1;
+
+     var tmp1 = 1/(D*D-4*A*B);
+     var h = (F*D-2*E*B)*tmp1;
+     var k = (E*D-2*A*F)*tmp1;
+     var Th = (B-A)==0 ? 0 : Math.atan( D/(B-A) ) * 0.5;
+
+     var CosTh = Math.cos(Th);
+     var SinTh = Math.sin(Th);
+     var A_tt = A*CosTh*CosTh + B*SinTh*SinTh - D*CosTh*SinTh;
+     var B_tt = A*SinTh*SinTh + B*CosTh*CosTh + D*CosTh*SinTh;
+     var KK = A*h*h + B*k*k + D*h*k - E*h - F*k + G > 0 ? 0 : A*h*h + B*k*k + D*h*k - E*h - F*k + G;
+     var Rx_tt = 1+Math.sqrt(-KK/A_tt);
+     var Ry_tt = 1+Math.sqrt(-KK/B_tt);
+     var x_tt = CosTh*h-SinTh*k;
+     var y_tt = SinTh*h+CosTh*k;
+     var JudgeValue = x_tt*x_tt/(Rx_tt*Rx_tt) + y_tt*y_tt/(Ry_tt*Ry_tt);
+
+     return (JudgeValue <= 1);
+  },
+
+  check_circle_tilted_rect: function(cx, cy, cr, x1, y1, x2, y2, x3, y3, x4, y4){
+    return CCk.check_point_triangle(cx, cy, x1, y1, x2, y2, x3, y3) || 
+           CCk.check_point_triangle(cx, cy, x1, y1, x3, y3, x4, y4) || 
+           check_circle_line(cx, cy, cr, x1, y1, x2, y2) ||
+           check_circle_line(cx, cy, cr, x2, y2, x3, y3) ||
+           check_circle_line(cx, cy, cr, x3, y3, x4, y4) ||
+           check_circle_line(cx, cy, cr, x4, y4, x1, y1);
+  },
+
+  check_circle_triangle: function(cx, cy, cr, x1, y1, x2, y2, x3, y3) {
+    return CCk.check_point_triangle(cx, cy, x1, y1, x2, y2, x3, y3) || 
+           check_circle_line(cx, cy, cr, x1, y1, x2, y2) ||
+           check_circle_line(cx, cy, cr, x2, y2, x3, y3) ||
+           check_circle_line(cx, cy, cr, x3, y3, x1, y1);
+  },
+
+  check_rect_rect: function(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2) {
+    return ax1 < bx2 &&
+           ay1 < by2 &&
+           bx1 < ax2 &&
+           by1 < ay2;
+  },
+
+  // Rect(may be tilted) vs Triangle
+  check_tilted_rect_triangle: function(ox1, oy1, ox2, oy2, ox3, oy3, ox4, oy4,
+                                       dx1, dy1, dx2, dy2, dx3, dy3) {
+    return check_line_line(ox1, oy1, ox2, oy2, dx1, dy1, dx2, dy2) ||
+           check_line_line(ox1, oy1, ox2, oy2, dx2, dy2, dx3, dy3) ||
+           check_line_line(ox1, oy1, ox2, oy2, dx3, dy3, dx1, dy1) ||
+           check_line_line(ox2, oy2, ox3, oy3, dx1, dy1, dx2, dy2) ||
+           check_line_line(ox2, oy2, ox3, oy3, dx2, dy2, dx3, dy3) ||
+           check_line_line(ox2, oy2, ox3, oy3, dx3, dy3, dx1, dy1) ||
+           check_line_line(ox3, oy3, ox4, oy4, dx1, dy1, dx2, dy2) ||
+           check_line_line(ox3, oy3, ox4, oy4, dx2, dy2, dx3, dy3) ||
+           check_line_line(ox3, oy3, ox4, oy4, dx3, dy3, dx1, dy1) ||
+           check_line_line(ox4, oy4, ox1, oy1, dx1, dy1, dx2, dy2) ||
+           check_line_line(ox4, oy4, ox1, oy1, dx2, dy2, dx3, dy3) ||
+           check_line_line(ox4, oy4, ox1, oy1, dx3, dy3, dx1, dy1) ||
+           CCk.check_point_triangle(dx1, dy1, ox1, oy1, ox2, oy2, ox3, oy3) || 
+           CCk.check_point_triangle(dx1, dy1, ox1, oy1, ox3, oy3, ox4, oy4) || 
+           CCk.check_point_triangle(ox1, oy1, dx1, dy1, dx2, dy2, dx3, dy3);
+  },
+
+  // Triangle vs Triangle
+  check_triangle_triangle: function(ox1, oy1, ox2, oy2, ox3, oy3,
+                                    dx1, dy1, dx2, dy2, dx3, dy3) {
+    return check_line_line(ox1, oy1, ox2, oy2, dx2, dy2, dx3, dy3) ||
+           check_line_line(ox1, oy1, ox2, oy2, dx3, dy3, dx1, dy1) ||
+           check_line_line(ox2, oy2, ox3, oy3, dx1, dy1, dx2, dy2) ||
+           check_line_line(ox2, oy2, ox3, oy3, dx3, dy3, dx1, dy1) ||
+           check_line_line(ox3, oy3, ox1, oy1, dx1, dy1, dx2, dy2) ||
+           check_line_line(ox3, oy3, ox1, oy1, dx2, dy2, dx3, dy3) ||
+           CCk.check_point_triangle(ox1, oy1, dx1, dy1, dx2, dy2, dx3, dy3) ||
+           CCk.check_point_triangle(dx1, dy1, ox1, oy1, ox2, oy2, ox3, oy3);
+  }
+};
+
+Opal.DXOpal.CollisionChecker = CCk;
+Opal.DXOpal.CCk = CCk; // Alias
+
+})(); }