rubygame 2.2.0 → 2.3.0

data/ext/rubygame/rubygame_sound.h

@@ -0,0 +1,29 @@
+/*
+ *  Interface to SDL_mixer sound playback and mixing.
+ *--
+ *  Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+ *  Copyright (C) 2004-2008  John Croisant
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *++
+ */
+
+
+#ifndef _RUBYGAME_SOUND_H
+#define _RUBYGAME_SOUND_H
+
+extern void Rubygame_Init_Sound();
+
+#endif

data/ext/rubygame/rubygame_surface.c

@@ -1130,6 +1130,10 @@ void Rubygame_Init_Surface()
 	rb_define_method(cSurface,"savebmp",rbgm_image_savebmp,1);
 	rb_define_method(cSurface,"flip",rbgm_transform_flip,2);
 
+
+	/* Include the Rubygame::NamedResource mixin module. */
+	rg_include_named_resource(cSurface);
+
 	
 	/* Surface initialization flags */
 	rb_define_const(mRubygame,"SWSURFACE",UINT2NUM(SDL_SWSURFACE));

data/lib/rubygame/color/models/base.rb

@@ -17,6 +17,8 @@
 #	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #++
 
+module Rubygame
+module Color
 
 # A mix-in module defining color arithmetic operations.
 module ColorBase
@@ -104,3 +106,6 @@ module ColorBase
 		return v		
 	end
 end
+
+end
+end

data/lib/rubygame/named_resource.rb

@@ -0,0 +1,254 @@
+#--
+#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+#	Copyright (C) 2004-2008  John Croisant
+#
+#	This library is free software; you can redistribute it and/or
+#	modify it under the terms of the GNU Lesser General Public
+#	License as published by the Free Software Foundation; either
+#	version 2.1 of the License, or (at your option) any later version.
+#
+#	This library is distributed in the hope that it will be useful,
+#	but WITHOUT ANY WARRANTY; without even the implied warranty of
+#	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#	Lesser General Public License for more details.
+#
+#	You should have received a copy of the GNU Lesser General Public
+#	License along with this library; if not, write to the Free Software
+#	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#++
+
+
+module Rubygame
+
+  #  NamedResource is a mix-in module to implement a globally-available
+  #  resource table, a @name variable and accessors, and a system for
+  #  automatically loading resources when they are first needed.
+  #
+  #  This module is used for Rubygame::Music, Rubygame::Sound, and
+  #  Rubygame::Surface. You can use it in your own classes this way:
+  #
+  #  1. Do 'include Rubygame::NamedResource' in your class definition.
+  #
+  #  2. Set MyClass.autoload_dirs to an Array of directories to look
+  #     for files when autoloading. Tip: use File.join to create
+  #     paths that work on any operating system.
+  #
+  #  3. Define #autoload to implement the behavior for your class,
+  #     or leave it as the default if you don't need autoloading.
+  #     See the docs for #autoload for more information.
+  #
+  #  Here's an example of how you could use this for a class which
+  #  loads maps from a file:
+  #
+  #      class Map
+  #        include Rubygame::NamedResource
+  #
+  #        Map.autoload_dirs = [ File.join("maps","world_1"),
+  #                              File.join("maps","custom") ]
+  #
+  #        def autoload( name )
+  #          # Searches autoload_dirs for the file
+  #          path = find_file( name )
+  #
+  #          if( path )
+  #            return load_map( path )
+  #          else
+  #            return nil
+  #          end
+  #        end
+  #
+  #        def load_map( path )
+  #          # Your code to do the real loading, then return
+  #          # the created instance of Map class.
+  #          # ...
+  #          return map_instance
+  #        end
+  #      end
+  #
+  #  Here's an example of how you could then use the Map class:
+  #
+  #      map = Map["level_1.map"]
+  #
+  #      if( map )
+  #        start_playing( map )
+  #      else
+  #        raise "Oops! The map file for Level 1 doesn't exist!"
+  #      end
+  #
+  module NamedResource
+
+
+    #  Adds class methods when the NamedResource module is included
+    #  in a class. (Here, we are assuming that the NamedResource
+    #  module was included in a class called MyClass.)
+    module NamedResourceClassMethods
+
+      #  An Array of paths to check for files. See #find_file.
+      attr_accessor :autoload_dirs
+
+
+      #  call-seq:
+      #    MyClass[ name ]  ->  instance or nil
+      #
+      #  Retrieves an instance of the class from a per-class resource
+      #  table (Hash).
+      #
+      #  If no object has been saved under the given name, invoke
+      #  #autoload to try to load a new instance, store it in the
+      #  Hash table under this name, and sets the instance's @name
+      #  to this name.
+      #
+      def []( name )
+        result = @resources[name]
+
+        if result.nil?
+          result = autoload(name)
+          if result
+            self[name] = result
+            result.name = name
+          end
+        end
+
+        return result
+      end
+
+
+      #  call-seq:
+      #    MyClass[ name ] = instance
+      #
+      #  Stores an instance of the class in a per-class resource table
+      #  (Hash) for future access. If another object is already stored
+      #  with this name, the old record is lost.
+      #
+      #  May raise:  TypeError, if you try to store anything
+      #             that is not kind of this class.
+      #
+      def []=( name, value )
+        if( value.kind_of? self )
+          @resources[name] = value
+        else
+          raise TypeError, "#{self}#[]= can only store instances of #{self}"
+        end
+      end
+
+      #  call-seq:
+      #    MyClass.autoload( name )  ->  instance or nil
+      #
+      #  This method is invoked when a non-existing resource is
+      #  accessed with #[]. By default, this method simply returns
+      #  nil, effectively disabling autoloading.
+      #
+      #  You should override this method in your class to provide
+      #  class-specific loading behavior, or leave it as the default if
+      #  you don't need autoloading. Your method should return either
+      #  an instance of the class, or nil.
+      #
+      #  NOTE: The #find_file method is useful for getting the full
+      #  path to a file which matches the name. That's what it's there
+      #  for, so you should use it!
+      #
+      def autoload( name )
+        nil
+      end
+
+
+      #  call-seq:
+      #    MyClass.basename( path )  ->  filename
+      #
+      #  Returns the basename for the path (i.e. the
+      #  filename without the directory). Same as
+      #  File.basename
+      #
+      def basename( path )
+        File.basename( path )
+      end
+
+
+      #  call-seq:
+      #    MyClass.exist?( path )  ->  true or false
+      #
+      #  True if the given path points to a file
+      #  that exists, otherwise false. Same as
+      #  File.exist?
+      #
+      def exist?( path )
+        File.exist?(path)
+      end
+
+
+      #  call-seq:
+      #    MyClass.find_file( filename )  ->  path or nil
+      #
+      #  Checks every directory in @autoload_dirs for
+      #  a file with the given name, and returns the
+      #  path (directory and name) for the first match.
+      #
+      #  If no directories have a file with that name,
+      #  return nil.
+      #
+      def find_file( filename )
+        dir = @autoload_dirs.find { |dir|
+          exist?( File.join(dir,filename) )
+        }
+
+        if dir
+          return File.join(dir,filename)
+        else
+          return nil
+        end
+      end
+
+    end
+
+
+    #  Sets up the class when this module is included.
+    #  Adds the class methods and defines class instance
+    #  variables.
+    def self.included( object ) # :nodoc:
+
+      class << object
+        include NamedResourceClassMethods
+      end
+
+      object.instance_eval do
+        @resources = Hash.new
+        @autoload_dirs = []
+      end
+
+    end
+
+
+    # Returns the instance's @name. See also #name=.
+    def name
+      @name
+    end
+
+    #
+    #  Sets the instance's @name to the given String, or nil to
+    #  unset the name. See also #name.
+    #
+    #  NOTE: This does not automatically store the instance in the
+    #  class resource table by name. Use the #[]= class method to do
+    #  that.
+    #
+    #  The string is dup'ed and frozen before being stored.
+    #
+    #  May raise:  TypeError, if new_name is not a String or nil.
+    #
+    def name=( new_name )
+      if new_name.nil?
+        return @name = nil
+      end
+
+      unless new_name.kind_of? String
+        raise TypeError, "name must be a String (got #{new_name.class})"
+      end
+
+      @name = new_name.dup
+      @name.freeze
+    end
+
+
+  end
+
+end

data/samples/chimp.rb

@@ -24,49 +24,41 @@
 # Rosetta Stone for a pygame user switching to Rubygame.
 
 require "rubygame"
+include Rubygame
 
 puts 'Warning, images disabled' unless 
-  ($image_ok = (Rubygame::VERSIONS[:sdl_image] != nil))
+  ($image_ok = (VERSIONS[:sdl_image] != nil))
 puts 'Warning, font disabled' unless 
-  ($font_ok = (Rubygame::VERSIONS[:sdl_ttf] != nil))
+  ($font_ok = (VERSIONS[:sdl_ttf] != nil))
 puts 'Warning, sound disabled' unless
-  ($sound_ok = (Rubygame::VERSIONS[:sdl_mixer] != nil))
-
-# Functions to create our resources:
-def load_image(name, colorkey=nil)
-	# Rubygame::Image.load has been replaced with Surface
-	image = Rubygame::Surface.load_image(name)
-	if colorkey != nil
-		if colorkey == -1
-			colorkey = image.get_at([0,0])
-		end
-		image.set_colorkey(colorkey)
-	end
-	return image, Rubygame::Rect.new(0,0,*image.size)
-end
+  ($sound_ok = (VERSIONS[:sdl_mixer] != nil))
+
+
+# Get the directory this script is in.
+resources_dir = File.dirname(__FILE__)
+
+# Set the directories to autoload images and sounds from.
+# See the docs for Rubygame::NamedResource.
+Surface.autoload_dirs = [ resources_dir ]
+Sound.autoload_dirs = [ resources_dir ]
 
-def load_sound(name)
-	return nil unless $sound_ok
-	begin
-		sound = Rubygame::Mixer::Sample.load_audio(name)
-		return sound
-	rescue Rubygame::SDLError => e
-		warn "Cannot load sound #{name}. (#{e})\nContinuing anyway..."
-		return nil
-	end
-end
 
 # Classes for our game objects:
 
 # The fist object, which follows the mouse and punches on mouseclick
 class Fist
 	# It's a sprite (an image with location data).
-	include Rubygame::Sprites::Sprite
+	include Sprites::Sprite
 
 	# Create and set up a new Fist object
 	def initialize
 		super					# initialize sprite
-		@image, @rect = load_image('fist.bmp', -1)
+
+		# Autoload the image and set its colorkey
+		@image = Surface['fist.bmp']
+		@image.set_colorkey( @image.get_at([0,0]) )
+
+		@rect = @image.make_rect()
 		@punching = false		# whether the fist is punching
 		@mpos = [0,0]			# mouse curson position
 	end
@@ -78,7 +70,7 @@ class Fist
 	# in @mpos for later use in Fist#update().
 	def tell(ev)
 		case ev
-		when Rubygame::MouseMotionEvent
+		when MouseMotionEvent
 			# mouse cursor moved, remember its last location for #update()
 			@mpos = ev.pos
 		end
@@ -110,17 +102,22 @@ end
 # A chimpanzee which moves across the screen and spins when punched.
 class Chimp
 	# It's a sprite (an image with location data).
-	include Rubygame::Sprites::Sprite
+	include Sprites::Sprite
 
 	# Create and set up a new Chimp object
 	def initialize
 		super					# initialize sprite
-		@original, @rect = load_image('chimp.bmp', -1)
+
+		# Autoload the image and set its colorkey
+		@original = Surface['chimp.bmp']
+		@original.set_colorkey( @original.get_at([0,0]) )
 		@image = @original 		# store original image during rotation
+
+		@rect = @image.make_rect()
 		@rect.topleft = 10,10
+
 		# @area is the area of the screen, which the chimp will walk across
-		@area = Rubygame::Rect.new(0,0,
-															 *Rubygame::Screen.get_surface().size())
+		@area = Rubygame::Screen.get_surface().make_rect()
 		@xvel = 9 # called self.move in the pygame example
 
 		# In python, the integer 0 signifies false, while in ruby it does not.
@@ -168,7 +165,7 @@ class Chimp
 			# and is just as efficient as incremental rotations.
 			@image = @original.rotozoom(@dizzy,1,true)
 		end
-		@rect = Rubygame::Rect.new(0,0,*@image.size)
+		@rect = image.make_rect()
 		@rect.center = center # re-center
 	end
 
@@ -193,24 +190,14 @@ def main
 	
 	# Initialize Everything
 	Rubygame.init()
-	screen = Rubygame::Screen.set_mode([468, 60])
+	screen = Screen.new([468, 60])
 	screen.title = 'Monkey Fever'
 	screen.show_cursor = false;
 	# In Rubygame, you make an EventQueue object; pygame just uses functions
-	queue = Rubygame::EventQueue.new()
-
-	begin
-		# Not in the pygame version - for Rubygame, we need to
-		# open the audio device. The default values are fine.
-		Rubygame::Mixer::open_audio
-	rescue Rubygame::SDLError => e
-		warn e
-		$sound_ok = false
-		warn "Continuing without sound..."
-	end
-	
+	queue = EventQueue.new()
+
 	# Create The Background
-	background = Rubygame::Surface.new(screen.size)
+	background = Surface.new(screen.size)
 	background.fill([250,250,250])
 	
 	# Put Text On The Background, Centered
@@ -223,9 +210,9 @@ def main
 		# 
 		# 25 is more or less the actual font size in the pygame example,
 		# based on scaling factor (0.6875) pygame applies to its default font.
-		font = Rubygame::TTF.new("FreeSans.ttf",25)
+		font = TTF.new("FreeSans.ttf",25)
 		text = font.render("Pummel The Chimp, And Win $$$", true, [10,10,10])
-		textpos = Rubygame::Rect.new(0,0,*text.size)
+		textpos = text.make_rect()
 		textpos.centerx = background.width/2
 		# ATTENTION: Note that the "actor" is reversed from the pygame usage.
 		# In pygame, a surface "pulls" another surface's data onto itself.
@@ -243,13 +230,16 @@ def main
 	# This also differs from pygame. Rather than pass the desired framerate
 	# when you call clock.tick, you set the framerate for the clock, either
 	# when you create it, or afterwards with the desired_fps accessors.
-	clock = Rubygame::Clock.new { |clock| clock.target_framerate = 30 }
+	clock = Clock.new { |clock| clock.target_framerate = 30 }
 
-	whiff_sound = load_sound('whiff.wav')
-	punch_sound = load_sound('punch.wav')
+	# Autoload the sound effects
+	whiff_sound = Sound['whiff.wav']
+	punch_sound = Sound['punch.wav']
+	
 	chimp = Chimp.new()
 	fist = Fist.new()
-	allsprites = Rubygame::Sprites::Group.new()
+	
+	allsprites = Sprites::Group.new()
 	allsprites.push(chimp, fist)
 	
 	#Main Loop
@@ -264,25 +254,25 @@ def main
 			# Unlike in pygame, each event is detected by class, not
 			# by an integer type identifier.
 			case(event)
-			when Rubygame::QuitEvent
+			when QuitEvent
 				return			# break out of the main function
-			when Rubygame::KeyDownEvent
+			when KeyDownEvent
 				case event.key 
-				when Rubygame::K_ESCAPE
+				when K_ESCAPE
 					return			# break out of the main function
 				end
-			when Rubygame::MouseMotionEvent
+			when MouseMotionEvent
 				fist.tell(event)
-			when Rubygame::MouseDownEvent
+			when MouseDownEvent
 				if fist.punch(chimp)
 					chimp.punched()
 					# Only try to play the sound if it isn't nil
-					Rubygame::Mixer::play(punch_sound,-1,0) if punch_sound
+					punch_sound.play if punch_sound
 				else
 					# Only try to play the sound if it isn't nil
-					Rubygame::Mixer::play(whiff_sound,-1,0) if whiff_sound
+					whiff_sound.play if whiff_sound
 				end
-			when Rubygame::MouseUpEvent
+			when MouseUpEvent
 				fist.unpunch()
 			end
 		end 					# end event handling
@@ -302,7 +292,6 @@ def main
 ensure
   # This ensures that we properly close and clean up everything at the end
   # of the game.
-	Rubygame::Mixer.close_audio()
 	Rubygame.quit()
 end								# end main function
 

data/samples/demo_music.rb

@@ -2,10 +2,10 @@
 
 require 'rubygame'
 
+include Rubygame
 Rubygame.init()
 
 def test_music() 
-	mix = Rubygame::Mixer
 
 	# Use the lines below to get rid of artsd and contact ALSA directly on Linux.
 	# ARTSD happens to be buggy on my old, old linux distro. 
@@ -16,9 +16,7 @@ def test_music()
 		end
 	end
 
-	mix.open_audio
-	puts "Using audio driver:" + mix.driver_name
-	music = mix::Music
+	puts "Using audio driver:" + Rubygame.audio_driver
 
 	if ARGV[0]
 		file = ARGV[0]
@@ -27,10 +25,15 @@ def test_music()
 		puts "If you want, you could give a filename as an argument to this script."
 	end
 
-	mus = music.load_audio(file);
+	Music.autoload_dirs = [ File.dirname(__FILE__) ]
+	mus = Music[file];
+
+	unless mus
+		puts "ERROR: Couldn't find audio file '#{file}'."
+	end
 
 	puts "Testing fading in over 3 seconds, repeating forever."
-	mus.fade_in(3, -1);
+	mus.play( :fade_in => 3, :repeats => -1 );
 	puts('ERROR: Music not fading in') unless mus.fading?(:in)
 	sleep 3
 
@@ -52,7 +55,7 @@ def test_music()
 	sleep 1
 
 	puts "Resuming."
-	mus.resume
+	mus.unpause
 	puts "ERROR: Music not resumed" unless mus.playing?
 
 	puts "Playing for 2 seconds."
@@ -66,7 +69,6 @@ def test_music()
 	# Test playing of music to the end
 
 	puts "ERROR: Music not ended" if mus.playing?
-	mix.close_audio
 end
 
 music_thread = Thread.new do test_music() end

data/samples/demo_rubygame.rb

@@ -28,10 +28,21 @@ unless ($gfx_ok = (VERSIONS[:sdl_gfx] != nil))
   raise "SDL_gfx is not available. Bailing out." 
 end
 
+
+# Set up autoloading for Surfaces. Surfaces will be loaded automatically
+# the first time you use Surface["filename"]. Check out the docs for
+# Rubygame::NamedResource for more info about that.
+#
+Surface.autoload_dirs = [ File.dirname(__FILE__) ]
+
+
 class Panda
 	include Sprites::Sprite
-	@@pandapic = Surface.load_image("panda.png")
+  
+  # Autoload the "panda.png" image and set its colorkey
+	@@pandapic = Surface["panda.png"]
 	@@pandapic.set_colorkey(@@pandapic.get_at(0,0))
+  
 	attr_accessor :vx, :vy, :speed
 	def initialize(x,y)
 		super()
@@ -173,11 +184,12 @@ background.draw_ellipse_a([200,150],[30,25], :beige )
 
 # Let's make some labels
 require "rubygame/sfont"
-sfont = SFont.new("term16.png")
+sfont = SFont.new( Surface["term16.png"] )
 sfont.render("Arrow keys move the spinning panda!").blit(background,[10,10])
 
 TTF.setup()
-ttfont = TTF.new("FreeSans.ttf",20)
+ttfont_path = File.join(File.dirname(__FILE__),"FreeSans.ttf")
+ttfont = TTF.new( ttfont_path, 20 )
 ttfont.render("This is some TTF text!",true,[250,250,250]).blit(background,[20,200])