ruby_rpg 0.0.4 → 0.0.5

data/lib/engine/input.rb

@@ -1,104 +1,105 @@
-# frozen_string_literal: true
-
-module Engine
-  class Input
-    def self.init
-      @key_callback = GLFW::create_callback(:GLFWkeyfun) do |window, key, scancode, action, mods|
-        Input.key_callback(key, action)
-      end
-      GLFW.SetKeyCallback(Window.window, @key_callback)
-
-      @cursor_pos_callback = GLFW::create_callback(:GLFWcursorposfun) do |window, x, y|
-        Input.mouse_callback(x, y)
-      end
-      GLFW.SetCursorPosCallback(Window.window, @cursor_pos_callback)
-
-      @mouse_button_callback = GLFW::create_callback(:GLFWmousebuttonfun) do |window, button, action, mods|
-        Input.mouse_button_callback(button, action)
-      end
-      GLFW.SetMouseButtonCallback(Window.window, @mouse_button_callback)
-    end
-
-    def self.key?(key)
-      keys[key] == :down || keys[key] == :held
-    end
-
-    def self.key_down?(key)
-      keys[key] == :down
-    end
-
-    def self.key_up?(key)
-      keys[key] == :up
-    end
-
-    def self.mouse_pos
-      @mouse_pos
-    end
-
-    def self.mouse_delta
-      return Vector[0, 0] if @old_mouse_pos.nil?
-      return Vector[0, 0] unless @mouse_pos_updated
-
-      @mouse_pos - @old_mouse_pos
-    end
-
-    def self._on_key_down(key)
-      keys[key] = :down
-      if key == GLFW::KEY_ESCAPE
-        Engine.close
-      end
-
-      if key == GLFW::KEY_BACKSPACE
-        Engine::Debugging.breakpoint { binding.pry }
-        # Engine.breakpoint { debugger }
-      end
-
-      if key == GLFW::KEY_F
-        Engine::Window.toggle_full_screen
-      end
-    end
-
-    def self._on_key_up(key)
-      keys[key] = :up
-    end
-
-    def self.key_callback(key, action)
-      if action == GLFW::PRESS
-        _on_key_down(key)
-      elsif action == GLFW::RELEASE
-        _on_key_up(key)
-      end
-    end
-
-    def self.mouse_callback(x, y)
-      @mouse_pos_updated = true
-      @old_mouse_pos = @mouse_pos
-      @mouse_pos = Vector[x, y]
-    end
-
-    def self.mouse_button_callback(button, action)
-      if action == GLFW::PRESS
-        keys[button] = :down
-      elsif action == GLFW::RELEASE
-        keys[button] = :up
-      end
-    end
-
-    def self.update_key_states
-      @mouse_pos_updated = false
-      keys.each do |key, state|
-        if state == :down
-          keys[key] = :held
-        elsif state == :up
-          keys.delete(key)
-        end
-      end
-    end
-
-    private
-
-    def self.keys
-      @keys ||= {}
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine
+  class Input
+    def self.init
+      @key_callback = GLFW::create_callback(:GLFWkeyfun) do |window, key, scancode, action, mods|
+        Input.key_callback(key, action)
+      end
+      GLFW.SetKeyCallback(Window.window, @key_callback)
+
+      @cursor_pos_callback = GLFW::create_callback(:GLFWcursorposfun) do |window, x, y|
+        Input.mouse_callback(x, y)
+      end
+      GLFW.SetCursorPosCallback(Window.window, @cursor_pos_callback)
+
+      @mouse_button_callback = GLFW::create_callback(:GLFWmousebuttonfun) do |window, button, action, mods|
+        Input.mouse_button_callback(button, action)
+      end
+      GLFW.SetMouseButtonCallback(Window.window, @mouse_button_callback)
+    end
+
+    def self.key?(key)
+      keys[key] == :down || keys[key] == :held
+    end
+
+    def self.key_down?(key)
+      keys[key] == :down
+    end
+
+    def self.key_up?(key)
+      keys[key] == :up
+    end
+
+    def self.mouse_pos
+      @mouse_pos
+    end
+
+    def self.mouse_delta
+      return Vector[0, 0] if @old_mouse_pos.nil?
+      return Vector[0, 0] unless @mouse_pos_updated
+
+      @mouse_pos - @old_mouse_pos
+    end
+
+    def self._on_key_down(key)
+      keys[key] = :down
+      if key == GLFW::KEY_ESCAPE
+        Engine.close
+      end
+
+      if key == GLFW::KEY_BACKSPACE
+        Engine::Debugging.breakpoint { binding.pry }
+        # Engine.breakpoint { debugger }
+      end
+
+      if key == GLFW::KEY_F
+        Engine::Window.toggle_full_screen
+      end
+    end
+
+    def self._on_key_up(key)
+      keys[key] = :up
+    end
+
+    def self.key_callback(key, action)
+      if action == GLFW::PRESS
+        _on_key_down(key)
+      elsif action == GLFW::RELEASE
+        _on_key_up(key)
+      end
+    end
+
+    def self.mouse_callback(x, y)
+      @mouse_pos_updated = true
+      @old_mouse_pos = @mouse_pos
+      screen_height = Window.height
+      @mouse_pos = Vector[x, screen_height - y]
+    end
+
+    def self.mouse_button_callback(button, action)
+      if action == GLFW::PRESS
+        keys[button] = :down
+      elsif action == GLFW::RELEASE
+        keys[button] = :up
+      end
+    end
+
+    def self.update_key_states
+      @mouse_pos_updated = false
+      keys.each do |key, state|
+        if state == :down
+          keys[key] = :held
+        elsif state == :up
+          keys.delete(key)
+        end
+      end
+    end
+
+    private
+
+    def self.keys
+      @keys ||= {}
+    end
+  end
+end

data/lib/engine/material.rb

@@ -1,79 +1,79 @@
-# frozen_string_literal: true
-
-module Engine
-  class Material
-    attr_reader :shader
-
-    def initialize(shader)
-      @shader = shader
-    end
-
-    def set_mat4(name, value)
-      mat4s[name] = value
-    end
-
-    def set_vec3(name, value)
-      vec3s[name] = value
-    end
-
-    def set_vec4(name, value)
-      vec4s[name] = value
-    end
-
-    def set_float(name, value)
-      floats[name] = value
-    end
-
-    def set_texture(name, value)
-      textures[name] = value
-    end
-
-    def update_shader
-      shader.use
-
-      mat4s.each do |name, value|
-        shader.set_mat4(name, value)
-      end
-      vec3s.each do |name, value|
-        shader.set_vec3(name, value)
-      end
-      vec4s.each do |name, value|
-        shader.set_vec4(name, value)
-      end
-      floats.each do |name, value|
-        shader.set_float(name, value)
-      end
-      textures.each.with_index do |(name, value), slot|
-        GL.ActiveTexture(Object.const_get("GL::TEXTURE#{slot}"))
-        if value
-          GL.BindTexture(GL::TEXTURE_2D, value)
-        else
-          GL.BindTexture(GL::TEXTURE_2D, 0)
-        end
-        shader.set_int(name, slot)
-      end
-    end
-
-    private
-
-    def mat4s
-      @mat4s ||= {}
-    end
-
-    def vec3s
-      @vec3s ||= {}
-    end
-
-    def vec4s
-      @vec4s ||= {}
-    end
-
-    def floats
-      @floats ||= {}
-    end
-
-    def textures
-      @textures ||= {}
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine
+  class Material
+    attr_reader :shader
+
+    def initialize(shader)
+      @shader = shader
+    end
+
+    def set_mat4(name, value)
+      mat4s[name] = value
+    end
+
+    def set_vec3(name, value)
+      vec3s[name] = value
+    end
+
+    def set_vec4(name, value)
+      vec4s[name] = value
+    end
+
+    def set_float(name, value)
+      floats[name] = value
+    end
+
+    def set_texture(name, value)
+      textures[name] = value
+    end
+
+    def update_shader
+      shader.use
+
+      mat4s.each do |name, value|
+        shader.set_mat4(name, value)
+      end
+      vec3s.each do |name, value|
+        shader.set_vec3(name, value)
+      end
+      vec4s.each do |name, value|
+        shader.set_vec4(name, value)
+      end
+      floats.each do |name, value|
+        shader.set_float(name, value)
+      end
+      textures.each.with_index do |(name, value), slot|
+        GL.ActiveTexture(Object.const_get("GL::TEXTURE#{slot}"))
+        if value
+          GL.BindTexture(GL::TEXTURE_2D, value)
+        else
+          GL.BindTexture(GL::TEXTURE_2D, 0)
+        end
+        shader.set_int(name, slot)
+      end
+    end
+
+    private
+
+    def mat4s
+      @mat4s ||= {}
+    end
+
+    def vec3s
+      @vec3s ||= {}
+    end
+
+    def vec4s
+      @vec4s ||= {}
+    end
+
+    def floats
+      @floats ||= {}
+    end
+
+    def textures
+      @textures ||= {}
+    end
+  end
+end

data/lib/engine/mesh.rb

@@ -1,43 +1,43 @@
-# frozen_string_literal: true
-
-module Engine
-  class Mesh
-    attr_reader :vertex_data, :index_data
-    private_class_method :new
-
-    def initialize(mesh_file)
-      @vertex_data = Mesh.open_vertex(mesh_file)
-      @index_data = Mesh.open_index(mesh_file)
-    end
-
-    def self.for(mesh_file)
-      mesh_cache[mesh_file]
-    end
-
-    def self.mesh_cache
-      @mesh_cache ||= Hash.new do |hash, key|
-        hash[key] = new(key)
-      end
-    end
-
-    def self.open_vertex(mesh_file)
-      vertex_cache[File.join(GAME_DIR, "_imported", mesh_file + ".vertex_data")]
-    end
-
-    def self.vertex_cache
-      @index_data_cache ||= Hash.new do |hash, key|
-        hash[key] = File.readlines(key).reject{|l| l == ""}.map(&:to_f)
-      end
-    end
-
-    def self.open_index(mesh_file)
-      index_cache[File.join(GAME_DIR, "_imported", mesh_file + ".index_data")]
-    end
-
-    def self.index_cache
-      @index_data_cache ||= Hash.new do |hash, key|
-        hash[key] = File.readlines(key).reject{|l| l == ""}.map(&:to_i)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine
+  class Mesh
+    attr_reader :vertex_data, :index_data
+    private_class_method :new
+
+    def initialize(mesh_file)
+      @vertex_data = Mesh.open_vertex(mesh_file)
+      @index_data = Mesh.open_index(mesh_file)
+    end
+
+    def self.for(mesh_file)
+      mesh_cache[mesh_file]
+    end
+
+    def self.mesh_cache
+      @mesh_cache ||= Hash.new do |hash, key|
+        hash[key] = new(key)
+      end
+    end
+
+    def self.open_vertex(mesh_file)
+      vertex_cache[File.join(GAME_DIR, "_imported", mesh_file + ".vertex_data")]
+    end
+
+    def self.vertex_cache
+      @index_data_cache ||= Hash.new do |hash, key|
+        hash[key] = File.readlines(key).reject{|l| l == ""}.map(&:to_f)
+      end
+    end
+
+    def self.open_index(mesh_file)
+      index_cache[File.join(GAME_DIR, "_imported", mesh_file + ".index_data")]
+    end
+
+    def self.index_cache
+      @index_data_cache ||= Hash.new do |hash, key|
+        hash[key] = File.readlines(key).reject{|l| l == ""}.map(&:to_i)
+      end
+    end
+  end
+end

data/lib/engine/path.rb

@@ -1,92 +1,92 @@
-# frozen_string_literal: true
-
-module Engine
-  class NoEarsException < StandardError; end
-
-  class Path
-    attr_reader :points
-
-    def initialize(points)
-      optimised_points = remove_colinear(points)
-      if optimised_points.length <= 3
-        @points = points
-      else
-        @points = optimised_points
-      end
-      #@points = points
-    end
-
-    def point_string(p)
-      "#{20 * (p[0] + 3)}, #{50 * (p[1] + 2)}"
-    end
-
-    def length
-      points.length
-    end
-
-    def find_ear
-      triangles = points.map.with_index do |point, i|
-        a = points[i - 1]
-        b = point
-        c = points[(i + 1) % points.length]
-        [a, b, c]
-      end
-
-      triangles.each do |triangle|
-        if is_ear?(triangle)
-          new_points = points.reject { |point| point == triangle[1] }
-          return triangle, Path.new(new_points)
-        end
-      end
-      raise NoEarsException
-    end
-
-    def is_ear?(triangle)
-      return false unless clockwise?(triangle)
-      points.each do |point|
-        next if triangle.include?(point)
-        return false if point_in_triangle?(point, triangle)
-      end
-      true
-    end
-
-    private
-
-    def remove_colinear(points)
-      points.reject.with_index do |point, i|
-        a = points[i - 1]
-        b = point
-        c = points[(i + 1) % points.length]
-
-        cross_product(a, b, c).zero?
-      end
-    end
-
-    def anti_clockwise?(triangle)
-      a, b, c = triangle
-      cross_product = (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])
-      cross_product > 0
-    end
-
-    def clockwise?(triangle)
-      !anti_clockwise?(triangle)
-    end
-
-    def point_in_triangle?(point, triangle)
-      a, b, c = triangle
-      pab = cross_product(point, a, b)
-      pbc = cross_product(point, b, c)
-      pca = cross_product(point, c, a)
-
-      same_sign?(pab, pbc) && same_sign?(pbc, pca)
-    end
-
-    def cross_product(a, b, c)
-      (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])
-    end
-
-    def same_sign?(a, b)
-      a.negative? == b.negative?
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine
+  class NoEarsException < StandardError; end
+
+  class Path
+    attr_reader :points
+
+    def initialize(points)
+      optimised_points = remove_colinear(points)
+      if optimised_points.length <= 3
+        @points = points
+      else
+        @points = optimised_points
+      end
+      #@points = points
+    end
+
+    def point_string(p)
+      "#{20 * (p[0] + 3)}, #{50 * (p[1] + 2)}"
+    end
+
+    def length
+      points.length
+    end
+
+    def find_ear
+      triangles = points.map.with_index do |point, i|
+        a = points[i - 1]
+        b = point
+        c = points[(i + 1) % points.length]
+        [a, b, c]
+      end
+
+      triangles.each do |triangle|
+        if is_ear?(triangle)
+          new_points = points.reject { |point| point == triangle[1] }
+          return triangle, Path.new(new_points)
+        end
+      end
+      raise NoEarsException
+    end
+
+    def is_ear?(triangle)
+      return false unless clockwise?(triangle)
+      points.each do |point|
+        next if triangle.include?(point)
+        return false if point_in_triangle?(point, triangle)
+      end
+      true
+    end
+
+    private
+
+    def remove_colinear(points)
+      points.reject.with_index do |point, i|
+        a = points[i - 1]
+        b = point
+        c = points[(i + 1) % points.length]
+
+        cross_product(a, b, c).zero?
+      end
+    end
+
+    def anti_clockwise?(triangle)
+      a, b, c = triangle
+      cross_product = (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])
+      cross_product > 0
+    end
+
+    def clockwise?(triangle)
+      !anti_clockwise?(triangle)
+    end
+
+    def point_in_triangle?(point, triangle)
+      a, b, c = triangle
+      pab = cross_product(point, a, b)
+      pbc = cross_product(point, b, c)
+      pca = cross_product(point, c, a)
+
+      same_sign?(pab, pbc) && same_sign?(pbc, pca)
+    end
+
+    def cross_product(a, b, c)
+      (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])
+    end
+
+    def same_sign?(a, b)
+      a.negative? == b.negative?
+    end
+  end
+end

data/lib/engine/physics/collision.rb

@@ -1,12 +1,12 @@
-# frozen_string_literal: true
-
-module Engine::Physics
-  class Collision
-    attr_accessor :impulse, :point
-
-    def initialize(impulse, point)
-      @impulse = impulse
-      @point = point
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine::Physics
+  class Collision
+    attr_accessor :impulse, :point
+
+    def initialize(impulse, point)
+      @impulse = impulse
+      @point = point
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
-# frozen_string_literal: true
-
-module Engine::Physics::Components
-  class CubeCollider < Engine::Component
-  end
-end
+# frozen_string_literal: true
+
+module Engine::Physics::Components
+  class CubeCollider < Engine::Component
+  end
+end