private void GetLosersCallback(IEnumerable <Stock> losers)
{
Losers.Clear();
foreach (Stock stock in losers)
{
Losers.Add(stock);
}
}
private void ManageRegularGroup()
{
if (_challengers.Count == 1)
{
Winner = _challengers.First();
}
//Looping through the challengers until they are one. (the "winner")
while (_challengers.Count != 1)
{
//looping through the Challengers list taking every two challengers, putting them in a match and
//remove them from the '_challengers' list then add the winner to the '_challengersTemp' list.
for (int i = 0; i < _challengers.Count; i += 2)
{
//create an object from the Match that will contain the player in the index 'i' with the player in the index 'i+1'.
Match match = new Match(_challengers[i], _challengers[i + 1]);
Matches.Add(new MatchRecord(_challengers[i], _challengers[i + 1], this));
//Starting the match which will end up with a winner and a loser.
match.Start();
//Adding the winner to the '_challengersTemp' List.
_challengersTemp.Add(match.Winner);
//Adding the loser to the 'Losers' List.
Losers.Add(match.Loser);
}
//moving items from challengersTemp to challengers and clean challengers temp in order to set the path for another round
HelperMethods.MoveItems(_challengersTemp, ref _challengers, true);
CurrentRound++;
OnCurrentRoundLeveledUp(this, null);
if (_exit)
{
return;
}
}
Winner = _challengers.First();
}
/// <summary>
/// Verschiebt die Spieler vom Winning Bracket in das Loser Bracket
/// </summary>
/// <param name="losers"></param>
public void MoveLosingPlayers(List <Player> losers)
{
// Bei der ersten Loser Runde werden einfach alle Spieler in eine Liste getan
if (FirstLosers)
{
foreach (Player loser in losers)
{
Winners.Remove(loser);
Losers.Add(loser);
}
FirstLosers = false;
}
// Bei den nachfolgenden Runden müssen die Verlierer vom Winning Bracket gegen gezielte Gegner aus dem Loser Bracket spielen
else
{
int counterIndex = 0;
foreach (Player loser in losers)
{
Winners.Remove(loser);
Losers.Insert(counterIndex, loser);
counterIndex += 2;
}
}
}
public bool GameLoop()
{
foreach (var player in Players)
{
if (player.Pos.InCellCenter())
{
var direction = SendTick(player);
if (direction != null)
{
player.ChangeDirection(direction.Value);
}
}
}
foreach (var player in Players)
{
player.Move();
}
var playerToCaptured = new Dictionary <Player, HashSet <V> >();
foreach (var player in Players)
{
player.RemoveSawBonus();
if (player.Pos.InCellCenter())
{
player.UpdateLines();
var captured = player.Territory.Capture(player.Lines);
playerToCaptured[player] = captured;
if (captured.Count > 0)
{
player.Lines.Clear();
player.TickScore += Env.NEUTRAL_TERRITORY_SCORE * captured.Count;
}
}
}
foreach (var player in Players)
{
if (CheckLoss(player))
{
Losers.Add(player);
}
}
playerToCaptured = CollisionResolution(playerToCaptured);
foreach (var player in Players)
{
if (player.IsAte(playerToCaptured))
{
Losers.Add(player);
}
}
foreach (var player in Players)
{
if (player.Pos.InCellCenter())
{
if (!playerToCaptured.TryGetValue(player, out var captured))
{
captured = new HashSet <V>();
}
player.TickAction();
foreach (var bonus in Bonuses.ToList())
{
if (bonus.IsAte(player, captured))
{
bonus.Apply(player);
Bonuses.Remove(bonus);
if (bonus is Saw)
{
var line = player.GetDirectionLine();
foreach (var p in Players)
{
if (p != player)
{
if (line.Any(point => p.Pos.IntersectsWith(point)))
{
Losers.Add(p);
player.TickScore += Env.SAW_KILL_SCORE;
}
else
{
var removed = p.Territory.Split(line, player.Dir ?? throw new InvalidOperationException(), p);
if (removed.Count > 0)
{
player.TickScore += Env.SAW_SCORE;
}
}
}
}
}
}
}
if (captured.Count > 0)
{
player.Territory.Points.UnionWith(captured);
foreach (var p in Players)
{
if (p != player)
{
var removed = p.Territory.RemovePoints(captured);
player.TickScore += (Env.ENEMY_TERRITORY_SCORE - Env.NEUTRAL_TERRITORY_SCORE) * removed.Count;
}
}
}
}
}
foreach (var loser in Losers)
{
Players.Remove(loser);
}
foreach (var player in Players)
{
player.Score += player.TickScore;
player.TickScore = 0;
}
GenerateBonus();
Tick++;
return(Players.Count == 0);
}
/// <summary>
/// Combines the losers from the whole tournament into one collection
/// </summary>
/// <param name="finalMatch"></param>
private void AddLosers(Match finalMatch)
{
Losers.AddRange(Group1.Losers);
Losers.AddRange(Group2.Losers);
Losers.Add(finalMatch.Loser);
}
public void Lose(Player player)
{
Losers.Add(player);
_ = Players.Remove(player);
CurrentTurn.CurrentStep.GameEvents.Enqueue(new LoseEvent(new Player(player)));
}