chingu 0.5.5.3

data/lib/chingu.rb

@@ -0,0 +1,32 @@
+#--
+#
+# Chingu -- Game framework built on top of the opengl accelerated gamelib Gosu
+# Copyright (C) 2009 ippa / ippa@rubylicio.us
+#
+# 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
+#
+#++
+
+CHINGU_ROOT = File.dirname(File.expand_path(__FILE__))
+
+require 'rubygems' unless RUBY_VERSION =~ /1\.9/
+require 'gosu'
+require 'set'
+require File.join(CHINGU_ROOT,"chingu","require_all") # Thanks to http://github.com/tarcieri/require_all !
+require_all "#{CHINGU_ROOT}/chingu"
+
+module Chingu
+  VERSION = "0.5.5.3"
+end

data/lib/chingu/actor.rb

@@ -0,0 +1,17 @@
+module Chingu
+  #
+  # A game object class with most components included, nice for quick prototypes
+  #
+  # TODO: we probably wanna expand this concept or remove Actor as a whole.
+  #
+  class Actor < Chingu::GameObject
+    has_traits :effect, :velocity, :input
+
+    def update
+      # needed for traits to work
+      super     
+      
+      # your game logic Here
+    end    
+  end
+end

data/lib/chingu/animation.rb

@@ -0,0 +1,142 @@
+module Chingu
+  #
+  # The Animation-class helps you load and manage a tileanimation.
+  # A Tileanimation is a file where all the frames are put after eachother.
+  #
+  # An easy to use program to create tileanimations is http://tilestudio.sourceforge.net/
+  #
+  class Animation
+    attr_accessor :frames, :delay
+    
+    #
+    # Create a new Animation. 
+    #
+    #   - loop: [true|false]. After the last frame is used, start from the beginning.
+    #   - bounce: [true|false]. After the last frame is used, play it backwards untill the first frame is used again, then start playing forwards again.
+    #   - file:   Tile-file to cut up animation frames from.
+    #   - width:  width of each frame in the tileanimation
+    #   - height:  width of each frame in the tileanimation
+    #
+    #
+    def initialize(options)
+      options = {:loop => true, :bounce => false, :width => 32, :height => 32, :index => 0, :delay => 100}.merge(options)
+      
+      @loop = options[:loop]
+      @bounce = options[:bounce]
+      @file = options[:file]
+      @height = options[:height]
+      @width = options[:width]
+      @index = options[:index]
+      @delay = options[:delay]
+      @dt = 0
+      
+      if options[:size]
+        @width = options[:size][0]
+        @height = options[:size][1]
+      end
+      
+      @frame_actions = []
+      @frames = Gosu::Image.load_tiles($window, @file, @width, @height, true)
+      @step = 1
+    end
+    
+    #
+    # Returns first frame (GOSU::Image) from animation
+    #
+    def first
+      @frames.first
+    end
+
+    #
+    # Returns last frame (GOSU::Image) from animation
+    #
+    def last
+      @frames.first
+    end
+    
+    #
+    # Fetch a frame or frames:
+    #
+    #   @animation[0]       # returns first frame
+    #   @animation[0..2]    # returns a new Animation-instance with first, second and third frame
+    #
+    def [](index)
+      return @frames[index]               if  index.is_a?(Fixnum)
+      return self.new_from_frames(index)  if  index.is_a?(Range)
+    end
+		
+    #
+    # Get the current frame (a Gosu#Image)
+    #
+    def image
+      @frames[@index]
+    end
+		
+    #
+    # Resets the animation, re-starts it at frame 0
+    # returns itself.
+    #
+    def reset!
+      @index = 0
+      self
+    end
+		
+    #
+    # Returns a new animation with the frames from the original animation.
+    # Specify which frames you want with "range", for example "0..3" for the 4 first frames.
+    #
+    def new_from_frames(range)
+      new_animation = self.dup
+      new_animation.frames = []
+      range.each do |nr|
+        new_animation.frames << self.frames[nr]
+      end
+      return new_animation
+    end
+    
+    #
+    # Propelles the animation forward. Usually called in #update within the class which holds the animation.
+    # #next! will look at bounce and loop flags to always return a correct frame (a Gosu#Image)
+    #
+    def next!
+      if (@dt += $window.milliseconds_since_last_tick) > @delay
+        @dt = 0
+        @previous_index = @index
+        @index += @step
+        
+        # Has the animation hit end or beginning... time for bounce or loop?
+        if (@index >= @frames.size || @index < 0)
+          if @bounce
+            @step *= -1   # invert number
+            @index += @step
+          elsif @loop
+            @index = 0	
+          else
+            @index = @previous_index # no bounce or loop, use previous frame
+          end
+        end
+        @frame_actions[@index].call	if	@frame_actions[@index]
+      end
+      @frames[@index]
+    end
+		
+    #
+    # Initialize non-blurry zoom on frames in animation
+    #
+    def retrofy
+      frames.each { |frame| frame.retrofy }
+    end
+    
+    #
+    # Execute a certain block of code when a certain frame in the animation is active.
+    # This could be used for pixel perfect animation/movement.
+    #
+    def on_frame(frames, &block)
+      if frames.kind_of? Array
+        frames.each { |frame| @frame_actions[frame] = block }
+      else
+        @frame_actions[frames] = block
+      end
+    end		
+  end
+end

data/lib/chingu/assets.rb

@@ -0,0 +1,64 @@
+#
+# Rubygames Named Resources for GOSU
+# Assumes a global variable $window having the Gosu::Window instance.
+# Quick 'n easy access to sprites, sounds and tiles!
+#
+module Chingu
+  def media_path(file)
+    File.join($window.root, "media", file)  
+  end
+  
+  def image_path(file)
+    File.join($window.root, "gfx", file)
+  end
+  
+  class ImagePath
+    include Chingu::NamedResource
+		
+    def self.autoload(name)
+    find_file(name)
+    end
+  end
+end
+
+module Gosu
+  class Image
+    include Chingu::NamedResource
+    
+    def self.autoload(name)
+      (path = find_file(name)) ? Gosu::Image.new($window, path, true) : nil
+    end
+  end
+
+  class Song
+    include Chingu::NamedResource
+		
+    def self.autoload(name)
+      (path = find_file(name)) ? Gosu::Song.new($window, path) : nil
+    end
+  end
+  
+  class Sample
+    include Chingu::NamedResource
+    
+    def self.autoload(name)
+      (path = find_file(name)) ? Gosu::Sample.new($window, path) : nil
+    end
+  end
+  Sound = Sample
+	
+  class Tile
+    include Chingu::NamedResource	
+	
+    def self.autoload(name)
+      (path = find_file(name)) ? Gosu::Image.load_tiles($window, path, 32, 32, true) : nil
+    end
+  end
+  
+  class CutTiles
+    def self.[](name, width, height)
+      @@tiles = Hash.new unless defined?(@@tiles)
+      @@tiles[name] ||= Gosu::Image.load_tiles($window, name, width, height, true)
+    end
+  end
+end

data/lib/chingu/basic_game_object.rb

@@ -0,0 +1,132 @@
+module Chingu
+  #
+  # BasicGameObject. Resonating with 1.9.1, this is our most basic class that all game objects ultimate should build on.
+  #
+  # All objects that inherits from this class will by default be automaticly be updated and drawn.
+  # It will also acts as a container for the trait-system of chingu.
+  #
+  class BasicGameObject
+    attr_reader :options
+    attr_accessor :parent
+        
+    #
+    # adds a trait or traits to a certain game class
+    # 
+    # Executes a ruby "include" the specified module
+    #
+    def self.has_trait(*traits)
+      has_traits(*traits)
+    end
+    
+    #
+    # See #has_trait
+    #
+    def self.has_traits(*traits)
+      Array(traits).each do |trait|
+        if trait.is_a?(::Symbol) || trait.is_a?(::String)
+          include Chingu::Traits.const_get(Chingu::Inflector.camelize(trait))
+        end
+      end
+    end
+        
+    #
+    # BasicGameObject initialize
+    # - call .setup_trait() on all traits that implements it
+    #
+    def initialize(options = {})
+      @options = options
+      
+      #
+      # A GameObject either belong to a GameState or our mainwindow ($window)
+      #
+      if $window && $window.respond_to?(:game_state_manager)
+        @parent = $window.game_state_manager.inside_state || $window
+      end
+      
+      # This will call #setup_trait on the latest trait mixed in
+      # which then will pass it on to the next setup_trait() with a super-call.
+      setup_trait(options)
+    end
+    
+    #
+    # Creates a new object from class just as new() but also:
+    # - adds game object to current game state
+    # - or $window if no game state exists
+    #
+    # Use create() instead of new() if you want to keep track of your objects through
+    # Chingus "game_objects" which is available in all game states and the main window.
+    #
+    def self.create(options = {})
+      instance = self.new(options)
+      
+      
+      #
+      # Add to parents list of game objects
+      #
+      instance.parent.add_game_object(instance) if instance.parent
+      
+      return instance
+    end
+    
+    def setup_trait(options)
+    end
+    
+    def update_trait
+		end
+    
+    def draw_trait
+    end    
+        
+    def update
+    end
+
+    def draw
+    end
+    
+        
+    #
+    # Returns an array with all objects of current class.
+    # BasicGameObject#all is state aware so only objects belonging to the current state will be returned.
+    #
+    #   Bullet.all.each do {}  # Iterate through all bullets in current game state
+    #
+    def self.all
+      $window.current_parent.game_objects.of_class(self).dup
+    end
+    
+    #
+    # Returns
+    #
+    def self.size
+      $window.current_parent.game_objects.of_class(self).size
+    end
+    
+    #
+    # Destroy all instances of current class that fills a certain condition
+    #   Enemy.destroy_if(&:dead?)   # Assumes Enemy.dead? returns true/false depending on aliveness :)
+    #
+    def self.destroy_if(&block)
+      all.each do |object|
+        object.destroy if yield(object)
+      end
+    end
+    
+    #
+    # Destroys all intances of objects class:
+    #   Bullet.destroy_all    # Removes all Bullet objects from the game
+    #
+    def self.destroy_all
+      self.all.each { |object| object.destroy! }
+    end
+
+    #
+    # Removes object from the update cycle and freezes the object to prevent further modifications.
+    # If the object isn't being managed by Chingu (ie. you're doing manual update/draw calls) the object is only frozen, not removed from any updae cycle (because you are controlling that).
+    #
+    def destroy
+      @parent.remove_game_object(self) if @parent
+      self.freeze
+    end
+    alias :destroy! :destroy
+  end
+end

data/lib/chingu/core_extensions.rb

@@ -0,0 +1,53 @@
+#--
+#
+# Chingu -- Game framework built on top of the opengl accelerated gamelib Gosu
+# Copyright (C) 2009 ippa / ippa@rubylicio.us
+#
+# 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
+#
+#++
+
+
+#
+# Core extensions to GOSU
+# Some of these require the gem 'texplay'
+#
+module Gosu
+  
+  class Image
+    #
+    # Returns true if the pixel at x, y is 100% transperant (good for collisiondetection)
+    # Requires texplay
+    #
+    def transparent_pixel?(x, y)
+      begin
+        self.get_pixel(x,y)[3] == 0
+      rescue
+        puts "Error in get_pixel at x/y: #{x}/#{y}"
+      end
+    end
+    
+    #
+    # Retrofy should be called just after the image is loaded.
+    # When retrofied an image will use a non-blurry zoom.
+    # This could be used to make each pixel a sharp 4 pixelblock => retrofeeling.
+    #
+    def retrofy
+      glBindTexture(GL_TEXTURE_2D, self.gl_tex_info.tex_name)
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+    end
+  end
+end