scorched_earth 5.0.4.pre-java → 5.0.5.pre-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f00d9340bc3c2def8581c5632ff80cfb2c9a1c7b
-  data.tar.gz: 628dff9384fc39729eaa311a7c5377e5857bb606
+  metadata.gz: f5194b6a1289adc43e4d2e6a619f1f92919f1924
+  data.tar.gz: 5a5a91fb6b9dbd47e948fdbb1934b70976242dae
 SHA512:
-  metadata.gz: 6d50a62e49990eb185ff5a7c2b22d6e4d7ecc43efbb45b30a901496b30c12fdf19434c249e6752837ed3d8344e126e1d1f413000838cb8a041c65f12b25f2ccd
-  data.tar.gz: cb23c05a6f96ac3f4a82903331c5918f01e46e9b11b2ba77e18eeae7066abc0192cf75d8ca819070c5c3350ac8d3b9c44ec2e0e7db5c6b50cf1185804cc6f5dc
+  metadata.gz: 6d2f4458c1e45261dd3000dd32d41d93f1583ea2e7deb5f45ad6b40af29b0553a9e308b9f872fcd7fc0ebde40b7427b68710e9af0a4f60ff76b97f5a89f19100
+  data.tar.gz: e67a02cfd9786bef1a123bbdb8fdf5165961718652fcdd9842700d93bd89f49257760a212ab7e9e3ef0c5b3bf3c51eff91eeb5944b190dbcf6fc8091080c798d

data/bin/console

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env jruby
 
 require 'bundler/setup'
 require 'scorched_earth'

data/exe/scorched

@@ -2,4 +2,6 @@
 
 require_relative '../lib/scorched_earth'
 
-ScorchedEarth::GameWindow.new(800, 600).run
+game = ScorchedEarth::Game.new 800, 600
+
+ScorchedEarth::GameWindow.new(game.width, game.height, game).run

data/lib/scorched_earth/event_runner.rb

@@ -16,7 +16,7 @@ module ScorchedEarth
     end
 
     def process!
-      processing = queue.size.times.map { queue.pop }
+      processing = Array.new(queue.size) { queue.pop }
 
       processing.each do |event|
         subscribers.each do |klass, block|

data/lib/scorched_earth/events/{game_ending.rb → game_over.rb}

@@ -1,5 +1,5 @@
 module ScorchedEarth
   module Events
-    GameEnding = Struct.new(:time)
+    GameOver = Struct.new(:time)
   end
 end

data/lib/scorched_earth/events/{entity_created.rb → game_update.rb}

@@ -1,5 +1,5 @@
 module ScorchedEarth
   module Events
-    EntityCreated = Struct.new(:entity)
+    GameUpdate = Struct.new(:delta)
   end
 end

data/lib/scorched_earth/events/{entity_destroyed.rb → hit.rb}

@@ -1,5 +1,5 @@
 module ScorchedEarth
   module Events
-    EntityDestroyed = Struct.new(:entity)
+    Hit = Struct.new(:object, :radius)
   end
 end

data/lib/scorched_earth/game.rb

@@ -2,91 +2,77 @@ include Java
 
 import java.awt.Color
 
-require 'scorched_earth/helpers'
-require 'scorched_earth/terrain'
-require 'scorched_earth/player'
-require 'scorched_earth/shot'
-require 'scorched_earth/explosion'
-require 'scorched_earth/mouse'
-require 'scorched_earth/color_palette'
+require 'scorched_earth/objects/player'
+require 'scorched_earth/objects/shot'
+require 'scorched_earth/objects/explosion'
+require 'scorched_earth/objects/mouse'
 require 'scorched_earth/event_runner'
-require 'scorched_earth/events/entity_created'
-require 'scorched_earth/events/entity_destroyed'
-require 'scorched_earth/events/game_ending'
+require 'scorched_earth/events/game_update'
+require 'scorched_earth/subscribers/game_over/timeout'
+require 'scorched_earth/subscribers/game_update/collisions'
+require 'scorched_earth/subscribers/hit/deform'
+require 'scorched_earth/subscribers/hit/effect'
+require 'scorched_earth/subscribers/hit/radius'
+require 'scorched_earth/subscribers/mouse_moved'
+require 'scorched_earth/subscribers/mouse_pressed'
+require 'scorched_earth/subscribers/mouse_released/fire'
+require 'scorched_earth/subscribers/mouse_released/next_player'
+require 'scorched_earth/helpers'
+require 'scorched_earth/services/color_palette'
+require 'scorched_earth/services/deform'
+require 'scorched_earth/services/wave'
+require 'scorched_earth/renders'
 
 module ScorchedEarth
   class Game
     include Helpers
 
-    attr_reader :width, :height,
-                :color_palette, :entities, :mouse, :players, :terrain,
-                :event_runner
+    Subscribers.constants.each { |name| prepend Subscribers.const_get name }
+
+    attr_reader :width, :height, :mouse,
+                :event_runner, :color_palette, :objects, :players, :array
 
     def initialize(width, height)
       @width  = width
       @height = height
+      @mouse  = Mouse.new
     end
 
     def setup
-      @color_palette = ColorPalette.new Color.red, Color.yellow, Color.white
-      @entities      = []
+      @color_palette = Services::ColorPalette.new Color::RED, Color::YELLOW, Color::WHITE
       @event_runner  = EventRunner.new
-      @players       = Array.new(2) { |index| Player.new rand(width), color_palette.get("player_#{index}") }
-      @terrain       = Terrain.new width, height, rand(10), color_palette.get('terrain')
-      @mouse         = Mouse.new event_runner, players, terrain
-
-      register_events
+      @objects       = []
+      @array         = Services::Wave.new(width, height, phases = rand(10)).each.to_a # Array.new(width) { height / 4 }
+      @players       = Array.new(2) { x = rand(width); Player.new(x, array[x]) }
     end
 
     def update(delta)
-      event_runner.process!
+      @objects = objects
+                 .map { |object| object.update delta }
+                 .compact
 
-      @entities
-        .each   { |entity| entity.update delta }
-        .reject { |entity| terrain.fetch(entity.x, 0) < entity.y }
-        .each   { |entity| event_runner.publish Events::EntityDestroyed.new(entity) }
+      event_runner.publish Events::GameUpdate.new delta
+      event_runner.process!
     end
 
     def render(graphics)
       graphics.set_color color_palette.get('sky')
       graphics.fill_rect 0, 0, width, height
 
-      entities.each do |entity|
-        entity.draw graphics
-      end
+      Renders::Mouse.new(mouse, current_player).call(graphics, color_palette)
 
-      players.each do |player|
-        player.draw graphics, terrain[player.x]
-      end
+      objects.each { |object| Renders.find(object).call(graphics, color_palette) }
+      players.each { |player| Renders.find(player).call(graphics, color_palette) }
 
-      mouse.draw graphics
-
-      terrain.draw graphics
+      Renders::Map.new(array).call(graphics, color_palette)
     end
 
     def publish(event)
       event_runner.publish event
     end
 
-    private
-
-    def register_events
-      event_runner.subscribe Events::MousePressed,    &mouse.method(:mouse_pressed)
-      event_runner.subscribe Events::MouseReleased,   &mouse.method(:mouse_released)
-      event_runner.subscribe Events::MouseMoved,      &mouse.method(:mouse_moved)
-      event_runner.subscribe(Events::GameEnding)      { |event| event.time < Time.now ? setup : event_runner.publish(event) }
-      event_runner.subscribe(Events::EntityCreated)   { |event| entities << event.entity }
-      event_runner.subscribe(Events::EntityDestroyed) { |event| entities.delete event.entity }
-      event_runner.subscribe(Events::EntityDestroyed) do |event|
-        radius = 50
-        [event.entity]
-          .select { |entity| entity.is_a? Shot }
-          .select { |entity| entity.x < terrain.width && entity.x > 0 }
-          .each   { |entity| terrain.bite entity.x, radius }
-          .each   { |entity| event_runner.publish Events::EntityCreated.new(Explosion.new(entity.x, entity.y)) }
-          .select { |entity| players.any? { |player| inside_radius? entity.x - player.x, 0, radius } }
-          .each   { event_runner.publish Events::GameEnding.new(Time.now + 0.25) }
-      end
+    def current_player
+      players.first
     end
   end
 end

data/lib/scorched_earth/game_window.rb

@@ -8,7 +8,6 @@ import java.awt.Dimension
 import javax.swing.JPanel
 import java.awt.Color
 
-require 'scorched_earth/game'
 require 'scorched_earth/events/mouse_pressed'
 require 'scorched_earth/events/mouse_released'
 require 'scorched_earth/events/mouse_moved'
@@ -20,7 +19,8 @@ module ScorchedEarth
 
     attr_reader :buffer_strategy, :canvas, :game
 
-    def initialize(width, height)
+    def initialize(width, height, game)
+      @game      = game
       @container = JFrame.new
       @canvas    = Canvas.new
       @panel     = @container.get_content_pane
@@ -44,8 +44,6 @@ module ScorchedEarth
       @canvas.set_ignore_repaint true
       @canvas.create_buffer_strategy 2
       @buffer_strategy = @canvas.get_buffer_strategy
-
-      @game = ScorchedEarth::Game.new canvas.width, canvas.height
     end
 
     def run
@@ -58,9 +56,6 @@ module ScorchedEarth
         last_time = Time.now
         graphics  = buffer_strategy.get_draw_graphics
 
-        graphics.set_color Color.black
-        graphics.fill_rect 0, 0, canvas.width, canvas.height
-
         game.update delta
         game.render graphics
 

data/lib/scorched_earth/helpers.rb

@@ -41,6 +41,7 @@ module ScorchedEarth
       x**2 + y**2 < radius**2
     end
 
-    module_function :angle, :circle, :inside_radius?, :radians_to_degrees, :degrees_to_radians, :normalize_degrees, :offset_x, :offset_y
+    module_function :angle, :circle, :inside_radius?, :radians_to_degrees,
+                    :degrees_to_radians, :normalize_degrees, :offset_x, :offset_y
   end
 end

data/lib/scorched_earth/objects/explosion.rb

@@ -0,0 +1,17 @@
+module ScorchedEarth
+  class Explosion
+    attr_reader :x, :y, :radius
+
+    def initialize(x, y, radius = 25)
+      @x      = x
+      @y      = y
+      @radius = radius
+
+      freeze
+    end
+
+    def update(_delta)
+      self.class.new(x, y, radius + 25) if radius < 125
+    end
+  end
+end

data/lib/scorched_earth/objects/mouse.rb

@@ -0,0 +1,13 @@
+module ScorchedEarth
+  class Mouse
+    attr_reader :x, :y, :pressed_at
+
+    def initialize(x = nil, y = nil, pressed_at = nil)
+      @x          = x
+      @y          = y
+      @pressed_at = pressed_at
+
+      freeze
+    end
+  end
+end

data/lib/scorched_earth/objects/player.rb

@@ -0,0 +1,12 @@
+module ScorchedEarth
+  class Player
+    attr_reader :x, :y
+
+    def initialize(x, y)
+      @x     = x
+      @y     = y
+
+      freeze
+    end
+  end
+end

data/lib/scorched_earth/objects/shot.rb

@@ -0,0 +1,41 @@
+module ScorchedEarth
+  class Shot
+    class Trajectory < Array
+      def initialize(*args)
+        super
+
+        freeze
+      end
+
+      def update(*_args)
+        self
+      end
+    end
+
+    attr_reader :x, :y, :velocity_x, :velocity_y, :trajectory
+
+    def initialize(x, y, velocity_x, velocity_y, trajectory = Trajectory.new)
+      @x          = x
+      @y          = y
+      @velocity_x = velocity_x
+      @velocity_y = velocity_y
+      @trajectory = Trajectory.new trajectory + [[x, y]]
+
+      freeze
+    end
+
+    def update(delta)
+      self.class.new(
+        x + velocity_x * delta,
+        y + velocity_y * delta,
+        velocity_x,
+        velocity_y - gravity * delta,
+        trajectory
+      )
+    end
+
+    def gravity
+      2000
+    end
+  end
+end

data/lib/scorched_earth/renders/explosion.rb

@@ -0,0 +1,33 @@
+module ScorchedEarth
+  module Renders
+    class Explosion
+      attr_reader :explosion
+
+      def initialize(explosion)
+        @explosion = explosion
+      end
+
+      def call(graphics, *_args)
+        height = graphics.destination.height
+        y      = height - explosion.y - radius / 2
+
+        graphics.set_color color
+        graphics.fill_oval x, y, radius, radius
+      end
+
+      private
+
+      def color
+        Color::WHITE
+      end
+
+      def radius
+        explosion.radius
+      end
+
+      def x
+        explosion.x - radius / 2
+      end
+    end
+  end
+end

data/lib/scorched_earth/renders/map.rb

@@ -0,0 +1,76 @@
+include Java
+
+import java.awt.Transparency
+import java.awt.Image
+
+module ScorchedEarth
+  module Renders
+    class Map
+      module Cache
+        def to_image(graphics, color_palette)
+          cache(key) do
+            super
+          end
+        end
+
+        private
+
+        def key
+          array.join
+        end
+
+        def cache(key)
+          @@cache ||= {}
+
+          if value = @@cache[key]
+            value
+          else
+            @@cache = {}
+
+            @@cache[key] ||= begin
+              yield
+            end
+          end
+        end
+      end
+
+      prepend Cache
+
+      attr_reader :array
+
+      def initialize(array)
+        @array = array
+      end
+
+      def call(graphics, color_palette)
+        graphics.draw_image to_image(graphics, color_palette), 0, 0, nil
+      end
+
+      private
+
+      def to_image(graphics, color_palette)
+        height = graphics.destination.height
+        color  = color_palette.get(array.class.name)
+
+        image = graphics
+                .get_device_configuration
+                .create_compatible_image width, height, Transparency::TRANSLUCENT
+
+        image.set_acceleration_priority 1
+
+        array.each_with_index do |y, x|
+          image.graphics.tap do |image_graphics|
+            image_graphics.set_color color
+            image_graphics.draw_line x, height - y, x, height
+          end
+        end
+
+        image
+      end
+
+      def width
+        array.size
+      end
+    end
+  end
+end

data/lib/scorched_earth/renders/mouse.rb

@@ -0,0 +1,27 @@
+include Java
+
+import java.awt.BasicStroke
+
+module ScorchedEarth
+  module Renders
+    class Mouse
+      attr_reader :mouse, :player
+
+      def initialize(mouse, player)
+        @mouse  = mouse
+        @player = player
+      end
+
+      def call(graphics, color_palette)
+        return unless mouse.x && mouse.y
+
+        color  = color_palette.get(player.x)
+        height = graphics.destination.height
+
+        graphics.set_color color
+        graphics.setStroke BasicStroke.new 3
+        graphics.draw_line mouse.x, mouse.y, player.x, height - player.y
+      end
+    end
+  end
+end

data/lib/scorched_earth/renders/player.rb

@@ -0,0 +1,30 @@
+module ScorchedEarth
+  module Renders
+    class Player
+      attr_reader :player
+
+      def initialize(player)
+        @player = player
+      end
+
+      def call(graphics, color_palette)
+        color  = color_palette.get(player.x)
+        height = graphics.destination.height
+        y      = height - player.y - radius / 2
+
+        graphics.set_color color
+        graphics.fill_oval x, y, radius, radius
+      end
+
+      private
+
+      def x
+        player.x - radius / 2
+      end
+
+      def radius
+        25
+      end
+    end
+  end
+end

data/lib/scorched_earth/renders/shot.rb

@@ -0,0 +1,23 @@
+include Java
+
+import java.awt.Color
+import java.awt.BasicStroke
+import java.awt.geom.GeneralPath
+
+require 'scorched_earth/renders/trajectory'
+
+module ScorchedEarth
+  module Renders
+    class Shot
+      attr_reader :shot
+
+      def initialize(shot)
+        @shot = shot
+      end
+
+      def call(graphics, *_args)
+        ScorchedEarth::Renders::Trajectory.new(shot.trajectory).call(graphics, *_args)
+      end
+    end
+  end
+end

data/lib/scorched_earth/renders/trajectory.rb

@@ -0,0 +1,34 @@
+include Java
+
+import java.awt.Color
+import java.awt.BasicStroke
+import java.awt.geom.GeneralPath
+
+module ScorchedEarth
+  module Renders
+    class Trajectory
+      attr_reader :trajectory
+
+      def initialize(trajectory)
+        @trajectory = trajectory
+      end
+
+      def call(graphics, *_args)
+        height            = graphics.destination.height
+        path              = GeneralPath.new GeneralPath::WIND_NON_ZERO
+        first, *remaining = trajectory
+
+        path.move_to first[0], height - first[1]
+
+        remaining.each do |x, y|
+          path.line_to x, height - y
+        end
+
+        graphics.set_stroke BasicStroke.new 3.0, BasicStroke::CAP_ROUND, BasicStroke::JOIN_ROUND, 10.0, [10.0].to_java(:float), 0.0
+        graphics.set_color Color::WHITE
+
+        graphics.draw path
+      end
+    end
+  end
+end

data/lib/scorched_earth/renders.rb

@@ -0,0 +1,16 @@
+require 'scorched_earth/renders/explosion'
+require 'scorched_earth/renders/mouse'
+require 'scorched_earth/renders/player'
+require 'scorched_earth/renders/shot'
+require 'scorched_earth/renders/map'
+
+module ScorchedEarth
+  module Renders
+    def self.find(object)
+      class_name   = object.class.name.split('::').last
+      render_class = const_get class_name
+
+      render_class.new object
+    end
+  end
+end

data/lib/scorched_earth/services/cie94.rb

@@ -31,67 +31,67 @@ module ScorchedEarth
         delta_a = a_1 - a_2
         delta_b = b_1 - b_2
 
-        c_1 = Math.sqrt((a_1 ** 2) + (b_1 ** 2))
-        c_2 = Math.sqrt((a_2 ** 2) + (b_2 ** 2))
+        c_1 = Math.sqrt((a_1**2) + (b_1**2))
+        c_2 = Math.sqrt((a_2**2) + (b_2**2))
 
         delta_L = color_1[:L] - color_2[:L]
         delta_C = c_1 - c_2
 
-        delta_H2 = (delta_a ** 2) + (delta_b ** 2) - (delta_C ** 2)
+        delta_H2 = (delta_a**2) + (delta_b**2) - (delta_C**2)
 
         s_L = 1
         s_C = 1 + k_1 * c_1
         s_H = 1 + k_2 * c_1
 
-        composite_L = (delta_L / (k_L * s_L)) ** 2
-        composite_C = (delta_C / (k_C * s_C)) ** 2
-        composite_H = delta_H2 / ((k_H * s_H) ** 2)
+        composite_L = (delta_L / (k_L * s_L))**2
+        composite_C = (delta_C / (k_C * s_C))**2
+        composite_H = delta_H2 / ((k_H * s_H)**2)
 
         Math.sqrt(composite_L + composite_C + composite_H)
       end
 
       private
 
-      def to_xyz(color, color_space = :sRGB)
-        r, g, b = [ color.red, color.green, color.blue ].map { |v|
-          if (v > 0.04045)
-            (((v + 0.055) / 1.055) ** 2.4) * 100
+      def to_xyz(color, _color_space = :sRGB)
+        r, g, b = [color.red, color.green, color.blue].map do |v|
+          if v > 0.04045
+            (((v + 0.055) / 1.055)**2.4) * 100
           else
             (v / 12.92) * 100
           end
-        }
+        end
 
         # Convert using the RGB/XYZ matrix at:
         # http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html#WSMatrices
         {
-          :x => (r * 0.4124564 + g * 0.3575761 + b * 0.1804375),
-          :y => (r * 0.2126729 + g * 0.7151522 + b * 0.0721750),
-          :z => (r * 0.0193339 + g * 0.1191920 + b * 0.9503041)
+          x: (r * 0.4124564 + g * 0.3575761 + b * 0.1804375),
+          y: (r * 0.2126729 + g * 0.7151522 + b * 0.0721750),
+          z: (r * 0.0193339 + g * 0.1191920 + b * 0.9503041)
         }
       end
 
-      def to_lab(color, color_space = :sRGB, reference_white = [ 95.047, 100.00, 108.883 ])
+      def to_lab(color, _color_space = :sRGB, reference_white = [95.047, 100.00, 108.883])
         xyz = to_xyz color
 
         xr = xyz[:x] / reference_white[0]
         yr = xyz[:y] / reference_white[1]
         zr = xyz[:z] / reference_white[2]
 
-        epsilon = (216 / 24389.0)
-        kappa   = (24389 / 27.0)
+        epsilon = (216 / 24_389.0)
+        kappa   = (24_389 / 27.0)
 
-        fx, fy, fz = [ xr, yr, zr ].map do |t|
-          if (t > (epsilon))
-            t ** (1.0 / 3)
+        fx, fy, fz = [xr, yr, zr].map do |t|
+          if t > epsilon
+            t**(1.0 / 3)
           else # t <= epsilon
             ((kappa * t) + 16) / 116.0
           end
         end
 
         {
-          :L => ((116 * fy) - 16),
-          :a => (500 * (fx - fy)),
-          :b => (200 * (fy - fz))
+          L: ((116 * fy) - 16),
+          a: (500 * (fx - fy)),
+          b: (200 * (fy - fz))
         }
       end
     end