author_engine 0.5.0 → 0.9.0

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

@@ -17,66 +17,88 @@ class AuthorEngine
       @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
+      @fps = 0
+      @counted_frames = 0
+      @frame_count_stated_at = 0
 
       @show_touch_controls = false
-      @touch_buttons = []
-      buttons = AuthorEngine::Part::OpalInput::BUTTONS
-      key_states = AuthorEngine::Part::OpalInput::KEY_STATES
-      @touch_buttons.push(
-        TouchButton.new(
-          label: "Up", color: @game.dark_gray, x: 137, y: `window.innerHeight/2 - #{125}`, width: 50, height: 50, side: :left,
-          contact_proc: proc { key_states[buttons["up"]] = true}, no_contact_proc: proc { key_states[buttons["up"]] = false}
-        ),
-        TouchButton.new(
-          label: "Down", color: @game.dark_gray, x: 137, y: `window.innerHeight/2 + 25`, width: 50, height: 50, side: :left,
-          contact_proc: proc { key_states[buttons["down"]] = true}, no_contact_proc: proc { key_states[buttons["down"]] = false}
-        ),
-
-        TouchButton.new(
-          label: "Left", color: @game.black, x: 175, width: 50, height: 50, side: :left,
-          contact_proc: proc { key_states[buttons["left"]] = true}, no_contact_proc: proc { key_states[buttons["left"]] = false}
-        ),
-        TouchButton.new(
-          label: "Right", color: @game.black, x: 100, width: 50, height: 50, side: :left,
-          contact_proc: proc { key_states[buttons["right"]] = true}, no_contact_proc: proc { key_states[buttons["right"]] = false}
-        ),
-
-
-        TouchButton.new(
-          label: "X", color: @game.red, x: 50, width: 50, height: 50, side: :right,
-          contact_proc: proc { key_states[buttons["x"]] = true}, no_contact_proc: proc { key_states[buttons["x"]] = false}
-        ),
-        TouchButton.new(
-          label: "Y", color: @game.yellow, x: 125, width: 50, height: 50, side: :right,
-          contact_proc: proc { key_states[buttons["y"]] = true}, no_contact_proc: proc { key_states[buttons["y"]] = false}
-        )
-      )
-      touch_handler_setup
+
+      @game_loaded = false
+
+      @loader_tasks = [
+        [
+          "Loading levels",
+          proc {
+            @levels  = @save_file.levels
+            @levels.each {|level| level.each {|sprite| sprite.x = sprite.x * @sprite_size; sprite.y = sprite.y * @sprite_size}}
+          }
+        ],
+
+        [
+          "Evaluating game",
+          proc {
+            @game.authorengine_eval_code
+          },
+        ],
+
+        [
+          "Loading sprites",
+          proc {
+            build_spritesheet_and_sprites_list
+          },
+        ],
+
+        [
+          "Setting up collision detection",
+          proc {
+            @collision_detection = AuthorEngine::CollisionDetection.new(@sprites, @levels, @save_file.sprites)
+            @game.authorengine_collision_detection = @collision_detection
+          },
+        ],
+
+        [
+          "Initializing game",
+          proc {
+            @game.init
+          },
+        ],
+
+        [
+          "Setting up touch controls",
+          proc {
+            @touch_joystick = TouchJoystick.new(radius: 50)
+            @touch_buttons = []
+            @touch_buttons.push(
+              TouchButton.new(
+                label: "X", color: @game.red, width: 50, height: 50, for_key: "x"
+                ),
+              TouchButton.new(
+                label: "Y", color: @game.yellow, width: 50, height: 50, for_key: "y"
+              )
+            )
+
+            @fullscreen_button = TouchButton.new(label: "Fullscreen", color: @game.black, width: 100, height: 50)
+            touch_handler_setup
+            reposition_touch_controls
+          },
+        ],
+
+        [
+          "Loading done",
+          proc {
+            @game_loaded = true
+          },
+        ],
+      ]
 
       return self
     end
@@ -94,7 +116,14 @@ class AuthorEngine
 
     def run_game
       `window.requestAnimationFrame(function() {#{run_game}})` # placed here to ensure next frame is called even if draw or update throw an error
-      `#{@game.canvas_context}.clearRect(0,0, window.innerWidth, window.innerHeight)`
+      width  = `window.innerWidth`
+      height = `window.innerHeight`
+      game_width = 128 * @game.authorengine_scale
+      game_height = 128 * @game.authorengine_scale
+
+      area_width  = (`window.innerWidth` - game_width) / 2
+
+      `#{@game.authorengine_canvas_context}.clearRect(#{area_width},0, #{game_width}, #{game_height})`
 
       @counted_frames+=1
 
@@ -104,25 +133,22 @@ class AuthorEngine
         @counted_frames = 0
       end
 
+      `#{@game.authorengine_canvas_context}.save()`
+      `#{@game.authorengine_canvas_context}.translate(window.innerWidth/2 - #{game_height/2}, 0)`
+      `#{@game.authorengine_canvas_context}.scale(#{@game.authorengine_scale}, #{@game.authorengine_scale})`
+      `#{@game.authorengine_canvas_context}.save()`
 
-      if @sprites.size == (@spritesheet_width/@sprite_size)*(@spritesheet_height/@sprite_size)
-        width = 128 * @game.scale
+      region = `new Path2D()`
+      `#{region}.rect(0, 0, 128, 128)`
+      `#{@game.authorengine_canvas_context}.clip(#{region})`
+      `#{@game.authorengine_canvas_context}.save()`
 
-        # `#{@canvas_context}.setTransform(1, 0, 0, 1, 0, 0)`
-        `#{@game.canvas_context}.save()`
-        `#{@game.canvas_context}.translate(window.innerWidth/2 - #{width/2}, 0)`
-        `#{@game.canvas_context}.scale(#{@game.scale}, #{@game.scale})`
-        `#{@game.canvas_context}.save()`
 
-        region = `new Path2D()`
-        `#{region}.rect(0, 0, 128, 128)`
-        `#{@game.canvas_context}.clip(#{region})`
-        `#{@game.canvas_context}.save()`
+      if @game_loaded or @loader_tasks.empty?
         draw
-
-        `#{@game.canvas_context}.restore()`
-        `#{@game.canvas_context}.restore()`
-        `#{@game.canvas_context}.restore()`
+        `#{@game.authorengine_canvas_context}.restore()`
+        `#{@game.authorengine_canvas_context}.restore()`
+        `#{@game.authorengine_canvas_context}.restore()`
 
         update
 
@@ -130,31 +156,89 @@ class AuthorEngine
           draw_touch_controls
           update_touch_controls
         end
+
       else
-        @game.draw_background
-        @game.text("Loading sprite #{@sprites.size}/#{(@spritesheet_width/@sprite_size)*(@spritesheet_height/@sprite_size)}.", 0, @game.height/2, 8)
+        task = @loader_tasks.shift
+        @game.rect(0, 0, @game.width, @game.height, @game.dark_purple)
+        @game.text("AuthorEngine v#{AuthorEngine::VERSION}", 2, @game.height / 2 - 20, 10)
+        @game.text("#{task[0]}...", 6, @game.height / 2 - 4, 8, 0, @game.light_gray)
+        @game.text("Empowered by Opal v#{Opal::VERSION}, a Ruby interpeter.", 4, @game.height - 6, 4, 0, @game.indigo)
+
+        `#{@game.authorengine_canvas_context}.restore()`
+        `#{@game.authorengine_canvas_context}.restore()`
+        `#{@game.authorengine_canvas_context}.restore()`
+
+        task[1].call
       end
 
       return nil
     end
 
     def draw_touch_controls
+      @fullscreen_button.draw
       @touch_buttons.each(&:draw)
+      @touch_joystick.draw
     end
 
     def update_touch_controls
-      active_buttons = []
-
-      @touch_buttons.each do |button|
-        @current_touches.each do |id, touch|
-          if touch.x.between?(button.x, button.x+button.width) && touch.y.between?(button.y, button.y+button.height)
-            active_buttons << button
-            button.active
-          end
+      @touch_buttons.each { |button| button.trigger?(@current_touches) }
+      @touch_joystick.update(@current_touches)
+    end
+
+    def reposition_touch_controls
+      return nil unless @touch_joystick
+
+      width  = `window.innerWidth`
+      height = `window.innerHeight`
+      game_width = 128 * @game.authorengine_scale
+      game_height = 128 * @game.authorengine_scale
+
+      # place controls under game
+      if width < height
+        area_width  = width
+        area_height = height - game_height
+
+        puts "space: width #{area_width} x height #{area_height}"
+
+        @touch_joystick.x = @touch_joystick.radius + @touch_joystick.radius
+        @touch_joystick.y = game_height + area_height / 2
+
+        padding = 10
+        last_x = 20
+        @touch_buttons.reverse.each do |button|
+          button.x = width - (last_x + button.width)
+          button.y = (height - area_height) + area_height / 2 - button.height / 2
+
+          last_x += button.width + padding
         end
+
+        @fullscreen_button.x = width - (width / 2 + @fullscreen_button.width / 2)
+        @fullscreen_button.y = height - @fullscreen_button.height
+
+      # place controls beside game
+      else
+        area_width  = (`window.innerWidth` - game_width) / 2
+        area_height = game_height
+
+        puts "space: width #{area_width} x height #{area_height}"
+
+        @touch_joystick.x = @touch_joystick.radius + @touch_joystick.radius
+        @touch_joystick.y = game_height / 2
+
+        padding = 10
+        last_x = 50
+        @touch_buttons.reverse.each do |button|
+          button.x = width - (last_x + button.width)
+          button.y = game_height / 2 - button.height / 2
+
+          last_x += button.width + padding
+        end
+
+        @fullscreen_button.x = width - @fullscreen_button.width
+        @fullscreen_button.y = 0
       end
 
-      (@touch_buttons - active_buttons).each(&:inactive)
+      return nil
     end
 
     def resize_canvas
@@ -162,17 +246,20 @@ class AuthorEngine
       height = `window.innerHeight`
 
       if width < height
-        @game.scale = `window.innerWidth / 128.0`
+        @game.authorengine_scale = `#{width} / 128.0`
       else
-        @game.scale = `window.innerHeight / 128.0`
+        @game.authorengine_scale = `#{height} / 128.0`
       end
 
-      `#{@game.canvas}.width  = #{width}`
-      `#{@game.canvas}.height = #{height}`
-      `#{@game.canvas}.style.width  = #{width}`
-      `#{@game.canvas}.style.height = #{height}`
+      `#{@game.authorengine_canvas}.width  = #{width}`
+      `#{@game.authorengine_canvas}.height = #{height}`
+      `#{@game.authorengine_canvas}.style.width  = #{width}`
+      `#{@game.authorengine_canvas}.style.height = #{height}`
+
+      `#{@game.authorengine_canvas_context}.imageSmoothingEnabled = false`
 
-      `#{@game.canvas_context}.imageSmoothingEnabled = false`
+      reposition_touch_controls
+      `#{@game.authorengine_canvas_context}.clearRect(0, 0, window.innerWidth, window.innerHeight)`
       return nil
     end
 
@@ -212,7 +299,6 @@ class AuthorEngine
         (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
@@ -221,19 +307,26 @@ class AuthorEngine
       return nil
     end
 
+    def fullscreen_changed
+      resize_canvas
+    end
+
     def show(update_interval = (1000.0 / 60))
       return unless RUBY_ENGINE == "opal"
 
       `window.addEventListener('resize', () => { #{resize_canvas} })`
-      `document.addEventListener('keydown', (event) => { #{AuthorEngine::Part::OpalInput::KEY_STATES[`event.key`] = true} })`
+      `document.addEventListener('keydown', (event) => { #{@show_touch_controls = false; AuthorEngine::Part::OpalInput::KEY_STATES[`event.key`] = true} })`
       `document.addEventListener('keyup',   (event) => { #{AuthorEngine::Part::OpalInput::KEY_STATES[`event.key`] = false} })`
 
-      `#{@game.canvas}.addEventListener('touchstart',  (event) => { #{@show_touch_controls = true; handle_touch_start(`event`); puts "Touch started..."} })`
-      `#{@game.canvas}.addEventListener('touchmove',   (event) => { #{handle_touch_move(`event`); puts "Touch moved..."} })`
-      `#{@game.canvas}.addEventListener('touchcancel', (event) => { #{handle_touch_cancel(`event`); puts "Touch canceled."} })`
-      `#{@game.canvas}.addEventListener('touchend',    (event) => { #{handle_touch_end(`event`); puts "Touch Ended."} })`
+      `#{@game.authorengine_canvas}.addEventListener('touchstart',  (event) => { #{@show_touch_controls = true; handle_touch_start(`event`)} })`
+      `#{@game.authorengine_canvas}.addEventListener('touchmove',   (event) => { #{handle_touch_move(`event`)} })`
+      `#{@game.authorengine_canvas}.addEventListener('touchcancel', (event) => { #{handle_touch_cancel(`event`)} })`
+      `#{@game.authorengine_canvas}.addEventListener('touchend',    (event) => { #{handle_touch_end(`event`)} })`
+
+      `#{@game.authorengine_canvas}.addEventListener('fullscreenchange',    () => { #{fullscreen_changed} })`
 
       `document.getElementById('loading').style.display = "none"`
+
       `window.requestAnimationFrame(function() {#{run_game}})`
       return nil
     end

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

@@ -2,8 +2,8 @@ class AuthorEngine
   class Part
     module OpalGraphics
       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})`
+        `#{@authorengine_canvas_context}.fillStyle = #{color}`
+        `#{@authorengine_canvas_context}.fillRect(#{x}, #{y}, #{width}, #{height})`
         return nil
       end
 
@@ -11,25 +11,25 @@ class AuthorEngine
         size = 16 # sprite size
         sprites = AuthorEngine::GameRunner.instance.sprites
 
-        `#{@canvas_context}.save()`
+        `#{@authorengine_canvas_context}.save()`
         if alpha <= 0
           alpha = 0
         else
           alpha = (alpha / 255.0)
         end
-        `#{@canvas_context}.globalAlpha = #{alpha}`
+        `#{@authorengine_canvas_context}.globalAlpha = #{alpha}`
 
-        `#{@canvas_context}.drawImage(#{sprites[sprite_sheet_index]}, #{x}, #{y})`
+        `#{@authorengine_canvas_context}.drawImage(#{sprites[sprite_sheet_index]}, #{x}, #{y})`
 
-        `#{@canvas_context}.restore()`
+        `#{@authorengine_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})`
+        `#{@authorengine_canvas_context}.font = #{font}`
+        `#{@authorengine_canvas_context}.fillStyle = #{color}`
+        `#{@authorengine_canvas_context}.textBaseline = "top"`
+        `#{@authorengine_canvas_context}.fillText(#{string}, #{x}, #{y})`
       end
 
       def level(index, z = 0)
@@ -45,24 +45,24 @@ class AuthorEngine
         _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]
+        raise "No sprite at '#{replacement_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})`
+        `#{@authorengine_canvas_context}.save()`
+        `#{@authorengine_canvas_context}.translate(#{x}, #{y})`
         block.call if block
-        `#{@canvas_context}.restore()`
+        `#{@authorengine_canvas_context}.restore()`
       end
 
       def rotate(angle, x = 0, y = 0, &block)
-        `#{@canvas_context}.save()`
-        `#{@canvas_context}.translate(#{x}, #{y})`
-        `#{@canvas_context}.rotate(#{angle})`
+        `#{@authorengine_canvas_context}.save()`
+        `#{@authorengine_canvas_context}.translate(#{x}, #{y})`
+        `#{@authorengine_canvas_context}.rotate(#{angle})`
         block.call if block
-        `#{@canvas_context}.restore()`
+        `#{@authorengine_canvas_context}.restore()`
       end
     end
   end

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

@@ -1,36 +1,57 @@
 class AuthorEngine
   class TouchButton
-    attr_reader :x, :y, :width, :height
-    def initialize(label:, color:, x:, y: nil, width:, height:, side:, contact_proc:, no_contact_proc:)
+    attr_accessor :x, :y
+    attr_reader :width, :height
+    def initialize(label:, color:, x: 0, y: 0, width:, height:, for_key: nil, &block)
       @label, @color, @x, @y, @width, @height = label, color, x, y, width, height
-      @side, @contact_proc, @no_contact_proc = side, contact_proc, no_contact_proc
+      @for_key = for_key
+      @block = block
+
+      @buttons    = AuthorEngine::Part::OpalInput::BUTTONS
+      @key_states = AuthorEngine::Part::OpalInput::KEY_STATES
 
       @game       = AuthorEngine::GameRunner.instance.game
-      @game_width = 128 * @game.scale
+      @game_width = 128 * @game.authorengine_scale
       @game_x     = `window.innerWidth/2 - #{@game_width/2}`
+    end
 
-      if @side == :left
-        @x = @game_x-@x
-      elsif @side == :right
-        @x = @game_x+@game_width+@x
-      else
-        raise "side must be :left or :right"
-      end
+    def draw
+      `#{@game.authorengine_canvas_context}.fillStyle = #{@color}`
+      `#{@game.authorengine_canvas_context}.fillRect(#{@x}, #{@y}, #{@width}, #{@height})`
 
-      @y = `window.innerHeight/2 - #{height}` unless @y.is_a?(Numeric)
+      font = "#{@height}px Connection, Consolas"
+      `#{@game.authorengine_canvas_context}.font = #{font}`
+      `#{@game.authorengine_canvas_context}.fillStyle = "white"`
+      `#{@game.authorengine_canvas_context}.textBaseline = "top"`
+      `#{@game.authorengine_canvas_context}.fillText(#{@label}, #{@x}, #{@y}, #{@width})`
     end
 
-    def draw
-      `#{@game.canvas_context}.fillStyle = #{@color}`
-      `#{@game.canvas_context}.fillRect(#{@x}, #{@y}, #{width}, #{width})`
+    def trigger?(touches)
+      triggered = false
+
+      touches.detect do |id, touch|
+        if touch.x.between?(@x, @x+@width) && touch.y.between?(@y, @y+@height)
+          triggered = true
+        end
+      end
+
+
+      if @for_key
+        active if triggered
+        inactive unless triggered
+      else
+        @block.call if @block && triggered
+      end
+
+      return triggered
     end
 
     def active
-      @contact_proc.call
+      @key_states[@buttons[@for_key]] = true
     end
 
     def inactive
-      @no_contact_proc.call
+      @key_states[@buttons[@for_key]] = false
     end
   end
 end