cyberarm_engine 0.12.0 → 0.15.0

data/lib/cyberarm_engine/ui/style.rb

@@ -1,11 +1,11 @@
 module Gosu
   class Color
-    def _dump(level)
+    def _dump(_level)
       [
-        "%02X" % self.alpha,
-        "%02X" % self.red,
-        "%02X" % self.green,
-        "%02X" % self.blue
+        "%02X" % alpha,
+        "%02X" % red,
+        "%02X" % green,
+        "%02X" % blue
       ].join
     end
 
@@ -21,17 +21,18 @@ module CyberarmEngine
       @hash = Marshal.load(Marshal.dump(hash))
     end
 
-    def method_missing(method, *args, &block)
+    def method_missing(method, *args)
       if method.to_s.end_with?("=")
         raise "Did not expect more than 1 argument" if args.size > 1
-        return @hash[method.to_s.sub("=", "").to_sym] = args.first
+
+        @hash[method.to_s.sub("=", "").to_sym] = args.first
 
       elsif args.size == 0
-        return @hash[method]
+        @hash[method]
 
       else
         raise ArgumentError, "Did not expect arguments"
       end
     end
   end
-end
+end

data/lib/cyberarm_engine/ui/theme.rb

@@ -11,17 +11,21 @@ module CyberarmEngine
 
     def theme_defaults(options)
       raise "Error" unless self.class.ancestors.include?(CyberarmEngine::Element)
+
       _theme = THEME
-      _theme = _theme.merge(options[:theme]) if options[:theme]
+      _theme = deep_merge(_theme, options[:theme]) if options[:theme]
       _theme.delete(:theme) if options[:theme]
 
       hash = {}
       class_names = self.class.ancestors
-      class_names = class_names[0..class_names.index(CyberarmEngine::Element)].map! {|c| c.to_s.split("::").last.to_sym}.reverse!
+      class_names = class_names[0..class_names.index(CyberarmEngine::Element)].map! do |c|
+        c.to_s.split("::").last.to_sym
+      end.reverse!
 
       class_names.each do |klass|
         next unless data = _theme.dig(klass)
-        data.each do |key, value|
+
+        data.each do |_key, _value|
           hash.merge!(data)
         end
       end
@@ -32,7 +36,7 @@ module CyberarmEngine
     # Derived from Rails Hash#deep_merge!
     # Enables passing partial themes through Element options without issue
     def deep_merge(original, intergrate, &block)
-      hash = original.merge(intergrate) do |key, this_val, other_val|
+      original.merge(intergrate) do |key, this_val, other_val|
         if this_val.is_a?(Hash) && other_val.is_a?(Hash)
           deep_merge(this_val, other_val, &block)
         elsif block_given?
@@ -41,8 +45,6 @@ module CyberarmEngine
           other_val
         end
       end
-
-      return hash
     end
 
     THEME = {
@@ -51,28 +53,30 @@ module CyberarmEngine
         y: 0,
         z: 30,
 
-        width:  nil,
+        width: nil,
         height: nil,
-        color:     Gosu::Color::WHITE,
+        color: Gosu::Color::WHITE,
         background: Gosu::Color::NONE,
-        margin:   0,
-        padding:  0,
+        margin: 0,
+        padding: 0,
         border_thickness: 0,
         border_color: Gosu::Color::NONE,
-        border_radius: 0,
+        border_radius: 0
       },
 
       Button: { # < Label
-        margin:   1,
-        padding:  4,
+        margin: 1,
+        padding: 4,
         border_thickness: 1,
         border_color: ["ffd59674".hex, "ffff8746".hex],
         border_radius: 0,
         background: ["ffc75e61".to_i(16), "ffe26623".to_i(16)],
+        text_align: :center,
+        text_wrap: :none,
 
         hover: {
-          color: Gosu::Color.rgb(200,200,200),
-          background:  ["ffB23E41".to_i(16), "ffFF7C00".to_i(16)],
+          color: Gosu::Color.rgb(200, 200, 200),
+          background: ["ffB23E41".to_i(16), "ffFF7C00".to_i(16)]
         },
 
         active: {
@@ -88,18 +92,23 @@ module CyberarmEngine
         caret_width: 2,
         caret_color: Gosu::Color::WHITE,
         caret_interval: 500,
+        selection_color: Gosu::Color.rgba(255, 128, 50, 200),
+        text_align: :left
       },
 
       Image: { # < Element
+        color: Gosu::Color::WHITE,
         retro: false
       },
 
       Label: { # < Element
-      text_size: 28,
-      text_shadow: false,
-      font: "Arial",
-      margin: 0,
-      padding: 2
+        text_size: 28,
+        text_wrap: :none, # :word_wrap, :break_word, :none
+        text_shadow: false,
+        text_align: :left,
+        font: "Arial",
+        margin: 0,
+        padding: 2
       },
 
       ToggleButton: { # < Button
@@ -111,7 +120,16 @@ module CyberarmEngine
         height: 36,
         background: 0xff111111,
         fraction_background: [0xffc75e61, 0xffe26623],
-        border_thickness: 4,
+        border_thickness: 1,
+        border_color: [0xffd59674, 0xffff8746]
+      },
+
+      Slider: { # < Element
+        width: 250,
+        height: 36,
+        background: 0xff111111,
+        fraction_background: [0xffc75e61, 0xffe26623],
+        border_thickness: 1,
         border_color: [0xffd59674, 0xffff8746]
       }
     }.freeze

data/lib/cyberarm_engine/vector.rb

@@ -1,63 +1,101 @@
 module CyberarmEngine
   class Vector
+    ##
+    # Creates a up vector
+    #
+    #   Vector.new(0, 1, 0)
+    #
+    # @return [CyberarmEngine::Vector]
     def self.up
       Vector.new(0, 1, 0)
     end
 
+    ##
+    # Creates a down vector
+    #
+    #   Vector.new(0, -1, 0)
+    #
+    # @return [CyberarmEngine::Vector]
     def self.down
       Vector.new(0, -1, 0)
     end
 
+    ##
+    # Creates a left vector
+    #
+    #   Vector.new(-1, 0, 0)
+    #
+    # @return [CyberarmEngine::Vector]
     def self.left
       Vector.new(-1, 0, 0)
     end
 
+    ##
+    # Creates a right vector
+    #
+    #   Vector.new(1, 0, 0)
+    #
+    # @return [CyberarmEngine::Vector]
     def self.right
       Vector.new(1, 0, 0)
     end
 
+    ##
+    # Creates a forward vector
+    #
+    #   Vector.new(0, 0, 1)
+    #
+    # @return [CyberarmEngine::Vector]
     def self.forward
       Vector.new(0, 0, 1)
     end
 
+    ##
+    # Creates a backward vector
+    #
+    #   Vector.new(0, 0, -1)
+    #
+    # @return [CyberarmEngine::Vector]
     def self.backward
       Vector.new(0, 0, -1)
     end
 
+    attr_accessor :x, :y, :z, :weight
+
     def initialize(x = 0, y = 0, z = 0, weight = 0)
-      @x, @y, @z, @weight = x, y, z, weight
+      @x = x
+      @y = y
+      @z = z
+      @weight = weight
     end
 
-    def x; @x; end
-    def x=(n); @x = n; end
-
-    def y; @y; end
-    def y=(n); @y = n; end
-
-    def z; @z; end
-    def z=(n); @z = n; end
-
-    def weight; @weight; end
-    def weight=(n); @weight = n; end
-
     alias w weight
     alias w= weight=
 
+    # @return [Boolean]
     def ==(other)
       if other.is_a?(Numeric)
         @x      == other &&
-        @y      == other &&
-        @z      == other &&
-        @weight == other
-      else
+          @y      == other &&
+          @z      == other &&
+          @weight == other
+      elsif other.is_a?(Vector)
         @x      == other.x &&
-        @y      == other.y &&
-        @z      == other.z &&
-        @weight == other.weight
+          @y      == other.y &&
+          @z      == other.z &&
+          @weight == other.weight
+      else
+        other == self
       end
     end
 
-    # Performs math operation, excluding @weight
+    # Create a new vector using {x} and {y} values
+    # @return [CyberarmEngine::Vector]
+    def xy
+      Vector.new(@x, @y)
+    end
+
+    # Performs math operation, excluding {weight}
     private def operator(function, other)
       if other.is_a?(Numeric)
         Vector.new(
@@ -74,22 +112,37 @@ module CyberarmEngine
       end
     end
 
-    # Adds Vector and Numberic or Vector and Vector, excluding @weight
+    # Adds Vector and Numeric or Vector and Vector, excluding {weight}
+    # @return [CyberarmEngine::Vector]
     def +(other)
       operator("+", other)
     end
 
-    # Subtracts Vector and Numberic or Vector and Vector, excluding @weight
+    # Subtracts Vector and Numeric or Vector and Vector, excluding {weight}
+    # @return [CyberarmEngine::Vector]
     def -(other)
       operator("-", other)
     end
 
-    # Multiplies Vector and Numberic or Vector and Vector, excluding @weight
+    # Multiplies Vector and Numeric or Vector and Vector, excluding {weight}
+    # @return [CyberarmEngine::Vector]
     def *(other)
       operator("*", other)
     end
 
-    # Divides Vector and Numberic or Vector and Vector, excluding @weight
+    def multiply_transform(transform)
+      e = transform.elements
+
+      x = @x * e[0]  + @y * e[1]  + @z * e[2]  + 1 * e[3]
+      y = @x * e[4]  + @y * e[5]  + @z * e[6]  + 1 * e[7]
+      z = @x * e[8]  + @y * e[9]  + @z * e[10] + 1 * e[11]
+      w = @x * e[12] + @y * e[13] + @z * e[14] + 1 * e[15]
+
+      Vector.new(x / 1, y / 1, z / 1, w / 1)
+    end
+
+    # Divides Vector and Numeric or Vector and Vector, excluding {weight}
+    # @return [CyberarmEngine::Vector]
     def /(other)
       # Duplicated to protect from DivideByZero
       if other.is_a?(Numeric)
@@ -107,21 +160,25 @@ module CyberarmEngine
       end
     end
 
+    # dot product of {Vector}
+    # @return [Integer|Float]
     def dot(other)
       product = 0
 
-      a = self.to_a
+      a = to_a
       b = other.to_a
 
       3.times do |i|
-        product = product + (a[i] * b[i])
+        product += (a[i] * b[i])
       end
 
-      return product
+      product
     end
 
+    # cross product of {Vector}
+    # @return [CyberarmEngine::Vector]
     def cross(other)
-      a = self.to_a
+      a = to_a
       b = other.to_a
 
       Vector.new(
@@ -132,24 +189,39 @@ module CyberarmEngine
     end
 
     # returns degrees
+    # @return [Float]
     def angle(other)
-      Math.acos( self.normalized.dot(other.normalized) ) * 180 / Math::PI
+      Math.acos(normalized.dot(other.normalized)) * 180 / Math::PI
     end
 
     # returns magnitude of Vector, ignoring #weight
+    # @return [Float]
     def magnitude
       Math.sqrt((@x * @x) + (@y * @y) + (@z * @z))
     end
 
+    ##
+    # returns normalized {Vector}
+    #
+    # @example
+    #   CyberarmEngine::Vector.new(50, 21.2, 45).normalized
+    #   # => <CyberarmEngine::Vector:0x001 @x=0.7089... @y=0.3005... @z=0.6380... @weight=0>
+    #
+    # @return [CyberarmEngine::Vector]
     def normalized
       mag = magnitude
       self / Vector.new(mag, mag, mag)
     end
 
+    # returns a direction {Vector}
+    #
+    # z is pitch
+    #
+    # y is yaw
+    #
+    # x is roll
+    # @return [CyberarmEngine::Vector]
     def direction
-      # z is pitch
-      # y is yaw
-      # x is roll
       _x = -Math.sin(@y.degrees_to_radians) * Math.cos(@z.degrees_to_radians)
       _y = Math.sin(@z.degrees_to_radians)
       _z = Math.cos(@y.degrees_to_radians) * Math.cos(@z.degrees_to_radians)
@@ -157,43 +229,65 @@ module CyberarmEngine
       Vector.new(_x, _y, _z)
     end
 
+    # returns an inverse {Vector}
+    # @return [CyberarmEngine::Vector]
     def inverse
       Vector.new(1.0 / @x, 1.0 / @y, 1.0 / @z)
     end
 
+    # Adds up values of {x}, {y}, and {z}
+    # @return [Integer|Float]
     def sum
       @x + @y + @z
     end
 
+    ##
+    # Linear interpolation: smoothly transition between two {Vector}
+    #
+    #   CyberarmEngine::Vector.new(100, 100, 100).lerp( CyberarmEngine::Vector.new(0, 0, 0), 0.75 )
+    #   # => <CyberarmEngine::Vector:0x0001 @x=75.0, @y=75.0, @z=75.0, @weight=0>
+    #
+    # @param other [CyberarmEngine::Vector | Integer | Float] value to subtract from
+    # @param factor [Float] how complete transition to _other_ is, in range [0.0..1.0]
+    # @return [CyberarmEngine::Vector]
     def lerp(other, factor)
       (self - other) * factor.clamp(0.0, 1.0)
     end
 
     # 2D distance using X and Y
+    # @return [Float]
     def distance(other)
-      Math.sqrt((@x-other.x)**2 + (@y-other.y)**2)
+      Math.sqrt((@x - other.x)**2 + (@y - other.y)**2)
     end
 
     # 2D distance using X and Z
+    # @return [Float]
     def gl_distance2d(other)
-      Math.sqrt((@x-other.x)**2 + (@z-other.z)**2)
+      Math.sqrt((@x - other.x)**2 + (@z - other.z)**2)
     end
 
     # 3D distance using X, Y, and Z
+    # @return [Float]
     def distance3d(other)
-      Math.sqrt((@x-other.x)**2 + (@y-other.y)**2 + (@z-other.z)**2)
+      Math.sqrt((@x - other.x)**2 + (@y - other.y)**2 + (@z - other.z)**2)
     end
 
+    # Converts {Vector} to Array
+    # @return [Array]
     def to_a
       [@x, @y, @z, @weight]
     end
 
+    # Converts {Vector} to String
+    # @return [String]
     def to_s
       "X: #{@x}, Y: #{@y}, Z: #{@z}, Weight: #{@weight}"
     end
 
+    # Converts {Vector} to Hash
+    # @return [Hash]
     def to_h
-      {x: @x, y: @y, z: @z, weight: @weight}
+      { x: @x, y: @y, z: @z, weight: @weight }
     end
   end
-end
+end