**Clarifying project requirements** It seems the user wants a straightforward app instead of a conceptual approach, focusing on details like project structure and copyable files. They favor minimal packages, with features like offline caching and manual PGN import as optional. I'm considering whether to use ScottPlot or OxyPlot for charting and whether to implement my PGN parser, ensuring it accurately processes chess legality. I'll need to gather the right APIs and libraries, prioritizing user expectations without holdbacks.**Exploring WPF app features** I'm thinking about creating a self-contained WPF app that includes a chessboard with a SAN resolver to handle pseudo-legal moves and legality checks like castling and clock phases. For analyzing positions, I could integrate the Stockfish engine to translate legal SAN into UCI commands. However, I wonder if using a Python-chess bridge might conflict with the C# approach. I need to consider how to best implement these features while ensuring everything works smoothly together. Below is a substantial **C# / WPF chess analytics app** called **OpenChessLab**. It includes: - Chess.com username/profile-URL import. - Public profile and account statistics. - Monthly game archive import, local caching, retries, cancellation, and progress reporting. - Rating-history charts and an activity heatmap. - Results by time control, color, opening, opponent, rating difference, month, weekday, hour, castling, and more. - Streaks, session statistics, clock statistics, material statistics, and piece/phase breakdowns. - Optional local **Stockfish analysis**: centipawn loss, expected-score loss, best-move matching, mistakes, blunders, critical moments, and advantage-conversion statistics. - Filters and CSV exports. - A local-first design: no account password, telemetry, or game uploads. **Important limitation:** Chess.com’s public API does **not** expose every proprietary Insights/Game Review metric. This app imports accuracy when the API supplies it, but its Stockfish statistics are separate, explicitly labeled calculations—not replicas of Chess.com’s proprietary accuracy, “brilliant move,” or coaching algorithms. Missing values remain missing rather than becoming fabricated zeroes. The source below targets **.NET 8 WPF on Windows**. I cannot compile or test it against the live API from this chat, so treat it as a comprehensive implementation to build and validate—not as a tested binary. --- # 1. Create the project ```powershell dotnet new wpf -n OpenChessLab -f net8.0 cd OpenChessLab ``` Replace/add the following files: ```text OpenChessLab/ ├── OpenChessLab.csproj ├── App.xaml ├── App.xaml.cs ├── MainWindow.xaml ├── MainWindow.xaml.cs ├── Models.cs ├── ChessComClient.cs ├── ChessBoard.cs ├── Pgn.cs ├── Analytics.cs ├── Stockfish.cs └── Charts.cs ``` No NuGet packages are required. Stockfish is optional and selected through the UI. --- # 2. Project and application files ## `OpenChessLab.csproj` ```xml WinExe net8.0-windows true enable enable 12.0 ``` ## `App.xaml` ```xml ``` ## `App.xaml.cs` ```csharp using System.Windows; namespace OpenChessLab; public partial class App : Application { } ``` --- # 3. Data models ## `Models.cs` ```csharp namespace OpenChessLab; public sealed class Game { public string Id { get; init; } = ""; public string Url { get; init; } = ""; public string Player { get; init; } = ""; public string Opponent { get; init; } = ""; public DateTime EndUtc { get; init; } public DateTime? StartUtc { get; init; } public bool IsWhite { get; init; } public bool Rated { get; init; } public string TimeClass { get; init; } = ""; public string Rules { get; init; } = ""; public string TimeControl { get; init; } = ""; public int? MyRating { get; init; } public int? OppRating { get; init; } public string MyCode { get; init; } = ""; public string OppCode { get; init; } = ""; public double? Score { get; init; } public string Eco { get; init; } = "Unknown"; public string Opening { get; init; } = "Unknown"; public double? ApiAccuracy { get; init; } public string Pgn { get; init; } = ""; public string StartFen { get; set; } = ChessBoard.InitialFen; public bool StartWhite { get; set; } = true; public int InitialMaterial { get; set; } public double? BaseSeconds { get; set; } public double? IncrementSeconds { get; set; } public int RejectedClockSamples { get; set; } public string? ParseError { get; set; } public List Moves { get; } = []; public bool Parsed => ParseError is null && Moves.Count > 0; public string Color => IsWhite ? "White" : "Black"; public string Result => Score switch { 1 => "Win", 0.5 => "Draw", 0 => "Loss", _ => "Unknown" }; public string EndCode => Score == 1 ? OppCode : MyCode; public IEnumerable Mine => Moves.Where(p => p.White == IsWhite); public string Castle => !Parsed ? "Unavailable" : Mine.FirstOrDefault(p => p.Castle.Length > 0)?.Castle ?? "Not recorded"; public string OppCastle => !Parsed ? "Unavailable" : Moves.FirstOrDefault(p => p.White != IsWhite && p.Castle.Length > 0) ?.Castle ?? "Not recorded"; public double? FinalClock => Parsed ? Mine.LastOrDefault()?.ClockAfter : null; public double? GameSeconds => StartUtc.HasValue && EndUtc >= StartUtc.Value ? (EndUtc - StartUtc.Value).TotalSeconds : null; public IEnumerable MyMaterialPath => Moves.Select(p => p.WhiteMaterialAfter) .Prepend(InitialMaterial) .Select(v => IsWhite ? v : -v); } public sealed class Ply { public int Index { get; init; } public int Turn { get; init; } public bool White { get; init; } public string San { get; init; } = ""; public string Uci { get; init; } = ""; public string Piece { get; init; } = ""; public string Phase { get; init; } = ""; public bool Capture { get; init; } public bool Check { get; init; } public bool Promotion { get; init; } public string Castle { get; init; } = ""; public int WhiteMaterialAfter { get; init; } public int QueensAfter { get; init; } public double? ClockAfter { get; init; } public double? Seconds { get; init; } public string TimingSource { get; init; } = ""; } public sealed record ApiField(string Source, string Field, string Value); public sealed record ImportResult( string Username, List Games, List Api, int Archives, int UnmatchedGames, int Duplicates, DateTime ImportedUtc); public sealed record MetricRow( string Section, string Metric, string Value, string Notes); public sealed record InsightRow( string Topic, string Evidence, string SuggestedAction); public sealed record SliceRow( string Dimension, string Bucket, int Games, int Scored, int Wins, int Draws, int Losses, double? WinPct, double? ScorePct, string Win95Pct, double? MeanMyRating, double? MeanOppRating, int EloN, double? ExpectedPct, double? AboveExpectedPp, double? PerformanceElo, int ParsedGames, double? MeanPlies, int AccuracyN, double? ApiAccuracy, int EngineMoves, int EngineCpN, double? Acpl); public sealed record MoveGroupRow( string Dimension, string Bucket, int Moves, int ClockN, int TimedN, double? MeanSeconds, double? MedianSeconds, double? P90Seconds, double? ChecksPct, double? CapturesPct, int Promotions, int EngineMoves, int EngineCpN, double? Acpl, int WdlN, double? MeanWdlLossPp, int Blunders); public sealed record GameRow( string Id, DateTime EndUtc, string Mode, string Rules, bool Rated, string Color, string Result, string Opponent, int? MyRating, int? OppRating, string TimeControl, string EndCode, string Eco, string Opening, int? Plies, double? GameSeconds, string Castle, string OppCastle, double? FinalClock, double? MeanMoveSeconds, double? ApiAccuracy, double? Acpl, int? MaterialMin, int? MaterialMax, string MoveData, string Url); public sealed record EngineMove( string GameId, DateTime DateUtc, int Ply, int Turn, string San, string Uci, string BestUci, string Phase, string Piece, double? Seconds, double? ClockAfter, string Before, string After, double? CpLoss, double? WdlLossPp, string Grade, string GradeBasis, int Depth) { public bool BestMatch => Uci == BestUci; } public sealed class EngineReport { public string GameId { get; init; } = ""; public string Engine { get; init; } = ""; public int MsPerPosition { get; init; } public DateTime AnalyzedUtc { get; init; } public int Positions { get; init; } public double MeanDepth { get; init; } public bool? HadAdvantage { get; init; } public bool? HadDisadvantage { get; init; } public List Moves { get; init; } = []; } public sealed record EngineGameRow( DateTime DateUtc, string Opponent, string GameId, string Engine, int MsPerPosition, DateTime AnalyzedUtc, int Positions, int MyMoves, int CpN, double? Acpl, double? MedianCpLoss, double? P90CpLoss, int WdlN, double? MeanWdlLossPp, double? BestMatchPct, int Inaccuracies, int Mistakes, int Blunders, bool? HadAdvantage, bool? HadDisadvantage, double MeanDepth); public sealed class Dashboard { public List Metrics { get; init; } = []; public List Insights { get; init; } = []; public List Segments { get; init; } = []; public List Openings { get; init; } = []; public List Opponents { get; init; } = []; public List MoveGroups { get; init; } = []; public List Games { get; init; } = []; public List EngineGames { get; init; } = []; public List EngineMoves { get; init; } = []; } ``` --- # 4. Chess.com API, caching, and import ## `ChessComClient.cs` ```csharp using System.Globalization; using System.Net; using System.Net.Http; using System.Security.Cryptography; using System.Text; using System.Text.Json; using System.Text.RegularExpressions; namespace OpenChessLab; public static class LocalStore { public static string Root => Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "OpenChessLab"); public static string FileFor(string area, string key) { var hash = Convert.ToHexString( SHA256.HashData(Encoding.UTF8.GetBytes(key))); return Path.Combine(Root, area, hash + ".json"); } public static async Task ReadAsync( string path, TimeSpan? ttl, CancellationToken ct) { try { if (!File.Exists(path)) return null; if (ttl.HasValue && DateTime.UtcNow - File.GetLastWriteTimeUtc(path) > ttl.Value) return null; return await File.ReadAllTextAsync(path, ct); } catch (IOException) { return null; } } public static async Task WriteAsync( string path, string text, CancellationToken ct) { Directory.CreateDirectory(Path.GetDirectoryName(path)!); var temp = path + "." + Guid.NewGuid().ToString("N") + ".tmp"; try { await File.WriteAllTextAsync( temp, text, new UTF8Encoding(false), ct); File.Move(temp, path, overwrite: true); } finally { try { if (File.Exists(temp)) File.Delete(temp); } catch (IOException) { // A leftover temporary cache file is not authoritative data. } } } } internal static class JsonFields { public static JsonElement Get(this JsonElement e, string name) => e.ValueKind == JsonValueKind.Object && e.TryGetProperty(name, out var value) ? value : default; public static string Text(this JsonElement e, string fallback = "") => e.ValueKind == JsonValueKind.String ? e.GetString() ?? fallback : fallback; public static int? Int(this JsonElement e) => e.ValueKind == JsonValueKind.Number && e.TryGetInt32(out var n) ? n : null; public static long? Long(this JsonElement e) => e.ValueKind == JsonValueKind.Number && e.TryGetInt64(out var n) ? n : null; public static double? Number(this JsonElement e) => e.ValueKind == JsonValueKind.Number && e.TryGetDouble(out var n) ? n : null; } public sealed class ChessComClient : IDisposable { private readonly HttpClient _http = new() { Timeout = TimeSpan.FromSeconds(60) }; public ChessComClient() { _http.DefaultRequestHeaders.UserAgent.ParseAdd("OpenChessLab/1.0"); _http.DefaultRequestHeaders.Accept.ParseAdd("application/json"); } public void Dispose() => _http.Dispose(); public static string NormalizeUsername(string input) { var value = input.Trim(); if (Uri.TryCreate(value, UriKind.Absolute, out var uri)) { if (uri.Scheme != "https" || !(uri.Host.Equals("chess.com", StringComparison.OrdinalIgnoreCase) || uri.Host.Equals("www.chess.com", StringComparison.OrdinalIgnoreCase))) throw new ArgumentException("Use a Chess.com profile URL or username."); var parts = uri.AbsolutePath.Split( '/', StringSplitOptions.RemoveEmptyEntries); if (parts.Length != 2 || !(parts[0].Equals("member", StringComparison.OrdinalIgnoreCase) || parts[0].Equals("player", StringComparison.OrdinalIgnoreCase))) throw new ArgumentException("Expected /member/username or /player/username."); value = Uri.UnescapeDataString(parts[1]); } if (!Regex.IsMatch(value, @"^[A-Za-z0-9_-]{1,50}$")) throw new ArgumentException("Invalid username."); return value.ToLowerInvariant(); } private async Task GetJsonAsync( string url, TimeSpan ttl, bool refresh, CancellationToken ct) { if (!Uri.TryCreate(url, UriKind.Absolute, out var uri) || uri.Scheme != "https" || !uri.Host.Equals("api.chess.com", StringComparison.OrdinalIgnoreCase)) throw new InvalidDataException("Unexpected archive URL."); var cachePath = LocalStore.FileFor("api", url); if (!refresh) { var cached = await LocalStore.ReadAsync(cachePath, ttl, ct); if (cached is not null) { try { using var check = JsonDocument.Parse(cached); return cached; } catch (JsonException) { // Corrupt cache: fetch a fresh response. } } } for (var attempt = 0; attempt < 5; attempt++) { ct.ThrowIfCancellationRequested(); using var response = await _http.GetAsync( uri, HttpCompletionOption.ResponseHeadersRead, ct); var retryable = response.StatusCode == HttpStatusCode.TooManyRequests || response.StatusCode == HttpStatusCode.BadGateway || response.StatusCode == HttpStatusCode.ServiceUnavailable || response.StatusCode == HttpStatusCode.GatewayTimeout; if (retryable && attempt < 4) { var delay = response.Headers.RetryAfter?.Delta; if (!delay.HasValue && response.Headers.RetryAfter?.Date is { } date) delay = date - DateTimeOffset.UtcNow; delay ??= TimeSpan.FromSeconds(Math.Pow(2, attempt + 1)); if (delay.Value < TimeSpan.FromMilliseconds(250)) delay = TimeSpan.FromMilliseconds(250); await Task.Delay(delay.Value, ct); continue; } if (!response.IsSuccessStatusCode) throw new HttpRequestException( $"Chess.com returned {(int)response.StatusCode} " + $"{response.StatusCode} for {uri.AbsolutePath}.", null, response.StatusCode); var json = await response.Content.ReadAsStringAsync(ct); using (JsonDocument.Parse(json)) { // Validate before committing to the cache. } await LocalStore.WriteAsync(cachePath, json, ct); return json; } throw new HttpRequestException("Retry limit reached."); } public async Task ImportAsync( string input, int months, bool refresh, IProgress progress, CancellationToken ct) { var username = NormalizeUsername(input); var root = $"https://api.chess.com/pub/player/{Uri.EscapeDataString(username)}"; progress.Report("Loading profile and public account statistics…"); var profileJson = await GetJsonAsync( root, TimeSpan.FromHours(1), refresh, ct); var statsJson = await GetJsonAsync( root + "/stats", TimeSpan.FromMinutes(10), refresh, ct); var archivesJson = await GetJsonAsync( root + "/games/archives", TimeSpan.FromMinutes(10), refresh, ct); using var profile = JsonDocument.Parse(profileJson); using var stats = JsonDocument.Parse(statsJson); using var archives = JsonDocument.Parse(archivesJson); username = profile.RootElement.Get("username").Text(username); var fields = new List(); Flatten("Profile", "", profile.RootElement, fields); Flatten("Account stats", "", stats.RootElement, fields); var archiveArray = archives.RootElement.Get("archives"); if (archiveArray.ValueKind != JsonValueKind.Array) throw new InvalidDataException("Missing archive list in API response."); var allUrls = archiveArray.EnumerateArray() .Select(x => x.Text()) .Where(x => x.Length > 0) .Distinct(StringComparer.Ordinal) .OrderBy(x => x, StringComparer.Ordinal) .ToArray(); var urls = months == 0 ? allUrls : allUrls.TakeLast(months).ToArray(); var games = new Dictionary(StringComparer.Ordinal); var unmatched = 0; var duplicates = 0; for (var i = 0; i < urls.Length; i++) { ct.ThrowIfCancellationRequested(); var url = urls[i]; progress.Report( $"Archive {i + 1}/{urls.Length}: {url.Split('/')[^2]}/{url.Split('/')[^1]}"); var now = DateTime.UtcNow; var currentSuffix = $"/{now.Year:0000}/{now.Month:00}"; var ttl = url.EndsWith(currentSuffix, StringComparison.Ordinal) ? TimeSpan.FromMinutes(5) : TimeSpan.FromDays(7); // Sequential requests avoid hammering the public API. var json = await GetJsonAsync(url, ttl, refresh, ct); await Task.Run(() => { using var doc = JsonDocument.Parse(json); var gameArray = doc.RootElement.Get("games"); if (gameArray.ValueKind != JsonValueKind.Array) throw new InvalidDataException("Archive has no games array."); foreach (var item in gameArray.EnumerateArray()) { ct.ThrowIfCancellationRequested(); var game = ParseGame(item, username, ct); if (game is null) { unmatched++; continue; } if (!games.TryAdd(game.Id, game)) duplicates++; } }, ct); progress.Report( $"Imported {games.Count:N0} unique games from {i + 1}/{urls.Length} archives."); } var importedUtc = DateTime.UtcNow; fields.Add(new("Import", "archives_loaded", urls.Length.ToString())); fields.Add(new("Import", "unmatched_games", unmatched.ToString())); fields.Add(new("Import", "duplicate_records", duplicates.ToString())); fields.Add(new("Import", "imported_utc", importedUtc.ToString("O"))); fields.Add(new("Import", "cache_directory", LocalStore.Root)); return new ImportResult( username, games.Values.OrderBy(g => g.EndUtc).ThenBy(g => g.Id).ToList(), fields, urls.Length, unmatched, duplicates, importedUtc); } private static Game? ParseGame( JsonElement e, string username, CancellationToken ct) { var white = e.Get("white"); var black = e.Get("black"); bool Matches(JsonElement player) => player.Get("username").Text().Equals( username, StringComparison.OrdinalIgnoreCase) || player.Get("@id").Text().EndsWith( "/" + username, StringComparison.OrdinalIgnoreCase); var isWhite = Matches(white); if (!isWhite && !Matches(black)) return null; var mine = isWhite ? white : black; var opponent = isWhite ? black : white; var pgn = e.Get("pgn").Text(); var tags = Pgn.Tags(pgn); var myCode = mine.Get("result").Text("unknown"); var oppCode = opponent.Get("result").Text("unknown"); var end = e.Get("end_time").Long(); if (!end.HasValue || end.Value <= 0) throw new InvalidDataException("An archive game has no valid end timestamp."); var url = e.Get("url").Text(); var id = e.Get("uuid").Text(url); if (id.Length == 0) id = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(pgn))); DateTime? start = null; if (tags.TryGetValue("UTCDate", out var date) && tags.TryGetValue("UTCTime", out var time) && DateTime.TryParseExact( date + " " + time, ["yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm:ss.FFF"], CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out var parsedStart)) start = parsedStart; var opening = tags.GetValueOrDefault("Opening", ""); var variation = tags.GetValueOrDefault("Variation", ""); if (opening.Length > 0 && variation.Length > 0) opening += ": " + variation; if (opening.Length == 0 && tags.TryGetValue("ECOUrl", out var ecoUrl) && Uri.TryCreate(ecoUrl, UriKind.Absolute, out var ecoUri)) { opening = Uri.UnescapeDataString( ecoUri.AbsolutePath.TrimEnd('/').Split('/')[^1]).Replace('-', ' '); } var game = new Game { Id = id, Url = url, Player = username, Opponent = opponent.Get("username").Text("Unknown"), EndUtc = DateTimeOffset.FromUnixTimeSeconds(end.Value).UtcDateTime, StartUtc = start, IsWhite = isWhite, Rated = e.Get("rated").ValueKind == JsonValueKind.True, Rules = e.Get("rules").Text("unknown"), TimeClass = e.Get("time_class").Text("unknown"), TimeControl = e.Get("time_control").Text(), MyRating = mine.Get("rating").Int(), OppRating = opponent.Get("rating").Int(), MyCode = myCode, OppCode = oppCode, Score = DetermineScore( myCode, oppCode, tags.GetValueOrDefault("Result", "*"), isWhite), Eco = tags.GetValueOrDefault("ECO", "Unknown"), Opening = opening.Length == 0 ? "Unknown" : opening, ApiAccuracy = e.Get("accuracies") .Get(isWhite ? "white" : "black").Number(), Pgn = pgn }; Pgn.Enrich(game, tags, ct); return game; } private static double? DetermineScore( string mine, string opponent, string pgnResult, bool white) { if (mine == "win") return 1; if (opponent == "win") return 0; string[] draws = [ "agreed", "repetition", "stalemate", "insufficient", "50move", "timevsinsufficient" ]; if (draws.Contains(mine) || draws.Contains(opponent)) return 0.5; return pgnResult switch { "1-0" => white ? 1 : 0, "0-1" => white ? 0 : 1, "1/2-1/2" => 0.5, _ => null }; } private static void Flatten( string source, string path, JsonElement value, List rows) { if (value.ValueKind == JsonValueKind.Object) { var properties = value.EnumerateObject().ToArray(); if (properties.Length == 0) rows.Add(new(source, path, "{}")); foreach (var p in properties) Flatten(source, path.Length == 0 ? p.Name : path + "." + p.Name, p.Value, rows); } else if (value.ValueKind == JsonValueKind.Array) { var array = value.EnumerateArray().ToArray(); if (array.Length == 0) rows.Add(new(source, path, "[]")); for (var i = 0; i < array.Length; i++) Flatten(source, $"{path}[{i}]", array[i], rows); } else { rows.Add(new(source, path, value.ValueKind == JsonValueKind.String ? value.GetString() ?? "" : value.GetRawText())); } } } ``` --- # 5. Orthodox-chess move reconstruction This is used to derive piece activity, material, castling, phases, and legal UCI moves for Stockfish. Unsupported variants still receive archive/result statistics, but not orthodox-chess move analysis. ## `ChessBoard.cs` ```csharp using System.Text; using System.Text.RegularExpressions; namespace OpenChessLab; public sealed record PlayedMove( string Uci, string Piece, bool Capture, bool Check, bool Promotion, string Castle); public sealed class ChessBoard { public const string InitialFen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"; private char[] _s = Enumerable.Repeat('.', 64).ToArray(); private string _rights = ""; private int _ep = -1; private int _halfmove; public bool WhiteToMove { get; private set; } public int Fullmove { get; private set; } private static readonly Regex SanPattern = new( @"^(?[KQRBN])?(?[a-h])?(?[1-8])?" + @"(?x)?(?[a-h][1-8])(?:=?(?[QRBN]))?$", RegexOptions.Compiled); private readonly record struct Move( int From, int To, char Promotion = '\0', bool EnPassant = false, bool Castling = false) { public string Uci => Name(From) + Name(To) + (Promotion == '\0' ? "" : char.ToLowerInvariant(Promotion).ToString()); } public static ChessBoard FromFen(string fen) { var parts = fen.Split(' ', StringSplitOptions.RemoveEmptyEntries); if (parts.Length < 4) throw new FormatException("FEN requires at least four fields."); var b = new ChessBoard(); var ranks = parts[0].Split('/'); if (ranks.Length != 8) throw new FormatException("FEN requires eight ranks."); for (var r = 0; r < 8; r++) { var file = 0; foreach (var c in ranks[r]) { if (c is >= '1' and <= '8') { file += c - '0'; } else { if (!"PNBRQKpnbrqk".Contains(c) || file >= 8) throw new FormatException("Invalid FEN piece placement."); b._s[(7 - r) * 8 + file++] = c; } if (file > 8) throw new FormatException("Invalid FEN rank width."); } if (file != 8) throw new FormatException("Invalid FEN rank width."); } if (b._s.Count(c => c == 'K') != 1 || b._s.Count(c => c == 'k') != 1) throw new FormatException("Expected one king for each side."); if (parts[1] is not ("w" or "b")) throw new FormatException("Invalid FEN side to move."); b.WhiteToMove = parts[1] == "w"; b._rights = parts[2] == "-" ? "" : parts[2]; if (b._rights.Any(c => !"KQkq".Contains(c))) throw new FormatException("Non-orthodox castling rights are unsupported."); b._ep = parts[3] == "-" ? -1 : Square(parts[3]); b._halfmove = parts.Length > 4 ? int.Parse(parts[4]) : 0; b.Fullmove = parts.Length > 5 ? int.Parse(parts[5]) : 1; if (b._halfmove < 0 || b.Fullmove < 1) throw new FormatException("Invalid FEN counters."); return b; } public string ToFen() { var text = new StringBuilder(); for (var rank = 7; rank >= 0; rank--) { var empty = 0; for (var file = 0; file < 8; file++) { var c = _s[rank * 8 + file]; if (c == '.') { empty++; } else { if (empty > 0) text.Append(empty); empty = 0; text.Append(c); } } if (empty > 0) text.Append(empty); if (rank > 0) text.Append('/'); } text.Append(WhiteToMove ? " w " : " b "); text.Append(_rights.Length == 0 ? "-" : _rights); text.Append(' ').Append(_ep < 0 ? "-" : Name(_ep)); text.Append(' ').Append(_halfmove).Append(' ').Append(Fullmove); return text.ToString(); } public int Material => _s.Sum(c => { var value = char.ToUpperInvariant(c) switch { 'P' => 1, 'N' or 'B' => 3, 'R' => 5, 'Q' => 9, _ => 0 }; return char.IsUpper(c) ? value : -value; }); public int Queens => _s.Count(c => c is 'Q' or 'q'); public string Phase { get { var units = _s.Sum(c => char.ToUpperInvariant(c) switch { 'N' or 'B' => 1, 'R' => 2, 'Q' => 4, _ => 0 }); return units <= 8 ? "Endgame" : Fullmove <= 10 ? "Opening" : "Middlegame"; } } private ChessBoard Copy() { var copy = (ChessBoard)MemberwiseClone(); copy._s = (char[])_s.Clone(); return copy; } public PlayedMove PlaySan(string original) { var san = original.Trim() .Replace('0', 'O') .TrimEnd('+', '#', '!', '?'); if (san is "O-O" or "O-O-O") return Castle(san == "O-O"); var match = SanPattern.Match(san); if (!match.Success) throw new FormatException($"Unsupported SAN token: {original}"); var kind = match.Groups["piece"].Success ? match.Groups["piece"].Value[0] : 'P'; var to = Square(match.Groups["to"].Value); var file = match.Groups["file"].Value; var rank = match.Groups["rank"].Value; var wantsCapture = match.Groups["capture"].Success; var promotion = match.Groups["promo"].Success ? match.Groups["promo"].Value[0] : '\0'; var candidates = new List(); for (var from = 0; from < 64; from++) { var piece = _s[from]; if (piece == '.' || char.IsUpper(piece) != WhiteToMove || char.ToUpperInvariant(piece) != kind) continue; if (file.Length > 0 && from % 8 != file[0] - 'a') continue; if (rank.Length > 0 && from / 8 != rank[0] - '1') continue; if (!CanMove(from, to)) continue; var ep = kind == 'P' && to == _ep && _s[to] == '.' && from % 8 != to % 8; var capture = _s[to] != '.' || ep; if (capture != wantsCapture) continue; var lastRank = to / 8 is 0 or 7; if (kind == 'P') { if (lastRank != (promotion != '\0')) continue; } else if (promotion != '\0') { continue; } var move = new Move(from, to, promotion, ep); var copy = Copy(); copy.Apply(move); if (!copy.InCheck(WhiteToMove)) candidates.Add(move); } if (candidates.Count != 1) throw new FormatException( $"SAN '{original}' resolved to {candidates.Count} legal moves."); return Finish(candidates[0], ""); } private PlayedMove Castle(bool kingSide) { var white = WhiteToMove; var from = white ? 4 : 60; var direction = kingSide ? 1 : -1; var to = from + direction * 2; var rook = kingSide ? from + 3 : from - 4; var right = white ? (kingSide ? 'K' : 'Q') : (kingSide ? 'k' : 'q'); if (!_rights.Contains(right) || _s[from] != (white ? 'K' : 'k') || _s[rook] != (white ? 'R' : 'r')) throw new FormatException("Castling rights/pieces are unavailable."); var emptySquares = kingSide ? new[] { from + 1, from + 2 } : new[] { from - 1, from - 2, from - 3 }; if (emptySquares.Any(s => _s[s] != '.') || InCheck(white)) throw new FormatException("Illegal castling."); var middle = Copy(); middle.Apply(new Move(from, from + direction)); if (middle.InCheck(white)) throw new FormatException("Castling through check."); var final = Copy(); var move = new Move(from, to, Castling: true); final.Apply(move); if (final.InCheck(white)) throw new FormatException("Castling into check."); return Finish(move, kingSide ? "O-O" : "O-O-O"); } private PlayedMove Finish(Move move, string castle) { var piece = char.ToUpperInvariant(_s[move.From]).ToString(); var capture = _s[move.To] != '.' || move.EnPassant; Apply(move); return new PlayedMove( move.Uci, piece, capture, InCheck(WhiteToMove), move.Promotion != '\0', castle); } private bool CanMove(int from, int to) { if (from == to) return false; var piece = _s[from]; var target = _s[to]; var white = char.IsUpper(piece); if (target != '.' && (char.IsUpper(target) == white || char.ToUpperInvariant(target) == 'K')) return false; var df = to % 8 - from % 8; var dr = to / 8 - from / 8; if (char.ToUpperInvariant(piece) == 'P') { var step = white ? 1 : -1; var startRank = white ? 1 : 6; if (df == 0 && target == '.') { return dr == step || (dr == 2 * step && from / 8 == startRank && _s[from + step * 8] == '.'); } if (Math.Abs(df) != 1 || dr != step) return false; if (target != '.') return true; var captured = to - step * 8; return to == _ep && captured is >= 0 and < 64 && _s[captured] == (white ? 'p' : 'P'); } return Attacks(from, to); } private bool Attacks(int from, int to) { var piece = _s[from]; var df = to % 8 - from % 8; var dr = to / 8 - from / 8; if (from == to) return false; return char.ToUpperInvariant(piece) switch { 'P' => Math.Abs(df) == 1 && dr == (char.IsUpper(piece) ? 1 : -1), 'N' => Math.Abs(df) * Math.Abs(dr) == 2, 'K' => Math.Max(Math.Abs(df), Math.Abs(dr)) == 1, 'B' => Math.Abs(df) == Math.Abs(dr) && ClearRay(from, to), 'R' => (df == 0 || dr == 0) && ClearRay(from, to), 'Q' => (df == 0 || dr == 0 || Math.Abs(df) == Math.Abs(dr)) && ClearRay(from, to), _ => false }; } private bool ClearRay(int from, int to) { var df = Math.Sign(to % 8 - from % 8); var dr = Math.Sign(to / 8 - from / 8); var file = from % 8 + df; var rank = from / 8 + dr; while (file != to % 8 || rank != to / 8) { if (_s[rank * 8 + file] != '.') return false; file += df; rank += dr; } return true; } private bool InCheck(bool white) { var king = Array.IndexOf(_s, white ? 'K' : 'k'); if (king < 0) throw new FormatException("King missing from position."); for (var i = 0; i < 64; i++) { if (_s[i] != '.' && char.IsUpper(_s[i]) != white && Attacks(i, king)) return true; } return false; } private void Apply(Move move) { var piece = _s[move.From]; var white = char.IsUpper(piece); var pawn = char.ToUpperInvariant(piece) == 'P'; var captured = _s[move.To]; _s[move.From] = '.'; if (move.EnPassant) { var square = move.To + (white ? -8 : 8); captured = _s[square]; _s[square] = '.'; } _s[move.To] = move.Promotion == '\0' ? piece : white ? char.ToUpperInvariant(move.Promotion) : char.ToLowerInvariant(move.Promotion); if (move.Castling) { var kingSide = move.To > move.From; var rookFrom = kingSide ? move.From + 3 : move.From - 4; var rookTo = kingSide ? move.From + 1 : move.From - 1; _s[rookTo] = _s[rookFrom]; _s[rookFrom] = '.'; } if (piece == 'K') _rights = _rights.Replace("K", "").Replace("Q", ""); if (piece == 'k') _rights = _rights.Replace("k", "").Replace("q", ""); foreach (var (square, right) in new[] { (0, 'Q'), (7, 'K'), (56, 'q'), (63, 'k') }) { if (move.From == square || move.To == square) _rights = _rights.Replace(right.ToString(), ""); } _ep = pawn && Math.Abs(move.To - move.From) == 16 ? (move.From + move.To) / 2 : -1; _halfmove = pawn || captured != '.' ? 0 : _halfmove + 1; if (!WhiteToMove) Fullmove++; WhiteToMove = !WhiteToMove; } private static int Square(string name) { if (name.Length != 2 || name[0] is < 'a' or > 'h' || name[1] is < '1' or > '8') throw new FormatException("Invalid square: " + name); return (name[1] - '1') * 8 + name[0] - 'a'; } private static string Name(int square) => $"{(char)('a' + square % 8)}{(char)('1' + square / 8)}"; } ``` --- # 6. PGN and clock analysis ## `Pgn.cs` ```csharp using System.Globalization; using System.Text.RegularExpressions; namespace OpenChessLab; public static class Pgn { private static readonly Regex TagPattern = new( @"(?m)^\s*\[(?[A-Za-z0-9_]+)\s+""(?(?:\\.|[^""\\])*)""\]\s*$", RegexOptions.Compiled); private static readonly Regex MoveNumber = new( @"^\d+\.(?:\.\.)?", RegexOptions.Compiled); private static readonly Regex Clock = new( @"\[%clk\s+([0-9:.]+)\]", RegexOptions.Compiled); private static readonly Regex Elapsed = new( @"\[%emt\s+([0-9:.]+)\]", RegexOptions.Compiled); private sealed class RawMove(string san) { public string San { get; } = san; public double? Clock { get; set; } public double? Elapsed { get; set; } } public static Dictionary Tags(string text) { var result = new Dictionary(StringComparer.Ordinal); foreach (Match m in TagPattern.Matches(text)) { result[m.Groups["key"].Value] = Regex.Replace(m.Groups["value"].Value, @"\\(.)", "$1"); } return result; } public static void Enrich( Game game, Dictionary tags, CancellationToken ct) { if (game.Rules != "chess") { game.ParseError = $"Move analysis unsupported for rules={game.Rules}"; return; } try { if (string.IsNullOrWhiteSpace(game.Pgn)) throw new FormatException("PGN is missing."); var board = ChessBoard.FromFen( tags.GetValueOrDefault("FEN", ChessBoard.InitialFen)); game.StartFen = board.ToFen(); game.StartWhite = board.WhiteToMove; game.InitialMaterial = board.Material; ParseTimeControl(game); var rawMoves = ReadMoves(TagPattern.Replace(game.Pgn, "")); var previousClock = new double?[2]; foreach (var raw in rawMoves) { ct.ThrowIfCancellationRequested(); var white = board.WhiteToMove; var side = white ? 0 : 1; var turn = board.Fullmove; var phase = board.Phase; var played = board.PlaySan(raw.San); double? seconds = null; var source = ""; if (game.TimeClass != "daily") { if (raw.Elapsed.HasValue) { seconds = raw.Elapsed; source = "PGN EMT"; } else if (game.BaseSeconds.HasValue && previousClock[side].HasValue && raw.Clock.HasValue) { var estimate = previousClock[side]!.Value + game.IncrementSeconds.GetValueOrDefault() - raw.Clock.Value; if (estimate >= -0.05) { seconds = Math.Max(0, estimate); source = "Clock difference estimate"; } else { game.RejectedClockSamples++; } } } // A missing clock invalidates the next difference for that side. // The first observed move is deliberately not timed from base time. previousClock[side] = raw.Clock; game.Moves.Add(new Ply { Index = game.Moves.Count + 1, Turn = turn, White = white, San = raw.San, Uci = played.Uci, Piece = played.Piece, Phase = phase, Capture = played.Capture, Check = played.Check, Promotion = played.Promotion, Castle = played.Castle, WhiteMaterialAfter = board.Material, QueensAfter = board.Queens, ClockAfter = raw.Clock, Seconds = seconds, TimingSource = source }); } if (game.Moves.Count == 0) throw new FormatException("PGN contains no mainline moves."); } catch (Exception ex) when ( ex is FormatException or InvalidDataException or ArgumentException) { // Do not aggregate partially reconstructed games as complete games. game.Moves.Clear(); game.ParseError = ex.Message; } } private static void ParseTimeControl(Game game) { if (game.TimeControl.Contains('/') || game.TimeControl.Contains(':')) return; var parts = game.TimeControl.Split('+'); if (parts.Length is < 1 or > 2) return; if (!double.TryParse(parts[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var baseSeconds) || baseSeconds <= 0) return; var increment = 0.0; if (parts.Length == 2 && (!double.TryParse(parts[1], NumberStyles.Float, CultureInfo.InvariantCulture, out increment) || increment < 0)) return; game.BaseSeconds = baseSeconds; game.IncrementSeconds = increment; } private static List ReadMoves(string text) { var moves = new List(); var depth = 0; var i = 0; while (i < text.Length) { var c = text[i]; if (char.IsWhiteSpace(c)) { i++; continue; } if (c == ';') { while (i < text.Length && text[i] != '\n') i++; continue; } if (c == '{') { var end = text.IndexOf('}', i + 1); if (end < 0) throw new FormatException("Unclosed PGN comment."); if (depth == 0 && moves.Count > 0) { var comment = text[(i + 1)..end]; var clock = Clock.Match(comment); var elapsed = Elapsed.Match(comment); if (clock.Success) moves[^1].Clock = ParseDuration(clock.Groups[1].Value); if (elapsed.Success) moves[^1].Elapsed = ParseDuration(elapsed.Groups[1].Value); } i = end + 1; continue; } if (c == '(') { depth++; i++; continue; } if (c == ')') { if (depth == 0) throw new FormatException("Unmatched PGN variation terminator."); depth--; i++; continue; } if (depth > 0) { i++; continue; } if (c == '}') throw new FormatException("Unmatched PGN comment terminator."); var start = i; while (i < text.Length && !char.IsWhiteSpace(text[i]) && !"{}();".Contains(text[i])) i++; var token = text[start..i]; token = MoveNumber.Replace(token, ""); token = Regex.Replace(token, @"\$\d+", ""); if (token.Length == 0 || token is "." or "..." or "e.p." || Regex.IsMatch(token, @"^[!?]+$")) continue; if (token is "1-0" or "0-1" or "1/2-1/2" or "*") break; moves.Add(new RawMove(token)); } if (depth != 0) throw new FormatException("Unclosed PGN variation."); return moves; } private static double? ParseDuration(string text) { var parts = text.Split(':'); if (parts.Length is < 1 or > 3) return null; var total = 0.0; foreach (var part in parts) { if (!double.TryParse(part, NumberStyles.Float, CultureInfo.InvariantCulture, out var value) || value < 0) return null; total = total * 60 + value; } return total; } } ``` --- # 7. Analytics engine ## `Analytics.cs` ```csharp using System.Globalization; namespace OpenChessLab; public static class Analytics { public static double? Mean(IEnumerable values) { var a = values.ToArray(); return a.Length == 0 ? null : a.Average(); } public static double[] Present(IEnumerable values) => values.Where(x => x.HasValue).Select(x => x.GetValueOrDefault()).ToArray(); public static double? Quantile(IEnumerable values, double q) { var a = values.OrderBy(x => x).ToArray(); if (a.Length == 0) return null; var p = (a.Length - 1) * q; var lo = (int)Math.Floor(p); var hi = (int)Math.Ceiling(p); return a[lo] + (a[hi] - a[lo]) * (p - lo); } public static double? Pct(int numerator, int denominator) => denominator == 0 ? null : 100.0 * numerator / denominator; public static string N(double? value, string format = "0.##") => value?.ToString(format, CultureInfo.InvariantCulture) ?? "—"; private static double Expected(Game g) => 1.0 / (1.0 + Math.Pow(10, (g.OppRating!.Value - g.MyRating!.Value) / 400.0)); private static string Wilson(int wins, int n) { if (n == 0) return "—"; const double z = 1.96; var p = wins / (double)n; var denominator = 1 + z * z / n; var center = (p + z * z / (2 * n)) / denominator; var half = z * Math.Sqrt(p * (1 - p) / n + z * z / (4.0 * n * n)) / denominator; return $"{100 * (center - half):0.0}–{100 * (center + half):0.0}"; } public static Dashboard Build( IReadOnlyList input, IReadOnlyDictionary reports, CancellationToken ct) { var games = input.OrderBy(g => g.EndUtc).ThenBy(g => g.Id).ToArray(); var ids = games.Select(g => g.Id).ToHashSet(StringComparer.Ordinal); var engineReports = reports.Values.Where(r => ids.Contains(r.GameId)).ToArray(); var engineMoves = engineReports.SelectMany(r => r.Moves).ToArray(); var engineLookup = engineMoves.ToDictionary(x => (x.GameId, x.Ply)); var parsed = games.Where(g => g.Parsed).ToArray(); var scored = games.Where(g => g.Score.HasValue).ToArray(); var own = parsed.SelectMany( g => g.Mine.Select(p => (Game: g, Ply: p))).ToArray(); var seconds = Present(own.Select(x => x.Ply.Seconds)); var cpLosses = Present(engineMoves.Select(m => m.CpLoss)); var wdlLosses = Present(engineMoves.Select(m => m.WdlLossPp)); var wins = scored.Count(g => g.Score == 1); var draws = scored.Count(g => g.Score == 0.5); var losses = scored.Count(g => g.Score == 0); var result = new Dashboard(); void Add(string section, string metric, string value, string note = "") => result.Metrics.Add(new(section, metric, value, note)); void Number(string section, string metric, double? value, string note = "") => Add(section, metric, N(value), note); SliceRow Slice(string dimension, string bucket, IEnumerable source) { var a = source.ToArray(); var known = a.Where(g => g.Score.HasValue).ToArray(); var w = known.Count(g => g.Score == 1); var d = known.Count(g => g.Score == 0.5); var l = known.Count(g => g.Score == 0); var elo = known.Where(g => g.Rated && g.Rules == "chess" && g.MyRating is > 0 && g.OppRating is > 0).ToArray(); var em = a.Where(g => reports.ContainsKey(g.Id)) .SelectMany(g => reports[g.Id].Moves).ToArray(); var accuracy = Present(a.Select(g => g.ApiAccuracy)); var cpl = Present(em.Select(m => m.CpLoss)); double? performance = null; if (elo.Length > 0 && elo.Select(g => g.TimeClass).Distinct().Count() == 1) { var score = elo.Average(g => g.Score!.Value); if (score > 0 && score < 1) { performance = elo.Average(g => g.OppRating!.Value) + 400 * Math.Log10(score / (1 - score)); } } return new SliceRow( dimension, bucket, a.Length, known.Length, w, d, l, Pct(w, known.Length), Mean(known.Select(g => g.Score!.Value * 100)), Wilson(w, known.Length), Mean(a.Where(g => g.MyRating.HasValue).Select(g => (double)g.MyRating!.Value)), Mean(a.Where(g => g.OppRating.HasValue).Select(g => (double)g.OppRating!.Value)), elo.Length, Mean(elo.Select(g => Expected(g) * 100)), Mean(elo.Select(g => (g.Score!.Value - Expected(g)) * 100)), performance, a.Count(g => g.Parsed), Mean(a.Where(g => g.Parsed).Select(g => (double)g.Moves.Count)), accuracy.Length, Mean(accuracy), em.Length, cpl.Length, Mean(cpl)); } Number("Headline", "Games", games.Length); Add("Headline", "Win rate", N(Pct(wins, scored.Length)) + "%", "Wins / games with known outcomes; draws are not wins."); Add("Headline", "Score rate", N(Mean(scored.Select(g => g.Score!.Value * 100))) + "%", "(Wins + 0.5 × draws) / known outcomes."); Number("Headline", "Engine ACPL", Mean(cpLosses), "Analyzed sample only; excludes mate-score transitions."); Number("Headline", "API accuracy", Mean(Present(games.Select(g => g.ApiAccuracy))), "Only when supplied by Chess.com's API. Not generated by this app."); Number("Coverage", "Known outcomes", scored.Length); Number("Coverage", "Unknown outcomes", games.Length - scored.Length); Number("Coverage", "Rated games", games.Count(g => g.Rated)); Number("Coverage", "Parsed orthodox games", parsed.Length); Number("Coverage", "Unsupported-variant games", games.Count(g => g.Rules != "chess")); Number("Coverage", "Orthodox PGN failures", games.Count(g => g.Rules == "chess" && !g.Parsed)); Number("Coverage", "Player plies reconstructed", own.Length); Number("Coverage", "Player plies with clock", own.Count(x => x.Ply.ClockAfter.HasValue)); Number("Coverage", "Player plies with move time", seconds.Length); Number("Coverage", "Rejected clock differences", games.Sum(g => g.RejectedClockSamples)); Number("Coverage", "Games with API accuracy", games.Count(g => g.ApiAccuracy.HasValue)); Number("Coverage", "Engine-analyzed games", engineReports.Length); Number("Coverage", "Engine-analyzed player moves", engineMoves.Length); Number("Coverage", "Engine CP-loss observations", cpLosses.Length); Number("Coverage", "Engine WDL-loss observations", wdlLosses.Length); Number("Results", "Wins", wins); Number("Results", "Draws", draws); Number("Results", "Losses", losses); Add("Results", "Win-rate Wilson 95% interval", Wilson(wins, scored.Length) + "%", "Illustrative binomial interval; games need not be independent."); Number("Results", "Timeout losses", games.Count(g => g.Score == 0 && g.MyCode == "timeout")); Number("Results", "Resignation losses", games.Count(g => g.Score == 0 && g.MyCode == "resigned")); Number("Results", "Checkmate wins", games.Count(g => g.Score == 1 && g.OppCode == "checkmated")); Number("Results", "Checkmate losses", games.Count(g => g.Score == 0 && g.MyCode == "checkmated")); int Longest(Func predicate) { var best = 0; var run = 0; foreach (var g in games) { run = predicate(g) ? run + 1 : 0; best = Math.Max(best, run); } return best; } Number("Streaks", "Longest win streak", Longest(g => g.Score == 1)); Number("Streaks", "Longest loss streak", Longest(g => g.Score == 0)); Number("Streaks", "Longest draw streak", Longest(g => g.Score == 0.5)); Number("Streaks", "Longest unbeaten streak", Longest(g => g.Score.HasValue && g.Score >= 0.5)); if (games.Length > 0) { var last = games[^1].Result; var current = games.Reverse().TakeWhile(g => g.Result == last).Count(); Add("Streaks", "Latest outcome streak", $"{current} × {last}"); var dates = games.Select(g => g.EndUtc.Date).Distinct().OrderBy(d => d).ToArray(); var bestDays = 0; var runDays = 0; DateTime? previous = null; foreach (var day in dates) { runDays = previous.HasValue && day == previous.Value.AddDays(1) ? runDays + 1 : 1; bestDays = Math.Max(bestDays, runDays); previous = day; } var dateSet = dates.ToHashSet(); var cursor = DateTime.UtcNow.Date; if (!dateSet.Contains(cursor)) cursor = cursor.AddDays(-1); var currentDays = 0; while (dateSet.Contains(cursor)) { currentDays++; cursor = cursor.AddDays(-1); } Add("Activity", "First / last game UTC", $"{games[0].EndUtc:u} / {games[^1].EndUtc:u}"); Number("Activity", "Active UTC days", dates.Length); Number("Activity", "Games per active day", games.Length / (double)dates.Length); Number("Activity", "Games per calendar day", games.Length / ((dates[^1] - dates[0]).TotalDays + 1)); Number("Activity", "Longest active-day streak", bestDays); Number("Activity", "Current active-day streak", currentDays, "Ends today or yesterday UTC; within current filters."); } var sessionBucket = new Dictionary(); var sessionSizes = new List(); DateTime? lastLive = null; var sessionIndex = 0; foreach (var g in games.Where(g => g.TimeClass != "daily")) { if (!lastLive.HasValue || g.EndUtc - lastLive.Value > TimeSpan.FromMinutes(30)) { if (sessionIndex > 0) sessionSizes.Add(sessionIndex); sessionIndex = 0; } sessionIndex++; sessionBucket[g.Id] = sessionIndex switch { <= 5 => "1–5", <= 10 => "6–10", <= 20 => "11–20", _ => "21+" }; lastLive = g.EndUtc; } if (sessionIndex > 0) sessionSizes.Add(sessionIndex); Number("Activity", "Live sessions", sessionSizes.Count, "Heuristic: a >30-minute gap between game END timestamps starts a new session."); Number("Activity", "Mean games per session", Mean(sessionSizes.Select(x => (double)x))); Number("Activity", "Largest session", sessionSizes.Count == 0 ? null : sessionSizes.Max()); foreach (var pool in games.Where(g => g.Rated && g.Rules == "chess" && g.MyRating.HasValue) .GroupBy(g => g.TimeClass)) { var a = pool.ToArray(); var section = "Recorded rating: " + pool.Key; Number(section, "First", a[0].MyRating); Number(section, "Latest", a[^1].MyRating); Number(section, "Peak", a.Max(g => g.MyRating)); Number(section, "Lowest", a.Min(g => g.MyRating)); Number(section, "Window change", a[^1].MyRating - a[0].MyRating, "Difference between archive-recorded ratings; not per-game rating gain."); if (a.Length >= 60) Number(section, "Last 30 mean minus previous 30 mean", a.TakeLast(30).Average(g => g.MyRating!.Value) - a.Skip(a.Length - 60).Take(30).Average(g => g.MyRating!.Value)); } Number("Clocks", "Mean move seconds", Mean(seconds)); Number("Clocks", "Median move seconds", Quantile(seconds, 0.5)); Number("Clocks", "P90 move seconds", Quantile(seconds, 0.9)); Number("Clocks", "Observed move-time hours", seconds.Sum() / 3600, "Sum of available samples only; not total play time."); Add("Clocks", "Moves taking <=1 second", N(Pct(seconds.Count(x => x <= 1), seconds.Length)) + "%"); Add("Clocks", "Moves taking >=30 seconds", N(Pct(seconds.Count(x => x >= 30), seconds.Length)) + "%"); Number("Clocks", "Mean final recorded clock", Mean(Present(parsed.Where(g => g.TimeClass != "daily").Select(g => g.FinalClock)))); Number("Clocks", "Games with <=10 seconds seen", parsed.Count(g => g.TimeClass != "daily" && g.Mine.Any(p => p.ClockAfter <= 10))); Number("Clocks", "Mean live elapsed game seconds", Mean(Present(games.Where(g => g.TimeClass != "daily").Select(g => g.GameSeconds))), "UTC start-to-end where start tags exist; separate from estimated thinking time."); Number("Board", "Kingside castling games", parsed.Count(g => g.Castle == "O-O")); Number("Board", "Queenside castling games", parsed.Count(g => g.Castle == "O-O-O")); Number("Board", "No castling recorded", parsed.Count(g => g.Castle == "Not recorded")); Number("Board", "Mean castling turn", Mean(own.Where(x => x.Ply.Castle.Length > 0).Select(x => (double)x.Ply.Turn))); Number("Board", "Player captures", own.Count(x => x.Ply.Capture)); Number("Board", "Player checks", own.Count(x => x.Ply.Check)); Number("Board", "Player promotions", own.Count(x => x.Ply.Promotion)); Number("Board", "Games with queen moved by turn 10", parsed.Count(g => g.Mine.Any(p => p.Turn <= 10 && p.Piece == "Q")), "Descriptive, not a judgment that early queen movement is bad."); Number("Board", "Games queenless by turn 20", parsed.Count(g => g.Moves.Any(p => p.Turn <= 20 && p.QueensAfter == 0))); Number("Board", "Games visiting material +3 or more", parsed.Count(g => g.MyMaterialPath.Any(v => v >= 3))); Number("Board", "Games visiting material -3 or less", parsed.Count(g => g.MyMaterialPath.Any(v => v <= -3)), "Material-only, including transient positions. Not engine advantage."); Number("Engine sample", "Mean CP loss", Mean(cpLosses)); Number("Engine sample", "Median CP loss", Quantile(cpLosses, 0.5)); Number("Engine sample", "P90 CP loss", Quantile(cpLosses, 0.9)); Number("Engine sample", "Mean WDL expected-score loss pp", Mean(wdlLosses)); Add("Engine sample", "Best-move match rate", N(Pct(engineMoves.Count(m => m.BestMatch), engineMoves.Length)) + "%"); Number("Engine sample", "Inaccuracies", engineMoves.Count(m => m.Grade == "Inaccuracy")); Number("Engine sample", "Mistakes", engineMoves.Count(m => m.Grade == "Mistake")); Number("Engine sample", "Blunders", engineMoves.Count(m => m.Grade == "Blunder")); Number("Engine sample", "Mean search depth", Mean(engineMoves.Select(m => (double)m.Depth))); var advantageGames = games.Where(g => reports.TryGetValue(g.Id, out var r) && r.HadAdvantage == true && g.Score.HasValue).ToArray(); Add("Engine sample", "Wins after >=80% expected score", N(Pct(advantageGames.Count(g => g.Score == 1), advantageGames.Length)) + "%", $"Denominator: {advantageGames.Length} analyzed games reaching the threshold."); var troubleGames = games.Where(g => reports.TryGetValue(g.Id, out var r) && r.HadDisadvantage == true && g.Score.HasValue).ToArray(); Add("Engine sample", "Draws/wins after <=20% expected score", N(Pct(troubleGames.Count(g => g.Score >= 0.5), troubleGames.Length)) + "%", $"Denominator: {troubleGames.Length} analyzed games reaching the threshold."); var previousResult = new Dictionary(); foreach (var pool in games.GroupBy(g => (g.Rules, g.TimeClass))) { var previous = "First in filtered pool"; foreach (var g in pool) { previousResult[g.Id] = previous; previous = g.Result; } } string Gap(Game g) { if (!g.MyRating.HasValue || !g.OppRating.HasValue) return "Unknown"; var delta = g.OppRating.Value - g.MyRating.Value; return delta switch { < -200 => "Opponent >200 lower", < -50 => "Opponent 51–200 lower", <= 50 => "Within 50", <= 200 => "Opponent 51–200 higher", _ => "Opponent >200 higher" }; } string CastlePair(Game g) { if (!g.Parsed) return "Unavailable"; if (!g.Castle.StartsWith("O-") || !g.OppCastle.StartsWith("O-")) return "One/neither recorded"; return g.Castle == g.OppCastle ? "Same side" : "Opposite sides"; } string MaterialVisit(Game g) { if (!g.Parsed) return "Unavailable"; var plus = g.MyMaterialPath.Any(v => v >= 3); var minus = g.MyMaterialPath.Any(v => v <= -3); return plus && minus ? "Visited both +3 and -3" : plus ? "Visited +3" : minus ? "Visited -3" : "Neither"; } var dimensions = new (string Name, Func Key)[] { ("Pool", g => g.Rules + " / " + g.TimeClass), ("Rules", g => g.Rules), ("Color", g => g.Color), ("Rated", g => g.Rated ? "Rated" : "Unrated"), ("Time control", g => g.TimeControl), ("Month UTC", g => g.EndUtc.ToString("yyyy-MM")), ("Weekday UTC", g => $"{((int)g.EndUtc.DayOfWeek + 6) % 7 + 1} {g.EndUtc:dddd}"), ("Hour finished UTC", g => g.EndUtc.ToString("HH")), ("Termination", g => g.Result + " / " + g.EndCode), ("Opponent rating gap", Gap), ("Player rating band", g => g.MyRating.HasValue ? $"{g.MyRating.Value / 200 * 200}–{g.MyRating.Value / 200 * 200 + 199}" : "Unknown"), ("Opponent rating band", g => g.OppRating.HasValue ? $"{g.OppRating.Value / 200 * 200}–{g.OppRating.Value / 200 * 200 + 199}" : "Unknown"), ("Game length plies", g => !g.Parsed ? "Unavailable" : g.Moves.Count <= 40 ? "1–40" : g.Moves.Count <= 80 ? "41–80" : g.Moves.Count <= 120 ? "81–120" : "121+"), ("Player castling", g => g.Castle), ("Opponent castling", g => g.OppCastle), ("Castling relationship", CastlePair), ("First recorded player move", g => g.Parsed ? g.Mine.FirstOrDefault()?.San ?? "None" : "Unavailable"), ("Material visits", MaterialVisit), ("Queenless by turn 20", g => !g.Parsed ? "Unavailable" : g.Moves.Any(p => p.Turn <= 20 && p.QueensAfter == 0) ? "Yes" : "No"), ("Clock <=10 seconds seen", g => !g.Parsed || g.TimeClass == "daily" || !g.Mine.Any(p => p.ClockAfter.HasValue) ? "Unavailable" : g.Mine.Any(p => p.ClockAfter <= 10) ? "Yes" : "No"), ("Session game number", g => sessionBucket.GetValueOrDefault(g.Id, "Daily / N/A")), ("Previous result in filtered pool", g => previousResult[g.Id]), ("Engine >=80% expected score seen", g => !reports.TryGetValue(g.Id, out var r) || !r.HadAdvantage.HasValue ? "Unavailable" : r.HadAdvantage.Value ? "Yes" : "No") }; foreach (var dimension in dimensions) { ct.ThrowIfCancellationRequested(); foreach (var group in games.GroupBy(dimension.Key).OrderBy(g => g.Key)) result.Segments.Add(Slice(dimension.Name, group.Key, group)); } foreach (var group in games.GroupBy(g => (g.Eco, g.Opening, g.Color))) result.Openings.Add(Slice( "Opening / color", $"{group.Key.Eco} | {group.Key.Opening} | {group.Key.Color}", group)); result.Openings.Sort((a, b) => b.Games.CompareTo(a.Games)); foreach (var group in games.GroupBy(g => g.Opponent, StringComparer.OrdinalIgnoreCase)) result.Opponents.Add(Slice("Opponent", group.Key, group)); result.Opponents.Sort((a, b) => b.Games.CompareTo(a.Games)); void AddMoveGroups(string dimension, Func key) { foreach (var group in own.GroupBy(x => key(x.Ply)).OrderBy(g => g.Key)) { ct.ThrowIfCancellationRequested(); var a = group.ToArray(); var timed = Present(a.Select(x => x.Ply.Seconds)); var em = a.Select(x => engineLookup.GetValueOrDefault((x.Game.Id, x.Ply.Index))) .Where(x => x is not null).Cast().ToArray(); var cpl = Present(em.Select(x => x.CpLoss)); var wdl = Present(em.Select(x => x.WdlLossPp)); result.MoveGroups.Add(new( dimension, group.Key, a.Length, a.Count(x => x.Ply.ClockAfter.HasValue), timed.Length, Mean(timed), Quantile(timed, 0.5), Quantile(timed, 0.9), Pct(a.Count(x => x.Ply.Check), a.Length), Pct(a.Count(x => x.Ply.Capture), a.Length), a.Count(x => x.Ply.Promotion), em.Length, cpl.Length, Mean(cpl), wdl.Length, Mean(wdl), em.Count(x => x.Grade == "Blunder"))); } } AddMoveGroups("Piece", p => p.Piece); AddMoveGroups("Phase", p => p.Phase); AddMoveGroups("Turn", p => p.Turn <= 10 ? "01–10" : p.Turn <= 20 ? "11–20" : p.Turn <= 40 ? "21–40" : "41+"); AddMoveGroups("Time spent", p => !p.Seconds.HasValue ? "Unavailable" : p.Seconds <= 1 ? "<=1s" : p.Seconds <= 5 ? "1–5s" : p.Seconds <= 15 ? "5–15s" : p.Seconds <= 30 ? "15–30s" : ">30s"); AddMoveGroups("Clock after move", p => !p.ClockAfter.HasValue ? "Unavailable" : p.ClockAfter <= 10 ? "<=10s" : p.ClockAfter <= 30 ? "10–30s" : p.ClockAfter <= 60 ? "30–60s" : p.ClockAfter <= 180 ? "60–180s" : ">180s"); foreach (var g in games.Reverse()) { reports.TryGetValue(g.Id, out var report); result.Games.Add(new( g.Id, g.EndUtc, g.TimeClass, g.Rules, g.Rated, g.Color, g.Result, g.Opponent, g.MyRating, g.OppRating, g.TimeControl, g.EndCode, g.Eco, g.Opening, g.Parsed ? g.Moves.Count : null, g.GameSeconds, g.Castle, g.OppCastle, g.FinalClock, Mean(Present(g.Mine.Select(p => p.Seconds))), g.ApiAccuracy, report is null ? null : Mean(Present(report.Moves.Select(m => m.CpLoss))), g.Parsed ? g.MyMaterialPath.Min() : null, g.Parsed ? g.MyMaterialPath.Max() : null, g.Parsed ? "Parsed" : g.ParseError ?? "Unavailable", g.Url)); if (report is not null) { var cpl = Present(report.Moves.Select(m => m.CpLoss)); var wdl = Present(report.Moves.Select(m => m.WdlLossPp)); result.EngineGames.Add(new( g.EndUtc, g.Opponent, g.Id, report.Engine, report.MsPerPosition, report.AnalyzedUtc, report.Positions, report.Moves.Count, cpl.Length, Mean(cpl), Quantile(cpl, 0.5), Quantile(cpl, 0.9), wdl.Length, Mean(wdl), Pct(report.Moves.Count(m => m.BestMatch), report.Moves.Count), report.Moves.Count(m => m.Grade == "Inaccuracy"), report.Moves.Count(m => m.Grade == "Mistake"), report.Moves.Count(m => m.Grade == "Blunder"), report.HadAdvantage, report.HadDisadvantage, report.MeanDepth)); } } result.EngineMoves.AddRange( engineMoves.OrderByDescending(m => m.DateUtc).ThenBy(m => m.Ply)); foreach (var opening in result.Openings .Where(x => x.Scored >= 10) .OrderBy(x => x.ScorePct).Take(3)) { result.Insights.Add(new( "Opening study candidate", $"{opening.Bucket}: {opening.Scored} scored games, " + $"{N(opening.ScorePct)}% score.", "Review representative losses. Compare time controls and opponent strength " + "before concluding the opening itself is the problem.")); } var timeoutLosses = games.Count(g => g.Score == 0 && g.MyCode == "timeout"); if (timeoutLosses > 0) result.Insights.Add(new( "Time management", $"{timeoutLosses} timeout losses; {N(Pct(timeoutLosses, losses))}% of losses.", "Inspect the time-spent and low-clock buckets. Clock-derived timings are estimates.")); foreach (var phase in result.MoveGroups .Where(x => x.Dimension == "Phase" && x.EngineMoves >= 10) .OrderByDescending(x => x.Acpl).Take(1)) { result.Insights.Add(new( "Engine review priority", $"{phase.Bucket}: {phase.EngineMoves} analyzed moves, " + $"{N(phase.Acpl)} ACPL, {phase.Blunders} heuristic blunders.", "Review this phase at a larger engine budget; the analyzed sample may be biased.")); } foreach (var move in engineMoves.Where(m => m.CpLoss.HasValue) .OrderByDescending(m => m.CpLoss).Take(3)) { result.Insights.Add(new( "Critical-moment candidate", $"{move.DateUtc:u}, turn {move.Turn}, {move.San}: " + $"approximately {N(move.CpLoss)} cp loss.", $"Compare {move.Uci} with candidate {move.BestUci}; verify with deeper analysis.")); } if (result.Insights.Count == 0) result.Insights.Add(new( "More data needed", "No sufficiently populated opening group or analyzed critical moment is available.", "Import more archives or run Stockfish on a representative sample.")); Add("Definitions", "Phase heuristic", "Opening / Middlegame / Endgame", "Endgame when total N/B=1, R=2, Q=4 units <=8; otherwise turns 1–10 are Opening."); Add("Definitions", "Elo-model columns", "Approximate; not Glicko", "Use rated standard games with both ratings. Performance is undefined at 0%/100% score."); Add("Definitions", "Clock calculations", "Estimates unless EMT supplied", "Previous same-side clock + increment - current clock. First samples and invalid resets excluded."); Add("Definitions", "Comparisons", "Descriptive, not causal", "Small samples, opponent strength, pool mix, and selection effects can confound comparisons."); Add("Definitions", "Missing data", "Excluded, not zero-filled", "Coverage columns show the relevant observation counts."); Add("Definitions", "Engine scope", "Analyzed sample only", "Latest-N analysis is not necessarily representative of the full imported history."); return result; } } ``` --- # 8. Stockfish integration This launches a local UCI engine, preserves move history in its `position` commands, analyzes every position in each selected game, and caches completed reports. ## `Stockfish.cs` ```csharp using System.Diagnostics; using System.Globalization; using System.Security.Cryptography; using System.Text; using System.Text.Json; using System.Text.RegularExpressions; namespace OpenChessLab; internal sealed record EngineEvaluation( double? Cp, int? Mate, int? W, int? D, int? L, int Depth, string BestUci) { public double? ExpectedRoot { get { if (W.HasValue && D.HasValue && L.HasValue) { var total = W.Value + D.Value + L.Value; if (total > 0) return (W.Value + D.Value / 2.0) / total; } // UCI mate 0 at a terminal root means side to move is checkmated. if (Mate.HasValue) return Mate.Value > 0 ? 1 : 0; return null; } } public string Display(bool flip) { if (Cp.HasValue) { var value = (flip ? -Cp.Value : Cp.Value) / 100; return value.ToString("+0.00;-0.00;0.00", CultureInfo.InvariantCulture); } if (Mate.HasValue) { if (Mate.Value == 0) return flip ? "Mate delivered" : "Checkmated"; var value = flip ? -Mate.Value : Mate.Value; return value > 0 ? $"M{value}" : $"-M{Math.Abs(value)}"; } return "Unavailable"; } } internal sealed class UciEngine : IDisposable { private readonly Process _process; public string Name { get; private set; } = "UCI engine"; public UciEngine(string executable) { _process = new Process { StartInfo = new ProcessStartInfo(executable) { UseShellExecute = false, CreateNoWindow = true, RedirectStandardInput = true, RedirectStandardOutput = true, RedirectStandardError = true, StandardInputEncoding = new UTF8Encoding(false), StandardOutputEncoding = Encoding.UTF8 } }; _process.ErrorDataReceived += (_, _) => { }; if (!_process.Start()) throw new InvalidOperationException("Could not start the engine."); _process.StandardInput.AutoFlush = true; _process.BeginErrorReadLine(); } private Task SendAsync(string text) => _process.StandardInput.WriteLineAsync(text); private async Task ReadAsync(CancellationToken ct) => await _process.StandardOutput.ReadLineAsync(ct) ?? throw new InvalidOperationException("The engine exited unexpectedly."); public async Task InitializeAsync(CancellationToken ct) { using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct); timeout.CancelAfter(TimeSpan.FromSeconds(20)); var options = new HashSet(StringComparer.OrdinalIgnoreCase); await SendAsync("uci"); while (true) { var line = await ReadAsync(timeout.Token); if (line.StartsWith("id name ")) Name = line[8..].Trim(); if (line.StartsWith("option name ")) { var end = line.IndexOf(" type ", StringComparison.Ordinal); if (end > 12) options.Add(line[12..end]); } if (line == "uciok") break; } async Task Set(string name, string value) { if (options.Contains(name)) await SendAsync($"setoption name {name} value {value}"); } await Set("Threads", "1"); await Set("Hash", "64"); await Set("MultiPV", "1"); await Set("UCI_Chess960", "false"); await Set("UCI_LimitStrength", "false"); await Set("UCI_AnalyseMode", "true"); await Set("UCI_ShowWDL", "true"); await ReadyAsync(timeout.Token); } private async Task ReadyAsync(CancellationToken ct) { await SendAsync("isready"); while (await ReadAsync(ct) != "readyok") { } } public async Task NewGameAsync(CancellationToken ct) { using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct); timeout.CancelAfter(TimeSpan.FromSeconds(15)); await SendAsync("ucinewgame"); await ReadyAsync(timeout.Token); } public async Task EvaluateAsync( string positionCommand, int milliseconds, CancellationToken ct) { using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct); timeout.CancelAfter(TimeSpan.FromMilliseconds(milliseconds + 20_000)); await SendAsync(positionCommand); await SendAsync($"go movetime {milliseconds}"); EngineEvaluation? evaluation = null; while (true) { var line = await ReadAsync(timeout.Token); if (line.StartsWith("info ") && !line.Contains("lowerbound") && !line.Contains("upperbound")) { var multi = Regex.Match(line, @"\bmultipv (\d+)"); if (multi.Success && multi.Groups[1].Value != "1") continue; var score = Regex.Match(line, @"\bscore (cp|mate) (-?\d+)"); if (!score.Success) continue; var depth = Regex.Match(line, @"\bdepth (\d+)"); var wdl = Regex.Match(line, @"\bwdl (\d+) (\d+) (\d+)"); var value = int.Parse(score.Groups[2].Value, CultureInfo.InvariantCulture); evaluation = new EngineEvaluation( score.Groups[1].Value == "cp" ? value : null, score.Groups[1].Value == "mate" ? value : null, wdl.Success ? int.Parse(wdl.Groups[1].Value) : null, wdl.Success ? int.Parse(wdl.Groups[2].Value) : null, wdl.Success ? int.Parse(wdl.Groups[3].Value) : null, depth.Success ? int.Parse(depth.Groups[1].Value) : 0, ""); } if (line.StartsWith("bestmove ")) { if (evaluation is null) throw new InvalidDataException( "Engine returned no usable score. Increase the search budget."); var fields = line.Split(' ', StringSplitOptions.RemoveEmptyEntries); return evaluation with { BestUci = fields.Length > 1 ? fields[1] : "" }; } } } public void Abort() { try { if (!_process.HasExited) _process.Kill(entireProcessTree: true); } catch (InvalidOperationException) { } catch (System.ComponentModel.Win32Exception) { } } public void Dispose() { Abort(); _process.Dispose(); } } public static class Stockfish { public static async Task AnalyzeAsync( string executable, IReadOnlyList games, int milliseconds, IProgress progress, Action completed, CancellationToken ct) { string binaryHash; await using (var file = File.OpenRead(executable)) binaryHash = Convert.ToHexString(await SHA256.HashDataAsync(file, ct)); using var engine = new UciEngine(executable); using var abort = ct.Register(engine.Abort); try { await engine.InitializeAsync(ct); for (var gameIndex = 0; gameIndex < games.Count; gameIndex++) { ct.ThrowIfCancellationRequested(); var game = games[gameIndex]; var allUci = string.Join(" ", game.Moves.Select(p => p.Uci)); var cacheKey = $"analysis-v1|{binaryHash}|{milliseconds}|{game.Id}|" + $"{game.IsWhite}|{game.StartFen}|{allUci}"; var path = LocalStore.FileFor("engine", cacheKey); var cached = await LocalStore.ReadAsync(path, null, ct); if (cached is not null) { try { var report = JsonSerializer.Deserialize(cached); if (report is not null && report.GameId == game.Id && report.Moves.Count == game.Mine.Count()) { completed(report); progress.Report( $"Engine cache: {gameIndex + 1}/{games.Count} games."); continue; } } catch (JsonException) { // Invalid cache: analyze again. } } await engine.NewGameAsync(ct); var evaluations = new List(); var position = new StringBuilder("position fen " + game.StartFen); for (var i = 0; i <= game.Moves.Count; i++) { ct.ThrowIfCancellationRequested(); progress.Report( $"Stockfish game {gameIndex + 1}/{games.Count}, " + $"position {i + 1}/{game.Moves.Count + 1}."); evaluations.Add(await engine.EvaluateAsync( position.ToString(), milliseconds, ct)); if (i < game.Moves.Count) { position.Append(i == 0 ? " moves " : " "); position.Append(game.Moves[i].Uci); } } var rows = new List(); for (var i = 0; i < game.Moves.Count; i++) { var ply = game.Moves[i]; if (ply.White != game.IsWhite) continue; var before = evaluations[i]; var after = evaluations[i + 1]; // Before is in mover's perspective. // After is in the opponent's perspective, so invert it. double? cpLoss = before.Cp.HasValue && after.Cp.HasValue ? Math.Max(0, before.Cp.Value + after.Cp.Value) : null; double? wdlLoss = before.ExpectedRoot.HasValue && after.ExpectedRoot.HasValue ? Math.Max(0, (before.ExpectedRoot.Value - (1 - after.ExpectedRoot.Value)) * 100) : null; var (grade, basis) = Grade( ply.Uci == before.BestUci, cpLoss, wdlLoss); rows.Add(new EngineMove( game.Id, game.EndUtc, ply.Index, ply.Turn, ply.San, ply.Uci, before.BestUci, ply.Phase, ply.Piece, ply.Seconds, ply.ClockAfter, before.Display(false), after.Display(true), cpLoss, wdlLoss, grade, basis, before.Depth)); } var expectations = new List(); for (var i = 0; i < evaluations.Count; i++) { var expected = evaluations[i].ExpectedRoot; if (!expected.HasValue) continue; var sideWhite = i % 2 == 0 ? game.StartWhite : !game.StartWhite; expectations.Add(sideWhite == game.IsWhite ? expected.Value : 1 - expected.Value); } bool? Visited(Func predicate) => expectations.Any(predicate) ? true : expectations.Count == evaluations.Count ? false : null; var newReport = new EngineReport { GameId = game.Id, Engine = $"{engine.Name} [{binaryHash[..12]}]", MsPerPosition = milliseconds, AnalyzedUtc = DateTime.UtcNow, Positions = evaluations.Count, MeanDepth = evaluations.Average(e => e.Depth), HadAdvantage = Visited(p => p >= 0.8), HadDisadvantage = Visited(p => p <= 0.2), Moves = rows }; // Preserve completed work even if persistence subsequently fails. completed(newReport); await LocalStore.WriteAsync( path, JsonSerializer.Serialize(newReport), ct); } } catch (OperationCanceledException) when (!ct.IsCancellationRequested) { throw new TimeoutException("The engine did not respond within its timeout."); } catch (Exception) when (ct.IsCancellationRequested) { throw new OperationCanceledException(ct); } } private static (string Grade, string Basis) Grade( bool bestMatch, double? cpLoss, double? wdlLoss) { if (bestMatch) return ("Best match", "UCI bestmove"); if (wdlLoss.HasValue) { return (wdlLoss.Value switch { <= 1 => "Near best", <= 5 => "Inaccuracy", <= 10 => "Mistake", _ => "Blunder" }, "WDL loss pp"); } if (cpLoss.HasValue) { return (cpLoss.Value switch { <= 20 => "Near best", <= 100 => "Inaccuracy", <= 200 => "Mistake", _ => "Blunder" }, "CP-loss fallback"); } return ("Unclassified", "Insufficient comparable scores"); } } ``` --- # 9. Native WPF charts ## `Charts.cs` ```csharp using System.Globalization; using System.Windows; using System.Windows.Media; namespace OpenChessLab; internal static class ChartDrawing { public static void Text( FrameworkElement owner, DrawingContext dc, string text, double x, double y, Brush? brush = null, double size = 11) { dc.DrawText(new FormattedText( text, CultureInfo.InvariantCulture, FlowDirection.LeftToRight, new Typeface("Segoe UI"), size, brush ?? Brushes.LightSlateGray, VisualTreeHelper.GetDpi(owner).PixelsPerDip), new Point(x, y)); } } public sealed class RatingChart : FrameworkElement { private Game[] _games = []; private static readonly Brush[] Colors = [ Brushes.DeepSkyBlue, Brushes.MediumSpringGreen, Brushes.Orange, Brushes.Violet, Brushes.Gold, Brushes.Tomato ]; public void SetGames(IEnumerable games) { _games = games.Where(g => g.Rated && g.Rules == "chess" && g.MyRating.HasValue) .OrderBy(g => g.EndUtc).ToArray(); InvalidateVisual(); } protected override void OnRender(DrawingContext dc) { base.OnRender(dc); dc.DrawRectangle(new SolidColorBrush(Color.FromRgb(16, 27, 43)), null, new Rect(RenderSize)); ChartDrawing.Text(this, dc, "ARCHIVE-RECORDED RATINGS • separate pools • not per-game rating gains", 12, 8); if (_games.Length == 0 || ActualWidth < 150 || ActualHeight < 100) { ChartDrawing.Text(this, dc, "No rated standard-chess games in this filter.", 12, 40); return; } const double left = 58; const double top = 35; var width = Math.Max(1, ActualWidth - left - 20); var height = Math.Max(1, ActualHeight - top - 45); var minRating = _games.Min(g => g.MyRating!.Value) - 25.0; var maxRating = _games.Max(g => g.MyRating!.Value) + 25.0; var first = _games[0].EndUtc; var last = _games[^1].EndUtc; var span = Math.Max(1, (last - first).TotalSeconds); for (var i = 0; i <= 4; i++) { var y = top + height * i / 4; var rating = maxRating - (maxRating - minRating) * i / 4; dc.DrawLine(new Pen(new SolidColorBrush(Color.FromRgb(38, 52, 73)), 1), new Point(left, y), new Point(left + width, y)); ChartDrawing.Text(this, dc, rating.ToString("0"), 8, y - 7); } var poolIndex = 0; var legendX = left; foreach (var pool in _games.GroupBy(g => g.TimeClass)) { var brush = Colors[poolIndex++ % Colors.Length]; var values = pool.ToArray(); var step = Math.Max(1, values.Length / 1800); var sampled = values.Where((_, i) => i % step == 0 || i == values.Length - 1).ToArray(); var geometry = new StreamGeometry(); using (var context = geometry.Open()) { for (var i = 0; i < sampled.Length; i++) { var game = sampled[i]; var point = new Point( left + (game.EndUtc - first).TotalSeconds / span * width, top + (maxRating - game.MyRating!.Value) / (maxRating - minRating) * height); if (i == 0) context.BeginFigure(point, false, false); else context.LineTo(point, true, false); if (sampled.Length == 1) dc.DrawEllipse(brush, null, point, 3, 3); } } geometry.Freeze(); dc.DrawGeometry(null, new Pen(brush, 1.8), geometry); ChartDrawing.Text(this, dc, pool.Key, legendX, ActualHeight - 19, brush); legendX += 100; } ChartDrawing.Text(this, dc, first.ToString("yyyy-MM-dd"), left, top + height + 4); ChartDrawing.Text(this, dc, last.ToString("yyyy-MM-dd"), Math.Max(left, ActualWidth - 90), top + height + 4); } } public sealed class ActivityChart : FrameworkElement { private readonly int[,] _counts = new int[7, 24]; public void SetGames(IEnumerable games) { Array.Clear(_counts, 0, _counts.Length); foreach (var game in games) { var day = ((int)game.EndUtc.DayOfWeek + 6) % 7; _counts[day, game.EndUtc.Hour]++; } InvalidateVisual(); } protected override void OnRender(DrawingContext dc) { base.OnRender(dc); dc.DrawRectangle(new SolidColorBrush(Color.FromRgb(16, 27, 43)), null, new Rect(RenderSize)); ChartDrawing.Text(this, dc, "ACTIVITY • games finishing by weekday and hour UTC", 12, 6); if (ActualWidth < 160 || ActualHeight < 100) return; const double left = 48; const double top = 32; var cellWidth = (ActualWidth - left - 10) / 24; var cellHeight = (ActualHeight - top - 22) / 7; var max = Math.Max(1, _counts.Cast().Max()); string[] days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]; for (var day = 0; day < 7; day++) { ChartDrawing.Text(this, dc, days[day], 8, top + day * cellHeight); for (var hour = 0; hour < 24; hour++) { var value = _counts[day, hour]; var intensity = Math.Log(1 + value) / Math.Log(1 + max); var brush = new SolidColorBrush(Color.FromRgb( (byte)(20 + 15 * intensity), (byte)(35 + 170 * intensity), (byte)(55 + 105 * intensity))); var rect = new Rect( left + hour * cellWidth, top + day * cellHeight, Math.Max(1, cellWidth - 2), Math.Max(1, cellHeight - 2)); dc.DrawRectangle(brush, null, rect); if (value > 0 && cellWidth > 34 && cellHeight > 16) ChartDrawing.Text(this, dc, value.ToString(), rect.X + 3, rect.Y, Brushes.White, 10); } } for (var hour = 0; hour < 24; hour += 2) ChartDrawing.Text(this, dc, hour.ToString("00"), left + hour * cellWidth, ActualHeight - 19); } } ``` --- # 10. WPF interface ## `MainWindow.xaml` ```xml

xxx