elo2 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 249ef1b338e702a1f19cf4ee6e4472c5ca3c22d9
+  data.tar.gz: 121bea75bb56e1cac834ad81559ecdfa60160c9c
+SHA512:
+  metadata.gz: 7a0c882c33002e9d5e52900587ad771934e4d8726f7e807c4ca931ee257fd889e7af23f8d8fd8f2b061d307a75134fc941c29d9ea59b4532574369c9b5ed5f9a
+  data.tar.gz: 929fde0b1092d16eb469067fe0dbc7ee3278199a3b1e807b88d8bb78c6c10052d57c3013d0b7963cbaf7aa698df4af01cb34c6bddfcf85cf0113b035f4d972ba

data/lib/elo.rb

@@ -0,0 +1,27 @@
+require 'elo/helper'
+require 'elo/configuration'
+require 'elo/game'
+require 'elo/player'
+require 'elo/rating'
+require 'elo/version'
+
+# See README.rdoc for general information about Elo.
+module Elo
+
+  # Accessor to the configuration object, which,
+  # should be instantiated only once (and automatically).
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  # Configure Elo in a block style.
+  # See Elo::Configuration for more details.
+  #
+  #   Elo.configure do |config|
+  #     config.attribute = :value
+  #   end
+  def self.configure(&block)
+    yield(config)
+  end
+
+end

data/lib/elo/configuration.rb

@@ -0,0 +1,83 @@
+module Elo
+
+  class Configuration
+
+    # This is the lower boundry of the rating you need to be a pro player.
+    # This setting is used in the FIDE k-factor rules. (default = 2400)
+    attr_accessor :pro_rating_boundry
+
+    # This is the lower boundry in the amount of games played to be a starting player
+    # This setting is used in the FIDE k-factor rules. (default = 30)
+    attr_accessor :starter_boundry
+
+    # The default k-factor is chosen when no k-factor rules apply.
+    # K-factor rules can be added by using the +k_factor+-method. (default = 15)
+    attr_accessor :default_k_factor
+
+    # This is the rating every player starts out with. (default = 1000)
+    attr_accessor :default_rating
+
+    # Use the settings that FIDE use for determening the K-factor.
+    # This is the case when all settings are unaltered. (default = true)
+    # 
+    # In short:
+    # 
+    # * K-factor is 25 when a player is a starter (less than 30 games played)
+    # * K-factor is 10 when a player is a pro (rating above 2400, now or in the past)
+    # * K-factor is 15 when a player in other cases
+    #
+    # If you want to use your own settings, either change the boundry settings,
+    # or set this setting to false and add you're own k-factor rules.
+    # K-factor rules can be added by using the +k_factor+-method.
+    attr_accessor :use_FIDE_settings
+
+    def initialize #:nodoc:
+      @pro_rating_boundry = 2400
+      @starter_boundry    = 30
+      @default_rating     = 1000
+      @default_k_factor   = 15
+      @use_FIDE_settings  = true
+    end
+
+    # Add a K-factor rule. The first argument is the k-factor value.
+    # The block should return a boolean that determines if this K-factor rule applies.
+    # The first rule that applies is the one determining the K-factor.
+    #
+    # The block is instance_eval'ed into the player, so you can access all it's
+    # properties directly. The K-factor is recalculated every time a match is played.
+    #
+    # By default, the FIDE settings are used (see: +use_FIDE_settings+). To implement
+    # that yourself, you could write:
+    #
+    #   Elo.configure do |config|
+    #     config.k_factor(10) { pro? or pro_rating? }
+    #     config.k_factor(25) { starter? }
+    #     config.default_k_factor = 15
+    #   end
+    #
+    def k_factor(factor, &rule)
+      k_factors << { :factor => factor, :rule => rule }
+    end
+
+    def applied_k_factors #:nodoc:
+      apply_fide_k_factors if use_FIDE_settings
+      k_factors
+    end
+
+    private
+
+    def k_factors
+      @k_factors ||= []
+    end
+
+    def apply_fide_k_factors
+      unless @applied_fide_k_factors
+        k_factor(10) { pro? or pro_rating? }
+        k_factor(25) { starter? }
+        @applied_fide_k_factors = true
+      end
+    end
+
+  end
+
+end

data/lib/elo/game.rb

@@ -0,0 +1,102 @@
+module Elo
+
+	# A Game is a collection of two Elo::Player objects
+	# and a result.
+	# Once the result is known, it propagates the new
+	# ratings to the players.
+  class Game
+
+    include Helper
+
+		# The result is the result of the match. It's a nubmer
+		# from 0 to 1 from the perspective of player +:one+.
+    attr_reader :result
+
+		# The first Elo::Player. The result is in perspecive of
+		# this player.
+    attr_reader :one
+
+		# The second Elo::Player.
+    attr_reader :two
+
+    # Every time a result is set, it tells the Elo::Player
+		# objects to update their scores.
+    def process_result(result)
+      @result = result
+      calculate
+    end
+    alias result= process_result
+
+    def calculate
+      if result
+        one.send(:played, self)
+        two.send(:played, self)
+        save
+      end
+      self
+    end
+
+		# Player +:one+ has won!
+		# This is a shortcut method for setting the score to 1
+    def win
+      process_result 1.0
+    end
+
+		# Player +:one+ has lost!
+		# This is a shortcut method for setting the score to 0
+    def lose
+      process_result 0.0
+    end
+
+		# It was a draw.
+		# This is a shortcut method for setting the score to 0.5
+    def draw
+      process_result 0.5
+    end
+
+    # You can override this method if you store each game
+		# in a database or something like that.
+		# This method will be called when a result is known.
+    def save
+    end
+
+		# Set the winner. Provide it with a Elo::Player. 
+    def winner=(player)
+      process_result(player == one ? 1.0 : 0.0)
+    end
+
+		# Set the loser. Provide it with a Elo::Player. 
+    def loser=(player)
+      process_result(player == one ? 0.0 : 1.0)
+    end
+
+		# Access the Elo::Rating objects for both players.
+    def ratings
+      @ratings ||= { one => rating_one, two => rating_two }
+    end
+
+    def inspect
+      "game"
+    end
+
+    private
+
+		# Create an Elo::Rating object for player one
+    def rating_one
+      Rating.new(:result        => result,
+                 :old_rating    => one.rating,
+                 :other_rating  => two.rating,
+                 :k_factor      => one.k_factor)
+    end
+
+		# Create an Elo::Rating object for player two
+    def rating_two
+      Rating.new(:result        => (1.0 - result),
+                 :old_rating    => two.rating,
+                 :other_rating  => one.rating,
+                 :k_factor      => two.k_factor)
+    end
+
+  end
+
+end

data/lib/elo/helper.rb

@@ -0,0 +1,29 @@
+module Elo
+
+	module Helper
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # Every object can be initialized with a hash,
+		# almost, but not quite, entirely unlike ActiveRecord.
+    def initialize(attributes = {})
+      attributes.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+      self.class.all << self
+    end
+
+    module ClassMethods
+
+      # Provides a list of all instantiated objects of the class.
+      def all
+        @all ||= []
+      end
+
+    end
+
+	end
+
+end

data/lib/elo/model.rb

@@ -0,0 +1,10 @@
+module Elo
+  module Model
+    # Poor man's activemodel
+    def initialize(attributes = {})
+      attributes.each do |key, value|
+        public_send("#{key}=", value)
+      end
+    end
+  end
+end

data/lib/elo/player.rb

@@ -0,0 +1,114 @@
+module Elo
+
+  # A player. You need at least two play a Game.
+  class Player
+
+    include Helper
+
+    # The rating you provided, or the default rating from configuration
+    def rating
+      @rating ||= Elo.config.default_rating
+    end
+
+		# The number of games played is needed for calculating the K-factor.
+    def games_played
+      @games_played ||= games.size
+    end
+
+		# A list of games played by the player.
+    def games
+      @games ||= []
+    end
+
+		# Is the player considered a pro, because his/her rating crossed
+		# the threshold configured? This is needed for calculating the K-factor.
+    def pro_rating?
+      rating >= Elo.config.pro_rating_boundry
+    end
+
+		# Is the player just starting? Provide the boundry for
+		# the amount of games played in the configuration.
+		# This is needed for calculating the K-factor.
+    def starter?
+      games_played < Elo.config.starter_boundry
+    end
+
+		# FIDE regulations specify that once you reach a pro status
+		# (see +pro_rating?+), you are considered a pro for life.
+		#
+		# You might need to specify it manually, when depending on
+		# external persistence of players.
+		#
+		#		Elo::Player.new(:pro => true)
+    def pro?
+      !!@pro
+    end
+
+    # You can override this method if you store each game
+		# in a database or something like that.
+		# This method will be called when a result is known.
+    def save
+    end
+
+		# Calculates the K-factor for the player.
+		# Elo allows you specify custom Rules (see Elo::Configuration).
+		#
+		# You can set it manually, if you wish:
+		#
+		#		Elo::Player.new(:k_factor => 10)
+		#
+		#	This stops this player from using the K-factor rules.
+    def k_factor
+      return @k_factor if @k_factor
+      Elo.config.applied_k_factors.each do |rule|
+        return rule[:factor] if instance_eval(&rule[:rule])
+      end
+      Elo.config.default_k_factor
+    end
+
+		# Start a game with another player. At this point, no
+		# result is known and nothing really happens.
+    def versus(other_player, options = {})
+      Game.new(options.merge(:one => self, :two => other_player)).calculate
+    end
+
+		# Start a game with another player and set the score
+		# immediately.
+    def wins_from(other_player, options = {})
+      versus(other_player, options).win
+    end
+
+		# Start a game with another player and set the score
+		# immediately.
+    def plays_draw(other_player, options = {})
+      versus(other_player, options).draw
+    end
+
+		# Start a game with another player and set the score
+		# immediately.
+    def loses_from(other_player, options = {})
+      versus(other_player, options).lose
+    end
+
+    def inspect
+      "player"
+    end
+
+    private
+
+    # A Game tells the players informed to update their
+    # scores, after it knows the result (so it can calculate the rating).
+    #
+    # This method is private, because it is called automatically.
+    # Therefore it is not part of the public API of Elo.
+    def played(game)
+      @games_played = games_played + 1
+      games << game
+      @rating = game.ratings[self].new_rating
+      @pro    = true if pro_rating?
+      save
+    end
+
+  end
+
+end

data/lib/elo/rating.rb

@@ -0,0 +1,59 @@
+module Elo
+
+	# This class calculates the rating between two players,
+	# but only from one persons perspective. You need two Rating-instances
+	# to calculate ratings for both players. Luckily, Elo::Game handles
+	# this for you automatically.
+  class Rating
+
+    include Helper
+
+		# The rating of the player you DON"T wish to calculate.
+    attr_reader :other_rating
+
+		# The rating of the player you wish to calculate.
+    attr_reader :old_rating
+
+		# The k-factor you wish to use for this calculation.
+    attr_reader :k_factor
+
+		# The new rating is... wait for it... the new rating!
+    def new_rating
+      old_rating + change.round
+    end
+
+		private
+
+		# The result of the match. 1 means that the player won, 0 means that the
+		# player lost and 0.5 means that it was a draw.
+    def result
+      raise "Invalid result: #{@result.inspect}" unless valid_result?
+      @result.to_f
+    end
+
+		# Only values between 0 and 1 are considered to be valid scores.
+    def valid_result?
+      (0..1).include? @result
+    end
+
+		# The expected score is the probably outcome of the match, depending
+		# on the difference in rating between the two players.
+		# 
+		# For more information visit
+		# {Wikipedia}[http://en.wikipedia.org/wiki/Elo_rating_system#Mathematical_details]
+    def expected
+      1.0 / ( 1.0 + ( 10.0 ** ((other_rating.to_f - old_rating.to_f) / 400.0) ) )
+    end
+
+		# The change is the points you earn or lose.
+		# 
+		# For more information visit
+		# {Wikipedia}[http://en.wikipedia.org/wiki/Elo_rating_system#Mathematical_details]
+    def change
+      k_factor.to_f * ( result.to_f - expected )
+    end
+
+
+  end
+
+end

data/lib/elo/version.rb

@@ -0,0 +1,3 @@
+module Elo
+  VERSION = "0.1.0"
+end

data/lib/elo2.rb

@@ -0,0 +1 @@
+require 'elo'

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: elo2
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- John Hawthorn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: The Elo rating system is a method for calculating the relative skill
+  levels of players in two-player games such as cess and Go.
+email:
+- john.hawthorn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/elo.rb
+- lib/elo/configuration.rb
+- lib/elo/game.rb
+- lib/elo/helper.rb
+- lib/elo/model.rb
+- lib/elo/player.rb
+- lib/elo/rating.rb
+- lib/elo/version.rb
+- lib/elo2.rb
+homepage: http://github.com/iain/elo
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: The Elo rating system is a method for calculating the relative skill levels
+  of players in two-player games such as cess and Go.
+test_files: []