red_bird 0.1.1

data/lib/red_bird/controller.rb

@@ -0,0 +1,44 @@
+# SPDX-License-Identifier: MIT
+module RedBird
+  # A Controller receives commands from a {RedBird::InputDevice} and executes
+  # codes associated with those commands. Every {RedBird::InputDevice} instance
+  # has a variable called +@controller+ that must point to an instance of this
+  # class.
+  #
+  # The purpose of this class is to allow you to change the effect of user
+  # input by merely changing the currently active controller; you would do so,
+  # for example, when the user pauses the game, or when the user's character
+  # enters a vehicle.
+  #
+  # @see RedBird::InputDevice
+  # @author Frederico Linhares
+  class Controller
+    def initialize
+      @commands = {}
+
+      # By default, quit game when window is closed or another signal to end
+      # the game is given.
+      self.add_command(:quit_game) do
+        Engine::quit_game
+      end
+    end
+
+    # Use this method to create an association between a command and a code
+    # block.
+    #
+    # @param command [Symbol]
+    # @param function
+    # @author Frederico Linhares
+    def add_command(command, &function)
+      @commands[command] = function
+    end
+
+    # Execute a code block associated with a command.
+    #
+    # @param command [Symbol]
+    # @author Frederico Linhares
+    def call_command(command)
+      @commands[command].call unless @commands[command].nil?
+    end
+  end
+end

data/lib/red_bird/dynamic_sprite.rb

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: MIT
+module RedBird
+  # A sprite is rectangular part of an texture.
+  class DynamicSprite
+    # 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.
+    # @param mods [Hash]
+    # @return [Array]
+    # @author Frederico Linhares
+    def self.grid(texture, init_x, init_y, num_hor_sprites, num_ver_sprites,
+                  width, height, mods)
+      sprites = []
+      num_ver_sprites.times do |v|
+        num_hor_sprites.times do |h|
+          sprites << new(
+            texture, init_x + h * width, init_y + v * height, width, height,
+            mods)
+        end
+      end
+
+      return sprites
+    end
+  end
+end

data/lib/red_bird/engine.rb

@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: MIT
+module RedBird
+  module Engine
+    # Maximum frames per second. The Engine will try to maintain the game
+    # running at the frame rate defined by this variable.
+    @@max_fps = 30
+
+    # Set frames per second.
+    #
+    # @param fps [Integer]
+    # @author Frederico Linhares
+    def self.fps=(fps)
+      @@max_fps = fps
+    end
+
+    # Get frames per second.
+    #
+    # @return [Integer]frames per second.
+    def self.fps
+      return @@max_fps
+    end
+
+    # Exit the current stage and end the {Engine#run} loop.
+    #
+    # @author Frederico Linhares
+    def self.quit_game
+      @@quit_game = true
+      @@quit_stage = true
+    end
+
+    # Exit the current stage. The code block sent to {Engine#run} will be
+    # called again to get the next stage.
+    #
+    # @author Frederico Linhares
+    def self.quit_stage
+      @@quit_stage = true
+    end
+
+    # This method initializes the engine, executes the main loop, and returns
+    # when the game is over. This function calls the code block to get the
+    # first stage of the game and call it again every time a stage end to get
+    # the next one.
+    #
+    # @param global_data [Object] any object that you want to share between the
+    #   game. This method sends this object back to the code block received.
+    # @yield [global_data] give +global_data+ to the block and expect it to
+    #   return the next stage.
+    def self.run(global_data, &stage_manager)
+      @@quit_game = false
+
+      self.load do
+        while not @@quit_game do
+          @@quit_stage = false
+
+          timer = Timer.new(@@max_fps)
+          clear_color = Color.new(0, 0, 0, 0)
+          current_stage = stage_manager.call(global_data)
+
+          # The best moment to cleanup memory is before the engine loads a new
+          # stage.
+          GC.start
+
+          while not @@quit_stage do
+            timer.tick
+
+            current_stage.input_device.exec_events(current_stage.entities)
+
+            current_stage.pre_tick
+            current_stage.entities.each { |e| e.tick }
+            current_stage.post_tick
+
+            Render.set_color(clear_color)
+            Render.clear_screen
+            current_stage.entities.each { |e| e.render }
+            Render.update_screen
+          end
+        end
+      end
+    end
+  end
+end

data/lib/red_bird/entity.rb

@@ -0,0 +1,74 @@
+# SPDX-License-Identifier: MIT
+module RedBird
+  # An entity is an object that is managed by the Engine; it has a size, a
+  # position, ticks, and is renderable. {RedBird::Engine.run} expects every
+  # single entity that it receives from {RedBird::Stage} to have these methods
+  # and attributes.
+  #
+  # @author Frederico Linhares
+  class Entity
+    # Position
+    #
+    # @return [Integer]
+    attr_reader :pos_x, :pos_y
+    # Size
+    #
+    # @return [Integer]
+    attr_reader :width, :height
+    # Entities with higher priorit are called first when the
+    # {RedBird::Engine.run} calls {#tick} and {#render}.
+    #
+    # @return [Integer]
+    attr_reader :priority
+
+    # The {RedBird::Engine.run} calls this method every single frame. Overwrite
+    # it if you want your entity to do something every frame.
+    #
+    # @author Frederico Linhares
+    def tick
+      # By default do nothing
+    end
+
+    # The {RedBird::Engine.run} calls this method whenever the cursor is over
+    # this entity. Overwrite this function if you want your entity to react to a
+    # cursor hover.
+    #
+    # @param x [Integer] cursor position.
+    # @param y [Integer] cursor position.
+    # @author Frederico Linhares
+    def cursor_hover(x, y)
+      # By default do nothing
+    end
+
+    # The {RedBird::Engine.run} calls this method whenever there is a click over
+    # this entity. Overwrite this function if you want your entity to react to a
+    # click.
+    #
+    # @param x [Integer] cursor position.
+    # @param y [Integer] cursor position.
+    # @author Frederico Linhares
+    def cursor_down(x, y)
+      # By default do nothing
+    end
+
+    # The {RedBird::Engine.run} calls this method whenever there is a cursor
+    # release over this entity. Overwrite this function if you want your entity
+    # to react to a cursor release.
+    #
+    # @param x [Integer] cursor position.
+    # @param y [Integer] cursor position.
+    # @author Frederico Linhares
+    def cursor_up(x, y)
+      # By default do nothing
+    end
+
+    # The {RedBird::Engine.run} calls this method to render this entity into
+    # the scree. Overwrite this method if you want to change how the entity
+    # renders into the screen.
+    #
+    # @author Frederico Linhares
+    def render
+      self.current_sprite.render_to_screen(self.pos_x, self.pos_y)
+    end
+  end
+end

data/lib/red_bird/entity_collision.rb

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: MIT
+module RedBird
+  # This class does collision tests between entities.
+  class EntityCollision
+    # @param entities [Array<RedBird::Entity>] array containing the entities to
+    #   test for collusion.
+    # @author Frederico Linhares
+    def initialize(entities)
+      @entities = entities
+    end
+
+    # Loop over entities in the array and test if they collide. In the case of
+    # collision, it calls the method +collide+ of the entity and sends the
+    # entity it collided to as a single argument.
+    #
+    # @author Frederico Linhares
+    def call
+      # Calculate entities rote
+      @entities.each_with_index do |e1, i|
+        @entities.drop(i + 1).each do |e2|
+          if e1.collision_box.collide? e2.collision_box then
+            e1.collide(e2)
+            e2.collide(e1)
+            # If an object responds to 'collision_box' then it is tested.
+          end if e1.respond_to?('collision_box')
+        end
+      end
+    end
+
+  end
+end

data/lib/red_bird/input_device.rb

@@ -0,0 +1,86 @@
+# SPDX-License-Identifier: MIT
+module RedBird
+  # The InputDevice receives input from the keyboard, joystick, and mouse;
+  # then, it translates the input into a meaningful command name and sends it
+  # to a Controller. For example, you can use it to translate the 'space' key
+  # from the keyboard and an 'x' button from a controller into a +:jump+
+  # command.
+  #
+  # This class has an internal Hash that translates inputs into commands. For
+  # every input, it looks if there is a key associated with that input; it
+  # sends a command if such key exists; otherwise, it does nothing.
+  #
+  # @see RedBird::Controller
+  # @author Frederico Linhares
+  class InputDevice
+    # Defines a {RedBird::Controller} to receives commands from the input.
+    attr_writer :controller
+
+    # @param controller [RedBird::Controller]
+    # @author Frederico Linhares
+    def initialize(controller)
+      @controller = controller
+      @keydown_inputs = {}
+      @keyup_inputs = {}
+    end
+
+    # Associates a keydown even to a command_name.
+    #
+    # @param keycode [Integer] use constants under {RedBird::Keycode}.
+    # @param command_name [Symbol]
+    # @author Frederico Linhares
+    def add_keydown(keycode, command_name)
+      @keydown_inputs[keycode] = command_name
+    end
+
+    # Associates a keyup even to a command_name.
+    #
+    # @param keycode [Integer] use constants under {RedBird::Keycode}.
+    # @param command_name [Symbol]
+    # @author Frederico Linhares
+    def add_keyup(keycode, command_name)
+      @keyup_inputs[keycode] = command_name
+    end
+
+    # Gets all events that are in the queue, translate then into commands, and
+    # send then to the current controller.
+    #
+    # @param entities [Array<RedBird::Entity>] entities that can receive events
+    #   from mouse.
+    # @author Frederico Linhares
+    def exec_events(entities)
+      get_events do |type, data|
+        case type
+        when :key_down then
+          @controller.call_command(@keydown_inputs[data])
+        when :key_up then
+          @controller.call_command(@keyup_inputs[data])
+        when :mouse_motion then
+          entity = cursor_hover_entity(entities, data[:x], data[:y])
+          entity.cursor_hover(data[:x], data[:y]) unless entity.nil?
+        when :mouse_button_down then
+          entity = cursor_hover_entity(entities, data[:x], data[:y])
+          entity.cursor_down(data[:x], data[:y]) unless entity.nil?
+        when :mouse_button_up then
+          entity = cursor_hover_entity(entities, data[:x], data[:y])
+          entity.cursor_up(data[:x], data[:y]) unless entity.nil?
+        when :quit_game then
+          Engine::quit_game
+        end
+      end
+    end
+
+    protected
+    # This function is called when user move the mouse to se if mouse is hover
+    # an entity.
+    def cursor_hover_entity(entities, x, y)
+      entities.each do |e|
+        if(x >= e.pos_x and x <= e.pos_x + e.width and
+           y >= e.pos_y and y <= e.pos_y + e.height) then
+          return e
+        end
+      end
+      return nil
+    end
+  end
+end

data/lib/red_bird/palette.rb

@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: MIT
+require 'yaml'
+
+module RedBird
+  class Palette
+    # Load information from a YAML file and uses it to create an instance of this
+    # class
+    #
+    # @param tile_file [String] path to the yaml file.
+    # @return [RedBird::Palette]
+    # @author Frederico Linhares
+    def self.from_yml(palette_file)
+      data = YAML.load_file(palette_file)
+
+      # Convert data from YAML into Color instances.
+      colors = data.map do |i|
+        Color.new(i[0], i[1], i[2], i[3])
+      end
+
+      return self.new(colors)
+    end
+  end
+end

data/lib/red_bird/relative_entity.rb

@@ -0,0 +1,95 @@
+# SPDX-License-Identifier: MIT
+require_relative 'entity'
+
+module RedBird
+  # The {RedBird::Entity} has an absolute position on the screen. Use this
+  # class if you want an entity that has a position relative to a scenario
+  # ({RedBird::TileMap}).
+  #
+  # @author Frederico Linhares
+  class RelativeEntity < Entity
+    # @return [RedBird::Rect]
+    attr_reader :collision_box
+
+    # @param relative_pos_x [Integer] position in the scenario
+    # @param relative_pos_y [Integer] position in the scenario
+    # @param width [Integer]
+    # @param height [Integer]
+    # @author Frederico Linhares
+    def initialize(relative_pos_x, relative_pos_y, width, height)
+      super()
+
+      @priority = 1
+
+      @collision_box = RedBird::Rect.new(
+        relative_pos_x, relative_pos_y, width, height)
+    end
+
+    # Define which scenario to use as a reference for every
+    # {RedBird::RelativeEntity}.
+    #
+    # @param scenario [RedBird::TileMap]
+    # @author Frederico Linhares
+    def self.scenario=(scenario)
+      @@scenario = scenario
+    end
+
+    # @return [RedBird::TileMap]
+    # @author Frederico Linhares
+    def self.scenario
+      return @@scenario
+    end
+
+    # @return [Integer] position in the scenario
+    # @author Frederico Linhares
+    def relative_pos_x
+      return @collision_box.x
+    end
+
+    # @return [Integer] position in the scenario
+    # @author Frederico Linhares
+    def relative_pos_y
+      return @collision_box.y
+    end
+
+    # @param x [Integer] position in the scenario
+    # @author Frederico Linhares
+    def relative_pos_x=(x)
+      @collision_box.x = x
+    end
+
+    # @param y [Integer] position in the scenario
+    # @author Frederico Linhares
+    def relative_pos_y=(y)
+      @collision_box.y = y
+    end
+
+    # Gets absolute position (position in the screen).
+    #
+    # @return [Float] position in the screen
+    # @author Frederico Linhares
+    def pos_x
+      @collision_box.x - @@scenario.hor_offset + @@scenario.pos_x
+    end
+
+    # Gets absolute position (position in the screen).
+    #
+    # @return [Float] position in the screen
+    # @author Frederico Linhares
+    def pos_y
+      @collision_box.y - @@scenario.ver_offset + @@scenario.pos_y
+    end
+
+    # @return [Integer]
+    # @author Frederico Linhares
+    def width
+      @collision_box.width
+    end
+
+    # @return [Integer]
+    # @author Frederico Linhares
+    def height
+      @collision_box.height
+    end
+  end
+end