author_engine 0.1.0 → 0.3.0

data/lib/author_engine/game/opal/game_runner.rb

@@ -0,0 +1,158 @@
+class AuthorEngine
+  class GameRunner
+    def self.instance
+      @instance
+    end
+    def self.instance=(klass)
+      @instance = klass
+    end
+
+    attr_reader :save_file, :spritesheet, :sprites, :levels, :fps
+    attr_reader :game
+    def initialize(project_string)
+      AuthorEngine::GameRunner.instance=(self)
+
+      @save_file = AuthorEngine::SaveFile.new(nil)
+      @save_file.load(false, project_string)
+
+      size = 16
+
+      @levels  = @save_file.levels
+      @levels.each {|level| level.each {|sprite| sprite.x = sprite.x * size; sprite.y = sprite.y * size}}
+
+      @sprites = []
+      @spritesheet = nil
+      @spritesheet_width  = @save_file.sprites.columns
+      @spritesheet_height = @save_file.sprites.rows
+      @sprite_size = 16
+
+      @fps = 0
+      @counted_frames = 0
+      @frame_count_stated_at = 0
+
+      @game = Game.new(code: @save_file.code)
+      build_spritesheet_and_sprites_list
+      resize_canvas
+
+      @collision_detection = AuthorEngine::CollisionDetection.new(@sprites, @levels)
+      @game.collision_detection = @collision_detection
+
+      @levels.each {|level| @collision_detection.add_level(level) }
+
+      @game.init
+
+      return self
+    end
+
+    def draw
+      @game.draw_background
+      @game.draw
+      return nil
+    end
+
+    def update
+      @game.update
+      return nil
+    end
+
+    def run_game
+      `window.requestAnimationFrame(function() {#{run_game}})` # placed here to ensure next frame is called even if draw or update throw an error
+
+      @counted_frames+=1
+
+      if @game.milliseconds - @frame_count_stated_at >= 1000.0
+        @fps = @counted_frames
+        @frame_count_stated_at = @game.milliseconds
+        @counted_frames = 0
+      end
+
+
+      if @sprites.size == (@spritesheet_width/@sprite_size)*(@spritesheet_height/@sprite_size)
+        draw
+        update
+      else
+        @game.draw_background
+        @game.text("Loading sprite #{@sprites.size}/#{(@spritesheet_width/@sprite_size)*(@spritesheet_height/@sprite_size)}.", 0, @game.height/2, 8)
+      end
+
+      return nil
+    end
+
+    def resize_canvas
+      width  = `window.innerWidth`
+      height = `window.innerHeight`
+
+      if width < height
+        @game.scale = `window.innerWidth / 128.0`
+      else
+        @game.scale = `window.innerHeight / 128.0`
+      end
+
+      `#{@game.canvas}.width  = 128 * #{@game.scale}`
+      `#{@game.canvas}.height = 128 * #{@game.scale}`
+      `#{@game.canvas}.style.width  = 128 * #{@game.scale}`
+      `#{@game.canvas}.style.height = 128 * #{@game.scale}`
+
+      `#{@game.canvas_context}.scale(#{@game.scale}, #{@game.scale})`
+      `#{@game.canvas_context}.imageSmoothingEnabled = false`
+      return nil
+    end
+
+    def build_spritesheet_and_sprites_list
+      spritesheet_data = @save_file.sprites
+      width = spritesheet_data.columns
+      height= spritesheet_data.rows
+      size  = 16
+
+      temp_canvas = `document.createElement('canvas')`
+      temp_canvas_context = `#{temp_canvas}.getContext('2d')`
+      `#{temp_canvas}.width  = #{spritesheet_data.columns}`
+      `#{temp_canvas}.height = #{spritesheet_data.rows}`
+
+      buffer = `new Uint8ClampedArray(#{spritesheet_data.to_blob})`
+      image_data = `new ImageData(#{buffer}, #{width})`
+      `#{temp_canvas_context}.putImageData(#{image_data}, 0, 0)`
+
+      @spritesheet = `new Image()`
+      `#{@spritesheet}.onload = function() { #{load_sprites} }`
+      `#{@spritesheet}.src = #{temp_canvas}.toDataURL()`
+
+    end
+
+    def load_sprites
+      spritesheet_data = @save_file.sprites
+      width = spritesheet_data.columns
+      height= spritesheet_data.rows
+      size  = 16
+
+      temp_canvas = `document.createElement('canvas')`
+      temp_canvas_context = `#{temp_canvas}.getContext('2d')`
+      `#{temp_canvas}.width  = #{size}`
+      `#{temp_canvas}.height = #{size}`
+
+      (height/size).times do |y|
+        (width/size).times do |x|
+          `#{temp_canvas_context}.clearRect(0,0, #{size}, #{size})`
+          `#{temp_canvas_context}.drawImage(#{@spritesheet}, #{x * size}, #{y * size}, #{size}, #{size}, 0, 0, #{size}, #{size})`
+          @collision_detection.add_sprite(`#{temp_canvas_context}.getImageData(0,0, #{size}, #{size}).data`)
+
+          `createImageBitmap(#{@spritesheet}, #{x * size}, #{y * size}, #{size}, #{size}).then(sprite => { #{@sprites.push(`sprite`)} })`
+        end
+      end
+
+      return nil
+    end
+
+    def show(update_interval = (1000.0 / 60))
+      return unless RUBY_ENGINE == "opal"
+
+      `window.addEventListener('resize', () => { #{resize_canvas} })`
+      `document.addEventListener('keydown', (event) => { #{AuthorEngine::Part::Input::KEY_STATES[`event.key`] = true} })`
+      `document.addEventListener('keyup',   (event) => { #{AuthorEngine::Part::Input::KEY_STATES[`event.key`] = false} })`
+
+      `document.getElementById('loading').style.display = "none"`
+      `window.requestAnimationFrame(function() {#{run_game}})`
+      return nil
+    end
+  end
+end

data/lib/author_engine/game/opal/parts/colors.rb

@@ -0,0 +1,64 @@
+class AuthorEngine
+  class Part
+    module Colors
+      Color = Struct.new(:red, :green, :blue)
+      COLORS = {
+        0 => Color.new(0,0,0),
+        1 => Color.new(29, 43, 83),
+        2 => Color.new(126, 37, 83),
+        3 => Color.new(0, 135, 81),
+
+        4 => Color.new(171, 82, 54),
+        5 => Color.new(95, 87, 79),
+        6 => Color.new(194, 195, 199),
+        7 => Color.new(255, 241, 232),
+
+        8  => Color.new(255, 0, 77),
+        9  => Color.new(255, 163, 0),
+        10 => Color.new(225, 236, 39),
+        11 => Color.new(0, 228, 54),
+
+        12 => Color.new(41, 173, 255),
+        13 => Color.new(131, 118, 156),
+        14 => Color.new(225, 119, 168),
+        15 => Color.new(255, 204, 170)
+      }
+
+      def black;       rgb(COLORS.dig(0)); end
+      def dark_blue;   rgb(COLORS.dig(1)); end
+      def dark_purple; rgb(COLORS.dig(2)); end
+      def dark_green;  rgb(COLORS.dig(3)); end
+
+      def brown;       rgb(COLORS.dig(4)); end
+      def dark_gray;   rgb(COLORS.dig(5)); end
+      def light_gray;  rgb(COLORS.dig(6)); end
+      def white;       rgb(COLORS.dig(7)); end
+
+      def red;         rgb(COLORS.dig(8)); end
+      def orange;      rgb(COLORS.dig(9)); end
+      def yellow;      rgb(COLORS.dig(10)); end
+      def green;       rgb(COLORS.dig(11)); end
+
+      def blue;        rgb(COLORS.dig(12)); end
+      def indigo;      rgb(COLORS.dig(13)); end
+      def pink;        rgb(COLORS.dig(14)); end
+      def peach;       rgb(COLORS.dig(15)); end
+
+      def rgb(color)
+        return "rgb(#{color.red}, #{color.green}, #{color.blue})"
+      end
+
+      def xml_color(color)
+        red   = color.red.to_s(16)
+        green = color.green.to_s(16)
+        blue  = color.blue.to_s(16)
+
+        red   = "0#{red}"   if color.red < 10
+        green = "0#{green}" if color.green < 10
+        blue  = "0#{blue}"  if color.blue < 10
+
+        return "#{red}#{green}#{blue}"
+      end
+    end
+  end
+end

data/lib/author_engine/game/opal/parts/common.rb

@@ -0,0 +1,13 @@
+class AuthorEngine
+  class Part
+    module Common
+      def width; 128; end
+      def height; 128; end
+      def fps; AuthorEngine::GameRunner.instance.fps; end
+      def milliseconds
+        @__initial_milliseconds ||= `performance.now()`
+        (`performance.now()` - @__initial_milliseconds).round(3)
+      end
+    end
+  end
+end

data/lib/author_engine/game/opal/parts/graphics.rb

@@ -0,0 +1,69 @@
+class AuthorEngine
+  class Part
+    module Graphics
+      def rect(x = 0, y = 0, width = 1, height = 1, color = "white", z = 0)
+        `#{@canvas_context}.fillStyle = #{color}`
+        `#{@canvas_context}.fillRect(#{x}, #{y}, #{width}, #{height})`
+        return nil
+      end
+
+      def sprite(sprite_sheet_index, x = 0, y = 0, z = 0, alpha = 255)
+        size = 16 # sprite size
+        sprites = AuthorEngine::GameRunner.instance.sprites
+
+        `#{@canvas_context}.save()`
+        if alpha <= 0
+          alpha = 0
+        else
+          alpha = (alpha / 255.0)
+        end
+        `#{@canvas_context}.globalAlpha = #{alpha}`
+
+        `#{@canvas_context}.drawImage(#{sprites[sprite_sheet_index]}, #{x}, #{y})`
+
+        `#{@canvas_context}.restore()`
+      end
+
+      def text(string, x = 0, y = 0, size = 4, z = 0, color = "white")
+        font = "#{size}px Connection, Consolas"
+        `#{@canvas_context}.font = #{font}`
+        `#{@canvas_context}.fillStyle = #{color}`
+        `#{@canvas_context}.textBaseline = "top"`
+        `#{@canvas_context}.fillText(#{string}, #{x}, #{y})`
+      end
+
+      def level(index, z = 0)
+        _level = AuthorEngine::GameRunner.instance.levels[index]
+        raise "No level at '#{index}'!" unless _level
+
+        _level.each do |sprite|
+          sprite(sprite.sprite, sprite.x, sprite.y, z)
+        end
+      end
+
+      def swap(level, current_sprite, replacement_sprite)
+        _level = AuthorEngine::GameRunner.instance.levels[level]
+        raise "No level at '#{index}'!" unless _level
+        raise "No sprite at '#{current_sprite}'!" unless AuthorEngine::GameRunner.instance.sprites[current_sprite]
+        raise "No sprite at '#{current_sprite}'!" unless AuthorEngine::GameRunner.instance.sprites[replacement_sprite]
+
+        _level.each {|sprite| sprite.sprite = replacement_sprite if sprite.sprite == current_sprite}
+      end
+
+      def translate(x, y, &block)
+        `#{@canvas_context}.save()`
+        `#{@canvas_context}.translate(#{x}, #{y})`
+        block.call if block
+        `#{@canvas_context}.restore()`
+      end
+
+      def rotate(angle, x = 0, y = 0, &block)
+        `#{@canvas_context}.save()`
+        `#{@canvas_context}.translate(#{x}, #{y})`
+        `#{@canvas_context}.rotate(#{angle})`
+        block.call if block
+        `#{@canvas_context}.restore()`
+      end
+    end
+  end
+end

data/lib/author_engine/game/opal/parts/input.rb

@@ -0,0 +1,30 @@
+class AuthorEngine
+  class Part
+    module Input
+      BUTTONS = {
+        "left"  => "ArrowLeft",
+        "right" => "ArrowRight",
+        "up"    => "ArrowUp",
+        "down"  => "ArrowDown",
+        "x"     => "x",
+        "y"     => "c",
+      }
+
+      # Store keys state
+      KEY_STATES = {
+      }
+
+      def button?(name)
+        down = false
+
+        if BUTTONS.dig(name)
+          down = KEY_STATES.dig(BUTTONS.dig(name)) # dig returns false if key not found
+        else
+          raise "Button '#{name}' not found!"
+        end
+
+        return down
+      end
+    end
+  end
+end

data/lib/author_engine/image.rb

@@ -12,6 +12,7 @@ class AuthorEngine
     def height; @image.height; end
 
     def image_from_cache(path)
+      path = "#{File.expand_path("../../../", __FILE__)}/#{path}"
       image = nil
       if image = CACHE.dig(path)
         return image

data/lib/author_engine/level_picker.rb

@@ -0,0 +1,92 @@
+class AuthorEngine
+  class LevelPicker
+    include Support
+
+    attr_reader :x, :y, :z, :width, :height, :offset
+    attr_reader :active_level, :active_layer
+    def initialize(x: nil, y: nil, z: 15)
+      @x, @y, @z = x, y, z
+
+      @offset = 1 * window.square_scale
+      @width = window.width - @offset * 4
+      @height = (window.sprite_size * window.square_scale) + @offset * 2
+
+      @x = window.width / 2 - self.width / 2
+
+      @current_level = AuthorEngine::Text.new(y: @y + @offset*2, z: @z + 1)
+
+      @active_level = 0
+      @active_layer = 0
+
+      @max_layers = 16
+
+      @buttons = []
+
+      @buttons << Button.new(label: "-", color: Gosu::Color::GRAY,  x: (window.width / 2) - @offset*8, y: @y + @offset*2, z: 18, tooltip: "↓ Decrease Layer") do
+        @active_layer-=1 unless @active_layer < 1
+      end
+      @buttons << Button.new(label: "+", color: Gosu::Color::GRAY, x: (@buttons.last.x + @buttons.last.width) + @offset*2, y: @y + @offset*2, z: 18, tooltip: "↑ Increase Layer") do
+        @active_layer+=1 if @active_layer < @max_layers
+      end
+
+      @buttons << Button.new(label: "<", x: (@x + @width) - @width/3, y: @y + @offset*2, z: 18, tooltip: "← Previous Level", color: Gosu::Color::GRAY) do
+        @active_level-=1
+        @active_level = LevelEditor.instance.levels.size - 1 if @active_level < 0
+      end
+
+      @buttons << Button.new(label: "-", x: @buttons.last.x + @buttons.last.width + @offset, y: @y + @offset*2, z: 18, tooltip: "Destroy Level (Non-recoverable)", color: Gosu::Color::RED) do
+        if LevelEditor.instance.levels[@active_level].is_a?(Array)
+          LevelEditor.instance.levels.delete_at(@active_level)
+          @active_level-=1
+        end
+
+        if LevelEditor.instance.levels.size == 0
+          LevelEditor.instance.levels.push([])
+          @active_level = LevelEditor.instance.levels.size - 1
+        end
+      end
+
+      @buttons << Button.new(label: "+", x: @buttons.last.x + @buttons.last.width + @offset, y: @y + @offset*2, z: 18, tooltip: "Add Level", color: Gosu::Color::GREEN) do
+        LevelEditor.instance.levels.push([])
+        @active_level = LevelEditor.instance.levels.size - 1
+      end
+
+
+      @buttons << Button.new(label: ">", x: @buttons.last.x + @buttons.last.width + @offset, y: @y + @offset*2, z: 18, tooltip: "→ Next Level", color: Gosu::Color::GRAY) do
+        @active_level+=1
+        @active_level = 0 if @active_level >= LevelEditor.instance.levels.size - 1
+      end
+    end
+
+    def draw
+      Gosu.draw_rect(@x, @y, @width, @height, Gosu::Color.rgba(255,255,255,220), @z)
+      Gosu.draw_rect(@x+4, @y+4, @width-8, @height-8, Gosu::Color.rgba(10, 10, 10,200), @z)
+
+      @buttons.each(&:draw)
+
+      @current_level.message = "Level: #{@active_level}\nLayer: #{@active_layer}/#{@max_layers}"
+      @current_level.x = @x + @offset*2
+      @current_level.draw
+    end
+
+    def button_up(id)
+      @buttons.each {|b| b.button_up(id) }
+
+      case id
+      when Gosu::KbUp
+        @active_layer+=1 if @active_layer < @max_layers
+
+      when Gosu::KbDown
+        @active_layer-=1 unless @active_layer < 1
+
+      when Gosu::KbLeft
+        @active_level -= 1
+        @active_level = LevelEditor.instance.levels.size - 1 if @active_level < 0
+
+      when Gosu::KbRight
+        @active_level += 1
+        @active_level = 0 unless @active_level < LevelEditor.instance.levels.size
+      end
+    end
+  end
+end

data/lib/author_engine/opal.rb

@@ -0,0 +1,15 @@
+raise "Only require \"author_engine/opal\" with Opal!" unless RUBY_ENGINE == "opal"
+
+require_relative "game/common/parts/collision_detection"
+
+require_relative "game/opal/parts/common"
+require_relative "game/opal/parts/colors"
+require_relative "game/opal/parts/graphics"
+require_relative "game/opal/parts/input"
+
+require_relative "collision_detection/collision_detection"
+require_relative "sprite"
+
+require_relative "game/game"
+require_relative "save_file"
+require_relative "game/opal/game_runner"

data/lib/author_engine/save_file.rb

@@ -23,7 +23,7 @@ class AuthorEngine
 
       @code, @sprites, @levels = nil, nil, nil
 
-      load
+      load unless RUBY_ENGINE == "opal"
     end
 
     def save
@@ -64,23 +64,29 @@ class AuthorEngine
 
     def save_levels
       @buffer+= "___LEVELS___\n"
-      # @buffer+= LevelEditor.instance.levels
-      @buffer+="\n"
+      LevelEditor.instance.levels.each do |level|
+        @buffer+= "#{level.map {|s| "#{s.sprite},#{s.x},#{s.y},#{s.z}"}.join(",")}\n"
+      end
+      @buffer.strip # Level is the last element saved
     end
 
-    def load
-      file = ""
-      File.open(@file, "r") {|f| file = f.read}
+    def load(from_file = true, data = nil)
+      string = ""
+      if from_file
+        File.open(@file, "r") {|f| string = f.read}
+      else
+        string = data
+      end
 
-      load_code(file)
-      load_spritesheet(file)
-      load_levels(file)
+      load_code(string)
+      load_spritesheet(string)
+      load_levels(string)
     end
 
-    def load_code(file)
+    def load_code(string)
       buffer = ""
       in_code= false
-      file.each_line do |line|
+      string.each_line do |line|
         if line.start_with?("___CODE___")
           in_code = true
           next
@@ -95,13 +101,13 @@ class AuthorEngine
       @code = buffer
     end
 
-    def load_spritesheet(file)
+    def load_spritesheet(string)
       buffer = ""
       width  = 0
       height = 0
       in_sprites = false
 
-      file.each_line do |line|
+      string.each_line do |line|
         if line.strip.start_with?("___SPRITES___")
           in_sprites = true
           next
@@ -123,12 +129,40 @@ class AuthorEngine
         buffer += line.strip
       end
 
-      stream = buffer.scan(/../).map { |x| x.hex }.pack('c*')
+      stream = nil
+      if RUBY_ENGINE != "opal"
+        stream = buffer.scan(/../).map { |x| x.hex }.pack('c*')
+      else
+        stream = buffer.scan(/../).map { |x| Integer(x.hex) }
+      end
 
       @sprites = SpriteSheetData.new(width, height, stream)
     end
 
-    def load_levels(file)
+    def load_levels(string)
+      levels   = []
+      in_level = false
+
+      string.each_line do |line|
+        if line.start_with?("___LEVELS___")
+          in_level = true
+          next
+        end
+        if line.start_with?("___") && in_level
+          break
+        end
+
+        if in_level
+          level = []
+          # 0 - Sprite, 1 - X, 2 - Y, 3 - Z
+          line.strip.split(",").each_slice(4) do |sprite|
+            level << Sprite.new(Integer(sprite[0]), Integer(sprite[1]), Integer(sprite[2]), Integer(sprite[3]))
+          end
+          levels << level
+        end
+      end
+
+      @levels = levels
     end
   end
 end

data/lib/author_engine/sprite.rb

@@ -1,4 +1,3 @@
 class AuthorEngine
-  class Sprite
-  end
+  Sprite = Struct.new(:sprite, :x, :y, :z)
 end

data/lib/author_engine/sprite_picker.rb

@@ -4,7 +4,7 @@ class AuthorEngine
 
     attr_reader :active_sprite
     attr_reader :x, :y, :width, :height
-    attr_reader :rows, :columns
+    attr_reader :rows, :columns, :offset
     def initialize(x: nil, y:, width: nil, height: nil)
       @x, @y, @width, @height = x, y, width, height
       @sprite_size = window.sprite_size
@@ -21,19 +21,26 @@ class AuthorEngine
 
       @offset = 1 * window.square_scale
       @tooltip = AuthorEngine::Text.new(message: "", z: 100)
-      @current_page = AuthorEngine::Text.new(message: "Page 0", size: 20, x: window.width/2, y: @y - 24, z: 100)
+      @current_page = AuthorEngine::Text.new(message: "Page 0", size: 20, x: window.width/2, z: 100)
 
       @page = 0
     end
 
+    def y=(n)
+      @y = n
+    end
+
     def draw
-      Gosu.draw_rect(@x-@offset, @y-@offset, @width+(@offset*2), @height+(@offset*2), Gosu::Color::WHITE, 15)
+      @current_page.y = @y - 24
+
+      Gosu.draw_rect(@x-@offset, @y-@offset, @width+(@offset*2), @height+(@offset*2), Gosu::Color.rgba(255,255,255,220), 15)
       Gosu.draw_rect(@x, @y, @width, @height, Gosu::Color.rgba(10, 10, 10, 200), 15)
       draw_grid
       draw_sprites
 
       draw_and_update_tooltip
       @current_page.message = "Page #{@page}"
+      @current_page.x = @width/2 - @current_page.width/2
       @current_page.draw
     end
 

data/lib/author_engine/text.rb

@@ -1,8 +1,8 @@
 class AuthorEngine
   class Text
     include Support
-    FONT_DEFAULT = "assets/fonts/Connection.otf"
-    FONT_DEFAULT_BOLD = "assets/fonts/ConnectionBold.otf"
+    FONT_DEFAULT      = "#{File.expand_path("../../../", __FILE__)}/assets/fonts/Connection.otf"
+    FONT_DEFAULT_BOLD = "#{File.expand_path("../../../", __FILE__)}/assets/fonts/ConnectionBold.otf"
 
     attr_accessor :message, :x, :y, :z, :color
     attr_reader :size, :font

data/lib/author_engine/version.rb

@@ -1,3 +1,3 @@
 class AuthorEngine
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end