red_bird 0.1.1

data/ext/red_bird/font.h

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_FONT_H
+#define RED_BIRD_FONT_H 1
+
+#include "main.h"
+
+extern VALUE bird_cFont;
+
+struct bird_font_data
+{
+  TTF_Font *data;
+};
+
+VALUE
+bird_alloc_font(VALUE klass);
+
+VALUE
+bird_cFont_initialize(VALUE self, VALUE file_path, VALUE size);
+
+struct bird_font_data*
+bird_cFont_get_data(VALUE self);
+
+void
+Init_red_bird_font(void);
+
+#endif /* RED_BIRD_FONT_H */

data/ext/red_bird/input_device.c

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: MIT
+#include "input_device.h"
+
+#include "engine.h"
+
+VALUE bird_cInputDevice;
+
+static VALUE sym_key_down;
+static VALUE sym_key_up;
+static VALUE sym_mouse_motion;
+static VALUE sym_mouse_button_down;
+static VALUE sym_mouse_button_up;
+static VALUE sym_quit_game;
+static VALUE sym_x;
+static VALUE sym_y;
+
+VALUE
+bird_cInputDevice_get_events(VALUE self)
+{
+  SDL_Event event;
+  int mouse_x;
+  int mouse_y;
+
+  VALUE type;
+  VALUE data;
+  VALUE x;
+  VALUE y;
+
+  rb_need_block();
+
+  // Get input
+  while(SDL_PollEvent(&event) != 0)
+  {
+    switch(event.type)
+    {
+      case SDL_KEYDOWN:
+        type = sym_key_down;
+        data = INT2NUM(event.key.keysym.sym);
+        break;
+      case SDL_KEYUP:
+        type = sym_key_up;
+        data = INT2NUM(event.key.keysym.sym);
+        break;
+      case SDL_MOUSEMOTION:
+        type = sym_mouse_motion;
+        SDL_GetMouseState(&mouse_x, &mouse_y);
+        x = INT2NUM(mouse_x);
+        y = INT2NUM(mouse_y);
+        data = rb_hash_new();
+        rb_hash_aset(data, sym_x, x);
+        rb_hash_aset(data, sym_y, y);
+        break;
+      case SDL_MOUSEBUTTONDOWN:
+        type = sym_mouse_button_down;
+        SDL_GetMouseState(&mouse_x, &mouse_y);
+        x = INT2NUM(mouse_x);
+        y = INT2NUM(mouse_y);
+        data = rb_hash_new();
+        rb_hash_aset(data, sym_x, x);
+        rb_hash_aset(data, sym_y, y);
+        break;
+      case SDL_MOUSEBUTTONUP:
+        type = sym_mouse_button_up;
+        SDL_GetMouseState(&mouse_x, &mouse_y);
+        x = INT2NUM(mouse_x);
+        y = INT2NUM(mouse_y);
+        data = rb_hash_new();
+        rb_hash_aset(data, sym_x, x);
+        rb_hash_aset(data, sym_y, y);
+        break;
+      case SDL_QUIT:
+        type = sym_quit_game;
+        data = Qnil;
+        break;
+      default:
+        continue;
+    }
+
+    rb_yield_values(2, type, data);
+  }
+
+  return self;
+}
+
+void
+Init_red_bird_input_device(void)
+{
+  sym_key_down = ID2SYM(rb_intern("key_down"));
+  sym_key_up = ID2SYM(rb_intern("key_up"));
+  sym_mouse_motion = ID2SYM(rb_intern("mouse_motion"));
+  sym_mouse_button_down = ID2SYM(rb_intern("mouse_button_down"));
+  sym_mouse_button_up = ID2SYM(rb_intern("mouse_button_up"));
+  sym_quit_game = ID2SYM(rb_intern("quit_game"));
+  sym_x = ID2SYM(rb_intern("x"));
+  sym_y = ID2SYM(rb_intern("y"));
+
+  bird_cInputDevice = rb_define_class_under(bird_m, "InputDevice", rb_cObject);
+  rb_define_protected_method(bird_cInputDevice, "get_events",
+                             bird_cInputDevice_get_events, 0);
+}

data/ext/red_bird/input_device.h

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_INPUT_DEVICE_H
+#define RED_BIRD_INPUT_DEVICE_H 1
+
+#include "main.h"
+
+extern VALUE bird_cInputDevice;
+
+VALUE
+bird_cInputDevice_get_events(VALUE self);
+
+void
+Init_red_bird_input_device(void);
+
+#endif /* RED_BIRD_INPUT_DEVICE_H */

data/ext/red_bird/keycode.c

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+#include "keycode.h"
+
+VALUE bird_mKeycode;
+
+void
+Init_red_bird_keycode(void)
+{
+  bird_mKeycode = rb_define_module_under(bird_m, "Keycode");
+
+  rb_define_const(bird_mKeycode, "A", INT2NUM(SDLK_a));
+  rb_define_const(bird_mKeycode, "B", INT2NUM(SDLK_b));
+  rb_define_const(bird_mKeycode, "C", INT2NUM(SDLK_c));
+  rb_define_const(bird_mKeycode, "D", INT2NUM(SDLK_d));
+  rb_define_const(bird_mKeycode, "E", INT2NUM(SDLK_e));
+  rb_define_const(bird_mKeycode, "F", INT2NUM(SDLK_f));
+  rb_define_const(bird_mKeycode, "G", INT2NUM(SDLK_g));
+  rb_define_const(bird_mKeycode, "H", INT2NUM(SDLK_h));
+  rb_define_const(bird_mKeycode, "I", INT2NUM(SDLK_i));
+  rb_define_const(bird_mKeycode, "J", INT2NUM(SDLK_j));
+  rb_define_const(bird_mKeycode, "K", INT2NUM(SDLK_k));
+  rb_define_const(bird_mKeycode, "L", INT2NUM(SDLK_l));
+  rb_define_const(bird_mKeycode, "M", INT2NUM(SDLK_m));
+  rb_define_const(bird_mKeycode, "N", INT2NUM(SDLK_n));
+  rb_define_const(bird_mKeycode, "O", INT2NUM(SDLK_o));
+  rb_define_const(bird_mKeycode, "P", INT2NUM(SDLK_p));
+  rb_define_const(bird_mKeycode, "Q", INT2NUM(SDLK_q));
+  rb_define_const(bird_mKeycode, "R", INT2NUM(SDLK_r));
+  rb_define_const(bird_mKeycode, "S", INT2NUM(SDLK_s));
+  rb_define_const(bird_mKeycode, "T", INT2NUM(SDLK_t));
+  rb_define_const(bird_mKeycode, "U", INT2NUM(SDLK_u));
+  rb_define_const(bird_mKeycode, "V", INT2NUM(SDLK_v));
+  rb_define_const(bird_mKeycode, "W", INT2NUM(SDLK_w));
+  rb_define_const(bird_mKeycode, "X", INT2NUM(SDLK_x));
+  rb_define_const(bird_mKeycode, "Y", INT2NUM(SDLK_y));
+  rb_define_const(bird_mKeycode, "Z", INT2NUM(SDLK_z));
+
+  rb_define_const(bird_mKeycode, "KEY_UP", INT2NUM(SDLK_UP));
+  rb_define_const(bird_mKeycode, "KEY_DOWN", INT2NUM(SDLK_DOWN));
+  rb_define_const(bird_mKeycode, "KEY_LEFT", INT2NUM(SDLK_LEFT));
+  rb_define_const(bird_mKeycode, "KEY_RIGHT", INT2NUM(SDLK_RIGHT));
+}

data/ext/red_bird/keycode.h

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_KEYCODE_H
+#define RED_BIRD_KEYCODE_H 1
+
+#include "main.h"
+
+extern VALUE bird_mKeycode;
+
+void
+Init_red_bird_keycode(void);
+
+#endif /* RED_BIRD_KEYCODE_H */

data/ext/red_bird/loader.c

@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: MIT
+#include <stdlib.h>
+
+#include "loader.h"
+
+static SDL_bool
+LoaderStack_step_load(LoaderStack *self, int32_t step)
+{
+  SDL_bool error = SDL_FALSE;
+
+  // Already loaded, nothing to do.
+  if(self->last_loaded >= step) return SDL_TRUE;
+
+  for(;self->last_loaded < step; self->last_loaded++)
+    {
+      error = !self->loaders[self->last_loaded].load(self->obj, self);
+      if(error) break;
+    }
+
+  // Self number will be one after the last loeaded after the loading loop is
+  // over.
+  self->last_loaded--;
+
+  if(error)
+    {
+      // Backward interaction to unload what was loaded.
+      for(;self->last_loaded >= 0; self->last_loaded--)
+	self->loaders[self->last_loaded].unload(self->obj, self);
+      self->last_loaded++;
+    }
+
+  return !error;
+}
+
+static void
+LoaderStack_step_unload(LoaderStack *self, int32_t step)
+{
+  // Already unloaded, nothing to do.
+  if(self->last_loaded <= step) return;
+
+  for(; self->last_loaded >= 0; self->last_loaded--)
+    self->loaders[self->last_loaded].unload(self->obj, self);
+
+  // Self number will be one before the last loeaded after the unloading loop
+  // is over.
+  self->last_loaded++;
+
+  self->is_loaded = SDL_FALSE;
+}
+
+void
+LoaderStack_constructor(LoaderStack *self, void *obj)
+{
+  self->is_loaded = SDL_FALSE;
+  self->last_loaded = 0;
+
+  self->loader_capacity = 10; // Totally arbitrary value.
+  self->loader_size = 0;
+
+  self->obj = obj;
+
+  self->error_message = 0;
+
+  self->loaders = malloc(sizeof(Loader) * self->loader_capacity);
+}
+
+void
+LoaderStack_destructor(LoaderStack *self)
+{
+  if(self->error_message != 0)
+    free(self->error_message);
+
+  if(self->is_loaded) LoaderStack_unload(self);
+  free(self->loaders);
+}
+
+void
+LoaderStack_add(LoaderStack *self,
+  SDL_bool (*load)(void *obj, LoaderStack *ls),
+  void (*unload)(void *obj, LoaderStack *ls))
+{
+  Loader *l;
+  uint32_t next_loader = self->loader_size;
+
+  // Expand if is full.
+  if(self->loader_size == self->loader_capacity)
+    {
+      self->loader_capacity += 5; // Totally arbitrary value.
+      self->loaders = realloc(self->loaders,
+	sizeof(Loader) * self->loader_capacity);
+    }
+
+  l = &(self->loaders[next_loader]);
+  l->load = load;
+  l->unload = unload;
+
+  self->loader_size++;
+}
+
+void
+LoaderStack_set_error(LoaderStack *self, const char* base_error,
+  const char* current_error)
+{
+  if(self->error_message != 0)
+    free(self->error_message);
+
+  if(current_error != NULL)
+    {
+      self->error_message =
+	malloc(strlen(base_error) + strlen(current_error) + 1);
+
+      strcpy(self->error_message, base_error);
+      strcat(self->error_message, current_error);
+    }
+  else
+    {
+      self->error_message = malloc(strlen(base_error));
+
+      strcpy(self->error_message, base_error);
+    }
+}
+
+SDL_bool
+LoaderStack_load(LoaderStack *self)
+{
+  if(self->is_loaded) return SDL_TRUE;
+
+  if(LoaderStack_step_load(self, self->loader_size))
+    {
+      self->is_loaded = SDL_TRUE;
+      return SDL_TRUE;
+    }
+  else
+    {
+      return SDL_FALSE;
+    }
+}
+
+SDL_bool
+LoaderStack_reload(LoaderStack *self, int32_t step)
+{
+  if(!self->is_loaded) return SDL_FALSE;
+
+  LoaderStack_step_unload(self, self->loader_size);
+  return LoaderStack_step_load(self, step);
+}
+
+void
+LoaderStack_unload(LoaderStack *self)
+{
+  if(!self->is_loaded) return;
+
+  LoaderStack_step_unload(self, 0);
+}

data/ext/red_bird/loader.h

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_LOADER_H
+#define RED_BIRD_LOADER_H 1
+
+#include "main.h"
+
+struct LoaderStack_s;
+
+typedef struct
+{
+  SDL_bool (*load)(void *obj, struct LoaderStack_s *ls);
+  void (*unload)(void *obj, struct LoaderStack_s *ls);
+} Loader;
+
+struct LoaderStack_s
+{
+  void *obj;
+  SDL_bool is_loaded;
+  int32_t last_loaded;
+
+  uint32_t loader_capacity;
+  uint32_t loader_size;
+  Loader *loaders;
+
+  char* error_message;
+};
+
+typedef struct LoaderStack_s LoaderStack;
+
+void
+LoaderStack_constructor(LoaderStack *self, void *obj);
+
+void
+LoaderStack_destructor(LoaderStack *self);
+
+void
+LoaderStack_add(LoaderStack *self,
+  SDL_bool (*load)(void *obj, LoaderStack *ls),
+  void (*unload)(void *obj, LoaderStack *ls));
+
+void
+LoaderStack_set_error(LoaderStack *self, const char* base_error,
+  const char* current_error);
+
+SDL_bool
+LoaderStack_load(LoaderStack *self);
+
+SDL_bool
+LoaderStack_reload(LoaderStack *self, int32_t step);
+
+void
+LoaderStack_unload(LoaderStack *self);
+
+#endif /* RED_BIRD_LOADER_H */

data/ext/red_bird/main.c

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+#include "main.h"
+
+#include "bird.h"
+#include "color.h"
+#include "dynamic_sprite.h"
+#include "engine.h"
+#include "font.h"
+#include "keycode.h"
+#include "input_device.h"
+#include "palette.h"
+#include "rect.h"
+#include "render.h"
+#include "sprite.h"
+#include "texture.h"
+#include "text.h"
+#include "timer.h"
+
+VALUE bird_m;
+
+void
+Init_red_bird(void)
+{
+  Init_red_bird_module();
+  Init_red_bird_engine();
+  Init_red_bird_color();
+  Init_red_bird_dynamic_sprite();
+  Init_red_bird_font();
+  Init_red_bird_keycode();
+  Init_red_bird_input_device();
+  Init_red_bird_palette();
+  Init_red_bird_rect();
+  Init_red_bird_render();
+  Init_red_bird_sprite();
+  Init_red_bird_text();
+  Init_red_bird_texture();
+  Init_red_bird_timer();
+}