Day 2 vibes

2026-06-11 09:04:54 -04:00
parent adeb4ae7cb
commit 404ad03d0d
105 changed files with 55677 additions and 46068 deletions
@@ -1,4 +1,7 @@
+using System.Net;
 using System.Net.Http.Json;
+using System.Text;
+using System.Text.RegularExpressions;
 using Markdig;
 using Web.Models;

@@ -6,12 +9,20 @@ namespace Web.Services;

 public class DocsService
 {
-    private readonly HttpClient _http;
-    private NotesIndex? _index;
    private static readonly MarkdownPipeline Pipeline = new MarkdownPipelineBuilder()
        .UseYamlFrontMatter()
+        .UsePipeTables()
        .Build();

+    private static readonly HashSet<string> ImageExtensions = new(StringComparer.OrdinalIgnoreCase)
+    {
+        ".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".bmp"
+    };
+
+    private readonly HttpClient _http;
+    private NotesIndex? _index;
+    private readonly Dictionary<string, string> _markdownCache = new();
+
    public DocsService(HttpClient http)
    {
        _http = http;
@@ -38,7 +49,7 @@ public class DocsService
        try
        {
            var markdown = await _http.GetStringAsync($"docs/notes/{slug}.md");
-            return ParseDocument(slug, noteInfo.Title, markdown);
+            return await ParseDocument(slug, noteInfo.Title, markdown);
        }
        catch
        {
@@ -46,7 +57,7 @@ public class DocsService
        }
    }

-    private static NoteDocument ParseDocument(string slug, string title, string markdown)
+    private async Task<NoteDocument> ParseDocument(string slug, string title, string markdown, int depth = 0)
    {
        var doc = new NoteDocument
        {
@@ -69,6 +80,7 @@ public class DocsService
                    inFrontmatter = true;
                    continue;
                }
+
                inFrontmatter = false;
                frontmatterDone = true;
                continue;
@@ -89,13 +101,11 @@ public class DocsService
                {
                    var key = line[..colonIdx].Trim();
                    if (string.Equals(key, "category", StringComparison.OrdinalIgnoreCase))
-                    {
                        doc.Category = line[(colonIdx + 1)..].Trim().Trim('"');
-                    }
                }
            }

-            var fmHtml = new System.Text.StringBuilder();
+            var fmHtml = new StringBuilder();
            fmHtml.Append("<table class=\"frontmatter\">");
            foreach (var line in frontmatterLines)
            {
@@ -105,35 +115,93 @@ public class DocsService
                    var key = line[..colonIdx].Trim();
                    var value = line[(colonIdx + 1)..].Trim().Trim('"');
                    fmHtml.Append("<tr><td class=\"fm-key\">");
-                    fmHtml.Append(System.Net.WebUtility.HtmlEncode(key));
+                    fmHtml.Append(WebUtility.HtmlEncode(key));
                    fmHtml.Append("</td><td class=\"fm-value\">");
-                    var encoded = System.Net.WebUtility.HtmlEncode(value);
+                    var encoded = WebUtility.HtmlEncode(value);
                    fmHtml.Append(ConvertWikiLinks(encoded));
                    fmHtml.Append("</td></tr>");
                }
                else
                {
                    fmHtml.Append("<tr><td colspan=\"2\">");
-                    fmHtml.Append(ConvertWikiLinks(System.Net.WebUtility.HtmlEncode(line.Trim())));
+                    fmHtml.Append(ConvertWikiLinks(WebUtility.HtmlEncode(line.Trim())));
                    fmHtml.Append("</td></tr>");
                }
            }
+
            fmHtml.Append("</table>");
            doc.FrontmatterHtml = fmHtml.ToString();
        }

        var body = string.Join("\n", bodyLines);
        body = ConvertWikiLinks(body);
-        doc.HtmlContent = Markdown.ToHtml(body, Pipeline);
+        var html = Markdown.ToHtml(body, Pipeline);
+        html = await ResolveEmbedsInHtml(html, depth);
+        doc.HtmlContent = html;

        return doc;
    }

+    private async Task<string> ResolveEmbedsInHtml(string html, int depth)
+    {
+        if (depth > 10) return html;
+
+        var regex = new Regex(@"(?:<p>)?!\[\[([^\]]+)\]\](?:</p>)?");
+        var sb = new StringBuilder();
+        var lastIndex = 0;
+
+        foreach (Match match in regex.Matches(html))
+        {
+            sb.Append(html, lastIndex, match.Index - lastIndex);
+
+            var filename = match.Groups[1].Value.Trim();
+            var replacement = await ResolveEmbed(filename, depth);
+            sb.Append(replacement);
+
+            lastIndex = match.Index + match.Length;
+        }
+
+        sb.Append(html, lastIndex, html.Length - lastIndex);
+        return sb.ToString();
+    }
+
+    private async Task<string> ResolveEmbed(string filename, int depth)
+    {
+        var ext = Path.GetExtension(filename);
+
+        if (ImageExtensions.Contains(ext))
+        {
+            return $"<img src=\"/docs/images/{filename}\" alt=\"{WebUtility.HtmlEncode(filename)}\" />";
+        }
+
+        var slug = Slugify(filename);
+        try
+        {
+            var markdown = await GetMarkdownAsync(slug);
+            var embedded = await ParseDocument(slug, filename, markdown, depth + 1);
+            return $"<div class=\"embed\">{embedded.HtmlContent}</div>";
+        }
+        catch
+        {
+            return $"<div class=\"embed-error\">[Embed not found: {WebUtility.HtmlEncode(filename)}]</div>";
+        }
+    }
+
+    private async Task<string> GetMarkdownAsync(string slug)
+    {
+        if (_markdownCache.TryGetValue(slug, out var cached))
+            return cached;
+
+        var markdown = await _http.GetStringAsync($"docs/notes/{slug}.md");
+        _markdownCache[slug] = markdown;
+        return markdown;
+    }
+
    private static string ConvertWikiLinks(string text)
    {
-        return System.Text.RegularExpressions.Regex.Replace(
+        return Regex.Replace(
            text,
-            @"\[\[([^\]]+)\]\]",
+            @"(?<!!)\[\[([^\]]+)\]\]",
            match =>
            {
                var content = match.Groups[1].Value;
@@ -141,7 +209,7 @@ public class DocsService
                var linkText = parts.Length > 1 ? parts[1].Trim() : parts[0].Trim();
                var target = parts[0].Trim();
                var slug = Slugify(target);
-                return $"<a href=\"/docs/{slug}\">{System.Net.WebUtility.HtmlEncode(linkText)}</a>";
+                return $"<a href=\"/docs/{slug}\">{WebUtility.HtmlEncode(linkText)}</a>";
            });
    }

@@ -153,8 +221,8 @@ public class DocsService
            .Replace(".", "")
            .Replace("(", "")
            .Replace(")", "");
-        slug = System.Text.RegularExpressions.Regex.Replace(slug, @"[^a-z0-9\-]", "");
-        slug = System.Text.RegularExpressions.Regex.Replace(slug, @"-+", "-");
+        slug = Regex.Replace(slug, @"[^a-z0-9\-]", "");
+        slug = Regex.Replace(slug, @"-+", "-");
        return slug.Trim('-');
    }
 }
@@ -0,0 +1,355 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Web.Services;
+
+public class RegionState
+{
+    public string Name { get; set; } = "";
+    public string Slug { get; set; } = "";
+    public string Terrain { get; set; } = "";
+    public int X { get; set; }
+    public int Y { get; set; }
+    public List<string> Connections { get; set; } = new();
+    public int PredatorMeeples { get; set; }
+    public int PreyMeeples { get; set; }
+    public int FloraMeeples { get; set; }
+
+    public RegionState Clone()
+    {
+        return new RegionState
+        {
+            Name = Name,
+            Slug = Slug,
+            Terrain = Terrain,
+            X = X,
+            Y = Y,
+            Connections = new List<string>(Connections),
+            PredatorMeeples = PredatorMeeples,
+            PreyMeeples = PreyMeeples,
+            FloraMeeples = FloraMeeples
+        };
+    }
+}
+
+public class TerrainActivation
+{
+    public string MeepleType { get; set; } = "";
+    public string RegionType { get; set; } = "";
+}
+
+public class TurnEvent
+{
+    public int TurnNumber { get; set; }
+    public List<TerrainActivation> Activations { get; set; } = new();
+    public List<string> Details { get; set; } = new();
+}
+
+public class SimulationData
+{
+    public List<RegionState> Regions { get; set; } = new();
+    public List<RegionState> InitialRegions { get; set; } = new();
+    public List<TurnEvent> Events { get; set; } = new();
+    public List<List<RegionState>> Timeline { get; set; } = new();
+    public int CurrentTurn { get; set; }
+    public bool IsInitialized { get; set; }
+}
+
+public class GameSimulationService
+{
+    private readonly Random _rng = new();
+
+    public SimulationData Data { get; private set; } = new();
+
+    public void RunSimulation()
+    {
+        Data = new SimulationData();
+        var regions = CreateRegions();
+        Data.Regions = regions;
+        AddInitialFlora();
+        AddRandomMeepleCombos();
+        Data.InitialRegions = Data.Regions.Select(r => r.Clone()).ToList();
+        GenerateAndApplyEvents();
+        Data.IsInitialized = true;
+    }
+
+    public void RandomizeEvents()
+    {
+        var initialRegions = Data.InitialRegions;
+        Data = new SimulationData();
+        Data.Regions = initialRegions.Select(r => r.Clone()).ToList();
+        Data.InitialRegions = initialRegions;
+        GenerateAndApplyEvents();
+        Data.IsInitialized = true;
+    }
+
+    public List<RegionState> GetCurrentState()
+    {
+        return Data.Timeline[Data.CurrentTurn].Select(r => r.Clone()).ToList();
+    }
+
+    public TurnEvent? GetCurrentEvent()
+    {
+        return Data.CurrentTurn > 0
+            ? Data.Events.ElementAtOrDefault(Data.CurrentTurn - 1)
+            : null;
+    }
+
+    public List<RegionState> GetPreviousState()
+    {
+        var prev = Data.CurrentTurn > 0 ? Data.CurrentTurn - 1 : 0;
+        return Data.Timeline[prev].Select(r => r.Clone()).ToList();
+    }
+
+    public (int predators, int prey, int flora)[] GetPopulationHistory()
+    {
+        return Data.Timeline.Select(t => (
+            t.Sum(r => r.PredatorMeeples),
+            t.Sum(r => r.PreyMeeples),
+            t.Sum(r => r.FloraMeeples)
+        )).ToArray();
+    }
+
+    private void GenerateAndApplyEvents()
+    {
+        Data.Timeline.Add(Data.Regions.Select(r => r.Clone()).ToList());
+
+        for (int turn = 1; turn <= 20; turn++)
+        {
+            var turnEvent = GenerateTurnEvent(turn);
+            ApplyTurnEvent(turnEvent);
+            Data.Events.Add(turnEvent);
+            Data.Timeline.Add(Data.Regions.Select(r => r.Clone()).ToList());
+        }
+
+        Data.CurrentTurn = 0;
+    }
+
+    private TurnEvent GenerateTurnEvent(int turnNumber)
+    {
+        string[] meepleTypes = { "Predator", "Prey", "Flora" };
+        string[] regionTypes = { "Grass", "Forest", "Mountain", "Water", "Wasteland" };
+        var numTypes = _rng.Next(1, 4);
+        var selectedTypes = regionTypes.OrderBy(_ => _rng.Next()).Take(numTypes).ToList();
+
+        var activations = selectedTypes.Select(rt => new TerrainActivation
+        {
+            RegionType = rt,
+            MeepleType = meepleTypes[_rng.Next(3)]
+        }).ToList();
+
+        return new TurnEvent
+        {
+            TurnNumber = turnNumber,
+            Activations = activations,
+            Details = new List<string>()
+        };
+    }
+
+    private void ApplyTurnEvent(TurnEvent turnEvent)
+    {
+        var details = new List<string>();
+
+        foreach (var activation in turnEvent.Activations)
+        {
+            foreach (var region in Data.Regions.Where(r => r.Terrain == activation.RegionType))
+            {
+                switch (activation.MeepleType)
+                {
+                    case "Flora":
+                        region.FloraMeeples++;
+                        details.Add($"{region.Name}: +1 Flora");
+                        break;
+
+                    case "Predator":
+                        ApplyPredatorActivation(region, details);
+                        break;
+
+                    case "Prey":
+                        ApplyPreyActivation(region, details);
+                        break;
+                }
+            }
+        }
+
+        turnEvent.Details = details;
+    }
+
+    private void ApplyPredatorActivation(RegionState region, List<string> details)
+    {
+        if (region.PredatorMeeples <= 0)
+            return;
+
+        if (region.PreyMeeples > 0)
+        {
+            int eaten = Math.Min(region.PredatorMeeples, region.PreyMeeples);
+            region.PreyMeeples -= eaten;
+            region.PredatorMeeples += eaten;
+            details.Add($"{region.Name}: Predators ate {eaten} prey, now {region.PredatorMeeples}P / {region.PreyMeeples}R");
+        }
+        else
+        {
+            var target = FindBestTravelTarget(region, r => r.PreyMeeples);
+            if (target != null)
+            {
+                int traveling = region.PredatorMeeples;
+                target.PredatorMeeples += traveling;
+                region.PredatorMeeples = 0;
+                details.Add($"{region.Name}: {traveling} predators traveled to {target.Name}");
+            }
+        }
+    }
+
+    private void ApplyPreyActivation(RegionState region, List<string> details)
+    {
+        if (region.PreyMeeples <= 0)
+            return;
+
+        if (region.FloraMeeples > 0)
+        {
+            int consumed = Math.Min(region.PreyMeeples, region.FloraMeeples);
+            region.FloraMeeples -= consumed;
+            region.PreyMeeples += consumed;
+            details.Add($"{region.Name}: Prey consumed {consumed} flora, now {region.PreyMeeples}R / {region.FloraMeeples}F");
+        }
+        else
+        {
+            var target = FindBestTravelTarget(region, r => r.FloraMeeples);
+            if (target != null)
+            {
+                int traveling = region.PreyMeeples;
+                target.PreyMeeples += traveling;
+                region.PreyMeeples = 0;
+                details.Add($"{region.Name}: {traveling} prey traveled to {target.Name}");
+            }
+        }
+    }
+
+    private RegionState? FindBestTravelTarget(RegionState region, Func<RegionState, int> resourceCount)
+    {
+        var direct = region.Connections
+            .Select(name => Data.Regions.FirstOrDefault(r => r.Name == name))
+            .OfType<RegionState>()
+            .Where(r => resourceCount(r) > 0)
+            .ToList();
+
+        if (direct.Count > 0)
+        {
+            return direct.OrderByDescending(r => resourceCount(r)).First();
+        }
+
+        // BFS to find nearest region with resource, return first step along path
+        var visited = new HashSet<string> { region.Name };
+        var prev = new Dictionary<string, string>();
+        var queue = new Queue<string>();
+
+        foreach (var conn in region.Connections)
+        {
+            if (!visited.Contains(conn))
+            {
+                visited.Add(conn);
+                prev[conn] = region.Name;
+                queue.Enqueue(conn);
+            }
+        }
+
+        while (queue.Count > 0)
+        {
+            var currentName = queue.Dequeue();
+            var current = Data.Regions.FirstOrDefault(r => r.Name == currentName);
+            if (current == null) continue;
+
+            if (resourceCount(current) > 0)
+            {
+                // Walk back to find the first step from the origin region
+                var step = currentName;
+                while (prev[step] != region.Name)
+                    step = prev[step];
+                return Data.Regions.FirstOrDefault(r => r.Name == step);
+            }
+
+            foreach (var conn in current.Connections)
+            {
+                if (!visited.Contains(conn))
+                {
+                    visited.Add(conn);
+                    prev[conn] = currentName;
+                    queue.Enqueue(conn);
+                }
+            }
+        }
+
+        return null;
+    }
+
+    private void AddInitialFlora()
+    {
+        var excluded = new HashSet<string>
+        {
+            "Grass 1", "Grass 2", "Wasteland 1",
+            "Mountain 1", "Mountain 2", "Mountain 3", "Mountain 4", "Mountain 5"
+        };
+
+        foreach (var region in Data.Regions)
+        {
+            if (!excluded.Contains(region.Name))
+            {
+                region.FloraMeeples = 1;
+            }
+        }
+    }
+
+    private void AddRandomMeepleCombos()
+    {
+        var combos = new List<(int pred, int prey, int flora)>();
+        for (int total = 1; total <= 3; total++)
+        {
+            for (int p = 0; p <= total; p++)
+            {
+                for (int r = 0; r <= total - p; r++)
+                {
+                    int f = total - p - r;
+                    combos.Add((p, r, f));
+                }
+            }
+        }
+
+        var shuffled = combos.OrderBy(_ => _rng.Next()).ToList();
+        for (int i = 0; i < Data.Regions.Count; i++)
+        {
+            var (p, r, f) = shuffled[i % shuffled.Count];
+            Data.Regions[i].PredatorMeeples = p;
+            Data.Regions[i].PreyMeeples = r;
+            Data.Regions[i].FloraMeeples = f;
+        }
+    }
+
+    private static List<RegionState> CreateRegions()
+    {
+        return new List<RegionState>
+        {
+            new() { Name = "Grass 1", Slug = "grass-1", Terrain = "Grass", X = 15, Y = 260, Connections = new() { "Mountain 1", "Water 2", "Forest 1" } },
+            new() { Name = "Grass 2", Slug = "grass-2", Terrain = "Grass", X = 150, Y = 400, Connections = new() { "Forest 1", "Forest 2" } },
+            new() { Name = "Grass 3", Slug = "grass-3", Terrain = "Grass", X = 300, Y = 230, Connections = new() { "Water 2", "Mountain 2", "Mountain 3" } },
+            new() { Name = "Grass 4", Slug = "grass-4", Terrain = "Grass", X = 510, Y = 30, Connections = new() { "Mountain 4", "Wasteland 1" } },
+            new() { Name = "Grass 5", Slug = "grass-5", Terrain = "Grass", X = 550, Y = 290, Connections = new() { "Mountain 5", "Water 5", "Wasteland 1", "Forest 4" } },
+            new() { Name = "Forest 1", Slug = "forest-1", Terrain = "Forest", X = 60, Y = 330, Connections = new() { "Grass 1", "Grass 2", "Water 1", "Forest 2" } },
+            new() { Name = "Forest 2", Slug = "forest-2", Terrain = "Forest", X = 250, Y = 370, Connections = new() { "Grass 2", "Water 2", "Forest 1" } },
+            new() { Name = "Forest 3", Slug = "forest-3", Terrain = "Forest", X = 150, Y = 125, Connections = new() { "Water 2", "Water 3" } },
+            new() { Name = "Forest 4", Slug = "forest-4", Terrain = "Forest", X = 420, Y = 100, Connections = new() { "Grass 4", "Wasteland 1", "Grass 5" } },
+            new() { Name = "Forest 5", Slug = "forest-5", Terrain = "Forest", X = 470, Y = 410, Connections = new() { "Water 5" } },
+            new() { Name = "Mountain 1", Slug = "mountain-1", Terrain = "Mountain", X = 20, Y = 120, Connections = new() { "Grass 1", "Water 3", "Forest 3" } },
+            new() { Name = "Mountain 2", Slug = "mountain-2", Terrain = "Mountain", X = 260, Y = 110, Connections = new() { "Water 3", "Forest 3" } },
+            new() { Name = "Mountain 3", Slug = "mountain-3", Terrain = "Mountain", X = 380, Y = 180, Connections = new() { "Mountain 5", "Forest 4", "Grass 3" } },
+            new() { Name = "Mountain 4", Slug = "mountain-4", Terrain = "Mountain", X = 370, Y = 30, Connections = new() { "Forest 4", "Grass 4" } },
+            new() { Name = "Mountain 5", Slug = "mountain-5", Terrain = "Mountain", X = 430, Y = 330, Connections = new() { "Grass 5", "Mountain 3" } },
+            new() { Name = "Water 1", Slug = "water-1", Terrain = "Water", X = 30, Y = 410, Connections = new() { "Forest 1" } },
+            new() { Name = "Water 2", Slug = "water-2", Terrain = "Water", X = 140, Y = 260, Connections = new() { "Forest 1", "Forest 2", "Grass 1", "Forest 3", "Grass 3" } },
+            new() { Name = "Water 3", Slug = "water-3", Terrain = "Water", X = 50, Y = 50, Connections = new() { "Mountain 1", "Mountain 2", "Forest 3" } },
+            new() { Name = "Water 4", Slug = "water-4", Terrain = "Water", X = 640, Y = 110, Connections = new() { "Grass 4", "Wasteland 1" } },
+            new() { Name = "Water 5", Slug = "water-5", Terrain = "Water", X = 600, Y = 400, Connections = new() { "Grass 5", "Forest 5" } },
+            new() { Name = "Wasteland 1", Slug = "wasteland-1", Terrain = "Wasteland", X = 560, Y = 120, Connections = new() { "Forest 4", "Grass 4", "Grass 5", "Water 4" } }
+        };
+    }
+}