red_bird 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 815c82919387f7aaa0a34ec4e50faf885c3d43f1be1e2b5533c939e907af6aea
+  data.tar.gz: 397c6e509536b737bb87bfeafe9e6e7e30490449b4977f12e9dc469e98f96939
+SHA512:
+  metadata.gz: 327d4193f540b20a82f9650f011c695ea8aacfb708e2488578cf30470177a3f22aa2bb3f829113f0940f51c73b7dffe2848df03b866e769bc7e159e8414a57eb
+  data.tar.gz: 35ed309150aab1a128c98e9a66f5506b633f2f6e8628798a4057c90d0b55e90387a2bfa37c108b6456f7a532fc963476d1542670a52548254991b15f63a2de09

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in red_bird.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    red_bird (0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (13.0.1)
+    rake-compiler (1.0.8)
+      rake
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 2.0)
+  rake (>= 10.0)
+  rake-compiler
+  red_bird!
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Frederico Linhares
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# RedBird
+
+RedBird is a 2D game engine for Ruby, it is designed to make game development quick and easy.
+
+## Installation
+
+RedBird gem links against libSDL2 and libSDL2_ttf, so before installing RedBird into a machine, ensure that development libraries for SDL are installed.
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'red_bird'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install red_bird
+
+## Usage
+
+To crate a minimal code using RedBird you need to call {RedBird::Engine.run}
+and pass to it a code block that returns a {RedBird::Stage}:
+
+    require 'red_bird'
+    require 'red_bird/stage'
+
+    class Stage < RedBird::Stage
+      def initialize(global_data)
+	    super(global_data)
+        @controller = RedBird::Controller.new
+        @input_device = RedBird::InputDevice.new(@controller)
+      end
+    end
+
+    RedBird::Engine.run(nil) { |global_data| Stage.new(global_data) }
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [bitbucket.org/fredlinhares/red_bird](https://bitbucket.org/fredlinhares/red_bird)
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+
+task :build => :compile
+
+Rake::ExtensionTask.new("red_bird") do |ext|
+  ext.lib_dir = "lib/red_bird"
+end
+
+task :default => [:clobber, :compile]

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/red_bird/bird.c

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+#include "bird.h"
+
+/*
+  Document-module: RedBird
+
+  This module exist to prevent name clashes.
+
+  @author Frederico Linhares
+ */
+void
+Init_red_bird_module(void)
+{
+  bird_m = rb_define_module("RedBird");
+}

data/ext/red_bird/bird.h

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_BIRD_H
+#define RED_BIRD_BIRD_H 1
+
+#include "main.h"
+
+void
+Init_red_bird_module(void);
+
+#endif /* RED_BIRD_MAIN_H */

data/ext/red_bird/color.c

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+#include "color.h"
+
+/*
+  Document-class: RedBird::Color
+  A color represented by red, green, blue, and alpha (transparency) values.
+*/
+VALUE bird_cColor;
+
+/*
+  Basic functions all Ruby classes need.
+ */
+
+void
+bird_free_color(void* obj)
+{
+  struct bird_color_data *ptr = obj;
+
+  free(ptr);
+}
+
+size_t
+bird_memsize_color(const void* obj)
+{
+  // TODO
+  return 0;
+}
+
+static const rb_data_type_t
+bird_color_type = {
+  "red_bird_color",
+  {0, bird_free_color, bird_memsize_color,},
+  0, 0,
+  RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE
+bird_alloc_color(VALUE klass)
+{
+  VALUE obj;
+  struct bird_color_data *ptr;
+
+  obj = TypedData_Make_Struct(klass, struct bird_color_data, &bird_color_type,
+                              ptr);
+
+  return obj;
+}
+
+/*
+  Create a new color based in the RGBA color model.
+
+  @param red [Integer] the amount of red (between 0 and 255).
+  @param green [Integer] the amount of green (between 0 and 255).
+  @param blue [Integer] the amount of blue (between 0 and 255).
+  @param alpha [Integer] the amount of transparency (between 0 and 255). 0 is
+    transparent, 255 is opaque.
+*/
+VALUE
+bird_cColor_initialize(VALUE self, VALUE red, VALUE green, VALUE blue,
+                       VALUE alpha)
+{
+  struct bird_color_data *ptr;
+
+  RB_INTEGER_TYPE_P(red);
+  RB_INTEGER_TYPE_P(green);
+  RB_INTEGER_TYPE_P(blue);
+  RB_INTEGER_TYPE_P(alpha);
+
+  TypedData_Get_Struct(self, struct bird_color_data, &bird_color_type, ptr);
+
+  ptr->data.r = NUM2UINT(red);
+  ptr->data.g = NUM2UINT(green);
+  ptr->data.b = NUM2UINT(blue);
+  ptr->data.a = NUM2UINT(alpha);
+
+  return self;
+}
+
+struct bird_color_data*
+bird_cColor_get_data(VALUE self)
+{
+  struct bird_color_data *ptr;
+
+  TypedData_Get_Struct(self, struct bird_color_data, &bird_color_type, ptr);
+
+  return ptr;
+}
+
+void
+Init_red_bird_color(void)
+{
+  bird_cColor = rb_define_class_under(bird_m, "Color", rb_cData);
+  rb_define_alloc_func(bird_cColor, bird_alloc_color);
+  rb_define_method(bird_cColor, "initialize", bird_cColor_initialize, 4);
+}

data/ext/red_bird/color.h

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_COLOR_H
+#define RED_BIRD_COLOR_H 1
+
+#include "main.h"
+
+extern VALUE bird_cColor;
+
+struct bird_color_data
+{
+  SDL_Color data;
+};
+
+VALUE
+bird_alloc_color(VALUE klass);
+
+VALUE
+bird_cColor_initialize(VALUE self, VALUE red, VALUE green, VALUE blue,
+                       VALUE aplha);
+
+struct bird_color_data*
+bird_cColor_get_data(VALUE self);
+
+void
+Init_red_bird_color(void);
+
+#endif /* RED_BIRD_COLOR_H */

data/ext/red_bird/dynamic_sprite.c

@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: MIT
+#include "dynamic_sprite.h"
+
+#include "engine.h"
+#include "texture.h"
+
+VALUE bird_cDynamicSprite;
+
+static ID id_at_texture;
+static VALUE id_flip;
+static VALUE id_vertical;
+static VALUE id_horizontal;
+static VALUE id_both;
+
+// TODO: make this class inherit from RedBird::Sprite.
+
+/*
+  Basic functions that all Ruby classes need.
+ */
+
+void
+bird_free_dynamic_sprite(void* obj)
+{
+  struct bird_dynamic_sprite_data *ptr = obj;
+
+  free(ptr);
+}
+
+size_t
+bird_memsize_dynamic_sprite(const void* obj)
+{
+  // TODO
+  return 0;
+}
+
+static const rb_data_type_t
+bird_dynamic_sprite_type = {
+  "red_bird_dynamic_sprite",
+  {0, bird_free_dynamic_sprite, bird_memsize_dynamic_sprite,},
+  0, 0,
+  RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE
+bird_alloc_dynamic_sprite(VALUE klass)
+{
+  VALUE obj;
+  struct bird_dynamic_sprite_data *ptr;
+
+  obj = TypedData_Make_Struct(klass, struct bird_dynamic_sprite_data,
+                              &bird_dynamic_sprite_type, ptr);
+
+  return obj;
+}
+
+/*
+  @param texture [RedBird::Texture]
+  @param x [Integer]
+  @param y [Integer]
+  @param width [Integer]
+  @param height [Integer]
+  @param mods [Hash]
+*/
+VALUE
+bird_cDynamicSprite_initialize(VALUE self, VALUE texture, VALUE  x, VALUE  y,
+                               VALUE  width, VALUE  height, VALUE mods)
+{
+  struct bird_dynamic_sprite_data *ptr;
+
+  VALUE hash_val;
+
+  if(!rb_obj_is_kind_of(texture, bird_cTexture))
+    rb_raise(rb_eTypeError, "%s",
+             "texture must be an instance of RedBird::Texture");
+  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_dynamic_sprite_data,
+                       &bird_dynamic_sprite_type, ptr);
+
+  rb_ivar_set(self, id_at_texture, texture);
+  ptr->rect.x = NUM2INT(x);
+  ptr->rect.y = NUM2INT(y);
+  ptr->rect.w = NUM2INT(width);
+  ptr->rect.h = NUM2INT(height);
+
+  ptr->angle = 0;
+  ptr->center.x = 0;
+  ptr->center.y = 0;
+
+  // Get 'flip'.
+  ptr->flip = SDL_FLIP_NONE; // By default do not flip.
+  hash_val = rb_hash_aref(mods, id_flip);
+  if(SYMBOL_P(hash_val))
+  {
+    if(hash_val == id_vertical)
+      ptr->flip = SDL_FLIP_VERTICAL;
+    else if(hash_val == id_horizontal)
+      ptr->flip = SDL_FLIP_HORIZONTAL;
+    else if(hash_val == id_both)
+      ptr->flip = SDL_FLIP_VERTICAL | SDL_FLIP_HORIZONTAL;
+  }
+
+  return self;
+}
+
+/*
+  Render itself directly to the screen.
+
+  @param x [Integer] x coordinate of the screen.
+  @param y [Integer] y coordinate of the screen.
+  @return [RedBird::DynamicSprite] self
+  @author Frederico Linhares
+*/
+VALUE
+bird_cDynamicSprite_render_to_screen(VALUE self, VALUE  x, VALUE  y)
+{
+  SDL_Rect dst_rect;
+
+  struct bird_dynamic_sprite_data *ptr;
+  struct bird_texture_data *texture_ptr;
+
+  VALUE texture;
+
+  RB_INTEGER_TYPE_P(x);
+  RB_INTEGER_TYPE_P(y);
+
+  texture = rb_ivar_get(self, id_at_texture);
+
+  TypedData_Get_Struct(self, struct bird_dynamic_sprite_data,
+                       &bird_dynamic_sprite_type, ptr);
+  texture_ptr = bird_cTexture_get_data(texture);
+
+  dst_rect.x = NUM2INT(x);
+  dst_rect.y = NUM2INT(y);
+  dst_rect.w = ptr->rect.w;
+  dst_rect.h = ptr->rect.h;
+
+  SDL_RenderCopyEx(bird_core.renderer, texture_ptr->data, &ptr->rect,
+                   &dst_rect, ptr->angle, &ptr->center, ptr->flip);
+
+  return self;
+}
+
+void
+Init_red_bird_dynamic_sprite(void)
+{
+  id_at_texture = rb_intern("@texture");
+  id_flip = ID2SYM(rb_intern("flip"));
+  id_vertical = ID2SYM(rb_intern("vertical"));
+  id_horizontal = ID2SYM(rb_intern("horizontal"));
+  id_both = ID2SYM(rb_intern("both"));
+
+  bird_cDynamicSprite = rb_define_class_under(bird_m, "DynamicSprite",
+                                              rb_cData);
+  rb_define_alloc_func(bird_cDynamicSprite, bird_alloc_dynamic_sprite);
+  rb_define_method(bird_cDynamicSprite, "initialize",
+                   bird_cDynamicSprite_initialize, 6);
+  rb_define_method(bird_cDynamicSprite, "render_to_screen",
+                   bird_cDynamicSprite_render_to_screen, 2);
+}