public string AddAction(string playerId, List <int> actions)
{
Player player = CurrentPlayers.FirstOrDefault(p => p.PlayerId.Equals(playerId));
string result;
if (player != null)
{
if (!player.ActionRecorded)
{
player.ActionList = actions;
PlayersResponseCounter++;
result = $"Player action added, {CurrentPlayers.Count}/{MaxPlayers}";
if (PlayersResponseCounter >= CurrentPlayers.Count)
{
result = MakeMove();
}
}
else
{
result = "Player action add failed, action already added";
}
}
else
{
result = "Player action add failed, player not found";
}
return(result);
}
// Dessa 3 metoder hanterar listan
public void AddHumanPlayer(string playerName)
{
HumanPlayerAmount++;
PlayerModel humanPlayer = new PlayerModel();
humanPlayer.PlayerName = playerName;
CurrentPlayers.Add(humanPlayer);
}
private void AwardWinners(IChatClient chatClient, QuizQuestion question)
{
char correctLetter = question.LetterAssignment.Single(x => x.Value == question.CorrectAnswer).Key;
List <string> winners = CurrentPlayers.Where(x => x.Value == correctLetter).Select(x => x.Key).ToList();
chatClient.SendMessage($"Congratulations to {string.Join(", ", winners)}");
_currencyGenerator.AddCurrencyTo(winners, 10);
}
public void AddComPlayer()
{
ComPlayerAmount++;
PlayerModel newComPlayer = new PlayerModel();
newComPlayer.PlayerName = "Dator" + ComPlayerAmount.ToString();
CurrentPlayers.Add(newComPlayer);
}
private void ResetGame()
{
IsRunning = false;
_questionAskingStarted = false;
CurrentPlayers.Clear();
_automatedActionSystem.RemoveAction(_messageHint1);
_automatedActionSystem.RemoveAction(_messageHint2);
_automatedActionSystem.RemoveAction(_oneTimeActionEndingQuestion);
}
public void Refresh()
{
CurrentPlayers.Clear();
CurrentVessels.Clear();
Subspaces.Clear();
CurrentPlayers.AddRange(ServerContext.Clients.Values.Select(v => v.PlayerName));
CurrentVessels.AddRange(VesselStoreSystem.CurrentVessels.Values.Select(v => new VesselInfo(v)));
Subspaces.AddRange(WarpContext.Subspaces.Values);
}
public string UpdateGuess(ChatUser chatUser, string guess)
{
if (CurrentPlayers.ContainsKey(chatUser.DisplayName))
{
CurrentPlayers[chatUser.DisplayName] = guess.ToLower().Single();
return($"You updated your guess to {guess}, {chatUser.DisplayName}.");
}
return($"You aren't playing. Stop it, {chatUser.DisplayName}.");
}
public void Refresh()
{
CurrentPlayers.Clear();
CurrentVessels.Clear();
Subspaces.Clear();
StartTime = TimeContext.StartTime;
CurrentPlayers.AddRange(ServerContext.Clients.Values.Select(v => v.PlayerName));
CurrentVessels.AddRange(VesselStoreSystem.CurrentVessels.Values.Select(v => new VesselInfo(v)));
Subspaces.AddRange(WarpContext.Subspaces.Values);
BytesUsed = Environment.WorkingSet;
}
public string AddPlayer(string id)
{
string result;
if (CurrentPlayers.Count < MaxPlayers && !CurrentPlayers.Exists(player => player.PlayerId.Equals(id)))
{
Player newPlayer = new Player(CurrentPlayers.Count, id, CurrentPlayers.Count * 3, 1 + CurrentPlayers.Count, Rand);
CurrentPlayers.Add(newPlayer);
Player p;
switch (CurrentPlayers.Count)
{
case 3:
MaxX = 5;
MaxY = 4;
Grid = new int[MaxX, MaxY];
p = CurrentPlayers.First(d => d.PlayerNumber == 0);
p.X = 0;
p.Y = 0;
p = CurrentPlayers.First(d => d.PlayerNumber == 1);
p.X = 2;
p.Y = 3;
p = CurrentPlayers.First(d => d.PlayerNumber == 2);
p.X = 4;
p.Y = 0;
break;
case 4:
MaxX = 5;
MaxY = 5;
Grid = new int[MaxX, MaxY];
p = CurrentPlayers.First(d => d.PlayerNumber == 0);
p.X = 0;
p.Y = 0;
p = CurrentPlayers.First(d => d.PlayerNumber == 1);
p.X = 0;
p.Y = 4;
p = CurrentPlayers.First(d => d.PlayerNumber == 2);
p.X = 4;
p.Y = 0;
p = CurrentPlayers.First(d => d.PlayerNumber == 3);
p.X = 4;
p.Y = 4;
break;
}
result = "User Added";
}
else
{
result = "Too many players, sorry";
}
return(result);
}
/// <summary>
/// Resets the server information.
/// </summary>
public void Reset()
{
CurrentPlayers.Clear();
CurrentServerGameState = QlGameStates.Unspecified;
CurrentServerGameType = QlGameTypes.Unspecified;
CurrentServerId = string.Empty;
CurrentServerAddress = string.Empty;
IsQlConnectedToServer = false;
PlayerFollowedForAccuracy = string.Empty;
ScoreBlueTeam = 0;
ScoreRedTeam = 0;
Log.Write("Reset server information.", _logClassType, _logPrefix);
}
void OnReceived(IAsyncResult result)
{
// this is what had been passed into BeginReceive as the second parameter:
UdpClient socket = result.AsyncState as UdpClient;
// points towards whoever had sent the message:
IPEndPoint source = new IPEndPoint(0, 0);
// get the actual message and fill out the source:
byte[] message = socket.EndReceive(result, ref source);
// do what you'd like with `message` here:
string returnData = Encoding.ASCII.GetString(message);
Debug.Log("Got this: " + returnData);
latestMessage = JsonUtility.FromJson <Message>(returnData);
try{
switch (latestMessage.cmd)
{
case commands.NEW_CLIENT:
connectingPlayers = JsonUtility.FromJson <CurrentPlayers>(returnData);
Debug.Log("New Players: " + connectingPlayers.newPlayers);
break;
case commands.UPDATE:
lastestGameState = JsonUtility.FromJson <GameState>(returnData);
break;
case commands.DISC_CLIENT:
disconnectingPlayers = JsonUtility.FromJson <CurrentPlayers>(returnData);
Debug.Log("Players Left: " + disconnectingPlayers.newPlayers);
break;
case commands.ADD_ID:
info = JsonUtility.FromJson <UDPClient>(returnData);
Debug.Log("Gain client ID: " + info.ID);
break;
default:
Debug.Log("Error");
break;
}
}
catch (Exception e) {
Debug.Log(e.ToString());
}
// schedule the next receive operation once reading is done:
socket.BeginReceive(new AsyncCallback(OnReceived), socket);
}
public string RemovePlayer(string id)
{
string result;
if (!String.IsNullOrEmpty(id) && CurrentPlayers.RemoveAll(p => p.PlayerId.Equals(id)) == 1)
{
result = "Player removed";
}
else
{
result = "Player to remove not found";
}
return(result);
}
public JoinGameResult AttemptToJoin(ChatUser chatUser)
{
if (CurrentPlayers.Any(x => x.Key.EqualsIns(chatUser.DisplayName)))
{
return(QuizJoinResults.AlreadyInGameResult(chatUser.DisplayName));
}
if (!IsGameJoinable)
{
return(QuizJoinResults.NotJoinTimeResult(chatUser.DisplayName));
}
CurrentPlayers[chatUser.DisplayName] = ' ';
return(QuizJoinResults.SuccessJoinResult(chatUser.DisplayName));
}
/// <summary>
/// Gets the team.
/// </summary>
/// <param name="t">The Team enum.</param>
/// <returns>A list of <see cref="PlayerInfo"/> objects for a given Team enum.</returns>
public List <PlayerInfo> GetTeam(Team t)
{
var team = CurrentPlayers.Where(player => player.Value.Team.Equals(t))
.Select(player => player.Value)
.ToList();
var sb = new StringBuilder();
foreach (var player in team)
{
sb.Append(string.Format("{0}, ", player.ShortName));
}
Log.Write(string.Format("Internally retrieving {0} stored players for {1} team: {2}",
team.Count, t, sb.ToString().TrimEnd(',', ' ')), _logClassType, _logPrefix);
return(team);
}
public void OnGameOver(List <int> failedPlayers)
{
for (var i = 0; i < failedPlayers.Count; i++)
{
var player = CurrentPlayers.First(p => p.playerId == failedPlayers[i]);
player.score += i;
}
var winner = CurrentPlayers.Where(p => !failedPlayers.Contains(p.playerId)).First();
winner.score += failedPlayers.Count;
//TODO: 发点通知啥的
SceneManager.LoadSceneAsync("Scenes/PlayerRoom/Room", LoadSceneMode.Single);
}
public string AttemptToLeave(ChatUser chatUser)
{
if (!IsRunning)
{
return("You can't leave a game that isn't being played."); // TODO: this needs to be a whisper
}
if (_questionAskingStarted)
{
return("The questions have started, you can't leave."); // TODO: this needs to be a whisper
}
if (CurrentPlayers.ContainsKey(chatUser.DisplayName))
{
CurrentPlayers.Remove(chatUser.DisplayName);
return($"{chatUser.DisplayName} has quit the game.");
}
return($"You aren't in this game, {chatUser.DisplayName}"); // TODO: this needs to be a whisper
}
public void ClearPlayerList()
{
CurrentPlayers.Clear();
ComPlayerAmount = 0;
HumanPlayerAmount = 0;
}
private void ResolveAttack(int cardNumber)
{
//Dictionary<string, Tuple<int, List<Tuple<int,int>>>> playersAttacks = new Dictionary<string, Tuple<int, List<Tuple<int,int>>>>(); //dmg, kernel
Dictionary <string, Tuple <int, int> > playersPositions = new Dictionary <string, Tuple <int, int> >();
foreach (var player in CurrentPlayers)
{
playersPositions[player.PlayerId] = new Tuple <int, int>(player.X, player.Y);
}
foreach (var player in CurrentPlayers)
{
List <Tuple <int, int> > affectedPositions = new List <Tuple <int, int> >();
var card = CardsList[player.ActionList[cardNumber]];
if (card.Dmg != 0)
{
player.Animation = AnimationStatus.Attack;
int sizePerSide = card.DmgKernel.GetLength(0) / 2;
for (int y = 0; y < card.DmgKernel.GetLength(0); y++)
{
for (int x = 0; x < card.DmgKernel.GetLength(0); x++)
{
if (card.DmgKernel[y, x])
{
affectedPositions.Add(new Tuple <int, int>(player.X + x - sizePerSide, player.Y + y - sizePerSide));
}
}
}
//playersAttacks[player.PlayerId] = new Tuple<int, bool[,]>(card.Dmg, card.DmgKernel);
//player.Animation = AnimationStatus.Attack;
}
foreach (var position in playersPositions)
{
foreach (var pos in affectedPositions)
{
if (pos.Item1 >= 0 && pos.Item1 < MaxX && pos.Item2 >= 0 && pos.Item2 < MaxY && Grid[pos.Item1, pos.Item2] == -1)
{
Grid[pos.Item1, pos.Item2] = -2;
}
}
if (affectedPositions.Contains(position.Value))
{
Player currentPlayer = CurrentPlayers.First(d => d.PlayerId == position.Key);
currentPlayer.HP -= card.Dmg;
switch (currentPlayer.Animation)
{
case AnimationStatus.Idle:
currentPlayer.Animation = AnimationStatus.IdleHurt;
break;
case AnimationStatus.Move:
currentPlayer.Animation = AnimationStatus.MoveHurt;
break;
case AnimationStatus.Attack:
currentPlayer.Animation = AnimationStatus.AttackHurt;
break;
case AnimationStatus.Colide:
currentPlayer.Animation = AnimationStatus.ColideHurt;
break;
}
if (currentPlayer.HP <= 0)
{
int pN = currentPlayer.PlayerNumber;
//currentPlayer.Animation = AnimationStatus.Death;
for (int i = 0; i < MaxX; i++)
{
for (int j = 0; j < MaxY; j++)
{
if (Grid[i, j] == pN)
{
Grid[i, j] = -2;
}
}
}
CurrentPlayers.Remove(currentPlayer);
//Status = 0; //game ended (specjalna wiadomość?)
}
}
}
}
}
private void ResetGame()
{
IsRunning = false;
_questionAskingStarted = false;
CurrentPlayers.Clear();
}
private bool PopulateTeams()
{
MySqlConnection cnn = new MySqlConnection("SERVER=cis4250.cpnptclkba5c.ca-central-1.rds.amazonaws.com;DATABASE=fantasySportsApplication;UID=teamOgre;PWD=sportsApp123;Connection Timeout=5");
cnn.Open();
MySqlCommand cmdSql = new MySqlCommand("SELECT league_id, league_name, max_teams, private FROM league;", cnn);
MySqlDataReader rdr = cmdSql.ExecuteReader();
int LeagueID;
String LeagueName;
int MaxPlayers;
int Private;
int CurrentPlayers;
while (rdr.Read())
{
LeagueID = rdr.GetInt32(0);
LeagueName = rdr.GetString(1);
MaxPlayers = rdr.GetInt32(2);
Private = rdr.GetInt32(3);
dgvLeagues.Rows.Add("", LeagueName, Private, MaxPlayers, "", "Join Now", LeagueID);
}
rdr.Close();
foreach (DataGridViewRow row in dgvLeagues.Rows)
{
row.DefaultCellStyle.BackColor = Color.LightGreen;
cmdSql = new MySqlCommand(String.Format("SELECT COUNT(*) FROM league_roster WHERE league_id = {0};", row.Cells[6].Value.ToString()), cnn);
rdr = cmdSql.ExecuteReader();
rdr.Read();
CurrentPlayers = rdr.GetInt32(0);
if (CurrentPlayers.ToString() == row.Cells[3].Value.ToString())
{
row.DefaultCellStyle.BackColor = Color.LightPink;
}
row.Cells[3].Value = CurrentPlayers.ToString() + " / " + row.Cells[3].Value.ToString();
rdr.Close();
cmdSql = new MySqlCommand(String.Format("SELECT COUNT(*) FROM league_roster WHERE league_id = {0} AND participant_id = {1};", row.Cells[6].Value.ToString(), CurrentID), cnn);
rdr = cmdSql.ExecuteReader();
rdr.Read();
if (rdr.GetInt32(0) > 0)
{
row.Cells[4].Value = "Already Joined";
row.DefaultCellStyle.BackColor = Color.LightPink;
}
else
{
row.Cells[4].Value = "Not Yet Joined";
}
rdr.Close();
switch (row.Cells[2].Value.ToString())
{
case "0":
row.Cells[0].Value = "";
row.Cells[2].Value = "Public";
break;
case "1":
row.Cells[0].Value = "🔒";
row.Cells[2].Value = "Private";
break;
}
}
cnn.Close();
return(true);
}
protected virtual void ProcessJsonEvent(JObject evt)
{
var eventName = (string)evt["event"];
CommunicationLogger.LogDebug("received event {EventName}", eventName);
bool playNow = false;
switch (eventName)
{
case CurrentPlayerEventName:
{
// my turn? not my turn? (legacy)
var currentPlayer = (string)evt["player"];
playNow = (currentPlayer == ConnectionManager.MyNickname);
break;
}
case CurrentPlayerOrderEventName:
{
// my turn? not my turn?
var upcomingPlayers = (JArray)evt["order"];
playNow = ((string)upcomingPlayers[0] == ConnectionManager.MyNickname);
NextPlayer = (upcomingPlayers.Count > 1)
? (string)upcomingPlayers[1]
: null;
// if upcomingPlayers.Count <= 2, then NextPlayer == PreviousPlayer
PreviousPlayer = (upcomingPlayers.Count > 2)
? (string)upcomingPlayers.Last
: null;
// if upcomingPlayers.Count <= 2, then NextButOnePlayer == me
NextButOnePlayer = (upcomingPlayers.Count > 2)
? (string)upcomingPlayers[2]
: null;
CurrentPlayers.Clear();
CurrentPlayers.UnionWith(upcomingPlayers.Select(tok => (string)tok));
break;
}
case CardCountsEventName:
{
var cardCounts = (JArray)evt["counts"];
CurrentCardCounts.Clear();
foreach (var playerAndCount in cardCounts.OfType <JObject>())
{
var player = (string)playerAndCount["player"];
var count = (int)playerAndCount["count"];
CurrentCardCounts[player] = count;
}
break;
}
case TopCardEventName:
{
var currentCardName = (string)evt["current_card"];
TopCard = CardUtils.ParseColorAndValue(currentCardName).Value;
break;
}
case HandInfoEventName:
{
var handCards = (JArray)evt["hand"];
CurrentHand = handCards
.Select(e => CardUtils.ParseColorAndValue((string)e))
.Where(cav => cav.HasValue)
.Select(cav => cav.Value)
.ToList();
if (LastHandCount > 0 && Config.ManyCardsCurseThreshold > 0 && CurrentHand.Count - LastHandCount >= Config.ManyCardsCurseThreshold)
{
StrategyLogger.LogDebug("cursing because of overfilled hand");
Curse();
}
LastHandCount = CurrentHand.Count;
break;
}
case CardDrawnEventName:
{
var player = (string)evt["player"];
if (player == ConnectionManager.MyNickname)
{
playNow = true;
}
break;
}
}
if (playNow)
{
PlayACard();
}
}
protected virtual void HandleChannelMessage(object sender, IChannelMessageEventArgs args, MessageFlags flags)
{
if (flags.HasFlag(MessageFlags.UserBanned))
{
return;
}
if (args.SenderNickname == ConnectionManager.MyNickname)
{
return;
}
if (Config.UnoChannel != args.Channel)
{
return;
}
if (IsBotCommand(args.Message, "?join"))
{
ConnectionManager.SendChannelMessage(args.Channel, "!botjoin");
// don't curse if the number of cards jumps up from 1 to 7 ;)
LastHandCount = 0;
return;
}
if (IsBotCommand(args.Message, "?leave"))
{
ConnectionManager.SendChannelMessage(args.Channel, "!leave");
return;
}
if (args.Message.StartsWith("??color "))
{
var denyColor = false;
if (!CurrentPlayers.Contains(args.SenderNickname))
{
// player is not taking part
StrategyLogger.LogDebug("denying {Nickname}'s color request because they are a spectator", args.SenderNickname);
denyColor = true;
}
if (CurrentCardCounts.Values.All(v => v > Config.PlayToWinThreshold))
{
// everybody has more than two cards
StrategyLogger.LogDebug("denying {Nickname}'s color request because everybody has more than {CardCount} cards", args.SenderNickname, Config.PlayToWinThreshold);
denyColor = true;
}
if (CurrentCardCounts.ContainsKey(args.SenderNickname) && CurrentCardCounts[args.SenderNickname] <= Config.PlayToWinThreshold)
{
// the person who is asking has two cards or less
StrategyLogger.LogDebug("denying {Nickname}'s color request because they have {CardThreshold} cards or fewer ({CardCount})", args.SenderNickname, Config.PlayToWinThreshold, CurrentCardCounts[args.SenderNickname]);
denyColor = true;
}
if (CurrentHand.Count <= Config.PlayToWinThreshold)
{
// I have two cards or less
StrategyLogger.LogDebug("denying {Nickname}'s color request because I have {CardThreshold} cards or fewer ({CardCount})", args.SenderNickname, Config.PlayToWinThreshold, CurrentHand.Count);
denyColor = true;
}
if (denyColor)
{
ConnectionManager.SendChannelMessageFormat(args.Channel, "Sorry, {0}, no can do.", args.SenderNickname);
return;
}
var colorString = args.Message.Substring(("??color ").Length);
var color = CardUtils.ParseColor(colorString);
if (!color.HasValue || color == CardColor.Wild)
{
ConnectionManager.SendChannelMessage(args.Channel, "Uhh, what color is that?");
return;
}
ColorRequest = color;
// can I change the color?
if (CurrentHand.Any(c => c.Color == CardColor.Wild))
{
ConnectionManager.SendChannelMessageFormat(args.Channel, "Yeah, I think that's doable, {0}.", args.SenderNickname);
}
else if (CurrentHand.Any(c => c.Color == color))
{
ConnectionManager.SendChannelMessageFormat(args.Channel, "No color changers, but I'll try, {0}.", args.SenderNickname);
}
else
{
ConnectionManager.SendChannelMessageFormat(args.Channel, "Ain't got the cards, {0}, but I'll try...", args.SenderNickname);
}
return;
}
var runtimeTweakMatch = RuntimeTweakPattern.Match(args.Message);
if (runtimeTweakMatch.Success)
{
if (!Config.RuntimeTweakable)
{
ConnectionManager.SendChannelMessageFormat(args.Channel, "Sorry, {0}, I'm not allowed to do that.", args.SenderNickname);
return;
}
try
{
ConfigTweaking.TweakConfig(Config, runtimeTweakMatch.Groups["property"].Value, runtimeTweakMatch.Groups["value"].Value);
}
catch (ArgumentException ae)
{
ConnectionManager.SendChannelMessageFormat(args.Channel, "That didn't work out, {0}: {1}", args.SenderNickname, ae.Message);
return;
}
ConnectionManager.SendChannelMessageFormat(args.Channel, "{0}: Done.", args.SenderNickname);
return;
}
}
public static void Update(IMongoDatabase db)
{
// db.DropCollection("Games");
// db.DropCollection("W1Games");
// db.DropCollection("RunningGames");
db.DropCollection("GameWeeks");
Ladder.Clear();
CurrentPlayers.Clear();
OldPlayers.Clear();
// Have to get them piecemeal because we've hit the limit of how many games snellman will return
List <Game> AllGames = GetGamesFromSnellman("FireIceLadderW0%")
.Concat(GetGamesFromSnellman("FireIceLadderW1%"))
.Concat(GetGamesFromSnellman("FireIceLadderW2%"))
.Concat(GetGamesFromSnellman("FireIceLadderW3%"))
.Concat(GetGamesFromSnellman("FireIceLadderW4%"))
.Concat(GetGamesFromSnellman("FireIceLadderW5%"))
.Concat(GetGamesFromSnellman("FireIceLadderW6%"))
.Concat(GetGamesFromSnellman("FireIceLadderW7%"))
.Concat(GetGamesFromSnellman("FireIceLadderW8%"))
.Concat(GetGamesFromSnellman("FireIceLadderW9%"))
.ToList();
// First create GameWeek 1
GameWeek GW1 = new GameWeek();
GW1.Name = "Week 1";
GW1.ProcessingOrder = 1;
GW1.Games = new List <Game>();
List <Game> FinishedW1Games = AllGames.Where(x => (x.WeekNumber == 1 && x.finished == 1 && x.aborted == 0))
.OrderByDescending(x => x.seconds_since_update).ToList();
foreach (Game GameData in FinishedW1Games)
{
ProcessGame(GameData);
GameData.index = GW1.Games.Count();
GW1.Games.Add(GameData);
}
for (int rank = 1; rank < 5; rank++)
{
foreach (Game GameData in FinishedW1Games)
{
foreach (GamePlayer gameplayer in GameData.GamePlayers.Where(x => x.rank == rank && x.dropped != 1).OrderBy(x => x.playername))
{
Ladder.Add(new LadderPlayer(gameplayer.playername, Ladder.Count() + 1));
}
}
}
GW1.Ladder = Ladder;
SaveGameWeek(GW1, db);
foreach (LadderPlayer LadderPlayer in Ladder)
{
LadderPlayer.OldPosition = LadderPlayer.Position;
}
// Now gameweeks 2 - 7
int i = 2;
GameWeek CurrentGW = new GameWeek();
CurrentGW.ProcessingOrder = i;
CurrentGW.Name = "Week ~" + i.ToString();
CurrentGW.Games = new List <Game>();
foreach (Game GameData in AllGames.Where(x => (x.aborted == 0 && x.WeekNumber > 1 && x.WeekNumber < 8))
.OrderByDescending(x => x.seconds_since_update))
{
ProcessGame(GameData);
if (CurrentGW.Games.Count() > 15)
{
CurrentGW.Ladder = Ladder;
SaveGameWeek(CurrentGW, db);
foreach (LadderPlayer LadderPlayer in Ladder)
{
LadderPlayer.OldPosition = LadderPlayer.Position;
}
i = Math.Min(7, i + 1);
CurrentGW.Name = "Week ~" + i.ToString();
CurrentGW.Games.Clear();
CurrentGW.ProcessingOrder = i;
}
GameData.index = CurrentGW.Games.Count();
CurrentGW.Games.Add(GameData);
if (GameData.finished == 1)
{
AddGameToLadder(GameData);
}
}
CurrentGW.Ladder = Ladder;
SaveGameWeek(CurrentGW, db);
foreach (LadderPlayer LadderPlayer in Ladder)
{
LadderPlayer.OldPosition = LadderPlayer.Position;
}
// Now gameweeks 8+
int CurrentWeekNumber = 8;
CurrentPlayers = AllGames.Where(x => (x.aborted == 0 && x.WeekNumber == CurrentWeekNumber)).SelectMany(x => x.usernames).ToList();
CurrentGW.ProcessingOrder = CurrentWeekNumber;
CurrentGW.Name = "Week " + CurrentWeekNumber.ToString();
CurrentGW.Games.Clear();
foreach (Game GameData in AllGames.Where(x => (x.aborted == 0 && x.WeekNumber >= 8 && x.WeekNumber < 38))
.OrderBy(x => x.WeekNumber).ThenByDescending(x => x.GameNumber))
{
ProcessGame(GameData);
if (GameData.WeekNumber != CurrentWeekNumber)
{
CurrentGW.Ladder = PurgeNonPlayers(Ladder, AllGames, CurrentWeekNumber);
SaveGameWeek(CurrentGW, db);
foreach (LadderPlayer LadderPlayer in Ladder)
{
LadderPlayer.OldPosition = LadderPlayer.Position;
}
CurrentWeekNumber = GameData.WeekNumber;
CurrentPlayers = AllGames.Where(x => (x.aborted == 0 && x.WeekNumber == CurrentWeekNumber)).SelectMany(x => x.usernames).ToList();
CurrentGW.Name = "Week " + CurrentWeekNumber.ToString();
CurrentGW.Games.Clear();
CurrentGW.ProcessingOrder = CurrentWeekNumber;
}
GameData.index = CurrentGW.Games.Count();
CurrentGW.Games.Add(GameData);
if (GameData.finished == 1)
{
AddGameToLadder(GameData);
}
}
CurrentGW.Ladder = PurgeNonPlayers(Ladder, AllGames, CurrentWeekNumber);
SaveGameWeek(CurrentGW, db);
foreach (LadderPlayer LadderPlayer in Ladder)
{
LadderPlayer.OldPosition = LadderPlayer.Position;
}
// Now gameweeks 38 onwards
// Process all games in a gameweek at once and then order everyone properly at the end
// No longer purge or drop down non players - just hide them somehow (probably in the front end)
while (true)
{
CurrentWeekNumber += 1;
CurrentGW.Games = AllGames.Where(x => (x.aborted == 0 && x.WeekNumber == CurrentWeekNumber)).OrderBy(x => x.GameNumber).ToList();
if (CurrentGW.Games.Count == 0)
{
break;
}
CurrentGW.Name = "Week " + CurrentWeekNumber.ToString();
CurrentGW.ProcessingOrder = CurrentWeekNumber;
int InitialLadderSize = Ladder.Max(x => x.Playing ? x.Position : 0);
if (InitialLadderSize == 0)
{
InitialLadderSize = Ladder.Max(x => x.Position);
}
foreach (LadderPlayer LP in Ladder)
{
LP.Playing = false;
LP.OldPosition = LP.Position;
// see note below
if (CurrentWeekNumber == 38)
{
LP.TemporaryPositionDouble = LP.Position;
}
}
foreach (Game GameData in CurrentGW.Games.OrderByDescending(x => x.GameNumber))
{
ProcessGame(GameData);
GameData.index = 0 - GameData.GameNumber;
UpdateLadderBasedOnGame(GameData, InitialLadderSize + 1);
}
// then put everyone in the right place on the ladder
// NOTE that for GW 38 we have to account for the fact everyone's moving a long way up the ladder. This means moving non-players up too, hence the "|| CurrentWeekNumber = 38". This works because we've set their temporary position above too.
int newpos = 1;
foreach (LadderPlayer LadderPlayer in Ladder.Where(x => x.Playing || CurrentWeekNumber == 38).OrderBy(x => x.TemporaryPositionDouble).ThenBy(x => x.OldPosition).ThenBy(x => x.Games.Last().Value.GameNumber).ThenBy(x => x.Games.Count()))
{
LadderPlayer.Position = newpos;
if (LadderPlayer.Playing)
{
newpos++;
}
}
CurrentGW.Ladder = Ladder;
SaveGameWeek(CurrentGW, db);
}
}
