red_bird 0.1.1

data/ext/red_bird/texture.h

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_TEXTURE_H
+#define RED_BIRD_TEXTURE_H 1
+
+#include "main.h"
+
+extern VALUE bird_cTexture;
+
+struct bird_texture_data
+{
+  SDL_Texture *data;
+  int width, height;
+};
+
+VALUE
+bird_alloc_texture(VALUE klass);
+
+VALUE
+bird_cTexture_initialize(VALUE self, VALUE file_path, VALUE palette);
+
+VALUE
+bird_cTexture_width(VALUE self);
+
+VALUE
+bird_cTexture_height(VALUE self);
+
+struct bird_texture_data*
+bird_cTexture_get_data(VALUE self);
+
+void
+Init_red_bird_texture(void);
+
+#endif /* RED_BIRD_TEXTURE_H */

data/ext/red_bird/texture_imp.cpp

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+#include "texture_imp.hpp"
+
+#include <charconv>
+#include <fstream>
+#include <string>
+
+SDL_bool
+bird_cTexture_PGM_load(
+    struct bird_cTexture_PGM *pgm_img, const char *file_path)
+{
+  int wh_pos;
+  std::string line;
+  std::ifstream file(file_path);
+
+  if(!file) return SDL_FALSE;
+
+  // Read file magic.
+  std::getline(file, line);
+  if(line != "P5") return SDL_FALSE;
+
+  // Read file comment.
+  std::getline(file, line);
+
+  // Read file width and height.
+  std::getline(file, line);
+  wh_pos = line.find(" ");
+  std::from_chars(line.data(), line.data() + wh_pos, pgm_img->width);
+  std::from_chars(
+      line.data() + wh_pos + 1, line.data() + line.size(), pgm_img->height);
+
+  // Read file maximum value.
+  std::getline(file, line);
+  std::from_chars(line.data(), line.data() + line.size(), pgm_img->max_value);
+
+  // Read file values.
+  std::getline(file, line);
+  pgm_img->data_size = line.size();
+  pgm_img->data = new char[pgm_img->data_size];
+  memcpy(pgm_img->data, line.data(), pgm_img->data_size);
+
+  return SDL_TRUE;
+}
+
+void
+bird_cTexture_PGM_unload(bird_cTexture_PGM *pgm_img)
+{
+  delete[] pgm_img->data;
+}

data/ext/red_bird/texture_imp.hpp

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_TEXTURE_IMP_H
+#define RED_BIRD_TEXTURE_IMP_H 1
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include "main.h"
+
+struct bird_cTexture_PGM
+{
+  int width, height, max_value, data_size;
+  char *data;
+};
+
+SDL_bool
+bird_cTexture_PGM_load(
+    struct bird_cTexture_PGM *pgm_img, const char *file_path);
+  
+void
+bird_cTexture_PGM_unload(struct bird_cTexture_PGM *pgm_img);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* RED_BIRD_TEXTURE_IMP_H */

data/ext/red_bird/timer.c

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: MIT
+#include "timer.h"
+
+#include "engine.h"
+
+/*
+  Document-class: RedBird::Timer
+
+  A Timer controls the speed of execution of a frame; it prevents that a frame
+  run too quickly and give you compensation when a frame runs too slow.
+
+  When creating a new instance, you must define the maximum frame rate that you
+  want; then, you should call {#tick} at every frame to get a delta time. The
+  delta time is proportional to the frame rate defined during the creation of
+  the instance or is higher when the last frame was slower than expected.
+
+  @author Frederico Linhares
+*/
+VALUE bird_cTimer;
+
+/*
+  Basic functions all Ruby classes need.
+ */
+
+static void
+bird_free_timer(void* obj)
+{
+  struct bird_timer_data *ptr = obj;
+
+  free(ptr);
+}
+
+static size_t
+bird_memsize_timer(const void* obj)
+{
+  // TODO
+  return 0;
+}
+
+static const rb_data_type_t
+bird_timer_type = {
+  "red_bird_timer",
+  {0, bird_free_timer, bird_memsize_timer,},
+  0, 0,
+  RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+bird_alloc_timer(VALUE klass)
+{
+  VALUE obj;
+  struct bird_timer_data *ptr;
+
+  obj = TypedData_Make_Struct(klass, struct bird_timer_data, &bird_timer_type,
+                              ptr);
+
+  return obj;
+}
+
+/*
+  @param max_fps [Integer] the maximum of frames to be rendered per second.
+  @author Frederico Linhares
+*/
+VALUE
+bird_cTimer_initialize(VALUE self, VALUE max_fps)
+{
+  struct bird_timer_data *ptr;
+
+  if(!engine_initialized)
+    rb_raise(rb_eRuntimeError, "%s",
+             "can not create a RedBird::Timer instance before "
+             "RedBird::Engine is started");
+
+  RB_INTEGER_TYPE_P(max_fps);
+
+  TypedData_Get_Struct(self, struct bird_timer_data, &bird_timer_type, ptr);
+  ptr->max_frame_duration_ms = 1000 / NUM2INT(max_fps);
+  ptr->max_frame_duration_sec = ptr->max_frame_duration_ms/1000.0;
+  ptr->frame_start = SDL_GetTicks();
+
+  return self;
+}
+
+/*
+  Every time you call this method, it compares the current time with the last
+  time it was called; if the amount of time is inferior to the frame duration,
+  it waits to ensure the frame has the exact duration expected; otherwise, it
+  returns instantly and gives you a delta value that compensates for the extra
+  duration of the last frame.
+
+  @return [Float] represents the amount of time between this frame and the last
+    frame, the higher, the higher amount of time has passed.
+  @author Frederico Linhares
+*/
+VALUE
+bird_cTimer_tick(VALUE self)
+{
+  struct bird_timer_data *ptr;
+  Uint32 frame_stop;
+  Uint32 frame_duration;
+  VALUE delta;
+
+  TypedData_Get_Struct(self, struct bird_timer_data, &bird_timer_type, ptr);
+
+  frame_stop = SDL_GetTicks();
+  frame_duration = frame_stop - ptr->frame_start;
+
+  // If frame take less time than maximum allowed.
+  if(ptr->max_frame_duration_ms > frame_duration)
+  {
+    SDL_Delay(ptr->max_frame_duration_ms - frame_duration);
+    delta = rb_float_new(ptr->max_frame_duration_sec);
+  }
+  // If frame take too long time.
+  else
+  {
+    // SDL_GetTicks return time im miliseconds, so I need to divide by 1000 to
+    // get the time in seconds.
+    delta = rb_float_new((double)frame_duration/1000.0);
+  }
+
+  ptr->frame_start = frame_stop;
+
+  return delta;
+}
+
+void
+Init_red_bird_timer(void)
+{
+  bird_cTimer = rb_define_class_under(bird_m, "Timer", rb_cData);
+  rb_define_alloc_func(bird_cTimer, bird_alloc_timer);
+  rb_define_method(bird_cTimer, "initialize", bird_cTimer_initialize, 1);
+  rb_define_method(bird_cTimer, "tick", bird_cTimer_tick, 0);
+}

data/ext/red_bird/timer.h

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_TIMER_H
+#define RED_BIRD_TIMER_H 1
+
+#include "main.h"
+
+extern VALUE bird_cTimer;
+
+struct bird_timer_data
+{
+  Uint32 frame_start;
+  Uint32 max_frame_duration_ms; // in miliseconds
+  double max_frame_duration_sec; // in seconds
+};
+
+VALUE
+bird_cTimer_initialize(VALUE self, VALUE max_fps);
+
+VALUE
+bird_cTimer_tick(VALUE self);
+
+void
+Init_red_bird_timer(void);
+
+#endif // RED_BIRD_TIMER_H

data/lib/red_bird.rb

@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: MIT
+require_relative "red_bird/red_bird"
+require_relative "red_bird/controller"
+require_relative "red_bird/dynamic_sprite"
+require_relative "red_bird/engine"
+require_relative "red_bird/entity"
+require_relative "red_bird/input_device"
+require_relative "red_bird/palette"
+require_relative "red_bird/sprite"
+require_relative "red_bird/version"
+
+module RedBird
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/red_bird/animation.rb

@@ -0,0 +1,133 @@
+# SPDX-License-Identifier: MIT
+module RedBird
+  # This module contains different kinds of animations.
+  module Animation
+    # Each frame has a sprite and a duration.
+    #
+    # @!attribute [r] duration
+    #   @return [Integer] how long this frame lasts.
+    # @!attribute [r] sprite
+    #   @return [RedBird::Sprite] sprite to display in this frame.
+    # @see RedBird::Animation::Base
+    # @author Frederico Linhares
+    class Frame
+      attr_reader :duration, :sprite
+
+      # @param duration [Integer] this animation frame will persist for as many
+      #   game frames as defined by this value.
+      # @param sprite [RedBird::Sprite] sprite to be displayed in this frame.
+      # @author Frederico Linhares
+      def initialize(duration, sprite)
+        @duration = duration
+        @sprite = sprite
+      end
+
+      # Create an array of frames and return it. This method must receive an
+      # Array.
+      #
+      # @param frames [Array] each object in it must be an array containing the
+      #   attributes for each frame returned.
+      # @author Frederico Linhares
+      def self.sequence(frames)
+        return frames.collect { |i| Frame.new(i[0], i[1]) }
+      end
+    end
+
+    # Base class for different animations. An animation consists of a sequence
+    # of frames, a state to define which one to show and which comes next and
+    # an animation method to determine how the frames change.
+    #
+    # @author Frederico Linhares
+    class Base
+      # @return [RedBird::Sprite] the sprite for the current stage of the
+      #   animation.
+      attr_reader :current_sprite
+
+      # @param frames [Array] an array of RedBird::Frame.
+      # @author Frederico Linhares
+      def initialize(frames)
+        @frames = frames
+        self.set
+      end
+
+      # Set this animation to the initial state.
+      #
+      # @author Frederico Linhares
+      def reset
+        self.set
+      end
+    end
+
+    # This animation starts in the first frame and goes through every frame
+    # until the last, then it goes back to the first frame and starts again.
+    #
+    # @author Frederico Linhares
+    class Loop < Base
+      # This method must be called for every tick. It changes the current
+      # displayed sprite.
+      def animate
+        @current_time += 1
+        if @current_time > @frames[@current_frame].duration then
+          @current_time -= @frames[@current_frame].duration
+          @current_frame += 1
+          if @current_frame >= @frames.size then
+            @current_frame = 0
+          end
+          @current_sprite = @frames[@current_frame].sprite
+        end
+      end
+
+      protected
+      def set
+        @current_time = 0
+        @current_frame = 0
+        @current_sprite = @frames[@current_frame].sprite
+      end
+    end
+
+    # This animation starts in the first frame and goes through every frame
+    # until the last; then, it moves backward through every frame and starts
+    # again.
+    #
+    # @author Frederico Linhares
+    class BackAndForth < Base
+      # This method must be called for every tick. It changes the current
+      # displayed sprite.
+      def animate
+        case @direction
+        when :forward
+          @current_time += 1
+          if @current_time > @frames[@current_frame].duration then
+            @current_time -= @frames[@current_frame].duration
+            @current_frame += 1
+            if @current_frame >= @frames.size then
+              @direction = :backward
+              @current_frame = @frames.size - 2
+            end
+            @current_sprite = @frames[@current_frame].sprite
+          end
+        when :backward
+          @current_time += 1
+          if @current_time > @frames[@current_frame].duration then
+            @current_time -= @frames[@current_frame].duration
+            @current_frame -= 1
+            if @current_frame < 0 then
+              @direction = :forward
+              @current_frame = 1
+            end
+            @current_sprite = @frames[@current_frame].sprite
+          end
+        end
+      end
+
+      protected
+      def set
+        @direction = :forward
+        @current_time = 0
+        @current_frame = 0
+        @current_sprite = @frames[@current_frame].sprite
+      end
+    end
+
+  end
+end

data/lib/red_bird/camera.rb

@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: MIT
+module RedBird
+  # Because most of the time the tilemap used as the scenario is larger than
+  # the screen, you need to choose an entity to use as a reference. A Camera
+  # control the scenario offset and makes the position of the scene rendered in
+  # the screen be relative to an entity.
+  #
+  # @author Frederico Linhares
+  class Camera
+
+    # @param focus [RedBird::RelativeEntity] entity to use as reference for the
+    #   scenario
+    # @param scenario [RedBird::TileMap]
+    # @author Frederico Linhares
+    def initialize(focus, scenario)
+      @scenario = scenario
+      @max_hor_offset = @scenario.total_width - @scenario.width
+      @max_ver_offset = @scenario.total_height - @scenario.height
+      self.focus = focus
+    end
+
+    # Change the camere focus.
+    #
+    # @param focus [RedBird::RelativeEntity]
+    # @author Frederico Linhares
+    def focus=(focus)
+      @focus = focus
+      set_center
+    end
+
+    # Updates scenario offset according to entity position.
+    #
+    # @author Frederico Linhares
+    def call
+      hor_offset = (@focus.relative_pos_x - @hor_center).to_i
+      if hor_offset < 0 then
+        @scenario.hor_offset = 0
+      elsif hor_offset > @max_hor_offset then
+        @scenario.hor_offset = @max_hor_offset
+      else
+        @scenario.hor_offset = hor_offset
+      end
+
+      ver_offset = (@focus.relative_pos_y - @ver_center).to_i
+      if ver_offset < 0 then
+        @scenario.ver_offset = 0
+      elsif ver_offset > @max_ver_offset then
+        @scenario.ver_offset = @max_ver_offset
+      else
+        @scenario.ver_offset = ver_offset
+      end
+    end
+
+    private
+
+    def set_center
+      @hor_center = @scenario.width / 2 - @focus.width / 2
+      @ver_center = @scenario.height / 2 - @focus.height / 2
+    end
+  end
+end