red_bird 0.1.1

data/lib/red_bird/sprite.rb

@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: MIT
+module RedBird
+  # A rectangular part of a texture. It allows you to print only a portion of
+  # the image instead of it all. This will, for example, enable you to insert
+  # several animation frames into the same texture instead of having to load
+  # several small files.
+  # @author Frederico Linhares
+  class Sprite
+    # Create an array of sprites and return it. The array has homogeneous
+    # sprites that do not overlap and have no gaps between them.
+    #
+    # To create a grid  starting from the position x 20, y 20, containing three
+    # columns and two rows, each sprite, having 100x80 pixels:
+    #
+    #   RedBird::Texture.grid sprite, 20, 20, 3, 2, 100, 80
+    #
+    # @param texture [RedBird::Texture] a texture that will be used as the
+    #   source for all sprites.
+    # @param init_x [Integer] initial x coordinate for the grid.
+    # @param init_y [Integer] initial y coordinate for the grid.
+    # @param num_hor_sprites [Integer] number of columns the grid will have.
+    # @param num_ver_sprites [Integer] number of rows the grid will have.
+    # @param width [Integer] width of every sprite.
+    # @param height [Integer] height of every sprite.
+    # @return [Array]
+    # @author Frederico Linhares
+    def self.grid(texture, init_x, init_y, num_hor_sprites, num_ver_sprites,
+                  width, height)
+      sprites = []
+      num_ver_sprites.times do |v|
+        num_hor_sprites.times do |h|
+          sprites << Sprite.new(
+            texture, init_x + h * width, init_y + v * height, width, height)
+        end
+      end
+
+      return sprites
+    end
+  end
+end

data/lib/red_bird/stage.rb

@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: MIT
+module RedBird
+  # A game built with RedBird consists of a succession of Stages. A game has
+  # only a single Stage running at a time. Each Stage must have an
+  # {RedBird::InputDevice} instance and an Array of {RedBird::Entity}
+  # instances.
+  #
+  # This class contains a basic set of functionalities that every stage of a
+  # game needs.
+  #
+  # @!attribute [r] input_device
+  #   @return [RedBird::InputDevice] the class that inherits from Stage must
+  #     defines an variable +@input_device+ containing and instance of
+  #     {RedBird::InputDevice}.
+  # @!attribute [r] entities
+  #   @return [Array<RedBird::Entity>]
+  # @author Frederico Linhares
+  class Stage
+    attr_accessor :input_device, :entities
+
+    # @param global_data [Object] use this to share common data among different
+    #   stages.
+    # @author Frederico Linhares
+    def initialize(global_data)
+      @global_data = global_data
+      @entities = []
+    end
+
+    # Add a new entity to this stage. This method organizes the entities as
+    # expected by some methods in {RedBird::Engine}.
+    #
+    # @param entities [Entity, Array<Entity>]
+    # @author Frederico Linhares
+    def add_entities(entities)
+      if entities.is_a? Array then
+        @entities.concat entities
+      else
+        @entities << entities
+      end
+
+      @entities.sort! { |a, b| a.priority <=> b.priority }
+    end
+
+    # {RedBird::Engine} calls this method before it ticks entities. Overwrite
+    # this to add routines that must run before entities tick.
+    #
+    # @author Frederico Linhares
+    def pre_tick
+      # By default do nothing.
+    end
+
+    # {RedBird::Engine} calls this method after it ticks entities. Overwrite
+    # this to add routines that must run after entities tick.
+    #
+    # @author Frederico Linhares
+    def post_tick
+      # By default do nothing.
+    end
+  end
+end

data/lib/red_bird/tile_map.rb

@@ -0,0 +1,118 @@
+# SPDX-License-Identifier: MIT
+require_relative "tile_set"
+
+module RedBird
+  # A TileMap is a grid of {RedBird::Sprite}s; it works as a scenario. It has
+  # scrolling functionalities to control which portion of it is on the screen.
+  #
+  # @!attribute [rw] hor_offset
+  #   @return [Integer] how much the tilemap scrolled from the left corner.
+  # @!attribute [rw] ver_offset
+  #   @return [Integer] how much the tilemap scrolled from the top.
+  # @!attribute [r] tiles
+  #   @return [Array<Integer>] tiles indexes.
+  # @!attribute [r] tile_set
+  #   @return [RedBird::TileSet] tile set in use by this class.
+  # @!attribute [r] total_width
+  #   @return [Integer] width of the entire tilemap (not only what is displayed
+  #     in the screen).
+  # @!attribute [r] total_height
+  #   @return [Integer] height of the entire tilemap (not only what is
+  #     displayed in the screen).
+  # @author Frederico Linhares
+  class TileMap < Entity
+    attr_accessor :hor_offset, :ver_offset
+    attr_reader :tiles, :tile_set, :total_width, :total_height
+
+    # @param tile_set [RedBird::TileSet]
+    # @param pos_x [Integer] horizontal position of this map in the screen.
+    # @param pos_y [Integer] vertical position of this map in the screen.
+    # @param width [Integer] width of the region displayed in the screen.
+    # @param height [Integer] height of the region displayed in the screen.
+    # @param num_hor_tiles [Integer] total width in number of tiles.
+    # @param num_ver_tiles [Integer] total height in number of tiles.
+    # @param tiles [Array<Integer>] code of every tile to display, must be an
+    #   one dimension array.
+    # @author Frederico Linhares
+    def initialize(tile_set, pos_x, pos_y, width, height, num_hor_tiles,
+                   num_ver_tiles, tiles)
+      @tile_set = tile_set
+      @pos_x = pos_x
+      @pos_y = pos_y
+
+      @width = width
+      @height = height
+
+      @ver_offset = 0
+      @hor_offset = 0
+
+      @priority = -1
+
+      @tiles = tiles
+
+      # Number of tiles that are going to be rendered to screen.
+      @render_hor_tiles = @width / @tile_set.tile_width + 1
+      @render_ver_tiles = @height / @tile_set.tile_height + 1
+
+      @total_hor_tiles = num_hor_tiles
+      @total_ver_tiles = num_ver_tiles
+
+      @total_width = @total_hor_tiles * @tile_set.tile_width
+      @total_height = @total_ver_tiles * @tile_set.tile_height
+    end
+
+    # Load information from a yaml file and uses it create an instance of this
+    # class.
+    #
+    # @param data_dir [String] path to the directory containing the yaml and
+    #   other files referenced in the yaml.
+    # @param map_file [String] path to the yaml file.
+    # @return [RedBird::TileMap]
+    # @author Frederico Linhares
+    def self.from_yml(data_dir, map_file, tile_set, pos_x, pos_y, width,
+                      height)
+      yaml_file = data_dir + map_file
+
+      data = YAML.load_file(yaml_file)
+      num_hor_tiles = data["num_hor_tiles"]
+      num_ver_tiles = data["num_ver_tiles"]
+      tiles = data["tiles"].unpack("S*")
+
+      return self.new(
+               tile_set, pos_x, pos_y, width, height, num_hor_tiles,
+               num_ver_tiles, tiles)
+    end
+
+    # Gets the {RedBird::Sprite} at position x, y.
+    #
+    # @param x [Integer]
+    # @param y [Integer]
+    # @author Frederico Linhares
+    def tile_xy(x, y)
+      return @tile_set.tiles[@tiles[y_to_tile(y) + x]][:type]
+    end
+
+    # Renders this tilemap to the screen.
+    #
+    # @author Frederico Linhares
+    def render
+      first_hor_tile = @hor_offset / @tile_set.tile_width
+      first_ver_tile = @ver_offset / @tile_set.tile_height
+
+      (first_ver_tile..(first_ver_tile + @render_ver_tiles)).each do |y|
+        (first_hor_tile..(first_hor_tile + @render_hor_tiles)).each do |x|
+          unless @tiles[y_to_tile(y) + x].nil? then
+            @tile_set.tiles[@tiles[y_to_tile(y) + x]].render_to_screen(
+              x * @tile_set.tile_width - @hor_offset + @pos_x,
+              y * @tile_set.tile_height - @ver_offset + @pos_y)
+          end
+        end
+      end
+    end
+
+    private
+    def y_to_tile(y)
+      return y * @total_hor_tiles
+    end
+  end
+end

data/lib/red_bird/tile_set.rb

@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: MIT
+require 'yaml'
+
+module RedBird
+  # A TileSet is a set of {RedBird::Sprite}s. It allows you to reuse the same
+  # {RedBird::Sprite} several times in the creation of a game scenario, making
+  # the level design more straightforward.
+  #
+  # @!attribute [r] tiles
+  #   @return [Array<RedBird::TileSet::Sprite>]
+  # @!attribute [r] tile_width
+  #   @return [Integer] width of each tile.
+  # @!attribute [r] tile_height
+  #   @return [Integer] height of each tile.
+  # @author Frederico Linhares
+  class TileSet
+    attr_reader :tiles, :tile_width, :tile_height
+
+    # @param texture_file [String] this method uses the path as argument to
+    #   create a {RedBird::Texture}.
+    # @param tile_width [Integer] width of each tile.
+    # @param tile_height [Integer] height of each tile.
+    # @author Frederico Linhares
+    def initialize(texture_file, texture_palette, tile_width, tile_height)
+      @texture = RedBird::Texture.new(texture_file, texture_palette)
+
+      @tile_width = tile_width
+      @tile_height = tile_height
+
+      horizontal_tiles = @texture.width / @tile_width
+      vertical_tiles = @texture.height / @tile_height
+
+      @tiles = Sprite.grid(
+        @texture, 0, 0, horizontal_tiles, vertical_tiles, @tile_width,
+        @tile_height)
+    end
+
+    # Load information from a yaml file and uses it create an instance of this
+    # class.
+    #
+    # @param data_dir [String] path to the directory containing the yaml and
+    #   other files referenced in the yaml.
+    # @param tile_file [String] path to the yaml file.
+    # @return [RedBird::TileSet]
+    # @author Frederico Linhares
+    def self.from_yml(data_dir, tile_file, palette)
+      yaml_file = data_dir + tile_file
+
+      data = YAML.load_file(yaml_file)
+      texture_path = data_dir + data["texture"]
+
+      return self.new(texture_path, palette, data["width"], data["height"])
+    end
+
+  end
+end

data/lib/red_bird/uibox.rb

@@ -0,0 +1,143 @@
+# SPDX-License-Identifier: MIT
+module RedBird
+  # User Interface Box works as a visual background for texts, menus, or
+  # anything else.
+  #
+  # @author Frederico Linhares
+  class UIBox < Entity
+    # A style defines the visual appearance of a Box.
+    #
+    # @author Frederico Linhares
+    class Style
+      # @!attribute [r] texture
+      #   @return [RedBird::Texture]
+      # @!attribute [r] bg_color
+      #   @return [RedBird::Color]
+      # @!attribute [r] sprites
+      #   @return [Array<RedBird::Sprite>]
+      # @!attribute [r] sprite_width
+      #   @return [Integer]
+      # @!attribute [r] sprite_height
+      #   @return [Integer]
+      attr_reader :texture, :bg_color, :sprites, :sprite_width, :sprite_height
+
+      # @param texture_file [String] path to a image file in the format
+      #   required by this class.
+      # @param bg_color [RedBird::Color] color used to fill the background of
+      #   the box.
+      # @param sprite_width [Integer] width of each sprite in the
+      #   +texture_file+.
+      # @param sprite_height [Integer] height of each sprite in the
+      #   +texture_file+.
+      # @author Frederico Linhares
+      def initialize(texture_file, texture_palette, bg_color, sprite_width,
+                     sprite_height)
+        @texture = Texture.new(texture_file, texture_palette)
+        @bg_color = bg_color
+        @sprite_width = sprite_width
+        @sprite_height = sprite_height
+
+        @sprites = {}
+        @sprites[:arrow_select] = Sprite.new(
+          @texture, 1 * @sprite_width, 1 * @sprite_height,
+          @sprite_width, @sprite_height)
+        @sprites[:box_top_left] = Sprite.new(
+          @texture, 0, 0, @sprite_width, @sprite_height)
+        @sprites[:box_top] = Sprite.new(
+          @texture, 1 * @sprite_width, 0,
+          @sprite_width, @sprite_height)
+        @sprites[:box_top_right] = Sprite.new(
+          @texture, 2 * @sprite_height, 0,
+          @sprite_width, @sprite_height)
+        @sprites[:box_left] = Sprite.new(
+          @texture, 0, 1 * @sprite_height,
+          @sprite_width, @sprite_height)
+        @sprites[:box_right] = Sprite.new(
+          @texture, 2 * @sprite_width, 1 * @sprite_height,
+          @sprite_width, @sprite_height)
+        @sprites[:box_bottom_left] = Sprite.new(
+          @texture, 0, 2 * @sprite_height,
+          @sprite_width, @sprite_height)
+        @sprites[:box_bottom] = Sprite.new(
+          @texture, 1 * @sprite_width, 2 * @sprite_height,
+          @sprite_width, @sprite_height)
+        @sprites[:box_bottom_right] = Sprite.new(
+          @texture, 2 * @sprite_width, 2 * @sprite_height,
+          @sprite_width, @sprite_height)
+      end
+    end
+
+    # @param style [RedBird::Style]
+    # @param pos_x [Integer]
+    # @param pos_y [Integer]
+    # @param num_vertical_sprites [Integer] number of sprites rows.
+    # @param num_horizontal_sprites [Integer] number of sprites columns.
+    # @author Frederico Linhares
+    def initialize(style, pos_x, pos_y, num_vertical_sprites,
+                   num_horizontal_sprites)
+      @style = style
+      @pos_x = pos_x
+      @pos_y = pos_y
+      @num_vertical_sprites = num_vertical_sprites
+      @num_horizontal_sprites = num_horizontal_sprites
+    end
+
+    # The height is defined by +num_horizontal_sprites+ plus two (the borders).
+    # The width of each sprite is defined by the style used.
+    #
+    # @return [Integer]
+    # @author Frederico Linhares
+    def width
+      @style.sprite_width * (@num_horizontal_sprites + 2)
+    end
+
+    # The height is defined by +num_vertical_sprites+ plus two (the borders).
+    # The height of each sprite is defined by the style used.
+    #
+    # @return [Integer]
+    # @author Frederico Linhares
+    def height
+      @style.sprite_height * (@num_vertical_sprites + 2)
+    end
+
+    # Renders to the screen.
+    #
+    # @author Frederico Linhares
+    def render
+      Render.set_color(@style.bg_color)
+      Render.fill_rect(@pos_x, @pos_y, self.width, self.height)
+
+      # Draw the corners.
+      @style.sprites[:box_top_left].render_to_screen(@pos_x, @pos_y)
+      @style.sprites[:box_top_right].render_to_screen(
+        @style.sprite_width * (@num_horizontal_sprites + 1) + @pos_x,
+        @pos_y)
+      @style.sprites[:box_bottom_left].render_to_screen(
+        @pos_x,
+        @style.sprite_height * (@num_vertical_sprites + 1) + @pos_y)
+      @style.sprites[:box_bottom_right].render_to_screen(
+        @style.sprite_width * (@num_horizontal_sprites + 1) + @pos_x,
+        @style.sprite_height * (@num_vertical_sprites + 1) + @pos_y)
+
+      # Draw the edges.
+      @num_horizontal_sprites.times do |i|
+        # Top
+        @style.sprites[:box_top].render_to_screen(
+          @style.sprite_width * (i + 1) + @pos_x, @pos_y)
+        # Bottom
+        @style.sprites[:box_bottom].render_to_screen(
+          @style.sprite_width * (i + 1) + @pos_x,
+          @style.sprite_height * (@num_vertical_sprites + 1) + @pos_y)
+      end
+      @num_vertical_sprites.times do |i|
+        # Left
+        @style.sprites[:box_left].render_to_screen(
+          @pos_x, @style.sprite_height * (i + 1) + @pos_y)
+        # Right
+        @style.sprites[:box_right].render_to_screen(
+          @style.sprite_width * (@num_horizontal_sprites + 1) + @pos_x,
+          @style.sprite_height * (i + 1) + @pos_y)
+      end
+    end
+  end
+end

data/lib/red_bird/version.rb

@@ -0,0 +1,3 @@
+module RedBird
+  VERSION = "0.1.1"
+end

data/lib/red_bird/vertical_menu.rb

@@ -0,0 +1,110 @@
+# SPDX-License-Identifier: MIT
+require_relative "uibox"
+
+module RedBird
+  # VerticalMenu is an interactive menu that receives input from players. It
+  # consists of a vertical list of {RedBird::VerticalMenu::Option}.
+  #
+  # @author Frederico Linhares
+  class VerticalMenu < Entity
+
+    # An option to be used in {RedBird::VerticalMenu}.
+    #
+    # @!attribute [r] action
+    #   @return [Proc] code for option selection
+    # @!attribute [r] text
+    #   @return [String] option name
+    # @author Frederico Linhares
+    class Option
+      attr_accessor :action, :text
+
+      # @param text [String] option name
+      # @param action [Proc] code to use when this option is selected
+      # @author Frederico Linhares
+      def initialize(text, &action)
+        @text = text
+        @action = action
+        @priority = 100
+      end
+    end
+
+    # @param style [RedBird::UIBox::Style]
+    # @param pos_x [Integer]
+    # @param pos_y [Integer]
+    # @param options [Array<RedBird::VerticalMenu::Option>]
+    # @author Frederico Linhares
+    def initialize(style, pos_x, pos_y, options)
+      @style = style
+      @pos_x = pos_x
+      @pos_y = pos_y
+
+      @options = options
+      @current_option = 0
+      @option_max_width = 0
+      @option_max_height = 0
+
+      @options.each do |i|
+        if @option_max_width < i.text.width then
+          @option_max_width = i.text.width
+        end
+        if @option_max_height < i.text.height then
+          @option_max_height = i.text.height
+        end
+      end
+    end
+
+    # @return [Integer]
+    # @author Frederico Linhares
+    def width
+      @option_max_width
+    end
+
+    # @return [Integer]
+    # @author Frederico Linhares
+    def height
+      @option_max_height * @options.size
+    end
+
+    # Executes the action in the selected option.
+    #
+    # @author Frederico Linhares
+    def activate
+      @options[@current_option].action.call
+    end
+
+    # Changes the selected {RedBird::VerticalMenu::Option} to the next one.
+    #
+    # @author Frederico Linhares
+    def next_opt
+      @current_option += 1
+      @current_option = 0 if @current_option >= @options.size
+    end
+
+    # Changes the selected {RedBird::VerticalMenu::Option} to the previous one.
+    #
+    # @author Frederico Linhares
+    def pred_opt
+      if @current_option <= 0 then
+        @current_option = @options.size - 1
+      else
+        @current_option -= 1
+      end
+    end
+
+    # Renders to the screen.
+    #
+    # @author Frederico Linhares
+    def render
+      # Render texts.
+      @options.each_with_index do |o, i|
+        o.text.render_to_screen(
+          @style.sprite_width * 2 + @pos_x,
+          @style.sprite_height * (i + 1) + @pos_y)
+      end
+
+      @style.sprites[:arrow_select].render_to_screen(
+        @style.sprite_width + @pos_x,
+        @style.sprite_height * (@current_option + 1) + @pos_y)
+    end
+  end
+end