Rug 0.0.2

data/README

@@ -0,0 +1,32 @@
+Rug is a basic gaming library for Ruby, based on Love2D for Lua. The goal is to promote
+rapid game development by handling the boiler plate details under the hood and leave the
+fun stuff for the programmer.
+
+============================
+        Dependencies
+============================
+
+In order to build Rug, you need a few dependencies:
+  - Ruby development headers
+  - SDL
+  - SDL_image
+
+In Ubuntu, you can install these with apt-get:
+
+  sudo apt-get install ruby-dev libsdl1.2-dev libsdl-image1.2-dev
+
+============================
+        Installation
+============================
+
+At the moment only Linux has been tested, but the library should work on any system
+that supports both Ruby and SDL. You need the SDL libraries installed in order to 
+build Rug.
+
+To build:
+
+    ruby extconf.rb
+    make
+
+At the moment there are no pre-built versions of Rug for you to download. These will
+be made available as soon as possible.

data/Rakefile

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+spec = Gem::Specification.new do |s|
+  s.name         = "Rug"
+  s.version      = "0.0.2"
+  s.author       = "Rob Britton"
+  s.email        = "rob.s.brit@gmail.com"
+  s.platform     = Gem::Platform::RUBY
+  s.summary      = "A simple game framework."
+  s.files        = FileList["Rakefile", "lib/*.rb", "ext/*.{c,h}", "README"].to_a
+  s.require_path = "lib"
+  s.has_rdoc     = false
+  s.extensions   = ["ext/extconf.rb"]
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
+end

data/ext/extconf.rb

@@ -0,0 +1,14 @@
+require 'mkmf'
+
+good = true
+
+libraries = %w[SDL SDL_image]
+
+libraries.each do |lib|
+  if not have_library(lib)
+    good = false
+  end
+end
+
+create_makefile("Rug") if good
+

data/ext/rug.c

@@ -0,0 +1,117 @@
+#include "ruby.h"
+
+#include "rug_conf.h"
+#include "rug_resources.h"
+#include "rug_events.h"
+
+#include <SDL/SDL.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+SDL_Surface * mainWnd = NULL;
+VALUE loadFunc, drawFunc, updateFunc;
+
+VALUE mRug, mRugEvent;
+
+extern _RugConf RugConf;
+
+static VALUE RugLoad(int argc, VALUE * argv, VALUE class){
+  if (rb_block_given_p()){
+    VALUE func;
+    rb_scan_args(argc, argv, "0&", &func);
+    loadFunc = func;
+  }
+  return Qnil;
+}
+
+static VALUE RugDraw(int argc, VALUE * argv, VALUE class){
+  if (rb_block_given_p()){
+    VALUE func;
+    rb_scan_args(argc, argv, "0&", &func);
+    drawFunc = func;
+  }
+  return Qnil;
+}
+
+static VALUE RugUpdate(int argc, VALUE * argv, VALUE class){
+  if (rb_block_given_p()){
+    VALUE func;
+    rb_scan_args(argc, argv, "0&", &func);
+    updateFunc = func;
+  }
+  return Qnil;
+}
+
+static VALUE RugStart(VALUE class){
+  SDL_Init(SDL_INIT_VIDEO);
+  atexit(SDL_Quit);
+
+  SDL_Event ev;
+  int lastDraw = 0;
+
+  int frameGap = RugConf.frameGap;
+
+  mainWnd = DoConf();
+
+  if (loadFunc != Qnil){
+    rb_funcall(loadFunc, rb_intern("call"), 0);
+  }
+
+  // TODO: make background configurable
+  Uint32 black = SDL_MapRGB(mainWnd->format, 0, 0, 0);
+
+  while (1){
+    if (SDL_PollEvent(&ev)){
+      if (!HandleEvent(ev)){
+        break;
+      }
+    }
+
+    int now = SDL_GetTicks();
+    if (lastDraw + frameGap < now){
+      // update
+      if (updateFunc != Qnil){
+        rb_funcall(updateFunc, rb_intern("call"), 1, INT2NUM(now - lastDraw));
+      }
+
+      // render
+      SDL_FillRect(mainWnd, NULL, black);
+
+      if (drawFunc != Qnil){
+        rb_funcall(drawFunc, rb_intern("call"), 0);
+      }
+      SDL_UpdateRect(mainWnd, 0, 0, 0, 0);
+      lastDraw = now;
+    }
+
+    SDL_Delay(1);
+  }
+
+  return Qnil;
+}
+
+VALUE RugShowCursor(VALUE class, VALUE show){
+  SDL_ShowCursor(TYPE(show) == T_TRUE);
+}
+
+void Init_Rug(){
+  loadFunc = updateFunc = drawFunc = Qnil;
+
+  // Main Rug module
+  mRug = rb_define_module("Rug");
+
+  // main Rug actions
+  rb_define_singleton_method(mRug, "load", RugLoad, -1);
+  rb_define_singleton_method(mRug, "draw", RugDraw, -1);
+  rb_define_singleton_method(mRug, "update", RugUpdate, -1);
+  rb_define_singleton_method(mRug, "start", RugStart, -1);
+
+  // some basic options
+  rb_define_singleton_method(mRug, "show_cursor=", RugShowCursor, 1);
+
+  // load additional classes/modules
+  LoadConf(mRug);
+  LoadEvents(mRug);
+  LoadResourcesModule(mRug);
+  LoadLayer(mRug);
+}

data/ext/rug_conf.c

@@ -0,0 +1,104 @@
+#include "rug_conf.h"
+
+#include <SDL/SDL.h>
+
+_RugConf RugConf;
+VALUE cRugConf;
+VALUE block_converter;
+
+VALUE RugConfSetWidth(VALUE self, VALUE _width){
+  RugConf.width = NUM2INT(_width);
+  return _width;
+}
+VALUE RugConfSetHeight(VALUE self, VALUE _height){
+  RugConf.height = NUM2INT(_height);
+  return _height;
+}
+VALUE RugConfSetBpp(VALUE self, VALUE _bpp){
+  RugConf.bpp = NUM2INT(_bpp);
+  return _bpp;
+}
+
+VALUE RugConfSetTitle(VALUE self, VALUE _title){
+  RugConf.title = _title;
+  return _title;
+}
+
+VALUE RugConfSetDelay(VALUE self, VALUE _repeatDelay){
+  RugConf.repeatDelay = _repeatDelay;
+  return _repeatDelay;
+}
+
+VALUE RugConfSetInterval(VALUE self, VALUE _repeatInterval){
+  RugConf.repeatInterval = _repeatInterval;
+  return _repeatInterval;
+}
+
+VALUE RugConfSetFullscreen(VALUE self, VALUE _fullscreen){
+  RugConf.fullscreen = (TYPE(_fullscreen) == T_TRUE ? 1 : 0);
+  return _fullscreen;
+}
+
+VALUE RugConfSetFPS(VALUE self, VALUE _fps){
+  RugConf.frameGap = 1000 / _fps;
+  return _fps;
+}
+
+static VALUE RugConfFunc(int argc, VALUE * argv, VALUE class){
+  // we keep track of the RugConf block and instance_eval it within
+  // a RugConf object
+  if (rb_block_given_p()){
+    VALUE confFunc;
+    rb_scan_args(argc, argv, "0&", &confFunc);
+    VALUE confObj = rb_funcall(cRugConf, rb_intern("new"), 0);
+    rb_funcall(block_converter, rb_intern("call"), 3, confObj, rb_str_new2("instance_eval"), confFunc);
+  }
+  return Qnil;
+}
+
+// This function performs all configuration necessary and returns the screen object
+SDL_Surface * DoConf(){
+  int params = SDL_HWSURFACE;
+
+  if (RugConf.fullscreen){
+    params |= SDL_FULLSCREEN;
+  }
+
+  SDL_Surface * wnd = SDL_SetVideoMode(RugConf.width, RugConf.height, RugConf.bpp, params);
+  if (RugConf.title != Qnil){
+    SDL_WM_SetCaption(STR2CSTR(RugConf.title), NULL);
+  }
+
+  // enable key repeating
+  SDL_EnableKeyRepeat(RugConf.repeatDelay, RugConf.repeatInterval);
+
+  return wnd;
+}
+
+void LoadConf(VALUE mRug){
+  // Set some defaults
+  RugConf.title          = Qnil;
+  RugConf.width          = 800;
+  RugConf.height         = 600;
+  RugConf.bpp            = 32;
+  RugConf.frameGap       = 33;
+  RugConf.fullscreen     = 0;
+  RugConf.repeatDelay    = SDL_DEFAULT_REPEAT_DELAY;
+  RugConf.repeatInterval = SDL_DEFAULT_REPEAT_INTERVAL;
+
+  block_converter = rb_eval_string("proc { |recv, msg, block| recv.send(msg, &block) }");
+  // add to main module
+  rb_define_singleton_method(mRug, "conf", RugConfFunc, -1);
+  
+  // create conf class
+  cRugConf = rb_define_class_under(mRug, "Conf", rb_cObject);
+
+  rb_define_method(cRugConf, "width",               RugConfSetWidth, 1);
+  rb_define_method(cRugConf, "height",              RugConfSetHeight, 1);
+  rb_define_method(cRugConf, "bpp",                 RugConfSetBpp, 1);
+  rb_define_method(cRugConf, "title",               RugConfSetTitle, 1);
+  rb_define_method(cRugConf, "fps",                 RugConfSetFPS, 1);
+  rb_define_method(cRugConf, "fullscreen",          RugConfSetFullscreen, 1);
+  rb_define_method(cRugConf, "key_repeat_delay",    RugConfSetDelay, 1);
+  rb_define_method(cRugConf, "key_repeat_interval", RugConfSetInterval, 1);
+}

data/ext/rug_conf.h

@@ -0,0 +1,18 @@
+#ifndef RUG_CONF_H
+#define RUG_CONF_H
+
+#include "ruby.h"
+#include <SDL/SDL.h>
+
+typedef struct {
+  int width, height, bpp;
+  VALUE title;
+  int repeatDelay, repeatInterval;
+  int frameGap;
+  int fullscreen;
+} _RugConf;
+
+void LoadConf(VALUE);
+SDL_Surface * DoConf();
+
+#endif //RUG_CONF_H

data/ext/rug_events.c

@@ -0,0 +1,124 @@
+#include "rug_events.h"
+
+#include <SDL/SDL.h>
+
+struct {
+  VALUE KeyUp, KeyDown, MouseMove, MouseDown, MouseUp, MouseMoveOffset;
+} RugEvents;
+
+static VALUE SetKeyUp(int argc, VALUE * argv, VALUE self){
+  VALUE keyup;
+  rb_scan_args(argc, argv, "0&", &keyup);
+  RugEvents.KeyUp = keyup;
+  return Qnil;
+}
+static VALUE SetKeyDown(int argc, VALUE * argv, VALUE self){
+  VALUE keydown;
+  rb_scan_args(argc, argv, "0&", &keydown);
+  RugEvents.KeyDown = keydown;
+  return Qnil;
+}
+static VALUE SetMouseMove(int argc, VALUE * argv, VALUE self){
+  VALUE mousemove;
+  rb_scan_args(argc, argv, "0&", &mousemove);
+  RugEvents.MouseMove = mousemove;
+  return Qnil;
+}
+static VALUE SetMouseDown(int argc, VALUE * argv, VALUE self){
+  VALUE mousedown;
+  rb_scan_args(argc, argv, "0&", &mousedown);
+  RugEvents.MouseDown = mousedown;
+  return Qnil;
+}
+static VALUE SetMouseUp(int argc, VALUE * argv, VALUE self){
+  VALUE mouseup;
+  rb_scan_args(argc, argv, "0&", &mouseup);
+  RugEvents.MouseUp = mouseup;
+  return Qnil;
+}
+static VALUE SetMouseMoveOffset(int argc, VALUE * argv, VALUE self){
+  VALUE func;
+  rb_scan_args(argc, argv, "0&", &func);
+  RugEvents.MouseMoveOffset = func;
+  return Qnil;
+}
+
+void LoadEvents(VALUE mRug){
+  rb_define_singleton_method(mRug, "keyup",           SetKeyUp,           -1);
+  rb_define_singleton_method(mRug, "keydown",         SetKeyDown,         -1);
+  rb_define_singleton_method(mRug, "mousemove",       SetMouseMove,       -1);
+  rb_define_singleton_method(mRug, "mousemoveoffset", SetMouseMoveOffset, -1);
+  rb_define_singleton_method(mRug, "mousedown",       SetMouseDown,       -1);
+  rb_define_singleton_method(mRug, "mouseup",         SetMouseUp,         -1);
+
+  VALUE mKeyModule = rb_define_module_under(mRug, "Key");
+  VALUE mMouseModule = rb_define_module_under(mRug, "Mouse");
+
+  rb_define_const(mKeyModule, "Left",  INT2FIX(SDLK_LEFT));
+  rb_define_const(mKeyModule, "Right", INT2FIX(SDLK_RIGHT));
+  rb_define_const(mKeyModule, "Down",  INT2FIX(SDLK_DOWN));
+  rb_define_const(mKeyModule, "Up",    INT2FIX(SDLK_UP));
+  // TODO: all the other characters
+  
+  // load in letters and numbers
+  char buff[3];
+  buff[1] = '\0';
+  for (buff[0] = 'A'; buff[0] <= 'Z'; buff[0]++){
+    rb_define_const(mKeyModule, buff, INT2FIX(buff[0] | 0x20));
+  }
+  buff[0] = 'K';
+  buff[2] = '\0';
+  for (buff[1] = '0'; buff[1] <= '9'; buff[1]++){
+    rb_define_const(mKeyModule, buff, INT2FIX(buff[1]));
+  }
+
+  rb_define_const(mMouseModule, "Left",   INT2FIX(SDL_BUTTON_LEFT));
+  rb_define_const(mMouseModule, "Middle", INT2FIX(SDL_BUTTON_MIDDLE));
+  rb_define_const(mMouseModule, "Right",  INT2FIX(SDL_BUTTON_RIGHT));
+
+  RugEvents.KeyUp           = Qnil;
+  RugEvents.KeyDown         = Qnil;
+  RugEvents.MouseMove       = Qnil;
+  RugEvents.MouseDown       = Qnil;
+  RugEvents.MouseUp         = Qnil;
+  RugEvents.MouseMoveOffset = Qnil;
+}
+
+int HandleEvent(SDL_Event ev){
+  switch(ev.type){
+  case SDL_KEYUP:
+    if (RugEvents.KeyUp != Qnil){
+      rb_funcall(RugEvents.KeyUp, rb_intern("call"), 1, INT2FIX(ev.key.keysym.sym));
+    }
+    break;
+  case SDL_KEYDOWN:
+    if (RugEvents.KeyDown != Qnil){
+      rb_funcall(RugEvents.KeyDown, rb_intern("call"), 1, INT2FIX(ev.key.keysym.sym));
+    }
+    break;
+  case SDL_MOUSEMOTION:
+    if (RugEvents.MouseMove != Qnil){
+      rb_funcall(RugEvents.MouseMove, rb_intern("call"), 2, INT2FIX(ev.motion.x), INT2FIX(ev.motion.y));
+    }
+    if (RugEvents.MouseMoveOffset != Qnil){
+      rb_funcall(RugEvents.MouseMoveOffset, rb_intern("call"), 2, INT2FIX(ev.motion.xrel), INT2FIX(ev.motion.yrel));
+    }
+    break;
+  case SDL_MOUSEBUTTONDOWN:
+    if (RugEvents.MouseDown != Qnil){
+      rb_funcall(RugEvents.MouseDown, rb_intern("call"), 3, INT2FIX(ev.button.x), INT2FIX(ev.button.y), INT2FIX(ev.button.button));
+    }
+    break;
+  case SDL_MOUSEBUTTONUP:
+    if (RugEvents.MouseUp != Qnil){
+      rb_funcall(RugEvents.MouseUp, rb_intern("call"), 3, INT2FIX(ev.button.x), INT2FIX(ev.button.y), INT2FIX(ev.button.button));
+    }
+    break;
+  case SDL_QUIT:
+    return 0;
+  default:
+    break;
+  }
+
+  return 1;
+}

data/ext/rug_events.h

@@ -0,0 +1,10 @@
+#ifndef RUG_EVENTS_H
+#define RUG_EVENTS_H
+
+#include "ruby.h"
+
+void LoadEvents(VALUE);
+
+#endif //RUG_EVENTS_H
+
+

data/ext/rug_layer.c

@@ -0,0 +1,54 @@
+#include "rug_layer.h"
+
+VALUE cRugLayer;
+
+extern SDL_Surface * mainWnd;
+
+void ClearLayer(RugLayer * rLayer){
+  Uint32 clear = SDL_MapRGBA(rLayer->layer->format, 0, 0, 0, 0);
+  SDL_FillRect(rLayer->layer, NULL, clear);
+}
+
+static void unload_layer(void * vp){
+  RugLayer * rLayer = (RugLayer *)vp;
+  SDL_FreeSurface(rLayer->layer);
+  rLayer->layer = NULL;
+}
+
+static VALUE RugInit(VALUE class){
+  if (mainWnd == NULL){
+    return Qnil;
+  }
+
+  RugLayer * rLayer = ALLOC(RugLayer);
+
+  rLayer->layer = SDL_CreateRGBSurface(SDL_HWSURFACE, mainWnd->w, mainWnd->h, mainWnd->format->BitsPerPixel, 0, 0, 0, 0);
+
+  // make the surface transparent
+  ClearLayer(rLayer);
+
+  return Data_Wrap_Struct(cRugLayer, NULL, unload_layer, rLayer);
+}
+
+static VALUE RugDrawLayer(VALUE self){
+  RugLayer * rLayer;
+  Data_Get_Struct(self, RugLayer, rLayer);
+  SDL_BlitSurface(rLayer->layer, NULL, mainWnd, NULL);
+  return Qnil;
+}
+
+static VALUE RugClearLayer(VALUE self){
+  RugLayer * rLayer;
+  Data_Get_Struct(self, RugLayer, rLayer);
+  ClearLayer(rLayer);
+  return Qnil;
+}
+
+void LoadLayer(VALUE mRug){
+  // create conf class
+  cRugLayer = rb_define_class_under(mRug, "Layer", rb_cObject);
+
+  rb_define_singleton_method(cRugLayer, "new", RugInit, 0);
+  rb_define_method(cRugLayer, "draw",  RugDrawLayer,  0);
+  rb_define_method(cRugLayer, "clear", RugClearLayer, 0);
+}

data/ext/rug_layer.h

@@ -0,0 +1,15 @@
+#ifndef RUG_LAYER_H
+#define RUG_LAYER_H
+
+#include "ruby.h"
+
+#include <SDL/SDL.h>
+
+void LoadLayer(VALUE);
+
+typedef struct {
+  SDL_Surface * layer;
+} RugLayer;
+
+#endif //RUG_LAYER_H
+

data/ext/rug_resources.c

@@ -0,0 +1,104 @@
+#include "rug_resources.h"
+#include "rug_layer.h"
+
+#include <SDL/SDL_image.h>
+#include <stdlib.h>
+#include <string.h>
+
+VALUE cRugImage;
+
+extern SDL_Surface * mainWnd;
+
+typedef struct {
+  SDL_Surface * image;
+} RugImage;
+
+static void unload_image(void * vp){
+  RugImage * rImage = (RugImage *)vp;
+  SDL_FreeSurface(rImage->image);
+  rImage->image = NULL;
+}
+
+static VALUE new_image(VALUE class, VALUE filename){
+  SDL_Surface * image = IMG_Load(STR2CSTR(filename));
+
+  if (!image){
+    // throw exception
+    rb_raise(rb_eIOError, "Unable to load image!");
+  }else{
+    RugImage * rImage = ALLOC(RugImage);
+
+    rImage->image = image;
+
+    return Data_Wrap_Struct(cRugImage, NULL, unload_image, rImage);
+  }
+
+  return Qnil;
+}
+
+static VALUE blit_image(int argc, VALUE * argv, VALUE self){
+  if (mainWnd != NULL){
+    VALUE sx, sy, x, y, width, height, targetLayer;
+
+    rb_scan_args(argc, argv, "25", &x, &y, &width, &height, &sx, &sy, &targetLayer);
+    
+    RugImage * image;
+    Data_Get_Struct(self, RugImage, image);
+
+    SDL_Rect src, dst;
+
+    SDL_Surface * target;
+
+    if (targetLayer == Qnil){
+      target = mainWnd;
+    }else{
+      RugLayer * layer;
+      Data_Get_Struct(targetLayer, RugLayer, layer);
+      target = layer->layer;
+    }
+
+    dst.x = FIX2INT(x);
+    dst.y = FIX2INT(y);
+    dst.w = dst.h = 0;
+
+    if (width != Qnil){
+      src.w = FIX2INT(width);
+
+      if (height != Qnil){
+        src.h = FIX2INT(height);
+      }else{
+        src.h = src.w;
+      }
+
+      if (x != Qnil){
+        src.x = FIX2INT(sx);
+      }else{
+        src.x = 0;
+      }
+
+      if (y != Qnil){
+        src.y = FIX2INT(sy);
+      }else{
+        src.y = 0;
+      }
+
+      SDL_BlitSurface(image->image, &src, target, &dst);
+    }else{
+      SDL_BlitSurface(image->image, NULL, target, &dst);
+    }
+  }
+
+  return self;
+}
+
+void LoadResourcesModule(VALUE rugModule){
+  IMG_Init(IMG_INIT_JPG | IMG_INIT_PNG | IMG_INIT_TIF);
+  atexit(IMG_Quit);
+
+  // define Image class
+  cRugImage = rb_define_class_under(rugModule, "Image", rb_cObject);
+
+  rb_define_singleton_method(cRugImage, "new", new_image, 1);
+  rb_define_method(cRugImage, "draw", blit_image, -1);
+}
+

data/ext/rug_resources.h

@@ -0,0 +1,9 @@
+#ifndef RUG_RESOURCES_H
+#define RUG_RESOURCES_H
+
+#include "ruby.h"
+
+void LoadResourcesModule(VALUE);
+
+#endif //RUG_RESOURCES_H
+

data/lib/Rug.rb

@@ -0,0 +1 @@
+require 'Rug.so'

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: Rug
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Rob Britton
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-21 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: rob.s.brit@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- lib/Rug.rb
+- ext/rug_resources.c
+- ext/rug_events.c
+- ext/rug_layer.c
+- ext/rug_conf.c
+- ext/rug.c
+- ext/rug_conf.h
+- ext/rug_resources.h
+- ext/rug_events.h
+- ext/rug_layer.h
+- README
+- ext/extconf.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A simple game framework.
+test_files: []
+