ruby_rpg 0.0.4 → 0.0.5

data/lib/engine/physics/components/rigidbody.rb

@@ -1,103 +1,103 @@
-# frozen_string_literal: true
-
-module Engine::Physics::Components
-  class Rigidbody < Engine::Component
-    attr_accessor :velocity,
-                  :angular_velocity,
-                  :force,
-                  :impulses,
-                  :mass,
-                  :coefficient_of_restitution,
-                  :coefficient_of_friction
-
-    def initialize(
-      velocity: Vector[0, 0, 0],
-      angular_velocity: Vector[0, 0, 0],
-      mass: 1,
-      inertia_tensor: nil,
-      gravity: Vector[0, -9.81, 0],
-      coefficient_of_restitution: 1,
-      coefficient_of_friction: 0
-    )
-      @velocity = velocity
-      @angular_velocity = angular_velocity
-      @force = gravity * mass
-      @gravity = gravity
-      @impulses = []
-      @angular_impulses = []
-      @mass = mass
-      @inertia_tensor = inertia_tensor || Matrix[
-        [1, 0, 0],
-        [0, 1, 0],
-        [0, 0, 1]
-      ] * mass
-      @coefficient_of_restitution = coefficient_of_restitution
-      @coefficient_of_friction = coefficient_of_friction
-    end
-
-    def update(delta_time)
-      @velocity += acceleration * delta_time
-      @velocity += @impulses.reduce(Vector[0, 0, 0]) { |acc, impulse| acc + impulse } / @mass
-      @impulses = []
-      @game_object.pos += @velocity * delta_time
-
-      total_angular_impulse = @angular_impulses.reduce(Vector[0, 0, 0]) { |acc, impulse| acc + impulse }
-      if total_angular_impulse.magnitude > 0
-        angular_inertia =
-          if moment_of_inertia == 0
-            impulse_direction = total_angular_impulse.normalize
-            impulse_direction.dot(@inertia_tensor * impulse_direction)
-          else
-            moment_of_inertia
-          end
-        @angular_velocity += total_angular_impulse / angular_inertia
-      end
-      @angular_impulses = []
-      @game_object.rotate_around(angular_velocity, delta_time * angular_velocity.magnitude) if angular_velocity.magnitude > 0
-    end
-
-    def apply_impulse(impulse, point)
-      @impulses << impulse
-      @angular_impulses << (game_object.pos - point).cross(impulse)
-    end
-
-    def apply_angular_impulse(impulse)
-      @angular_impulses << impulse
-    end
-
-    def colliders
-      @game_object.components.select { |c| c.is_a?(SphereCollider) }
-    end
-
-    def kinetic_energy
-      0.5 * @mass * @velocity.magnitude ** 2 +
-        0.5 * moment_of_inertia * @angular_velocity.magnitude ** 2
-    end
-
-    def momentum
-      @mass * @velocity
-    end
-
-    def angular_momentum(origin = Vector[0, 0, 0])
-      moment_of_inertia * @angular_velocity +
-        (game_object.pos - origin).cross(momentum)
-    end
-
-    def velocity_at_point(point)
-      velocity + (angular_velocity.cross(game_object.pos - point) * Math::PI / 180)
-    end
-
-    private
-
-    def acceleration
-      @force / @mass
-    end
-
-    def moment_of_inertia
-      return 0 if @angular_velocity.magnitude == 0
-
-      angular_velocity_direction = @angular_velocity.normalize
-      angular_velocity_direction.dot(@inertia_tensor * angular_velocity_direction)
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine::Physics::Components
+  class Rigidbody < Engine::Component
+    attr_accessor :velocity,
+                  :angular_velocity,
+                  :force,
+                  :impulses,
+                  :mass,
+                  :coefficient_of_restitution,
+                  :coefficient_of_friction
+
+    def initialize(
+      velocity: Vector[0, 0, 0],
+      angular_velocity: Vector[0, 0, 0],
+      mass: 1,
+      inertia_tensor: nil,
+      gravity: Vector[0, -9.81, 0],
+      coefficient_of_restitution: 1,
+      coefficient_of_friction: 0
+    )
+      @velocity = velocity
+      @angular_velocity = angular_velocity
+      @force = gravity * mass
+      @gravity = gravity
+      @impulses = []
+      @angular_impulses = []
+      @mass = mass
+      @inertia_tensor = inertia_tensor || Matrix[
+        [1, 0, 0],
+        [0, 1, 0],
+        [0, 0, 1]
+      ] * mass
+      @coefficient_of_restitution = coefficient_of_restitution
+      @coefficient_of_friction = coefficient_of_friction
+    end
+
+    def update(delta_time)
+      @velocity += acceleration * delta_time
+      @velocity += @impulses.reduce(Vector[0, 0, 0]) { |acc, impulse| acc + impulse } / @mass
+      @impulses = []
+      @game_object.pos += @velocity * delta_time
+
+      total_angular_impulse = @angular_impulses.reduce(Vector[0, 0, 0]) { |acc, impulse| acc + impulse }
+      if total_angular_impulse.magnitude > 0
+        angular_inertia =
+          if moment_of_inertia == 0
+            impulse_direction = total_angular_impulse.normalize
+            impulse_direction.dot(@inertia_tensor * impulse_direction)
+          else
+            moment_of_inertia
+          end
+        @angular_velocity += total_angular_impulse / angular_inertia
+      end
+      @angular_impulses = []
+      @game_object.rotate_around(angular_velocity, delta_time * angular_velocity.magnitude) if angular_velocity.magnitude > 0
+    end
+
+    def apply_impulse(impulse, point)
+      @impulses << impulse
+      @angular_impulses << (game_object.pos - point).cross(impulse)
+    end
+
+    def apply_angular_impulse(impulse)
+      @angular_impulses << impulse
+    end
+
+    def colliders
+      @game_object.components.select { |c| c.is_a?(SphereCollider) }
+    end
+
+    def kinetic_energy
+      0.5 * @mass * @velocity.magnitude ** 2 +
+        0.5 * moment_of_inertia * @angular_velocity.magnitude ** 2
+    end
+
+    def momentum
+      @mass * @velocity
+    end
+
+    def angular_momentum(origin = Vector[0, 0, 0])
+      moment_of_inertia * @angular_velocity +
+        (game_object.pos - origin).cross(momentum)
+    end
+
+    def velocity_at_point(point)
+      velocity + (angular_velocity.cross(game_object.pos - point) * Math::PI / 180)
+    end
+
+    private
+
+    def acceleration
+      @force / @mass
+    end
+
+    def moment_of_inertia
+      return 0 if @angular_velocity.magnitude == 0
+
+      angular_velocity_direction = @angular_velocity.normalize
+      angular_velocity_direction.dot(@inertia_tensor * angular_velocity_direction)
+    end
+  end
+end

data/lib/engine/physics/components/sphere_collider.rb

@@ -1,93 +1,93 @@
-# frozen_string_literal: true
-
-module Engine::Physics::Components
-  class SphereCollider < Engine::Component
-    attr_accessor :radius
-
-    def initialize(radius)
-      @radius = radius
-    end
-
-    def collision_for(other_collider)
-      distance = (game_object.pos - other_collider.game_object.pos).magnitude
-      min_distance = radius + other_collider.radius
-
-      return nil if distance >= min_distance
-
-      direction = (other_collider.game_object.pos - game_object.pos).normalize
-      collision_point = collision_point(direction, min_distance - distance)
-      magnitude = normal_impulse_magnitude(direction, other_collider, collision_point)
-
-      return nil if magnitude <= 0
-
-      normal_impulse = -direction * magnitude
-      tangential_impulse = tangential_impulse(other_collider, normal_impulse, collision_point)
-
-      puts "normal_impulse: #{normal_impulse}"
-      puts "tangential_impulse: #{tangential_impulse}"
-      puts "total impulse: #{normal_impulse + tangential_impulse}"
-
-      Engine::Physics::Collision.new(normal_impulse + tangential_impulse, collision_point)
-    end
-
-    def static?
-      rigidbody.nil?
-    end
-
-    def inverse_mass
-      1.0 / rigidbody.mass
-    end
-
-    def velocity(pos)
-      rigidbody&.velocity_at_point(pos) || Vector[0, 0, 0]
-    end
-
-    def rigidbody
-      game_object.components.find { |c| c.is_a?(Rigidbody) }
-    end
-
-    private
-
-    def combined_coefficient_of_restitution(other_collider)
-      return rigidbody.coefficient_of_restitution if other_collider.static?
-
-      rigidbody.coefficient_of_restitution * other_collider.rigidbody.coefficient_of_restitution
-    end
-
-    def combined_coefficient_of_friction(other_collider)
-      return rigidbody.coefficient_of_friction if other_collider.static?
-
-      rigidbody.coefficient_of_friction * other_collider.rigidbody.coefficient_of_friction
-    end
-
-    def collision_point(direction, overlap)
-      game_object.pos + direction * (radius - overlap / 2)
-    end
-
-    def normal_impulse_magnitude(direction, other_collider, collision_point)
-      (
-        if other_collider.static?
-          v_r = velocity(collision_point)
-          (v_r.dot(direction) * 2) / inverse_mass
-        else
-          v_r = velocity(collision_point) - other_collider.velocity(collision_point)
-          (v_r.dot(direction) * 2) / (inverse_mass + other_collider.inverse_mass)
-        end) * combined_coefficient_of_restitution(other_collider)
-    end
-
-    def tangential_impulse(other_collider, normal_impulse, collision_point)
-      normal_direction = normal_impulse.normalize
-      v_t = if other_collider.static?
-              velocity(collision_point)
-            else
-              velocity(collision_point) - other_collider.velocity(collision_point)
-            end
-
-      v_t_without_normal = -((v_t - v_t.dot(normal_direction) * normal_direction))
-      return Vector[0, 0, 0] if v_t_without_normal.magnitude == 0
-
-      relevant_speed = [v_t_without_normal.magnitude, normal_impulse.magnitude * combined_coefficient_of_friction(other_collider)].min
-      v_t_without_normal.normalize * relevant_speed / 2
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine::Physics::Components
+  class SphereCollider < Engine::Component
+    attr_accessor :radius
+
+    def initialize(radius)
+      @radius = radius
+    end
+
+    def collision_for(other_collider)
+      distance = (game_object.pos - other_collider.game_object.pos).magnitude
+      min_distance = radius + other_collider.radius
+
+      return nil if distance >= min_distance
+
+      direction = (other_collider.game_object.pos - game_object.pos).normalize
+      collision_point = collision_point(direction, min_distance - distance)
+      magnitude = normal_impulse_magnitude(direction, other_collider, collision_point)
+
+      return nil if magnitude <= 0
+
+      normal_impulse = -direction * magnitude
+      tangential_impulse = tangential_impulse(other_collider, normal_impulse, collision_point)
+
+      puts "normal_impulse: #{normal_impulse}"
+      puts "tangential_impulse: #{tangential_impulse}"
+      puts "total impulse: #{normal_impulse + tangential_impulse}"
+
+      Engine::Physics::Collision.new(normal_impulse + tangential_impulse, collision_point)
+    end
+
+    def static?
+      rigidbody.nil?
+    end
+
+    def inverse_mass
+      1.0 / rigidbody.mass
+    end
+
+    def velocity(pos)
+      rigidbody&.velocity_at_point(pos) || Vector[0, 0, 0]
+    end
+
+    def rigidbody
+      game_object.components.find { |c| c.is_a?(Rigidbody) }
+    end
+
+    private
+
+    def combined_coefficient_of_restitution(other_collider)
+      return rigidbody.coefficient_of_restitution if other_collider.static?
+
+      rigidbody.coefficient_of_restitution * other_collider.rigidbody.coefficient_of_restitution
+    end
+
+    def combined_coefficient_of_friction(other_collider)
+      return rigidbody.coefficient_of_friction if other_collider.static?
+
+      rigidbody.coefficient_of_friction * other_collider.rigidbody.coefficient_of_friction
+    end
+
+    def collision_point(direction, overlap)
+      game_object.pos + direction * (radius - overlap / 2)
+    end
+
+    def normal_impulse_magnitude(direction, other_collider, collision_point)
+      (
+        if other_collider.static?
+          v_r = velocity(collision_point)
+          (v_r.dot(direction) * 2) / inverse_mass
+        else
+          v_r = velocity(collision_point) - other_collider.velocity(collision_point)
+          (v_r.dot(direction) * 2) / (inverse_mass + other_collider.inverse_mass)
+        end) * combined_coefficient_of_restitution(other_collider)
+    end
+
+    def tangential_impulse(other_collider, normal_impulse, collision_point)
+      normal_direction = normal_impulse.normalize
+      v_t = if other_collider.static?
+              velocity(collision_point)
+            else
+              velocity(collision_point) - other_collider.velocity(collision_point)
+            end
+
+      v_t_without_normal = -((v_t - v_t.dot(normal_direction) * normal_direction))
+      return Vector[0, 0, 0] if v_t_without_normal.magnitude == 0
+
+      relevant_speed = [v_t_without_normal.magnitude, normal_impulse.magnitude * combined_coefficient_of_friction(other_collider)].min
+      v_t_without_normal.normalize * relevant_speed / 2
+    end
+  end
+end

data/lib/engine/physics/physics_resolver.rb

@@ -1,37 +1,37 @@
-# frozen_string_literal: true
-
-module Engine::Physics
-  module PhysicsResolver
-    def self.resolve
-      rigidbodies.each do |rb|
-        apply_collisions(rb)
-      end
-    end
-
-    private
-
-    def self.apply_collisions(rigidbody)
-      other_colliders = colliders.reject { |c| rigidbody.colliders.include?(c) }
-
-      rigidbody.colliders.map do |collider|
-        other_colliders.map do |other_collider|
-          collider.collision_for(other_collider)
-        end.compact
-      end.flatten.each do |collision|
-        rigidbody.apply_impulse(collision.impulse, collision.point)
-      end
-    end
-
-    def self.rigidbodies
-      Engine::GameObject.objects.map do |go|
-        go.components.find { |c| c.is_a?(Engine::Physics::Components::Rigidbody) }
-      end.compact
-    end
-
-    def self.colliders
-      Engine::GameObject.objects.map do |go|
-        go.components.select { |c| c.is_a?(Components::SphereCollider) }
-      end.flatten
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine::Physics
+  module PhysicsResolver
+    def self.resolve
+      rigidbodies.each do |rb|
+        apply_collisions(rb)
+      end
+    end
+
+    private
+
+    def self.apply_collisions(rigidbody)
+      other_colliders = colliders.reject { |c| rigidbody.colliders.include?(c) }
+
+      rigidbody.colliders.map do |collider|
+        other_colliders.map do |other_collider|
+          collider.collision_for(other_collider)
+        end.compact
+      end.flatten.each do |collision|
+        rigidbody.apply_impulse(collision.impulse, collision.point)
+      end
+    end
+
+    def self.rigidbodies
+      Engine::GameObject.objects.map do |go|
+        go.components.find { |c| c.is_a?(Engine::Physics::Components::Rigidbody) }
+      end.compact
+    end
+
+    def self.colliders
+      Engine::GameObject.objects.map do |go|
+        go.components.select { |c| c.is_a?(Components::SphereCollider) }
+      end.flatten
+    end
+  end
+end

data/lib/engine/polygon_mesh.rb

@@ -1,45 +1,45 @@
-# frozen_string_literal: true
-
-module Engine
-  class PolygonMesh
-    attr_reader :points, :uvs
-
-    def initialize(points, uvs)
-      @points = points
-      @uvs = uvs
-    end
-
-    def vertex_data
-      @vertex_data ||= generate_vertex_data
-    end
-
-    def index_data
-      @index_data ||= (0..vertices.length - 1).to_a
-    end
-
-    private
-
-    def generate_vertex_data
-      vertices.map do |point|
-        uv = uvs[points.index(point)]
-        [point[0], point[1], 0.0, uv[0], uv[1]]
-      end.flatten
-    end
-
-    def vertices
-      @vertices ||=
-        begin
-          path = Path.new(@points)
-          vertices = []
-          until path.length == 3
-            ear, new_path = path.find_ear
-            ear = ear.reverse!
-            vertices << ear
-            path = new_path
-          end
-          vertices += path.points.reverse
-          vertices.flatten(1)
-        end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine
+  class PolygonMesh
+    attr_reader :points, :uvs
+
+    def initialize(points, uvs)
+      @points = points
+      @uvs = uvs
+    end
+
+    def vertex_data
+      @vertex_data ||= generate_vertex_data
+    end
+
+    def index_data
+      @index_data ||= (0..vertices.length - 1).to_a
+    end
+
+    private
+
+    def generate_vertex_data
+      vertices.map do |point|
+        uv = uvs[points.index(point)]
+        [point[0], point[1], 0.0, uv[0], uv[1]]
+      end.flatten
+    end
+
+    def vertices
+      @vertices ||=
+        begin
+          path = Path.new(@points)
+          vertices = []
+          until path.length == 3
+            ear, new_path = path.find_ear
+            ear = ear.reverse!
+            vertices << ear
+            path = new_path
+          end
+          vertices += path.points.reverse
+          vertices.flatten(1)
+        end
+    end
+  end
+end