public Dsreplay(DsReplayDto dto)
{
Dsplayers = dto.DSPlayer.Select(s => new Dsplayer()
{
Breakpoints = s.Breakpoints.Select(b => new Breakpoint()
{
Breakpoint1 = b.Breakpoint,
Gas = b.Gas,
Income = b.Income,
Army = b.Army,
Kills = b.Kills,
Upgrades = b.Upgrades,
Tier = b.Tier,
Mid = b.Mid,
DsUnitsString = b.dsUnitsString,
DbUnitsString = b.dbUnitsString,
DbUpgradesString = b.dbUpgradesString
}).ToList(),
Pos = (byte)s.POS,
Realpos = (byte)s.REALPOS,
Name = s.NAME,
Race = (byte)DSData.GetCommander(s.RACE),
Opprace = (byte)DSData.GetCommander(s.OPPRACE),
Win = s.WIN,
Team = (byte)s.TEAM,
Killsum = s.KILLSUM,
Income = s.INCOME,
Pduration = s.PDURATION,
Army = s.ARMY,
Gas = (byte)s.GAS,
isPlayer = s.isPlayer
}).ToList();
Middles = dto.Middle.Select(m => new Middle()
{
Gameloop = m.Gameloop,
Team = (byte)m.Team
}).ToList();
Replay = dto.REPLAY;
Gametime = dto.GAMETIME;
Winner = (sbyte)dto.WINNER;
Duration = dto.DURATION;
Minkillsum = dto.MINKILLSUM;
Maxkillsum = dto.MAXKILLSUM;
Minarmy = dto.MINARMY;
Minincome = dto.MININCOME;
Maxleaver = dto.MAXLEAVER;
Playercount = (byte)dto.PLAYERCOUNT;
Reported = (byte)dto.REPORTED;
Isbrawl = dto.ISBRAWL;
Gamemode = (byte)DSData.GetGameMode(dto.GAMEMODE);
Version = dto.VERSION;
Hash = dto.HASH;
Replaypath = dto.REPLAYPATH;
Objective = dto.OBJECTIVE;
Upload = dto.Upload;
Bunker = dto.Bunker;
Cannon = dto.Cannon;
Mid1 = dto.Mid1;
Mid2 = dto.Mid2;
}
private void InsertReplay(DsReplayDto replay, List <string> playerNames)
{
var dbReplay = new Dsreplay(replay);
dbReplay.Dsplayers.Where(x => playerNames.Contains(x.Name)).ToList().ForEach(x => x.isPlayer = true);
ReplayFilter.SetDefaultFilter(new List <Dsreplay>()
{
dbReplay
});
DbService.SetMid(dbReplay);
insertService.AddReplay(dbReplay);
}
private static DsReplayDto?GetReplayDto(Sc2Replay replay)
{
if (replay.Details == null || replay.TrackerEvents == null)
{
return(null);
}
DsReplayDto replayDto = new DsReplayDto();
ParseDetails(replayDto, replay.Details);
ParseTrackerEvents(replayDto, replay.TrackerEvents);
return(replayDto);
}
private async Task ProduceReplays(List <string> replayPaths, CancellationToken token)
{
try
{
ParallelOptions po = new ParallelOptions()
{
MaxDegreeOfParallelism = Threads,
CancellationToken = token
};
await Parallel.ForEachAsync(replayPaths, po, async (data, token) =>
{
Interlocked.Increment(ref producerCount);
logger.LogInformation($"working on {Path.GetFileName(data)}");
DsReplayDto replayDto = null;
await Task.Run(() => { replayDto = DsDecodeService.DecodeReplay(AppPath, data, token); }, token);
if (replayDto != null)
{
InsertReplay(replayDto, PlayerNames);
Interlocked.Increment(ref decodeCount);
}
else
{
FailedReplays.Add(data);
}
Interlocked.Decrement(ref producerCount);
po.CancellationToken.ThrowIfCancellationRequested();
});
}
catch (OperationCanceledException)
{
insertService.Cancel();
}
catch (Exception ex)
{
logger.LogError(ex.Message);
}
finally
{
PrducerFinished();
}
logger.LogInformation($"producer job finished.");
}
private static void ParseTrackerUnitEvents(DsReplayDto replay, ICollection <SUnitBornEvent> bornEvents, ICollection <SUnitDiedEvent> diedEvents, ICollection <SUnitTypeChangeEvent> changeEvents)
{
SUnitBornEvent?nexusBornEvent = null;
SUnitBornEvent?planetaryBornEvent = null;
List <SUnitBornEvent> Refineries = new List <SUnitBornEvent>();
List <SUnitBornEvent> Units = new List <SUnitBornEvent>();
int i = 0;
foreach (SUnitBornEvent bornEvent in bornEvents)
{
i++;
DSPlayerDto?player = null;
bool noStagingAreaNextSpawn = false;
if (replay.GAMETIME < new DateTime(2019, 03, 24, 21, 46, 15))
{
noStagingAreaNextSpawn = true;
}
if (bornEvent.UnitTypeName.StartsWith("Worker"))
{
player = replay.DSPlayer.SingleOrDefault(f => f.POS == bornEvent.ControlPlayerId);
if (player == null)
{
player = replay.DSPlayer.SingleOrDefault(s => s.REALPOS == bornEvent.ControlPlayerId - 1);
if (player == null)
{
continue;
}
else
{
player.POS = bornEvent.ControlPlayerId;
}
}
player.REALPOS = 0;
player.RACE = bornEvent.UnitTypeName[6..];
private void DecodeReplay(string replayPath, CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
Interlocked.Increment(ref activeThreads);
string id = Path.GetFileNameWithoutExtension(replayPath);
logger.LogDebug($"Decoding replay {id} on {activeThreads} threads.");
try
{
dynamic MPQArchive = scriptScope.GetVariable("MPQArchive");
var archive = MPQArchive(replayPath);
var contents = archive.header["user_data_header"]["content"];
var versions = scriptScope.GetVariable("versions");
dynamic header = null;
lock (lockObject)
{
header = versions.latest().decode_replay_header(contents);
}
var baseBuild = header["m_version"]["m_baseBuild"];
var protocol = versions.build(baseBuild);
// details
var details_enc = archive.read_file("replay.details");
lib.Models.DSReplay replay = null;
var details_dec = protocol.decode_replay_details(details_enc);
replay = DetailsService.GetDetails(details_dec);
if (replay == null)
{
throw new Exception($"Decoding details for {id} failed.");
}
replay.REPLAYPATH = replayPath;
logger.LogDebug($"Got replay details with {replay.DSPlayer.Count} player.");
// trackerevents
var trackerevents_enc = archive.read_file("replay.tracker.events");
var trackerevents_dec = protocol.decode_replay_tracker_events(trackerevents_enc);
TrackerEventsService.GetTrackerEvents(replay, trackerevents_dec);
Initialize.Replay(replay, false);
var json = JsonSerializer.Serialize(replay);
DsReplayDto newreplay = JsonSerializer.Deserialize <DsReplayDto>(json, new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
newreplay.VERSION = Version.ToString();
Replays.Add(new Dsreplay(newreplay));
}
catch (Exception e)
{
FailedReplays.Add(replayPath);
logger.LogError($"Failed decoding replay {id}: {e.Message}");
}
finally
{
Interlocked.Decrement(ref activeThreads);
Interlocked.Increment(ref replaysDone);
}
}
private static void ParseUpgradeEvents(DsReplayDto replay, ICollection <SUpgradeEvent> upgradeEvetns)
{
foreach (SUpgradeEvent upgradeEvent in upgradeEvetns)
{
}
}
private static void ParseTrackerEvents(DsReplayDto replay, TrackerEvents trackerEvents)
{
ParseTrackerUnitEvents(replay, trackerEvents.SUnitBornEvents, trackerEvents.SUnitDiedEvents, trackerEvents.SUnitTypeChangeEvents);
ParseUpgradeEvents(replay, trackerEvents.SUpgradeEvents);
}
