author_engine 0.1.0

data/lib/author_engine/views/code_editor.rb

@@ -0,0 +1,154 @@
+class AuthorEngine
+  class CodeEditor < View
+
+    class CodeInput < Gosu::TextInput
+      def filter(text_in)
+        return text_in
+      end
+    end
+
+    DEFAULT_STRING = <<-EOF
+def init
+  @size = 10
+  @x    = width/2  - @size/2
+  @y    = height/2 - @size/2
+end
+
+def draw
+  rect(@x, @y, @size, @size, pink)
+  text("x: \#{@x}, y: \#{@y}", 0, 0, 8)
+end
+
+def update
+  @x+=1 if button?("right")
+  @x-=1 if button?("left")
+  @y-=1 if button?("up")
+  @y+=1 if button?("down")
+
+  @x = 0            if @x < 0
+  @x = 128-@size if @x > 128-@size
+
+  @y = 0            if @y < 0
+  @y = 128-@size if @y > 128-@size
+end
+    EOF
+
+
+    attr_accessor :x_offset, :y_offset
+    def setup
+      @font_size = 5 * window.square_scale.floor
+      @font = Gosu::Font.new(@font_size, name: Text::FONT_DEFAULT_BOLD) # "Consolas"
+      @line_numbers_spacing = "00"
+      @line_numbers_width   = @font.text_width(@line_numbers_spacing)
+
+      @text_input = CodeInput.new
+      if window.container.savefile.code.nil?
+        @text_input.text = DEFAULT_STRING
+      else
+        @text_input.text = window.container.savefile.code
+      end
+      @text = AuthorEngine::Text.new(message: "", size: @font_size, x: @line_numbers_width+@x_padding, y: window.container.header_height, font: Text::FONT_DEFAULT) # "DejaVu Sans Mono"
+
+      @cursor = Cursor.new(view: self, text_input: @text_input, text: @text)
+      @highlighting = Highlighting.new
+
+      @x_offset, @y_offset = 0, 0
+    end
+
+    def focus
+      window.text_input = @text_input
+      window.caption = "Code Editor"
+    end
+
+    def blur
+      window.text_input = nil
+    end
+
+    def draw
+      # Gosu.draw_rect(0, window.container.header_height, @width, @height, white)
+      super
+      Gosu.clip_to(0, window.container.header_height, window.width, window.height - window.container.header_height) do
+        Gosu.draw_rect(0, window.container.header_height, @line_numbers_width, @height, dark_gray)
+
+        Gosu.translate(0, @y_offset) do
+          min_width = @font.text_width("0")+@x_padding
+          (@text.message.lines.map(&:chomp)).each_with_index do |line, index|
+            min_width = @font.text_width("#{index+1}") if @font.text_width("#{index+1}") > min_width
+
+            @font.draw_text("#{index+1}", 1, window.container.header_height + (@font.height * index), 0)
+          end
+
+          @line_numbers_width = min_width
+          @text.x = @line_numbers_width+@x_padding
+        end
+      end
+
+      Gosu.clip_to(@line_numbers_width, window.container.header_height, window.width, @height) do
+        Gosu.translate(@x_offset, @y_offset) do
+          @text.draw_markup
+          @cursor.draw
+        end
+      end
+    end
+
+    def update
+      super
+      # @text_input.text+="\n" if Gosu.button_down?(Gosu::KbEnter) || Gosu.button_down?(Gosu::KbReturn) # FIXME
+      @caret_pos = @text_input.caret_pos
+      @highlighting.highlight(string: @text_input.text, text: @text)
+
+      @cursor.update
+    end
+
+    def code; @text_input.text; end
+
+    def button_down(id)
+      @cursor.button_down(id)
+    end
+
+    def button_up(id)
+      cursor_pos = @text_input.caret_pos # get a copy of the current cursor location
+
+      if id == Gosu::KbEnter || id == Gosu::KbReturn
+        # raise if @caret_pos != @text_input.caret_pos
+        @text_input.text = @text_input.text.insert(@text_input.caret_pos, "\n")
+        @cursor.set_position(cursor_pos+1)
+      end
+
+      @cursor.move(:up) if id == Gosu::KbUp
+      @cursor.move(:down) if id == Gosu::KbDown
+
+      if id == Gosu::KbTab
+        text = @text_input.text
+
+        if window.shift_button_down?
+          # FIXME: remove spaces behide cursor
+
+          # chars = @text_input.text.chars
+
+          # if text[cursor_pos] == " " && text[cursor_pos-1] == " "
+          #   chars.delete_at(cursor_pos-1)
+          #   chars.delete_at(cursor_pos)
+          #   @cursor.set_position(cursor_pos-2)
+
+          #   text = chars.join
+          # elsif text[cursor_pos] == " "
+          #   chars.delete_at(cursor_pos-1)
+          #   @cursor.set_position(cursor_pos-1)
+
+          #   text = chars.join
+          # else
+          #   p text[cursor_pos]
+          # end
+
+        else
+          @text_input.text = @text_input.text.insert(cursor_pos, "  ")
+          p cursor_pos+2
+          @cursor.set_position(cursor_pos+2)
+        end
+      end
+
+      @cursor.button_up(id)
+    end
+  end
+end

data/lib/author_engine/views/level_editor.rb

@@ -0,0 +1,7 @@
+class AuthorEngine
+  class LevelEditor < View
+    def focus
+      window.caption = "Level Editor"
+    end
+  end
+end

data/lib/author_engine/views/play_viewer.rb

@@ -0,0 +1,163 @@
+class AuthorEngine
+  class PlayViewer < View
+    def setup
+      @running = false
+
+      @error_icon = AuthorEngine::Image.new("assets/ui/error_icon.png", retro: true)
+      @error_icon_color = 0
+      @error_icon_colors = [yellow, orange]
+
+      @loading_icon = AuthorEngine::Image.new("assets/ui/loading_icon.png", retro: true)
+      @loading_icon_angle = 0
+      @loading_icon_rot_step = 45
+
+      @icon_rot_period = 500
+      @last_icon_rot = Gosu.milliseconds
+
+      @error_message = Text.new(message: "", x: @x_padding, y: window.container.header_height, z: Float::INFINITY)
+
+      @text = Text.new(message: "Press [Control+P] to Play")
+      @text.x = window.width/2 - @text.width/2
+      @text.y = window.height/2 + @text.height + @loading_icon.height * window.square_scale
+
+      @last_error = nil
+    end
+
+    def run(code: nil)
+      @last_error = nil
+      @game = Game.new(code: code)
+
+      @running = true
+      window.show_cursor = false
+      window.container.lock
+
+      @game.init
+    end
+
+    def catch_error(&block)
+      begin
+        block.call if block
+      rescue => error
+        error_response(error)
+      rescue SyntaxError => error
+        error_response(error)
+      end
+    end
+
+    def error_response(error)
+      stop
+
+      @last_error = error
+      format_error(text: @error_message, error: error)
+    end
+
+    def format_error(text:, error:)
+      puts "#{error.class}: #{error.message}"
+      puts error.backtrace.join("\n")
+
+      max_width = window.width - (@x_padding*2)
+      char_width= text.font.text_width("0")
+      chars_line= (max_width.to_f / char_width.to_f).ceil
+
+      backtrace = "<c=#{xml_color(orange)}>#{error.class}</c>\nBacktrace:\n"
+      error.backtrace.each {|trace| next unless trace.include?("(eval)"); backtrace+="  #{trace}\n"}
+      trace_buffer = "#{error.message}"
+      buffer = ""
+
+      trace_buffer.lines do |line|
+        line.chomp.chars.each_slice(chars_line).each do |slice|
+          string = slice.join
+          buffer += "  #{string}\n"
+        end
+      end
+
+      text.message = "#{backtrace}#{buffer}"
+    end
+
+    def focus
+      window.caption = "Play"
+      play
+    end
+
+    def play
+      catch_error do
+        run(code: code_editor.code)
+      end
+    end
+
+    def draw
+      if @running
+        Gosu.draw_rect(0, 0, window.width, window.height, @background)
+        Gosu.flush
+        catch_error do
+          draw_game
+        end
+      else
+        super
+        if @last_error
+          Gosu.scale(2,2, (window.width / 2) - (@error_icon.width / 2), (window.height / 2) - (@error_icon.height / 2)) do
+            @error_icon.draw_rot(window.width / 2, window.height / 2, 10, 0, 0.5, 0.5, 1 * window.square_scale, 1 * window.square_scale, @error_icon_colors[@error_icon_color])
+          end
+          @error_message.draw_markup
+        else
+          @loading_icon.draw_rot(window.width / 2, window.height / 2, 10, @loading_icon_angle, 0.5, 0.5, 1 * window.square_scale, 1 * window.square_scale)
+          @text.draw
+        end
+      end
+    end
+
+    def update
+      # super
+      if @running
+        catch_error do
+          update_game
+        end
+      else
+        if (Gosu.milliseconds - @last_icon_rot) > @icon_rot_period
+          @loading_icon_angle = (@loading_icon_angle + @loading_icon_rot_step) % 360
+          @error_icon_color += 1
+          @error_icon_color = 0 if @error_icon_color == @error_icon_colors.size
+          @last_icon_rot = Gosu.milliseconds
+        end
+      end
+    end
+
+    def draw_game
+      x_offset = 0
+      ratio    = Window::VIEW_WIDTH / window.width
+      if window.scale_x != window.scale_y
+        x_offset = window.width / 2 - (window.width * ratio * window.square_scale) / 2
+      end
+
+      Gosu.clip_to(x_offset, 0, (window.base_size * window.square_scale), (window.base_size * window.square_scale)) do
+        Gosu.translate(x_offset, 0) do
+          Gosu.scale(window.square_scale, window.square_scale) do
+            @game.draw_background
+            @game.draw
+          end
+        end
+      end
+    end
+
+    def update_game
+      @game.update if @game
+    end
+
+    def stop
+      @running = false
+      window.show_cursor = true
+      window.container.unlock
+    end
+
+    def button_up(id)
+      if id == Gosu::MsLeft && window.mouse_x.between?((window.width / 2) - (@loading_icon.width/2) * window.square_scale, (window.width / 2) + (@loading_icon.width/2) * window.square_scale)
+        if window.mouse_y.between?((window.height / 2) - (@loading_icon.height/2) * window.square_scale, (window.height / 2) + (@loading_icon.height/2) * window.square_scale)
+          play
+        end
+      end
+
+      stop if id == Gosu::KbEscape
+      play if id == Gosu::KbP && window.control_button_down?
+    end
+  end
+end

data/lib/author_engine/views/sprite_editor.rb

@@ -0,0 +1,333 @@
+class AuthorEngine
+  class SpriteEditor < View
+    BLANK_COLOR = Gosu::Color.rgba(0,0,0, 0)
+    class Pixel
+      attr_accessor :x, :y, :width, :height, :color
+      def initialize(x, y, width, height, color)
+        @x, @y, @width, @height, @color = x, y, width, height, color
+      end
+
+      def draw
+        Gosu.draw_rect(
+          @x, @y,
+          @width, @height,
+          @color,
+          5
+        )
+      end
+    end
+
+    def setup
+      @pixels = []
+      @active_color = Gosu::Color.rgba(101,1,101, 255)
+
+      create_grid(16, 16, 4)
+      @canvas_changed = false
+      @scale = 1 * window.square_scale
+      @palette = Palette.new(x: @grid_x + @grid_width + @grid_pixel_size, y: @grid_y)
+      @sprites_picker = SpritePicker.new(y: @grid_y + @grid_height + (@grid_pixel_size * 2))
+      @coordinates    = Text.new(message: "1:1", x: @scale, y: @grid_y)
+
+      @sprites= Array.new(@sprites_picker.rows*@sprites_picker.columns, nil)
+
+      @tools = []
+      @pixel_lock = false
+      @pixel_floodfill = false # aka bucket tool
+
+      @tools << Button.new(image: "assets/ui/unlock_icon.png", tooltip: "Toggle pixel lock", x: @palette.x, y: @palette.y + @palette.height + (window.square_scale * 2), color: dark_purple) do |b|
+        @unlock_icon ||= b.image
+        @lock_icon ||= AuthorEngine::Image.new("assets/ui/lock_icon.png", retro: true)
+
+        @pixel_lock = !@pixel_lock
+
+        if @pixel_lock
+          b.image = @lock_icon
+        else
+          b.image = @unlock_icon
+        end
+      end
+
+      @pencil_icon = AuthorEngine::Image.new("assets/ui/pencil_icon.png", retro: true)
+      @bucket_icon = AuthorEngine::Image.new("assets/ui/bucket_icon.png", retro: true)
+
+      @tools << Button.new(image: @pencil_icon, tooltip: "Toggle pencil/bucket", x: @palette.x + @tools.first.width + 1, y: @palette.y + @palette.height + (window.square_scale * 2), color: dark_purple) do |b|
+        @pixel_floodfill = !@pixel_floodfill
+
+        if @pixel_floodfill
+          b.image = @bucket_icon
+        else
+          b.image = @pencil_icon
+        end
+      end
+
+      import_spritesheet(window.container.savefile.sprites)
+    end
+
+    def focus
+      window.show_cursor = true
+      window.caption = "Sprite Editor"
+    end
+
+    def draw
+      super
+      @pixels.each(&:draw)
+      highlight_pixel
+      @coordinates.draw
+
+      Gosu.draw_rect(@grid_x-window.square_scale, @grid_y-window.square_scale, @grid_width+(window.square_scale*2), @grid_height+(window.square_scale*2), Gosu::Color::WHITE)
+      Gosu.draw_rect(@grid_x, @grid_y, @grid_width, @grid_height, Gosu::Color.rgba(10, 10, 10, 200))
+      @palette.draw
+      @sprites_picker.draw
+
+      @tools.each(&:draw)
+
+      Gosu.clip_to(@grid_x, @grid_y, @grid_width, @grid_height) do
+        if @pixel_floodfill
+          @bucket_icon.draw(window.mouse_x, window.mouse_y - (@bucket_icon.width * @scale), 1000, @scale, @scale)
+        else
+          @pencil_icon.draw(window.mouse_x, window.mouse_y - (@pencil_icon.width * @scale), 1000, @scale, @scale)
+        end
+      end
+    end
+
+    def update
+      super
+      unless @pixel_floodfill
+        paint if Gosu.button_down?(Gosu::MsLeft)
+        erase if Gosu.button_down?(Gosu::MsRight)
+      end
+      @palette.update
+
+      update_coordinates
+    end
+
+    def update_coordinates
+      x = normalize_x(window.mouse_x)
+      y = normalize_y(window.mouse_y)
+      return if (x >= @grid_columns || y >= @grid_rows)
+      return if (x < 0 || y < 0)
+
+      @coordinates.message = "#{x+1}:#{y+1}"
+    end
+
+    def create_grid(x, y, size)
+      size = size * window.square_scale
+
+      @grid_x = (window.width / 2) - (((size * x) / 2) + size*2 )
+      @grid_y = window.container.header_height + size
+      @grid_width = x * size
+      @grid_height = y * size
+      @grid_pixel_size = size
+      @grid_columns = x
+      @grid_rows    = y
+
+      y.times do |_y|
+        x.times do |_x|
+          @pixels << Pixel.new(
+            @grid_x+(_x*size), @grid_y+(_y*size),
+            size, size,
+            BLANK_COLOR
+          )
+        end
+      end
+    end
+
+    def highlight_pixel
+      return unless @palette.color
+
+      pixel = get_pixel_at(window.mouse_x, window.mouse_y)
+      return unless pixel
+      Gosu.draw_rect(
+        pixel.x, pixel.y,
+        pixel.width, pixel.height,
+        @palette.color,
+        6
+      )
+
+      Gosu.draw_rect(
+        pixel.x, pixel.y,
+        pixel.width, pixel.height,
+        Gosu::Color.rgba(255,255,255, 100),
+        6
+      )
+    end
+
+    def paint(color = @palette.color)
+      pixel = get_pixel_at(window.mouse_x, window.mouse_y)
+
+      return unless pixel
+      return if color.nil?
+      return if pixel.color != BLANK_COLOR && @pixel_lock
+
+      pixel.color = color
+      @canvas_changed = true
+    end
+
+    def erase
+      paint(BLANK_COLOR)
+    end
+
+    def get_pixel_at(x, y)
+      return if (x >= @grid_x+@grid_width || y >= @grid_y+@grid_height)
+      x = normalize_x(x)
+      y = normalize_y(y)
+      return if (x < 0 || y < 0)
+
+      @pixels[(x + (@grid_columns * y))]
+    end
+
+    def normalize_x(int)
+      return ((int - @grid_x) / @grid_pixel_size).floor
+    end
+
+    def normalize_y(int)
+      return ((int - @grid_y) / @grid_pixel_size).floor
+    end
+
+    # AKA The Bucket Tool
+    # @param pixel [Pixel]
+    # @param target_color [Gosu::Color] color to search and replace with replacement_color
+    # @param replacement_color [Gosu::Color] color to replace Pixel's current color
+    def floodfill(pixel, target_color, replacement_color)
+      return unless pixel
+      return if pixel.color == replacement_color
+      return if pixel.color != target_color
+      return if target_color != BLANK_COLOR && @pixel_lock # don't replace non-blank pixels with color if pixels are locked
+
+      pixel.color = replacement_color
+      @canvas_changed = true
+
+      # UP
+      _pixel = get_pixel_at(pixel.x, pixel.y - @grid_pixel_size)
+      floodfill(_pixel, target_color, replacement_color)
+
+      # DOWN
+      _pixel = get_pixel_at(pixel.x, pixel.y + @grid_pixel_size)
+      floodfill(_pixel, target_color, replacement_color)
+
+      # LEFT
+      _pixel = get_pixel_at(pixel.x - @grid_pixel_size, pixel.y)
+      floodfill(_pixel, target_color, replacement_color)
+
+      # RIGHT
+      _pixel = get_pixel_at(pixel.x + @grid_pixel_size, pixel.y)
+      floodfill(_pixel, target_color, replacement_color)
+    end
+
+    def sprites
+      @sprites
+    end
+
+    def set_sprite
+      if @sprites[@sprites_picker.active_sprite]
+        sprite_pixels(@sprites[@sprites_picker.active_sprite])
+      else
+        @pixels.each do |pixel|
+          pixel.color = BLANK_COLOR
+        end
+      end
+    end
+
+    def sprite_pixels(image)
+      pixels = []
+      image.to_blob.bytes.to_a.each_slice(4).each_with_index do |pixel|
+        buffer = []
+        pixel.each do |chunk|
+          buffer << Integer(chunk)
+        end
+        pixels << buffer
+      end
+
+      pixels.each_with_index do |pixel, index|
+        @pixels[index].color = Gosu::Color.rgba(pixel[0], pixel[1], pixel[2], pixel[3])
+      end
+    end
+
+    def update_sprite
+      list = []
+
+      @pixels.each_slice(window.sprite_size).each do |row|
+        list << row
+      end
+
+      image = Gosu.render(window.sprite_size, window.sprite_size, retro: true) do
+        list.each_with_index do |row, y|
+          row.each_with_index do |pixel, x|
+            Gosu.draw_rect(x, y, 1, 1, pixel.color)
+          end
+        end
+      end
+
+      @sprites[@sprites_picker.active_sprite] = nil # release image for garbage collection?
+      @sprites[@sprites_picker.active_sprite] = image
+      @canvas_changed = false
+    end
+
+    def copy_sprite
+      @copied_pixels = []
+      @pixels.each {|pixel| @copied_pixels << pixel.dup}
+    end
+
+    def paste_sprite
+      if @copied_pixels
+        @pixels.each_with_index do |pixel, i|
+          pixel.color = @copied_pixels[i].color
+        end
+        @canvas_changed = true
+        update_sprite
+      end
+
+      @copied_pixels = nil
+    end
+
+    def spritesheet
+      sheet = Gosu.render(512, 128, retro: true) do
+        @sprites.each_slice(512/16).each_with_index do |row, y|
+          row.each_with_index do |sprite, x|
+            next if sprite.nil?
+            sprite.draw(x * 16, y * 16, 0)
+          end
+        end
+      end
+
+      return sheet
+    end
+
+    def import_spritesheet(data)
+      return if data.to_blob.size < 4
+      sprites = Gosu::Image.load_tiles(data, 16, 16, retro: true, tileable: true)
+      @sprites.clear
+
+      sprites.each do |sprite|
+        @sprites.push(sprite)
+      end
+
+      set_sprite
+    end
+
+    def button_down(id)
+      super
+
+      copy_sprite  if window.control_button_down? && id == Gosu::KbC
+      paste_sprite if window.control_button_down? && id == Gosu::KbV
+    end
+
+    def button_up(id)
+      super
+      @palette.button_up(id)
+      @sprites_picker.button_up(id)
+
+      @tools.each{ |b| b.button_up(id) }
+
+      if @pixel_floodfill
+        pixel = get_pixel_at(window.mouse_x, window.mouse_y)
+        if pixel
+          floodfill(pixel, pixel.color, @palette.color) if id == Gosu::MsLeft if @palette.color
+          floodfill(pixel, pixel.color, BLANK_COLOR) if id == Gosu::MsRight
+        end
+      end
+
+      update_sprite if (id == Gosu::MsLeft || id == Gosu::MsRight) && @canvas_changed
+    end
+  end
+end