Why the ELO Rating System Rocks

The ELO Rating System has been around for decades. It was originally used for rating chess players but is portable to other games and really fits in well with web games. We've been using it in various projects for 5 or 6 years.

Here's what it does:

• First of all, ELO is used to rate players based on skill level. It is generally used for two player games like chess. But with some modifications it can be used for more than that.
• A new player is assigned a default rating, say 1200.
• Two players compete and end with one of three results: player 1 wins, player 2 wins, tie.
• The two player's ratings are fed into an algorithm along with the end state of the game and a new rating for each player is returned.

If two players both rated 1200 played and player 1 wins. Then player 1 will have a rating of about 1205 and player 2 will be 1195.

What makes ELO so cool is what happens over time. Players that win a lot end up with higher ratings. But the higher rated player starts to see diminishing returns for defeating low ranked players. So in order for a high ranked player to increase his rank, he must defeat other higher ranked players. If a high ranked player loses to a low ranked player, he loses much more of his rating then he'd gain if he won the match.

Over time the game players will end up being rated based on their skill level rather than other factors.

Last year we (at Electrotank) created a series of 10 multiplayer minigames for The Daily Show with Jon Stewart. These multiplayer games support 2 to 4 players per game. Mike Grundvig wrote a modified ELO system to support this. The end result is a pretty cool rating system. Players can view their own ratings and the ratings of other players in the game.

You can download an example ELO algorithm written in AS2 by me here: DOWNLOAD

Or here is the code:

function determineRatingConstant(rating:Number) {
 var returnVal:Number = 10;
 return returnVal;
 if (rating<2000) {
  returnVal = 30;
 } else if (rating>=2000 && rating<2400) {
  returnVal = 20;
 } else {
  returnVal = 10;
 }
 return returnVal;
}
function calculateNewRating(player1Rating:Number, player2Rating:Number, player1Victory:Boolean):Number {
 var outcome:Number = 0;
 if (player1Victory) {
  outcome = 1;
 }
 //Takes the rating of two players, the outcome of the game, and returns the new rating of the first player  
 var d:Number = player1Rating-player2Rating;
 var exponent:Number = -d/400;
 var expected_outcome:Number = 1/(1+(Math.pow(10, exponent)));
 var k:Number = determineRatingConstant(player1Rating);
 var new_rating:Number = Math.round(player1Rating+k*(outcome-expected_outcome));
 return new_rating;
}

//Example - create a player and make him beat 1000 newbies. See how his rating plateaus
var player:Object = new Object();
player.rating = 2000;
for (var i=0;i<1000;++i) {
 player.rating = calculateNewRating(player.rating, 2100, true);
 trace("i: "+i);
 trace(player.rating);
}

ELO is O.G.!