stylet 0.0.1

data/examples/00610_/345/206/205/347/251/215/343/201/250/345/244/226/347/251/215_inner_product.rb

@@ -0,0 +1,36 @@
+#
+# 内積
+#
+require_relative "helper"
+
+class App < Stylet::Base
+  include Helper::CursorWithObjectCollection
+  include Helper::MovablePoint
+
+  setup do
+    @points = []
+    @points << vec2.angle_at(Stylet::Magic.clock(3)).scale(100)
+    @points << vec2.angle_at(Stylet::Magic.clock(0)).scale(100)
+    self.title = "内積と外積"
+  end
+
+  update do
+    update_movable_points(@points, :origin => srect.center)
+    @points.each.with_index {|e, i| draw_vector(e, :origin => srect.center, :label => "P#{i} #{e.round(2)}") }
+
+    a, b = @points
+    # Bを動かしているときにはAをnormalizeした方がわかりやすい
+    dot_product = vec2.dot_product(a.normalize, b)
+    cross_product = vec2.cross_product(a.normalize, b)
+
+    vputs "内積(横): #{dot_product.round(2)}"
+    vputs "外積(縦): #{cross_product.round(2)}"
+
+    vC = a.normalize * dot_product
+    vD = a.normalize.rotate(Stylet::Magic.r90) * cross_product
+    draw_vector(vC, :origin => srect.center, :color => :orange)
+    draw_vector(vD, :origin => vC + srect.center, :color => :orange)
+  end
+
+  run
+end

data/examples/00620_/346/263/225/347/267/232/343/203/231/343/202/257/343/203/210/343/203/253.rb

@@ -0,0 +1,23 @@
+#
+# 法線ベクトル
+#
+require_relative "helper"
+
+class App < Stylet::Base
+  include Helper::CursorWithObjectCollection
+  include Helper::MovablePoint
+
+  setup do
+    @point = vec2.rand.normalize * 100
+    self.title = "法線ベクトル"
+  end
+
+  update do
+    update_movable_points([@point], :origin => srect.center)
+    [@point, @point.prep].each.with_index {|e, i| draw_vector(e, :origin => srect.center, :label => "P#{i} #{e.round(2)}") }
+    draw_vector(@point, :origin => srect.center)
+    draw_vector(@point.prep, :origin => srect.center, :color => :orange)
+  end
+
+  run
+end

data/examples/00630_/345/206/206/343/201/250/345/206/206/343/201/256/345/217/215/345/260/204_collision_reflect_circle_vs_circle.rb

@@ -0,0 +1,222 @@
+#
+# 円と円の反射
+#
+# 反射係数の関係(正面衝突したとする)
+#
+#   -(反射B - 反射A) / (衝突B - 衝突A) #=> 1.0
+#
+# 速度と質量を乗算すると運動量
+#
+#   運動量 = 質量 * 速度
+#
+# 運動量保存の法則により、衝突前の円の運動量の合計値と、衝突後の円の運動量の合計値は等しくなる
+#
+#   運動量保存の法則
+#   質量A * 衝突A + 質量B * 衝突B = 質量A * 反射A + 質量B * 反射B
+#
+require_relative "helper"
+
+class App < Stylet::Base
+  include Helper::CursorWithObjectCollection
+
+  attr_reader :reflect_mode
+
+  setup do
+    self.title = "円と円の反射"
+    cursor.vertex = 3
+
+    @modes = ["reflect", "move", "none"]
+    @reflect_mode = @modes.first
+
+    @pA = srect.center.clone + vec2[80, -70]
+    @sA = vec2.angle_at(Stylet::Magic.clock(6, 15)).scale(1.0)
+    @a_radius = 100
+    @am = @a_radius**2
+
+    @pB = srect.center.clone + vec2[-120, -80]
+    @sB = vec2.angle_at(Stylet::Magic.clock(4)).scale(1.0)
+    @b_radius = 60
+    @bm = @b_radius**2            # 質量
+
+    @s_radius = 100 # 速度ベクトル 1.0 を画面上では何ドットで表わすか？
+    @vertex = 32
+    @reflect_ratio = 1.0 # 反射係数
+  end
+
+  update do
+    if key_down?(SDL::Key::S)
+      @reflect_mode = @modes[@modes.index(@reflect_mode).next.modulo(@modes.size)]
+    end
+
+    vputs "S:reflect=#{@reflect_mode}"
+    vputs "Z:ray++ X:ray-- C:drag V:angle"
+
+    # 操作
+    begin
+      # AとBで速度ベクトルの反映
+      @pA += @sA.scale(button.btA.repeat_0or1) + @sA.scale(-button.btB.repeat_0or1)
+      @pB += @sB.scale(button.btA.repeat_0or1) + @sB.scale(-button.btB.repeat_0or1)
+      # Cボタンおしっぱなし + マウスで自機位置移動
+      if button.btC.press?
+        @pA = cursor.point.clone
+      end
+      # Dボタンおしっぱなし + マウスで自機角度変更
+      if button.btD.press?
+        if cursor.point != @pA
+          @sA = (cursor.point - @pA).normalize * @sA.magnitude
+        end
+      end
+    end
+
+    # @pA += @sA
+    # @pB += @sB
+
+    @diff = @pB - @pA
+    @rdiff = (@a_radius + @b_radius) - @diff.magnitude
+    vputs "magnitude=#{@diff.magnitude}"
+    vputs "rdiff=#{@rdiff}"
+
+    # AとBをお互い離す
+    if reflect_mode == "move"
+      if @rdiff > 0
+        @pA -= @diff.normalize * @rdiff / 2
+        @pB += @diff.normalize * @rdiff / 2
+      end
+    end
+
+    # 反射する
+    if reflect_mode == "reflect"
+      if @rdiff > 0
+        begin
+          # 反射するモードでもいったんお互いを引き離さないと絡まってしまう
+          @pA -= @diff.normalize * @rdiff * 0.5
+          @pB += @diff.normalize * @rdiff * 0.5
+
+          # (am.x,am.y) 円Ａから円Ｂへ移動運動を発生させるベクトル
+          # (ar.x,ar.y) 円Ａから円Ｂへ回転運動を発生させるベクトル
+          # (bm.x,bm.y) 円Ｂから円Ａへ移動運動を発生させるベクトル
+          # (br.x,br.y) 円Ｂから円Ａへ回転運動を発生させるベクトル
+
+          # 速度ベクトルを重心方向と垂直な方向に分離する
+          _denominator = (@diff.x**2 + @diff.y**2)
+
+          # A
+          # A→B 回転運動
+          t = -(@diff.x * @sA.x + @diff.y * @sA.y) / _denominator
+
+          ar = @sA + @diff.scale(t)
+
+          # A→B 移動運動
+          t = -(-@diff.y * @sA.x + @diff.x * @sA.y) / _denominator
+          am = vec2[
+            @sA.x - @diff.y * t,
+            @sA.y + @diff.x * t,
+          ]
+
+          # B
+          # B→A 回転運動
+          t = -(@diff.x * @sB.x + @diff.y * @sB.y) / _denominator
+          br = @sB + @diff.scale(t)
+
+          # B→A 移動運動
+          t = -(-@diff.y * @sB.x + @diff.x * @sB.y) / _denominator
+          bm = vec2[
+            @sB.x - @diff.y * t,
+            @sB.y + @diff.x * t,
+          ]
+
+          # x 方向と y 方向それぞれの衝突後の速度を計算する
+          ad = vec2[
+            (@am * am.x + @bm * bm.x + bm.x * @reflect_ratio * @bm - am.x * @reflect_ratio * @bm) / (@am + @bm),
+            (@am * am.y + @bm * bm.y + bm.y * @reflect_ratio * @bm - am.y * @reflect_ratio * @bm) / (@am + @bm),
+          ]
+          bd = vec2[
+            -@reflect_ratio * (bm.x - am.x) + ad.x,
+            -@reflect_ratio * (bm.y - am.y) + ad.y,
+          ]
+
+          # 回転運動を発生させるベクトルを加算して衝突後の速度を計算
+          @sA.x = ad.x + ar.x
+          @sA.y = ad.y + ar.y
+          @sB.x = bd.x + br.x
+          @sB.y = bd.y + br.y
+
+          # @pA += @sA
+          # @pB += @sB
+        end
+      end
+    end
+
+    draw_circle(@pA, :vertex => @vertex, :radius => @a_radius)
+    vputs "A(#{@am})", :vector => @pA
+    draw_vector(@sA.scale(@s_radius), :origin => @pA, :label => @sA.magnitude)
+
+    draw_circle(@pB, :vertex => @vertex, :radius => @b_radius)
+    vputs "B(#{@bm})", :vector => @pB
+    draw_vector(@sB.scale(@s_radius), :origin => @pB, :label => @sB.magnitude)
+
+    vputs "#{@sA.magnitude} + #{@sA.magnitude} = #{(@sA + @sB).magnitude}"
+
+    if false
+      if @resp = compute(@pA, @sA, @a_radius, @pB, @sB, @b_radius)
+        vputs @resp.inspect
+        vputs c_state(@resp)
+      end
+
+      if @resp
+        @pA2 = @pA + @sA.normalize.scale(@resp[:f0])
+        draw_circle(@pA2, :vertex => @vertex, :radius => @a_radius)
+
+        @pB2 = @pB + @sB.normalize.scale(@resp[:f0])
+        draw_circle(@pB2, :vertex => @vertex, :radius => @b_radius)
+      end
+    end
+  end
+
+  # hakuhin.jp/as/collide.html#COLLIDE_02
+  #
+  # 値                          状態
+  # f0 と f1 がどちらもプラス   円同士は近づいている
+  # f0 と f1 どちらもマイナス   円同士は離れている
+  # f0 と f1 の符号が反転       円同士はめり込んでいる
+  # f0 が 0 以上、 1 以下の値   現在のフレームで衝突する (この状態が発生しない。衝突は f0 == 0.0 && f1 > 0 のときっぽい←ちがう)
+  #
+  # Math.sqrt でエラーがでる
+  # はなれすぎているとエラーになるみたい
+  #
+  def compute(ap, as, ar, bp, bs, br)
+    _a = (as.x * as.x) - 2 * (as.x * bs.x) + (bs.x * bs.x) + (as.y * as.y) - 2 * (as.y * bs.y) + (bs.y * bs.y)
+    _b = 2 * (ap.x * as.x) - 2 * (ap.x * bs.x) - 2 * (as.x * bp.x) + 2 * (bp.x * bs.x) + 2 * (ap.y * as.y) - 2 * (ap.y * bs.y) - 2 * (as.y * bp.y) + 2 * (bp.y * bs.y)
+    _c = (ap.x * ap.x) - 2 * (ap.x * bp.x) + (bp.x * bp.x) + (ap.y * ap.y) - 2 * (ap.y * bp.y) + (bp.y * bp.y) - (ar + br) * (ar + br)
+    _d = Math.sqrt(_b * _b - 4 * _a * _c)
+
+    if _d <= 0
+      # 当たりなし
+      return
+    end
+
+    f0 = (- _b - _d) / (2 * _a) # 接触する瞬間
+    f1 = (- _b + _d) / (2 * _a) # 離れる瞬間
+
+    {:f0 => f0, :f1 => f1}
+  rescue Errno::EDOM => error
+    return
+  end
+
+  def c_state(resp)
+    return unless resp
+    # return if resp.is_a? StandardError
+    if resp[:f0] > 0 && resp[:f1] > 0
+      "tikazuki"
+    elsif resp[:f0] < 0 && resp[:f1] < 0
+      "hanare"
+    elsif resp[:f0] >= 0 && resp[:f1] <= 1
+      "collision"
+      # elsif (resp[:f0] < 0 && resp[:f1] >= 0) || (resp[:f1] < 0 && resp[:f0] >= 0)
+    elsif (resp[:f0] * resp[:f1]) < 0
+      "merikomi"
+    end
+  end
+
+  run
+end

data/examples/00640_/347/202/271/343/201/250/347/267/232/345/210/206/343/201/256/344/272/244/345/267/256/345/210/244/345/256/232_collision_ray_circle_vs_line.rb

@@ -0,0 +1,261 @@
+#
+# 点と線分の交差判定と反射
+#
+require_relative "helper"
+
+class App < Stylet::Base
+  include Helper::CursorWithObjectCollection
+
+  attr_reader :ray_mode
+  attr_reader :reflect_mode
+
+  setup do
+    self.title = "点と線分の交差判定と反射"
+    cursor.vertex = 3
+
+    @ray_mode = false          # true:ドット false:円
+    @reflect_mode = true       # true:反射する
+
+    @p0 = srect.center.clone                # 自機の位置ベクトル
+    @dot_radius = 3                        # 点の大きさ
+    @vertex = 32
+    @vS = vec2[0.84, -0.10].normalize  # 速度ベクトル
+
+    # 線分AB
+    @pA = srect.center + vec2[srect.w * 0.3, -srect.h * 0.30]
+    @pB = srect.center + vec2[srect.w * 0.0, +srect.h * 0.30]
+
+    mode_init
+  end
+
+  update do
+    if key_down?(SDL::Key::A)
+      @ray_mode = !@ray_mode
+      mode_init
+    end
+    if key_down?(SDL::Key::S)
+      @reflect_mode = !@reflect_mode
+    end
+
+    # 操作説明
+    vputs "A:ray=#{@ray_mode} S:reflect=#{@reflect_mode}"
+    vputs "Z:ray++ X:ray-- C:drag V:angle"
+  end
+
+  def mode_init
+    if ray_mode
+      @radius = 1         # 自機の大きさ
+    else
+      @radius = 50        # 自機の大きさ
+    end
+    @vS = @vS.normalize.scale(@radius * 0.5) # 自機の速度ベクトル制限
+  end
+
+  update do
+    # 操作
+    begin
+      # AとBで速度ベクトルの反映
+      @p0 += @vS.scale(button.btA.repeat_0or1) + @vS.scale(-button.btB.repeat_0or1)
+      # Cボタンおしっぱなし + マウスで自機位置移動
+      if button.btC.press?
+        @p0 = cursor.point.clone
+      end
+      # Dボタンおしっぱなし + マウスで自機角度変更
+      if button.btD.press?
+        if cursor.point != @p0
+          @vS = (cursor.point - @p0).normalize * @vS.magnitude
+        end
+      end
+    end
+
+    begin
+      # 法線取得
+      @normal = @pA.normal(@pB).normalize
+      # vputs "Normal: #{@normal.magnitude}"
+
+      # 線分ABの法線を見える化(長さに意味はない)
+      vN = @normal.normalize.scale(64)
+      origin = vec2.pos_vector_ratio(@pA, @pB, 0.5)
+      draw_vector(vN, :origin => origin, :arrow_size => 8)
+      vputs "vN", :vector => origin + vN
+    end
+
+    # t と C1 の取得
+    begin
+      # スピードベクトルをt倍したら線に衝突するかを求める
+      # 自機の原点・速度ベクトル・法線の原点(pAでもpBでもよい)・法線ベクトルを渡すと求まる
+      @t1 = vec2.collision_power_scale(@p0, @vS, @pA, @normal)
+
+      # 裏面(通りすぎている) <= 0.0 < 衝突 <= 1.0 < 表面(まだあたっていない)
+      vputs "C1 t1: #{@t1} (#{ps_state(@t1)})"
+
+      # スピードを t 倍したとき本当にラインに接触するのかを見える化
+      # draw_vector(@vS.scale(@t1), :origin => @p0)
+
+      # 交差点の取得
+      @pC1 = @p0 + @vS.scale(@t1)
+
+      # 交差点の視覚化
+      draw_triangle(@pC1, :radius => @dot_radius, :angle => @vS.angle)
+      vputs "C1", :vector => @pC1
+
+      # 線分ABの中に衝突しているか調べる方法
+      # 内積の取得
+      @ac1 = @pC1 - @pA
+      @bc1 = @pC1 - @pB
+      if @ac1.nonzero? && @bc1.nonzero?
+        @ip1 = vec2.dot_product(@ac1, @bc1)
+        vputs "C1 dot_product(AC1, BC1): #{@ip1} (#{dot_product_state(@ip1)})"
+
+        draw_vector(@ac1.normalize.scale(20), :origin => @pA + @normal.scale(-20 * 1), :arrow_size => 8)
+        draw_vector(@bc1.normalize.scale(20), :origin => @pB + @normal.scale(-20 * 1), :arrow_size => 8)
+      end
+    end
+
+    # t2 と C2 の取得
+    begin
+      # 自機から面と垂直な線を出して面と交差するか調べる(ここが点の場合と違う)
+      @vP = vec2.angle_at(@normal.reverse.angle).scale(@radius) # スケールは半径と同じ長さとする
+      draw_vector(@vP, :origin => @p0)
+      vputs "vP", :vector => @vP + @p0
+
+      # 自機の原点・逆法線ベクトル・法線の原点(pAでもpBでもよい)・法線ベクトルを渡すと求まる
+      # @t2 = vec2.collision_power_scale(@p0, @vP, @pA, @normal)
+      @t2 = vec2.collision_power_scale(@p0, @vP, @pA, @normal)
+      vputs "C2 t2: #{@t2} (#{ps_state(@t2)})"
+
+      # 交差点の取得
+      @pC2 = @p0 + @vP.scale(@t2)
+
+      # 交差点の視覚化
+      draw_triangle(@pC2, :radius => @dot_radius, :angle => @vP.angle)
+      vputs "C2", :vector => @pC2
+
+      # 内積の取得
+      @ac2 = @pC2 - @pA
+      @bc2 = @pC2 - @pB
+      if @ac2.nonzero? && @bc2.nonzero?
+        @ip2 = vec2.dot_product(@ac2, @bc2)
+        vputs "C2 dot_product(AC2, BC2): #{@ip2} (#{dot_product_state(@ip2)})"
+
+        # 二つのベクトルがどちらを向いているか視覚化(お互いが衝突していたら線の中にいることがわかる)
+        draw_vector(@ac2.normalize.scale(20), :origin => @pA + @normal.scale(-20 * 2), :arrow_size => 8)
+        draw_vector(@bc2.normalize.scale(20), :origin => @pB + @normal.scale(-20 * 2), :arrow_size => 8)
+      end
+    end
+
+    # 線の表裏どちらにいるか。また衝突しているか？ (この時点では無限線)
+    if reflect_mode
+      if ray_mode && false
+        # レイモードの反射は難しい
+        # Zで通りすぎてXボタンでバックして再び突進すると線を通りすぎてしまう。
+        # これは「移動距離 < 半径」の法則が慣りたってないから。
+        # 半径を0.1などと考えて円にして反射させるのがいいのかも
+
+        # _radius = 0.5
+        #
+        # if 0.0 < @t2 && @t2 <= 1.0 # めり込んでいる
+        #   if @ip2 < 0 # 線の中で
+        #     # 円を押し戻す
+        #     @p0 = @pC2 + @normal.normalize.scale(_radius)
+        #     @vS += @vS.reflect(@normal).scale(1.0)
+        #   end
+        # end
+        #
+        # # 速度制限(円が線から飛び出さないようにする)
+        # if @vS.radius > _radius
+        #   @vS = @vS.normalize.scale(_radius)
+        # end
+
+        # # Zで通りすぎてXボタンでバックして再び突進すると線を通りすぎてしまう。
+        # # これは「移動距離 < 半径」の法則が慣りたってないから。
+        # if 0.0 < @t && @t <= 1.0
+        #   if @ip < 0
+        #     @p0 = @pC1.clone
+        #     # @p0 = @pC1 + @normal.normalize.scale(1.1)
+        #     @vS += @vS.reflect(@normal)
+        #   end
+        # end
+      else
+        # レイの場合は半径がないので t1 と C1 を使っても同じ
+
+        if 0.0 < @t2 && @t2 <= 1.0 # めり込んでいる
+          if @ip2 < 0 # 線の中で
+            # 円を押し戻す
+            @p0 = @pC2 + @normal.normalize.scale(@radius)
+            @vS += @vS.reflect(@normal).scale(1.0)
+          end
+        end
+
+        # 速度制限(円が線から飛び出さないようにする)
+        if @vS.magnitude > @radius
+          @vS = @vS.normalize.scale(@radius)
+        end
+
+        # 点Aと点Bに円がめり込んでいたら押す
+        [@pA, @pB].each do |pX|
+          diff = @p0 - pX
+          if diff.magnitude > 0
+            if diff.magnitude < @radius
+              @p0 = pX + diff.normalize.scale(@radius)
+              if true
+                # 跳ね返す
+                @vS = diff.normalize.scale(@vS.magnitude)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    begin
+      if ray_mode
+        # 自機(ドット)の表示
+        draw_triangle(@p0, :radius => @dot_radius, :angle => @vS.angle)
+      else
+        # 自機(円)の表示
+        draw_circle(@p0, :radius => @radius, :vertex => @vertex, :angle => @vS.angle)
+      end
+      vputs "p0", :vector => @p0
+
+      # 自機の速度ベクトルの可視化(長さに意味はない)
+      pS = @vS
+      draw_vector(pS, :origin => @p0)
+      vputs "vS", :vector => @p0 + pS
+      vputs "Speed Vector: #{@vS.magnitude}"
+
+      # 線分ABの視覚化
+      draw_line(@pA, @pB)
+      vputs "A", :vector => @pA
+      vputs "B", :vector => @pB
+
+      if button.btC.press? || button.btD.press?
+        draw_line(@p0, @pC1)
+        draw_line(@p0, @pC2)
+      end
+    end
+  end
+
+  def ps_state(t)
+    if t > 1.0
+      "FACE"
+    elsif 0.0 < t && t <= 1.0
+      "COLLISION"
+    else # t <= 0.0
+      "REVERSE"
+    end
+  end
+
+  #   1. ←← or →→ 正 (0.0 < v)   お互いだいたい同じ方向を向いている
+  #   2. →←         負 (v   < 0.0) お互いだいたい逆の方向を向いている
+  #   3. →↓ →↑    零 (0.0)       お互いが直角の関係
+  def dot_product_state(v)
+    if v < 0
+      "IN"
+    else
+      "OUT"
+    end
+  end
+
+  run
+end