red_bird 0.1.1

data/ext/red_bird/main.h

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_MAIN_H
+#define RED_BIRD_MAIN_H 1
+
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_ttf.h>
+
+#include "ruby.h"
+
+extern VALUE bird_m;
+
+#endif /* RED_BIRD_MAIN_H */

data/ext/red_bird/palette.c

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: MIT
+#include "color.h"
+#include "palette.h"
+
+/*
+  Document-class: RedBird::Palette
+  A palette consists in a set of 256 colors.
+
+  @author Frederico Linhares
+*/
+VALUE bird_cPalette;
+
+void
+bird_free_palette(void* obj)
+{
+  struct bird_palette_data *ptr = obj;
+
+  free(ptr);
+}
+
+size_t
+bird_memsize_palette(const void* obj)
+{
+  // TODO
+  return 0;
+}
+
+static const rb_data_type_t
+bird_palette_type = {
+  "red_bird_palette",
+  {0, bird_free_palette, bird_memsize_palette,},
+  0, 0,
+  RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE
+bird_alloc_palette(VALUE klass)
+{
+  VALUE obj;
+  struct bird_palette_data *ptr;
+
+  obj = TypedData_Make_Struct(klass, struct bird_palette_data,
+                              &bird_palette_type, ptr);
+
+  return obj;
+}
+
+/*
+  @param colors [Array<RedBird::Color>] an Array with 256 instances of
+    {RedBird::Color}.
+  @author Frederico Linhares
+ */
+VALUE
+bird_cPalette_initialize(VALUE self, VALUE colors)
+{
+  long ary_index, ary_len;
+  VALUE v_color;
+  struct bird_palette_data *ptr;
+  const char* error_message =
+      "colors must be an Array with 256 instances of RedBird::Color";
+
+  if(!rb_obj_is_kind_of(colors, rb_cArray))
+    rb_raise(rb_eArgError, "%s", error_message);
+
+  ary_len = RARRAY_LEN(colors);
+  if(ary_len != 256)
+    rb_raise(rb_eArgError, "%s", error_message);
+
+  TypedData_Get_Struct(self, struct bird_palette_data, &bird_palette_type,
+                       ptr);
+
+  for(ary_index = 0; ary_index < ary_len; ary_index++)
+  {
+    v_color = rb_ary_entry(colors, ary_index);
+    if(!rb_obj_is_kind_of(v_color, bird_cColor))
+      rb_raise(rb_eArgError, "%s", error_message);
+
+    ptr->colors[ary_index] = bird_cColor_get_data(v_color)->data;
+  }
+
+  return self;
+}
+
+/*
+  @param index [Integer] color index. Must be between 0 and 255.
+  @return [RedBird::Color] a instance of {RedBird::Color} with values
+    referenced by the index.
+  @author Frederico Linhares
+ */
+VALUE
+bird_cPalette_get_color(VALUE self, VALUE index)
+{
+  VALUE argv[4];
+  int c_index;
+  struct bird_palette_data *ptr;
+
+  RB_INTEGER_TYPE_P(index);
+
+  c_index = NUM2INT(index);
+  if(c_index < 0 || c_index > 255)
+    rb_raise(rb_eArgError, "%s", "index must be between 0 and 255");
+
+  TypedData_Get_Struct(self, struct bird_palette_data, &bird_palette_type,
+                       ptr);
+
+  argv[0] = UINT2NUM(ptr->colors[c_index].r);
+  argv[1] = UINT2NUM(ptr->colors[c_index].g);
+  argv[2] = UINT2NUM(ptr->colors[c_index].b);
+  argv[3] = UINT2NUM(ptr->colors[c_index].a);
+
+  return rb_class_new_instance(4, argv, bird_cColor);
+}
+
+struct bird_palette_data*
+bird_cPalette_get_data(VALUE self)
+{
+  struct bird_palette_data *ptr;
+
+  TypedData_Get_Struct(self, struct bird_palette_data, &bird_palette_type,
+                       ptr);
+
+  return ptr;
+}
+
+void
+Init_red_bird_palette(void)
+{
+  bird_cPalette = rb_define_class_under(bird_m, "Palette", rb_cData);
+  rb_define_alloc_func(bird_cPalette, bird_alloc_palette);
+  rb_define_method(bird_cPalette, "initialize", bird_cPalette_initialize, 1);
+  rb_define_method(bird_cPalette, "get_color", bird_cPalette_get_color, 1);
+}

data/ext/red_bird/palette.h

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_PALETTE_H
+#define RED_BIRD_PALETTE_H 1
+
+#include "main.h"
+
+extern VALUE bird_cPalette;
+
+struct bird_palette_data
+{
+  SDL_Color colors[256];
+};
+
+VALUE
+bird_cPalette_initialize(VALUE self, VALUE colors);
+
+struct bird_palette_data*
+bird_cPalette_get_data(VALUE self);
+
+void
+Init_red_bird_palette(void);
+
+#endif /* RED_BIRD_PALETTE_H */

data/ext/red_bird/rect.c

@@ -0,0 +1,257 @@
+// SPDX-License-Identifier: MIT
+#include "rect.h"
+
+/*
+  Document-class: RedBird::Rect
+
+  An abstract rectangular object used mainly for collision detection.
+
+  @author Frederico Linhares
+*/
+VALUE bird_cRect;
+
+/*
+  Basic functions all Ruby classes need.
+ */
+
+static void
+bird_free_rect(void* obj)
+{
+  struct bird_rect_data *ptr = obj;
+
+  free(ptr);
+}
+
+static size_t
+bird_memsize_rect(const void* obj)
+{
+  // TODO
+  return 0;
+}
+
+static const rb_data_type_t
+bird_rect_type = {
+  "red_bird_rect",
+  {0, bird_free_rect, bird_memsize_rect,},
+  0, 0,
+  RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+bird_alloc_rect(VALUE klass)
+{
+  VALUE obj;
+  struct bird_rect_data *ptr;
+
+  obj = TypedData_Make_Struct(klass, struct bird_rect_data, &bird_rect_type,
+                              ptr);
+
+  return obj;
+}
+
+/*
+  @param x [Integer] coordinate x for the rectangle position.
+  @param y [Integer] coordinate y for the rectangle position.
+  @param width [Integer] rectangle width.
+  @param height [Integer] rectangle height.
+  @author Frederico Linhares
+*/
+VALUE
+bird_cRect_initialize(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
+{
+  struct bird_rect_data *ptr;
+
+  RB_INTEGER_TYPE_P(x);
+  RB_INTEGER_TYPE_P(y);
+  RB_INTEGER_TYPE_P(width);
+  RB_INTEGER_TYPE_P(height);
+
+  TypedData_Get_Struct(self, struct bird_rect_data, &bird_rect_type, ptr);
+
+  ptr->data.x = NUM2INT(x);
+  ptr->data.y = NUM2INT(y);
+  ptr->data.w = NUM2INT(width);
+  ptr->data.h = NUM2INT(height);
+
+  return self;
+}
+
+/*
+  @return [Integer] coordinate x of this rectangle.
+  @author Frederico Linhares
+*/
+VALUE
+bird_cRect_get_x(VALUE self)
+{
+  struct bird_rect_data *ptr;
+
+  TypedData_Get_Struct(self, struct bird_rect_data, &bird_rect_type, ptr);
+
+  return INT2FIX(ptr->data.x);
+}
+
+/*
+  @return [Integer] coordinate y of this rectangle.
+  @author Frederico Linhares
+*/
+VALUE
+bird_cRect_get_y(VALUE self)
+{
+  struct bird_rect_data *ptr;
+
+  TypedData_Get_Struct(self, struct bird_rect_data, &bird_rect_type, ptr);
+
+  return INT2FIX(ptr->data.y);
+}
+
+/*
+  Set the coordinate x of this rectangle.
+
+  @param x [Integer]
+  @author Frederico Linhares
+*/
+VALUE
+bird_cRect_set_x(VALUE self, VALUE x)
+{
+  struct bird_rect_data *ptr;
+
+  RB_INTEGER_TYPE_P(x);
+  TypedData_Get_Struct(self, struct bird_rect_data, &bird_rect_type, ptr);
+
+  ptr->data.x = FIX2INT(x);
+
+  return x;
+}
+
+/*
+  Set the coordinate y of this rectangle.
+
+  @param y [Integer]
+  @author Frederico Linhares
+*/
+VALUE
+bird_cRect_set_y(VALUE self, VALUE y)
+{
+  struct bird_rect_data *ptr;
+
+  RB_INTEGER_TYPE_P(y);
+  TypedData_Get_Struct(self, struct bird_rect_data, &bird_rect_type, ptr);
+
+  ptr->data.y = FIX2INT(y);
+
+  return y;
+}
+
+/*
+  @return [Integer] width of this rectangle.
+  @author Frederico Linhares
+*/
+VALUE
+bird_cRect_get_width(VALUE self)
+{
+  struct bird_rect_data *ptr;
+
+  TypedData_Get_Struct(self, struct bird_rect_data, &bird_rect_type, ptr);
+
+  return INT2FIX(ptr->data.w);
+}
+
+/*
+  @return [Integer] height of this rectangle.
+  @author Frederico Linhares
+*/
+VALUE
+bird_cRect_get_height(VALUE self)
+{
+  struct bird_rect_data *ptr;
+
+  TypedData_Get_Struct(self, struct bird_rect_data, &bird_rect_type, ptr);
+
+  return INT2FIX(ptr->data.h);
+}
+
+/*
+  Set the width of this rectangle.
+
+  @param width [Integer]
+  @author Frederico Linhares
+*/
+VALUE
+bird_cRect_set_width(VALUE self, VALUE width)
+{
+  struct bird_rect_data *ptr;
+
+  RB_INTEGER_TYPE_P(width);
+  TypedData_Get_Struct(self, struct bird_rect_data, &bird_rect_type, ptr);
+
+  ptr->data.w = FIX2INT(width);
+
+  return width;
+}
+
+/*
+  Set the height of this rectangle.
+
+  @param height [Integer]
+  @author Frederico Linhares
+*/
+VALUE
+bird_cRect_set_height(VALUE self, VALUE height)
+{
+  struct bird_rect_data *ptr;
+
+  RB_INTEGER_TYPE_P(height);
+  TypedData_Get_Struct(self, struct bird_rect_data, &bird_rect_type, ptr);
+
+  ptr->data.h = FIX2INT(height);
+
+  return height;
+}
+
+/*
+  Test if this rectangle collided with another rectangle.
+
+  @param rect [RedBird::Rect]
+  @return [Boolean] true if there is a collision, false if there is no
+    collision.
+  @author Frederico Linhares
+*/
+VALUE
+bird_cRect_collide(VALUE self, VALUE rect)
+{
+  struct bird_rect_data *ptr1, *ptr2;
+
+  if(!rb_obj_is_kind_of(rect, bird_cRect))
+    rb_raise(rb_eTypeError, "%s",
+             "rect must be an instance of RedBird::Rect");
+
+  TypedData_Get_Struct(self, struct bird_rect_data, &bird_rect_type, ptr1);
+  TypedData_Get_Struct(rect, struct bird_rect_data, &bird_rect_type, ptr2);
+
+  if(ptr1->data.x <= ptr2->data.x + ptr2->data.w &&
+     ptr1->data.x + ptr1->data.w >= ptr2->data.x &&
+     ptr1->data.y <= ptr2->data.y + ptr2->data.h &&
+     ptr1->data.y + ptr1->data.h >= ptr2->data.y)
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+void
+Init_red_bird_rect(void)
+{
+  bird_cRect = rb_define_class_under(bird_m, "Rect", rb_cData);
+  rb_define_alloc_func(bird_cRect, bird_alloc_rect);
+  rb_define_method(bird_cRect, "initialize", bird_cRect_initialize, 4);
+
+  rb_define_method(bird_cRect, "x", bird_cRect_get_x, 0);
+  rb_define_method(bird_cRect, "y", bird_cRect_get_y, 0);
+  rb_define_method(bird_cRect, "x=", bird_cRect_set_x, 1);
+  rb_define_method(bird_cRect, "y=", bird_cRect_set_y, 1);
+  rb_define_method(bird_cRect, "width", bird_cRect_get_width, 0);
+  rb_define_method(bird_cRect, "height", bird_cRect_get_height, 0);
+  rb_define_method(bird_cRect, "width=", bird_cRect_set_width, 1);
+  rb_define_method(bird_cRect, "height=", bird_cRect_set_height, 1);
+
+  rb_define_method(bird_cRect, "collide?", bird_cRect_collide, 1);
+}

data/ext/red_bird/rect.h

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_RECT_H
+#define RED_BIRD_RECT_H 1
+
+#include "main.h"
+
+extern VALUE bird_cRect;
+
+struct bird_rect_data
+{
+  SDL_Rect data;
+};
+
+VALUE
+bird_cRect_initialize(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height);
+
+void
+Init_red_bird_rect(void);
+
+#endif /* RED_BIRD_RECT_H */

data/ext/red_bird/render.c

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: MIT
+#include "render.h"
+
+#include "color.h"
+#include "engine.h"
+
+/*
+  Document-module: RedBird::Render
+
+  This module contains basic rendering functionalities.
+
+  @author Frederico Linhares
+*/
+VALUE bird_mRender;
+
+
+/*
+  Use this method to define the color that will be used by some drawing
+  methods.
+
+  @param color [RedBird::Color]
+  @return [RedBird::Render] self
+  @author Frederico Linhares
+*/
+VALUE
+bird_mRender_set_color(VALUE self, VALUE color)
+{
+  struct bird_color_data *color_ptr;
+
+  if(!rb_obj_is_kind_of(color, bird_cColor))
+  {
+    rb_raise(rb_eTypeError, "%s",
+             "color must be an instance of RedBird::Color");
+
+    return self;
+  }
+
+  color_ptr = bird_cColor_get_data(color);
+
+  SDL_SetRenderDrawColor(
+      bird_core.renderer, color_ptr->data.r, color_ptr->data.g,
+      color_ptr->data.b, color_ptr->data.a);
+
+  return self;
+}
+
+/*
+  Draw a rectangle filled with a color defined by RedBird::Render.set_color.
+
+  @param x [Integer]
+  @param y [Integer]
+  @param width [Integer]
+  @param height [Integer]
+  @return [RedBird::Render] self
+  @see RedBird::Render.set_color
+  @author Frederico Linhares
+*/
+VALUE
+bird_mRender_fill_rect(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
+{
+  SDL_Rect rect;
+
+  RB_INTEGER_TYPE_P(x);
+  RB_INTEGER_TYPE_P(y);
+  RB_INTEGER_TYPE_P(width);
+  RB_INTEGER_TYPE_P(height);
+
+  rect.x = x;
+  rect.y = y;
+  rect.w = width;
+  rect.h = height;
+
+  SDL_RenderFillRect(bird_core.renderer, &rect);
+
+  return self;
+}
+
+/*
+  Fill the entire screen with a single color defined by
+  RedBird::Render.set_color.
+
+  @return [RedBird::Render] self
+  @see RedBird::Render.set_color
+  @author Frederico Linhares
+*/
+VALUE
+bird_mRender_clear_screen(VALUE self)
+{
+  SDL_RenderClear(bird_core.renderer);
+
+  return self;
+}
+
+/*
+  Every time you draw anything, this drawing is not applied directly to the
+  screen; instead, the command draws to a buffer. This procedure allows you to
+  do all the drawing before you present it to the user. After you finish all
+  updates you want into the buffer, you must call this method to send the final
+  buffer to the screen.
+
+  @return [RedBird::Render] self
+  @author Frederico Linhares
+*/
+VALUE
+bird_mRender_update_screen(VALUE self)
+{
+  SDL_SetRenderTarget(bird_core.renderer, NULL);
+
+  SDL_RenderCopy(bird_core.renderer, bird_core.pre_screen_buffer, NULL,
+                 &bird_core.screen_rect);
+  SDL_RenderPresent(bird_core.renderer);
+
+  SDL_SetRenderTarget(bird_core.renderer, bird_core.pre_screen_buffer);
+
+  return self;
+}
+
+void
+Init_red_bird_render(void)
+{
+  bird_mRender = rb_define_module_under(bird_m, "Render");
+  rb_define_module_function(bird_mRender, "set_color", bird_mRender_set_color,
+                            1);
+  rb_define_module_function(bird_mRender, "fill_rect", bird_mRender_fill_rect,
+                            4);
+  rb_define_module_function(bird_mRender, "clear_screen",
+                            bird_mRender_clear_screen, 0);
+  rb_define_module_function(bird_mRender, "update_screen",
+                            bird_mRender_update_screen, 0);
+}