Great idea agent.

I only see three potential problems.

1) Number input: In a big 5v5 you've got 10 players numbers to input, I suppose if you wanted you could write them all down before minimizing, but I see a potential problem for people who dont have a pen and paper handy, having to minimize and maximize repeatedly to input numbers. That could get a little cumbersome for some, and for me, well, my computer doesn't quite like repeatedly minimizing and maximizing Sins and tends to crash it if I put to much strain on it (just me, but maybe a few others too).

2) The previous aside, there's also the problem of SMURFS! While your system would work fine for secret smurfs (ie ones you dont KNOW are smurfs) it could create a problem with those who are Obviously smurfs, or known smurfs. Your program would have problems adjusting for this and people would certainly cry foul if teams were stacked with smurfs, creating longer delays and kinda defeating the whole purpose of streamlining the pug process with a program.

3) The third problem is getting players to accept the results. While it may not be a huge issue, I've noted that people don't often like the teams as they are picked by a single person, even if the teams seem fair. The whole pug process allows everyone to be involved in the decision making, leading to players being more comfortable with the results even if teams are a bit stacked.

Sorry to be such a naysayer, just trying to point out potential snags. I'd certainly use the program as much as I could if you made it.

It would help with the smurf problem I think if you did Games played to win ratio, or at least for players with less than 100 games played. (More than that you can expect skewed ratios based on older versions of the game and all the bugs associated with them) That way someone with 10 games played and 9 wins is rated much higher than someone with 30 games played and 16 wins.

Eitherway I think a program could give game hosts a general idea of the teams even though they may need to make an adjustment or two to adjust to noobs and smurfs.

I got bored during a blank period during school today, so I wrote up some data for an example of my previous idea and what would happen.  I put in a wide range of skill sets from a player with 9 games, to a simulation of JJ.  This featured 8 players for a 4v4.

The result was that one team had a skill rating of about 9700 while the other was about 6000.  The thing is though, almost all of the 9700 is JJ, and he can only expand so quickly.  Because of the way this system works, while he is the best, he is also stuck with the two worst players, which means that while he will win his individual, his allies could lose, which means that he will be outnumbered later in the game.  That means that his supreme rule over the game would be neutralized by superior numbers.

I'll post a screenshot of the spreadsheet I used to figure this out with later.

Also, another thing I was thinking about earlier, but didn't have time to post would be one that deals with Diplo specifically.  It requires input of the player's race as well as the above factors.  This is designed to account for the effect of pacts.  The reason for this is that by pact swapping, the TEC can increase the fleet capacity of all its allies by up to 40%.  The same principle can apply to other pacts.  Some pacts are just flat out awesome. 

For this reason, the computer would have to estimate any players with similar skill ratings (within 10% of each other) as identical to begin with.  It would then take into account their race and would attempt to fill both teams with equal amounts of the races so that one side doesn't dominate the other by being TEC, Vasari, and Advent while the other is just one or two races.

In either case, it would be nice if this sort of thing would work inside Sins itself.  That way, all players would have easy access to it and would be more convenient as it could easily pull data from their profiles.  It could also allow balancing of teams when players use random races so the game could know which race to place the player as.

Okay, I actually have an alpha version working.  I've run a few test cases, and it seems to work well with those.

The algorithm I use is this (my own custom):

1) Add up all player records (number of games played) and divide by 2.  This represents the theoretical "midpoint score" you would want both teams to have, ideally.  For example, say you are doing a 2v2.  Say the number of games played is 50, 100, 100, and 50.  The total is 300.  Divided by 2, that's 150.  So you'd want to make teams who's sum total records are as close to 150 as possible.

2) Generate a matrix of ALL POSSIBLE TEAMS, and add up all their records.

3) Grab all team configurations who's records are equally close to the "midpoint score" which was calculated earlier, and present them as solutions.

Here is the program output for the above "toy" example:

pug 50 100 100 50

1 1 2 2
1 2 1 2
2 1 2 1
2 2 1 1

Another "toy" example:

pug 100 200 300 400 500 600

1 2 1 2 2 1
1 2 2 1 1 2
1 2 2 1 2 1
2 1 1 2 1 2
2 1 1 2 2 1
2 1 2 1 1 2

A more realistic looking example (this wasn't contrived - I literally just threw some numbers down off the top of my head):

pug 78 34 56 233 366 500

1 2 1 2 2 1
2 1 2 1 1 2

If you add up the scores for those teams, you get 633 and 634.  The program was trying to balance around the theoretical midpoint of 633.5, and it nailed it.  It found 2 solutions out of all possible solutions which are closest to 633.5.  Since both of those solutions are equally close to 633.5, it presented them both.

Any interest out there to develop this further?

As far as 1 goes, you'll have the smurf problem whether you pug normally, or pug with a program.  If you know who the smurf is, you could use a number that is closer to his real record.

As far as 2 goes (inconvenience), I actually tested this in a couple of real pug games tonight.  As soon as all the bickering started as far as "who's gonna cap?" and "pick a number!" and "let's just do tvb" blah blah, I grabbed my cell phone, entered all the player records into it, spawned out, loaded up my program, entered the data, ran it, and came back.  They were still bickering, and hadn't even started drafting yet, and I already had results.  This was for both games I tested with.  Basically, it is more convienent and faster to just spawn out and run my program than sit there for 20 minutes talking.

As far as 3 goes, yeah a super-high ranked player may get paired with bad allies.  I'm not necessarily sure this is a bad thing.  But one thing you could do is just cap a guy's record down somewhat if it's just ridiculous.  Like if there is a JJ with 1000 games, and an Agent of Kharma as next-highest with 500, you might want to call JJ 700.  The program would also work if you just called anyone with 100-200 games a 1, 200-300 a 2, etc.  There are lot of ways to input the data, the program will work regardless.

We can't really do anything about these other aspects you mention (map variations, etc), nor should we.  We just want a "fair" pug program that is as fair or fairer than a bunch of people picking teams, and more convenient.  I can write the program, I already have a working alpha version.  I can include other algorithms besides the one I created.  At the end of the day, I'm just doing this out of the goodness of my own heart.  If people show interest I'll make it available.  If they don't, they can just keep pugging the way they are doing it now.

Nice spreadsheet work.

You and Deceiver (I believe it was him) have both suggested using wins/losses ratios in the calculation.  Frankly, I don't care either way, but just so you guys know, most pros that I know don't do that.  They say the wins/losses don't count, because there can be minidumps, disconnects, map fucks, and about a million other things to make that data unreliable.  They just look at pure numbers of games played.  The rationale is, if you've played a ton of games, you're probably good.  If you haven't, you probably aren't.

Having said that, like I said, I really don't care either way.  I'll program in whatever people want.

I'm willing to make the program utilize several different methods to generate the pug.  That way, you can just choose whatever option you want.  Something like:

1) Standard (basically how it is done now)

2) Agent of Kharma style

3) Volt_Cruelerz style

4) other...

What does everyone think?  We really need more comments from the pug players out there who would use this.

REQUEST FOR INFO:

I've done these things a million times, but I'm too bored to pay attention.  Can someone tell me EXACTLY how these pugs are drafted currently?  The information I want is how many picks the captains get on each turn.  I think that for 5v5 it's 1 2 2 2 2 1... right?  Is it ALWAYS done that way?  And what about for games with less players?  How is it done?

Well, weirdly enough, there seems to be no interest in this from anyone.  I would think people would be beating down my door to get their hands on a program like this.  Go figure.

I did code up the "standard" pug where you just flip a coin, choose whether to defer or not, etc, and it works fine... but I guess since so one seems interested....