steam-condenser 1.3.5 → 1.3.6

data/pkg/steam-condenser-1.3.5/lib/steam/community/l4d/abstract_l4d_stats.rb

@@ -0,0 +1,185 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2009-2013, Sebastian Staudt
+
+require 'steam/community/game_stats'
+
+# This module is a base for statistics for Left4Dead and Left4Dead 2. As both
+# games have more or less the same statistics available in the Steam Community
+# the code for both is pretty much the same.
+#
+# @author Sebastian Staudt
+module AbstractL4DStats
+
+  # The names of the special infected in Left4Dead
+  SPECIAL_INFECTED = %w(boomer hunter smoker tank)
+
+  # Returns a hash of statistics for this user's most recently played game
+  #
+  # @return [Hash<String, Object>] The most recent statistics for this user
+  attr_reader :most_recent_game
+
+  # Creates a new instance of statistics for both, Left4Dead and Left4Dead 2
+  # parsing basic common data
+  #
+  # @param [String] steam_id The custom URL or 64bit Steam ID of the user
+  # @param [String] game_name The name of the game
+  def initialize(steam_id, game_name)
+    super steam_id, game_name
+
+    if public?
+      most_recent_game_data = @xml_data['stats']['mostrecentgame']
+
+      @most_recent_game = {}
+      unless most_recent_game_data.nil?
+        @most_recent_game[:difficulty]  = most_recent_game_data['difficulty']
+        @most_recent_game[:escaped]     = (most_recent_game_data['bEscaped'] == 1)
+        @most_recent_game[:movie]       = most_recent_game_data['movie']
+        @most_recent_game[:time_played] = most_recent_game_data['time']
+      end
+    end
+  end
+
+  # Returns a hash of favorites for this user like weapons and character
+  #
+  # If the favorites haven't been parsed already, parsing is done now.
+  #
+  # @return [Hash<String, Object>] The favorites of this user
+  def favorites
+    return unless public?
+
+    if @favorites.nil?
+      favorites_data = @xml_data['stats']['favorites']
+
+      @favorites = {}
+      @favorites[:campaign]                 = favorites_data['campaign']
+      @favorites[:campaign_percentage]      = favorites_data['campaignpct'].to_i
+      @favorites[:character]                = favorites_data['character']
+      @favorites[:character_percentage]     = favorites_data['characterpct'].to_i
+      @favorites[:level1_weapon]            = favorites_data['weapon1']
+      @favorites[:level1_weapon_percentage] = favorites_data['weapon1pct'].to_i
+      @favorites[:level2_weapon]            = favorites_data['weapon2']
+      @favorites[:level2_weapon_percentage] = favorites_data['weapon2pct'].to_i
+    end
+
+    @favorites
+  end
+
+  # Returns a hash of lifetime statistics for this user like the time played
+  #
+  # If the lifetime statistics haven't been parsed already, parsing is done
+  # now.
+  #
+  # @return [Hash<String, Object>] The lifetime statistics for this user
+  def lifetime_stats
+    return unless public?
+
+    if @lifetime_stats.nil?
+      lifetime_data = @xml_data['stats']['lifetime']
+
+      @lifetime_stats = {}
+      @lifetime_stats[:finales_survived] = lifetime_data['finales'].to_i
+      @lifetime_stats[:games_played]     = lifetime_data['gamesplayed'].to_i
+      @lifetime_stats[:infected_killed]  = lifetime_data['infectedkilled'].to_i
+      @lifetime_stats[:kills_per_hour]   = lifetime_data['killsperhour'].to_f
+      @lifetime_stats[:avg_kits_shared]  = lifetime_data['kitsshared'].to_f
+      @lifetime_stats[:avg_kits_used]    = lifetime_data['kitsused'].to_f
+      @lifetime_stats[:avg_pills_shared] = lifetime_data['pillsshared'].to_f
+      @lifetime_stats[:avg_pills_used]   = lifetime_data['pillsused'].to_f
+      @lifetime_stats[:time_played]      = lifetime_data['timeplayed']
+
+      @lifetime_stats[:finales_survived_percentage] = @lifetime_stats[:finales_survived].to_f / @lifetime_stats[:games_played]
+    end
+
+    @lifetime_stats
+  end
+
+  # Returns a hash of Survival statistics for this user like revived teammates
+  #
+  # If the Survival statistics haven't been parsed already, parsing is done
+  # now.
+  #
+  # @return [Hash<String, Object>] The Survival statistics for this user
+  def survival_stats
+    return unless public?
+
+    if @survival_stats.nil?
+      survival_data = @xml_data['stats']['survival']
+
+      @survival_stats = {}
+      @survival_stats[:gold_medals]   = survival_data['goldmedals'].to_i
+      @survival_stats[:silver_medals] = survival_data['silvermedals'].to_i
+      @survival_stats[:bronze_medals] = survival_data['bronzemedals'].to_i
+      @survival_stats[:rounds_played] = survival_data['roundsplayed'].to_i
+      @survival_stats[:best_time]     = survival_data['besttime'].to_f
+    end
+
+    @survival_stats
+  end
+
+  # Returns a hash of teamplay statistics for this user like revived teammates
+  #
+  # If the teamplay statistics haven't been parsed already, parsing is done
+  # now.
+  #
+  # @return [Hash<String, Object>] The teamplay statistics for this
+  def teamplay_stats
+    return unless public?
+
+    if @teamplay_stats.nil?
+      teamplay_data = @xml_data['stats']['teamplay']
+
+      @teamplay_stats = {}
+      @teamplay_stats[:revived]                       = teamplay_data['revived'].to_i
+      @teamplay_stats[:most_revived_difficulty]       = teamplay_data['reviveddiff']
+      @teamplay_stats[:avg_revived]                   = teamplay_data['revivedavg'].to_f
+      @teamplay_stats[:avg_was_revived]               = teamplay_data['wasrevivedavg'].to_f
+      @teamplay_stats[:protected]                     = teamplay_data['protected'].to_i
+      @teamplay_stats[:most_protected_difficulty]     = teamplay_data['protecteddiff']
+      @teamplay_stats[:avg_protected]                 = teamplay_data['protectedavg'].to_f
+      @teamplay_stats[:avg_was_protected]             = teamplay_data['wasprotectedavg'].to_f
+      @teamplay_stats[:friendly_fire_damage]          = teamplay_data['ffdamage'].to_i
+      @teamplay_stats[:most_friendly_fire_difficulty] = teamplay_data['ffdamagediff']
+      @teamplay_stats[:avg_friendly_fire_damage]      = teamplay_data['ffdamageavg'].to_f
+    end
+
+    @teamplay_stats
+  end
+
+  # Returns a hash of Versus statistics for this user like percentage of rounds
+  # won
+  #
+  # If the Versus statistics haven't been parsed already, parsing is done now.
+  #
+  # @return [Hash<String, Object>] The Versus statistics for this user
+  def versus_stats
+    return unless public?
+
+    if @versus_stats.nil?
+      versus_data = @xml_data['stats']['versus']
+
+      @versus_stats = {}
+      @versus_stats[:games_played]                = versus_data['gamesplayed'].to_i
+      @versus_stats[:games_completed]             = versus_data['gamescompleted'].to_i
+      @versus_stats[:finales_survived]            = versus_data['finales'].to_i
+      @versus_stats[:points]                      = versus_data['points'].to_i
+      @versus_stats[:most_points_infected]        = versus_data['pointsas']
+      @versus_stats[:games_won]                   = versus_data['gameswon'].to_i
+      @versus_stats[:games_lost]                  = versus_data['gameslost'].to_i
+      @versus_stats[:highest_survivor_score]      = versus_data['survivorscore'].to_i
+
+      @versus_stats[:finales_survived_percentage] = @versus_stats[:finales_survived].to_f / @versus_stats[:games_played]
+
+      self.class.const_get(:SPECIAL_INFECTED).each do |infected|
+        @versus_stats[infected] = {}
+        @versus_stats[infected][:special_attacks] = versus_data["#{infected}special"].to_i
+        @versus_stats[infected][:most_damage]     = versus_data["#{infected}dmg"].to_i
+        @versus_stats[infected]['avg_lifespan']    = versus_data["#{infected}lifespan"].to_i
+      end
+    end
+
+    @versus_stats
+  end
+
+end

data/pkg/steam-condenser-1.3.5/lib/steam/community/l4d/abstract_l4d_weapon.rb

@@ -0,0 +1,56 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2009-2011, Sebastian Staudt
+
+require 'steam/community/game_weapon'
+
+# This abstract class is a base class for weapons in Left4Dead and Left4Dead 2
+# as the weapon stats for both games are very similar
+#
+# @author Sebastian Staudt
+module AbstractL4DWeapon
+
+  include GameWeapon
+
+  # Returns the overall accuracy of the player with this weapon
+  #
+  # @return [String] The accuracy of the player with this weapon
+  attr_reader :accuracy
+
+  # Returns the percentage of kills with this weapon that have been headshots
+  #
+  # @return [String] The percentage of headshots with this weapon
+  attr_reader :headshots_percentage
+
+  # Returns the ID of the weapon
+  #
+  # @return [String] The ID of the weapon
+  attr_reader :id
+
+  # Returns the percentage of overall kills of the player that have been
+  # achieved with this weapon
+  #
+  # @return [String] The percentage of kills with this weapon
+  attr_reader :kill_percentage
+
+  # Returns the number of shots the player has fired with this weapon
+  #
+  # @return [Fixnum] The number of shots with this weapon
+  attr_reader :shots
+
+  # Creates a new instance of weapon from the given XML data and parses common
+  # data for both, `L4DWeapon` and `L4D2Weapon`
+  #
+  # @param [String] weapon_name The name of this weapon
+  # @param [Hash<String, Object>] weapon_data The XML data for this weapon
+  def initialize(weapon_name, weapon_data)
+    super weapon_data
+
+    @accuracy             = weapon_data['accuracy'].to_f * 0.01
+    @headshots_percentage = weapon_data['headshots'].to_f * 0.01
+    @id                   = weapon_name
+    @shots                = weapon_data['shots'].to_i
+  end
+
+end

data/pkg/steam-condenser-1.3.5/lib/steam/community/l4d/l4d2_map.rb

@@ -0,0 +1,90 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2009-2011, Sebastian Staudt
+
+require 'steam/community/steam_id'
+require 'steam/community/l4d/l4d_map'
+
+# L4D2Map holds statistical information about maps played by a player in
+# Survival mode of Left4Dead 2. The basic information provided is more or less
+# the same for Left4Dead and Left4Dead 2, but parsing has to be done
+# differently.
+#
+# @author Sebastian Staudt
+class L4D2Map < L4DMap
+
+  # Returns statistics about the items used by the player on this map
+  #
+  # @return [Hash<Symbol, Fixnum>] The items used by the player
+  attr_reader :items
+
+  # Returns the number of special infected killed by the player grouped by
+  # the names of the special infected
+  #
+  # @return [Hash<Symbol, Fixnum>] The special infected killed by the player
+  attr_reader :kills
+
+  # Returns the SteamIDs of the teammates of the player in his best game on
+  # this map
+  #
+  # @return [Array<SteamId>] The SteamIDs of the teammates in the best game
+  attr_reader :teammates
+
+  # The names of the special infected in Left4Dead 2
+  INFECTED = %w{boomer charger common hunter jockey smoker spitter tank}
+
+  # The items available in Left4Dead 2
+  ITEMS    = %w{adrenaline defibs medkits pills}
+
+  # Creates a new instance of a map based on the given XML data
+  #
+  # The map statistics for the Survival mode of Left4Dead 2 hold much more
+  # information than those for Left4Dead, e.g. the teammates and items are
+  # listed.
+  #
+  # @param [Hash<String, Object>] map_data The XML data for this map
+  def initialize(map_data)
+    @id        = map_data['img'].match(/http:\/\/cdn\.steamcommunity\.com\/public\/images\/gamestats\/550\/(.*).jpg/)[1]
+    @name      = map_data['name']
+    @played    = (map_data['hasPlayed'].to_i == 1)
+
+    if @played
+      @best_time = map_data['besttimemilliseconds'].to_f / 1000
+
+      @teammates = []
+      map_data['teammates']['steamID64'].each do |teammate|
+        @teammates << SteamId.new(teammate, false)
+      end
+
+      @items = {}
+      ITEMS.each do |item|
+        @items[item] = map_data["items_#{item}"].to_i
+      end
+
+      @kills = {}
+      INFECTED.each do |infected|
+        @kills[infected] = map_data["kills_#{infected}"].to_i
+      end
+
+      case map_data['medal']
+        when 'gold'
+          @medal = L4D2Map::GOLD
+        when 'silver'
+          @medal = L4D2Map::SILVER
+        when 'bronze'
+          @medal = L4D2Map::BRONZE
+        else
+          @medal = L4D2Map::NONE
+      end
+    end
+  end
+
+  # Returns whether the player has already played this map
+  #
+  # @return [Boolean] `true` if the player has already played this map
+  def played?
+    @played
+  end
+
+end

data/pkg/steam-condenser-1.3.5/lib/steam/community/l4d/l4d2_stats.rb

@@ -0,0 +1,174 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2009-2013, Sebastian Staudt
+
+require 'steam/community/l4d/abstract_l4d_stats'
+require 'steam/community/l4d/l4d2_map'
+require 'steam/community/l4d/l4d2_weapon'
+
+# This class represents the game statistics for a single user in Left4Dead 2
+#
+# @author Sebastian Staudt
+class L4D2Stats < GameStats
+
+  include AbstractL4DStats
+
+  # The names of the special infected in Left4Dead 2
+  SPECIAL_INFECTED = SPECIAL_INFECTED + %w{charger jockey spitter}
+
+  # Returns the percentage of damage done by this player with each weapon type
+  #
+  # Available weapon types are `:melee`, `:pistols`, `:rifles` and `:shotguns`.
+  #
+  # @return [Hash<Symbol, Float>] The percentages of damage done with each
+  #         weapon type
+  attr_reader :damage_percentages
+
+  # Creates a `L4D2Stats` object by calling the super constructor with the game
+  # name `'l4d2'`
+  #
+  # @param [String, Fixnum] steam_id The custom URL or 64bit Steam ID of the
+  #        user
+  # @macro cacheable
+  def initialize(steam_id)
+    super steam_id, 'l4d2'
+
+    weapons_data = @xml_data['stats']['weapons']
+
+    @damage_percentages = {
+      :melee    => weapons_data['meleepctdmg'].to_f,
+      :pistols  => weapons_data['pistolspctdmg'].to_f,
+      :rifles   => weapons_data['bulletspctdmg'].to_f,
+      :shotguns => weapons_data['shellspctdmg'].to_f
+    }
+  end
+
+  # Returns a hash of lifetime statistics for this user like the time played
+  #
+  # If the lifetime statistics haven't been parsed already, parsing is done
+  # now.
+  #
+  # There are only a few additional lifetime statistics for Left4Dead 2
+  # which are not generated for Left4Dead, so this calls
+  # {AbstractL4DStats#lifetime_stats} first and adds some additional stats.
+  #
+  # @return [Hash<String, Object>] The lifetime statistics of the player in
+  #         Left4Dead 2
+  def lifetime_stats
+    return unless public?
+
+    if @lifetime_stats.nil?
+      super
+
+      lifetime_data = @xml_data['stats']['lifetime']
+      @lifetime_stats[:avg_adrenaline_shared]   = lifetime_data['adrenalineshared'].to_f
+      @lifetime_stats[:avg_adrenaline_used]     = lifetime_data['adrenalineused'].to_f
+      @lifetime_stats[:avg_defibrillators_used] = lifetime_data['defibrillatorsused'].to_f
+    end
+
+    @lifetime_stats
+  end
+
+  # Returns a hash of Scavenge statistics for this user like the number of
+  # Scavenge rounds played
+  #
+  # If the Scavenge statistics haven't been parsed already, parsing is done
+  # now.
+  #
+  # @return [Hash<String, Object>] The Scavenge statistics of the player
+  def scavenge_stats
+    return unless public?
+
+    if @scavenge_stats.nil?
+      scavange_data = @xml_data['stats']['scavenge']
+
+      @scavenge_stats = {}
+      @scavenge_stats[:avg_cans_per_round] = scavange_data['avgcansperround'].to_f
+      @scavenge_stats[:perfect_rounds]     = scavange_data['perfect16canrounds'].to_i
+      @scavenge_stats[:rounds_lost]        = scavange_data['roundslost'].to_i
+      @scavenge_stats[:rounds_played]      = scavange_data['roundsplayed'].to_i
+      @scavenge_stats[:rounds_won]         = scavange_data['roundswon'].to_i
+      @scavenge_stats[:total_cans]         = scavange_data['totalcans'].to_i
+
+      @scavenge_stats[:maps] = {}
+      scavange_data['mapstats']['map'].each do |map_data|
+        map_stats = {}
+        map_stats['avg_round_score']     = map_data['avgscoreperround'].to_i
+        map_stats['highest_game_score']  = map_data['highgamescore'].to_i
+        map_stats['highest_round_score'] = map_data['highroundscore'].to_i
+        map_stats['name']                = map_data['fullname']
+        map_stats['rounds_played']       = map_data['roundsplayed'].to_i
+        map_stats['rounds_won']          = map_data['roundswon'].to_i
+        @scavenge_stats[:maps][map_data['name']] = map_stats
+
+      end
+
+      @scavenge_stats[:infected] = {}
+      scavange_data['infectedstats']['special'].each do |infected_data|
+        infected_stats = {}
+        infected_stats['max_damage_per_life']   = infected_data['maxdmg1life'].to_i
+        infected_stats['max_pours_interrupted'] = infected_data['maxpoursinterrupted'].to_i
+        infected_stats['special_attacks']       = infected_data['specialattacks'].to_i
+        @scavenge_stats[:infected][infected_data['name']] = infected_stats
+      end
+    end
+
+    @scavenge_stats
+  end
+
+  # Returns a hash of Survival statistics for this user like revived teammates
+  #
+  # If the Survival statistics haven't been parsed already, parsing is done
+  # now.
+  #
+  # The XML layout for the Survival statistics for Left4Dead 2 differs a bit
+  # from Left4Dead's Survival statistics. So we have to use a different way
+  # of parsing for the maps and we use a different map class
+  # (`L4D2Map`) which holds the additional information provided in
+  # Left4Dead 2's statistics.
+  #
+  # @return [Hash<String, Object>] The Survival statistics of the player
+  def survival_stats
+    return unless public?
+
+    if @survival_stats.nil?
+      super
+      @survival_stats[:maps] = {}
+      @xml_data['stats']['survival']['maps']['map'].each do |map_data|
+        map = L4D2Map.new(map_data)
+        @survival_stats[:maps][map.id] = map
+      end
+    end
+
+    @survival_stats
+  end
+
+  # Returns a hash of `L4D2Weapon` for this user containing all Left4Dead 2
+  # weapons
+  #
+  # If the weapons haven't been parsed already, parsing is done now.
+  #
+  # @return [Hash<String, Object>] The weapon statistics for this player
+  def weapon_stats
+    return unless public?
+
+    if @weapon_stats.nil?
+      @weapon_stats = {}
+      @xml_data['stats']['weapons'].each do |weapon_data|
+        next if weapon_data.nil?
+
+        unless %w{bilejars molotov pipes}.include? weapon_data[0]
+          weapon = L4D2Weapon.new *weapon_data
+        else
+          weapon = L4DExplosive.new *weapon_data
+        end
+
+        @weapon_stats[weapon_data[0]] = weapon
+      end
+    end
+
+    @weapon_stats
+  end
+
+end