author_engine 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa9450a11aa87c07b6af55a87d7ebf3a68feaff0c671662e6662a14ebf45a004
-  data.tar.gz: 52c74e684c1d5c402083b5dfa7a630ad99d445ec5cd786db9fc3a3d324f7c9a4
+  metadata.gz: 0ac3f16a1dc192379088c8f74dde1e6dab90e5edeefa35e1bcb810c7017b6833
+  data.tar.gz: '0860cdd4a930f02a6654fbde557148d8e460bb3666e8e87c10a64ba81dffcf6e'
 SHA512:
-  metadata.gz: 5b0173f8357c12aadd3d0ac99e0a7b2c78d862d93bca6940d3f383be701e51d00dfd5c63ea7873fb7289778389846bbce2cdb5129c5e5bb6b8801895d0f5f018
-  data.tar.gz: a59df8c02965376c9824385f756516a5af44a4c88854c748a8246bf6f2929a63048e6c1f040214cbd193b5837d91f1ca24ab0161d3d9a9e8984a16fd8aafec61
+  metadata.gz: 91dc4eace8dcb2c8f3edae461cef1a515e5616a915dd19f7598df02e0fd6f0bab0e45f75713b40869aefa803b9db6cda0f48b0279d9f91cb6cf4a5fa16c4caad
+  data.tar.gz: 6ff618da871039a3786b1bdab78977914d41c7c10e45101ac19865aaee3c7ab3f771af7caec2577bcfb35c03372b1dbf9dfdf0a0af669b45a9ec5a8b77af33b9

data/.gitignore

@@ -7,5 +7,6 @@
 /spec/reports/
 /tmp/
 
-_*.rb
-*.authorengine
+**/_*.rb
+**/*.authorengine
+**/*.html

data/API.md

@@ -38,10 +38,30 @@ end
 ### milliseconds
   Milliseconds since game started
 
+# CollisionDetection
+### bounding_box(sprite_index)
+  returns the bounding_box for sprite
+### sprite_vs_sprite(sprite_index, sprite_x, sprite_y, target_sprite_index, target_x, target_y)
+  determine whether 2 sprites are colliding
+### sprite_vs_level(sprite_index, sprite_x, sprite_y, level)
+  returns an array of level tiles that sprite is colliding with. returns an empty array if non are colliding.
+### colliding_edge(sprite_index, sprite_x, sprite_y, target_sprite_index, target_x, target_y)
+  determine the edge of which sprite is colliding with with target
+### draw_sprite_box(sprite_index, sprite_x, sprite_y)
+  draws sprites bounding box
+### draw_level_boxes(level_index)
+  draws bounding boxes around each tile of level
+### render_bounding_box(sprite_index, box, sprite_x, sprite_y, edges = {}, z = Float::INFINITY)
+  draw bounding box around sprite with optional edges from colliding_edges to show colliding edges
+
 # Graphics
 ### rect(x = 0, y = 0, width = 1, height = 1, color = white, z = 0)
 ### sprite(sprite_sheet_index, x = 0, y = 0, z = 0, color = white)
 ### text(string, x = 0, y = 0, size = 4, z = 0, color = white)
+### level(level_index, z = 0)
+
+### swap(level_index, current_sprite, replacement_sprite)
+  Swap level's current_sprite with replacement_sprite
 
 ### translate(x, y, &block)
   Translate the contents of block by x and y

data/Gemfile.lock

@@ -1,17 +1,28 @@
 PATH
   remote: .
   specs:
-    author_engine (0.1.0)
+    author_engine (0.3.0)
       coderay (~> 1.1.2)
       gosu (~> 0.14.4)
+      opal (~> 0.11.4)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    ast (2.4.0)
     coderay (1.1.2)
     gosu (0.14.4)
+    hike (1.2.3)
     minitest (5.11.3)
+    opal (0.11.4)
+      ast (>= 2.3.0)
+      hike (~> 1.2)
+      parser (= 2.3.3.1)
+      sourcemap (~> 0.1.0)
+    parser (2.3.3.1)
+      ast (~> 2.2)
     rake (10.5.0)
+    sourcemap (0.1.1)
 
 PLATFORMS
   ruby
@@ -23,4 +34,4 @@ DEPENDENCIES
   rake (~> 10.0)
 
 BUNDLED WITH
-   1.16.3
+   1.17.2

data/README.md

@@ -8,19 +8,23 @@ A virtual console¹ that you code in Ruby.
 `gem install author_engine`
 
 ## Run
-`author_engine`
+`author_engine [filename] [options]`
+- Run AuthorEngine editor with optional filename argument to open project.
+
+`author_engine export filename`
+- Export project to web using [Opal](https://opalrb.com).
 ### Options
 `--native` Open AuthorEngine in fullscreen and maximized.
 
 # Interface
 ## Play
-![play_view](#)
+![play_view](https://raw.githubusercontent.com/cyberarm/author_engineV2/master/screenshots/play.png)
 ## Sprite Editor
-![sprite_editor_view](#)
+![sprite_editor_view](https://raw.githubusercontent.com/cyberarm/author_engineV2/master/screenshots/sprite_editor.png)
 ## Level Editor
 ![level_editor_view](#)
 ## Code Editor
-![code_editor_view](#)
+![code_editor_view](https://raw.githubusercontent.com/cyberarm/author_engineV2/master/screenshots/code_editor.png)
 
 
 ¹: Does not directly run any kind of assembly

data/author_engine.gemspec

@@ -30,10 +30,11 @@ Gem::Specification.new do |spec|
   end
   spec.bindir        = "bin"
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ["lib", "assets"]
 
   spec.add_dependency "gosu", "~> 0.14.4"
   spec.add_dependency "coderay", "~> 1.1.2"
+  spec.add_dependency "opal", "~> 0.11.4"
 
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"

data/bin/author_engine

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
 
 require "author_engine"
-AuthorEngine::Window.new.show
+require "author_engine/cli"
+
+AuthorEngine::CLI.new

data/lib/author_engine/button.rb

@@ -111,7 +111,7 @@ class AuthorEngine
         @image.draw(@x+@x_padding, @y+@y_padding, @z, (1 * window.square_scale), (1 * window.square_scale))
 
       else
-        raise "Nothing to draw! (text and image were nil or invalid types)"
+        raise "Nothing to draw! (label and image were nil or invalid types)"
       end
     end
 

data/lib/author_engine/cli.rb

@@ -0,0 +1,21 @@
+class AuthorEngine
+  class CLI
+    def initialize
+      if ARGV[0] && ARGV[0] == "export"
+        if ARGV[1] && ARGV[1].end_with?(".authorengine")
+          require "author_engine/game/opal/exporter"
+
+          AuthorEngine::OpalExporter.new(project_file: ARGV[1])
+        else
+          puts "author_engine export project [exported_name]"
+        end
+
+      elsif ARGV[0] && ARGV[0].end_with?(".authorengine")
+        # The Loader Container handles loading projects
+        AuthorEngine::Window.new.show
+      else
+        AuthorEngine::Window.new.show
+      end
+    end
+  end
+end

data/lib/author_engine/collision_detection/collision_detection.rb

@@ -0,0 +1,188 @@
+class AuthorEngine
+  class CollisionDetection
+    Color = Struct.new(:red, :green, :blue, :alpha)
+    BoundingBox = Struct.new(:x, :y, :width, :height)
+
+    def initialize(game_sprites, game_levels)
+      @game_sprites = game_sprites
+      @game_levels  = game_levels
+
+      @sprites= []
+      @levels = []
+
+      @known_collisions = []
+    end
+
+    def clear
+      @known_collisions.clear
+    end
+
+    def add_sprite(image_or_blob)
+      blob = nil
+      if RUBY_ENGINE != "opal"
+        blob = image_or_blob.to_blob
+      else
+        blob = []
+        `#{image_or_blob}.forEach(function(value) {#{blob << `value`}})`#.each {|n| blob << n}
+      end
+
+      @sprites << {blob: blob, box: bounding_box(blob)}
+    end
+
+    def add_level(level_array)
+      @levels << level_array # TODO: Put level's into an optimized structure for fast quadrant look-ups
+    end
+
+    def box(sprite_index)
+      @sprites[sprite_index][:box]
+    end
+
+    def sprite_vs_sprite(sprite_index, sprite_x, sprite_y, target_sprite_index, target_x, target_y)
+      bounding_boxes_intersect?(box(sprite_index), sprite_x, sprite_y, box(target_sprite_index), target_x, target_y)
+    end
+
+    def sprite_vs_level(sprite_index, sprite_x, sprite_y, level)
+      detected = []
+
+      collider = box(sprite_index)
+      @levels[level].each do |sprite|
+        if bounding_boxes_intersect?(collider, sprite_x, sprite_y, box(sprite.sprite), sprite.x, sprite.y)
+          detected << sprite
+        end
+      end
+
+      return detected
+    end
+
+    def colliding_edge(sprite_index, sprite_x, sprite_y, target_sprite_index, target_x, target_y)
+      sprite_box = box(sprite_index)
+      target_box = box(target_sprite_index)
+
+      edges = {top: false, left: false, right: false, bottom: false}
+
+      # https://gamedev.stackexchange.com/a/24091
+      wy = (sprite_box.width + target_box.width) * ((sprite_y - sprite_box.height) - (target_y - target_box.height/2));
+      hx = (sprite_box.height + target_box.height) * ((sprite_x - sprite_box.width) - (target_x - target_box.height/2));
+
+      if (wy > hx)
+        if (wy > -hx)
+          edges[:bottom] = true
+        else
+          edges[:left] = true
+        end
+      else
+        if (wy > -hx)
+          edges[:right] = true
+        else
+          edges[:top] = true
+        end
+      end
+
+      return edges
+    end
+
+    def debug_draw_sprite(sprite_index, sprite_x, sprite_y)
+      render_bounding_box(sprite_index, box(sprite_index), sprite_x, sprite_y)
+    end
+
+    def debug_draw_level(level_index)
+      @levels[level_index].each do |sprite|
+        render_bounding_box(sprite.sprite, box(sprite.sprite), sprite.x, sprite.y)
+      end
+    end
+
+    def render_bounding_box(sprite_index, box, sprite_x, sprite_y, edges = {}, z = Float::INFINITY, color = 0xc800ff00, collision_color = 0xc8ff00ff)
+      if RUBY_ENGINE == "opal"
+        color = "green"
+        collision_color = "red"
+      end
+      paint_color = color
+      # EDGE: TOP
+      # TOP LEFT TO TOP RIGHT
+      if edges[:top] then paint_color = collision_color; else paint_color = color; end
+      draw_line(
+        box.x + sprite_x, box.y + sprite_y,
+        box.x + sprite_x + box.width, box.y + sprite_y,
+        paint_color, z
+      )
+
+      # EDGE: RIGHT
+      # TOP RIGHT TO BOTTOM RIGHT
+      if edges[:right] then paint_color = collision_color; else paint_color = color; end
+      draw_line(
+        box.x + sprite_x + box.width, box.y + sprite_y,
+        box.x + sprite_x + box.width, box.y + sprite_y + box.height,
+        paint_color, z
+      )
+
+      # EDGE: BOTTOM
+      # BOTTOM RIGHT to BOTTOM LEFT
+      if edges[:bottom] then paint_color = collision_color; else paint_color = color; end
+      draw_line(
+        box.x + sprite_x + box.width, box.y + sprite_y + box.height,
+        box.x + sprite_x, box.y + sprite_y + box.height,
+        paint_color, z
+      )
+
+      # EDGE: LEFT
+      # BOTTOM LEFT TO TOP LEFT
+      if edges[:left] then paint_color = collision_color; else paint_color = color; end
+      draw_line(
+        box.x + sprite_x, box.y + sprite_y + box.height,
+        box.x + sprite_x, box.y + sprite_y,
+        paint_color, z
+      )
+    end
+
+    private
+    def bounding_boxes_intersect?(a, a_x, a_y,  b, b_x, b_y)
+      (a.x + a_x) <= (b.x + b_x + b.width)  && (a.x + a_x + a.width)  >= (b.x + b_x) &&
+      (a.y + a_y) <= (b.y + b_y + b.height) && (a.y + a_y + a.height) >= (b.y + b_y)
+    end
+
+    def draw_line(x, y, x2, y2, color, z = 0)
+      if RUBY_ENGINE == "opal"
+        `#{AuthorEngine::GameRunner.instance.game.canvas_context}.strokeStyle = #{color}`
+        `#{AuthorEngine::GameRunner.instance.game.canvas_context}.lineWidth = 1`
+
+        `#{AuthorEngine::GameRunner.instance.game.canvas_context}.beginPath()`
+        `#{AuthorEngine::GameRunner.instance.game.canvas_context}.moveTo(#{x}, #{y})`
+        `#{AuthorEngine::GameRunner.instance.game.canvas_context}.lineTo(#{x2}, #{y2})`
+        `#{AuthorEngine::GameRunner.instance.game.canvas_context}.stroke()`
+      else
+        Gosu.draw_line(x, y, color, x2, y2, color, z)
+      end
+    end
+
+    # returns alpha value of pixel at x and y
+    def solid_at?(blob, x, y)
+      width = 16
+
+      blob[(y * width + x) * 4 + 3].ord
+    end
+
+    def bounding_box(blob, size = 16)
+      box = BoundingBox.new(size, size, 0, 0)
+      size.times do |y|
+        size.times do |x|
+          if solid_at?(blob, x, y) > 0
+            box.x = x if x < box.x
+            box.y = y if y < box.y
+            box.width  = x if x > box.width
+            box.height = y if y > box.height
+          end
+        end
+      end
+
+      # Correct width/height
+      box.width  -= box.x
+      box.height -= box.y
+
+      # Correct off-by-1
+      box.width  += 1
+      box.height += 1
+
+      return box
+    end
+  end
+end

data/lib/author_engine/containers/loader.rb

@@ -26,6 +26,14 @@ class AuthorEngine
         @entering_name = true
       end
       @new_button.x = window.width - @new_button.width
+
+      if ARGV[0] && File.exists?(ARGV[0])
+        if ARGV[0].end_with?(".authorengine")
+          load(ARGV[0])
+        else
+          puts "AuthorEngine: #{ARGV[0]} is not a compatible file."
+        end
+      end
     end
 
     def load(filename)
@@ -54,7 +62,6 @@ class AuthorEngine
       Gosu.draw_rect(0, @new_button.y, window.width, @new_button.height, @header_color)
       @font.draw_text("AuthorEngine", 1*window.square_scale,@font.height/2,0)
       @new_button.draw
-      @font.draw_text(@list[@index].name, 0, 0, 0) if @list[@index]
 
       Gosu.clip_to(0, @font.height*2, window.width, window.height-(@font.height*4)) do
         y = (window.height/2-@font.height) - (@height/2)

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

@@ -0,0 +1,33 @@
+class AuthorEngine
+  class Part
+    module CollisionDetection
+      def bounding_box(sprite_index)
+        @collision_detection.box(sprite_index)
+      end
+
+      def colliding_edge(sprite_index, sprite_x, sprite_y, target_sprite_index, target_x, target_y)
+        @collision_detection.colliding_edge(sprite_index, sprite_x, sprite_y, target_sprite_index, target_x, target_y)
+      end
+
+      def sprite_vs_sprite(sprite_index, sprite_x, sprite_y, target_sprite_index, target_x, target_y)
+        @collision_detection.sprite_vs_sprite(sprite_index, sprite_x, sprite_y, target_sprite_index, target_x, target_y)
+      end
+
+      def sprite_vs_level(sprite_index, sprite_x, sprite_y, level)
+        @collision_detection.sprite_vs_level(sprite_index, sprite_x, sprite_y, level)
+      end
+
+      def draw_sprite_box(sprite_index, sprite_x, sprite_y)
+        @collision_detection.debug_draw_sprite(sprite_index, sprite_x, sprite_y)
+      end
+
+      def draw_level_boxes(level_index)
+        @collision_detection.debug_draw_level(level_index)
+      end
+
+      def render_bounding_box(sprite_index, box, sprite_x, sprite_y, edges = {}, z = Float::INFINITY)
+        @collision_detection.render_bounding_box(sprite_index, box, sprite_x, sprite_y, edges, z, nil, nil)
+      end
+    end
+  end
+end

data/lib/author_engine/game/game.rb

@@ -1,17 +1,43 @@
 class AuthorEngine
   class Game
     include AuthorEngine::Part::Common
+    include AuthorEngine::Part::CollisionDetection
     include AuthorEngine::Part::Colors
     include AuthorEngine::Part::Graphics
     include AuthorEngine::Part::Input
 
+    attr_accessor :scale, :canvas, :canvas_context
+    attr_accessor :collision_detection
     def initialize(code:)
-      @background_color = Gosu::Color::BLACK
+      if RUBY_ENGINE == "opal"
+        @scale  = 1.0
+        @canvas = `document.getElementById('canvas')`
+        @canvas_context = `#{@canvas}.getContext('2d')`
+      end
+
+      if RUBY_ENGINE != "opal"
+        @sprites = SpriteEditor.instance.sprites
+
+        @levels = []
+        # Create a "Deep Copy" to allow for swapping of a level's sprites without corrupting LevelEditor's version
+        LevelEditor.instance.levels.each do |level|
+          @levels << level.sort_by {|sprite| sprite.z}.map {|sprite| sprite.dup}
+        end
+        size = 16
+        @levels.each {|level| level.each {|sprite| sprite.x = sprite.x * size; sprite.y = sprite.y * size}}
+
+        @collision_detection = CollisionDetection.new(@sprites, @levels)
+
+        @sprites.each {|sprite| @collision_detection.add_sprite(sprite) }
+        @levels.each {|level| @collision_detection.add_level(level) }
+      end
+
+      @background_color = black
       self.instance_eval(code)
     end
 
     def draw_background
-      Gosu.draw_rect(0, 0, Window::VIEW_WIDTH, Window::VIEW_HEIGHT, @background_color)
+      rect(0, 0, width, height, @background_color)
     end
 
     def init

data/lib/author_engine/game/{parts → gosu/parts}/graphics.rb

@@ -20,11 +20,29 @@ class AuthorEngine
       end
 
       def sprite(index, x = 0, y = 0, z = 0, alpha = 255)
-        image = SpriteEditor.instance.sprites[index]
+        image = @sprites[index]
         raise "No sprite at '#{index}'!" unless image
         image.draw(x, y, z, 1,1, Gosu::Color.rgba(255,255,255, alpha))
       end
 
+      def level(index, z = 0)
+        _level = @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 = @levels[level]
+        raise "No level at '#{index}'!" unless _level
+        raise "No sprite at '#{current_sprite}'!" unless @sprites[current_sprite]
+        raise "No sprite at '#{current_sprite}'!" unless @sprites[replacement_sprite]
+
+        _level.each {|sprite| sprite.sprite = replacement_sprite if sprite.sprite == current_sprite}
+      end
+
       def translate(x, y, &block)
         Gosu.translate(x, y) do
           block.call if block

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

@@ -0,0 +1,157 @@
+require "opal"
+require "fileutils"
+
+class AuthorEngine
+  class OpalExporter
+    def initialize(project_file:)
+      @project_file = project_file
+
+      save(export)
+    end
+
+    def project_name
+      name = File.basename(@project_file, ".authorengine")
+      return name.split("_").map {|n| n.capitalize}.join(" ")
+    end
+
+    def stylesheet
+      %{
+@font-face { font-family: Connection; src: url('fonts/Connection.otf'); }
+@font-face { font-family: ConnectionBold; src: url('fonts/ConnectionBold.otf'); }
+
+body {
+  margin: 0;
+  padding: 0;
+  background: #222;
+}
+#canvas {
+  display: block;
+  margin: 0 auto;
+  cursor: none;
+}
+#loading {
+  font-family: Connection, sans serif;
+  color: white;
+  text-align: center;
+
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  width: 50%;
+  height: 30%;
+  margin: auto;
+}
+      }
+    end
+
+    def project
+      %{
+var projectString = `#{File.open(@project_file).read}`;
+      }
+    end
+
+    def game_runtime
+      program = %{
+require "opal"
+require "opal-parser"
+require "author_engine/opal"
+
+`var callback = function(){
+  \#{AuthorEngine::GameRunner.new(`projectString`).show}
+};
+
+if (
+    document.readyState === "complete" ||
+    (document.readyState !== "loading" && !document.documentElement.doScroll)
+) {
+  callback();
+} else {
+  document.addEventListener("DOMContentLoaded", callback);
+}`
+      }
+
+      builder = Opal::Builder.new
+      base_path = File.expand_path("../../../..", __FILE__)
+      builder.append_paths("#{base_path}")
+
+      puts "Transpiling to JavaScript using Opal..."
+
+
+      builder.build("opal")
+      builder.build("opal-parser")
+      builder.build_require("author_engine/opal")
+
+      builder.build_str(program, "(inline)").to_s
+    end
+
+    def template
+      %{
+<!doctype html5>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>#{project_name} | AuthorEngine</title>
+  </head>
+  <style>
+    #{stylesheet}
+  </style>
+  <body>
+    <h1 id="loading">Loading...</h1>
+    <canvas id="canvas">
+      <h1>Your Browser Does Not Support HTML5 Canvas!</h1>
+    </canvas>
+
+    <script>
+      // Add a small delay before loading application in order to finish loading page and show "Loading..."
+      window.setTimeout(function() {
+        var script = document.createElement('script');
+        script.src = "application.js";
+
+        document.head.appendChild(script);
+      }, 500);
+    </script>
+  </body>
+</html>
+      }
+    end
+
+    def export
+      template
+    end
+
+    def save(string)
+      filename  = File.basename(@project_file)
+      directory = File.expand_path(@project_file.sub(filename, ''))
+      name      = filename.sub(".authorengine", "")
+
+      export_path = "#{directory}/#{name}"
+      unless File.exists?(export_path)
+        Dir.mkdir(export_path)
+        unless File.exists?("#{export_path}/fonts")
+          Dir.mkdir("#{export_path}/fonts")
+        end
+      end
+
+      puts "Saving to \"#{export_path}\""
+      File.open("#{export_path}/#{name}.html", "w") do |file|
+        file.write(string)
+      end
+
+      File.open("#{export_path}/application.js", "w") do |file|
+        file.write(project)
+        file.write("\n\n\n")
+        file.write(game_runtime)
+      end
+
+      fonts_path = "#{File.expand_path("../../../../../", __FILE__)}/assets/fonts"
+      font_files = Dir.glob("#{fonts_path}/*")
+      font_files.each do |file|
+        FileUtils.cp(file, "#{export_path}/fonts/#{File.basename(file)}")
+      end
+
+      puts "Saved."
+    end
+  end
+end