Forums » Everything else » scoring strategy advice needed

This may not be the most suitable forum for this kind of question, but I like Impact so what the hell. I'm sure some of you have already thought about scoring strategy.

So a friend and I are writing this multiplayer sports competition game for iOS. In the game, each player belongs to one of 10 classifications (from trainee to master). The number of game wins necessary to access a higher level is proportional to the level: at higher levels, more wins are needed to access the next level. It is also easy to go down in levels: a few losses (perhaps 2 or 3) and down one goes. Games can only be played between players of levels at most 1 step apart (e.g., level 6 vs level 6, or level 5 vs level 6, or level 7 vs level 6). Challenges can be issued to players of a higher level. Refusing too many challenges in a row triggers a loss of 1 level. Finally, form and sportsmanship affect scoring: fewer rounds to a game win result in a higher score. Win/loss ratios also affect the score.

Those were the ground rules that we set on paper. And now we are faced with the reality of it, and are wondering if we haven't strayed too far.

I am posting here in the hope that someone has some wisdom to offer on this (or useful links).

Thanks
Alex

A few hours of googling/reading/reflecting later...

We'll try the ELO rating system:
Intro to the ELO-based GO rating system
ELO rating in Chess
ELO rating system: start value?

and the winner is:
The Glicko System
(an improvement over the ELO system)

reminds me of the Mafia Wars PvP system. I'm not exactly sure what rating system was used by Zynga, but the characteristics are the same

- players can only battle players within the same level range ( plus minus 1~2 levels )
- bounty increases if we beat higher leveled players ( discourages farming )

this is actually very prevalent in all text-based RPG-titled games (like Storm8's World War, Vampires, and all the other variations )

what do you guys think of this simple formula, and any suggestions to build this further?

    // Player1 attacks Player 2 for gold
    var diff = Player1.attack - Player2.defense

    if (diff > 0) // win
        var bounty = diff/Player1.Attack * Player2.gold
    else{ // loss (tbd)
        
    }

Let's hope that no player with an attack of 0 attacks another one. :)

The game we are making does not force battle outcome to be determined by hit and defense points alone; skill--some might call it luck--comes into play, i.e., a weaker player may still defeat a stronger/more experienced one.

Simplifying ELO, we could try something like this:

Client usage:

gameOver: function (winner, loser)
{
	updatedRatings = ScoringSystem.postmortemRatings (winner, loser);
	winner.rating = updatedRatings.winner;
	loser.rating = updatedRatings.loser;
}

ScoringSystem:

// untested

ScoringSystem = {

  kFactor: 5;  // arbitrary: needs testing

  ratingClassification: function (playerRating)
  {
    if (playerRating > 800)
      return 3;
    else if (playerRating > 400)
      return 2;
    else if (playerRating > 200)
      return 1;
    else
      return 0;
  },

  fightPrediction: function (classification1, classification2)
  {
    var odds;

    var diff = abs(classification1 - classification2);
    if (diff == 3)
      odds = {strongerPlayer:0.92, weakerPlayer:0.08};
    else if (diff == 2)
      odds = {strongerPlayer:0.76, weakerPlayer:0.24};
    else if (diff == 1)
      odds = {strongerPlayer:0.64, weakerPlayer:0.36};
    else	//  same classification
      odds = {strongerPlayer:0.5, weakerPlayer:0.5};

    return odds;
  },

  postmortemRatings: function (winner, loser)
  {
    var results = {win:1, tie:0.5, loss:0};

    var winnerClass = this.ratingClassification (winner.rating);
    var loserClass = this.ratingClassification (loser.rating);

    var odds = this.fightPrediction(winnerClass, loserClass).odds;

    var updatedRatings;
    if (winner.rating > loser.rating)
    {
      updatedRatings.winner = winner.rating + this.kFactor*(results.win - odds.strongerPlayer); 
      updatedRatings.loser = loser.rating + this.kFactor*(results.win - odds.weakerPlayer);
    }
    else
    {
      updatedRatings.winner = winner.rating + this.kFactor*(results.win - odds.weakerPlayer); 
      updatedRatings.loser = loser.rating + this.kFactor*(results.win - odds.strongerPlayer);
    }			
    return updatedRatings;
  },

Of course, it would be great if Impact came with a multiplayer project sampler so that one could do real world testing of any multiplayer scoring system. ;)