public static void Setup(TestContext context)
{
var replayData = ReplayParser.FromTextReader(TestDataReader.GetInputFile("Power_2.log.txt"));
//var replayData = ReplaySerializer.Deserialize(TestDataReader.GetInputFile("Power_2.log.xml"));
_replay = new Replay(replayData);
_replay.LoadGame(0);
}
public void BundlesWithVisitor()
{
var files = Bundles.All.SelectMany(Directory.EnumerateFiles);
var visitor = new Shanten5EvaluatingVisitor();
foreach (var file in files)
{
ReplayParser.Parse(file, visitor);
}
Assert.Equal(0, visitor.ErrorCount);
}
public void ParseTest03()
{
var replayParser = new ReplayParser();
var memoryStream = new MemoryStream(ReplayParserTestResources._3v3_Tourney_Viteska_Brigada_B5P);
var replayDto = replayParser.ParseFile(memoryStream);
Assert.IsNotNull(replayDto);
Assert.AreEqual(1, replayDto.IsNetworkMode);
Assert.AreEqual("430000610", replayDto.Version);
}
public void ParseTest02()
{
var replayParser = new ReplayParser();
var memoryStream = new MemoryStream(ReplayParserTestResources.WRG_B5P_vs_1144_Tough_Jungle);
var replayDto = replayParser.ParseFile(memoryStream);
Assert.IsNotNull(replayDto);
Assert.AreEqual(1, replayDto.IsNetworkMode);
Assert.AreEqual("430000610", replayDto.Version);
}
private void btnBrowse_Click(object sender, RoutedEventArgs e)
{
using (OpenFileDialog openFileDialog = new OpenFileDialog())
{
openFileDialog.Filter = "Replay files (*.wotreplay)|*.wotreplay";
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
SelectReplay(ReplayParser.Parse(openFileDialog.FileName));
}
}
}
public void BundlesWithClassicVisitor()
{
var files = Bundles.All.SelectMany(Directory.EnumerateFiles);
var visitor = new ClassicScoreCalculatingVisitor();
foreach (var file in files)
{
ReplayParser.Parse(file, visitor);
}
Assert.Equal(0, visitor.FailureCount);
}
private void listReplays_SelectedIndexChanged(object sender, EventArgs e)
{
string replayName = (string)listReplays.SelectedItem;
if (!replayName.Equals("Set playback directory"))
{
try
{
ReplayParser replayFile = new ReplayParser((string)Settings.Default["PlaybackDir"] + "\\" + replayName + ".rec");
Replay replay = replayFile.Parse();
TimeSpan duration = new TimeSpan(0, 0, replay.Duration / 8);
replayInfo.Clear();
replayInfo.AppendText("Name: " + replayName + Environment.NewLine);
replayInfo.AppendText("Version: 3.0.0." + replay.Version + Environment.NewLine);
replayInfo.AppendText("Map: " + replay.MapFile + Environment.NewLine);
replayInfo.AppendText("Length: " + string.Format("{0:0}:{1:00}:{2:00}", duration.Hours, duration.Minutes, duration.Seconds) + Environment.NewLine);
replayInfo.AppendText("Date: " + replay.Date + Environment.NewLine);
replayInfo.AppendText("Win Condition: " + replay.WinCondition);
gridTeam1.Rows.Clear();
gridTeam2.Rows.Clear();
ResourceManager resources = new ResourceManager("CoH2ReplayTools.Properties.Resources", typeof(mainForm).Assembly);
foreach (Player player in replay.Players)
{
if (player.TeamID == 0)
{
gridTeam1.Rows.Add(resources.GetObject("_" + player.FactionID) as Image, player.Name, "--", player.SteamID);
}
else
{
gridTeam2.Rows.Add(resources.GetObject("_" + player.FactionID) as Image, player.Name, "--", player.SteamID);
}
}
}
catch (InvalidVersionException ex) { MessageBox.Show(ex.Message); }
}
}
public void ParseTest01()
{
var replayParser = new ReplayParser();
var memoryStream = new MemoryStream(ReplayParserTestResources.Steel_Balalaika_vs_We_suck_at_wargame_3vs3);
var replayDto = replayParser.ParseFile(memoryStream);
Assert.IsNotNull(replayDto);
Assert.AreEqual(1, replayDto.IsNetworkMode);
Assert.AreEqual("430000610", replayDto.Version);
Assert.AreEqual("1", replayDto.GameMode);
Assert.AreEqual(6, replayDto.NbMaxPlayer);
Assert.AreEqual(0, replayDto.NbAI);
Assert.AreEqual("0", replayDto.GameType);
Assert.AreEqual(1, replayDto.Private);
Assert.AreEqual(3000, replayDto.InitMoney);
Assert.AreEqual(2400, replayDto.TimeLimit);
Assert.AreEqual(500, replayDto.ScoreLimit);
Assert.AreEqual("Игра (|:Serega:|)", replayDto.ServerName);
}
static void Main(string[] args)
{
//Create logging level switch to allow for logger level to be changed to what is inside config, after logger initialization
LoggingLevelSwitch lls = new LoggingLevelSwitch();
//Initialize logger
Log.Logger = new LoggerConfiguration()
.MinimumLevel.ControlledBy(lls)
.WriteTo.Console()
.WriteTo.File("logs/logfile.log", rollingInterval: RollingInterval.Day)
.CreateLogger();
Log.Debug("Starting up");
Log.Debug("Shutting down");
//Load config file
ConfigLoader cfgLoader = new ConfigLoader();
Config cfg = cfgLoader.Load();
//Change logger depth to that stated in config
lls.MinimumLevel = cfg.LogDepth;
Database dm = DatabaseParser.Parse(cfg.DatabasePath);
string file = "";
while (!File.Exists(file))
{
Log.Information("Drag and drop the replay file, or input the file path: ");
file = Console.ReadLine();
if (!File.Exists(file))
{
Log.Error("File not found.");
}
}
Replay r = ReplayParser.Parse(file);
}
public static void Normalize(TextReader input, TextWriter output)
{
using (var writer = new JsonTextWriter(output)
{
CloseOutput = false
})
{
var parser = new ReplayParser(input);
while (!parser.IsEof)
{
if (parser.IsArray())
{
writer.WriteStartArray();
parser.Down();
}
else if (!parser.HasMoreElements)
{
writer.WriteEndArray();
parser.Up();
}
else if (parser.IsNumber())
{
writer.WriteValue(parser.ReadDouble());
}
else if (parser.IsString())
{
writer.WriteValue(parser.ReadString());
}
else
{
throw new InvalidOperationException();
}
}
writer.Flush();
}
}
public static async Task CheckPlayback(ILogger logger)
{
while (true)
{
// No temp.rec
if (!File.Exists(Constants.TempRecPath))
{
Thread.Sleep(30000);
continue;
}
// File is in use
bool isOpened = FileHelper.IsOpened(Constants.TempRecPath);
if (isOpened)
{
Thread.Sleep(30000);
continue;
}
bool isWarningsOpened = true;
while (isWarningsOpened)
{
isWarningsOpened = FileHelper.IsOpened(Path.Combine(Constants.SoulstormInstallPath, "warnings.log"));
Thread.Sleep(5000);
}
bool?isCurrentFileDueToPlayback = FileHelper.IsCurrentFilePlayback();
if (isCurrentFileDueToPlayback == true || isCurrentFileDueToPlayback == null)
{
Thread.Sleep(30000);
continue;
}
// Couldn't parse rec file
RelicChunkyData replayData = ReplayParser.Fetch(Constants.TempRecPath);
if (replayData == null)
{
Thread.Sleep(60000);
continue;
}
// Not a dowpro game
if (replayData.ModName != "dowpro" && replayData.ModName != "dowprotest")
{
Thread.Sleep(60000);
continue;
}
string modVersion = FileHelper.GetVersion(replayData.ModName);
string savedFileName = $"{replayData.MapName}_{DateTime.UtcNow.ToString("MMddyyyy-HHmmss")}.rec";
string savedFilePath = Path.Combine(Constants.PlayBackPath, savedFileName);
FileHelper.CopyRelicChunkyFile(Constants.TempRecPath, savedFilePath, replayData);
// Already saved
if (FileHelper.IsAlreadySaved(Constants.PlayBackPath, savedFileName))
{
File.Delete(savedFilePath);
Thread.Sleep(30000);
continue;
}
string resultFilePath = Path.Combine(
Constants.SoulstormInstallPath,
"Profiles",
FileHelper.GetPlayerProfile(),
"testStats.Lua");
GameResult result = LuaParser.ParseGameResult(resultFilePath);
result.ModVersion = modVersion;
result.ModName = replayData.ModName;
string playerName = FileHelper.GetPlayerName();
// verify if we should send
// only winners send results
// only 1vs1 are sent
// only player vs player
// 3.30 minutes duration minimum
string discardedGameReason = string.Empty;
if (result == null)
{
discardedGameReason = "Lua game result was null.";
}
else
{
if (result.TeamsCount != 2 || result.PlayersCount != 2 || result.Players.Count != 2)
{
discardedGameReason = "Game was not a 1vs1.";
}
if (string.IsNullOrEmpty(result.WinCondition))
{
discardedGameReason = "Game had no win condition.";
}
if (!result.Players
.Where(el => el.Name == playerName)
.Where(el => el.IsHuman)
.Where(el => el.IsAmongWinners)
.Any())
{
discardedGameReason = "Only winners send game results.";
}
if (!result.Players.All(el => el.IsHuman))
{
discardedGameReason = "Game was vs A.I.";
}
if (result.Duration < 210)
{
discardedGameReason = "Game duration was below 3.30 minutes.";
}
}
if (string.IsNullOrEmpty(discardedGameReason))
{
// should prob check if result and replay match
string jsonPath = Path.Combine(Constants.SoulstormInstallPath, "ReplaysWatcher", "result.json");
FileHelper.SaveAsJson(jsonPath, result);
string archivePath = Path.Combine(Constants.SoulstormInstallPath, "ReplaysWatcher", "arc.zip");
FileHelper.DeleteIfExists(archivePath);
ArchiveHelper.CreateZipFile(archivePath, new List <string>()
{
savedFilePath,
jsonPath
});
string unsentLadderFileName = $"{replayData.MapName}_{DateTime.UtcNow.ToString("MMddyyyy-HHmmss")}.ladder";
string unsentLadderFilePath = Path.Combine(Constants.SoulstormInstallPath, "Playback", "Unsent Ladder Games", unsentLadderFileName);
CryptoHelper.EncryptFile(
archivePath,
unsentLadderFilePath);
byte[] archiveData = File.ReadAllBytes(archivePath);
// Send
string uploadResult = await DoWproLadderApi.SendResult(archiveData);
if (uploadResult == "Added" ||
uploadResult.StartsWith("Unable to unzip ") ||
uploadResult.StartsWith("Unable to locate replay file for ") ||
uploadResult.StartsWith("Unable to compute file hash for") ||
uploadResult.EndsWith("Already exists in db store") ||
uploadResult.StartsWith("Unable to parse game result for") ||
uploadResult.StartsWith("Results did not match for") ||
uploadResult.StartsWith("Invalid players count for")
)
{
File.Delete(unsentLadderFilePath);
}
logger.WriteEntry($"{DateTime.Now} - {savedFileName} : {uploadResult}");
FileHelper.DeleteIfExists(archivePath);
FileHelper.DeleteIfExists(jsonPath);
}
else
{
logger.WriteEntry($"{DateTime.Now} - {savedFileName} : {discardedGameReason}");
Thread.Sleep(30000);
}
}
}
public void Test()
{
var replay = ReplayParser.FromTextReader(TestDataReader.GetInputFile("Power_3.log.txt"));
ReplaySerializer.Serialize(replay, "r3.xml");
}
