public short CalculateEarnedHonor(CharacterFighter character)
{
if (Draw)
{
return(0);
}
if (character.OpposedTeam.AlignmentSide == AlignmentSideEnum.ALIGNMENT_NEUTRAL)
{
return(0);
}
var winnersLevel = (double)Winners.GetAllFightersWithLeavers <CharacterFighter>().Sum(entry => entry.Level);
var losersLevel = (double)Losers.GetAllFightersWithLeavers <CharacterFighter>().Sum(entry => entry.Level);
var maxLosersLevel = winnersLevel + 15;
var delta = Math.Floor(Math.Sqrt(character.Level) * 10 * ((losersLevel > maxLosersLevel ? maxLosersLevel : losersLevel) / winnersLevel));
if (Losers == character.Team)
{
delta = -delta;
}
return((short)delta);
}
/// <summary>
/// Nachdem ein Loser nochmal verliert scheidet er aus dem Turnier aus
/// </summary>
/// <param name="losers"></param>
public void EliminateLosingPlayers(List <Player> losers)
{
foreach (Player loser in losers)
{
Losers.Remove(loser);
}
}
public void PopulateLosers()
{
IEXHandler webHandler = new IEXHandler();
List <StockStats> losersListRes = webHandler.Losers();
String losersData = JsonConvert.SerializeObject(losersListRes);
List <StockStats> losersList = null;
if (losersData != "")
{
var settings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
MissingMemberHandling = MissingMemberHandling.Ignore
};
losersList = JsonConvert.DeserializeObject <List <StockStats> >(losersData, settings);
}
foreach (StockStats loser in losersList)
{
//Database will give PK constraint violation error when trying to insert record with existing PK.
//So add company only if it doesnt exist, check existence using symbol (PK)
if (dbContext.Losers.Where(c => c.symbol.Equals(loser.symbol)).Count() == 0)
{
Losers loserData = new Losers(loser.symbol, loser.companyName, loser.primaryExchange, loser.sector);
dbContext.Losers.Add(loserData);
}
}
dbContext.SaveChanges();
}
private void GetLosersCallback(IEnumerable <Stock> losers)
{
Losers.Clear();
foreach (Stock stock in losers)
{
Losers.Add(stock);
}
}
protected override void CreateSummary()
{
if (Winners == null || !Winners.Any() || Losers == null || !Losers.Any())
{
Summary = "Game Ended.";
}
else
{
Summary = String.Format("Game ended: {0} wins against {1}.", Winners.First(), Losers.First());
}
}
public static void MostLosingCoach(List <SuperBowlWinner> SuperBowlWinners, StreamWriter Writer)
{
// using linq to get the coach who lost the most games.
var MostLosses = (
from i in SuperBowlWinners
group i by i.CoachLoser into Losers
where Losers.Count() > 2
orderby Losers.Count() descending
select Losers).Take(1);
foreach (var e in MostLosses)
{
Writer.WriteLine("The Coach who lost the most super bowls is {0}.", e.Key);
Writer.WriteLine();
}
}
public void ParseData()
{
LosersList = new List <User>();
SettledUsersList = new List <User>();
if (Losers != null)
{
var loserIds = Losers.Split(' ');
parseToList(loserIds, LosersList);
}
if (SettledUsers != null)
{
var settledIds = SettledUsers.Split(' ');
parseToList(settledIds, SettledUsersList);
}
}
public override void Stop()
{
Program.MainForm.LogDebug("Stopping." + Environment.StackTrace);
End?.Stop();
End = null;
List <Character> Winners;
List <Character> Losers;
if (SnowballMap.GetWinner() == SnowballEventState.MAPLE_WIN)
{
Winners = MapleTeam.ToList();
Losers = StoryTeam.ToList();
}
else
{
Winners = StoryTeam.ToList();
Losers = MapleTeam.ToList();
}
_log.Info("Total players: " + (Winners.Count + Losers.Count));
_log.Info("Winners: " + string.Join(", ", Winners.Select(x => x.Name)));
_log.Info("Losers: " + string.Join(", ", Losers.Select(x => x.Name)));
Winners.ForEach(c =>
{
MapPacket.MapEffect(c, 4, "Coconut/Victory", true);
MapPacket.MapEffect(c, 3, "event/coconut/victory", true);
});
Losers.ForEach(c =>
{
MapPacket.MapEffect(c, 4, "Coconut/Failed", true);
MapPacket.MapEffect(c, 3, "event/coconut/lose", true);
});
RepeatingAction.Start("snowball warper", e =>
{
Winners.ForEach(c => c.ChangeMap(WinMapId));
Losers.ForEach(c => c.ChangeMap(LoseMapId));
SnowballMap.TimerEndTime = MasterThread.CurrentTime;
MapleTeam.Clear();
StoryTeam.Clear();
SnowballMap.Reset();
base.Stop();
}, 10 * 1000, 0);
}
private void ManageIrregularGroup()
{
var nativeChallengers = new List <Challenger>(_challengers);
var remainingChallengers = FetchRemainigChallengers(ref nativeChallengers);
var tempGroup = new Group(nativeChallengers, this.GroupLabel, Shuffle, 1);
tempGroup.ManageRegularGroup();
var challengersFromRoundOne = tempGroup._challengers;
Matches.AddRange(tempGroup.Matches);
Losers.AddRange(tempGroup.Losers);
nativeChallengers = Enumerable.Concat(remainingChallengers, challengersFromRoundOne).ToList();
_challengers = nativeChallengers;
ManageRegularGroup();
}
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)));
}
