chingu 0.5.8.2 → 0.5.9

data/README.rdoc

@@ -71,15 +71,18 @@ It currently has to be namespaced to Chingu::Traits for "has_trait" to work insi
 == OTHER CLASSES / HELPERS
 
 === Chingu::Text
-Makes use of Gosu::Font more rubyish and powerful.
-In it's core, another Chingu::GameObject + Gosu::Font.
+Makes use of Image#from_text more rubyish and powerful.
+In it's core, another Chingu::GameObject + image genning with Image#from_text.
 
 === Chingu::Animation
 Load and interact with tile-based animations. loop, bounce and access invidual frame(s) easily.
-An "@image = @animation.next!" in your Player#update is usually enough to get you started!
+An "@image = @animation.next" in your Player#update is usually enough to get you started!
 
 === Chingu::Parallax
-A class for easy paralaxxscrolling. See example3.rb for more.
+A class for easy parallaxscrolling. Add layers with different damping, move the camera to generate a new snapshot. See example3.rb for more.
+
+=== Chingu::HighScoreList
+A class to keep track of high scores, limit the list, automatic sorting on score, save/load to disc. See example13.rb for more.
 
 === Various Helpers
 Both $window and game states gets some new graphical helpers, currently only 3, but quite useful:
@@ -147,7 +150,7 @@ You're probably familiar with this very common Gosu pattern:
   Game.new.show   # Start the Game update/draw loop!
 
 
-Chingu doesn't change any fundamental concept of Gosu, but it will make the above code cleaner:
+Chingu doesn't change the fundamental concept/flow of Gosu, but it will make the above code cleaner:
   
   #
   # We use Chingu::Window instead of Gosu::Window
@@ -157,7 +160,7 @@ Chingu doesn't change any fundamental concept of Gosu, but it will make the abov
       super       # This is always needed if you want to take advantage of what chingu offers
       #
       # Player will automaticly be updated and drawn since it's a Chingu::GameObject
-      # You'll need your own Game#update/#draw after a while, but just put #super there and Chingu can do its thing.
+      # You'll need your own Chingu::Window#update and Chingu::Window#draw after a while, but just put #super there and Chingu can do its thing.
       #
       @player = Player.create
       @player.input = {:left => :move_left, :right => :move_right}
@@ -166,7 +169,8 @@ Chingu doesn't change any fundamental concept of Gosu, but it will make the abov
     
   #
   # If we create classes from Chingu::GameObject we get stuff for free.
-  # The accessors: image,x,y,zorder,angle,factor_x,factor_y,center_x,center_y,mode,update,draw
+  # The accessors image,x,y,zorder,angle,factor_x,factor_y,center_x,center_y,mode,alpha.
+  # We also get a default #draw which draws the image to screen with the parameters listed above.
   # You might recognize those from #draw_rot - http://www.libgosu.org/rdoc/classes/Gosu/Image.html#M000023
   # And in it's core, that's what Chingu::GameObject is, an encapsulation of draw_rot with some extra cheese.
   # For example, we get automatic calls to draw/update with Chingu::GameObject, which usually is what you want. 
@@ -193,6 +197,22 @@ Roughly 50 lines became 26 more powerful lines. (you can do @player.angle = 100
 If you've worked with Gosu for a while you're probably tired of passing around the window-parameter.
 Chingu solves this (as has many other developers) with a global variable $window. Yes, globals are bad, but in this case it kinda makes sense. It's used under the hood in various places.
 
+The basic flow of Chingu::Window once show() is called is this (this is called one game iteration or game loop):
+  
+  - Chingu::Window#draw() is called
+  -- draw() is called on game objects belonging to Chingu::Window
+  -- draw() is called on all game objects belonging to current game state
+  
+  - Chingu::Window#update() is called
+  -- Input for Chingu::Window is processed
+  -- Input for all game objects belonging to Chingu::Window is processed
+  -- update() is called on all game objects belonging to Chingu::Window
+  -- Input for current game state is processed
+  -- Input for game objects belonging to current game state is processed
+  -- update() is called on all game objects belonging to current game state
+
+... the above is repeatet until game exists.
+  
 === Chingu::GameObject
 This is our basic "game unit"-class, meaning most in game objects (players, enemies, bullets etc) should be inherited from Chingu::GameObject.
 The basic ideas behind it are:
@@ -473,19 +493,20 @@ The flow for a game object then becomes:
 There's a couple of traits included as default in Chingu:
 
 ==== Trait "timer"
-Adds timer functionallity to your game object
+Adds timer functionality to your game object
   during(300) { @color = Color.new(0xFFFFFFFF) }   # forces @color to white every update for 300 ms
   after(400) { self.destroy }                      # destroy object after 400 ms
   between(1000,2000) { self.rotate(10) }           # starting after 1 second, call rotate(10) every update during 1 second
+  every(2000) { Sound["bleep.wav"].play }          # play bleep.wav every 2 seconds
   
 ==== Trait "velocity"
-Adds variables velocity_x, velocity_y, acceleration_x, acceleration_y, max_velocity to game object.
+Adds accessors velocity_x, velocity_y, acceleration_x, acceleration_y, max_velocity to game object.
 They modify x, y as you would expect. *speed / angle will come*
 
 
-==== (IN DEVELOPMENT) Trait "effect"
-Adds ability to automaticly fade, rotate and scale game objects.
-* API isn't stabilized yet! * 
+==== Trait "effect"
+Adds accessors rotation_rate, fade_rate and scale_rate to game object.
+They modify angle, alpha and factor_x/factor_y each update. Since this is pretty easy to do yourself this trait might be up for deprecation.
   
 ==== (IN DEVELOPMENT) Trait "collision_detection"
 Adds class and instance methods for basic collision detection.
@@ -510,7 +531,6 @@ Also provides new code for draw() which uses screen_x / screen_y instead of x /
 
 
 
-
 === Assets / Paths
 
 You might wonder why this is necessary in the straight Gosu example:

data/chingu.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{chingu}
-  s.version = "0.5.8.2"
+  s.version = "0.5.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["ippa"]
-  s.date = %q{2009-10-22}
+  s.date = %q{2009-10-25}
   s.description = %q{OpenGL accelerated 2D game framework for Ruby.
 Builds on the awesome Gosu (Ruby/C++) which provides all the core functionality.
 It adds simple yet powerful game states, prettier input handling, deployment safe asset-handling, a basic re-usable game object and automation of common task.}

data/examples/example13.rb

@@ -10,10 +10,10 @@ include Chingu
 class Game < Chingu::Window
   def initialize
     super(640,400)
-    self.input = {:esc => :exit}
-    self.caption = "Example of Chingus HighScore class"
+    self.input = {:esc => :exit, :space => :remote_high_score, :a => :add}
+    self.caption = "Example of Chingus HighScore class. Press Space to go to fetch high scores remotely!"
     
-    PulsatingText.create("HIGH SCORES", :x => $window.width/2, :y => 50, :size => 70)
+    @title = PulsatingText.create("HIGH SCORES", :x => $window.width/2, :y => 50, :size => 70)
     
     #
     # Load a list from disk, defaults to "high_score_list.yml"
@@ -25,29 +25,65 @@ class Game < Chingu::Window
     # Add some new high scores to the list. :name and :score are required but you can put whatever.
     # They will mix with the old scores, automatic default sorting on :score
     #
-    10.times { @high_score_list.add(:name => "NEW", :score => rand(10000)) }
+    10.times do
+      data = {:name => "NEW", :score => rand(10000)}
+      
+      position = @high_score_list.add(data)
+      if position
+        puts "#{data[:name]} - #{data[:score]} got position #{position}"
+      else
+        puts "#{data[:name]} - #{data[:score]} didn't make it"
+      end
+    end
+    
+    create_text
+    
+    # @high_score_list.save_to_file  # Uncomment to save list to disk
+  end
+  
+  def remote_high_score
+    game_objects.destroy_all
+    
+    @title = PulsatingText.create("REMOTE WEBSERVICE HIGH SCORES", :x => $window.width/2, :y => 50, :size => 30)
+    
+    #
+    # :game_id is the unique ID the game has on www.gamercv.com
+    # :user is the login for that specific game (set by owner)
+    # :password is the password for that specific game (set by owner)
+    #
+    # To read a high score list only :game_id is required
+    # To write to a high score list :user and :password is required as well
+    #
+    @high_score_list = HighScoreList.load_remote(:game_id => 1, :user => "chingu", :password => "chingu", :size => 10)
+    create_text
+  end
+  
+  def add
+    data = {:name => "NEW", :score => 1600}
+    position = @high_score_list.add(data)
+    puts "Got position: #{position.to_s}"
+    create_text
+  end
+  
+  def create_text
+    @score_texts ||= []
+    @score_texts.each { |text| text.destroy }
     
     #
     # Iterate through all high scores and create the visual represenation of it
     #
     @high_score_list.each_with_index do |high_score, index|
       y = index * 25 + 100
-      Text.create(high_score[:name], :x => 200, :y => y, :size => 20)
-      Text.create(high_score[:score], :x => 400, :y => y, :size => 20)
+      @score_texts << Text.create(high_score[:name], :x => 200, :y => y, :size => 20)
+      @score_texts << Text.create(high_score[:score], :x => 400, :y => y, :size => 20)
     end
     
     5.times do
       score = rand(20000)
-      puts "position for #{score}: #{@high_score_list.position_by_score(score)}"
+      puts "position for possible score #{score}: #{@high_score_list.position_by_score(score)}"
     end
-    
-    # @high_score_list.save  # Uncomment to save list to disk
   end
   
-  def update
-    super
-    self.caption = "FPS #{$window.fps} - game objects: #{game_objects.size}"
-  end
 end
 
 #

data/examples/high_score_list.yml

@@ -1,21 +1,23 @@
 --- 
-- :name: ABC
-  :score: 9260
-- :name: ABC
-  :score: 9112
-- :name: ABC
-  :score: 8660
-- :name: ABC
-  :score: 8030
-- :name: ABC
-  :score: 7802
-- :name: ABC
-  :score: 6976
-- :name: ABC
-  :score: 6718
-- :name: ABC
-  :score: 6325
-- :name: ABC
-  :score: 5632
-- :name: ABC
-  :score: 4199
+- :name: NEW
+  :score: 9971
+- :name: NEW
+  :score: 9960
+- :name: NEW
+  :score: 9912
+- :name: NEW
+  :score: 9900
+- :name: NEW
+  :score: 9885
+- :name: NEW
+  :score: 9840
+- :name: NEW
+  :score: 9839
+- :name: NEW
+  :score: 9746
+- :name: NEW
+  :score: 9742
+- :name: NEW
+  :score: 9736
+- :name: NEW
+  :score: 9706

data/lib/chingu.rb

@@ -28,5 +28,5 @@ require File.join(CHINGU_ROOT,"chingu","require_all") # Thanks to http://github.
 require_all "#{CHINGU_ROOT}/chingu"
 
 module Chingu
-  VERSION = "0.5.8.2"
+  VERSION = "0.5.9"
 end

data/lib/chingu/game_object.rb

@@ -47,13 +47,16 @@ module Chingu
       @y = options[:y] || 0
       @angle = options[:angle] || 0
       
-      self.center = options[:center] || 0.5
+
       self.factor = options[:factor] || 1.0
-      @center_x = options[:center_x] if options[:center_x]
-      @center_y = options[:center_y] if options[:center_y]
       @factor_x = options[:factor_x] if options[:factor_x]
       @factor_y = options[:factor_y] if options[:factor_y]
-
+      
+      self.center = options[:center] || 0.5      
+      self.rotation_center(options[:rotation_center]) if options[:rotation_center]
+      @center_x = options[:center_x] if options[:center_x]
+      @center_y = options[:center_y] if options[:center_y]
+      
       if options[:color].is_a?(Gosu::Color)
         @color = options[:color]
       else

data/lib/chingu/high_score_list.rb

@@ -25,7 +25,11 @@ module Chingu
   #
   # - Keeps a local YAML file with highscores, default highscores.yml in root game dir.
   # - Add, delete, clear highscores
-  # - Iterate through highscores with simple Highscore#each
+  # - Iterate through highscores with simple HighScores#each
+  #
+  # Working with the high score list:
+  # ...as a local file requires gem 'yaml'
+  # ...as a remote gamercv.com resource requires gem 'crack' and 'rest_client'
   #
   class HighScoreList
     attr_reader :file
@@ -34,10 +38,16 @@ module Chingu
     # Create a new high score list with 0 entries
     #
     def initialize(options = {})
-      require 'yaml'
       @file = options[:file] || "high_score_list.yml"
       @size = options[:size] || 100
       @sort_on = options[:sort_on] || :score
+      
+      @user = options[:user]
+      @password = options[:password]
+      @game_id = options[:game_id]
+      @server = "http://api.gamercv.com"
+      @resource = nil
+      
       @high_scores = Array.new
     end
     
@@ -46,25 +56,63 @@ module Chingu
     # If no :file is given, HighScoreList tries to load from file "high_score_list.yml"
     #
     def self.load(options = {})
+      require 'yaml'
       high_score_list = HighScoreList.new(options)
       high_score_list.load
       return high_score_list
     end
     
+    def self.load_remote(options = {})
+      high_score_list = HighScoreList.new(options)
+      high_score_list.load_remote
+      return high_score_list      
+    end
+        
     #
-    # Add a new high score to list.
+    # Adda a new high score to the local file
     # 'data' is a hash of key/value-pairs that needs to contain at least the keys :name and :score
+    # Returns the position it got in the list, with 1 beeing the first positions
     #
     def add(data)
       raise "No :name value in high score!"   if data[:name].nil?
       raise "No :score value in high score!"  if data[:score].nil?
-      
-      @high_scores.push(data)
-      @high_scores.sort! { |a, b| b[@sort_on] <=> a[@sort_on] }
-      @high_scores = @high_scores[0..@size]
+      @resource ? add_remote(data) : add_local(data)
+      position_by_score(data[:score])
     end
     alias << add
     
+    #
+    # POSTs a new high score to the remote web service
+    #
+    def add_remote(data)
+      begin
+        @res = @resource.post({:high_score => data})
+        data = Crack::XML.parse(@res)
+        add_to_list(force_symbol_hash(data["high_score"]))
+      rescue RestClient::RequestFailed
+        puts "RequestFailed: couldn't add high score"
+      rescue RestClient::Unauthorized
+        puts "Unauthorized to add high score (check :user and :password arguments)"
+      end
+    end
+      
+    #
+    # Adds a new high score to local file
+    # Returns the position it got in the list, with 1 beeing the first positions
+    #
+    def add_local(data)
+      add_to_list(force_symbol_hash(data))
+      save_to_file
+    end
+
+    #
+    # Returns the position of full data-hash data entry, used internally
+    #
+    def position_by_data(data)
+      position = @high_scores.rindex(data)
+      position += 1 if position
+    end
+          
     #
     # Returns the position 'score' would get in among the high scores:
     #   @high_score_list.position_by_score(999999999) # most likely returns 1 for the number one spot
@@ -79,6 +127,45 @@ module Chingu
       return nil
     end
     
+    #
+    # Load data from previously specified @file
+    #
+    def load
+      @high_scores = YAML.load_file(@file)  if File.exists?(@file)
+      @high_scores = @high_scores[0..@size]
+    end
+
+    #
+    # Load data from remove web service.
+    # Under the hood, this is accomplished through a simple REST-interface
+    # The returned XML-data is converted into a simple Hash (@high_scores), which is also returned from this method.
+    #
+    def load_remote
+      raise "You need to specify a Game_id to load a remote high score list"    unless defined?(@game_id)
+      raise "You need to specify a User to load a remote high score list"       unless defined?(@user)
+      raise "You need to specify a Password to load a remote high score list"   unless defined?(@password)
+      
+      require 'rest_client'
+      require 'crack/xml'
+      @resource = RestClient::Resource.new "#{@server}/games/#{@game_id}/high_scores", :user => @user, :password => @password, :timeout => 20, :open_timeout => 5
+      
+      @high_scores.clear
+      begin
+        res = @resource.get
+        data = Crack::XML.parse(res)
+        if data["high_scores"]
+          data["high_scores"].each do |high_score|
+            @high_scores.push(force_symbol_hash(high_score))
+          end
+        end
+      rescue RestClient::ResourceNotFound
+        puts "Couldn't find Resource, did you specify a correct :game_id ?"
+      end
+      
+      @high_scores = @high_scores[0..@size]
+      return @high_scores
+    end
+    
     #
     # Direct access to invidual high scores
     #
@@ -97,21 +184,31 @@ module Chingu
       @high_scores.each_with_index { |high_score, index| yield high_score, index }
     end
 
-    #
-    # Load data from previously specified @file
-    #
-    def load
-      @high_scores = YAML.load_file(@file)  if File.exists?(@file)
-    end
-    
     #
     # Save high score data into previously specified @file
     #
-    def save
+    def save_to_file
+      require 'yaml'
       File.open(@file, 'w') do |out|
         YAML.dump(@high_scores, out)
       end
     end
+
+    private
     
+    def add_to_list(data)
+      @high_scores.push(data)
+      @high_scores.sort! { |a, b| b[@sort_on] <=> a[@sort_on] }
+      @high_scores = @high_scores[0..@size]
+    end
+    
+    def force_symbol_hash(hash)
+      symbol_hash = {}
+      hash.each_pair do |key, value|
+        symbol_hash[key.to_sym] = value
+      end
+      return symbol_hash
+    end
+        
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: chingu
 version: !ruby/object:Gem::Version 
-  version: 0.5.8.2
+  version: 0.5.9
 platform: ruby
 authors: 
 - ippa
@@ -30,7 +30,7 @@ cert_chain:
   hxtMlw==
   -----END CERTIFICATE-----
 
-date: 2009-10-22 00:00:00 +02:00
+date: 2009-10-25 01:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency