public void RemovesAllkindsOfWhitespacesTest()
{
var game = new PgnGame();
var move = new PgnMove();
_state.OnEnter(move);
_state.Parse('h', 'e', game);
_state.Parse('e', 'l', game);
_state.Parse('l', 'l', game);
_state.Parse('l', 'o', game);
_state.Parse('o', '\t', game);
_state.Parse('\t', ' ', game);
_state.Parse(' ', 'w', game);
_state.Parse('w', 'o', game);
_state.Parse('o', 'r', game);
_state.Parse('r', 'l', game);
_state.Parse('l', 'd', game);
_state.Parse('d', '\r', game);
_state.Parse('\r', '\n', game);
_state.OnExit();
Assert.AreEqual("hello world", move.Comment);
}
public void WhiteTagTest()
{
var game = new PgnGame();
var move = new PgnMove();
_state.OnEnter(move);
_state.Parse('W', 'h', game);
_state.Parse('h', 'i', game);
_state.Parse('i', 't', game);
_state.Parse('t', 'e', game);
_state.Parse('e', ' ', game);
_state.Parse(' ', '"', game);
_state.Parse('"', 'A', game);
_state.Parse('A', 'n', game);
_state.Parse('n', 'a', game);
_state.Parse('a', 'n', game);
_state.Parse('n', 'd', game);
_state.Parse('d', '"', game);
_state.Parse('"', ']', game);
_state.OnExit();
PgnTag tag;
game.TryGetTag(PgnTag.White, out tag);
Assert.AreEqual("Anand", tag.Value);
}
public void DrawResultTest()
{
var game = new PgnGame();
var move = new PgnMove();
_state.OnEnter(move);
_state.Parse('1', '.', game);
_state.Parse('.', 'e', game);
_state.Parse('e', '4', game);
_state.Parse('4', ' ', game);
_state.Parse(' ', '1', game);
_state.Parse('1', '/', game);
_state.Parse('/', '2', game);
_state.Parse('2', '-', game);
_state.Parse('-', '1', game);
_state.Parse('1', '/', game);
_state.Parse('/', '2', game);
var result = _state.Parse('2', ' ', game);
_state.OnExit();
Assert.AreEqual("1/2-1/2", game.Result);
Assert.AreEqual(PgnParseResult.EndOfGame, result);
}
public void UnknownTagTest()
{
var game = new PgnGame();
var move = new PgnMove();
_state.OnEnter(move);
_state.Parse('N', 'o', game);
_state.Parse('o', 't', game);
_state.Parse('t', 'O', game);
_state.Parse('O', 'K', game);
_state.Parse('K', ' ', game);
_state.Parse(' ', '"', game);
_state.Parse('"', 'A', game);
_state.Parse('A', 'n', game);
_state.Parse('n', 'a', game);
_state.Parse('a', 'n', game);
_state.Parse('n', 'd', game);
_state.Parse('d', '"', game);
_state.Parse('"', ']', game);
_state.OnExit();
PgnTag tag;
game.TryGetTag("NotOK", out tag);
Assert.AreEqual("Anand", tag.Value);
}
public void EventTagTest()
{
var game = new PgnGame();
var move = new PgnMove();
_state.OnEnter(move);
_state.Parse('E', 'v', game);
_state.Parse('v', 'e', game);
_state.Parse('e', 'n', game);
_state.Parse('n', 't', game);
_state.Parse('t', ' ', game);
_state.Parse(' ', '"', game);
_state.Parse('"', 'c', game);
_state.Parse('c', 'o', game);
_state.Parse('o', 'o', game);
_state.Parse('o', 'l', game);
_state.Parse('l', '"', game);
_state.Parse('"', ']', game);
_state.OnExit();
PgnTag tag;
game.TryGetTag(PgnTag.Event, out tag);
Assert.AreEqual("cool", tag.Value);
}
private TimeSpan Play(bool parallelise)
{
var previousFf = FeatureFlags.ParalleliseRefreshAllPaths;
FeatureFlags.ParalleliseRefreshAllPaths = parallelise;
TimeSpan elapsed;
var stopwatch = Stopwatch.StartNew();
try
{
var pgnGame = PgnGame.ReadAllGamesFromString(WikiGame.PgnText).First();
PlaySingleGame(pgnGame);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
finally
{
elapsed = stopwatch.Elapsed;
FeatureFlags.ParalleliseRefreshAllPaths = previousFf;
}
return(elapsed);
}
private static void PlayTurns(PgnGame game, ChessGame chessGame)
{
PgnTurn lastTurn = null;
try
{
foreach (var gameTurn in game.Turns)
{
lastTurn = gameTurn;
if (gameTurn.White != null)
{
chessGame.Move(gameTurn.White.San);
}
if (gameTurn.Black != null)
{
chessGame.Move(gameTurn.Black.San);
}
}
}
catch (Exception e)
{
throw new Exception($"Problem with: {lastTurn}", e);
}
}
// [TestCase(@".\PGNFiles")]
// [TestCase(@"D:\Src\PGNArchive\PGN")]
public void ParseAllFiles(string path)
{
var pgnfiles = Directory.GetFiles(path, "*.pgn", SearchOption.AllDirectories);
var fileCount = 0;
var gamesCount = 0;
var fileGamesCount = 0;
foreach (var file in pgnfiles)
{
fileCount++;
if (file.Contains("FAILED"))
{
continue;
}
try
{
var games = PgnGame.ReadAllGamesFromString(File.ReadAllText(file));
// DumpGameInfo(game);
gamesCount += games.Count();
}
catch
{
Console.WriteLine($"Failed: {file}\nGame Idx: {fileCount}/{fileGamesCount}");
throw;
}
fileGamesCount = 0;
}
TestContext.Progress.WriteLine($"Files #: {fileCount}, Total Games #: {gamesCount}");
Assert.That(fileCount, Is.GreaterThan(0), "No files processed");
Assert.That(gamesCount, Is.GreaterThan(0), "No games processed");
}
public PgnJson(PgnGame game)
{
game.TagPairs.ToList().ForEach(tp => Add(tp.Name, tp.Value));
Add("Moves", game.MoveText);
Moves = game.MoveText;
}
[Explicit("WARNING: Could take a long time.")] // NEVER COMMIT THIS !!!!!!!!!!!!!!!!!!!!!!!!!
public void Measure_parse_game_time_100_games()
{
var filename = @"D:\Src\PGNArchive\PGN\Modern100.pgn";
TestContext.Progress.WriteLine($"Playing all games from;");
TestContext.Progress.WriteLine($" {filename}");
PlayAllGames(PgnGame.ReadAllGamesFromFile(filename));
TestContext.Progress.WriteLine($" {filename} complete!");
}
private static string NormaliseMoveText(PgnGame pgnGame)
{
return(pgnGame.MoveText
.Replace("\n", " ")
.Replace("\r", " ")
.Replace(" ", " ")
.Replace("{ ", "{")
.Replace(" }", "}"));
}
public void Wiki_games_FromString_works()
{
var games = PgnGame.ReadAllGamesFromString(
WikiGame.PgnText + "\n" +
WikiGame.PgnText).ToList();
AssertWikiGameIsCorrect(games[0]);
AssertWikiGameIsCorrect(games[1]);
}
// http://www.saremba.de/chessgml/standards/pgn/pgn-complete.htm
public static PgnGame ParseGame(string pgnData)
{
PgnGame game = new PgnGame
{
SevenTagRoster = PgnSevenTagRosterParser.Parse(pgnData),
Turns = PgnMoveTextParser.Parse(pgnData)
};
return(game);
}
/// <summary>
/// Return a canonicalized string with the values of the seven tags.
/// This string is formed by putting each tag of the seven-tag-roster
/// on a line with the format:
/// <code>Name=url-encoded-value</code>
/// The string will end in a trailing newline.
/// </summary>
/// <param name="pgnGame">The PGN game to create the canonicalized stream for.</param>
/// <returns>The canonicalized tag string.</returns>
internal static string CanonicalizeTags(PgnGame pgnGame)
{
var builder = new StringBuilder();
foreach (var tagName in SevenTagRoster)
{
var tagValue = pgnGame.AllTags[tagName].Value;
builder.AppendLine($"{tagName}={HttpUtility.UrlEncode(tagValue)}");
}
return(builder.ToString());
}
public void SmokeTest()
{
var game = new PgnGame();
var move = new PgnMove();
_state.OnEnter(move);
_state.Parse('h', 'a', game);
_state.OnExit();
Assert.AreEqual("h", move.Comment);
}
public PgnGame Build()
{
return(PgnGame.ReadAllGamesFromString(
PgnText
.Replace("{Event}", _event)
.Replace("{Site}", _site)
.Replace("{Date}", _date)
.Replace("{Round}", _round)
.Replace("{White}", _white)
.Replace("{Black}", _black)
.Replace("{Result}", _result)
).Single());
}
public void WorstMoveNagTest()
{
var game = new PgnGame();
var move = new PgnMove();
_state.OnEnter(move);
_state.Parse('9', ' ', game);
_state.OnExit();
Assert.AreEqual("(worst move)", move.Annotation);
}
public void GoodMoveNagTest()
{
var game = new PgnGame();
var move = new PgnMove();
_state.OnEnter(move);
_state.Parse('1', ' ', game);
_state.OnExit();
Assert.AreEqual("!", move.Annotation);
}
[Explicit("WARNING: Could take a long time.")] // NEVER COMMIT THIS !!!!!!!!!!!!!!!!!!!!!!!!!
public void Measure_parse_wiki_game_time_100_games()
{
var times = new List <TimeSpan>();
for (int i = 0; i < 100; i++)
{
var sw = Stopwatch.StartNew();
PlayAllGames(PgnGame.ReadAllGamesFromString(WikiGame.PgnText));
times.Add(sw.Elapsed);
}
TestContext.Progress.WriteLine($"Average Game Parse TIme: { new TimeSpan(Convert.ToInt64(times.Average(ts => ts.Ticks)))}");
}
public void UnknownNagTest()
{
var game = new PgnGame();
var move = new PgnMove();
_state.OnEnter(move);
_state.Parse('1', '2', game);
_state.Parse('2', '0', game);
_state.OnExit();
Assert.AreEqual("$12", move.Annotation);
}
/// <summary>
/// Return a canonicalized string with each main-line move added,
/// with any symbols removed (no checks, no mates). Each ply is
/// added on its own line, with a trailing newline character.
/// </summary>
/// <param name="pgnGame">The PGN game to create the canonicalized stream for.</param>
/// <returns>The canonicalized tag string.</returns>
internal static string CanonicalizeMainLine(PgnGame pgnGame)
{
var builder = new StringBuilder();
foreach (var ply in pgnGame.MainLineAsList)
{
string plyText = ply.San;
plyText = plyText
.Replace("+", string.Empty)
.Replace("#", string.Empty);
builder.AppendLine(plyText);
}
return(builder.ToString());
}
public bool MatchGame(PgnGame game, PgnGameFinderService.FindOptions options)
{
var stringComparisons = new List <Func <bool> >()
{
() => _stringComparer.Compare(game.Event.ToLower(), options.Event.ToLower()),
() => _stringComparer.Compare(game.Site.ToLower(), options.Site.ToLower()),
() => _stringComparer.Compare(game.Date.ToString().ToLower(), options.Date.ToLower()),
() => _stringComparer.Compare(game.White.ToLower(), options.White.ToLower()),
() => _stringComparer.Compare(game.Round.ToLower(), options.Round.ToLower()),
() => _stringComparer.Compare(game.Black.ToLower(), options.Black.ToLower()),
};
return(stringComparisons.All(c => c()) &&
_pgnGameResultComparer.Compare(game.Result, options.Result.ToLower())
);
}
private static bool AssertWikiGameIsCorrect(PgnGame pgnGame)
{
Assert.That(pgnGame.Event, Is.EqualTo($"F/S Return Match"));
Assert.That(pgnGame.Site, Is.EqualTo("Belgrade, Serbia JUG"));
Assert.That(pgnGame.Date.ToString(), Is.EqualTo("1992.11.04"));
StringAssert.StartsWith("29", pgnGame.Round);
Assert.That(pgnGame.White, Is.EqualTo("Fischer, Robert J."));
Assert.That(pgnGame.Black, Is.EqualTo("Spassky, Boris V."));
Assert.That(pgnGame.Result, Is.EqualTo(PgnGameResult.Draw));
Assert.That(pgnGame.Turns.Count(), Is.EqualTo(43));
Assert.That(pgnGame.Turns.First().Turn, Is.EqualTo(1));
Assert.That(pgnGame.Turns.Last().Turn, Is.EqualTo(43));
return(true);
}
private static (int, TimeSpan, IEnumerable <TimeSpan>) PlayFile(string file)
{
var fileTimes = new List <TimeSpan>();
Console.WriteLine($"*** Starting file: {file} at: {DateTime.Now}");
var fileSw = Stopwatch.StartNew();
var games = PgnGame.ReadAllGamesFromFile(file).ToList();
var gameTimes = PlayAllGames(games).ToList();
fileSw.Stop();
fileTimes.Add(fileSw.Elapsed);
Console.WriteLine($"*** Finished file: {file} at {DateTime.Now}, {gameTimes.Count()} " +
$"games read in {fileSw.Elapsed} {fileSw.Elapsed / gameTimes.Count()}");
return(games.Count(), fileSw.Elapsed, gameTimes);
}
public IEnumerable <PgnGame> Find(FindOptions options)
{
var results = new List <PgnGame>();
foreach (var fileSource in options.FileSources)
{
var games = PgnGame.ReadAllGamesFromFile(fileSource).ToList();
OnFileRead?.Invoke(this, fileSource, games);
var matchedGames = games.AsEnumerable().FindGames(options).ToList();
OnMatchesFound?.Invoke(this, matchedGames);
results.AddRange(matchedGames);
}
return(results);
}
private static void ImportGames(string[] pgnFiles, string scanPath)
{
Console.WriteLine("Initialising repo and cache...");
IGamesRepository repo = new GamesRepository(DbContext);
Console.WriteLine($"Beginning import of {pgnFiles.Length} PGN files at: {DateTime.Now}");
var fileCount = 0;
pgnFiles.ToList().ForEach(file =>
{
fileCount++;
try
{
Console.WriteLine($"File #{fileCount}/{pgnFiles.Length} : {file}");
var pgnGames = PgnGame.ReadAllGamesFromFile(file).ToArray();
Console.WriteLine($"Checking {pgnGames.Count()} games for new entries...");
var sw = Stopwatch.StartNew();
var createdCount = repo.AddImportBatch(pgnGames);
sw.Stop();
Console.WriteLine(
$" File complete, {createdCount} new games added to DB (file contained {pgnGames.Count() - createdCount} duplicates) , DB Total Games: {repo.TotalGames}");
Console.WriteLine(
$" time taken: {sw.Elapsed}, games created per second: {createdCount/sw.Elapsed.Seconds}");
Archiver.ArchiveImportedFile(file, scanPath);
}
catch (Exception e)
{
Console.WriteLine($"ERROR: Importing file: {file}");
Console.WriteLine(e);
var failPath = Archiver.ArchiveFailedFile(file, scanPath);
Console.WriteLine($"Fail archived at: {failPath}");
if (e is SqlException)
{
throw;
}
}
});
}
/// <summary>
/// Generate a unique ID for a pgn game.
/// </summary>
/// <param name="pgnGame">The game to generate the ID for.</param>
/// <returns>The unique id.</returns>
public static GameId GenerateGameId(PgnGame pgnGame)
{
var tagString = CanonicalizeTags(pgnGame);
var mainLineString = CanonicalizeMainLine(pgnGame);
var ids = Sha256AsIntArray(tagString + mainLineString);
var hashIds = new Hashids();
var uniqueId = Sha256AsHex(pgnGame.OriginalPgnText);
var canonicalizedId = Sha256AsHex(tagString + mainLineString);
var publicId = hashIds.Encode(ids);
return(new GameId()
{
UniqueId = uniqueId,
CanonicalizedId = canonicalizedId,
PublicId = publicId,
});
}
public void WhiteMoveTest()
{
var game = new PgnGame();
var move = new PgnMove();
_state.OnEnter(move);
_state.Parse('1', '.', game);
_state.Parse('.', ' ', game);
_state.Parse(' ', 'e', game);
_state.Parse('e', '4', game);
_state.Parse('4', ' ', game);
_state.Parse(' ', 'e', game);
_state.OnExit();
Assert.AreEqual("e4", move.Variation[0][0].Move);
}
public void WhiteMoveNoWhitespaceTest()
{
var game = new PgnGame();
var move = new PgnMove();
_state.OnEnter(move);
_state.Parse('1', '.', game);
_state.Parse('.', 'e', game);
_state.Parse('e', '4', game);
_state.Parse('4', ' ', game);
_state.Parse(' ', 'e', game);
_state.OnExit();
Assert.AreEqual("e4", move.Move);
Assert.IsTrue(move.IsValid);
}
public void OnGoingGameNoWhitespaceTest()
{
var game = new PgnGame();
var move = new PgnMove();
_state.OnEnter(move);
_state.Parse('1', '.', game);
_state.Parse('.', 'e', game);
_state.Parse('e', '4', game);
_state.Parse('4', '*', game);
var result = _state.Parse('*', ' ', game);
_state.OnExit();
Assert.AreEqual("*", game.Result);
Assert.AreEqual(PgnParseResult.EndOfGame, result);
}
