async Task LadderInit()
{
await Save();
List <string> LadderGames = new List <string>();
if (File.Exists(Program.ladder_file))
{
LadderGames = JsonSerializer.Deserialize <List <string> >(File.ReadAllText(Program.ladder_file));
}
foreach (var ent in LadderGames)
{
MMgameNG game;
MMgameNG racegame;
(game, racegame) = MMrating.RateGame(ent, "Commander3v3True", this);
await Save();
await Save(game);
await SaveRace(racegame);
}
}
async Task <MMgameNG> CheckLobby(ObservableCollection <MMplayerNG> lobby, int lobbysize)
{
MMgameNG game = new MMgameNG();
var rng = lobby.Where(x => x.Random == true);
int minticks = lobby.OrderBy(o => o.Ticks).First().Ticks;
if (rng.Count() >= 2)
{
if (lobby.Count < lobbysize && minticks > Minticks)
{
int i = 0;
while (lobby.Count < lobbysize)
{
i++;
MMplayerNG mm = new MMplayerNG();
mm.Name = "Random" + i;
mm.Ticks = Minticks * 3 + 1;
mm.Accepted = true;
lobby.Add(mm);
}
}
}
if (lobby.Count >= lobbysize)
{
if (minticks > Minticks || lobby.Count > lobbysize)
{
_logger.LogInformation("Generating Matchup .. " + minticks);
game = await MMrating.GenMatch(lobby.ToList(), lobbysize);
if (game != null)
{
Interlocked.Increment(ref MMID);
game.ID = MMID;
var temp_pl = game.GetPlayers().FirstOrDefault();
game.Lobby = temp_pl.Mode + temp_pl.Mode2 + temp_pl.Ladder;
_logger.LogInformation("Game found: {0} ({1}) ", MMID, lobby.Count);
Dictionary <string, int> Server = new Dictionary <string, int>();
foreach (var pl in game.GetPlayers())
{
Match m = rx_rng.Match(pl.Name);
if (m.Success)
{
continue;
}
lock (_startUp.MMplayers[pl.Name])
{
_startUp.MMplayers[pl.Name].Game = game;
}
lock (lobby)
{
lobby.Remove(_startUp.MMplayers[pl.Name]);
if (lobby.Count == 0)
{
int p = 0;
foreach (var ent in Lobbies.Values)
{
if (ent != null && ent.Count > 0)
{
p++;
}
}
if (p == 0)
{
LobbyCheck = false;
}
}
}
if (!Server.ContainsKey(_startUp.MMplayers[pl.Name].Server))
{
Server.Add(_startUp.MMplayers[pl.Name].Server, 1);
}
else
{
Server[_startUp.MMplayers[pl.Name].Server]++;
}
}
game.Server = Server.OrderByDescending(o => o.Value).First().Key;
game.State.GameID = game.ID;
game.State.PropertyChanged += GameChanged;
lock (Games)
{
Games[game.ID] = game;
}
}
}
}
return(game);
}
public void RateStringResult(string result, DSladder rank)
{
RESgame gameres = new RESgame();
gameres.Winner = 0;
var teams = result.Split(new string[] { " vs " }, StringSplitOptions.None);
if (teams.Length == 2)
{
int t = 0;
int p = 0;
foreach (var team in teams)
{
Match m = rx_pl.Match(team);
while (m.Success)
{
RESplayer plres = new RESplayer();
plres.Team = t;
plres.Pos = p;
var plent = m.Groups[1].ToString().Split(',', StringSplitOptions.None);
int i = 0;
foreach (var ent in plent)
{
string myent = ent.Replace(" ", string.Empty);
myent = ent.Replace("(", string.Empty);
myent = ent.Replace(")", string.Empty);
if (i == 0)
{
plres.Name = myent;
}
if (i == 1)
{
plres.Race = myent;
}
if (i == 2)
{
plres.Kills = int.Parse(myent);
}
i++;
}
gameres.Players.Add(plres);
m = rx_pl.Match(m.Groups[2].ToString());
p++;
}
t++;
}
}
List <MMplayer> t1 = new List <MMplayer>();
List <MMplayer> t2 = new List <MMplayer>();
List <MMplayer> t1_race = new List <MMplayer>();
List <MMplayer> t2_race = new List <MMplayer>();
foreach (var pl in gameres.Players)
{
if (!rank.MMplayers.ContainsKey(pl.Name))
{
rank.MMplayers.TryAdd(pl.Name, new MMplayer(pl.Name));
}
if (!rank.MMraces.ContainsKey(pl.Race))
{
rank.MMraces.TryAdd(pl.Race, new MMplayer(pl.Race));
}
if (pl.Team == 0)
{
t1.Add(rank.MMplayers[pl.Name]);
t1_race.Add(rank.MMraces[pl.Race]);
}
if (pl.Team == 1)
{
t2.Add(rank.MMplayers[pl.Name]);
if (t1_race.Contains(rank.MMraces[pl.Race]))
{
t1_race.Remove(rank.MMraces[pl.Race]);
}
else
{
t2_race.Add(rank.MMraces[pl.Race]);
}
}
}
MMrating.RateGame(t1, t2);
MMrating.RateGame(t1_race, t2_race);
}
public async Task <MMgame> Report(dsreplay replay, string id)
{
MMgame mmgame = new MMgame();
int gid = int.Parse(id);
if (Replays.ContainsKey(gid))
{
Replays[gid].Add(replay);
}
else
{
Replays.TryAdd(gid, new ConcurrentBag <dsreplay>());
Replays[gid].Add(replay);
}
Save(Games[gid], replay);
lock (Games)
{
if (Games.ContainsKey(gid))
{
if (Games[gid].Reported == true)
{
return(Games[gid]);
}
}
replay.GenHash();
if (ReplayHash.Contains(replay.HASH))
{
//return null;
}
else
{
ReplayHash.Add(replay.HASH);
}
List <MMplayer> team1 = new List <MMplayer>();
List <MMplayer> team2 = new List <MMplayer>();
foreach (var pl in replay.PLAYERS)
{
MMplayer mmpl = new MMplayer();
if (MMplayers.ContainsKey(pl.NAME))
{
mmpl = MMplayers[pl.NAME];
}
else
{
mmpl.Name = "Dummy";
}
if (pl.TEAM == replay.WINNER)
{
team1.Add(mmpl);
}
else
{
team2.Add(mmpl);
}
}
MMgame repgame = new MMgame();
repgame = MMrating.RateGame(team1, team2);
repgame.ID = Games[gid].ID;
repgame.Quality = Games[gid].Quality;
repgame.Server = Games[gid].Server;
repgame.Reported = true;
Games[gid] = repgame;
}
Save();
return(Games[gid]);
}
async Task <MMgame> GenMatchup(ConcurrentDictionary <MMplayer, byte> lobby, int lobbysize)
{
return(await MMrating.GenMatch(lobby.Keys.ToList(), lobbysize));
}
