steam-condenser 1.3.8.1 → 1.3.9

data/pkg/steam-condenser-1.3.8.1/lib/steam/community/game_item_schema.rb

@@ -0,0 +1,131 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2012, Sebastian Staudt
+
+require 'steam/community/cacheable'
+
+# Provides item definitions and related data that specify the items of a game
+#
+# @author Sebastian Staudt
+class GameItemSchema
+
+  include Cacheable
+  cacheable_with_ids [ :app_id, :language ]
+
+  # Returns the application ID of the game this item schema belongs to
+  #
+  # @return [Fixnum] The application ID of the game
+  attr_reader :app_id
+
+  # The attributes defined for this game's items
+  #
+  # @return [Hash<Symbol, Object>] This item schema's attributes
+  attr_reader :attributes
+
+  # The effects defined for this game's items
+  #
+  # @return [Hash<Symbol, Object>] This item schema's effects
+  attr_reader :effects
+
+  # The levels defined for this game's items
+  #
+  # @return [Hash<Symbol, Object>] This item schema's item levels
+  attr_reader :item_levels
+
+  # A mapping from the item name to the item's defindex
+  #
+  # @return [Hash<Symbol, Object>] The item name mapping
+  attr_reader :item_names
+
+  # The item sets defined for this game's items
+  #
+  # @return [Hash<Symbol, Object>] This item schema's item sets
+  attr_reader :item_sets
+
+  # The items defined for this game
+  #
+  # @return [Hash<Symbol, Object>] The items in this schema
+  attr_reader :items
+
+  # The language of this item schema
+  #
+  # @return [Symbol] The language of this item schema
+  attr_reader :language
+
+  # The item origins defined for this game's items
+  #
+  # @return [Array<String>] This item schema's origins
+  attr_reader :origins
+
+  # The item qualities defined for this game's items
+  #
+  # @return [Array<String>] This item schema's qualities
+  attr_reader :qualities
+
+  # Creates a new item schema for the game with the given application ID and
+  # with descriptions in the given language
+  #
+  # @param [Fixnum] app_id The application ID of the game
+  # @param [Symbol] language The language of description strings
+  # @macro cacheable
+  def initialize(app_id, language = nil)
+    @app_id   = app_id
+    @language = language
+  end
+
+  # Updates the item definitions of this schema using the Steam Web API
+  def fetch
+    params = { :language => language }
+    data = WebApi.json!("IEconItems_#{app_id}", 'GetSchema', 1, params)
+
+    @attributes = {}
+    data[:attributes].each do |attribute|
+      @attributes[attribute[:defindex]] = attribute
+      @attributes[attribute[:name]]     = attribute
+    end
+
+    @effects = {}
+    data[:attribute_controlled_attached_particles].each do |effect|
+      @effects[effect[:id]] = effect[:name]
+    end
+
+    @items = {}
+    @item_names = {}
+    data[:items].each do |item|
+      @items[item[:defindex]] = item
+      @item_names[item[:name]] = item[:defindex]
+    end
+
+    @item_levels = {}
+    data[:item_levels].each do |item_level_type|
+      @item_levels[item_level_type[:name]] = {}
+      item_level_type[:levels].each do |level|
+        @item_levels[item_level_type[:name]][level[:level]] = level[:name]
+      end
+    end if data.key? :item_levels
+
+    @item_sets = {}
+    data[:item_sets].each do |item_set|
+      @item_sets[item_set[:item_set]] = item_set
+    end
+
+    @origins = []
+    data[:originNames].each do |origin|
+      @origins[origin[:origin]] = origin[:name]
+    end
+
+    @qualities = []
+    data[:qualities].keys.each_with_index do |key, index|
+      @qualities[index] = data[:qualityNames][key] || key.to_s.capitalize
+    end
+  end
+
+  # Returns a short, human-readable string representation of this item schema
+  #
+  # @return [String] A string representation of this item schema
+  def inspect
+    "#<#{self.class}:#@app_id (#@language) - #{fetch_time || 'not fetched'}>"
+  end
+
+end

data/pkg/steam-condenser-1.3.8.1/lib/steam/community/game_leaderboard.rb

@@ -0,0 +1,212 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2011-2013, Sebastian Staudt
+
+require 'multi_xml'
+
+require 'steam/community/game_leaderboard_entry'
+require 'steam/community/steam_id'
+require 'steam/community/xml_data'
+
+# The GameLeaderboard class represents a single leaderboard for a specific game
+#
+# @author Sebastian Staudt
+class GameLeaderboard
+
+  include XMLData
+
+  DISPLAY_TYPE_NONE         = 0
+  DISPLAY_TYPE_NUMERIC      = 1
+  DISPLAY_TYPE_SECONDS      = 2
+  DISPLAY_TYPE_MILLISECONDS = 3
+
+  SORT_METHOD_NONE = 0
+  SORT_METHOD_ASC  = 1
+  SORT_METHOD_DESC = 2
+
+  @@leaderboards = {}
+
+  # Returns the display type of the scores on this leaderboard
+  #
+  # @return [Fixnum] The display type of the scores
+  attr_reader :display_type
+
+  # Returns the number of entries on this leaderboard
+  #
+  # @return [Fixnum] The number of entries on this leaderboard
+  attr_reader :entry_count
+
+  # Returns the ID of the leaderboard
+  #
+  # @return [Fixnum] The ID of the leaderboard
+  attr_reader :id
+
+  # Returns the name of the leaderboard
+  #
+  # @return [String] The name of the leaderboard
+  attr_reader :name
+
+  # Returns the method that is used to sort the entries on the leaderboard
+  #
+  # @return [Fixnum] The sort method
+  attr_reader :sort_method
+
+  # Returns the leaderboard for the given game and leaderboard ID or name
+  #
+  # @param [String] game_name The short name of the game
+  # @param [Fixnum, String] id The ID or name of the leaderboard to return
+  # @return [GameLeaderboard] The matching leaderboard if available
+  def self.leaderboard(game_name, id)
+    leaderboards = self.leaderboards game_name
+
+    if id.is_a? Fixnum
+      leaderboards[id]
+    else
+      leaderboards.each_value do |board|
+        return board if board.name == id
+      end
+    end
+  end
+
+  # Returns an array containing all of a game's leaderboards
+  #
+  # @param [String] game_name The name of the game
+  # @return [Array<GameLeaderboard>] The leaderboards for this game
+  def self.leaderboards(game_name)
+    self.load_leaderboards game_name unless @@leaderboards.key? game_name
+
+    @@leaderboards[game_name]
+  end
+
+  # Returns the entry on this leaderboard for the user with the given SteamID
+  #
+  # @param [Fixnum, SteamId] steam_id The 64bit SteamID or the `SteamId` object
+  #        of the user
+  # @return [GameLeaderboardEntry] The entry of the user if available
+  # raise [SteamCondenserException] if an error occurs while fetching the
+  #         leaderboard
+  def entry_for_steam_id(steam_id)
+    steam_id = steam_id.steam_id64 if steam_id.is_a? SteamId
+
+    parse "#@url&steamid=#{steam_id}"
+
+    error = @xml_data['error']
+    raise SteamCondenserError, error unless error.nil?
+
+    @xml_data['entries']['entry'].each do |entry_data|
+      if entry_data['steamid'].to_i == steam_id
+        return GameLeaderboardEntry.new entry_data, self
+      end
+    end
+
+    nil
+  end
+
+  # Returns an array of entries on this leaderboard for the user with the given
+  # SteamID and his/her friends
+  #
+  # @param [Fixnum, SteamId] steam_id The 64bit SteamID or the `SteamId` object
+  #        of the user
+  # @return [Array<GameLeaderboardEntry>] The entries of the user and his/her
+  #         friends
+  # raise [SteamCondenserException] if an error occurs while fetching the
+  #         leaderboard
+  def entry_for_steam_id_friends(steam_id)
+    steam_id = steam_id.steam_id64 if steam_id.is_a? SteamId
+
+    parse "#@url&steamid=#{steam_id}"
+
+    error = @xml_data['error']
+    raise SteamCondenserError, error unless error.nil?
+
+    parse_entries
+  end
+
+  # Returns the entries on this leaderboard for a given rank range
+  #
+  # The range is inclusive and a maximum of 5001 entries can be returned in a
+  # single request.
+  #
+  # @param [Fixnum] first The first entry to return from the leaderboard
+  # @param [Fixnum] last The last entry to return from the leaderboard
+  # @return [Array<GameLeaderboardEntry>] The entries that match the given rank
+  #         range
+  # raise [SteamCondenserException] if an error occurs while fetching the
+  #         leaderboard
+  def entry_range(first, last)
+    if last < first
+      raise SteamCondenserError,
+        'First entry must be prior to last entry for leaderboard entry lookup.'
+    end
+
+    if (last - first) > 5000
+      raise SteamCondenserError,
+        'Leaderboard entry lookup is currently limited to a maximum of 5001 entries per request.'
+    end
+
+    parse "#@url&start=#{first}&end=#{last}"
+
+    error = @xml_data['error']
+    raise SteamCondenserError, error unless error.nil?
+
+    entries = []
+    @xml_data['entries']['entry'].each do |entry_data|
+      rank = entry_data['rank'].to_i
+      entries[rank] = GameLeaderboardEntry.new entry_data, self
+    end
+
+    parse_entries
+  end
+
+  private
+
+  # Creates a new leaderboard instance with the given XML data
+  #
+  # @param [Hash<String, Object>] board_data The XML data of the leaderboard
+  def initialize(board_data)
+    @url          = board_data['url']
+    @id           = board_data['lbid'].to_i
+    @name         = board_data['name']
+    @entry_count  = board_data['entries'].to_i
+    @sort_method  = board_data['sortmethod'].to_i
+    @display_type = board_data['displaytype'].to_i
+  end
+
+  # Parses all entries available in the XML data
+  #
+  # @return [Array<GameLeaderboardEntry>] All available entries
+  def parse_entries
+    entries = []
+    @xml_data['entries']['entry'].each do |entry_data|
+      entries[entry_data['rank'].to_i] =
+        GameLeaderboardEntry.new entry_data, self
+    end
+
+    entries
+  end
+
+  # Loads the leaderboards of the specified games into the cache
+  #
+  # @param [String] game_name The short name of the game
+  # @raise [SteamCondenserException] if an error occurs while fetching the
+  #         leaderboards
+  def self.load_leaderboards(game_name)
+    begin
+      url = "http://steamcommunity.com/stats/#{game_name}/leaderboards/?xml=1"
+      boards_data = MultiXml.parse(open(url, {:proxy => true})).values.first
+    rescue
+      raise SteamCondenserError.new 'XML data could not be parsed.', $!
+    end
+
+    error = boards_data['error']
+    raise SteamCondenserError, error unless error.nil?
+
+    @@leaderboards[game_name] = []
+    boards_data['leaderboard'].each do |board_data|
+      leaderboard = GameLeaderboard.new board_data
+      @@leaderboards[game_name][leaderboard.id] = leaderboard
+    end
+  end
+
+end

data/pkg/steam-condenser-1.3.8.1/lib/steam/community/game_leaderboard_entry.rb

@@ -0,0 +1,43 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2011-2012, Sebastian Staudt
+
+# The GameLeaderboard class represents a single entry in a leaderboard
+#
+# @author Sebastian Staudt
+class GameLeaderboardEntry
+
+  # Returns the Steam ID of this entry's player
+  #
+  # @return [SteamId] The Steam ID of the player
+  attr_reader :steam_id
+
+  # Returns the score of this entry
+  #
+  # @return [Fixnum] The score of this player
+  attr_reader :score
+
+  # Returns the rank where this entry is listed in the leaderboard
+  #
+  # @return [Fixnum] The rank of this entry
+  attr_reader :rank
+
+  # Returns the leaderboard this entry belongs to
+  #
+  # @return [GameLeaderboard] The leaderboard of this entry
+  attr_reader :leaderboard
+
+  # Creates new entry instance for the given XML data and leaderboard
+  #
+  # @param [Hash<String, Object>] entry_data The XML data of the leaderboard of
+  #        the leaderboard entry
+  # @param [GameLeaderboard] leaderboard The leaderboard this entry belongs to
+  def initialize(entry_data, leaderboard)
+    @steam_id    = SteamId.new entry_data['steamid'].to_i, false
+    @score       = entry_data['score'].to_i
+    @rank        = entry_data['rank'].to_i
+    @leaderboard = leaderboard
+  end
+
+end

data/pkg/steam-condenser-1.3.8.1/lib/steam/community/game_stats.rb

@@ -0,0 +1,175 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2008-2012, Sebastian Staudt
+
+require 'steam/community/game_achievement'
+require 'steam/community/game_leaderboard'
+require 'steam/community/xml_data'
+
+# This class represents the game statistics for a single user and a specific
+# game
+#
+# It is subclassed for individual games if the games provide special statistics
+# that are unique to this game.
+#
+# @author Sebastian Staudt
+class GameStats
+
+  include XMLData
+
+  # Returns the game these stats belong to
+  #
+  # @return [SteamGame] The game object
+  attr_reader :game
+
+  # Returns the number of hours this game has been played by the player
+  #
+  # @return [String] The number of hours this game has been played
+  attr_reader :hours_played
+
+  # Returns the privacy setting of the Steam ID profile
+  #
+  # @return [String] The privacy setting of the Steam ID
+  attr_reader :privacy_state
+
+  # Returns the Steam ID of the player these stats belong to
+  #
+  # @return [SteamId] The Steam ID instance of the player
+  attr_reader :user
+
+  # Returns the base Steam Communtiy URL for the given player and game IDs
+  #
+  # @param [Fixnum, String] user_id The 64bit SteamID or custom URL of the user
+  # @param [Fixnum, String] game_id The application ID or short name of the
+  #        game
+  # @return The base URL used for the given stats IDs
+  def self.base_url(user_id, game_id)
+    game_url = game_id.is_a?(Fixnum) ? "appid/#{game_id}" : game_id
+
+    if user_id.is_a? Fixnum
+      "http://steamcommunity.com/profiles/#{user_id}/stats/#{game_url}"
+    else
+      "http://steamcommunity.com/id/#{user_id}/stats/#{game_url}"
+    end
+  end
+
+  # Creates a `GameStats` (or one of its subclasses) instance for the given
+  # user and game
+  #
+  # @param [String, Fixnum] steam_id The custom URL or the 64bit Steam ID of
+  #        the user
+  # @param [String] game_name The friendly name of the game
+  # @return [GameStats] The game stats object for the given user and game
+  def self.create_game_stats(steam_id, game_name)
+    case game_name
+      when 'alienswarm'
+        require 'steam/community/alien_swarm/alien_swarm_stats'
+        AlienSwarmStats.new(steam_id)
+      when 'cs:s'
+        require 'steam/community/css/css_stats'
+        CSSStats.new(steam_id)
+      when 'defensegrid:awakening'
+        require 'steam/community/defense_grid/defense_grid_stats'
+        DefenseGridStats.new(steam_id)
+      when 'dod:s'
+        require 'steam/community/dods/dods_stats'
+        DoDSStats.new(steam_id)
+      when 'l4d'
+        require 'steam/community/l4d/l4d_stats'
+        L4DStats.new(steam_id)
+      when 'l4d2'
+        require 'steam/community/l4d/l4d2_stats'
+        L4D2Stats.new(steam_id)
+      when 'portal2'
+        require 'steam/community/portal2/portal2_stats'
+        Portal2Stats.new steam_id
+      when 'tf2'
+        require 'steam/community/tf2/tf2_stats'
+        TF2Stats.new(steam_id)
+      else
+        new(steam_id, game_name)
+    end
+  end
+
+  # Creates a `GameStats` object and fetches data from the Steam Community for
+  # the given user and game
+  #
+  # @param [String, Fixnum] user_id The custom URL or the 64bit Steam ID of the
+  #        user
+  # @param [String] game_id The application ID or friendly name of the game
+  # @raise [SteamCondenserError] if the stats cannot be fetched
+  def initialize(user_id, game_id)
+    parse "#{self.class.base_url(user_id, game_id)}?xml=all"
+
+    @user = SteamId.new user_id, false
+
+    error = @xml_data['error']
+    raise SteamCondenserError, error unless error.nil?
+
+    @privacy_state = @xml_data['privacyState']
+    if public?
+      app_id        = @xml_data['game']['gameLink'].match(/http:\/\/steamcommunity\.com\/+app\/+([1-9][0-9]*)/)[1].to_i
+      @game         = SteamGame.new app_id, @xml_data['game']
+      @hours_played = @xml_data['stats']['hoursPlayed'] unless @xml_data['stats']['hoursPlayed'].nil?
+    end
+  end
+
+  # Returns the achievements for this stats' user and game
+  #
+  # If the achievements' data hasn't been parsed yet, parsing is done now.
+  #
+  # @return [Array<GameAchievement>] All achievements belonging to this game
+  def achievements
+    return unless public?
+
+    if @achievements.nil?
+      @achievements = Array.new
+      @xml_data['achievements']['achievement'].each do |achievement|
+        @achievements << GameAchievement.new(@user, @game, achievement)
+      end
+
+      @achievements_done = @achievements.reject{ |a| !a.unlocked? }.size
+    end
+
+    @achievements
+  end
+
+  # Returns the number of achievements done by this player
+  #
+  # If achievements haven't been parsed yet for this player and this game,
+  # parsing is done now.
+  #
+  # @return [Fixnum] The number of achievements completed
+  # @see #achievements
+  def achievements_done
+    achievements if @achievements_done.nil?
+    @achievements_done
+  end
+
+  # Returns the percentage of achievements done by this player
+  #
+  # If achievements haven't been parsed yet for this player and this game,
+  # parsing is done now.
+  #
+  # @return [Float] The percentage of achievements completed
+  # @see #achievements_done
+  def achievements_percentage
+    achievements_done.to_f / @achievements.size
+  end
+
+  # Returns the base Steam Communtiy URL for the stats contained in this object
+  #
+  # @return [String] The base URL used for queries on these stats
+  def base_url
+    self.class.base_url @user.id, @game.id
+  end
+
+  # Returns whether this Steam ID is publicly accessible
+  #
+  # @return [Boolean] `true` if this Steam ID is publicly accessible
+  def public?
+    @privacy_state == 'public'
+  end
+
+end