steam-condenser 1.3.9 → 1.3.10

data/pkg/steam-condenser-1.3.9/pkg/steam-condenser-1.3.8.1/lib/steam/community/game_weapon.rb

@@ -0,0 +1,41 @@
+# 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
+
+# A module implementing basic functionality for classes representing game
+# weapons
+#
+# @author Sebastian Staudt
+module GameWeapon
+
+  # Returns the number of kills achieved with this weapon
+  #
+  # @return [Fixnum] The number of kills achieved
+  attr_reader :kills
+
+  # Returns the unique identifier for this weapon
+  #
+  # @return [String] The identifier of this weapon
+  attr_reader :id
+
+  # Returns the number of shots fired with this weapon
+  #
+  # @return [Fixnum] The number of shots fired
+  attr_reader :shots
+
+  # Creates a new game weapon instance with the data provided
+  #
+  # @param [Hash<String, Object>] weapon_data The data representing this weapon
+  def initialize(weapon_data)
+    @kills = weapon_data['kills'].to_i
+  end
+
+  # Returns the average number of shots needed for a kill with this weapon
+  #
+  # @return [Float] The average number of shots needed for a kill
+  def avg_shots_per_kill
+    @shots.to_f / @kills
+  end
+
+end

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

@@ -0,0 +1,188 @@
+# 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 = most_recent_game_data.nil? ? {} : {
+        :difficulty  => most_recent_game_data['difficulty'],
+        :escaped     => (most_recent_game_data['bEscaped'] == 1),
+        :movie       => most_recent_game_data['movie'],
+        :time_played => most_recent_game_data['time']
+      }
+    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 = {
+        :campaign                 => favorites_data['campaign'],
+        :campaign_percentage      => favorites_data['campaignpct'].to_i,
+        :character                => favorites_data['character'],
+        :character_percentage     => favorites_data['characterpct'].to_i,
+        :level1_weapon            => favorites_data['weapon1'],
+        :level1_weapon_percentage => favorites_data['weapon1pct'].to_i,
+        :level2_weapon            => favorites_data['weapon2'],
+        :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 = {
+        :finales_survived            => lifetime_data['finales'].to_i,
+        :games_played                => lifetime_data['gamesplayed'].to_i,
+        :infected_killed             => lifetime_data['infectedkilled'].to_i,
+        :kills_per_hour              => lifetime_data['killsperhour'].to_f,
+        :avg_kits_shared             => lifetime_data['kitsshared'].to_f,
+        :avg_kits_used               => lifetime_data['kitsused'].to_f,
+        :avg_pills_shared            => lifetime_data['pillsshared'].to_f,
+        :avg_pills_used              => lifetime_data['pillsused'].to_f,
+        :time_played                 => lifetime_data['timeplayed'],
+        :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 = {
+        :gold_medals   => survival_data['goldmedals'].to_i,
+        :silver_medals => survival_data['silvermedals'].to_i,
+        :bronze_medals => survival_data['bronzemedals'].to_i,
+        :rounds_played => survival_data['roundsplayed'].to_i,
+        :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 = {
+        :revived                       => teamplay_data['revived'].to_i,
+        :most_revived_difficulty       => teamplay_data['reviveddiff'],
+        :avg_revived                   => teamplay_data['revivedavg'].to_f,
+        :avg_was_revived               => teamplay_data['wasrevivedavg'].to_f,
+        :protected                     => teamplay_data['protected'].to_i,
+        :most_protected_difficulty     => teamplay_data['protecteddiff'],
+        :avg_protected                 => teamplay_data['protectedavg'].to_f,
+        :avg_was_protected             => teamplay_data['wasprotectedavg'].to_f,
+        :friendly_fire_damage          => teamplay_data['ffdamage'].to_i,
+        :most_friendly_fire_difficulty => teamplay_data['ffdamagediff'],
+        :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 = {
+        :games_played                => versus_data['gamesplayed'].to_i,
+        :games_completed             => versus_data['gamescompleted'].to_i,
+        :finales_survived            => versus_data['finales'].to_i,
+        :points                      => versus_data['points'].to_i,
+        :most_points_infected        => versus_data['pointsas'],
+        :games_won                   => versus_data['gameswon'].to_i,
+        :games_lost                  => versus_data['gameslost'].to_i,
+        :highest_survivor_score      => versus_data['survivorscore'].to_i,
+        :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] = {
+          :special_attacks => versus_data["#{infected}special"].to_i,
+          :most_damage     => versus_data["#{infected}dmg"].to_i,
+          :avg_lifespan    => versus_data["#{infected}lifespan"].to_i
+        }
+      end
+    end
+
+    @versus_stats
+  end
+
+end

data/pkg/steam-condenser-1.3.9/pkg/steam-condenser-1.3.8.1/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.9/pkg/steam-condenser-1.3.8.1/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.9/pkg/steam-condenser-1.3.8.1/lib/steam/community/l4d/l4d2_stats.rb

@@ -0,0 +1,179 @@
+# 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.merge!({
+        :avg_adrenaline_shared   => lifetime_data['adrenalineshared'].to_f,
+        :avg_adrenaline_used     => lifetime_data['adrenalineused'].to_f,
+        :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 = {
+        :avg_cans_per_round => scavange_data['avgcansperround'].to_f,
+        :perfect_rounds     => scavange_data['perfect16canrounds'].to_i,
+        :rounds_lost        => scavange_data['roundslost'].to_i,
+        :rounds_played      => scavange_data['roundsplayed'].to_i,
+        :rounds_won         => scavange_data['roundswon'].to_i,
+        :total_cans         => scavange_data['totalcans'].to_i
+      }
+
+      @scavenge_stats[:maps] = {}
+      scavange_data['mapstats']['map'].each do |map_data|
+        map_stats = {
+          :avg_round_score     => map_data['avgscoreperround'].to_i,
+          :highest_game_score  => map_data['highgamescore'].to_i,
+          :highest_round_score => map_data['highroundscore'].to_i,
+          :name                => map_data['fullname'],
+          :rounds_played       => map_data['roundsplayed'].to_i,
+          :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 = {
+          :max_damage_per_life   => infected_data['maxdmg1life'].to_i,
+          :max_pours_interrupted => infected_data['maxpoursinterrupted'].to_i,
+          :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