/*
    In this code, total_xp is the XP earned by the party. The party var
    is a list of mobs in the party.
 */

var/total_theshold = 0
var/list/threshold = new
var/n = party.len
var/mob/M
for(M in party)
  /*
      We don't want a character gaining levels too quickly, so calculate a
      piece of the pie for them. Their ideal pie piece should be 10% of what
      they need to get from the current level's XP to the next. I.e. if you
      need 20 XP total to get to level 2 and 60 to reach level 3, then the
      ideal "cut" is +4 XP (10% of 40) for a level 2 character.
   */
  threshold[M] = max(1, round((XPFormula(M.level + 1) - XPFormula(M.level)) / 10))
  total_threshold += threshold[M]

/*
    Small pie: Everyone's total cut is more than the group actually earned
    on the kill(s). This is common unless fighting a boss or something. In
    this case an even split is ideal, but if you're partying with a
    low-level character, an even split may be bigger than the cut they
    need. So take care of the smaller pie pieces first, and divvy up the
    rest evenly.
 */
if(total_threshold > total_xp)
  var/changed
  do
    changed = 0
    /*
        The even split is recalculated as we give out small pie pieces.
        This helps because someone who wasn't considered a "small picee"
        character before might be now. For instance if 32 XP have to be
        shared and one of the four characters needs only 2 XP, an even
        split would have been 8 XP per person. After handing out the 2 XP,
        what's left is 30 XP split three ways, or 10 XP each. If another
        guy in the party only needs 9 XP, he gets it right away.
     */
    var/minxp = round(total_xp / n)
    for(M in party)
      if(threshold[M] <= minxp)
        M.xp += threshold[M]
        total_threshold -= threshold[M]
        total_xp -= threshold[M]
        M.Levelup()
        threshold -= M
        ++changed
        if(--n > 0) minxp = round(total_xp / n)
  while(changed && n)

  /*
    Whatever's left of the pie, split evenly. Pick at random so that any
    extra XP left off by rounding get distributed randomly.
   */
  while(n)
    var/minxp = round(total_xp / n)
    M = pick(threshold)
    M.xp += minxp
    total_xp -= minxp
    M.Levelup()
    threshold -= M
    --n
  return

/*
    Big pie: Everyone's ideal cut is actually small enough that there's
    XP to spare, so supersize it: Give everyone a proportionally bigger
    piece. Pick at random while calculating portions, so rounding errors
    will be moot.
 */
while(n)
  M = pick(threshold)
  var/allotment = round(total_xp * threshold[M] / total_threshold)
  M.xp += allotment
  total_xp -= allotment
  total_threshold -= threshold[M]
  M.Levelup()
  threshold -= M
  --n