protected override void HandleRoundStart(object sender, RoundStartedEventArgs e)
{
if (!IsMatchStarted)
{
return;
}
// Check players count to prevent missing players who was connected after the match started event
if (Demo.Players.Count < 10)
{
// Add all players to our ObservableCollection of PlayerExtended
foreach (Player player in Parser.PlayingParticipants)
{
// don't add bot and already known players
if (player.SteamID != 0 && Demo.Players.FirstOrDefault(p => p.SteamId == player.SteamID) == null)
{
PlayerExtended pl = new PlayerExtended
{
SteamId = player.SteamID,
Name = player.Name,
Side = player.Team
};
Application.Current.Dispatcher.Invoke(delegate
{
Demo.Players.Add(pl);
pl.TeamName = pl.Side == Team.CounterTerrorist ? Demo.TeamCT.Name : Demo.TeamT.Name;
});
}
}
}
CreateNewRound();
}
internal void WatchPlayerStuff(Demo demo, PlayerExtended player, string selectedType)
{
_arguments.Add("+playdemo");
_arguments.Add(demo.Path);
EquipmentElement type = EquipmentElement.Unknown;
switch (selectedType)
{
case "smokes":
type = EquipmentElement.Smoke;
break;
case "flashbangs":
type = EquipmentElement.Flash;
break;
case "he":
type = EquipmentElement.HE;
break;
case "molotovs":
type = EquipmentElement.Molotov;
break;
case "decoys":
type = EquipmentElement.Decoy;
break;
}
GeneratePlayerStuffVdm(demo, player, type);
StartGame();
}
public async Task <bool> UpdateRankInfoAsync(Demo demo)
{
// We don't care about no valve demos
if (demo.SourceName != "valve")
{
return(false);
}
// Check if the player is in the demo
PlayerExtended player = demo.Players
.FirstOrDefault(p => p.SteamId == Properties.Settings.Default.SelectedStatsAccountSteamID);
if (player == null)
{
return(false);
}
// Don't update if demo's date is higher than the known last rank date detected
RankInfo lastRankInfo = await GetLastRankInfoAsync();
if (lastRankInfo != null && lastRankInfo.LastDate > demo.Date)
{
return(false);
}
lastRankInfo = new RankInfo
{
SteamId = player.SteamId,
Number = player.RankNumberNew,
LastDate = demo.Date
};
await SaveLastRankInfoAsync(lastRankInfo);
return(true);
}
/// <summary>
/// Check if there are banned players and update their banned flags
/// </summary>
/// <param name="demo"></param>
/// <returns></returns>
public async Task <Demo> AnalyzeBannedPlayersAsync(Demo demo)
{
List <string> ids = demo.Players.Select(playerExtended => playerExtended.SteamId.ToString()).ToList();
IEnumerable <Suspect> suspects = await _steamService.GetBanStatusForUserList(ids);
var enumerableSuspects = suspects as IList <Suspect> ?? suspects.ToList();
if (enumerableSuspects.Any())
{
List <string> whitelistIds = await _cacheService.GetPlayersWhitelist();
// Update player's flag
foreach (Suspect suspect in enumerableSuspects)
{
PlayerExtended cheater = demo.Players.FirstOrDefault(p => p.SteamId.ToString() == suspect.SteamId);
if (cheater != null && !whitelistIds.Contains(cheater.SteamId.ToString()))
{
if (suspect.GameBanCount > 0)
{
demo.HasCheater = true;
cheater.IsOverwatchBanned = true;
}
if (suspect.VacBanned)
{
demo.HasCheater = true;
cheater.IsVacBanned = true;
}
}
}
}
return(demo);
}
private void StartMatch()
{
RoundCount = 0;
IsMatchStarted = true;
if (!string.IsNullOrWhiteSpace(Parser.CTClanName))
{
Demo.TeamCT.Name = Parser.CTClanName;
}
if (!string.IsNullOrWhiteSpace(Parser.TClanName))
{
Demo.TeamT.Name = Parser.TClanName;
}
// Add all players to our ObservableCollection of PlayerExtended
foreach (Player player in Parser.PlayingParticipants)
{
// don't add bot
if (player.SteamID != 0)
{
PlayerExtended pl = new PlayerExtended
{
SteamId = player.SteamID,
Name = player.Name,
Side = player.Team
};
if (!Demo.Players.Contains(pl))
{
Application.Current.Dispatcher.Invoke(delegate
{
Demo.Players.Add(pl);
if (pl.Side == Team.CounterTerrorist && !Demo.TeamCT.Players.Contains(pl))
{
Demo.TeamCT.Players.Add(pl);
if (!Demo.TeamCT.Players.Contains(pl))
{
Demo.TeamCT.Players.Add(pl);
}
pl.TeamName = Demo.TeamCT.Name;
}
if (pl.Side == Team.Terrorist && !Demo.TeamT.Players.Contains(pl))
{
Demo.TeamT.Players.Add(pl);
if (!Demo.TeamT.Players.Contains(pl))
{
Demo.TeamT.Players.Add(pl);
}
pl.TeamName = Demo.TeamT.Name;
}
});
}
}
}
// First round handled here because round_start is raised before begin_new_match
CreateNewRound();
}
public HeatmapService(MapService mapService, Demo demo, ComboboxSelector eventSelector, ComboboxSelector sideSelector, PlayerExtended selectedPlayer, Round selectedRound)
{
MapService = mapService;
_demo = demo;
_eventSelector = eventSelector;
_sideSelector = sideSelector;
_selectedPlayer = selectedPlayer;
_selectedRound = selectedRound;
}
void Start()
{
PlayerLogic = Player.GetComponent <PlayerExtended>() as PlayerExtended;
AnimatorManager = this.GetComponent <Animator>() as Animator;
NavMeshAgent = this.GetComponent <NavMeshAgent>() as NavMeshAgent;
isChasing = false;
_source = this.GetComponent <AudioSource>() as AudioSource;
AnimatorManager.SetBool("turnedLightOn", true);
}
public static PlayerExtendedGetResponseModel FromPlayer(PlayerExtended player)
{
return(new PlayerExtendedGetResponseModel
{
PlayerExtended = new PlayerExtendedEntry {
Gamertag = player.Gamertag, ExtendedInformation = player.ExtendedInformation
}
});
}
void Start()
{
cdLight = this.gameObject.GetComponentInChildren <Light>();
cdLight.enabled = false;
isGrabbable = false;
Player = GameObject.FindGameObjectsWithTag("Player")[0];
PlayerCtrl = this.Player.GetComponent <PlayerExtended>() as PlayerExtended;
isGrabbed = false;
//cdLight.color = Color.blue;
}
private void HandleServerRankUpdate(object sender, RankUpdateEventArgs e)
{
PlayerExtended player = Demo.Players.FirstOrDefault(p => p.SteamId == e.SteamId);
if (player != null)
{
player.RankNumberOld = e.RankOld;
player.RankNumberNew = e.RankNew;
player.WinCount = e.WinCount;
}
}
private void HandleServerRankUpdate(object sender, ServerRankUpdateEventArgs e)
{
foreach (ServerRankUpdateEventArgs.RankStruct rankStruct in e.RankStructList)
{
PlayerExtended player = Demo.Players.FirstOrDefault(p => p.SteamId == rankStruct.SteamId);
if (player != null)
{
player.RankNumberOld = rankStruct.Old;
player.RankNumberNew = rankStruct.New;
player.WinCount = rankStruct.NumWins;
}
}
}
private void HandleBotTakeOver(object sender, BotTakeOverEventArgs e)
{
if (!IsMatchStarted)
{
return;
}
PlayerExtended player = Demo.Players.FirstOrDefault(p => p.SteamId == e.Taker.SteamID);
if (player != null)
{
player.IsControllingBot = true;
}
}
public async Task <ActionResult> PostExtended([FromBody] PlayerExtendedPostRequestModel Player)
{
if (string.IsNullOrWhiteSpace(Player.Gamertag))
{
return(BadRequest()); //TODO: return error info in body
}
// Save player extended information
var player = new PlayerExtended
{
UserId = Player.UserId ?? Guid.NewGuid().ToString(),
Gamertag = Player.Gamertag,
ExtendedInformation = Player.ExtendedInformation
};
await _store.SavePlayerExtendedAsync(player);
// Return result
return(CreatedAtRoute(nameof(GetPlayer), new { gamertag = player.Gamertag }, null));
}
private void InitPlayers()
{
// Add all players to our ObservableCollection of PlayerExtended and teams
foreach (Player player in Parser.PlayingParticipants)
{
PlayerExtended pl = new PlayerExtended
{
SteamId = player.SteamID,
Name = player.Name,
Side = player.Team
};
Application.Current.Dispatcher.Invoke(delegate
{
if (!Demo.Players.Contains(pl))
{
Demo.Players.Add(pl);
}
if (pl.Side == Team.CounterTerrorist)
{
pl.TeamName = Demo.TeamCT.Name;
if (!Demo.TeamCT.Players.Contains(pl))
{
Demo.TeamCT.Players.Add(pl);
}
}
if (pl.Side == Team.Terrorist)
{
pl.TeamName = Demo.TeamT.Name;
if (!Demo.TeamT.Players.Contains(pl))
{
Demo.TeamT.Players.Add(pl);
}
}
});
}
}
public async Task SavePlayerExtendedAsync(PlayerExtended player)
{
// add only of the playerextended does not exist
PlayerExtendedEntity entity = player.UserId == null ? null : await _context.PlayersExtended.FindAsync(player.Gamertag);
if (entity == null)
{
await _context.PlayersExtended.AddAsync(new PlayerExtendedEntity
{
UserId = player.UserId,
Gamertag = player.Gamertag,
ExtendedInformation = player.ExtendedInformation
});
await _context.SaveChangesAsync();
}
else
{
entity.Gamertag = player.Gamertag;
entity.ExtendedInformation = player.ExtendedInformation;
await _context.SaveChangesAsync();
}
}
public Task <Demo> AnalyzeDemo(Demo demo, CancellationToken token)
{
Random random = new Random();
ObservableCollection <PlayerExtended> players = new ObservableCollection <PlayerExtended>();
for (int i = 0; i < 10; i++)
{
PlayerExtended player = new PlayerExtended
{
Name = "player" + (i + 1),
HeadshotCount = random.Next(14),
OnekillCount = random.Next(10, 30),
TwokillCount = random.Next(10, 20),
ThreekillCount = random.Next(0, 10),
FourKillCount = random.Next(0, 5),
FiveKillCount = random.Next(0, 2),
Clutch1V1Count = random.Next(1),
Clutch1V2Count = random.Next(1),
Clutch1V3Count = random.Next(1),
Clutch1V4Count = random.Next(1),
Clutch1V5Count = random.Next(1),
BombDefusedCount = random.Next(0, 2),
BombPlantedCount = random.Next(0, 2),
DeathCount = random.Next(0, 32),
KillsCount = random.Next(30),
AssistCount = random.Next(15),
Score = random.Next(10, 80),
RoundMvpCount = random.Next(6),
RankNumberNew = 5,
RankNumberOld = 4,
RatingHltv = (float)random.NextDouble(),
SteamId = random.Next(1000, 800000),
IsOverwatchBanned = random.Next(100) < 40,
IsVacBanned = random.Next(100) < 40,
TeamKillCount = random.Next(0, 1),
WinCount = random.Next(10, 687),
MolotovThrownCount = random.Next(0, 10),
DecoyThrownCount = random.Next(0, 10),
IncendiaryThrownCount = random.Next(20),
SmokeThrownCount = random.Next(20),
FlashbangThrownCount = random.Next(20),
HeGrenadeThrownCount = random.Next(20),
BombExplodedCount = random.Next(5),
AvatarUrl = string.Empty,
ClutchCount = random.Next(5),
ClutchLostCount = random.Next(5),
KillDeathRatio = (decimal)random.NextDouble(),
MatchCount = random.Next(100),
OpponentClutchCount = random.Next(5),
RoundPlayedCount = random.Next(100)
};
players.Add(player);
}
TeamExtended teamT = new TeamExtended
{
Name = "Team 1",
Players = new ObservableCollection <PlayerExtended>(players.Take(5))
};
TeamExtended teamCt = new TeamExtended
{
Name = "Team 2",
Players = new ObservableCollection <PlayerExtended>(players.Skip(5).Take(5))
};
ObservableCollection <Round> rounds = new ObservableCollection <Round>();
for (int i = 0; i < 32; i++)
{
ObservableCollection <KillEvent> kills = new ObservableCollection <KillEvent>();
for (int j = 0; j < random.Next(1, 9); j++)
{
PlayerExtended killer = players.ElementAt(random.Next(9));
PlayerExtended killed = players.ElementAt(random.Next(9));
kills.Add(new KillEvent(random.Next(1, 10000), random.Next(1, 100))
{
KillerName = killer.Name,
KillerSteamId = killer.SteamId,
KillerSide = killer.Side,
KilledName = killed.Name,
KilledSteamId = killed.SteamId,
KilledSide = killed.Side,
RoundNumber = i,
Weapon = Weapon.WeaponList.ElementAt(random.Next(44))
});
}
// generate open / entry kills for this round
Round round = new Round
{
Number = i + 1,
OneKillCount = random.Next(5),
TwoKillCount = random.Next(2),
ThreeKillCount = random.Next(1),
FourKillCount = random.Next(1),
FiveKillCount = random.Next(1),
EquipementValueTeam1 = random.Next(4200, 30000),
EquipementValueTeam2 = random.Next(4200, 30000),
StartMoneyTeam1 = random.Next(4200, 50000),
StartMoneyTeam2 = random.Next(4200, 50000),
Tick = random.Next(7000, 100000),
WinnerName = teamCt.Name,
WinnerSide = Team.CounterTerrorist,
StartTimeSeconds = random.Next(1),
BombDefused = null,
EndTimeSeconds = random.Next(100),
BombPlanted = null,
BombExploded = null,
Type = RoundType.NORMAL,
EndReason = RoundEndReason.CTWin,
EntryKillEvent = new EntryKillEvent(random.Next(1, 10000), random.Next(1, 100))
{
HasWin = random.Next(100) < 50,
KillerSteamId = players.ElementAt(random.Next(9)).SteamId,
KillerName = players.ElementAt(random.Next(9)).Name,
KilledSteamId = players.ElementAt(random.Next(9)).SteamId,
KilledName = players.ElementAt(random.Next(9)).Name,
Weapon = Weapon.WeaponList.ElementAt(random.Next(44)),
KilledSide = Team.CounterTerrorist,
KillerSide = Team.Terrorist
},
OpenKillEvent = new OpenKillEvent(random.Next(1, 10000), random.Next(1, 100))
{
HasWin = random.Next(100) < 50,
KillerSteamId = players.ElementAt(random.Next(9)).SteamId,
KillerName = players.ElementAt(random.Next(9)).Name,
KilledSteamId = players.ElementAt(random.Next(9)).SteamId,
KilledName = players.ElementAt(random.Next(9)).Name,
Weapon = Weapon.WeaponList.ElementAt(random.Next(44)),
KilledSide = Team.CounterTerrorist,
KillerSide = Team.Terrorist
},
SideTrouble = Team.Spectate,
Kills = kills
};
rounds.Add(round);
}
demo.Id = "de_dust25445648778447878";
demo.Source = new Valve();
demo.Name = "esea_nip_vs_titan.dem";
demo.Tickrate = 15;
demo.ServerTickrate = 128;
demo.MapName = "de_dust2";
demo.ClientName = "localhost";
demo.Hostname = "local";
demo.OneKillCount = 90;
demo.TwoKillCount = 30;
demo.ThreeKillCount = 25;
demo.FourKillCount = 3;
demo.FiveKillCount = 1;
demo.Path = "C:\\mydemo.dem";
demo.ScoreTeam1 = 16;
demo.ScoreTeam2 = 6;
demo.Type = "GOTV";
demo.Comment = "comment";
demo.ScoreFirstHalfTeam1 = 10;
demo.ScoreFirstHalfTeam2 = 5;
demo.ScoreSecondHalfTeam1 = 6;
demo.ScoreSecondHalfTeam2 = 1;
demo.TeamCT = teamCt;
demo.TeamT = teamT;
demo.Players = players;
demo.Rounds = rounds;
demo.MostKillingWeapon = Weapon.WeaponList[random.Next(44)];
foreach (KillEvent e in rounds.SelectMany(round => round.Kills))
{
demo.Kills.Add(e);
}
return(Task.FromResult(demo));
}
protected override void HandleMatchStarted(object sender, MatchStartedEventArgs e)
{
if (IsMatchStarted)
{
Demo.ResetStats(false);
}
RoundCount = 0;
IsMatchStarted = true;
TeamExtended team1 = new TeamExtended()
{
Name = !string.IsNullOrWhiteSpace(Parser.CTClanName) ? Parser.CTClanName : TEAM1_NAME
};
TeamExtended team2 = new TeamExtended()
{
Name = !string.IsNullOrWhiteSpace(Parser.TClanName) ? Parser.TClanName : TEAM2_NAME
};
Demo.ClanTagNameTeam1 = team1.Name;
Demo.ClanTagNameTeam2 = team2.Name;
// Add all players to our ObservableCollection of PlayerExtended
foreach (Player player in Parser.PlayingParticipants)
{
// don't add bot
if (player.SteamID != 0)
{
PlayerExtended pl = new PlayerExtended
{
SteamId = player.SteamID,
Name = player.Name,
Team = player.Team
};
if (!Demo.Players.Contains(pl))
{
Application.Current.Dispatcher.Invoke(delegate
{
Demo.Players.Add(pl);
if (pl.Team == Team.CounterTerrorist && !Demo.PlayersTeam1.Contains(pl))
{
Demo.PlayersTeam1.Add(pl);
if (!team1.Players.Contains(pl))
{
team1.Players.Add(pl);
}
}
if (pl.Team == Team.Terrorist && !Demo.PlayersTeam2.Contains(pl))
{
Demo.PlayersTeam2.Add(pl);
if (!team2.Players.Contains(pl))
{
team2.Players.Add(pl);
}
}
});
}
}
}
Application.Current.Dispatcher.Invoke(delegate
{
if (!Demo.Teams.Contains(team1))
{
Demo.Teams.Add(team1);
}
if (!Demo.Teams.Contains(team2))
{
Demo.Teams.Add(team2);
}
});
// First round handled here because round_start is raised before begin_new_match
CreateNewRound();
}
private void InitPlayers()
{
// We must set team1 as CT and team2 as T
TeamExtended team1 = new TeamExtended()
{
Name = !string.IsNullOrWhiteSpace(Parser.CTClanName) ? Parser.CTClanName : TEAM1_NAME
};
TeamExtended team2 = new TeamExtended()
{
Name = !string.IsNullOrWhiteSpace(Parser.TClanName) ? Parser.TClanName : TEAM2_NAME
};
Demo.ClanTagNameTeam1 = team1.Name;
Demo.ClanTagNameTeam2 = team2.Name;
// Add all players to our ObservableCollection of PlayerExtended and teams
foreach (Player player in Parser.PlayingParticipants)
{
PlayerExtended pl = new PlayerExtended
{
SteamId = player.SteamID,
Name = player.Name,
Team = player.Team
};
Application.Current.Dispatcher.Invoke(delegate
{
if (!Demo.Players.Contains(pl))
{
Demo.Players.Add(pl);
}
if (pl.Team == Team.CounterTerrorist)
{
if (!Demo.PlayersTeam1.Contains(pl))
{
Demo.PlayersTeam1.Add(pl);
}
if (!team1.Players.Contains(pl))
{
team1.Players.Add(pl);
}
}
if (pl.Team == Team.Terrorist)
{
if (!Demo.PlayersTeam2.Contains(pl))
{
Demo.PlayersTeam2.Add(pl);
}
if (!team2.Players.Contains(pl))
{
team2.Players.Add(pl);
}
}
});
}
// Add teams
Application.Current.Dispatcher.Invoke(delegate
{
Demo.Teams.Clear();
Demo.Teams.Add(team1);
Demo.Teams.Add(team2);
});
}
private void AddTeams()
{
// Detect possible swap by teams name, work for some demos
if (Parser.TClanName == Demo.TeamCT.Name || Parser.CTClanName == Demo.TeamT.Name)
{
TeamExtended tmp = Demo.TeamT;
Demo.TeamT = Demo.TeamCT;
Demo.TeamCT = tmp.Clone();
}
// Add all players to our ObservableCollection of PlayerExtended
foreach (Player player in Parser.PlayingParticipants)
{
if (player.SteamID != 0)
{
PlayerExtended pl = new PlayerExtended
{
SteamId = player.SteamID,
Name = player.Name,
Side = player.Team
};
Application.Current.Dispatcher.Invoke(delegate
{
if (!Demo.Players.Contains(pl))
{
Demo.Players.Add(pl);
}
if (pl.Side == Team.CounterTerrorist)
{
pl.TeamName = Demo.TeamCT.Name;
// Check swap
if (Demo.TeamT.Players.Contains(pl))
{
Demo.TeamCT.Players.Add(Demo.TeamT.Players.First(p => p.Equals(pl)));
Demo.TeamT.Players.Remove(pl);
}
else
{
if (!Demo.TeamCT.Players.Contains(pl))
{
Demo.TeamCT.Players.Add(pl);
}
}
}
if (pl.Side == Team.Terrorist)
{
pl.TeamName = Demo.TeamT.Name;
// Check swap
if (Demo.TeamCT.Players.Contains(pl))
{
Demo.TeamT.Players.Add(Demo.TeamCT.Players.First(p => p.Equals(pl)));
Demo.TeamCT.Players.Remove(pl);
}
else
{
if (!Demo.TeamT.Players.Contains(pl))
{
Demo.TeamT.Players.Add(pl);
}
}
}
});
}
}
}
private static void GeneratePlayerStuffVdm(Demo demo, PlayerExtended player, EquipmentElement type)
{
string vdmFilePath = GetVdmFilePath(demo);
string generated = string.Empty;
int actionCount = 0;
int lastTick = 0;
int beginTickDelayCount = (int)(demo.ServerTickrate * STUFF_BEGIN_DELAY);
int endTickDelayCount = (int)(demo.ServerTickrate * STUFF_END_DELAY);
int lastSuffSartedTick = 0;
// max delay between 2 stuffs
int maxTickDelayCount = (int)(demo.ServerTickrate * MAX_NEXT_STUFF_DELAY);
int nextActionDelayCount = (int)(demo.ServerTickrate * NEXT_ACTION_DELAY);
string message = GetFastForwardMessage(type);
foreach (WeaponFire e in demo.WeaponFired)
{
// TODO rework weapon type detection and remove strong dependency with demoinfo
if (e.ShooterSteamId == player.SteamId && e.Weapon.Element == type ||
(e.ShooterSteamId == player.SteamId &&
type == EquipmentElement.Molotov &&
(e.Weapon.Element == EquipmentElement.Molotov ||
e.Weapon.Element == EquipmentElement.Incendiary)))
{
int startToTick = actionCount == 0 ? 0 : lastTick;
int skipToTick = 0;
switch (type)
{
case EquipmentElement.Smoke:
// check if the player thrown an other smoke just after the previous one
if (e.Tick - lastTick > maxTickDelayCount)
{
skipToTick = e.Tick - beginTickDelayCount;
// if a smoke has been thrown previously, we skip ahead just after its popped
if (lastSuffSartedTick != 0)
{
startToTick = lastSuffSartedTick + endTickDelayCount;
}
generated += string.Format(Properties.Resources.text_message_start, ++actionCount, startToTick - nextActionDelayCount, message);
generated += string.Format(Properties.Resources.screen_fade_start, ++actionCount, startToTick - nextActionDelayCount);
generated += string.Format(Properties.Resources.skip_ahead, ++actionCount, startToTick, skipToTick);
generated += string.Format(Properties.Resources.spec_player, ++actionCount, startToTick, e.ShooterEntityId);
}
// find the tick where the smoke popped
foreach (Round round in demo.Rounds.Where(round => round.Number == e.RoundNumber))
{
foreach (
SmokeNadeStartedEvent smokeNadeStartedEvent in
round.SmokeStarted.Where(
smokeNadeStartedEvent =>
smokeNadeStartedEvent.ThrowerSteamId == player.SteamId &&
smokeNadeStartedEvent.Tick > lastSuffSartedTick))
{
lastSuffSartedTick = smokeNadeStartedEvent.Tick;
break;
}
}
break;
case EquipmentElement.Molotov:
if (e.Tick - lastTick > maxTickDelayCount)
{
skipToTick = e.Tick - beginTickDelayCount;
if (lastSuffSartedTick != 0)
{
startToTick = lastSuffSartedTick + endTickDelayCount;
}
generated += string.Format(Properties.Resources.text_message_start, ++actionCount, startToTick - nextActionDelayCount, message);
generated += string.Format(Properties.Resources.screen_fade_start, ++actionCount, startToTick - nextActionDelayCount);
generated += string.Format(Properties.Resources.skip_ahead, ++actionCount, startToTick, skipToTick);
generated += string.Format(Properties.Resources.spec_player, ++actionCount, startToTick, e.ShooterEntityId);
// the molotov may have not burned, use time average instead
lastSuffSartedTick = e.Tick + (int)(demo.ServerTickrate * MOLOTOV_TIME);
}
break;
case EquipmentElement.Flash:
case EquipmentElement.Decoy:
case EquipmentElement.HE:
if (e.Tick - lastTick > maxTickDelayCount)
{
skipToTick = e.Tick - beginTickDelayCount;
if (lastSuffSartedTick != 0)
{
startToTick = lastSuffSartedTick + endTickDelayCount;
}
generated += string.Format(Properties.Resources.text_message_start, ++actionCount, startToTick - nextActionDelayCount, message);
generated += string.Format(Properties.Resources.screen_fade_start, ++actionCount, startToTick - nextActionDelayCount);
generated += string.Format(Properties.Resources.skip_ahead, ++actionCount, startToTick, skipToTick);
generated += string.Format(Properties.Resources.spec_player, ++actionCount, startToTick, e.ShooterEntityId);
}
switch (type)
{
case EquipmentElement.Flash:
foreach (Round round in demo.Rounds.Where(round => round.Number == e.RoundNumber))
{
foreach (
FlashbangExplodedEvent flashEvent in
round.FlashbangsExploded.Where(
flashExplodedEvent =>
flashExplodedEvent.ThrowerSteamId == player.SteamId &&
flashExplodedEvent.Tick > lastSuffSartedTick))
{
lastSuffSartedTick = flashEvent.Tick;
break;
}
}
break;
case EquipmentElement.Decoy:
foreach (DecoyStartedEvent decoyEvent in demo.DecoyStarted)
{
if (decoyEvent.ThrowerSteamId == player.SteamId &&
decoyEvent.RoundNumber == e.RoundNumber &&
decoyEvent.Tick > lastSuffSartedTick)
{
lastSuffSartedTick = decoyEvent.Tick;
break;
}
}
break;
case EquipmentElement.HE:
foreach (Round round in demo.Rounds.Where(round => round.Number == e.RoundNumber))
{
foreach (
ExplosiveNadeExplodedEvent heEvent in
round.ExplosiveGrenadesExploded.Where(
heExplodedEvent =>
heExplodedEvent.ThrowerSteamId == player.SteamId &&
heExplodedEvent.Tick > lastSuffSartedTick))
{
lastSuffSartedTick = heEvent.Tick;
break;
}
}
break;
}
break;
}
lastTick = e.Tick;
}
}
generated += string.Format(Properties.Resources.stop_playback, ++actionCount, lastTick + nextActionDelayCount);
string content = string.Format(Properties.Resources.main, generated);
File.WriteAllText(vdmFilePath, content);
}
private void AddTeams()
{
// We must set team1 as CT and team2 as T
TeamExtended team1 = new TeamExtended()
{
Name = Parser.CTClanName
};
TeamExtended team2 = new TeamExtended()
{
Name = Parser.TClanName
};
Demo.ClanTagNameTeam1 = team1.Name;
Demo.ClanTagNameTeam2 = team2.Name;
// Add all players to our ObservableCollection of PlayerExtended and teams
foreach (Player player in Parser.PlayingParticipants)
{
if (player.SteamID != 0)
{
PlayerExtended pl = new PlayerExtended
{
SteamId = player.SteamID,
Name = player.Name,
Team = player.Team
};
Application.Current.Dispatcher.Invoke(delegate
{
if (!Demo.Players.Contains(pl))
{
Demo.Players.Add(pl);
}
if (pl.Team == Team.CounterTerrorist)
{
// Check swap
if (Demo.PlayersTeam2.Contains(pl))
{
Demo.PlayersTeam1.Add(Demo.PlayersTeam2.First(p => p.Equals(pl)));
Demo.PlayersTeam2.Remove(pl);
}
else
{
if (!Demo.PlayersTeam1.Contains(pl))
{
Demo.PlayersTeam1.Add(pl);
}
}
team1.Players.Add(Demo.Players.First(p => p.Equals(pl)));
}
if (pl.Team == Team.Terrorist)
{
// Check swap
if (Demo.PlayersTeam1.Contains(pl))
{
Demo.PlayersTeam2.Add(Demo.PlayersTeam1.First(p => p.Equals(pl)));
Demo.PlayersTeam1.Remove(pl);
}
else
{
if (!Demo.PlayersTeam2.Contains(pl))
{
Demo.PlayersTeam2.Add(pl);
}
}
team2.Players.Add(Demo.Players.First(p => p.Equals(pl)));
}
});
}
}
// Add teams
Application.Current.Dispatcher.Invoke(delegate
{
Demo.Teams.Clear();
Demo.Teams.Add(team1);
Demo.Teams.Add(team2);
});
}
public BombPlantedEvent(int tick) : base(tick)
{
Player = new PlayerExtended();
}
public Task <List <Demo> > GetDemosHeader(List <string> folders)
{
List <Demo> demos = new List <Demo>();
for (int i = 0; i < 20; i++)
{
ObservableCollection <PlayerExtended> players = new ObservableCollection <PlayerExtended>();
Random random = new Random();
ObservableCollection <EntryKillEvent> entryKills = new ObservableCollection <EntryKillEvent>();
for (int indexEntryKill = 0; indexEntryKill < random.Next(5); indexEntryKill++)
{
EntryKillEvent entryKill = new EntryKillEvent(random.Next(7000, 100000))
{
Killed = players.ElementAt(random.Next(0, 9)),
KilledTeam = Team.Terrorist,
Killer = players.ElementAt(random.Next(0, 9)),
KillerTeam = Team.CounterTerrorist
};
entryKills.Add(entryKill);
}
for (int j = 0; j < 10; j++)
{
PlayerExtended player = new PlayerExtended
{
Name = "player" + (j + 1),
HeadshotCount = random.Next(14),
OnekillCount = random.Next(10, 30),
TwokillCount = random.Next(10, 20),
ThreekillCount = random.Next(0, 10),
FourKillCount = random.Next(0, 5),
FiveKillCount = random.Next(0, 2),
Clutch1V1Count = random.Next(1),
Clutch1V2Count = random.Next(1),
Clutch1V3Count = random.Next(1),
Clutch1V4Count = random.Next(1),
Clutch1V5Count = random.Next(1),
BombDefusedCount = random.Next(0, 2),
BombPlantedCount = random.Next(0, 2),
EntryKills = entryKills,
DeathCount = random.Next(0, 32),
KillsCount = random.Next(30),
AssistCount = random.Next(15),
Score = random.Next(10, 80),
RoundMvpCount = random.Next(6)
};
players.Add(player);
}
ObservableCollection <Round> rounds = new ObservableCollection <Round>();
for (int k = 0; k < 32; k++)
{
Round round = new Round
{
Number = k + 1,
OneKillCount = random.Next(5),
TwoKillCount = random.Next(2),
ThreeKillCount = random.Next(1),
FourKillCount = random.Next(1),
FiveKillCount = random.Next(1),
EquipementValueTeam1 = random.Next(4200, 30000),
EquipementValueTeam2 = random.Next(4200, 30000),
StartMoneyTeam1 = random.Next(4200, 50000),
StartMoneyTeam2 = random.Next(4200, 50000),
Tick = random.Next(7000, 100000)
};
rounds.Add(round);
}
Demo demo = new Demo
{
Id = "de_dust25445648778447878",
Name = "mydemo" + (i + 1) + ".dem",
Tickrate = 128,
MapName = "de_dust2",
ClientName = "localhost",
Hostname = "local",
OneKillCount = random.Next(50, 90),
TwoKillCount = random.Next(20, 50),
ThreeKillCount = random.Next(10),
FourKillCount = random.Next(3),
FiveKillCount = random.Next(1),
Path = "C:\\mydemo.dem",
ScoreTeam1 = 16,
ScoreTeam2 = 6,
Type = "GOTV",
Comment = "comment",
ScoreFirstHalfTeam1 = 10,
ScoreFirstHalfTeam2 = 5,
ScoreSecondHalfTeam1 = 6,
ScoreSecondHalfTeam2 = 1,
Players = players,
PlayersTeam1 = new ObservableCollection <PlayerExtended>(players.Take(5)),
PlayersTeam2 = new ObservableCollection <PlayerExtended>(players.Skip(5).Take(5)),
MostBombPlantedPlayer = players.ElementAt(random.Next(10)),
MostHeadshotPlayer = players.ElementAt(random.Next(10)),
Rounds = rounds
};
demos.Add(demo);
}
return(Task.FromResult(demos));
}
protected new void HandlePlayerKilled(object sender, PlayerKilledEventArgs e)
{
if (!IsMatchStarted || e.Victim == null)
{
return;
}
Weapon weapon = Weapon.WeaponList.FirstOrDefault(w => w.Element == e.Weapon.Weapon);
if (weapon == null)
{
return;
}
PlayerExtended killed = Demo.Players.FirstOrDefault(player => player.SteamId == e.Victim.SteamID);
PlayerExtended killer = null;
KillEvent killEvent = new KillEvent(Parser.IngameTick, Parser.CurrentTime)
{
KillerSteamId = e.Killer?.SteamID ?? 0,
KillerName = e.Killer?.Name ?? "World",
KillerSide = e.Killer?.Team ?? Team.Spectate,
Weapon = weapon,
KillerVelocityX = e.Killer?.Velocity.X ?? 0,
KillerVelocityY = e.Killer?.Velocity.Y ?? 0,
KillerVelocityZ = e.Killer?.Velocity.Z ?? 0,
KilledSteamId = e.Victim.SteamID,
KilledName = e.Victim.Name,
KilledSide = e.Victim.Team,
RoundNumber = CurrentRound.Number,
IsKillerCrouching = e.Killer?.IsDucking ?? false,
Point = new KillHeatmapPoint
{
KillerX = e.Killer?.Position.X ?? 0,
KillerY = e.Killer?.Position.Y ?? 0,
VictimX = e.Victim.Position.X,
VictimY = e.Victim.Position.Y
},
KillerEntityId = e.Killer?.EntityID ?? -1,
KilledEntityId = e.Victim.EntityID
};
bool killerIsBot = false;
bool victimIsBot = false;
bool assisterIsBot = false;
if (e.Killer != null && e.Killer.SteamID == 0)
{
killerIsBot = true;
}
if (e.Victim.SteamID == 0)
{
victimIsBot = true;
}
if (e.Assister != null && e.Assister.SteamID == 0)
{
assisterIsBot = true;
}
if (e.Killer != null)
{
killer = Demo.Players.FirstOrDefault(player => player.SteamId == e.Killer.SteamID);
}
if (killer != null)
{
if (e.Killer.IsDucking)
{
killer.CrouchKillCount++;
}
if (e.Killer.Velocity.Z > 0)
{
killer.JumpKillCount++;
}
ProcessTradeKill(killEvent);
}
// Human killed human
if (!killerIsBot && !victimIsBot)
{
if (killer != null && killed != null)
{
killed.IsAlive = false;
// TK
if (killer.TeamName == killed.TeamName)
{
killer.TeamKillCount++;
killer.KillsCount--;
if (killer.HeadshotCount > 0)
{
killer.HeadshotCount--;
}
killed.DeathCount++;
}
else
{
// Regular kill
if (!killer.IsControllingBot)
{
killer.KillsCount++;
if (e.Headshot)
{
killer.HeadshotCount++;
}
}
if (!killed.IsControllingBot)
{
killed.DeathCount++;
}
}
}
}
// Human killed a bot
if (!killerIsBot && victimIsBot)
{
if (killer != null)
{
// TK
if (killer.Side == e.Victim.Team)
{
killer.TeamKillCount++;
killer.KillsCount--;
}
else
{
// Regular kill
if (!killer.IsControllingBot)
{
killer.KillsCount++;
if (e.Headshot)
{
killer.HeadshotCount++;
}
}
}
}
}
// A bot killed a human
if (killerIsBot && !victimIsBot && killed != null)
{
// TK or not we add a death to the human
killed.DeathCount++;
}
// Add assist if there was one
if (e.Assister != null && !assisterIsBot && e.Assister.Team != e.Victim.Team)
{
PlayerExtended assister = Demo.Players.FirstOrDefault(player => player.SteamId == e.Assister.SteamID);
if (assister != null)
{
killEvent.AssisterSteamId = e.Assister.SteamID;
killEvent.AssisterName = e.Assister.Name;
assister.AssistCount++;
}
}
// If the killer isn't a bot we can update individual kill, open and entry kills
if (e.Killer != null && killer != null && !killer.IsControllingBot)
{
if (!KillsThisRound.ContainsKey(e.Killer))
{
KillsThisRound[e.Killer] = 0;
}
KillsThisRound[e.Killer]++;
ProcessOpenAndEntryKills(killEvent);
}
ProcessClutches();
Demo.Kills.Add(killEvent);
CurrentRound.Kills.Add(killEvent);
if (AnalyzePlayersPosition)
{
PositionPoint positionPoint = new PositionPoint
{
X = e.Victim.Position.X,
Y = e.Victim.Position.Y,
PlayerSteamId = e.Killer?.SteamID ?? 0,
PlayerName = e.Killer?.Name ?? string.Empty,
Team = e.Killer?.Team ?? Team.Spectate,
Event = killEvent,
RoundNumber = CurrentRound.Number
};
Demo.PositionsPoint.Add(positionPoint);
}
}
public BombDefusedEvent(int tick)
: base(tick)
{
Player = new PlayerExtended();
}
/// <summary>
/// Return PositionPoint for each players determined by selection
/// </summary>
/// <param name="demo"></param>
/// <param name="teamSelector"></param>
/// <param name="selectedPlayer"></param>
/// <param name="round"></param>
/// <returns></returns>
public async Task <List <List <PositionPoint> > > GetPoints(Demo demo, ComboboxSelector teamSelector, PlayerExtended selectedPlayer, Round round)
{
List <List <PositionPoint> > points = new List <List <PositionPoint> >();
if (teamSelector != null)
{
switch (teamSelector.Id)
{
case "CT":
demo.PositionsPoint.Reverse();
foreach (PlayerExtended playerExtended in demo.Players)
{
List <PositionPoint> playerPoints = new List <PositionPoint>();
for (int i = demo.PositionsPoint.Count - 1; i >= 0; i--)
{
if (demo.PositionsPoint[i].RoundNumber != round.Number)
{
continue;
}
// Keep kills from terrorists
if (demo.PositionsPoint[i].Event != null &&
demo.PositionsPoint[i].Team == Team.Terrorist &&
demo.PositionsPoint[i].Event.GetType() == typeof(KillEvent))
{
KillEvent e = (KillEvent)demo.PositionsPoint[i].Event;
if (e.KillerSteamId == playerExtended.SteamId)
{
playerPoints.Add(demo.PositionsPoint[i]);
demo.PositionsPoint.RemoveAt(i);
continue;
}
}
if (demo.PositionsPoint[i].Team != Team.CounterTerrorist)
{
continue;
}
// Molotov started
if (demo.PositionsPoint[i].Event != null &&
demo.PositionsPoint[i].Event.GetType() == typeof(MolotovFireStartedEvent))
{
MolotovFireStartedEvent e = (MolotovFireStartedEvent)demo.PositionsPoint[i].Event;
if (e.ThrowerSteamId == playerExtended.SteamId)
{
playerPoints.Add(demo.PositionsPoint[i]);
demo.PositionsPoint.RemoveAt(i);
continue;
}
}
// Molotov ended
if (demo.PositionsPoint[i].Event != null &&
demo.PositionsPoint[i].Event.GetType() == typeof(MolotovFireEndedEvent))
{
MolotovFireEndedEvent e = (MolotovFireEndedEvent)demo.PositionsPoint[i].Event;
if (e.ThrowerSteamId == playerExtended.SteamId)
{
playerPoints.Add(demo.PositionsPoint[i]);
demo.PositionsPoint.RemoveAt(i);
continue;
}
}
if (demo.PositionsPoint[i].PlayerSteamId != 0 &&
demo.PositionsPoint[i].PlayerSteamId == playerExtended.SteamId)
{
playerPoints.Add(demo.PositionsPoint[i]);
demo.PositionsPoint.RemoveAt(i);
}
}
if (playerPoints.Any())
{
points.Add(playerPoints);
}
}
break;
case "T":
demo.PositionsPoint.Reverse();
foreach (PlayerExtended playerExtended in demo.Players)
{
List <PositionPoint> playerPoints = new List <PositionPoint>();
for (int i = demo.PositionsPoint.Count - 1; i >= 0; i--)
{
if (demo.PositionsPoint[i].RoundNumber != round.Number)
{
continue;
}
// Keep kills from CT
if (demo.PositionsPoint[i].Event != null &&
demo.PositionsPoint[i].Team == Team.CounterTerrorist &&
demo.PositionsPoint[i].Event.GetType() == typeof(KillEvent))
{
KillEvent e = (KillEvent)demo.PositionsPoint[i].Event;
if (e.KilledSteamId == playerExtended.SteamId)
{
playerPoints.Add(demo.PositionsPoint[i]);
demo.PositionsPoint.RemoveAt(i);
continue;
}
}
if (demo.PositionsPoint[i].Team != Team.Terrorist)
{
continue;
}
// Molotov started
if (demo.PositionsPoint[i].Event != null &&
demo.PositionsPoint[i].Event.GetType() == typeof(MolotovFireStartedEvent))
{
MolotovFireStartedEvent e = (MolotovFireStartedEvent)demo.PositionsPoint[i].Event;
if (e.ThrowerSteamId == playerExtended.SteamId)
{
playerPoints.Add(demo.PositionsPoint[i]);
demo.PositionsPoint.RemoveAt(i);
continue;
}
}
// Molotov ended
if (demo.PositionsPoint[i].Event != null &&
demo.PositionsPoint[i].Event.GetType() == typeof(MolotovFireEndedEvent))
{
MolotovFireEndedEvent e = (MolotovFireEndedEvent)demo.PositionsPoint[i].Event;
if (e.ThrowerSteamId == playerExtended.SteamId)
{
playerPoints.Add(demo.PositionsPoint[i]);
demo.PositionsPoint.RemoveAt(i);
continue;
}
}
if (demo.PositionsPoint[i].PlayerSteamId == playerExtended.SteamId)
{
playerPoints.Add(demo.PositionsPoint[i]);
demo.PositionsPoint.RemoveAt(i);
}
}
if (playerPoints.Any())
{
points.Add(playerPoints);
}
}
break;
case "BOTH":
points.AddRange(
demo.Players.Select(
playerExtended => demo.PositionsPoint.Where(
point => point.RoundNumber == round.Number &&
point.PlayerSteamId == playerExtended.SteamId).ToList())
.Where(pts => pts.Any()));
break;
}
}
if (selectedPlayer != null)
{
await Task.Run(delegate
{
List <PositionPoint> pt = demo.PositionsPoint.ToList().Where(
positionPoint => positionPoint.PlayerSteamId == selectedPlayer.SteamId &&
positionPoint.RoundNumber == round.Number ||
(positionPoint.Event != null &&
positionPoint.Event.GetType() == typeof(KillEvent)) &&
positionPoint.RoundNumber == round.Number).ToList();
if (pt.Any())
{
points.Add(pt);
}
});
}
// Set players color
await Task.Run(delegate
{
int index = 0;
foreach (List <PositionPoint> positionPoints in points.ToList())
{
foreach (PositionPoint positionPoint in positionPoints)
{
positionPoint.X = MapService.CalculatePointToResolutionX(positionPoint.X);
positionPoint.Y = MapService.CalculatePointToResolutionY(positionPoint.Y);
positionPoint.Color = ColorToInt(_colors[index]);
}
index++;
}
});
return(points);
}
protected override void HandlePlayerKilled(object sender, PlayerKilledEventArgs e)
{
if (!IsMatchStarted)
{
return;
}
if (e.Killer == null || e.Victim == null)
{
return;
}
KillEvent killEvent = new KillEvent(Parser.IngameTick)
{
Weapon = new Weapon(e.Weapon)
};
killEvent.DeathPerson = Demo.Players.FirstOrDefault(player => player.SteamId == e.Victim.SteamID);
if (killEvent.DeathPerson != null)
{
killEvent.DeathPerson.IsAlive = false;
}
if (e.Assister != null)
{
killEvent.Assister = Demo.Players.FirstOrDefault(player => player.SteamId == e.Assister.SteamID);
}
killEvent.Killer = Demo.Players.FirstOrDefault(player => player.SteamId == e.Killer.SteamID);
if (killEvent.Killer != null)
{
if (!KillsThisRound.ContainsKey(e.Killer))
{
KillsThisRound[e.Killer] = 0;
}
KillsThisRound[e.Killer]++;
ProcessOpenAndEntryKills(killEvent);
}
if (killEvent.DeathPerson != null)
{
killEvent.DeathPerson.DeathCount++;
// TK
if (e.Killer.Team == e.Victim.Team)
{
if (killEvent.Killer != null && killEvent.DeathPerson != null)
{
PlayerExtended player = Demo.Players.FirstOrDefault(p => p.SteamId == e.Killer.SteamID);
if (player != null)
{
player.TeamKillCount++;
}
}
}
else
{
if (killEvent.Killer != null)
{
killEvent.Killer.KillsCount++;
if (e.Headshot)
{
killEvent.Killer.HeadshotCount++;
}
}
}
}
if (killEvent.Assister != null)
{
killEvent.Assister.AssistCount++;
}
ProcessClutches();
if (AnalyzeHeatmapPoint)
{
killEvent.Point = new HeatmapPoint
{
X = e.Victim.Position.X,
Y = e.Victim.Position.Y,
Round = CurrentRound,
Player = killEvent.Killer,
Team = e.Killer.Team
};
}
Demo.Kills.Add(killEvent);
CurrentRound.Kills.Add(killEvent);
if (AnalyzePlayersPosition && killEvent.Killer != null)
{
PositionPoint positionPoint = new PositionPoint
{
X = e.Victim.Position.X,
Y = e.Victim.Position.Y,
Player = Demo.Players.First(p => p.SteamId == e.Killer.SteamID),
Team = e.Killer.Team,
Event = killEvent,
Round = CurrentRound
};
Demo.PositionsPoint.Add(positionPoint);
}
}
public NadeBaseEvent(int tick)
: base(tick)
{
Thrower = new PlayerExtended();
}
public Task <Demo> AnalyzeDemo(Demo demo)
{
Random random = new Random();
ObservableCollection <PlayerExtended> players = new ObservableCollection <PlayerExtended>();
for (int i = 0; i < 10; i++)
{
PlayerExtended player = new PlayerExtended
{
Name = "player" + (i + 1),
HeadshotCount = random.Next(14),
OnekillCount = random.Next(10, 30),
TwokillCount = random.Next(10, 20),
ThreekillCount = random.Next(0, 10),
FourKillCount = random.Next(0, 5),
FiveKillCount = random.Next(0, 2),
Clutch1V1Count = random.Next(1),
Clutch1V2Count = random.Next(1),
Clutch1V3Count = random.Next(1),
Clutch1V4Count = random.Next(1),
Clutch1V5Count = random.Next(1),
BombDefusedCount = random.Next(0, 2),
BombPlantedCount = random.Next(0, 2),
DeathCount = random.Next(0, 32),
KillsCount = random.Next(30),
AssistCount = random.Next(15),
Score = random.Next(10, 80),
RoundMvpCount = random.Next(6),
RankNumberNew = 5,
RankNumberOld = 4,
RatingHltv = (float)random.NextDouble(),
SteamId = random.Next(1000, 800000),
IsOverwatchBanned = random.Next(100) < 40,
IsVacBanned = random.Next(100) < 40,
TeamKillCount = random.Next(0, 1),
WinCount = random.Next(10, 687)
};
players.Add(player);
ObservableCollection <EntryKillEvent> entryKills = new ObservableCollection <EntryKillEvent>();
for (int indexEntryKill = 0; indexEntryKill < random.Next(5); indexEntryKill++)
{
EntryKillEvent entryKill = new EntryKillEvent(random.Next(7000, 100000))
{
Killed = players.ElementAt(random.Next(0, 9)),
KilledTeam = Team.Terrorist,
Killer = players.ElementAt(random.Next(0, 9)),
KillerTeam = Team.CounterTerrorist
};
entryKills.Add(entryKill);
}
ObservableCollection <OpenKillEvent> openKills = new ObservableCollection <OpenKillEvent>();
for (int indexOpenKill = 0; indexOpenKill < random.Next(5); indexOpenKill++)
{
OpenKillEvent openKill = new OpenKillEvent(random.Next(7000, 100000))
{
Killed = players.ElementAt(random.Next(0, 9)),
KilledTeam = Team.Terrorist,
Killer = players.ElementAt(random.Next(0, 9)),
KillerTeam = Team.CounterTerrorist
};
openKills.Add(openKill);
}
players.Last().EntryKills = entryKills;
players.Last().OpeningKills = openKills;
}
ObservableCollection <TeamExtended> teams = new ObservableCollection <TeamExtended>
{
new TeamExtended
{
Name = "Team 1",
Players = new ObservableCollection <PlayerExtended>(players.Take(5))
},
new TeamExtended
{
Name = "Team 2",
Players = new ObservableCollection <PlayerExtended>(players.Skip(5).Take(5))
}
};
ObservableCollection <Round> rounds = new ObservableCollection <Round>();
for (int i = 0; i < 32; i++)
{
Round round = new Round
{
Number = i + 1,
OneKillCount = random.Next(5),
TwoKillCount = random.Next(2),
ThreeKillCount = random.Next(1),
FourKillCount = random.Next(1),
FiveKillCount = random.Next(1),
EquipementValueTeam1 = random.Next(4200, 30000),
EquipementValueTeam2 = random.Next(4200, 30000),
StartMoneyTeam1 = random.Next(4200, 50000),
StartMoneyTeam2 = random.Next(4200, 50000),
Tick = random.Next(7000, 100000),
WinnerClanName = teams[random.Next(0, 2)].Name
};
rounds.Add(round);
}
demo.Id = "de_dust25445648778447878";
demo.Source = new Valve();
demo.Name = "esea_nip_vs_titan.dem";
demo.Tickrate = 15;
demo.ServerTickrate = 128;
demo.MapName = "de_dust2";
demo.ClientName = "localhost";
demo.Hostname = "local";
demo.OneKillCount = 90;
demo.TwoKillCount = 30;
demo.ThreeKillCount = 25;
demo.FourKillCount = 3;
demo.FiveKillCount = 1;
demo.Path = "C:\\mydemo.dem";
demo.ScoreTeam1 = 16;
demo.ScoreTeam2 = 6;
demo.Type = "GOTV";
demo.Comment = "comment";
demo.ScoreFirstHalfTeam1 = 10;
demo.ScoreFirstHalfTeam2 = 5;
demo.ScoreSecondHalfTeam1 = 6;
demo.ScoreSecondHalfTeam2 = 1;
demo.Players = players;
demo.PlayersTeam1 = teams[0].Players;
demo.PlayersTeam2 = teams[1].Players;
demo.MostBombPlantedPlayer = players.ElementAt(random.Next(10));
demo.MostHeadshotPlayer = players.ElementAt(random.Next(10));
demo.MostEntryKillPlayer = players.ElementAt(random.Next(10));
demo.MostKillingWeapon = new Weapon
{
Name = "AK-47"
};
demo.Teams = teams;
demo.Rounds = rounds;
return(Task.FromResult(demo));
}
private static void UpdateMapStats(Demo demo, Models.Map map)
{
map.MatchCount++;
map.RoundCount += demo.Rounds.Count();
map.BombPlantedCount += demo.BombPlantedCount;
map.BombDefusedCount += demo.BombDefusedCount;
map.BombExplodedCount += demo.BombExplodedCount;
foreach (Round round in demo.Rounds)
{
if (Properties.Settings.Default.SelectedStatsAccountSteamID != 0)
{
PlayerExtended player = demo.Players.FirstOrDefault(p => p.SteamId == Properties.Settings.Default.SelectedStatsAccountSteamID);
if (player != null)
{
if (player.TeamName != round.WinnerName)
{
continue;
}
}
}
if (round.WinnerSide == Team.CounterTerrorist)
{
map.WinCounterTerroritsCount++;
}
if (round.WinnerSide == Team.Terrorist)
{
map.WinTerroristCount++;
}
if (round.SideTrouble != Team.Spectate)
{
switch (round.Type)
{
case RoundType.ECO:
map.WinEcoRoundCount++;
break;
case RoundType.SEMI_ECO:
map.WinSemiEcoCount++;
break;
case RoundType.FORCE_BUY:
map.WinForceBuyCount++;
break;
case RoundType.PISTOL_ROUND:
map.WinPistolRoundCount++;
break;
}
}
}
foreach (BombPlantedEvent plantedEvent in demo.BombPlanted)
{
if (Properties.Settings.Default.SelectedStatsAccountSteamID != 0 &&
plantedEvent.PlanterSteamId != Properties.Settings.Default.SelectedStatsAccountSteamID)
{
continue;
}
if (plantedEvent.Site == "A")
{
map.BombPlantedOnACount++;
}
else
{
map.BombPlantedOnBCount++;
}
}
}
public async Task SavePlayerExtendedAsync(PlayerExtended player)
{
_logger.LogDebug("Saving Player Extended {0}", player.UserId);
await PlayersExtendedCollection.ReplaceOneAsync(p => p.PlayerId == player.UserId, player, s_upsertOptions);
}
public NadeBaseEvent(int tick)
: base(tick)
{
Thrower = new PlayerExtended();
}
