ippa-chingu 0.2.0

data/lib/chingu/animation.rb

@@ -0,0 +1,109 @@
+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
+    
+    #
+    # 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)
+      @loop = options[:loop] || true
+      @bounce = options[:bounce] || false
+      @file = options[:file]
+      @height = options[:height] || 32
+      @width = options[:width] || 32
+      @index = options[:index] || 0
+      @delay = options[:delay] || 100
+      @ticks = 0
+			
+      @frame_actions = []
+      @frames = Gosu::Image.load_tiles($window, @file, @width, @height, true)
+      @step = 1
+    end
+    
+    #
+    # Fetch a certain frame (a Gosu#Image), starts at 0.
+    #
+    def [](index)
+      @frames[index]
+    end
+		
+    #
+    # Get the current frame (a Gosu#Image)
+    #
+    def image
+      @frames[@index]
+    end
+		
+    #
+    # Resets the animation, re-starts it at frame 0
+    #
+    def reset!
+      @index = 0
+    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 (@ticks += $window.tick) > @delay
+        @ticks = 0
+        @index += @step
+        
+        # Has the animation hit end or beginning... time for bounce or loop?
+        if (@index >= @frames.size || @index < 0)
+          if @bounce
+            if @step == 1
+              @step = -1
+            else
+              @step = 1
+            end
+            @index += @step
+          elsif @loop
+            @index = 0	
+          end
+        end
+        @frame_actions[@index].call	if	@frame_actions[@index]
+      end
+      @frames[@index]
+    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,50 @@
+#
+# 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 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
+end

data/lib/chingu/chipmunk_object.rb

@@ -0,0 +1,117 @@
+module Chingu
+  #
+  # A basic class, all your gameobjects / actors should be built on this. Encapsulates
+  # Gosus draw_rot and it's parameters. 
+  #
+  # All objects that inherits from this class will automaticly be updated and drawn.
+  #
+  class Actor
+    attr_accessor :image, :x, :y, :angle, :center_x, :center_y, :factor_x, :factor_y, :mode
+    attr_accessor :update, :draw, :keymap
+    attr_reader :options
+    
+    #
+    # Class-level default values. 
+    # This allows you to set default-values that affect all created actors after that.
+    # You might want to draw screenobjects from the top-left @ x/y instead of putting it's center there:
+    # 
+    # in Gosu::Window#initialize: Actor.center_x = Actor.center_y = 0
+    #
+    @@zorder = 100
+    @@center_x = 0.5
+    @@center_y = 0.5
+    @@factor_x = 1.0
+    @@factor_y = 1.0
+
+    def self.zorder; @@zorder; end
+    def self.zorder=(value); @@zorder = value; end
+
+    def self.center_x; @@center_x; end
+    def self.center_x=(value); @@center_x = value; end
+
+    def self.center_y; @@center_y; end
+    def self.center_y=(value); @@center_y = value; end
+
+    def self.factor_x; @@factor_x; end
+    def self.factor_x=(value); @@factor_x = value; end
+
+    def self.factor_y; @@factor_y; end
+    def self.factor_y=(value); @@factor_y = value; end
+
+    #
+    # Create a new Actor. Arguments are given in hash-format:
+    # 
+    # :x        screen x-coordinate (default 0, to the left)
+    # :y        screen y-coordinate (default 0, top of screen)
+    # :angle    angle of object, used in draw_rot, (default 0, no rotation)
+    # :zorder   a gameclass "foo" with higher zorder then gameclass "bar" is drawn on top of "foo".
+    # :center_x relative horizontal position of the rotation center on the image. 
+    #           0 is the left border, 1 is the right border, 0.5 is the center (default 0.5)
+    # :center_y see center_x. (default 0.5)
+    # :factor_x horizontal zoom-factor, use >1.0 to zoom in. (default 1.0, no zoom).
+    # :factor_y vertical zoom-factor, use >1.0 to zoom in. (default 1.0, no zoom).
+    #
+    # :update [true|false] Automaticly call #update on object each gameloop. Default +true+.
+    # :draw   [true|false] Automaticly call #update on object each gameloop. Default +true+.
+    #
+    def initialize(options = {})
+      @options = options
+      
+      # draw_rot arguments
+      @image = options[:image]          if options[:image].is_a? Gosu::Image
+      @image = Image[options[:image]]   if options[:image].is_a? String
+      
+      @x = options[:x] || 0
+      @y = options[:y] || 0
+      @angle = options[:angle] || 0
+      @zorder = options[:zorder] || @@zorder
+      @center_x = options[:center_x] || options[:center] || @@center_x
+      @center_y = options[:center_y] || options[:center] || @@center_y
+      @factor_x = options[:factor_x] || options[:factor] || @@factor_x
+      @factor_y = options[:factor_y] || options[:factor] || @@factor_y
+      @mode = options[:mode] || :additive
+      
+      # gameloop logic
+      @update = options[:update] || true
+      @draw = options[:draw] || true
+      
+      automatic_update!	if @update
+      automatic_draw!		if @draw
+    end
+    
+    #
+    # Add self to the list of objects that Chingu calls #update on each update-loop. 
+    # This is done by default except if you create a gameobject with {:update => false}
+    #
+    def automatic_update!
+      $window.automatic_update_for(self)
+    end
+    #
+    # Add self to the list of objects that Chingu calls #draw on each update-loop.
+    # This is done by default except if you create a gameobject with {:draw => false}
+    #		
+    def automatic_draw!
+      $window.automatic_draw_for(self)
+    end
+    
+    def keymap=(keymap)
+      @keymap = keymap
+      $window.key_recievers << self		unless $window.key_recievers.include? self
+    end
+    
+    #
+    # Override this with your own actor/game-logic
+    # 
+    def update
+			
+		end
+    
+    #
+    # The core of the gameclass, the draw_rot encapsulation. Draws the sprite on screen.
+    # Calling #to_i on @x and @y enables thoose to be Float's, for subpixel slow movement in #update
+    #
+    def draw
+      @image.draw_rot(@x.to_i, @y.to_i, @zorder, @angle, @center_x, @center_y, @factor_x, @factor_y, @mode)
+    end
+  end
+end

data/lib/chingu/data_structures.rb

@@ -0,0 +1,6 @@
+module Chingu
+	Velocity = Struct.new(:x, :y, :z)
+	Position = Struct.new(:x, :y, :z)
+	Point = Struct.new(:x, :y)
+	#Rect = Struct.new(:x, :y, :width, :height)
+end

data/lib/chingu/fpscounter.rb

@@ -0,0 +1,21 @@
+module Chingu
+	class FPSCounter
+		attr_reader :fps
+  
+		def initialize
+			@current_second = Gosu::milliseconds / 1000
+			@accum_fps = 0
+			@fps = 0
+		end
+  
+		def register_tick
+			@accum_fps += 1
+			current_second = Gosu::milliseconds / 1000
+			if current_second != @current_second
+				@current_second = current_second
+				@fps = @accum_fps
+				@accum_fps = 0
+			end
+		end
+	end
+end

data/lib/chingu/game_object.rb

@@ -0,0 +1,101 @@
+module Chingu
+  #
+  # A basic class, all your ingame objects should be built on this. Encapsulates
+  # Gosus draw_rot and it's parameters. 
+  #
+  # All objects that inherits from this class will automaticly be updated and drawn.
+  #
+  class GameObject
+    attr_accessor :image, :x, :y, :angle, :center_x, :center_y, :factor_x, :factor_y, :mode
+    attr_accessor :update, :draw, :input
+    attr_reader :options
+    
+    #
+    # Class-level default values. 
+    # This allows you to set default-values that affect all created GameObjects after that.
+    # You might want to draw gameobjects from the top-left @ x/y instead of putting it's center there:
+    # 
+    # in Gosu::Window#initialize: GameObject.center_x = GameObject.center_y = 0
+    #
+    @@zorder = 100
+    @@center_x = 0.5
+    @@center_y = 0.5
+    @@factor_x = 1.0
+    @@factor_y = 1.0
+
+    def self.zorder; @@zorder; end
+    def self.zorder=(value); @@zorder = value; end
+
+    def self.center_x; @@center_x; end
+    def self.center_x=(value); @@center_x = value; end
+
+    def self.center_y; @@center_y; end
+    def self.center_y=(value); @@center_y = value; end
+
+    def self.factor_x; @@factor_x; end
+    def self.factor_x=(value); @@factor_x = value; end
+
+    def self.factor_y; @@factor_y; end
+    def self.factor_y=(value); @@factor_y = value; end
+
+    #
+    # Create a new GameObject. Arguments are given in hash-format:
+    # 
+    # :x        screen x-coordinate (default 0, to the left)
+    # :y        screen y-coordinate (default 0, top of screen)
+    # :angle    angle of object, used in draw_rot, (default 0, no rotation)
+    # :zorder   a gameclass "foo" with higher zorder then gameclass "bar" is drawn on top of "foo".
+    # :center_x relative horizontal position of the rotation center on the image. 
+    #           0 is the left border, 1 is the right border, 0.5 is the center (default 0.5)
+    # :center_y see center_x. (default 0.5)
+    # :factor_x horizontal zoom-factor, use >1.0 to zoom in. (default 1.0, no zoom).
+    # :factor_y vertical zoom-factor, use >1.0 to zoom in. (default 1.0, no zoom).
+    #
+    # :update [true|false] Automaticly call #update on object each gameloop. Default +true+.
+    # :draw   [true|false] Automaticly call #update on object each gameloop. Default +true+.
+    #
+    def initialize(options = {})
+      @options = options
+      
+      # draw_rot arguments
+      @image = options[:image]          if options[:image].is_a? Gosu::Image
+      @image = Image[options[:image]]   if options[:image].is_a? String
+      
+      @x = options[:x] || 0
+      @y = options[:y] || 0
+      @angle = options[:angle] || 0
+      @zorder = options[:zorder] || @@zorder
+      @center_x = options[:center_x] || options[:center] || @@center_x
+      @center_y = options[:center_y] || options[:center] || @@center_y
+      @factor_x = options[:factor_x] || options[:factor] || @@factor_x
+      @factor_y = options[:factor_y] || options[:factor] || @@factor_y
+      @color = options[:color] || 0xFFFFFFFF
+      @mode = options[:mode] || :default # :additive is also available.
+      
+      # gameloop/framework logic
+      @update = options[:update] || true
+      @draw = options[:draw] || true
+      @input = options[:input] || nil
+      
+      #
+      # A GameObject can either belong to a GameState or our mainwindow ($window)
+      # .. or live in limbo with manual updates
+      #
+      @parent = $window.game_state_manager.inside_state || $window
+      @parent.add_game_object(self)  if @parent
+    end
+    
+    
+    def update
+      # Objects gamelogic here
+		end
+    
+    #
+    # The core of the gameclass, the draw_rot encapsulation. Draws the sprite on screen.
+    # Calling #to_i on @x and @y enables thoose to be Float's, for subpixel slow movement in #update
+    #
+    def draw
+      @image.draw_rot(@x.to_i, @y.to_i, @zorder, @angle, @center_x, @center_y, @factor_x, @factor_y, @color, @mode)
+    end
+  end
+end

data/lib/chingu/game_state.rb

@@ -0,0 +1,39 @@
+module Chingu
+  class GameState
+    include Chingu::GameStateHelpers  # Easy access to the global game_state-queue
+    include Chingu::DrawHelpers       # Adds fill(), fade() etc to each gamestate.
+        
+    attr_reader :options              # so jac can access his :level-number
+    attr_reader :game_objects
+    attr_accessor :input
+    
+    def initialize(options = {})
+      @options = options
+      @game_objects = Array.new
+      @input = options[:input]
+      $window.game_state_manager.inside_state = self
+      setup
+    end
+    
+    def add_game_object(game_object)
+      @game_objects.push(game_object) unless @game_objects.include?(game_object)
+    end
+    
+    def setup
+    end
+    
+    def button_down(id)
+    end
+    
+    def button_up(id)
+    end
+
+    def update
+      @game_objects.each { |object| object.update }
+    end
+    
+    def draw
+      @game_objects.each { |object| object.draw }
+    end
+  end
+end

data/lib/chingu/game_state_manager.rb

@@ -0,0 +1,84 @@
+module Chingu  
+  class GameStateManager
+    attr_accessor :inside_state
+    attr_reader :states
+    
+    def initialize
+      @inside_state = nil
+      @states = []
+    end
+
+    #
+    # Gets the currently active gamestate (top of stack)
+    #
+    def state
+      @states.last
+    end
+
+    #
+    # Adds a state to the gamestate-stack
+    #
+    def push_state(state)
+      @states.push(state)
+    end
+    
+    #
+    # Pops a state off the gamestate-stack
+    #
+    def pop_state
+      @states.pop
+    end
+    
+    #
+    # Returns the previous gamestate
+    #
+    def previous_state
+      @states[@states.index(state)-1]
+    end
+    
+    alias :prev_state previous_state
+    
+    #
+    # Pops through all gamestates until matching a given gamestate
+    #
+    def switch_state(new_state)
+      while (state = @states.pop)
+        break if state == new_state
+      end
+    end
+    
+    #
+    # Bellow follows a set of auto-called Gosu::Window methods.
+    # We define them game_state_manager so Gosu::Window can call them here.
+    # Then the game_state_manager is responsible to resend them to the active state. 
+    # Or in the future many states.
+    #
+    
+    #
+    # Called before #update when the user pressed a button while the window had the focus. 
+    #
+    def button_down(id)
+      state.button_down(id) if state
+    end
+    
+    #
+    # Called when the user released a button. 
+    #
+    def button_up(id)
+      state.button_up(id)   if state
+    end
+    
+    #
+    # Calls #update on the current gamestate, if there is one.
+    #
+    def update
+      state.update  if state
+    end
+    #
+    # Calls draw() on the current gamestate, if there is one.
+    #
+    def draw
+      state.draw    if state
+    end
+  end
+end

data/lib/chingu/helpers.rb

@@ -0,0 +1,41 @@
+module Chingu
+  module GameStateHelpers
+    
+    #
+    # push_gamestate accepts either a class inherited from GameState or an object-instance from such a class.
+    #
+    # push_gamestate(Intro) is the same as:
+    # push_gamestate(Intro.new)
+    # 
+    # The first line ends upp calling "new" to Intro before activating the newlycreated gamestate.
+    #
+    def push_gamestate(state)
+      if state.is_a? Chingu::GameState
+        $window.game_state_manager.push_state(state)
+      elsif state.superclass == Chingu::GameState
+        $window.game_state_manager.push_state(state.new)
+      end
+    end
+  
+    def pop_gamestate
+      $window.game_state_manager.pop_state
+    end
+
+    def current_gamestate
+      $window.game_state_manager.state
+    end
+
+    def previous_gamestate
+      $window.game_state_manager.previous_state
+    end
+  end
+
+  module DrawHelpers
+    def fill(color)
+       $window.draw_quad(0, 0, color, $window.width, 0, color, $window.width, $window.width, color, 0, $window.height, color, 0, :default) 
+     end
+     
+    def fade(options = {})
+    end
+  end
+end

data/lib/chingu/input.rb

@@ -0,0 +1,100 @@
+module Chingu
+	module Input
+		include Gosu::Button
+    
+    #
+    # Ruby symbols describing http://www.libgosu.org/rdoc/classes/Gosu.html
+    #
+		CONSTANT_TO_SYMBOL = {
+      Kb0 => [:zero],
+      Kb1 => [:one],
+      Kb2 => [:two],
+      Kb3 => [:three],
+      Kb4 => [:four],
+      Kb5 => [:five],
+      Kb6 => [:six],
+      Kb7 => [:seven],
+      Kb8 => [:eight],
+      Kb9 => [:nine],
+    
+      KbBackspace => [:backspace],
+      KbDelete    => [:delete, :del],
+      KbDown      => [:down],
+      KbEnd       => [:end],
+      KbEnter     => [:enter],
+      KbEscape    => [:escape, :esc],
+
+      KbHome        => [:home],
+      KbInsert      => [:insert, :ins],
+      KbLeft        => [:left],
+      KbLeftAlt     => [:left_alt, :lalt],
+      KbLeftControl => [:left_control, :left_ctrl, :lctrl],
+      KbLeftShift   => [:left_shift, :lshift],
+      
+      
+      KbNumpadAdd       => [:"+", :add],
+      KbNumpadDivide    => [:"/", :divide],
+      KbNumpadMultiply  => [:"*", :multiply],
+      KbNumpadSubtract  => [:"-", :subtract],
+      KbPageDown        => [:page_down],
+      KbPageUp          => [:page_up],
+      # KbPause           => [:pause],
+      KbReturn          => [:return],
+      KbRight           => [:right],
+      KbRightAlt        => [:right_alt, :ralt],
+      KbRightControl    => [:right_control, :right_ctrl, :rctrl],
+      KbRightShift      => [:right_shift, :rshift],
+      KbSpace           => [:" ", :space],
+      KbTab             => [:tabulator, :tab],
+      KbUp              => [:up],
+      
+      MsLeft            => [:left_mouse_button, :mouse_left],
+      MsMiddle          => [:middle_mouse_button, :mouse_middle],
+      MsRight           => [:right_mouse_button, :mouse_right],
+      MsWheelDown       => [:mouse_wheel_down, :wheel_down],
+      MsWheelUp         => [:mouse_wheel_up, :wheel_up],
+      
+      GpDown 	          => [:gamepad_down, :gp_down, :pad_down],
+      GpLeft 	          => [:gamepad_left, :gp_left, :pad_left],
+      GpRight 	        => [:gamepad_right, :gp_right, :pad_right],
+      GpUp              => [:gamepad_up, :gp_up, :pad_up]
+		}
+    
+    # Letters, A-Z
+    ("A".."Z").each do |letter|
+      CONSTANT_TO_SYMBOL[eval("Kb#{letter}")] = [letter.downcase.to_sym]
+    end
+
+    # Numbers, 0-9
+    (0..9).each do |number|
+      CONSTANT_TO_SYMBOL[eval("Kb#{number.to_s}")] = [number.to_s.to_sym]
+    end
+
+    # Numpad-numbers, 0-9
+    (0..9).each do |number|
+      CONSTANT_TO_SYMBOL[eval("KbNumpad#{number.to_s}")] = ["numpad_#{number.to_s}".to_sym]
+    end
+
+    #F-keys, F1-F12
+    (1..12).each do |number|
+      CONSTANT_TO_SYMBOL[eval("KbF#{number.to_s}")] = ["f#{number.to_s}".to_sym]
+    end
+
+    # Gamepad-buttons 0-15
+    (0..15).each do |number|
+      CONSTANT_TO_SYMBOL[eval("GpButton#{number.to_s}")] = ["gamepad_button_#{number.to_s}"]
+    end
+
+    #
+    # Reverse CONSTANT_TO_SYMBOL -> SYMBOL_TO_CONSTNT
+    # like: SYMBOL_TO_CONSTANT = CONSTANT_TO_SYMBOL.invert.dup
+    #
+    SYMBOL_TO_CONSTANT = Hash.new
+    CONSTANT_TO_SYMBOL.each_pair do |constant, symbols|
+      symbols.each do |symbol|
+        SYMBOL_TO_CONSTANT[symbol] = constant
+      end
+    end
+    
+	end
+end