rubygame 2.3.0 → 2.4.0

data/ext/rubygame/rubygame_event2.h

@@ -0,0 +1,29 @@
+/*--
+ * This file is one part of:
+ *   Rubygame -- Ruby bindings to SDL to facilitate game creation
+ *
+ * Copyright (C) 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_EVENT2_H
+#define _RUBYGAME_EVENT2_H
+
+extern void Rubygame_Init_Event2();
+
+#endif

data/ext/rubygame/rubygame_joystick.c

@@ -77,6 +77,79 @@ static void RBGM_JoystickClose(SDL_Joystick *joy)
 }
 
 
+
+/* 
+ *  call-seq:
+ *    Joystick.activate_all()  ->  [joystick1, joystick2, ...]
+ *
+ *  Activate all joysticks on the system, equivalent to calling
+ *  Joystick.new for every joystick available. This will allow
+ *  joystick-related events to be sent to the EventQueue for
+ *  all joysticks.
+ *  
+ *  Returns::  Array of zero or more Joysticks.
+ *
+ */
+VALUE rbgm_joystick_activateall(VALUE module)
+{
+	/* Initialize if it isn't already. */
+	if( !SDL_WasInit(SDL_INIT_JOYSTICK) )
+	{
+		if( SDL_Init(SDL_INIT_JOYSTICK) != 0 )
+		{
+			rb_raise( eSDLError, "Could not initialize SDL joystick." );
+		}
+	}
+
+	int num_joysticks = SDL_NumJoysticks();
+	int i = 0;
+
+	/* Collect Joystick instances in an Array. */
+	VALUE joysticks = rb_ary_new();
+
+	for(; i < num_joysticks; ++i )
+	{
+		rb_ary_push( joysticks, rbgm_joystick_new(module, INT2NUM(i)) );
+	}
+
+	return joysticks;
+}
+
+
+/* 
+ *  call-seq:
+ *    Joystick.deactivate_all()
+ *
+ *  Deactivate all joysticks on the system. This will stop all
+ *  joystick-related events from being sent to the EventQueue.
+ *
+ */
+VALUE rbgm_joystick_deactivateall(VALUE module)
+{
+	/* Return right away if it wasn't active. */
+	if( !SDL_WasInit(SDL_INIT_JOYSTICK) )
+	{
+		return Qnil;
+	}
+
+	int num_joysticks = SDL_NumJoysticks();
+	int i = 0;
+	SDL_Joystick *joy;
+
+	for(; i < num_joysticks; ++i )
+	{
+		joy = SDL_JoystickOpen(i);
+		if(joy != NULL)
+		{
+			SDL_JoystickClose( joy );
+		}
+	}
+
+	return Qnil;
+}
+
+
+
 /* 
  *  call-seq:
  *    new( n )  ->  Joystick
@@ -206,25 +279,38 @@ VALUE rbgm_joystick_numbuttons( VALUE self )
 /*  Document-class: Rubygame::Joystick
  *
  *  The Joystick class interfaces with joysticks, gamepads, and other
- *  similar hardware devices, commonly used to play games. Each joystick can
- *  offer 0 or more #axes, #balls, #hats, and/or #buttons.
+ *  similar hardware devices used to play games. Each joystick may
+ *  have zero or more #axes, #balls, #hats, and/or #buttons.
  *
  *  After a Joystick object is successfully created, events for that
- *  Joystick will begin appearing on the Queue, reporting any state change
- *  that occurs. Some examples of state changes are a button being pressed
- *  or released, or a control stick being moved (resulting in one or more axes
- *  being changed).
- *
- *  The full list of Joystick-related events is as follows:
- *  - JoyAxisEvent
- *  - JoyBallEvent
- *  - JoyHatEvent
- *  - JoyDownEvent
- *  - JoyUpEvent
- *
- *  In future versions of Rubygame, it will be possible to directly query
- *  the state each joystick. However, it is recommended that you use the
- *  event system for most cases, so you might as well get used to it!
+ *  Joystick will begin appearing on the EventQueue when a button is
+ *  pressed or released, a control stick is moved, etc.
+ *
+ *  You can use Joystick.activate_all to start receiving events for
+ *  all joysticks (equivalent to creating them all individually with
+ *  Joystick.new). You can use Joystick.deactivate_all to stop
+ *  receiving events for all joysticks.
+ *
+ *  As of Rubygame 2.4, these are the current, "new-style" Joystick
+ *  event classes:
+ *
+ *  * Events::JoystickAxisMoved
+ *  * Events::JoystickButtonPressed
+ *  * Events::JoystickButtonReleased
+ *  * Events::JoystickBallMoved
+ *  * Events::JoystickHatMoved
+ *
+ *  These old Joystick-related events are deprecated and will be
+ *  removed in Rubygame 3.0:
+ *
+ *  * JoyAxisEvent
+ *  * JoyBallEvent
+ *  * JoyHatEvent
+ *  * JoyDownEvent
+ *  * JoyUpEvent
+ *
+ *  For more information about "new-style" events, see
+ *  EventQueue.enable_new_style_events.
  *
  */
 void Rubygame_Init_Joystick()
@@ -237,6 +323,9 @@ void Rubygame_Init_Joystick()
 	rb_define_singleton_method(cJoy,"num_joysticks",rbgm_joy_numjoysticks,0);
 	rb_define_singleton_method(cJoy,"get_name",rbgm_joy_getname,1);
 
+	rb_define_singleton_method(cJoy,"activate_all",rbgm_joystick_activateall,0);
+	rb_define_singleton_method(cJoy,"deactivate_all",rbgm_joystick_deactivateall,0);
+
 	rb_define_singleton_method(cJoy,"new",rbgm_joystick_new,1);
 	rb_define_method(cJoy,"index",rbgm_joystick_index,0);
 	rb_define_method(cJoy,"name",rbgm_joystick_name,0);

data/ext/rubygame/rubygame_main.c

@@ -22,6 +22,7 @@
 #include "rubygame_shared.h"
 #include "rubygame_main.h"
 #include "rubygame_event.h"
+#include "rubygame_event2.h"
 #include "rubygame_gl.h"
 #include "rubygame_joystick.h"
 #include "rubygame_screen.h"
@@ -76,6 +77,7 @@ VALUE rbgm_init(VALUE module)
 {
 	if(SDL_Init(SDL_INIT_EVERYTHING)==0)
 	{
+    SDL_EnableUNICODE(1);
 		return Qnil;
 	}
 	else
@@ -129,6 +131,7 @@ void Init_rubygame_core()
 	Rubygame_Init_Surface();
 	Rubygame_Init_Screen();
 	Rubygame_Init_Event();
+	Rubygame_Init_Event2();
 	Rubygame_Init_Joystick();
   Rubygame_Init_GL();
 

data/ext/rubygame/rubygame_shared.c

@@ -263,10 +263,7 @@ void Init_rubygame_shared()
 
 
   /* Rubygame::NamedResource mixin. See named_resource.rb. */
-  if( mNamedResource == (int)NULL )
-  {
-    rb_require("rubygame/named_resource");
-    mNamedResource = rb_const_get(mRubygame, rb_intern("NamedResource"));
-  }
+  rb_require("rubygame/named_resource");
+  mNamedResource = rb_const_get(mRubygame, rb_intern("NamedResource"));
 
 }

data/ext/rubygame/rubygame_shared.h

@@ -39,6 +39,7 @@ extern VALUE sanitized_symbol(char *);
 extern Uint32 collapse_flags(VALUE);
 extern VALUE convert_to_array(VALUE);
 
+extern VALUE convert_color(VALUE);
 extern SDL_Color make_sdl_color(VALUE);
 extern void extract_rgb_u8_as_u8(VALUE, Uint8*, Uint8*, Uint8*);
 extern void extract_rgba_u8_as_u8(VALUE, Uint8*, Uint8*, Uint8*, Uint8*);

data/ext/rubygame/rubygame_surface.c

@@ -333,10 +333,18 @@ VALUE rbgm_surface_get_colorkey( VALUE self )
 
 	Data_Get_Struct(self, SDL_Surface, surf);
 	colorkey = surf->format->colorkey;
-	if((int *)colorkey == NULL)
+
+	if( surf->flags & SDL_SRCCOLORKEY )
+	{
+		SDL_GetRGB(colorkey, surf->format, &r, &g, &b);
+		return rb_ary_new3(3,UINT2NUM(r),UINT2NUM(g),UINT2NUM(b));
+	}
+	else
+	{
+		/* No colorkey set. */
 		return Qnil;
-	SDL_GetRGB(colorkey, surf->format, &r, &g, &b);
-	return rb_ary_new3(3,UINT2NUM(r),UINT2NUM(g),UINT2NUM(b));
+	}
+
 }
 
 /*
@@ -618,12 +626,6 @@ VALUE rbgm_surface_getat( int argc, VALUE *argv, VALUE self )
 		locked -= 1;
 	}
 
-	if((int *)color == NULL)
-	{
-		VALUE zero = INT2NUM(0);
-		return rb_ary_new3(4,zero,zero,zero,zero);
-	}
-
 	SDL_GetRGBA(color, surf->format, &r, &g, &b, &a);
 	return rb_ary_new3(4,UINT2NUM(r),UINT2NUM(g),UINT2NUM(b),UINT2NUM(a));
 }

data/lib/rubygame.rb

@@ -1,6 +1,6 @@
 #--
 #  Rubygame -- Ruby code and bindings to SDL to facilitate game creation
-#  Copyright (C) 2004-2007  John Croisant
+#  Copyright (C) 2004-2007, 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
@@ -17,8 +17,15 @@
 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #++
 
-# This is the file that should be imported, it in turn imports rubygame.so
-# (which has all of the C code for rubygame) and all the other rubygame modules
+# This file is loaded when you "require 'rubygame'".
+# It loads up the compiled C extensions and the rest of
+# the Rubygame library modules.
+
+
+# Prefer local library over global installed version.
+$:.unshift( File.join( File.dirname(__FILE__), "..", "lib" ) )
+$:.unshift( File.join( File.dirname(__FILE__), "..", "ext", "rubygame" ) )
+
 
 require "rbconfig"
 
@@ -34,8 +41,12 @@ end
 
 require "rubygame/color"
 require "rubygame/constants"
+
 require "rubygame/event"
+require "rubygame/events"
 require "rubygame/queue"
+require "rubygame/event_handler"
+
 require "rubygame/rect"
 require "rubygame/sprite"
 require "rubygame/clock"

data/lib/rubygame/event_actions.rb

@@ -0,0 +1,203 @@
+#--
+#	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
+#++
+
+
+# This module contains all the event action classes that
+# come with Rubygame. 
+# 
+# An event action class is simply a class which can be
+# used as an action an EventHook. The action is used to
+# cause some effect when the EventHook matches an event.
+#
+# The only requirement for an event action is this:
+# 
+# * It must have a #perform method which takes exactly two
+#   arguments (the hook owner and an event). Return values
+#   are ignored.
+# 
+# You can make your own custom event action classes and
+# use them in an EventHook if they meet that requirement.
+#
+# Here is an overview of the event action classes that
+# come with Rubygame as of version 2.4:
+# 
+# BlockAction::  Calls a custom code block, passing it the
+#                hook owner and the event.
+# 
+# MethodAction:: Calls one of the owner's methods, passing
+#                it the event.
+# 
+# MultiAction::  Holds multiple other actions and performs
+#                each of them, in order.
+# 
+module Rubygame::EventActions
+
+
+# BlockAction is an event action used with EventHook. BlockAction
+# takes a code block at initialization. When the action is performed,
+# it executes the block, passing in the EventHook#owner and the event
+# that is being handled as the two parameters to the block.
+# 
+# Example:
+# 
+#   hit_by_missile = KindOfTrigger.new( MissileCollisionEvent )
+# 
+#   take_damage = BlockAction.new { |owner, event|
+#     owner.health -= event.damage_amount
+#   }
+# 
+#   hook = EventHook.new( :owner   => player_ship,
+#                         :trigger => hit_by_missile,
+#                         :action  => take_damage )
+# 
+# 
+# NOTE: It is also possible to pass a Proc or detached Method
+# as the block, using the standard Ruby syntax for that:
+# 
+#   # Using a pre-built Proc.
+# 
+#   my_proc = Proc.new { |owner, event| do_something() }
+# 
+#   BlockAction.new( &my_proc )
+# 
+# 
+#   # Using a detached method.
+# 
+#   def a_method( owner, event )
+#     do_something
+#   end
+# 
+#   detached_method = method(:a_method)
+# 
+#   BlockAction.new( &detached_method )
+# 
+# 
+class BlockAction
+
+	# Create a new BlockAction using the given code block.
+	# 
+	# &block::     the code block to execute. Should take two parameters,
+	#              owner and event. (Proc, required)
+	# 
+	# May raise::  ArgumentError, if no block is provided.
+	# 
+	def initialize( &block )
+		raise ArgumentError, "BlockAction needs a block" unless block_given?
+		@block = block
+	end
+	
+	# Execute the code block, passing in owner and event as the two
+	# parameters to the block. This is automatically called by EventHook
+	# when an event matches the trigger. You should usually not call it
+	# in your own code.
+	# 
+	# owner::  the owner of the EventHook, or nil if there is none.
+	#          (Object, required)
+	# event::  the event that matched the trigger. (Object, required)
+	# 
+	def perform( owner, event )
+		@block.call( owner, event )
+	end
+end
+
+
+# MethodAction is an event action used with EventHook.
+# MethodAction takes a symbol giving the name of a method. When
+# it is performed, it calls that method on the owner, passing
+# it the event that triggered the hook.
+# 
+# Example:
+# 
+#   class Player
+#     def aim_at( event )
+#       self.crosshair_pos = event.pos
+#     end
+#   end
+# 
+#   player1 = Player.new
+# 
+#   EventHook.new( :owner   => player1,
+#                  :trigger => MouseMoveTrigger.new(),
+#                  :action  => MethodAction.new( :aim_at ) )
+# 
+class MethodAction
+
+	# Create a new MethodAction using the given method name.
+	# 
+	# method_name::  the method to call when performing.
+	#                (Symbol, required)
+	# 
+	def initialize( method_name )
+		@method_name = method_name
+	end
+
+
+	# Call the method of the owner represented by @method_name,
+	# passing in the event as the only argument.
+	# 
+	# If that causes ArgumentError (e.g. because the method doesn't
+	# take an argument), calls again without any arguments.
+	# 
+	# If that also fails, this method re-raises the original error.
+	# 
+	def perform( owner, event )
+		owner.method(@method_name).call( event )
+	rescue ArgumentError => s
+		begin
+			# Oops! Try again, without any argument.
+			owner.method(@method_name).call()
+		rescue ArgumentError
+			# That didn't work either. Raise the original error.
+			raise s
+		end
+	end
+end
+
+
+
+# MultiAction is an event action used with EventHook.
+# It takes zero or more actions (e.g. BlockAction or MethodAction
+# instances) at initialization.
+# 
+# When MultiAction is performed, it performs all the given
+# actions, in the order they were given, passing in the owner
+# and event.
+# 
+# As the name suggests, you can use MultiAction to cause
+# multiple actions to occur when an EventHook is triggered.
+# 
+class MultiAction
+
+	# Create a new MultiAction instance with the given sub-actions.
+	# 
+	# *actions:: the actions to perform. (Action instances)
+	# 
+	def initialize( *actions )
+		@actions = actions
+	end
+	
+	# Performs all the sub-actions, in the order they were given,
+	# passing in the owner and event to each one.
+	# 
+	def perform( owner, event )
+		@actions.each { |action| action.perform( owner, event ) }
+	end
+end
+
+end