rubygame 2.5.3 → 2.6.0

data/lib/rubygame/ttf.rb

@@ -0,0 +1,311 @@
+#--
+#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+#	Copyright (C) 2004-2009  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
+#++
+
+
+
+require "ruby-sdl-ffi/ttf"
+
+Rubygame::VERSIONS[:sdl_ttf] = SDL::TTF.Linked_Version().to_ary
+
+
+# *IMPORTANT*: this class only exists if SDL_ttf is available!
+# Your code should check "defined?(Rubygame::TTF) != nil" to see if
+# you can use this class, or be prepared to rescue from NameError.
+# 
+# TTF provides an interface to SDL_ttf, allowing TrueType Font files to be
+# loaded and used to render text to Surfaces.
+#
+# The TTF class *must* be initialized with the #setup method before any
+# TTF objects can be created or used.
+#
+class Rubygame::TTF
+
+
+  # Attempt to setup the TTF class for use by initializing SDL_ttf.
+  # This *must* be called before the TTF class can be used.
+  # Raises SDLError if there is a problem initializing SDL_ttf.
+  #
+  def self.setup
+    if( SDL::TTF.WasInit() == 0 and SDL::TTF.Init() != 0 )
+      raise( Rubygame::SDLError,
+             "Could not setup TTF class: #{SDL.GetError()}" )
+    end
+  end
+
+
+  # Clean up and quit SDL_ttf, making the TTF class unusable as a result
+  # (until it is setup again). This does not need to be called before Rubygame
+  # exits, as it will be done automatically.
+  #
+  def self.quit
+    if( SDL::TTF.WasInit() != 0 )
+      SDL::TTF.Quit()
+    end
+  end
+
+
+
+  # Create a new TTF object, which can render text to a Surface with a
+  # particular font style and size.
+  #
+  # file:: filename of the TrueType font to use. Should be a TTF or
+  #        FON file.
+  # size:: point size (based on 72DPI). (That means the height in pixels from
+  #        the bottom of the descent to the top of the ascent.)
+  #
+  def initialize( file, size )
+    if( SDL::TTF.WasInit() == 0 )
+      raise( Rubygame::SDLError,
+             "You must call TTF.setup before opening a font." )
+    end
+
+    @struct = SDL::TTF.OpenFont( file, size )
+
+    if( @struct.pointer.null? )
+      raise Rubygame::SDLError, "Could not open font: #{SDL.GetError()}"
+    end
+  end
+
+
+  attr_reader :struct # :nodoc:
+  protected :struct
+
+
+  def _get_style( style )       # :nodoc:
+    return (SDL::TTF.GetFontStyle(@struct) & style == style)
+  end
+
+
+  # Sets the style and returns the old value.
+  #
+  def _set_style( enable, style ) # :nodoc:
+    old = SDL::TTF.GetFontStyle(@struct)
+    if( !enable and (old & style == style ) )
+			SDL::TTF.SetFontStyle( @struct, old ^ style )
+      return true
+    elsif( enable )
+      SDL::TTF.SetFontStyle( @struct, old | style )
+      return false
+    else
+      # No change
+      return enable;
+    end
+  end
+
+
+
+  # True if bold mode is enabled for this font.
+  #
+  def bold?
+    _get_style( SDL::TTF::STYLE_BOLD )
+  end
+  alias :bold :bold?
+
+
+  # Enable or disable bold mode for this font. Returns the old value.
+  #
+  def bold=( enabled )
+    _set_style( enabled, SDL::TTF::STYLE_BOLD )
+  end
+
+
+
+  # True if italic mode is enabled for this font.
+  #
+  def italic?
+    _get_style( SDL::TTF::STYLE_ITALIC )
+  end
+  alias :italic :italic?
+
+
+  # Enable or disable italic mode for this font. Returns the old
+  # value.
+  #
+  def italic=( enabled )
+    _set_style( enabled, SDL::TTF::STYLE_ITALIC )
+  end
+
+
+
+  # True if underline mode is enabled for this font.
+  #
+  def underline?
+    _get_style( SDL::TTF::STYLE_UNDERLINE )
+  end
+  alias :underline :underline?
+
+
+  # Enable or disable underline mode for this font. Returns the old
+  # value.
+  #
+  def underline=( enabled )
+    _set_style( enabled, SDL::TTF::STYLE_UNDERLINE )
+  end
+
+
+  # Return the biggest height (bottom to top; in pixels) of all glyphs
+  # in the font.
+  #
+  def height
+    SDL::TTF.FontHeight( @struct )
+  end
+
+
+  # Return the biggest ascent (baseline to top; in pixels) of all
+  # glyphs in the font.
+  #
+  def ascent
+    SDL::TTF.FontAnscent( @struct )
+  end
+
+
+  # Return the biggest descent (baseline to bottom; in pixels) of all
+  # glyphs in the font.
+  #
+  def descent
+    SDL::TTF.FontDescent( @struct )
+  end
+
+
+  # Return the recommended distance (in pixels) from a point on a line
+  # of text to the same point on the line of text below it.
+  #
+  def line_skip
+    SDL::TTF.FontLineSkip( @struct )
+  end
+
+
+
+  # The width and height the text would be if it were rendered,
+  # without the overhead of actually rendering it.
+  #
+  def size_text( text )
+    SDL::TTF.SizeText(@struct, text)
+  end
+
+
+  # The width and height the UTF-8 encoded text would be if it were
+  # rendered, without the overhead of actually rendering it.
+  #
+  def size_utf8( text )
+    SDL::TTF.SizeUTF8(@struct, text)
+  end
+
+
+  # The width and height the Unicode text would be if it were
+  # rendered, without the overhead of actually rendering it.
+  #
+  def size_unicode( text )
+    SDL::TTF.SizeUNICODE(@struct, text)
+  end
+
+
+
+  # Does the heavy lifting for the render methods.
+  #
+  def _render( text, smooth, color, back, shaded, blended, solid ) # :nodoc;
+
+    color = SDL::Color.new( Rubygame::Color.make_sdl_rgba(color) )
+
+    if back
+      back = SDL::Color.new( Rubygame::Color.make_sdl_rgba(back) )
+    end
+
+    surf =
+      if smooth
+        if back
+          shaded.call( @struct, text, color, back )
+        else
+          blended.call( @struct, text, color )
+        end
+      else
+        if back
+          s = solid.call( @struct, text, color )
+          SDL::SetColors( s, back.pointer, 0, 1 )
+          SDL::SetColorKey( s, 0, 0 );
+          s
+        else
+          solid.call( @struct, text, color )
+        end
+      end
+
+    if surf.pointer.null?
+      raise Rubygame::SDLError, "Could not render text: #{SDL.GetError()}"
+    end
+
+    return Rubygame::Surface.new( surf )
+
+  end
+
+
+  # Renders a string to a Surface with the font's style and the given
+  # color(s).
+  #
+  # text::   the text string to render
+  # smooth:: Use anti-aliasing if true. Enabling this makes the text
+  #          look much nicer (smooth curves), but is much slower.
+  # color::  the color to render the text, in the form [r,g,b]
+  # back::   the color to use as a background for the text. This
+  #          option can be omitted to have a transparent background.
+  #
+  def render( text, smooth, color, back=nil )
+    _render( text, smooth, color, back,
+             SDL::TTF.method(:RenderText_Shaded),
+             SDL::TTF.method(:RenderText_Blended),
+             SDL::TTF.method(:RenderText_Solid) )
+  end
+
+
+  # Renders a UTF-8 string to a Surface with the font's style and the
+  # given color(s).
+  #
+  # text::   the text string to render
+  # smooth:: Use anti-aliasing if true. Enabling this makes the text
+  #          look much nicer (smooth curves), but is much slower.
+  # color::  the color to render the text, in the form [r,g,b]
+  # back::   the color to use as a background for the text. This
+  #          option can be omitted to have a transparent background.
+  #
+  def render_utf8( text, smooth, color, back=nil )
+    _render( text, smooth, color, back,
+             SDL::TTF.method(:RenderUTF8_Shaded),
+             SDL::TTF.method(:RenderUTF8_Blended),
+             SDL::TTF.method(:RenderUTF8_Solid) )
+  end
+
+
+  # Renders a Unicode string to a Surface with the font's style and
+  # the given color(s).
+  #
+  # text::   the text string to render
+  # smooth:: Use anti-aliasing if true. Enabling this makes the text
+  #          look much nicer (smooth curves), but is much slower.
+  # color::  the color to render the text, in the form [r,g,b]
+  # back::   the color to use as a background for the text. This
+  #          option can be omitted to have a transparent background.
+  #
+  def render_unicode( text, smooth, color, back=nil )
+    _render( text, smooth, color, back,
+             SDL::TTF.method(:RenderUNICODE_Shaded),
+             SDL::TTF.method(:RenderUNICODE_Blended),
+             SDL::TTF.method(:RenderUNICODE_Solid) )
+  end
+
+
+end

data/samples/README

@@ -6,14 +6,14 @@ Copyright and licensing information for those items is included herein
 for your convenience.
 
 
-
-"ruby.png"         copyright (C) 2006  John Croisant
-"term16.png"       copyright (C) 2005  John Croisant
 "panda.png"        copyright (C) 2004  John Croisant
+"ruby.png"         copyright (C) 2006  John Croisant
+"rubygame.png"     copyright (C) 2009  John Croisant
 "song.ogg"         copyright (C) 1999  Bjorn De Meyer
+"term16.png"       copyright (C) 2005  John Croisant
 
 
-"ruby.png", "term16.png", "panda.png", and "song.ogg"
+"panda.png", "ruby.png", "rubygame.png", "song.ogg", and "term16.png"
 are licensed under the Creative Commons Attribution-ShareAlike 2.5 License. 
 
 To view a copy of this license, visit
@@ -28,7 +28,8 @@ or send a letter to:
 
 
 
-"FreeSans.ttf"     copyright (C) 2002-2003  Free Software Foundation
+"FreeSans.ttf"     Copyleft 2002, 2003, 2005, 2008, 2009
+                   Free Software Foundation.
 
 "FreeSans.ttf" is licensed under the GNU General Public License.
 

data/samples/demo_draw.rb

@@ -30,7 +30,7 @@ Surface.autoload_dirs = [ File.dirname(__FILE__) ]
 
 
 
-screen = Screen.set_mode([320,240])
+screen = Screen.open([320,240])
 screen.title = "Drawing test"
 
 

data/samples/demo_gl.rb

@@ -27,7 +27,7 @@ Rubygame::GL.set_attrib(Rubygame::GL::BLUE_SIZE, 5)
 Rubygame::GL.set_attrib(Rubygame::GL::DEPTH_SIZE, 16)
 Rubygame::GL.set_attrib(Rubygame::GL::DOUBLEBUFFER, 1)
 
-Rubygame::Screen.set_mode([WIDE,HIGH], 16, [Rubygame::OPENGL])
+Rubygame::Screen.open([WIDE,HIGH], 16, [Rubygame::OPENGL])
 queue = Rubygame::EventQueue.new()
 clock = Rubygame::Clock.new { |c| c.target_framerate = 60 }
 
@@ -149,3 +149,5 @@ catch(:rubygame_quit) do
 
 	end
 end
+
+Rubygame.quit

data/samples/demo_gl_tex.rb

@@ -21,7 +21,7 @@ WIDE = 640
 HIGH = 480
 SCALE = 500.0
 shadedCube=true
-TEXTURE = "ruby.png"
+TEXTURE = "rubygame.png"
 
 Rubygame.init
 
@@ -31,7 +31,7 @@ Rubygame::GL.set_attrib(Rubygame::GL::BLUE_SIZE, 5)
 Rubygame::GL.set_attrib(Rubygame::GL::DEPTH_SIZE, 16)
 Rubygame::GL.set_attrib(Rubygame::GL::DOUBLEBUFFER, 1)
 
-Rubygame::Screen.set_mode([WIDE,HIGH], 16, [Rubygame::OPENGL])
+Rubygame::Screen.open([WIDE,HIGH], 16, [Rubygame::OPENGL])
 queue = Rubygame::EventQueue.new()
 clock = Rubygame::Clock.new { |c| c.target_framerate = 60 }
 
@@ -197,3 +197,5 @@ catch(:rubygame_quit) do
 
 	end
 end
+
+Rubygame.quit

data/samples/demo_rubygame.rb

@@ -46,11 +46,13 @@ $smooth = false
 Rubygame.init()
 
 
-# SDL_gfx is required for drawing shapes and rotating/zooming Surfaces.
-$gfx_ok = (VERSIONS[:sdl_gfx] != nil)
+# SDL_gfx is required for rotating/zooming Surfaces.
+$gfx_ok = [:rotozoom, :zoom, :zoom_to].all? { |method|
+  Rubygame::Surface.new([1,1]).respond_to?( method )
+}
 
 unless ( $gfx_ok )
-	raise "You must have SDL_gfx support to run this demo!"
+	raise "This demo requires Surface rotozoom and zoom support (SDL_gfx)"
 end
 
 
@@ -110,18 +112,23 @@ class Panda
 	include Sprites::Sprite
 	include EventHandler::HasEventHandler
 
-	# Autoload the "panda.png" image and set its colorkey
-	@@pandapic = Surface["panda.png"]
-	@@pandapic.set_colorkey(@@pandapic.get_at(0,0))
+  def self.pandapic
+    return @pandapic if @pandapic
+    # Autoload the "panda.png" image and set its colorkey
+    @pandapic = Surface["panda.png"]
+    @pandapic.set_colorkey(@pandapic.get_at(0,0))
+    @pandapic.to_display_alpha
+  end
+
 
 	attr_accessor :vx, :vy, :speed
 	def initialize(x,y)
 		super()
 		@vx, @vy = 0,0
 		@speed = 40
-		@image = @@pandapic
-		@rect = Rect.new(x,y,*@@pandapic.size)
-
+    @pandapic = self.class.pandapic
+		@image = @pandapic
+		@rect = Rect.new(x,y,*@pandapic.size)
 	end
 
 	def update_image(time)
@@ -154,7 +161,7 @@ class SpinnyPanda < Panda
 
 	def update_image(time)
 		@angle += (@rate * time) % 360
-		@image = @@pandapic.rotozoom(@angle,1,$smooth)
+		@image = @pandapic.rotozoom(@angle,1,$smooth)
 	end
 end
 
@@ -172,7 +179,7 @@ class ExpandaPanda < Panda
 	def update_image(time)
 		@delta = (@delta + time*@rate/36) % (Math::PI*2)
 		zoom = 1 + Math.sin(@delta)/2
-		@image = @@pandapic.zoom(zoom,$smooth)
+		@image = @pandapic.zoom(zoom,$smooth)
 	end
 end
 
@@ -189,63 +196,12 @@ class WobblyPanda < Panda
 
 	def update_image(time)
 		@delta = (@delta + time*@rate/36) % (Math::PI*2)
-		zoomx = (1.5 + Math.sin(@delta)/6) * @@pandapic.width
-		zoomy = (1.5 + Math.cos(@delta)/5) * @@pandapic.height
-		@image = @@pandapic.zoom_to(zoomx,zoomy,$smooth)
-	end
-end
-
-
-# Create the very cute panda objects!
-panda1 = SpinnyPanda.new(100,50)
-panda2 = ExpandaPanda.new(150,50)
-panda3 = WobblyPanda.new(200,50,0.5)
-
-# Set their depths. This affects which one appears in front
-# of the other in case they overlap.
-panda1.depth = 0        # in between the others
-panda2.depth = 10       # behind both of the others
-panda3.depth = -10      # in front of both of the others
-
-
-
-
-###############
-# PANDA GROUP #
-###############
-
-
-# Create a spritegroup to manage the pandas.
-pandas = Sprites::Group.new
-pandas.extend(Sprites::UpdateGroup)
-pandas.extend(Sprites::DepthSortGroup)
-
-# Add the pandas to the group.
-pandas.push(panda1,panda2,panda3)
-
-
-# Extend the pandas group with event hooks.
-class << pandas
-	include EventHandler::HasEventHandler
-
-	# Draw all the sprites and refresh
-	# those parts of the screen
-	def do_draw( event )
-		dirty_rects = draw( event.screen )
-		event.screen.update_rects(dirty_rects)
-	end
-
-	# Erase the sprites from the screen by
-	# drawing over them with the background.
-	def do_undraw( event )
-		undraw( event.screen, event.background )
+		zoomx = (1.5 + Math.sin(@delta)/6) * @pandapic.width
+		zoomy = (1.5 + Math.cos(@delta)/5) * @pandapic.height
+		@image = @pandapic.zoom_to(zoomx,zoomy,$smooth)
 	end
 end
 
-pandas.make_magic_hooks( :tick         => :update,
-                         DrawSprites   => :do_draw,
-                         UndrawSprites => :do_undraw )
-
 
 
 ##########
@@ -254,7 +210,7 @@ pandas.make_magic_hooks( :tick         => :update,
 
 
 # Create the SDL window
-screen = Screen.set_mode([320,240])
+screen = Screen.open([320,240])
 screen.title = "Rubygame test"
 screen.show_cursor = false;
 
@@ -289,9 +245,9 @@ ttfont.render( "Press escape or q to quit.",
 
 
 
-############################
-# EVENT HOOKS AND HANDLING #
-############################
+#########################
+# EVENT HOOKS FACTORIES #
+#########################
 
 
 # Factory methods for creating event triggers
@@ -328,51 +284,105 @@ def joyreleased( button )
 end
 
 
-#######################
-# PANDA 1 EVENT HOOKS #
-#######################
 
-hooks = {
-	# Start moving when an arrow key is pressed
-	:up    =>  proc { |owner, event| owner.vy = -1 },
-	:down  =>  proc { |owner, event| owner.vy =  1 },
-	:left  =>  proc { |owner, event| owner.vx = -1 },
-	:right =>  proc { |owner, event| owner.vx =  1 },
+###################
+# PANDA INSTANCES #
+###################
 
-	# Stop moving when the arrow key is released
-	released( :up    ) =>  proc { |owner, event| owner.vy = 0 },
-	released( :down  ) =>  proc { |owner, event| owner.vy = 0 },
-	released( :left  ) =>  proc { |owner, event| owner.vx = 0 },
-	released( :right ) =>  proc { |owner, event| owner.vx = 0 },
 
-	# Move according to how far the joystick axis is moved
-	joyaxis( 0 ) =>  proc { |owner, event| owner.vx = event.value },
-	joyaxis( 1 ) =>  proc { |owner, event| owner.vy = event.value },
+def make_pandas( game )
 
-	# Fast speed when button is pressed, normal speed when released
-	joypressed(  4 ) => proc { |owner, event| owner.speed *= 2.0 },
-	joyreleased( 4 ) => proc { |owner, event| owner.speed *= 0.5 }
-}
+  # Create the very cute panda objects!
+  panda1 = SpinnyPanda.new(100,50)
+  panda2 = ExpandaPanda.new(150,50)
+  panda3 = WobblyPanda.new(200,50,0.5)
 
-panda1.make_magic_hooks( hooks )
+  # Set their depths. This affects which one appears in front
+  # of the other in case they overlap.
+  panda1.depth = 0        # in between the others
+  panda2.depth = 10       # behind both of the others
+  panda3.depth = -10      # in front of both of the others
 
 
-#######################
-# PANDA 2 EVENT HOOKS #
-#######################
+  # PANDA GROUP #
 
-hooks = {
-	# Move according to how far the joystick axis is moved
-	joyaxis( 2 ) =>  proc { |owner, event| owner.vx = event.value },
-	joyaxis( 3 ) =>  proc { |owner, event| owner.vy = event.value },
+  # Create a spritegroup to manage the pandas.
+  pandas = Sprites::Group.new
+  pandas.extend(Sprites::UpdateGroup)
+  pandas.extend(Sprites::DepthSortGroup)
 
-	# Fast speed when button is pressed, normal speed when released
-	joypressed(  5 ) => proc { |owner, event| owner.speed *= 2.0 },
-	joyreleased( 5 ) => proc { |owner, event| owner.speed *= 0.5 }
-}
+  # Add the pandas to the group.
+  pandas.push(panda1,panda2,panda3)
+
+
+  # Extend the pandas group with event hooks.
+  class << pandas
+    include EventHandler::HasEventHandler
+
+    # Draw all the sprites and refresh
+    # those parts of the screen
+    def do_draw( event )
+      dirty_rects = draw( event.screen )
+      event.screen.update_rects(dirty_rects)
+    end
+
+    # Erase the sprites from the screen by
+    # drawing over them with the background.
+    def do_undraw( event )
+      undraw( event.screen, event.background )
+    end
+  end
+
+  pandas.make_magic_hooks( :tick         => :update,
+                           DrawSprites   => :do_draw,
+                           UndrawSprites => :do_undraw )
+
+
+  # PANDA 1 EVENT HOOKS #
+
+  hooks = {
+    # Start moving when an arrow key is pressed
+    :up    =>  proc { |owner, event| owner.vy = -1 },
+    :down  =>  proc { |owner, event| owner.vy =  1 },
+    :left  =>  proc { |owner, event| owner.vx = -1 },
+    :right =>  proc { |owner, event| owner.vx =  1 },
 
-panda2.make_magic_hooks( hooks )
+    # Stop moving when the arrow key is released
+    released( :up    ) =>  proc { |owner, event| owner.vy = 0 },
+    released( :down  ) =>  proc { |owner, event| owner.vy = 0 },
+    released( :left  ) =>  proc { |owner, event| owner.vx = 0 },
+    released( :right ) =>  proc { |owner, event| owner.vx = 0 },
 
+    # Move according to how far the joystick axis is moved
+    joyaxis( 0 ) =>  proc { |owner, event| owner.vx = event.value },
+    joyaxis( 1 ) =>  proc { |owner, event| owner.vy = event.value },
+
+    # Fast speed when button is pressed, normal speed when released
+    joypressed(  4 ) => proc { |owner, event| owner.speed *= 2.0 },
+    joyreleased( 4 ) => proc { |owner, event| owner.speed *= 0.5 }
+  }
+
+  panda1.make_magic_hooks( hooks )
+
+
+  # PANDA 2 EVENT HOOKS #
+
+  hooks = {
+    # Move according to how far the joystick axis is moved
+    joyaxis( 2 ) =>  proc { |owner, event| owner.vx = event.value },
+    joyaxis( 3 ) =>  proc { |owner, event| owner.vy = event.value },
+
+    # Fast speed when button is pressed, normal speed when released
+    joypressed(  5 ) => proc { |owner, event| owner.speed *= 2.0 },
+    joyreleased( 5 ) => proc { |owner, event| owner.speed *= 0.5 }
+  }
+
+  panda2.make_magic_hooks( hooks )
+
+
+  game.register( pandas, panda1, panda2 )
+
+end
 
 
 
@@ -538,8 +548,7 @@ end
 
 $game = Game.new( screen, background )
 
-# Register the pandas to receive events.
-$game.register( pandas, panda1, panda2 )
+make_pandas( $game )
 
 # Start the main game loop. It will repeat forever
 # until the user quits the game!