rubygame 2.2.0 → 2.3.0

data/NEWS

@@ -1,4 +1,55 @@
-== Changes from 2.1.0 to 2.2.0
+= NEWS
+
+== Rubygame 2.3.0
+
+Release focus: Media resources.
+
+=== Features
+
+- Add: Rubygame::NamedResource mixin module
+  - Provides per-class resource repository and on-demand auto-loading
+    behavior.
+
+- Add: Rubygame::Music class.
+  - Intended as a full replacement for Rubygame::Mixer::Music.
+  - Includes NamedResources mixin.
+  - NOTE: Requires SDL_mixer support.
+
+- Add: Rubygame::Sound class.
+  - Intended as a full replacement for Rubygame::Mixer::Sample.
+  - Includes NamedResources mixin.
+  - NOTE: Requires SDL_mixer support.
+
+- Update: Rubygame::Surface class.
+  - Includes NamedResources mixin.
+  - Add: Surface.load_from_string (NOTE: Requires SDL_image support.)
+
+=== Fixes
+
+- ColorBase had been accidently placed in the top level namespace in
+  Rubygame 2.2.0. It is now correctly placed in the Rubygame::Color
+  module.
+
+=== Other Stuff
+
+- Deprecation (will be removed in Rubygame 3.0):
+  - Rubygame::Mixer module and methods are deprecated.
+  - Rubygame::Mixer::Music class is deprecated.
+    Use Rubygame::Music class instead.
+  - Rubygame::Mixer::Sample class is deprecated.
+    Use Rubygame::Sound class instead.
+  - Rubygame::Surface.load_image is deprecated.
+    Use Rubygame::Surface.load instead.
+
+- NOTE: Run ruby with -w flag or set $_v = true to enable run-time
+  deprecation warnings.
+
+
+
+
+== Rubygame 2.2.0
+
+Release focus: Colors.
 
 === Features
 
@@ -36,7 +87,7 @@
 
 
 
-== Changes from 2.0.1 to 2.1.0
+== Rubygame 2.1.0
 
 === Features
 
@@ -82,7 +133,7 @@
 
  
 
-== Changes from 2.0.0 to 2.0.1
+== Rubygame 2.0.1
 
 === Bug Fixes
 
@@ -103,7 +154,7 @@
 
 
 
-== Changes from 1.1.0 to 2.0.0:
+== Rubygame 2.0.0:
 
 *NOTICE*: version 2.0.0 is not totally backward-compatible with 1.1.0.
 You may have to update existing applications to the new syntax.

data/README

@@ -8,24 +8,15 @@
  worrying about low-level technical details, you can focus your energy on
  more interesting things (like making a fun game).
 
- Rubygame's core is written in C to bind low-level SDL functions in ruby.
- On top of that is a pure ruby library for higher-level behavior like
+ Rubygame's core is written in C to bind low-level SDL functions into Ruby.
+ On top of that is a pure Ruby library for higher-level behavior like
  event and game object management.
 
- There are two other Ruby-SDL bindings which are worth mentioning: Ruby/SDL
- and RUDL. Ruby/SDL is a simple wrapper which closely mirrors SDL's C API,
- while RUDL tries to provide some high-level concepts. 
- The main differences with Rubygame come down to a matter of priorities:
- a great deal of care and effort goes into making Rubygame especially clean,
- well-documented, powerful, and easy to use.
-
  === Relevant Links
  1. Rubygame: http://rubygame.sourceforge.net
  2. Ruby: http://www.ruby-lang.org
  3. Pygame: http://www.pygame.org
  4. SDL: http://www.libsdl.org
- 5. Ruby/SDL: http://www.kmc.gr.jp/~ohai/rubysdl.en.html
- 6. RUDL: http://rudl.sourceforge.net
 
  == Requirements
 
@@ -72,32 +63,33 @@
  The build and install tasks can be configured by providing certain commands
  to rake:
 
-  * no-sdl-gfx::    do not build modules which depend on SDL_gfx
-  * no-sdl-image::  do not build modules which depend on SDL_image
-  * no-sdl-mixer::  do not build modules which depend on SDL_mixer
-  * no-sdl-ttf::    do not build modules which depend on SDL_ttf
-  * no-opengl::     do not build modules which depend on OpenGL
+ no-sdl-gfx::    do not build modules which depend on SDL_gfx
+ no-sdl-image::  do not build modules which depend on SDL_image
+ no-sdl-mixer::  do not build modules which depend on SDL_mixer
+ no-sdl-ttf::    do not build modules which depend on SDL_ttf
+ no-opengl::     do not build modules which depend on OpenGL
 
-  * no-sdl-config:: do not guess compiler/linker flags using `sdl-config'
+ no-sdl-config:: do not guess compiler/linker flags using `sdl-config'
 
-  * debug::         build modules with debbugging flags enabled
-  * verbose::       display the build commands as they are run
+ debug::         build modules with debbugging flags enabled
+ universal::     on MacOS X, try to compile for both PPC and Intel
+ verbose::       display the build commands as they are run
 
  Additionally, the build process respects certain environmental variables.
  In particular, CFLAGS and LDFLAGS are important for users compiling with
  the no-sdl-config command.
 
-  * CC::            C compiler command
-  * CFLAGS::        flags passed to the C compiler
-  * LDSHARED::      linker command
-  * LDFLAGS::       flags passed to the linker
-  * RUBYARCHDIR::   where to install platform-specific compiled extensions
-  * RUBYLIBDIR::    where to install platform-independent interpreted libs
+ CC::            C compiler command
+ CFLAGS::        flags passed to the C compiler
+ LDSHARED::      linker command
+ LDFLAGS::       flags passed to the linker
+ RUBYARCHDIR::   where to install platform-specific compiled extensions
+ RUBYLIBDIR::    where to install platform-independent interpreted libs
 
  IMPORTANT: if you are missing any optional SDL_* libraries, you must specify
  "no-*" flags for those libraries. For example, if you don't have SDL_gfx:
 
-  $ rake no-gfx build
+  $ rake no-sdl-gfx build
 
  If you don't disable the features, the compile will probably fail when it
  looks for the headers and libraries. (The build system is not smart enough to
@@ -114,26 +106,18 @@
 
  == Usage
  
- To use Rubygame in an application, do:
-
-   require 'rubygame'
-
- You will probably also want a display window and event queue:
-
-   screen = Rubygame::Screen.new( [640,480] )
-   queue = Rubygame::EventQueue.new()
+ See the documentation (online at http://rubygame.sourceforge.net, or
+ generated locally with the 'rake rdoc' command). 
 
- For more information, see the documentation (online at 
- http://rubygame.sourceforge.net, or generated locally with the 
- 'rake rdoc' command). You should also take a peek at the demo applications
- in the 'samples' directory.
+ We also recommend that you take a peek at the demo applications in
+ the 'samples' directory, especially chimp.rb.
 
  == License
 
  Rubygame is distributed under the terms of the GNU Lesser GPL.
  See LICENSE for more details.
 
- Some of the sample files are distributed under other licenses than the
+ Some of the sample files are distributed under licenses other than the
  GNU Lesser GPL. See 'samples/README' and 'samples/GPL' for more details.
 
  John Croisant (jacius at users.sourceforge.net)

data/ROADMAP

@@ -1,24 +1,92 @@
 = ROADMAP
 
-=== 3.0.0 (next major release)
+This represents the direction Rubygame will be going in, but
+keep in mind that specific details may change over time.
 
-- Backwards compatibility will be broken:
-  - Surface#get_at
-  - Sprites::Group#collide_group
 
-- New scene/camera/sprite sytem.
-- New geometric primitives classes (for collision detection, drawing).
-- New hook-based event handler system.
+== 2.4.0 (next minor release)
+
+Release focus: Events.
+
+- New EventHook class, has 3 parts: owner, trigger, and action.
+  - New trigger classes, e.g. KeyPressedTrigger (matches key presses)
+  - New action classes, e.g. MethodAction (calls a method on owner)
+
+- New EventHandler class
+  - Holds many EventHook instances, feeds the event to each
+    matching hook.
+
+- New HasEventHandler mixin, can embed in sprite, etc. classes
+  for easy event handling and hook creation.
+
+- New Events module, with a suite of new and revised event classes.
+
+  - Eliminate integer constants in favor of symbols
+    - Keyboard keys are symbols (e.g. :up, :a, :space)
+    - Mouse buttons are symbols (e.g. :mouse_left, :mouse_wheel_up)
+
+  - Nicer, more natural naming scheme
+    - Drop the word "Event" from the class names.
+    - "Down" and "Up" (e.g. in KeyDownEvent) become "Pressed"
+      and "Released" (e.g. KeyPressed).
+    - MouseMotionEvent becomes MouseMoved.
+    - Other miscellaneous changes.
+
+  - Better unicode / international keyboard support
+    - KeyPress#string gives a UTF8 bytestring with the glyph that was
+      generated by the keypress (useful for text input in GUIs).
+
+- Old versions of the event classes stay the same, but are deprecated.
+
+
+
+== 2.X.0 (_possible_ minor releases before 3.0.0)
+
+=== Focus: Time
 
-- Keyboard events to be :symbols (e.g. :uparrow, :a, :spacebar)
+- New Events::Tick class with lots of information
+  - Time since last frame, in both seconds and milliseconds.
+  - Current time
+  - Current framerate
 
-- Clock class to be based on Ruby's timer (allows multi-threading). 
-- New TickEvent returned from Clock#tick.
+- New clock class
+  - Based on Ruby's timer (allows multi-threading).
+  - Better framerate calculation algorithm
+  - #tick returns an instance of Events::Tick.
+
+=== Focus: Sprites
+
+- New sprite system
+  - New Sprite, Scene, and Camera classes.
+  - More powerful and simpler to use.
+  - Integration with the Chipmunk physics library.
+
+
+
+== 3.0.0 (next major release)
+
+- Backwards compatibility is broken:
+  - Deprecated classes / methods retired:
+    - Rubygame::Mixer module.
+    - Rubygame::Mixer::Sample class. Use Rubygame::Sound.
+    - Rubygame::Mixer::Music class. Use Rubygame::Music.
+    - Rubygame::Surface.load_image method. User Rubygame::Surface.load.
+  - Surface#get_at
+  - Sprites::Group#collide_group
 
 - Change Sprites::Group#collide_group to scrap the 'killa/killb' stuff,
   take a block instead.
 
-=== On the horizon...
+
+
+== On the horizon...
+
+- Polygon, circle, and other geometric primitives
+  - Drawing, with styles?
+  - OpenGL drawing?
+  - Collision detection?
+  - Physical shapes w/ Chipmunk?
+  - Generate bounding Polygon from an image automatically?
 
 - Path (Curve?) (graphs/plots for tracing position and other uses)
   - Can find the position N units along the path.
@@ -27,17 +95,15 @@
   - BezierPath (chain of continuous cubic Bézier curves)
   - CodePath (calculated from a code block)
 
-- Better support for non-US keyboards, particularly generating strings for
-  keypresses: (EURO, WORLD*). Will need someone with a non-US keyboard to
-  test this.
-
-- Flesh out Mixer API.
-
-- Flesh out Rect unit tests.
+- Effect (Action?)
+  - "Attach" to an instance, does something over time.
+  - E.g. moves a sprite from point A to point B over N seconds.
+  - Many types of effects, easy to define custom ones.
+  - Takes parameters: start/end time, others depending on effect.
 
 - C equivalent of Rect.new_from_object (see rect.rb)
   - Screen#update (cannot pass object with rect attribute)
   - Screen#update_rects (same as above)
   - Why not just call the ruby function from within C?
 
-- Generate bounding Polygon from an image automatically.
+

data/Rakefile

@@ -48,11 +48,11 @@ end
 OBJEXT = from_env_or_config("OBJEXT")
 DLEXT = from_env_or_config("DLEXT")
 
-RUBYGAME_VERSION = "2.2.0"
+RUBYGAME_VERSION = [2,3,0]
 
-spec = Gem::Specification.new do |s|
+gem_spec = Gem::Specification.new do |s|
   s.name     = "rubygame"
-  s.version  = RUBYGAME_VERSION
+  s.version  = RUBYGAME_VERSION.join(".")
   s.author   = "John Croisant"
   s.email    = "jacius@users.sourceforge.net"
   s.homepage = "http://rubygame.sourceforge.net/"
@@ -66,7 +66,6 @@ spec = Gem::Specification.new do |s|
   end
 
   s.require_paths = ["lib", "lib/rubygame/", "ext/rubygame/"]
-  s.autorequire = "rubygame.rb"
   s.extensions = ["Rakefile"]
 
   s.extra_rdoc_files = FileList.new do |fl|
@@ -75,25 +74,17 @@ spec = Gem::Specification.new do |s|
   end
 end
 
-task :linux do
-	spec.platform = Gem::Platform::LINUX_586
+task :binary do
+	gem_spec.platform = Gem::Platform::CURRENT
 end
 
-task :macosx do
-	spec.platform = Gem::Platform::DARWIN
-end
-
-task :win32 do
-	spec.platform = Gem::Platform::WIN32
-end
-
-Rake::GemPackageTask.new(spec) do |pkg| 
+Rake::GemPackageTask.new(gem_spec) do |pkg| 
   pkg.need_tar_bz2 = true
 end
 
 Rake::RDocTask.new do |rd|
   rd.main = "README"
-  rd.title = "Rubygame #{RUBYGAME_VERSION} Docs"
+  rd.title = "Rubygame #{RUBYGAME_VERSION.join(".")} Docs"
   rd.rdoc_files.include("ext/rubygame/*.c",
                         "lib/rubygame/**/*.rb",
                         "doc/*.rdoc",
@@ -123,6 +114,7 @@ $options = {
 	:"sdl-mixer"  => true,
 	:opengl       => true,
 	:"sdl-config" => true,
+	:universal    => false,
 	:debug        => false,
 	:verbose      => false,
 	:sitearchdir  => CONFIG["sitearchdir"],
@@ -186,8 +178,9 @@ bool_option :"sdl-mixer",  nil,  "SDL_mixer support"
 bool_option :"sdl-ttf",    nil,  "SDL_ttf support"
 bool_option :"sdl-config", nil,  "guess compiler flags for SDL"
 bool_option :opengl,       nil,  "OpenGL support"
-bool_option :debug,        nil,  "compil with debug symbols"
+bool_option :debug,        nil,  "compile with debug symbols"
 bool_option :verbose,      nil,  "show compiler commands"
+bool_option :universal,    nil,  "universal binary (MacOS X Intel)"
 
 string_option "RUBYARCHDIR", :sitearchdir
 string_option :sitearchdir
@@ -199,7 +192,11 @@ string_option :sitelibdir
 CFLAGS = [from_env_or_config("CFLAGS"),
           try_sdl_config("--cflags"),
           "-I. -I#{CONFIG['topdir']}",
-          ("-g" if $options[:debug]) ].join(" ")
+          ("-g" if $options[:debug]),
+          "-DRUBYGAME_MAJOR_VERSION=#{RUBYGAME_VERSION[0]}",
+          "-DRUBYGAME_MINOR_VERSION=#{RUBYGAME_VERSION[1]}",
+          "-DRUBYGAME_PATCHLEVEL=#{RUBYGAME_VERSION[2]}"
+         ].join(" ")
 
 LINK_FLAGS = [from_env_or_config("LIBRUBYARG_SHARED"),
               from_env_or_config("LDFLAGS"),
@@ -241,7 +238,7 @@ class ExtensionModule
   # 
   # This is done so that the prerequisites don't have to be compiled when 
   # the final product already exists (such as in the precompiled win32 gem).
-	# 
+  # 
   def create_dl_task
     dynlib_full  = File.join( @directory, "#{dynlib}.#{DLEXT}" )
     objs_full = @objs.collect { |obj|
@@ -250,7 +247,16 @@ class ExtensionModule
 
     desc "Compile the #{@dynlib} extension"
     file dynlib_full => objs_full do |task|
+
       link_command = "#{from_env_or_config('LDSHARED')} #{LINK_FLAGS} #{@lflags} -o #{dynlib_full} #{task.prerequisites.join(' ')}"
+
+
+      # If link command includes i386 arch, and we're not allowing universal
+      if( /-arch i386/ === link_command and not $options[:universal] )
+        # Strip "-arch ppc" to prevent building a universal binary.
+        link_command.gsub!("-arch ppc","")
+      end
+
       if( $options[:verbose] )
         try_shell { sh link_command }
       else
@@ -276,7 +282,15 @@ class ExtensionModule
           end
          ])\
     do |t|
+
       compile_command = "#{from_env_or_config('CC')} -c #{CFLAGS} #{t.source} -o #{t.name}"
+
+      # If compile command includes i386 arch, and we're not allowing universal
+      if( /-arch i386/ === compile_command and not $options[:universal] )
+        # Strip "-arch ppc" to prevent building a universal binary.
+        compile_command.gsub!("-arch ppc","")
+      end
+
       if( $options[:verbose] )
         try_shell { sh compile_command }
       else
@@ -350,7 +364,7 @@ end
 
 rubygame_mixer = ExtensionModule.new do |mixer|
   mixer.dynlib = 'rubygame_mixer'
-  mixer.objs = ['rubygame_shared', 'rubygame_mixer']
+  mixer.objs = ['rubygame_shared', 'rubygame_mixer', 'rubygame_sound', 'rubygame_music']
   mixer.add_lib('SDL_mixer')
   mixer.add_header('SDL_mixer.h')
   mixer.create_all_tasks() if $options[:"sdl-mixer"]
@@ -407,3 +421,18 @@ end
 
 desc "Install both the extensions and the library"
 task :install => [:install_ext, :install_lib]
+
+
+
+begin
+  require 'spec/rake/spectask'
+
+  desc "Run all specs (tests)"
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_files = FileList['test/*_spec.rb']
+  end
+rescue LoadError
+  task :spec do 
+    puts "ERROR: RSpec is not installed?"
+  end
+end

data/doc/windows_install.rdoc

@@ -113,7 +113,7 @@ disable optional features by passing a "no-???" command to rake before the word
 type this instead of the above:
 
  envsetup.bat
- rake no-gfx install
+ rake no-sdl-gfx install
 
 If all goes well, you have built and installed Rubygame.
 Try to execute <code>require 'rubygame'</code> in an irb session and run

data/ext/rubygame/rubygame_image.c

@@ -26,11 +26,64 @@
 
 void Rubygame_Init_Image();
 VALUE rbgm_image_load(VALUE, VALUE);
+VALUE rbgm_from_string(int, VALUE*, VALUE);
 
 /*
  *  call-seq:
  *    Surface.load_image( filename )  ->  Surface
  *
+ *  **NOTE:** This method name is DEPRECATED and will be removed in
+ *  Rubygame 3.0. Please use the Surface.load instead.
+ *
+ *  Load an image file from the disk to a Surface. If the image has an alpha
+ *  channel (e.g. PNG with transparency), the Surface will as well. If the
+ *  image cannot be loaded (for example if the image format is unsupported),
+ *  will raise SDLError.
+ *
+ *  This method is only usable if Rubygame was compiled with the SDL_image
+ *  library; you can check Rubygame::VERSIONS[:sdl_image] to see if it was.
+ *
+ *  This method takes this argument:
+ *  filename:: a string containing the relative or absolute path to the
+ *             image file. The file must have the proper file extension,
+ *             as it is used to determine image format.
+ *
+ *  These formats may be supported, but some may not be available on a
+ *  particular system.
+ *  BMP:: "Windows Bitmap" format.
+ *  GIF:: "Graphics Interchange Format."
+ *  JPG:: "Independent JPEG Group" format.
+ *  LBM:: "Linear Bitmap" format (?)
+ *  PCX:: "PC Paintbrush" format
+ *  PNG:: "Portable Network Graphics" format.
+ *  PNM:: "Portable Any Map" format. (i.e., PPM, PGM, or PBM)
+ *  TGA:: "Truevision TARGA" format.
+ *  TIF:: "Tagged Image File Format"
+ *  XCF:: "eXperimental Computing Facility" (GIMP native format).
+ *  XPM:: "XPixMap" format.
+ */
+VALUE rbgm_image_load_image( VALUE class, VALUE filename )
+{
+
+  /* This feature will be removed in Rubygame 3.0. */
+  rg_deprecated("Rubygame::Surface.load_image", "3.0");
+
+	char *name;
+	SDL_Surface *surf;
+
+	name = StringValuePtr(filename);
+	surf = IMG_Load( name );
+	if(surf == NULL)
+	{
+		rb_raise(eSDLError,"Couldn't load image `%s': %s", name, IMG_GetError());
+	}
+	return Data_Wrap_Struct( cSurface,0,SDL_FreeSurface,surf );
+}
+
+/*
+ *  call-seq:
+ *    Surface.load( filename )  ->  Surface
+ *
  *  Load an image file from the disk to a Surface. If the image has an alpha
  *  channel (e.g. PNG with transparency), the Surface will as well. If the
  *  image cannot be loaded (for example if the image format is unsupported),
@@ -72,6 +125,91 @@ VALUE rbgm_image_load( VALUE class, VALUE filename )
 	return Data_Wrap_Struct( cSurface,0,SDL_FreeSurface,surf );
 }
 
+
+/*
+ *  call-seq:
+ *    Surface.autoload( filename )  ->  Surface or nil
+ *
+ *  Searches each directory in Surface.autoload_dirs for a file with
+ *  the given filename. If it finds that file, loads it and returns
+ *  a Surface instance. If it doesn't find the file, returns nil.
+ *
+ *  See Rubygame::NamedResource for more information about this
+ *  functionality.
+ *
+ */
+VALUE rbgm_image_autoload( VALUE class, VALUE namev )
+{
+  VALUE pathv = rb_funcall( class, rb_intern("find_file"), 1, namev );
+
+  if( RTEST(pathv) )
+  {
+    return rbgm_image_load( class, pathv );
+  }
+  else
+  {
+    return Qnil;
+  }
+}
+
+/*
+ *  call-seq:
+ *    Surface.load_from_string( data [,type] )  ->  Surface
+ *
+ *  Load an image file from memory (in the form of the given data) to a Surface.
+ *  If the image has an alpha channel (e.g. PNG with transparency), the Surface
+ *  will as well. If the image cannot be loaded (for example if the image
+ *  format is unsupported), will raise SDLError.
+ *
+ *  This method is only usable if Rubygame was compiled with the SDL_image
+ *  library; you can check Rubygame::VERSIONS[:sdl_image] to see if it was.
+ *
+ *  This method takes these arguments:
+ *  data:: a string containing the data for the image, such as IO::read would
+ *         return.
+ *  type:: The type of file that the image is (i.e. 'TGA').  Case is not 
+ *         important.  If absent, the library will try to automatically
+ *         detect the type.
+ *
+ *  These formats may be supported, but some may not be available on a
+ *  particular system.
+ *  BMP:: "Windows Bitmap" format.
+ *  GIF:: "Graphics Interchange Format."
+ *  JPG:: "Independent JPEG Group" format.
+ *  LBM:: "Linear Bitmap" format (?)
+ *  PCX:: "PC Paintbrush" format
+ *  PNG:: "Portable Network Graphics" format.
+ *  PNM:: "Portable Any Map" format. (i.e., PPM, PGM, or PBM)
+ *  TGA:: "Truevision TARGA" format.
+ *  TIF:: "Tagged Image File Format"
+ *  XCF:: "eXperimental Computing Facility" (GIMP native format).
+ *  XPM:: "XPixMap" format.
+ */
+VALUE rbgm_image_load_from_string( int argc, VALUE *argv, VALUE obj)
+{
+	Check_Type(argv[0], T_STRING);
+	/* There's probably a better way of using a string as raw data than this,
+	 * but I don't know it. */
+	void *raw = (void *)RSTRING_PTR(argv[0]);
+	int len = RSTRING_LEN(argv[0]);
+	
+	SDL_RWops *rw = SDL_RWFromMem(raw,len);
+	
+	SDL_Surface *surf;
+	if(argc > 1) {
+		Check_Type(argv[1], T_STRING);
+		surf = IMG_LoadTyped_RW(rw, 1,StringValuePtr(argv[1]));
+	} else {
+		surf = IMG_Load_RW(rw,1);
+	}
+	
+	if(surf == NULL)
+	{
+		rb_raise(eSDLError,"Couldn't load image from string: %s", IMG_GetError());
+	}
+	return Data_Wrap_Struct( cSurface, 0, SDL_FreeSurface, surf);	
+}
+
 /* 
  *  Document-class: Rubygame::Surface
  *
@@ -85,6 +223,9 @@ VALUE rbgm_image_load( VALUE class, VALUE filename )
  *  Screen (which is a special type of Surface) and then using Screen#update,
  *  you can make images appear for the player to see.
  *
+ *  As of Rubygame 2.3.0, Surface includes the Rubygame::NamedResource mixin
+ *  module, which can perform autoloading of images on demand, among other
+ *  things.
  */
 void Init_rubygame_image()
 {
@@ -104,5 +245,8 @@ void Init_rubygame_image()
                            INT2NUM(SDL_IMAGE_PATCHLEVEL)));
 
 	/* Image methods */
-	rb_define_singleton_method(cSurface,"load_image",rbgm_image_load,1);
+	rb_define_singleton_method(cSurface, "load_image",       rbgm_image_load_image,        1);
+	rb_define_singleton_method(cSurface, "load",             rbgm_image_load,              1);
+	rb_define_singleton_method(cSurface, "autoload",         rbgm_image_autoload,          1);
+	rb_define_singleton_method(cSurface, "load_from_string", rbgm_image_load_from_string, -1);
 }

data/ext/rubygame/rubygame_main.h

@@ -21,13 +21,16 @@
 #ifndef _RUBYGAME_H
 #define _RUBYGAME_H
 
-#define RUBYGAME_MAJOR_VERSION 2
+#ifndef RUBYGAME_MAJOR_VERSION
+
+#define RUBYGAME_MAJOR_VERSION 0
 #define RUBYGAME_MINOR_VERSION 0
-#define RUBYGAME_PATCHLEVEL 1
+#define RUBYGAME_PATCHLEVEL 0
+
+#endif
 
 extern VALUE rbgm_keyname(VALUE, VALUE);
 extern VALUE rbgm_init(VALUE);
 extern VALUE rbgm_quit(VALUE);
-extern void Define_Rubygame_Constants();
 
 #endif