- About
-
*@
-
- Sorry, there's nothing at this address.
-@L["App_NotFound"]
+Counter
- -Current count: @currentCount
- - - -@code { - private int currentCount = 0; - - private void IncrementCount() - { - currentCount++; - } -} diff --git a/src/FastGeography.Client/Pages/GameTable.razor b/src/FastGeography.Client/Pages/GameTable.razor index 9257666..865657e 100644 --- a/src/FastGeography.Client/Pages/GameTable.razor +++ b/src/FastGeography.Client/Pages/GameTable.razor @@ -1,203 +1,267 @@ -@page "/fastgeography" -@using BingMapsRESTToolkit; -@using System.Net.Http.Json; -@using System.Linq; -@using FastGeography.Shared; -@inject HttpClient HttpClient; +@page "/" +@page "/fastgeography" +@implements IDisposable +@using System.Net.Http.Json +@using System.Linq +@using FastGeography.Shared +@inject HttpClient HttpClient +@inject ILogger
-
\ No newline at end of file
+
+ private ListHello, world!
- -Welcome to your new app. - -
+
+
+@code {
+ private readonly LoginModel _model = new();
+ private string? _error;
+ private bool _busy;
+ private string? _returnUrl;
+
+ protected override void OnInitialized()
+ {
+ var query = new Uri(Nav.Uri).Query;
+ foreach (var part in query.TrimStart('?').Split('&'))
+ {
+ var kv = part.Split('=', 2);
+ if (kv.Length == 2 && kv[0] == "returnUrl")
+ {
+ _returnUrl = Uri.UnescapeDataString(kv[1]);
+ break;
+ }
+ }
+ }
+
+ private async Task DoLogin()
+ {
+ _busy = true;
+ _error = null;
+ var ok = await Auth.LoginAsync(_model.Email, _model.Password);
+ _busy = false;
+
+ if (ok) Nav.NavigateTo(string.IsNullOrWhiteSpace(_returnUrl) ? "/" : _returnUrl);
+ else _error = L["Login_InvalidCredentials"];
+ }
+
+ private sealed class LoginModel
+ {
+ [System.ComponentModel.DataAnnotations.Required]
+ [System.ComponentModel.DataAnnotations.EmailAddress]
+ public string Email { get; set; } = string.Empty;
+
+ [System.ComponentModel.DataAnnotations.Required]
+ public string Password { get; set; } = string.Empty;
+ }
+}
diff --git a/src/FastGeography.Client/Pages/MultiplayerGame.razor b/src/FastGeography.Client/Pages/MultiplayerGame.razor
new file mode 100644
index 0000000..cb986b5
--- /dev/null
+++ b/src/FastGeography.Client/Pages/MultiplayerGame.razor
@@ -0,0 +1,456 @@
+@page "/multiplayer/{RoomCode}"
+@attribute [Authorize]
+@implements IAsyncDisposable
+@inject HttpClient Http
+@inject CookieAuthenticationStateProvider Auth
+@inject NavigationManager Nav
+@inject ActiveMultiplayerRoomState ActiveRoom
+@inject ILogger
+
+
+
+
+@L["Login_Heading"]
+ + @if (!string.IsNullOrEmpty(_error)) + { +@_error
+ }
+
+
+
+
+
+
+
+
+
+
+ + @L["Login_NoAccount"] @L["Login_RegisterLink"] +
+
+
+ @* ── Header bar ── *@
+
+
+
+
+
+ }
+
+ @if (_setComplete && _myRows.Count > 0)
+ {
+
+
+@code {
+ [Parameter] public string RoomCode { get; set; } = string.Empty;
+
+ private HubConnection? _hub;
+ private bool _connected, _connecting;
+ private bool _isHost;
+ private string _hostName = string.Empty;
+ private List
+ @L["MpGame_Room"]
+
+
+ @(_languageCode == "mk" ? L["MpGame_LangMk"].Value : L["MpGame_LangEn"].Value)
+
+
+ @if (_roundsCompleted > 0 || _roundActive)
+ {
+
+ @string.Format(L["MpGame_RoundOf"]!, _roundActive ? _roundNumber : _roundsCompleted, ScoringRules.SetSize)
+
+ }
+
+ @if (_mySetPoints > 0)
+ {
+ @string.Format(L["MpGame_SetTotal"]!, _mySetPoints)
+ }
+
+
+
+ @if (!string.IsNullOrEmpty(_error))
+ {
+ @L["MpGame_Room"] @RoomCode
+
+
+ @(_languageCode == "mk" ? L["MpGame_LangMk"].Value : L["MpGame_LangEn"].Value)
+
+
+ @if (_roundsCompleted > 0 || _roundActive)
+ {
+
+ @string.Format(L["MpGame_RoundOf"]!, _roundActive ? _roundNumber : _roundsCompleted, ScoringRules.SetSize)
+
+ }
+
+ @if (_mySetPoints > 0)
+ {
+ @string.Format(L["MpGame_SetTotal"]!, _mySetPoints)
+ }
+
+
+
+
+
+
+ @_error
+
+
+ }
+
+ @* ── Players + controls ── *@
+
+
+
+ @* ── Personal answers table (casual-play style) ── *@
+ @if (_myRows.Count > 0 || _roundActive)
+ {
+
+
+
+
+
+
+
+ @L["MpGame_Players"]
+ @foreach (var p in _players)
+ {
+
+
+ }
+
+ @if (_isHost && !_roundActive && _connected && !_setComplete)
+ {
+
+ }
+ @if (_isHost && _setComplete && !_roundActive && _connected)
+ {
+
+ }
+ @if (!_connected && !_connecting)
+ {
+
+ @L["MpGame_Disconnected"]
+
+
+ }
+
+ | @L["Col_Letter"] | +@L["Col_City"] | +@L["Col_Village"] | +@L["Col_Country"] | +@L["Col_River"] | +@L["Col_Mountain"] | +@L["Col_Check"] | +
|---|---|---|---|---|---|---|
| @_letter | ++ | + | + | + | + | + + | +
| @_letter | +@L["MpGame_WaitingPlayers"] | ++ | ||||
+ @L["MpGame_SetComplete"] @string.Format(L["MpGame_SetCompleteDetail"]!, _mySetPoints, ScoringRules.SetSize)
+ @if (_isHost) { @L["MpGame_PlayAnotherHint"] }
+
+ }
+
+ @* ── All-player round results ── *@
+ @if (_results is not null)
+ {
+
+
+
+
+
+ }
+@string.Format(L["MpGame_RoundResults"]!, _roundsCompleted)
+| # | @L["Col_Player"] | @L["Col_Points"] | +@L["Col_City"] | @L["Col_Village"] | @L["Col_Country"] | @L["Col_River"] | @L["Col_Mountain"] | +
|---|---|---|---|---|---|---|---|
| @r.Rank | +
+
+
+ |
+ @r.TotalPoints | + @foreach (var d in r.Details) + { ++ @(string.IsNullOrEmpty(d.Answer) ? "–" : d.Answer) + @d.Points @L["MpGame_Pts"] + | + } +
+
+
+@code {
+ private string _joinCode = string.Empty;
+ private string _createLang = "en";
+ private bool _busy;
+ private string? _error;
+ private string? _returnRoomCode;
+
+ protected override async Task OnInitializedAsync()
+ {
+ await ActiveRoom.EnsureLoadedAsync();
+ _returnRoomCode = ActiveRoom.RoomCode;
+ ActiveRoom.Changed += OnActiveRoomChanged;
+ }
+
+ private void OnActiveRoomChanged()
+ {
+ _returnRoomCode = ActiveRoom.RoomCode;
+ InvokeAsync(StateHasChanged);
+ }
+
+ private async Task DismissReturnRoom()
+ {
+ await ActiveRoom.ClearAsync();
+ _returnRoomCode = null;
+ }
+
+ public void Dispose() => ActiveRoom.Changed -= OnActiveRoomChanged;
+
+ private async Task CreateRoom()
+ {
+ _busy = true;
+ _error = null;
+ var resp = await Http.PostAsync($"api/rooms?lang={_createLang}", null);
+ _busy = false;
+
+ if (resp.IsSuccessStatusCode)
+ {
+ var result = await resp.Content.ReadFromJsonAsync@L["Mp_Heading"]
+@L["Mp_Description"]
+ + @if (_returnRoomCode is not null) + { +
+
+ }
+
+ @if (!string.IsNullOrEmpty(_error))
+ {
+
+ @string.Format(L["Mp_ReturnToRoom"]!, _returnRoomCode)
+
+
+ @string.Format(L["Mp_ReturnToRoomDesc"]!, _returnRoomCode)
+ @_error
+ }
+
+
+
+
+
+
+ @L["Mp_CreateRoomTitle"]
+@L["Mp_CreateRoomDesc"]
+
+
+
+
+
+
+
+
+
+ @L["Mp_JoinRoomTitle"]
+
+
+
+
+
+
+
+
+
+ }
+
+ @if (_roundActive && _roundId.HasValue)
+ {
+
+
+
+ }
+
+
+@code {
+ private Countdown _countdown = null!;
+ private Guid? _roundId;
+ private char _letter;
+ private string _languageCode = "en";
+ private DateTime _endsAt;
+ private bool _roundActive;
+ private bool _checking;
+ private string? _error;
+ private SoloSubmitResponse? _result;
+
+ private string? _city, _village, _country, _river, _mountain;
+ private List
+
+
+ @if (!string.IsNullOrEmpty(_error))
+ {
+
+
+
+ @L["Ranked_Heading"]
+ @L["Ranked_Subtitle"] +
+
+ @if (_checking)
+ {
+
+
+ @L["Ranked_Submitting"]
+
+ }
+
+ @_error
+
+
+ }
+
+ @if (_result is not null)
+ {
+
+ @L["Ranked_RoundComplete"] @L["Ranked_YouScored"] @_result.TotalPoints @L["Ranked_Points"].
+ @L["Ranked_Badge"] @L[$"Badge_{_result.Badge}"]
+ @L["Ranked_ViewScoreboard"]
+
+ | @L["Col_Category"] | @L["Col_Answer"] | @L["Col_Points"] |
|---|---|---|
| @L[$"Location_{d.Type}"] | +
+ @(string.IsNullOrEmpty(d.Answer) ? "–" : d.Answer)
+ @if (!string.IsNullOrEmpty(d.Answer))
+ {
+ |
+ @d.Points | +
| @L["Col_Letter"] | +@L["Col_City"] | +@L["Col_Village"] | +@L["Col_Country"] | +@L["Col_River"] | +@L["Col_Mountain"] | ++ |
|---|---|---|---|---|---|---|
| @_letter | ++ | + | + | + | + | + + | +
+
+
+@code {
+ private readonly RegisterModel _model = new();
+ private string? _error;
+ private bool _busy;
+
+ private async Task DoRegister()
+ {
+ _busy = true;
+ _error = null;
+ var (ok, err) = await Auth.RegisterAsync(_model.Email, _model.Password, _model.DisplayName);
+ _busy = false;
+
+ if (ok) Nav.NavigateTo("/");
+ else _error = err ?? L["Reg_Failed"];
+ }
+
+ private sealed class RegisterModel
+ {
+ [System.ComponentModel.DataAnnotations.Required]
+ [System.ComponentModel.DataAnnotations.StringLength(50, MinimumLength = 2)]
+ public string DisplayName { get; set; } = string.Empty;
+
+ [System.ComponentModel.DataAnnotations.Required]
+ [System.ComponentModel.DataAnnotations.EmailAddress]
+ public string Email { get; set; } = string.Empty;
+
+ [System.ComponentModel.DataAnnotations.Required]
+ [System.ComponentModel.DataAnnotations.MinLength(6)]
+ public string Password { get; set; } = string.Empty;
+ }
+}
diff --git a/src/FastGeography.Client/Pages/Scoreboard.razor b/src/FastGeography.Client/Pages/Scoreboard.razor
new file mode 100644
index 0000000..ef81eda
--- /dev/null
+++ b/src/FastGeography.Client/Pages/Scoreboard.razor
@@ -0,0 +1,111 @@
+@page "/scoreboard"
+@inject HttpClient Http
+@inject IStringLocalizer
+
+
+
+
+@L["Reg_Heading"]
+ + @if (!string.IsNullOrEmpty(_error)) + { +@_error
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ + @L["Reg_HaveAccount"] @L["Reg_SignInLink"] +
+
+ @L["Sb_LoadError"] @_error
+
+}
+
+
+
+
+
+
+
+ @if (_loading)
+ {
+
+
+@code {
+ private List@L["Sb_Heading"]
+ +
+
+
+
+
+
+ @L["Sb_MyStats"]
+
+
+
+ @L["Sb_Loading"]
+
+ }
+ else if (_entries is null || !_entries.Any())
+ {
+ @L["Sb_NoScores"]
+ } + else + { +
+
+
+
+
+ }
+| @L["Sb_ColRank"] | +@L["Sb_ColExplorer"] | +@L["Sb_ColBadge"] | +@L["Sb_ColPoints"] | +@L["Sb_ColGames"] | +
|---|---|---|---|---|
| + @if (e.Rank == 1) { 🥇 } + else if (e.Rank == 2) { 🥈 } + else if (e.Rank == 3) { 🥉 } + else { @e.Rank } + | +
+
+
+ |
+ @L[$"Badge_{e.Badge}"] | +@e.CareerPoints | +@e.GamesPlayed | +
+
+
+@code {
+ private PlayerStats? _stats;
+ private bool _loading = true;
+ private string? _error;
+
+ protected override async Task OnInitializedAsync() => await LoadStatsAsync();
+
+ private async Task LoadStatsAsync()
+ {
+ _loading = true;
+ _error = null;
+ _stats = null;
+ StateHasChanged();
+
+ try
+ {
+ var response = await Http.GetAsync("api/leaderboard/me");
+ if (response.IsSuccessStatusCode)
+ {
+ _stats = await response.Content.ReadFromJsonAsync
+
+
+ @if (_error is not null)
+ {
+ @L["Sb_Me_Heading"]
+ @L["Sb_Me_BackToScoreboard"] +
+ @L["Sb_LoadError"] @_error
+
+ }
+ else if (_loading)
+ {
+
+
+ @L["Sb_Loading"]
+
+ }
+ else if (_stats is not null)
+ {
+
+
+
+
+
+
+
+
+
+ @L["Sb_ColExplorer"]
+
+
+ @_stats.DisplayName
+
+
+
+
+
+
+ @L["Sb_Me_GlobalRank"]
+ #@_stats.Rank
+
+
+
+
+
+
+ @L["Sb_ColPoints"]
+ @_stats.CareerPoints
+
+
+
+
+
+
+ @L["Sb_ColBadge"]
+ @L[$"Badge_{_stats.Badge}"]
+ + @string.Format(L["Sb_Me_GamesSummary"]!, _stats.GamesPlayed) +
+ +@L["Sb_Me_RecentRounds"]
+ + @if (_stats.RecentRounds.Count == 0) + { +@L["Sb_Me_NoRounds"]
+ } + else + { +
+
+
+
+
+ }
+ }
+| @L["Sb_Me_ColPlayedAt"] | +@L["Sb_Me_ColMode"] | +@L["Col_Letter"] | +@L["Sb_ColPoints"] | +
|---|---|---|---|
| @round.PlayedAt.ToLocalTime().ToString("g") | +@FormatMode(round.Mode) | +@round.Letter | +@round.Points | +
+ @if (MapsUri is not null)
+ {
+
+ 
+
+ }
+
+ @if (_showStorySlot)
+ {
+ @if (_storyPending)
+ {
+
+
+
+ }
+ else if (_story is not null)
+ {
+ 
+
+
+
+@code {
+ [Parameter] public Uri? MapsUri { get; set; }
+ [Parameter] public string? Answer { get; set; }
+ [Parameter] public GameLocation? Location { get; set; }
+ [Parameter] public bool PopoverLeft { get; set; }
+
+ [CascadingParameter] private DestinationStoriesContext? Stories { get; set; }
+
+ private bool _pinned;
+ private DestinationStoryEntry? _story;
+ private bool _storyPending;
+ private bool _showStorySlot;
+ private bool _imageBroken;
+ private string _stampSrc = "";
+ private string _stampAlt = "";
+ private string _categoryIcon = "";
+ private bool _showPopoverImage;
+ private bool _showFallbackArt;
+
+ protected override void OnParametersSet()
+ {
+ _story = Stories?.GetStory(Location);
+ _storyPending = Stories?.IsStoryPending(Location) == true;
+ _showStorySlot = Stories?.ShouldShowStorySlot(Location) == true;
+ _imageBroken = false;
+
+ _categoryIcon = Location is not null
+ ? PlaceCategoryIcon.CategoryIconPath(Location.LocationType)
+ : PlaceCategoryIcon.CategoryIconPath(LocationType.City);
+
+ _stampAlt = Location is not null
+ ? string.Format(L["Stories_PlaceStamp"]!, L[$"Location_{Location.LocationType}"].Value, Answer)
+ : Answer ?? "";
+
+ if (_story is not null)
+ {
+ _showPopoverImage = !string.IsNullOrWhiteSpace(_story.ImageUrl);
+ _showFallbackArt = !_showPopoverImage;
+ _stampSrc = _showPopoverImage ? _story.ImageUrl! : _categoryIcon;
+ }
+
+ if (!_showStorySlot || _story is null)
+ _pinned = false;
+ }
+
+ private void TogglePin() => _pinned = !_pinned;
+
+ private void ClosePin() => _pinned = false;
+
+ private void OnImageError()
+ {
+ _imageBroken = true;
+ _showPopoverImage = false;
+ _showFallbackArt = true;
+ _stampSrc = _categoryIcon;
+ }
+
+ private void OnKeyDown(KeyboardEventArgs e)
+ {
+ if (e.Key == "Escape")
+ ClosePin();
+ }
+}
diff --git a/src/FastGeography.Client/Shared/Countdown.razor b/src/FastGeography.Client/Shared/Countdown.razor
index 4f952af..e9372b3 100644
--- a/src/FastGeography.Client/Shared/Countdown.razor
+++ b/src/FastGeography.Client/Shared/Countdown.razor
@@ -1,29 +1,30 @@
@using System.Timers;
-
+
+ }
+
+ @if (_showStorySlot)
+ {
+ @if (_storyPending)
+ {
+
+
+
+ }
+ else if (_story is not null)
+ {
+
+
+
+ }
+ }
+
+ @if (_pinned)
+ {
+
+ }
+
+ @if (_showPopoverImage)
+ {
+ 
+ }
+ else if (_showFallbackArt)
+ {
+ 
+ }
+
+ @_story.Story
+ @if (_showPopoverImage && !string.IsNullOrWhiteSpace(_story.ImageAttribution)) + { ++ @string.Format(L["Stories_ViaSource"]!, _story.ImageAttribution) +
+ } +
-
- @Time
- Logger
+@implements IDisposable
+
+
+ @ChildContent
+
+
+@code {
+ [Parameter] public RenderFragment? ChildContent { get; set; }
+
+ [Parameter]
+ public List? Places { get; set; }
+
+ private DestinationStoriesContext _context = new(null);
+ private int _loadId;
+ private readonly Dictionary<(string Name, LocationType Type), DestinationStoryEntry> _stories = new();
+
+ protected override async Task OnInitializedAsync()
+ {
+ await Language.EnsureLoadedAsync();
+ Language.Changed += OnLanguageChanged;
+ }
+
+ protected override async Task OnParametersSetAsync() => await LoadStoriesAsync();
+
+ private void OnLanguageChanged()
+ {
+ _stories.Clear();
+ _ = InvokeAsync(LoadStoriesAsync);
+ }
+
+ private async Task LoadStoriesAsync()
+ {
+ if (Places is null || Places.Count == 0)
+ {
+ _stories.Clear();
+ _context = new DestinationStoriesContext(null);
+ return;
+ }
+
+ await Language.EnsureLoadedAsync();
+ var lang = Language.Code;
+ var places = Places.Select(p => p with { Lang = lang }).ToList();
+ var pending = places
+ .Where(p => !_stories.ContainsKey(StoryKey(p)))
+ .ToList();
+
+ if (pending.Count == 0)
+ {
+ PublishContext();
+ return;
+ }
+
+ const int maxBatch = 10;
+ var loadId = ++_loadId;
+ var pendingKeys = pending.Select(p => (p.Name, p.Type)).ToList();
+ PublishContext(pendingKeys);
+ await InvokeAsync(StateHasChanged);
+
+ try
+ {
+ foreach (var batch in pending.Chunk(maxBatch))
+ {
+ if (loadId != _loadId)
+ return;
+
+ var body = new DestinationStoriesRequest(batch.ToList());
+ var resp = await Http.PostAsJsonAsync("api/destination-stories", body);
+ if (loadId != _loadId)
+ return;
+
+ if (!resp.IsSuccessStatusCode)
+ {
+ Logger.LogWarning(
+ "Destination stories request failed with {StatusCode}",
+ (int)resp.StatusCode);
+ continue;
+ }
+
+ var data = await resp.Content.ReadFromJsonAsync();
+ var results = data?.Stories ?? [];
+ foreach (var result in results)
+ {
+ _stories[StoryKey(result.Name, result.Type)] = new DestinationStoryEntry(
+ result.Story,
+ result.ImageUrl,
+ result.ImageAttribution);
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ if (loadId != _loadId)
+ return;
+ Logger.LogWarning(ex, "Could not load destination stories");
+ }
+
+ if (loadId != _loadId)
+ return;
+
+ PublishContext();
+ await InvokeAsync(StateHasChanged);
+ }
+
+ private void PublishContext(IReadOnlyList<(string Name, LocationType Type)>? pendingKeys = null)
+ {
+ var stories = _stories
+ .Select(kv => (kv.Key.Name, kv.Key.Type, kv.Value.Story, kv.Value.ImageUrl, kv.Value.ImageAttribution))
+ .ToList();
+ _context = new DestinationStoriesContext(stories, pendingKeys);
+ }
+
+ private static (string Name, LocationType Type) StoryKey(StoryRequest place) =>
+ StoryKey(place.Name, place.Type);
+
+ private static (string Name, LocationType Type) StoryKey(string name, LocationType type) =>
+ (name.Trim().ToLowerInvariant(), type);
+
+ public void Dispose() => Language.Changed -= OnLanguageChanged;
+}
diff --git a/src/FastGeography.Client/Shared/DestinationStoriesContext.cs b/src/FastGeography.Client/Shared/DestinationStoriesContext.cs
new file mode 100644
index 0000000..8e05540
--- /dev/null
+++ b/src/FastGeography.Client/Shared/DestinationStoriesContext.cs
@@ -0,0 +1,72 @@
+namespace FastGeography.Client.Shared;
+
+using FastGeography.Shared;
+
+///
+/// A loaded destination story with optional place image.
+///
+public sealed record DestinationStoryEntry(
+ string Story,
+ string? ImageUrl,
+ string? ImageAttribution);
+
+///
+/// Cascading context for destination story lookup inside a table.
+///
+public sealed class DestinationStoriesContext
+{
+ private readonly Dictionary<(string NormalizedName, LocationType Type), DestinationStoryEntry> _stories;
+ private readonly HashSet<(string NormalizedName, LocationType Type)> _pendingKeys;
+
+ public DestinationStoriesContext(
+ IReadOnlyList<(string Name, LocationType Type, string Story, string? ImageUrl, string? ImageAttribution)>? stories,
+ IReadOnlyList<(string Name, LocationType Type)>? pendingKeys = null)
+ {
+ _stories = new Dictionary<(string, LocationType), DestinationStoryEntry>();
+ _pendingKeys = new HashSet<(string, LocationType)>();
+
+ if (stories is not null)
+ {
+ foreach (var (name, type, story, imageUrl, imageAttribution) in stories)
+ {
+ _stories[NormalizeKey(name, type)] = new DestinationStoryEntry(
+ story, imageUrl, imageAttribution);
+ }
+ }
+
+ if (pendingKeys is not null)
+ {
+ foreach (var (name, type) in pendingKeys)
+ _pendingKeys.Add(NormalizeKey(name, type));
+ }
+ }
+
+ public bool IsEligible(GameLocation? location) =>
+ location is not null
+ && location.Points == ScoringRules.ValidPoints
+ && !string.IsNullOrWhiteSpace(location.Answer);
+
+ public bool IsStoryPending(GameLocation? location)
+ {
+ if (!IsEligible(location))
+ return false;
+
+ var key = NormalizeKey(location!.Answer!, location.LocationType);
+ return _pendingKeys.Contains(key) && !_stories.ContainsKey(key);
+ }
+
+ public DestinationStoryEntry? GetStory(GameLocation? location)
+ {
+ if (!IsEligible(location))
+ return null;
+
+ var key = NormalizeKey(location!.Answer!, location.LocationType);
+ return _stories.TryGetValue(key, out var story) ? story : null;
+ }
+
+ public bool ShouldShowStorySlot(GameLocation? location) =>
+ IsStoryPending(location) || GetStory(location) is not null;
+
+ private static (string NormalizedName, LocationType Type) NormalizeKey(string name, LocationType type) =>
+ (name.Trim().ToLowerInvariant(), type);
+}
diff --git a/src/FastGeography.Client/Shared/GameRow.razor b/src/FastGeography.Client/Shared/GameRow.razor
index 71d4ffd..54df5e2 100644
--- a/src/FastGeography.Client/Shared/GameRow.razor
+++ b/src/FastGeography.Client/Shared/GameRow.razor
@@ -1,54 +1,53 @@
-@using FastGeography.Shared;
+@using FastGeography.Shared
+@inject IStringLocalizer L
-
-
- @if (game.City.MapsUri != null)
- {
-
- 
-
- }
+
+
-
-
- @if (game.Village.MapsUri != null)
- {
-
-
-
- }
+
+
+
-
-
- @if (game.Country.MapsUri != null)
- {
-
-
-
- }
+
+
+
-
-
- @if (game.River.MapsUri != null)
- {
-
-
-
- }
+
+
+
-
-
- @if (game.Mountain.MapsUri != null)
- {
-
-
-
- }
+
+
+
+
+
+
+
+
- @game.SecondsPlayed
-
@code {
@@ -62,29 +61,27 @@
[Parameter] public GameLocation? Mountain { get; set; }
[Parameter] public GameLocation? River { get; set; }
[Parameter] public bool IsFinished { get; set; }
+ [Parameter] public bool IsChecking { get; set; }
[Parameter] public int SecondsPlayed { get; set; }
- Game game = new Game();
+ private Game game = new();
- async Task HandleClick()
- {
- await OnClick.InvokeAsync(game);
- }
+ private async Task HandleClick() => await OnClick.InvokeAsync(game);
protected override void OnParametersSet()
{
game = new Game
- {
- Id = Id,
- DatePlayed = DatePlayed,
- Letter = Letter,
- City = City,
- Village = Village,
- Country = Country,
- Mountain = Mountain,
- River = River,
- IsFinished = IsFinished,
- SecondsPlayed = SecondsPlayed
- };
+ {
+ Id = Id,
+ DatePlayed = DatePlayed,
+ Letter = Letter,
+ City = City,
+ Village = Village,
+ Country = Country,
+ Mountain = Mountain,
+ River = River,
+ IsFinished = IsFinished,
+ SecondsPlayed = SecondsPlayed
+ };
}
-}
\ No newline at end of file
+}
diff --git a/src/FastGeography.Client/Shared/MainLayout.razor b/src/FastGeography.Client/Shared/MainLayout.razor
index 3e7ef88..4b945fd 100644
--- a/src/FastGeography.Client/Shared/MainLayout.razor
+++ b/src/FastGeography.Client/Shared/MainLayout.razor
@@ -1,20 +1,25 @@
-@using FastGeography.Client.Pages
-@inherits LayoutComponentBase
+@inherits LayoutComponentBase
+@implements IDisposable
+@inject GameLanguageState Language
⏰
+
+
@code {
private System.Timers.Timer _timer = null!;
private int _secondsToRun = 0;
- private int initialSeconds = 0;
+ private int _initialSeconds = 0;
- protected string Time { get; set; } = "00:00";
+ protected string Time { get; set; } = "01:00";
[Parameter]
public EventCallback TimerOut { get; set; }
- [Parameter]
- public int SecondsToRun { get { return _secondsToRun; } set { } }
- public int ElapsedSeconds { get { return initialSeconds - _secondsToRun; } }
+ public int ElapsedSeconds => _initialSeconds - _secondsToRun;
public void Start(int secondsToRun)
{
- initialSeconds = secondsToRun;
+ _initialSeconds = secondsToRun;
_secondsToRun = secondsToRun;
if (_secondsToRun > 0)
@@ -52,14 +53,14 @@
await InvokeAsync(() =>
{
- Time = TimeSpan.FromSeconds(_secondsToRun).ToString(@"mm\:ss");
+ Time = TimeSpan.FromSeconds(Math.Max(0, _secondsToRun)).ToString(@"mm\:ss");
StateHasChanged();
});
if (_secondsToRun <= 0)
{
_timer.Stop();
- await TimerOut.InvokeAsync();
+ await InvokeAsync(() => TimerOut.InvokeAsync());
}
}
}
diff --git a/src/FastGeography.Client/Shared/DestinationStories.razor b/src/FastGeography.Client/Shared/DestinationStories.razor
new file mode 100644
index 0000000..6a76346
--- /dev/null
+++ b/src/FastGeography.Client/Shared/DestinationStories.razor
@@ -0,0 +1,122 @@
+@inject HttpClient Http
+@inject GameLanguageState Language
+@inject ILogger
+
+
-
- }
+
-
- }
+
-
- }
+
-
- }
+
-
- }
+
- @*
- @*
- @* @Body*@
-
+ @Body
-
+
+@code {
+ protected override void OnInitialized()
+ {
+ Language.Changed += OnLanguageChanged;
+ }
+
+ private void OnLanguageChanged() => InvokeAsync(StateHasChanged);
+
+ public void Dispose() => Language.Changed -= OnLanguageChanged;
+}
diff --git a/src/FastGeography.Client/Shared/NavMenu.razor b/src/FastGeography.Client/Shared/NavMenu.razor
index 093bf87..b57654b 100644
--- a/src/FastGeography.Client/Shared/NavMenu.razor
+++ b/src/FastGeography.Client/Shared/NavMenu.razor
@@ -1,7 +1,15 @@
-
+@implements IDisposable
+@inject CookieAuthenticationStateProvider Auth
+@inject NavigationManager Nav
+@inject HttpClient Http
+@inject GameLanguageState Language
+@inject ActiveMultiplayerRoomState ActiveRoom
+@inject IStringLocalizer L
+
+
@code {
private bool collapseNavMenu = true;
-
private string? NavMenuCssClass => collapseNavMenu ? "collapse" : null;
+ private string _currentLang = "en";
+ private string? _returnRoomCode;
+
+ protected override async Task OnInitializedAsync()
+ {
+ // Prefer the signed-in user's server-persisted preference; fall back to localStorage.
+ var user = Auth.CurrentUser;
+ if (user is not null)
+ {
+ await Language.SetAsync(user.PreferredLanguage);
+ }
+ else
+ {
+ await Language.EnsureLoadedAsync();
+ }
+ _currentLang = Language.Code;
+
+ await ActiveRoom.EnsureLoadedAsync();
+ UpdateReturnRoomCode();
+ ActiveRoom.Changed += OnActiveRoomChanged;
+ Nav.LocationChanged += OnLocationChanged;
+ }
+
+ private void OnLocationChanged(object? sender, Microsoft.AspNetCore.Components.Routing.LocationChangedEventArgs e)
+ {
+ UpdateReturnRoomCode();
+ InvokeAsync(StateHasChanged);
+ }
+
+ private void OnActiveRoomChanged()
+ {
+ UpdateReturnRoomCode();
+ InvokeAsync(StateHasChanged);
+ }
+
+ private void UpdateReturnRoomCode()
+ {
+ var code = ActiveRoom.RoomCode;
+ _returnRoomCode = code is not null && !IsOnRoomPage(code) ? code : null;
+ }
+
+ private bool IsOnRoomPage(string code)
+ {
+ var relative = Nav.ToBaseRelativePath(Nav.Uri).TrimEnd('/');
+ return relative.Equals($"multiplayer/{code}", StringComparison.OrdinalIgnoreCase);
+ }
+
+ public void Dispose()
+ {
+ ActiveRoom.Changed -= OnActiveRoomChanged;
+ Nav.LocationChanged -= OnLocationChanged;
+ }
+
+ private void ToggleNavMenu() => collapseNavMenu = !collapseNavMenu;
+
+ private async Task OnLanguageChanged(ChangeEventArgs e)
+ {
+ var lang = e.Value?.ToString() ?? "en";
+ await Language.SetAsync(lang);
+ _currentLang = Language.Code;
+
+ // Persist to the server when signed in.
+ if (Auth.CurrentUser is not null)
+ {
+ await Http.PatchAsJsonAsync("api/auth/language", new SetLanguageRequest(Language.Code));
+ }
+ }
- private void ToggleNavMenu()
+ private async Task Logout()
{
- collapseNavMenu = !collapseNavMenu;
+ await Auth.LogoutAsync();
+ Nav.NavigateTo("/");
}
}
diff --git a/src/FastGeography.Client/Shared/PlaceCategoryIcon.cs b/src/FastGeography.Client/Shared/PlaceCategoryIcon.cs
new file mode 100644
index 0000000..d07a394
--- /dev/null
+++ b/src/FastGeography.Client/Shared/PlaceCategoryIcon.cs
@@ -0,0 +1,16 @@
+namespace FastGeography.Client.Shared;
+
+using FastGeography.Shared;
+
+public static class PlaceCategoryIcon
+{
+ public static string CategoryIconPath(LocationType type) => type switch
+ {
+ LocationType.City => "images/place-city.svg",
+ LocationType.Village => "images/place-village.svg",
+ LocationType.Country => "images/place-country.svg",
+ LocationType.River => "images/place-river.svg",
+ LocationType.Mountain => "images/place-mountain.svg",
+ _ => "images/place-city.svg"
+ };
+}
diff --git a/src/FastGeography.Client/Shared/RedirectToLogin.razor b/src/FastGeography.Client/Shared/RedirectToLogin.razor
new file mode 100644
index 0000000..446cc8c
--- /dev/null
+++ b/src/FastGeography.Client/Shared/RedirectToLogin.razor
@@ -0,0 +1,9 @@
+@inject NavigationManager Nav
+
+@code {
+ protected override void OnInitialized()
+ {
+ var returnUrl = Uri.EscapeDataString(Nav.Uri);
+ Nav.NavigateTo($"login?returnUrl={returnUrl}");
+ }
+}
diff --git a/src/FastGeography.Client/Shared/SurveyPrompt.razor b/src/FastGeography.Client/Shared/SurveyPrompt.razor
deleted file mode 100644
index 962027f..0000000
--- a/src/FastGeography.Client/Shared/SurveyPrompt.razor
+++ /dev/null
@@ -1,16 +0,0 @@
-
+
+
+@code {
+ [Parameter] public string? UserId { get; set; }
+ [Parameter] public string? DisplayName { get; set; }
+ [Parameter] public string Size { get; set; } = "md";
+ [Parameter] public string? Title { get; set; }
+
+ private int _index;
+ private string _color = "#2d6a4f";
+
+ protected override void OnParametersSet()
+ {
+ var info = PlayerAvatar.Resolve(UserId, DisplayName);
+ _index = info.Index;
+ _color = info.BackgroundColor;
+ Title ??= DisplayName;
+ }
+}
diff --git a/src/FastGeography.Client/_Imports.razor b/src/FastGeography.Client/_Imports.razor
index f2d8172..1bf2faf 100644
--- a/src/FastGeography.Client/_Imports.razor
+++ b/src/FastGeography.Client/_Imports.razor
@@ -5,7 +5,16 @@
@using Microsoft.AspNetCore.Components.Web
@using Microsoft.AspNetCore.Components.Web.Virtualization
@using Microsoft.AspNetCore.Components.WebAssembly.Http
+@using Microsoft.AspNetCore.Components.Authorization
+@using Microsoft.AspNetCore.Authorization
+@using Microsoft.AspNetCore.SignalR.Client
@using Microsoft.JSInterop
@using FastGeography.Client
@using FastGeography.Client.Shared
+@using FastGeography.Client.Auth
+@using FastGeography.Client.Services
+@using FastGeography.Client.Resources
+@using Microsoft.Extensions.Localization
+@using FastGeography.Shared
+@using FastGeography.Shared.Dtos
@using BlazorApplicationInsights
diff --git a/src/FastGeography.Client/wwwroot/css/app.css b/src/FastGeography.Client/wwwroot/css/app.css
index bea0166..729e1e5 100644
--- a/src/FastGeography.Client/wwwroot/css/app.css
+++ b/src/FastGeography.Client/wwwroot/css/app.css
@@ -46,6 +46,10 @@ a, .btn-link {
z-index: 1000;
}
+#blazor-error-ui.show {
+ display: block;
+}
+
#blazor-error-ui .dismiss {
cursor: pointer;
position: absolute;
@@ -81,15 +85,70 @@ a, .btn-link {
.game-button:hover {
transform: scale(1.05);
}
+
+.game-header {
+ display: flex;
+ align-items: center;
+ flex-wrap: wrap;
+ gap: 0.75rem 1rem;
+ margin-bottom: 1rem;
+}
+
+.game-header-title {
+ flex: 1 1 auto;
+ min-width: 12rem;
+}
+
+.game-header-title h4 {
+ margin-bottom: 0.15rem;
+}
+
+.game-header-score {
+ margin-left: auto;
+ font-weight: 600;
+ color: #2c3e50;
+}
+
+.timer-container {
+ display: flex;
+ align-items: center;
+ flex: 0 0 auto;
+ width: auto;
+}
+
+.game-header-status {
+ display: inline-flex;
+ align-items: center;
+ gap: 0.5rem;
+ flex: 0 0 auto;
+ font-size: 0.95rem;
+ color: #2c3e50;
+ white-space: nowrap;
+}
.achievement-banner {
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ flex-wrap: wrap;
+ gap: 1rem;
background: linear-gradient(45deg, #FFD700, #FFA500);
border-radius: 10px;
- padding: 15px;
- margin: 20px 0;
- text-align: center;
+ padding: 10px 16px;
+ margin: 16px 0 0;
animation: glow 2s infinite alternate;
}
+
+.achievement-banner-text {
+ display: flex;
+ flex-direction: column;
+ gap: 0.15rem;
+}
+
+.achievement-banner-text h3 {
+ margin: 0;
+ font-size: 1.1rem;
+}
@keyframes glow {
from {
@@ -101,8 +160,8 @@ a, .btn-link {
}
.badge-image {
- width: 100px;
- height: 100px;
+ width: 56px;
+ height: 56px;
transition: transform 0.3s;
}
@@ -111,9 +170,11 @@ a, .btn-link {
}
.timer {
- font-size: 2rem;
- font-weight: bold;
+ display: inline-flex;
+ font-size: 1.15rem;
+ font-weight: 700;
color: #2193b0;
+ line-height: 1;
}
.timer-warning {
@@ -121,16 +182,25 @@ a, .btn-link {
animation: pulse 1s infinite;
}
-.timer-circle {
+.timer-pill {
+ display: inline-flex;
+ align-items: center;
+ gap: 0.4rem;
background: #fff;
- border-radius: 50%;
- padding: 20px;
- box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+ border-radius: 999px;
+ padding: 0.45rem 0.9rem;
+ box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+ white-space: nowrap;
+}
+
+.timer-icon {
+ font-size: 1.1rem;
+ line-height: 1;
}
-.timer-emoji {
- font-size: 1.5rem;
- margin-top: 5px;
+.timer-text {
+ font-variant-numeric: tabular-nums;
+ letter-spacing: 0.02em;
}
@keyframes pulse {
@@ -145,4 +215,235 @@ a, .btn-link {
100% {
transform: scale(1);
}
-}
\ No newline at end of file
+}
+/* ── Auth pages ─────────────────────────────────────── */
+.auth-container {
+ display: flex;
+ justify-content: center;
+ padding: 2rem 1rem;
+}
+
+.auth-card {
+ width: 100%;
+ max-width: 420px;
+ background: #fff;
+ border-radius: 12px;
+ padding: 2rem;
+ box-shadow: 0 4px 20px rgba(0,0,0,0.12);
+}
+
+.auth-card h2 {
+ margin-bottom: 1.5rem;
+ font-weight: 700;
+ color: #2c3e50;
+}
+
+.game-check-cell {
+ vertical-align: middle;
+ white-space: nowrap;
+}
+
+.game-check-btn {
+ min-width: 7.5rem;
+}
+.table .answer-cell {
+ overflow: visible;
+ position: relative;
+ vertical-align: middle;
+}
+
+table.table {
+ overflow: visible;
+}
+
+.answer-actions {
+ display: inline-flex;
+ align-items: center;
+ gap: 2px;
+ margin-left: 4px;
+ vertical-align: middle;
+ position: relative;
+}
+
+.answer-action-link {
+ display: inline-flex;
+ line-height: 0;
+ border: none;
+ background: none;
+ padding: 0;
+ cursor: pointer;
+ text-decoration: none;
+}
+
+.answer-action-icon {
+ width: 32px;
+ height: 32px;
+}
+
+.answer-story-loading {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ width: 32px;
+ height: 32px;
+}
+
+.story-trigger {
+ position: relative;
+ display: inline-flex;
+}
+
+.story-btn {
+ border-radius: 50%;
+ transition: transform 0.15s ease;
+}
+
+.story-icon-unlock {
+ animation: storyUnlock 0.35s ease-out;
+}
+
+@keyframes storyUnlock {
+ 0% { transform: scale(0.4); opacity: 0; }
+ 70% { transform: scale(1.1); }
+ 100% { transform: scale(1); opacity: 1; }
+}
+
+.story-popover {
+ display: none;
+ position: absolute;
+ top: calc(100% + 6px);
+ left: 50%;
+ transform: translateX(-50%);
+ width: min(320px, 80vw);
+ padding: 0;
+ background: #fff;
+ border: 1px solid #d8f3dc;
+ border-radius: 10px;
+ box-shadow: 0 8px 24px rgba(45, 106, 79, 0.18);
+ z-index: 1050;
+ text-align: left;
+ overflow: hidden;
+}
+
+.story-popover::before {
+ content: "";
+ position: absolute;
+ top: -6px;
+ left: 50%;
+ transform: translateX(-50%) rotate(45deg);
+ width: 10px;
+ height: 10px;
+ background: #fff;
+ border-left: 1px solid #d8f3dc;
+ border-top: 1px solid #d8f3dc;
+}
+
+.answer-actions.popover-left .story-popover {
+ left: auto;
+ right: 0;
+ transform: none;
+}
+
+.answer-actions.popover-left .story-popover::before {
+ left: auto;
+ right: 14px;
+ transform: rotate(45deg);
+}
+
+.story-popover-text {
+ margin: 0;
+ padding: 0.75rem 0.9rem;
+ font-size: 0.9rem;
+ color: #374151;
+ line-height: 1.55;
+}
+
+.story-popover-image {
+ display: block;
+ width: 100%;
+ height: 140px;
+ object-fit: cover;
+ background: #e8f5e9;
+}
+
+.story-popover-fallback {
+ object-fit: contain;
+ padding: 1rem;
+ height: 100px;
+ background: linear-gradient(135deg, #d8f3dc 0%, #b7e4c7 100%);
+}
+
+.story-popover-credit {
+ margin: 0;
+ padding: 0 0.9rem 0.65rem;
+ font-size: 0.72rem;
+ color: #6b7280;
+ text-align: right;
+}
+
+.story-stamp {
+ width: 36px;
+ height: 36px;
+ border-radius: 50%;
+ object-fit: cover;
+ border: 2px solid #95d5b2;
+ box-shadow: 0 2px 6px rgba(45, 106, 79, 0.2);
+ vertical-align: middle;
+ animation: storyUnlock 0.35s ease-out;
+}
+
+.story-stamp-fallback {
+ object-fit: contain;
+ padding: 4px;
+ background: #d8f3dc;
+}
+
+.story-trigger:hover .story-popover,
+.story-trigger:focus-within .story-popover,
+.story-trigger.story-pinned .story-popover {
+ display: block;
+}
+
+.story-backdrop {
+ position: fixed;
+ inset: 0;
+ z-index: 1040;
+ border: none;
+ background: transparent;
+ cursor: default;
+ padding: 0;
+}
+
+/* ── Player avatars ─────────────────────────────────────────────────────── */
+
+.player-avatar {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ border-radius: 50%;
+ background: var(--avatar-bg, #2d6a4f);
+ box-shadow: 0 2px 6px rgba(0, 0, 0, 0.18);
+ flex-shrink: 0;
+ overflow: hidden;
+}
+
+.player-avatar img {
+ width: 62%;
+ height: 62%;
+ object-fit: contain;
+}
+
+.player-avatar-sm {
+ width: 28px;
+ height: 28px;
+}
+
+.player-avatar-md {
+ width: 36px;
+ height: 36px;
+}
+
+.player-avatar-lg {
+ width: 52px;
+ height: 52px;
+}
diff --git a/src/FastGeography.Client/wwwroot/images/avatars/avatar-0.svg b/src/FastGeography.Client/wwwroot/images/avatars/avatar-0.svg
new file mode 100644
index 0000000..f72b558
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/avatars/avatar-0.svg
@@ -0,0 +1,6 @@
+
diff --git a/src/FastGeography.Client/wwwroot/images/avatars/avatar-1.svg b/src/FastGeography.Client/wwwroot/images/avatars/avatar-1.svg
new file mode 100644
index 0000000..34a2393
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/avatars/avatar-1.svg
@@ -0,0 +1,6 @@
+
diff --git a/src/FastGeography.Client/wwwroot/images/avatars/avatar-2.svg b/src/FastGeography.Client/wwwroot/images/avatars/avatar-2.svg
new file mode 100644
index 0000000..7ce231b
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/avatars/avatar-2.svg
@@ -0,0 +1,5 @@
+
diff --git a/src/FastGeography.Client/wwwroot/images/avatars/avatar-3.svg b/src/FastGeography.Client/wwwroot/images/avatars/avatar-3.svg
new file mode 100644
index 0000000..0f6d4c2
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/avatars/avatar-3.svg
@@ -0,0 +1,5 @@
+
diff --git a/src/FastGeography.Client/wwwroot/images/avatars/avatar-4.svg b/src/FastGeography.Client/wwwroot/images/avatars/avatar-4.svg
new file mode 100644
index 0000000..4f73f2d
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/avatars/avatar-4.svg
@@ -0,0 +1,6 @@
+
diff --git a/src/FastGeography.Client/wwwroot/images/avatars/avatar-5.svg b/src/FastGeography.Client/wwwroot/images/avatars/avatar-5.svg
new file mode 100644
index 0000000..6697707
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/avatars/avatar-5.svg
@@ -0,0 +1,6 @@
+
diff --git a/src/FastGeography.Client/wwwroot/images/avatars/avatar-6.svg b/src/FastGeography.Client/wwwroot/images/avatars/avatar-6.svg
new file mode 100644
index 0000000..24bdc0b
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/avatars/avatar-6.svg
@@ -0,0 +1,6 @@
+
diff --git a/src/FastGeography.Client/wwwroot/images/avatars/avatar-7.svg b/src/FastGeography.Client/wwwroot/images/avatars/avatar-7.svg
new file mode 100644
index 0000000..373a8d8
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/avatars/avatar-7.svg
@@ -0,0 +1,7 @@
+
diff --git a/src/FastGeography.Client/wwwroot/images/badge-0.svg b/src/FastGeography.Client/wwwroot/images/badge-0.svg
new file mode 100644
index 0000000..99494ba
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/badge-0.svg
@@ -0,0 +1,6 @@
+
\ No newline at end of file
diff --git a/src/FastGeography.Client/wwwroot/images/badge-1.svg b/src/FastGeography.Client/wwwroot/images/badge-1.svg
new file mode 100644
index 0000000..a18a628
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/badge-1.svg
@@ -0,0 +1,6 @@
+
\ No newline at end of file
diff --git a/src/FastGeography.Client/wwwroot/images/badge-2.svg b/src/FastGeography.Client/wwwroot/images/badge-2.svg
new file mode 100644
index 0000000..3caa7e3
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/badge-2.svg
@@ -0,0 +1,6 @@
+
\ No newline at end of file
diff --git a/src/FastGeography.Client/wwwroot/images/badge-3.svg b/src/FastGeography.Client/wwwroot/images/badge-3.svg
new file mode 100644
index 0000000..16bdec6
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/badge-3.svg
@@ -0,0 +1,6 @@
+
\ No newline at end of file
diff --git a/src/FastGeography.Client/wwwroot/images/badge-4.svg b/src/FastGeography.Client/wwwroot/images/badge-4.svg
new file mode 100644
index 0000000..e2987b7
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/badge-4.svg
@@ -0,0 +1,6 @@
+
\ No newline at end of file
diff --git a/src/FastGeography.Client/wwwroot/images/badge-5.svg b/src/FastGeography.Client/wwwroot/images/badge-5.svg
new file mode 100644
index 0000000..3f9f478
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/badge-5.svg
@@ -0,0 +1,6 @@
+
\ No newline at end of file
diff --git a/src/FastGeography.Client/wwwroot/images/badge-6.svg b/src/FastGeography.Client/wwwroot/images/badge-6.svg
new file mode 100644
index 0000000..29fa04b
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/badge-6.svg
@@ -0,0 +1,6 @@
+
\ No newline at end of file
diff --git a/src/FastGeography.Client/wwwroot/images/badge-7.svg b/src/FastGeography.Client/wwwroot/images/badge-7.svg
new file mode 100644
index 0000000..2553336
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/badge-7.svg
@@ -0,0 +1,6 @@
+
\ No newline at end of file
diff --git a/src/FastGeography.Client/wwwroot/images/badge-8.svg b/src/FastGeography.Client/wwwroot/images/badge-8.svg
new file mode 100644
index 0000000..53cfa0b
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/badge-8.svg
@@ -0,0 +1,6 @@
+
\ No newline at end of file
diff --git a/src/FastGeography.Client/wwwroot/images/badge-9.svg b/src/FastGeography.Client/wwwroot/images/badge-9.svg
new file mode 100644
index 0000000..15f508f
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/badge-9.svg
@@ -0,0 +1,6 @@
+
\ No newline at end of file
diff --git a/src/FastGeography.Client/wwwroot/images/place-city.svg b/src/FastGeography.Client/wwwroot/images/place-city.svg
new file mode 100644
index 0000000..8ef990c
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/place-city.svg
@@ -0,0 +1,8 @@
+
diff --git a/src/FastGeography.Client/wwwroot/images/place-country.svg b/src/FastGeography.Client/wwwroot/images/place-country.svg
new file mode 100644
index 0000000..973041e
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/place-country.svg
@@ -0,0 +1,8 @@
+
diff --git a/src/FastGeography.Client/wwwroot/images/place-mountain.svg b/src/FastGeography.Client/wwwroot/images/place-mountain.svg
new file mode 100644
index 0000000..b95200d
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/place-mountain.svg
@@ -0,0 +1,6 @@
+
diff --git a/src/FastGeography.Client/wwwroot/images/place-river.svg b/src/FastGeography.Client/wwwroot/images/place-river.svg
new file mode 100644
index 0000000..51e4147
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/place-river.svg
@@ -0,0 +1,4 @@
+
diff --git a/src/FastGeography.Client/wwwroot/images/place-village.svg b/src/FastGeography.Client/wwwroot/images/place-village.svg
new file mode 100644
index 0000000..c52d933
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/place-village.svg
@@ -0,0 +1,7 @@
+
diff --git a/src/FastGeography.Client/wwwroot/images/story.svg b/src/FastGeography.Client/wwwroot/images/story.svg
new file mode 100644
index 0000000..bc681bb
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/story.svg
@@ -0,0 +1,6 @@
+
diff --git a/src/FastGeography.Client/wwwroot/images/visit.svg b/src/FastGeography.Client/wwwroot/images/visit.svg
new file mode 100644
index 0000000..2985e3c
--- /dev/null
+++ b/src/FastGeography.Client/wwwroot/images/visit.svg
@@ -0,0 +1,5 @@
+
diff --git a/src/FastGeography.Client/wwwroot/index.html b/src/FastGeography.Client/wwwroot/index.html
index 1839651..a23d8ae 100644
--- a/src/FastGeography.Client/wwwroot/index.html
+++ b/src/FastGeography.Client/wwwroot/index.html
@@ -3,7 +3,7 @@
-
+
FastGeography
Register([FromBody] RegisterRequest request)
+ {
+ var result = await _authService.RegisterAsync(request.Email, request.Password, request.DisplayName);
+ if (!result.Succeeded)
+ return BadRequest(new { errors = result.Errors.Select(e => e.Description) });
+
+ return Ok();
+ }
+
+ [HttpPost("login")]
+ public async Task Login([FromBody] LoginRequest request)
+ {
+ var result = await _authService.LoginAsync(request.Email, request.Password);
+ if (!result)
+ return Unauthorized(new { error = "Invalid email or password." });
+
+ return Ok();
+ }
+
+ [Authorize]
+ [HttpPost("logout")]
+ public async Task Logout()
+ {
+ await _authService.LogoutAsync();
+ return Ok();
+ }
+
+ [Authorize]
+ [HttpGet("userinfo")]
+ public async Task GetUserInfo()
+ {
+ var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+ if (userId is null) return Unauthorized();
+
+ var user = await _db.Users.FindAsync(userId);
+ if (user is null) return Unauthorized();
+
+ return Ok(new UserInfoResponse(user.Id, user.Email ?? string.Empty, user.DisplayName, user.PreferredLanguage));
+ }
+
+ [Authorize]
+ [HttpPatch("language")]
+ public async Task SetLanguage([FromBody] SetLanguageRequest request)
+ {
+ var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+ if (userId is null) return Unauthorized();
+
+ var user = await _db.Users.FindAsync(userId);
+ if (user is null) return Unauthorized();
+
+ var code = GameLanguageExtensions.Parse(request.LanguageCode).ToCode();
+ user.PreferredLanguage = code;
+ await _db.SaveChangesAsync();
+
+ return Ok();
+ }
+}
diff --git a/src/FastGeography.Server/Controllers/BingMapsController.cs b/src/FastGeography.Server/Controllers/BingMapsController.cs
deleted file mode 100644
index 7faa8df..0000000
--- a/src/FastGeography.Server/Controllers/BingMapsController.cs
+++ /dev/null
@@ -1,80 +0,0 @@
-namespace FastGeography.Server.Controllers
-{
- using BingMapsRESTToolkit;
-
- using FastGeography.Shared;
-
- using Microsoft.AspNetCore.Mvc;
-
- [ApiController]
- [Route("bingmaps")]
- public class BingMapsController : ControllerBase
- {
- private string bingMapsKey = "AvgAK8EVgx50WkOB6cyA8ckUM5ku4U3kGJvxthKwE75_S4-c-XlTP82kUom8baQk";
-
- [HttpGet("{location}/{locationType}")]
- public async Task GetLocationType(string location, LocationType locationType)
- {
- // Create a geocode request
- var request = new GeocodeRequest()
- {
- Query = location,
- IncludeIso2 = true,
- MaxResults = 1,
- BingMapsKey = bingMapsKey
- };
- var response = request.Execute().Result;
-
- if (!IsValid(response))
- {
- return Ok($"{locationType}:-5");
- }
-
- // Get the location type (e.g. city, river, mountain)
- var result = response.ResourceSets[0].Resources[0] as Location;
-
- if (LocationExists(result, locationType))
- {
- var coordinates = $"{result.Point.Coordinates[0]},{result.Point.Coordinates[1]}";
- return Ok($"{locationType}:20:{coordinates}");
- }
- else
- {
- return Ok($"{locationType}:-5");
- }
- }
-
- private static bool IsValid(Response? response)
- {
- //TODO: use FluentValidation!!!
- return (response != null && response.ResourceSets != null &&
- response.ResourceSets.Length > 0 &&
- response.ResourceSets[0].Resources != null &&
- response.ResourceSets[0].Resources.Length > 0);
- }
-
- private bool LocationExists(Location? location, LocationType locationType)
- {
- if (location == null)
- return false;
-
- switch (locationType)
- {
- case LocationType.City:
- return location.EntityType.Contains("PopulatedPlace");
- case LocationType.Village:
- return location.EntityType.Contains("PopulatedPlace");
- case LocationType.Country:
- return location.EntityType.Contains("CountryRegion") || location.EntityType.Contains("AdminDivision1");
- case LocationType.Mountain:
- return location.EntityType.Contains("Mountain") || location.EntityType.Contains("MountainRange");
- case LocationType.River:
- return location.EntityType.Contains("River");
-
- default:
- return false;
- }
-
- }
- }
-}
diff --git a/src/FastGeography.Server/Controllers/DestinationStoriesController.cs b/src/FastGeography.Server/Controllers/DestinationStoriesController.cs
new file mode 100644
index 0000000..684d235
--- /dev/null
+++ b/src/FastGeography.Server/Controllers/DestinationStoriesController.cs
@@ -0,0 +1,129 @@
+namespace FastGeography.Server.Controllers;
+
+using FastGeography.Server.Data;
+using FastGeography.Server.Services;
+using FastGeography.Shared;
+using FastGeography.Shared.Dtos;
+
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.RateLimiting;
+using Microsoft.EntityFrameworkCore;
+
+[ApiController]
+[EnableRateLimiting("stories")]
+public sealed class DestinationStoriesController : ControllerBase
+{
+ private const int MaxPlacesPerRequest = 10;
+
+ private readonly IDestinationStoryService _stories;
+ private readonly IPlaceImageService _images;
+ private readonly ApplicationDbContext _db;
+ private readonly ILogger _logger;
+
+ public DestinationStoriesController(
+ IDestinationStoryService stories,
+ IPlaceImageService images,
+ ApplicationDbContext db,
+ ILogger logger)
+ {
+ _stories = stories;
+ _images = images;
+ _db = db;
+ _logger = logger;
+ }
+
+ ///
+ /// Generates (or retrieves cached) short travel stories for the supplied places.
+ /// Only places that already exist in the Toponyms table are processed — this
+ /// prevents clients from injecting arbitrary prompts for unverified locations.
+ ///
+ [HttpPost("api/destination-stories")]
+ public async Task GetStories(
+ [FromBody] DestinationStoriesRequest request,
+ CancellationToken ct)
+ {
+ if (request.Places is null || request.Places.Count == 0)
+ return BadRequest("No places supplied.");
+
+ if (request.Places.Count > MaxPlacesPerRequest)
+ return BadRequest($"Maximum {MaxPlacesPerRequest} places per request.");
+
+ var results = new List();
+
+ foreach (var place in request.Places)
+ {
+ if (string.IsNullOrWhiteSpace(place.Name) || place.Name.Length > ScoringRules.MaxAnswerLength)
+ continue;
+
+ // Story language follows the UI picker (place.Lang), which may differ
+ // from the language the answer was verified in.
+ var lang = GameLanguageExtensions.Parse(place.Lang);
+ var normalized = place.Name.Trim().ToLowerInvariant();
+
+ // Safety check: only generate stories for places that were already verified
+ // by the geocoding pipeline (a Toponym row exists in any language).
+ var exists = await _db.Toponyms
+ .AnyAsync(
+ t => t.NormalizedName == normalized
+ && t.Category == place.Type,
+ ct);
+
+ if (!exists)
+ {
+ _logger.LogDebug(
+ "Skipping story for unverified place '{Name}' ({Type}/{Lang})",
+ place.Name, place.Type, place.Lang);
+ continue;
+ }
+
+ var story = await _stories.GetStoryAsync(place.Name, place.Type, place.Coordinates, lang, ct);
+ if (story is null)
+ continue;
+
+ var (lat, lon) = ParseCoordinates(place.Coordinates);
+ if (lat is null || lon is null)
+ {
+ var coords = await _db.Toponyms
+ .AsNoTracking()
+ .Where(t => t.NormalizedName == normalized && t.Category == place.Type)
+ .Select(t => new { t.Latitude, t.Longitude })
+ .FirstOrDefaultAsync(ct);
+ if (coords is not null)
+ {
+ lat = coords.Latitude;
+ lon = coords.Longitude;
+ }
+ }
+
+ var image = await _images.GetImageAsync(
+ normalized, place.Type, place.Name, lat, lon, lang, ct);
+
+ results.Add(new StoryResult(
+ place.Name,
+ place.Type,
+ story,
+ image?.ImageUrl,
+ image?.Attribution));
+ }
+
+ return Ok(new DestinationStoriesResponse(results));
+ }
+
+ private static (double? Lat, double? Lon) ParseCoordinates(string? coordinates)
+ {
+ if (string.IsNullOrWhiteSpace(coordinates))
+ return (null, null);
+
+ var parts = coordinates.Split(',');
+ if (parts.Length != 2)
+ return (null, null);
+
+ if (double.TryParse(parts[0].Trim(), System.Globalization.NumberStyles.Float,
+ System.Globalization.CultureInfo.InvariantCulture, out var lat)
+ && double.TryParse(parts[1].Trim(), System.Globalization.NumberStyles.Float,
+ System.Globalization.CultureInfo.InvariantCulture, out var lon))
+ return (lat, lon);
+
+ return (null, null);
+ }
+}
diff --git a/src/FastGeography.Server/Controllers/GamesController.cs b/src/FastGeography.Server/Controllers/GamesController.cs
new file mode 100644
index 0000000..25fb51d
--- /dev/null
+++ b/src/FastGeography.Server/Controllers/GamesController.cs
@@ -0,0 +1,144 @@
+namespace FastGeography.Server.Controllers;
+
+using System.Security.Claims;
+
+using FastGeography.Server.Data;
+using FastGeography.Server.Data.Entities;
+using FastGeography.Server.Services;
+using FastGeography.Shared;
+using FastGeography.Shared.Dtos;
+
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+[ApiController]
+[Route("api/games")]
+[Authorize]
+public class GamesController : ControllerBase
+{
+ private static readonly TimeSpan GracePeriod = TimeSpan.FromSeconds(5);
+
+ private readonly ApplicationDbContext _db;
+ private readonly IGeocodingService _geocodingService;
+
+ public GamesController(ApplicationDbContext db, IGeocodingService geocodingService)
+ {
+ _db = db;
+ _geocodingService = geocodingService;
+ }
+
+ [HttpPost("solo/start")]
+ public async Task StartSolo([FromQuery] string? lang)
+ {
+ var userId = User.FindFirstValue(ClaimTypes.NameIdentifier)!;
+ var language = GameLanguageExtensions.Parse(lang);
+ var letter = Alphabet.RandomLetter(language);
+ var now = DateTime.UtcNow;
+
+ var round = new GameRound
+ {
+ Id = Guid.NewGuid(),
+ Mode = GameMode.Solo,
+ Letter = letter,
+ LanguageCode = language.ToCode(),
+ StartedAt = now,
+ EndsAt = now.AddSeconds(ScoringRules.DefaultTimerSeconds)
+ };
+
+ _db.GameRounds.Add(round);
+ await _db.SaveChangesAsync();
+
+ return Ok(new SoloStartResponse(round.Id, round.Letter, round.EndsAt, round.LanguageCode));
+ }
+
+ [HttpPost("solo/{roundId:guid}/submit")]
+ public async Task SubmitSolo(Guid roundId, [FromBody] SubmitAnswersRequest request)
+ {
+ var userId = User.FindFirstValue(ClaimTypes.NameIdentifier)!;
+
+ var round = await _db.GameRounds.FindAsync(roundId);
+ if (round is null) return NotFound();
+ if (round.Mode != GameMode.Solo) return BadRequest("Round is not a solo round.");
+ if (DateTime.UtcNow > round.EndsAt + GracePeriod) return BadRequest("Submission deadline passed.");
+
+ var alreadySubmitted = await _db.RoundSubmissions
+ .AnyAsync(s => s.RoundId == roundId && s.UserId == userId);
+ if (alreadySubmitted) return Conflict("Already submitted for this round.");
+
+ // Use the language from the round (authoritative); fall back to request for
+ // backward-compat with older clients that do not send LanguageCode.
+ var language = GameLanguageExtensions.Parse(
+ string.IsNullOrEmpty(round.LanguageCode) ? request.LanguageCode : round.LanguageCode);
+
+ var details = await ValidateAllAsync(round.Letter, language, request);
+ var submission = BuildSubmission(roundId, userId, request, details);
+
+ _db.RoundSubmissions.Add(submission);
+
+ var profile = await _db.PlayerProfiles.FirstOrDefaultAsync(p => p.UserId == userId);
+ if (profile is not null)
+ {
+ profile.CareerPoints += submission.CityPoints + submission.VillagePoints +
+ submission.CountryPoints + submission.RiverPoints +
+ submission.MountainPoints;
+ profile.GamesPlayed++;
+ }
+
+ await _db.SaveChangesAsync();
+
+ var badge = BadgeCalculator.Calculate(profile?.CareerPoints ?? 0).ToString();
+ return Ok(new SoloSubmitResponse(submission.TotalPoints, badge, details));
+ }
+
+ private async Task> ValidateAllAsync(char letter, GameLanguage language, SubmitAnswersRequest req)
+ {
+ var tasks = new[]
+ {
+ ValidateAsync(LocationType.City, req.City, letter, language),
+ ValidateAsync(LocationType.Village, req.Village, letter, language),
+ ValidateAsync(LocationType.Country, req.Country, letter, language),
+ ValidateAsync(LocationType.River, req.River, letter, language),
+ ValidateAsync(LocationType.Mountain, req.Mountain, letter, language),
+ };
+
+ await Task.WhenAll(tasks);
+ return tasks.Select(t => t.Result).ToList();
+ }
+
+ private async Task ValidateAsync(LocationType type, string? answer, char letter, GameLanguage language)
+ {
+ if (string.IsNullOrWhiteSpace(answer))
+ return new LocationResult(type, answer, ScoringRules.EmptyPoints, null);
+
+ if (!Alphabet.StartsWithLetter(answer, letter))
+ return new LocationResult(type, answer, ScoringRules.WrongLetterPoints, null);
+
+ var result = await _geocodingService.ValidateAsync(answer, type, language);
+ return new LocationResult(type, answer, result.Points, result.Coordinates);
+ }
+
+ private static RoundSubmission BuildSubmission(
+ Guid roundId, string userId, SubmitAnswersRequest req, List details)
+ {
+ int PointsFor(LocationType t) => details.First(d => d.Type == t).Points;
+
+ return new RoundSubmission
+ {
+ Id = Guid.NewGuid(),
+ RoundId = roundId,
+ UserId = userId,
+ CityAnswer = req.City,
+ VillageAnswer = req.Village,
+ CountryAnswer = req.Country,
+ RiverAnswer = req.River,
+ MountainAnswer = req.Mountain,
+ CityPoints = PointsFor(LocationType.City),
+ VillagePoints = PointsFor(LocationType.Village),
+ CountryPoints = PointsFor(LocationType.Country),
+ RiverPoints = PointsFor(LocationType.River),
+ MountainPoints = PointsFor(LocationType.Mountain),
+ RankInRound = 1
+ };
+ }
+}
diff --git a/src/FastGeography.Server/Controllers/GeocodingController.cs b/src/FastGeography.Server/Controllers/GeocodingController.cs
new file mode 100644
index 0000000..3f8f539
--- /dev/null
+++ b/src/FastGeography.Server/Controllers/GeocodingController.cs
@@ -0,0 +1,47 @@
+namespace FastGeography.Server.Controllers;
+
+using FastGeography.Server.Services;
+using FastGeography.Shared;
+
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.RateLimiting;
+
+[ApiController]
+[EnableRateLimiting("geocode")]
+public class GeocodingController : ControllerBase
+{
+ private readonly IGeocodingService _geocoding;
+ private readonly ILogger _logger;
+
+ public GeocodingController(IGeocodingService geocoding, ILogger logger)
+ {
+ _geocoding = geocoding;
+ _logger = logger;
+ }
+
+ ///
+ /// Validates a player's geography answer for the given location type.
+ /// Location is limited to 100 characters to prevent quota abuse.
+ /// Returns a
+ [HttpGet("geocode/{location}/{locationType}")]
+ [HttpGet("bingmaps/{location}/{locationType}")]
+ public async Task GetLocationType(
+ string location,
+ LocationType locationType,
+ [FromQuery] string? lang,
+ CancellationToken cancellationToken)
+ {
+ if (string.IsNullOrWhiteSpace(location) || location.Length > ScoringRules.MaxAnswerLength)
+ return BadRequest("Location must be between 1 and 100 characters.");
+
+ var language = GameLanguageExtensions.Parse(lang);
+
+ _logger.LogInformation(
+ "Validating answer '{Location}' for type {LocationType} / language {Language}", location, locationType, language);
+
+ var result = await _geocoding.ValidateAsync(location, locationType, language, cancellationToken);
+ return Ok(result);
+ }
+}
diff --git a/src/FastGeography.Server/Controllers/HomeController.cs b/src/FastGeography.Server/Controllers/HomeController.cs
deleted file mode 100644
index 19d799c..0000000
--- a/src/FastGeography.Server/Controllers/HomeController.cs
+++ /dev/null
@@ -1,83 +0,0 @@
-namespace FastGeography.Server.Controllers
-{
- using Microsoft.AspNetCore.Http;
- using Microsoft.AspNetCore.Mvc;
-
- public class HomeController : Controller
- {
- // GET: HomeController
- public ActionResult Index()
- {
- return View();
- }
-
- // GET: HomeController/Details/5
- public ActionResult Details(int id)
- {
- return View();
- }
-
- // GET: HomeController/Create
- public ActionResult Create()
- {
- return View();
- }
-
- // POST: HomeController/Create
- [HttpPost]
- [ValidateAntiForgeryToken]
- public ActionResult Create(IFormCollection collection)
- {
- try
- {
- return RedirectToAction(nameof(Index));
- }
- catch
- {
- return View();
- }
- }
-
- // GET: HomeController/Edit/5
- public ActionResult Edit(int id)
- {
- return View();
- }
-
- // POST: HomeController/Edit/5
- [HttpPost]
- [ValidateAntiForgeryToken]
- public ActionResult Edit(int id, IFormCollection collection)
- {
- try
- {
- return RedirectToAction(nameof(Index));
- }
- catch
- {
- return View();
- }
- }
-
- // GET: HomeController/Delete/5
- public ActionResult Delete(int id)
- {
- return View();
- }
-
- // POST: HomeController/Delete/5
- [HttpPost]
- [ValidateAntiForgeryToken]
- public ActionResult Delete(int id, IFormCollection collection)
- {
- try
- {
- return RedirectToAction(nameof(Index));
- }
- catch
- {
- return View();
- }
- }
- }
-}
diff --git a/src/FastGeography.Server/Controllers/LeaderboardController.cs b/src/FastGeography.Server/Controllers/LeaderboardController.cs
new file mode 100644
index 0000000..3627852
--- /dev/null
+++ b/src/FastGeography.Server/Controllers/LeaderboardController.cs
@@ -0,0 +1,117 @@
+namespace FastGeography.Server.Controllers;
+
+using System.Security.Claims;
+
+using FastGeography.Server.Data;
+using FastGeography.Shared;
+using FastGeography.Shared.Dtos;
+
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+[ApiController]
+[Route("api/leaderboard")]
+public class LeaderboardController : ControllerBase
+{
+ private readonly ApplicationDbContext _db;
+
+ public LeaderboardController(ApplicationDbContext db) => _db = db;
+
+ /// Returns top 25 players. filter=alltime (default) or week.
+ [HttpGet]
+ public async Task GetLeaderboard([FromQuery] string filter = "alltime")
+ {
+ List<(string UserId, int Points, int Games)> raw;
+
+ if (filter == "week")
+ {
+ var cutoff = DateTime.UtcNow.AddDays(-7);
+
+ // GroupBy with aggregates over a joined navigation cannot be translated by EF Core.
+ // Fetch only the columns needed, then aggregate in memory.
+ var submissions = await _db.RoundSubmissions
+ .Where(s => s.Round.StartedAt >= cutoff)
+ .Select(s => new
+ {
+ s.UserId,
+ Points = s.CityPoints + s.VillagePoints + s.CountryPoints + s.RiverPoints + s.MountainPoints
+ })
+ .ToListAsync();
+
+ raw = submissions
+ .GroupBy(s => s.UserId)
+ .Select(g => (g.Key, g.Sum(s => s.Points), g.Count()))
+ .OrderByDescending(x => x.Item2)
+ .Take(25)
+ .ToList();
+ }
+ else
+ {
+ var profiles = await _db.PlayerProfiles
+ .OrderByDescending(p => p.CareerPoints)
+ .Take(25)
+ .Select(p => new { p.UserId, p.CareerPoints, p.GamesPlayed })
+ .ToListAsync();
+
+ raw = profiles
+ .Select(p => (p.UserId, p.CareerPoints, p.GamesPlayed))
+ .ToList();
+ }
+
+ if (raw.Count == 0)
+ return Ok(Array.Empty());
+
+ var userIds = raw.Select(r => r.Item1).ToList();
+ var displayNames = await _db.Users
+ .Where(u => userIds.Contains(u.Id))
+ .ToDictionaryAsync(u => u.Id, u => u.DisplayName);
+
+ var entries = raw.Select((r, i) => new LeaderboardEntry(
+ Rank: i + 1,
+ UserId: r.Item1,
+ DisplayName: displayNames.TryGetValue(r.Item1, out var n) ? n : "Unknown",
+ CareerPoints: r.Item2,
+ Badge: BadgeCalculator.Calculate(r.Item2).ToString(),
+ GamesPlayed: r.Item3)).ToList();
+
+ return Ok(entries);
+ }
+
+ /// Returns current user's rank, career stats, and last 10 rounds.
+ [HttpGet("me")]
+ [Microsoft.AspNetCore.Authorization.Authorize]
+ public async Task GetMyStats()
+ {
+ var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+ if (userId is null) return Unauthorized();
+
+ var profile = await _db.PlayerProfiles.FirstOrDefaultAsync(p => p.UserId == userId);
+ var user = await _db.Users.FindAsync(userId);
+ if (profile is null || user is null) return NotFound();
+
+ var rank = await _db.PlayerProfiles
+ .CountAsync(p => p.CareerPoints > profile.CareerPoints) + 1;
+
+ var recent = await _db.RoundSubmissions
+ .Include(s => s.Round)
+ .Where(s => s.UserId == userId)
+ .OrderByDescending(s => s.Round.StartedAt)
+ .Take(10)
+ .Select(s => new RecentRound(
+ s.RoundId,
+ s.Round.Mode.ToString(),
+ s.Round.Letter,
+ s.CityPoints + s.VillagePoints + s.CountryPoints + s.RiverPoints + s.MountainPoints,
+ s.Round.StartedAt))
+ .ToListAsync();
+
+ return Ok(new PlayerStats(
+ userId,
+ rank,
+ user.DisplayName,
+ profile.CareerPoints,
+ BadgeCalculator.Calculate(profile.CareerPoints).ToString(),
+ profile.GamesPlayed,
+ recent));
+ }
+}
diff --git a/src/FastGeography.Server/Controllers/RoomsController.cs b/src/FastGeography.Server/Controllers/RoomsController.cs
new file mode 100644
index 0000000..2b26eb2
--- /dev/null
+++ b/src/FastGeography.Server/Controllers/RoomsController.cs
@@ -0,0 +1,38 @@
+namespace FastGeography.Server.Controllers;
+
+using System.Security.Claims;
+
+using FastGeography.Server.Services;
+using FastGeography.Shared;
+using FastGeography.Shared.Dtos;
+
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+[ApiController]
+[Route("api/rooms")]
+[Authorize]
+public class RoomsController : ControllerBase
+{
+ private readonly IRoomService _rooms;
+
+ public RoomsController(IRoomService rooms) => _rooms = rooms;
+
+ [HttpPost]
+ public IActionResult CreateRoom([FromQuery] string? lang)
+ {
+ var userId = User.FindFirstValue(ClaimTypes.NameIdentifier)!;
+ var displayName = User.FindFirstValue(ClaimTypes.Name) ?? "Player";
+ var language = GameLanguageExtensions.Parse(lang);
+ var room = _rooms.CreateRoom(userId, displayName, language);
+ return Ok(new CreateRoomResponse(room.Code, room.LanguageCode));
+ }
+
+ [HttpGet("{code}/exists")]
+ [AllowAnonymous]
+ public IActionResult RoomExists(string code)
+ {
+ var room = _rooms.GetRoom(code);
+ return room is null ? NotFound() : Ok();
+ }
+}
diff --git a/src/FastGeography.Server/Data/ApplicationDbContext.cs b/src/FastGeography.Server/Data/ApplicationDbContext.cs
new file mode 100644
index 0000000..77df6ef
--- /dev/null
+++ b/src/FastGeography.Server/Data/ApplicationDbContext.cs
@@ -0,0 +1,75 @@
+namespace FastGeography.Server.Data;
+
+using FastGeography.Server.Data.Entities;
+
+using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore;
+
+public sealed class ApplicationDbContext : IdentityDbContext
+{
+ public ApplicationDbContext(DbContextOptions options) : base(options) { }
+
+ public DbSet PlayerProfiles => Set();
+ public DbSet GameRounds => Set();
+ public DbSet RoundSubmissions => Set();
+ public DbSet Toponyms => Set();
+ public DbSet ToponymStories => Set();
+
+ protected override void OnModelCreating(ModelBuilder builder)
+ {
+ base.OnModelCreating(builder);
+
+ builder.Entity(e =>
+ {
+ e.HasKey(p => p.Id);
+ e.HasOne(p => p.User)
+ .WithOne(u => u.Profile)
+ .HasForeignKey(p => p.UserId);
+ e.HasIndex(p => p.UserId).IsUnique();
+ });
+
+ builder.Entity(e =>
+ {
+ e.HasKey(r => r.Id);
+ e.Property(r => r.Letter).HasColumnType("char(1)");
+ });
+
+ builder.Entity(e =>
+ {
+ e.HasKey(s => s.Id);
+ e.HasOne(s => s.Round)
+ .WithMany(r => r.Submissions)
+ .HasForeignKey(s => s.RoundId);
+ e.HasOne(s => s.User)
+ .WithMany()
+ .HasForeignKey(s => s.UserId);
+ e.Ignore(s => s.TotalPoints);
+ });
+
+ builder.Entity(e =>
+ {
+ e.HasKey(t => t.Id);
+ e.Property(t => t.NormalizedName).HasMaxLength(200);
+ e.Property(t => t.DisplayName).HasMaxLength(200);
+ e.Property(t => t.LanguageCode).HasMaxLength(8).HasDefaultValue("en");
+ e.Property(t => t.Provider).HasMaxLength(50);
+ e.Property(t => t.ImageUrl).HasMaxLength(500);
+ e.Property(t => t.ImageAttribution).HasMaxLength(100);
+ // (NormalizedName, Category, LanguageCode) is the natural lookup key and must be
+ // unique so concurrent inserts for the same verified answer + language don't create
+ // duplicates.
+ e.HasIndex(t => new { t.NormalizedName, t.Category, t.LanguageCode }).IsUnique();
+ });
+
+ builder.Entity(e =>
+ {
+ e.ToTable("ToponymStories");
+ e.HasKey(s => s.Id);
+ e.Property(s => s.NormalizedName).HasMaxLength(200);
+ e.Property(s => s.LanguageCode).HasMaxLength(8);
+ e.Property(s => s.Body).HasMaxLength(600);
+ e.Property(s => s.Angle).HasMaxLength(32);
+ e.HasIndex(s => new { s.NormalizedName, s.Category, s.LanguageCode });
+ });
+ }
+}
diff --git a/src/FastGeography.Server/Data/ApplicationDbContextFactory.cs b/src/FastGeography.Server/Data/ApplicationDbContextFactory.cs
new file mode 100644
index 0000000..c1fea11
--- /dev/null
+++ b/src/FastGeography.Server/Data/ApplicationDbContextFactory.cs
@@ -0,0 +1,42 @@
+namespace FastGeography.Server.Data;
+
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Design;
+using Microsoft.Extensions.Configuration;
+
+///
+/// Used exclusively by dotnet ef tooling (migrations add / update / script).
+/// Not referenced at runtime — the real context is configured in Program.cs.
+///
+/// The connection string is read from
+/// src/FastGeography.AppHost/appsettings.json so there is a single place
+/// to manage the local development database URL.
+///
+internal sealed class ApplicationDbContextFactory : IDesignTimeDbContextFactory
+{
+ public ApplicationDbContext CreateDbContext(string[] args)
+ {
+ // dotnet-ef runs with CWD = the Server project folder.
+ // One level up lands at src/, then into the AppHost project.
+ var appHostSettings = Path.GetFullPath(
+ Path.Combine(Directory.GetCurrentDirectory(), "..", "FastGeography.AppHost", "appsettings.json"));
+
+ var configuration = new ConfigurationBuilder()
+ .AddJsonFile(appHostSettings, optional: false, reloadOnChange: false)
+ .AddEnvironmentVariables()
+ .Build();
+
+ var connectionString = configuration.GetConnectionString("fastgeography-db")
+ ?? throw new InvalidOperationException(
+ $"Connection string 'fastgeography-db' was not found. " +
+ $"Expected it in: {appHostSettings}");
+
+ var options = new DbContextOptionsBuilder()
+ .UseNpgsql(
+ connectionString,
+ o => o.MigrationsAssembly(typeof(ApplicationDbContext).Assembly.GetName().Name))
+ .Options;
+
+ return new ApplicationDbContext(options);
+ }
+}
diff --git a/src/FastGeography.Server/Data/ApplicationUser.cs b/src/FastGeography.Server/Data/ApplicationUser.cs
new file mode 100644
index 0000000..b8f1b5c
--- /dev/null
+++ b/src/FastGeography.Server/Data/ApplicationUser.cs
@@ -0,0 +1,18 @@
+namespace FastGeography.Server.Data;
+
+using FastGeography.Server.Data.Entities;
+
+using Microsoft.AspNetCore.Identity;
+
+public sealed class ApplicationUser : IdentityUser
+{
+ public string DisplayName { get; set; } = string.Empty;
+
+ ///
+ /// ISO 639-1 UI + game language preference ("en" or "mk"). Persisted so the
+ /// picker survives sign-in across devices.
+ ///
+ public string PreferredLanguage { get; set; } = "en";
+
+ public PlayerProfile? Profile { get; set; }
+}
diff --git a/src/FastGeography.Server/Data/Entities/GameRound.cs b/src/FastGeography.Server/Data/Entities/GameRound.cs
new file mode 100644
index 0000000..dfdbc24
--- /dev/null
+++ b/src/FastGeography.Server/Data/Entities/GameRound.cs
@@ -0,0 +1,20 @@
+namespace FastGeography.Server.Data.Entities;
+
+using FastGeography.Shared;
+
+public sealed class GameRound
+{
+ public Guid Id { get; set; }
+ public GameMode Mode { get; set; }
+ public char Letter { get; set; }
+ public DateTime StartedAt { get; set; }
+ public DateTime EndsAt { get; set; }
+
+ /// Short alphanumeric code for multiplayer rooms; null for solo rounds.
+ public string? RoomCode { get; set; }
+
+ /// ISO 639-1 game language code ("en" or "mk") for the alphabet used in this round.
+ public string LanguageCode { get; set; } = "en";
+
+ public List Submissions { get; set; } = [];
+}
diff --git a/src/FastGeography.Server/Data/Entities/PlayerProfile.cs b/src/FastGeography.Server/Data/Entities/PlayerProfile.cs
new file mode 100644
index 0000000..a9972c2
--- /dev/null
+++ b/src/FastGeography.Server/Data/Entities/PlayerProfile.cs
@@ -0,0 +1,13 @@
+namespace FastGeography.Server.Data.Entities;
+
+using FastGeography.Server.Data;
+
+public sealed class PlayerProfile
+{
+ public Guid Id { get; set; }
+ public string UserId { get; set; } = string.Empty;
+ public ApplicationUser User { get; set; } = null!;
+
+ public int CareerPoints { get; set; }
+ public int GamesPlayed { get; set; }
+}
diff --git a/src/FastGeography.Server/Data/Entities/RoundSubmission.cs b/src/FastGeography.Server/Data/Entities/RoundSubmission.cs
new file mode 100644
index 0000000..6b911cb
--- /dev/null
+++ b/src/FastGeography.Server/Data/Entities/RoundSubmission.cs
@@ -0,0 +1,33 @@
+namespace FastGeography.Server.Data.Entities;
+
+using FastGeography.Server.Data;
+
+public sealed class RoundSubmission
+{
+ public Guid Id { get; set; }
+ public Guid RoundId { get; set; }
+ public GameRound Round { get; set; } = null!;
+
+ public string UserId { get; set; } = string.Empty;
+ public ApplicationUser User { get; set; } = null!;
+
+ public string? CityAnswer { get; set; }
+ public string? VillageAnswer { get; set; }
+ public string? CountryAnswer { get; set; }
+ public string? RiverAnswer { get; set; }
+ public string? MountainAnswer { get; set; }
+
+ public int CityPoints { get; set; }
+ public int VillagePoints { get; set; }
+ public int CountryPoints { get; set; }
+ public int RiverPoints { get; set; }
+ public int MountainPoints { get; set; }
+
+ public int TotalPoints =>
+ CityPoints + VillagePoints + CountryPoints + RiverPoints + MountainPoints;
+
+ public int SecondsPlayed { get; set; }
+
+ /// Rank within this round (1 = highest score).
+ public int RankInRound { get; set; }
+}
diff --git a/src/FastGeography.Server/Data/Entities/Toponym.cs b/src/FastGeography.Server/Data/Entities/Toponym.cs
new file mode 100644
index 0000000..ad78718
--- /dev/null
+++ b/src/FastGeography.Server/Data/Entities/Toponym.cs
@@ -0,0 +1,44 @@
+namespace FastGeography.Server.Data.Entities;
+
+using FastGeography.Shared;
+
+///
+/// A geography toponym that has been verified by a maps provider and acts as the
+/// server-side cache of correct answers. Populated on first confirmed hit from
+/// the active geocoding provider so subsequent validations skip the external API entirely.
+///
+public sealed class Toponym
+{
+ public Guid Id { get; set; }
+
+ ///
+ /// Lower-invariant, trimmed form of the player's answer used as the lookup key.
+ ///
+ public string NormalizedName { get; set; } = string.Empty;
+
+ /// Display form as submitted by the player (or formatted by the provider).
+ public string DisplayName { get; set; } = string.Empty;
+
+ public LocationType Category { get; set; }
+
+ /// ISO 639-1 game language code ("en" or "mk") used when this entry was verified.
+ public string LanguageCode { get; set; } = "en";
+
+ public double Latitude { get; set; }
+ public double Longitude { get; set; }
+
+ /// Name of the maps provider that verified this entry (e.g. "Nominatim").
+ public string Provider { get; set; } = string.Empty;
+
+ /// UTC timestamp when the provider confirmed the toponym.
+ public DateTime VerifiedAtUtc { get; set; }
+
+ /// Wikipedia or Wikimedia Commons thumbnail URL for this place.
+ public string? ImageUrl { get; set; }
+
+ /// Short attribution for
+ public string? ImageAttribution { get; set; }
+
+ /// When an image lookup was last attempted (hit or miss).
+ public DateTime? ImageFetchedAtUtc { get; set; }
+}
diff --git a/src/FastGeography.Server/Data/Entities/ToponymStory.cs b/src/FastGeography.Server/Data/Entities/ToponymStory.cs
new file mode 100644
index 0000000..eed4833
--- /dev/null
+++ b/src/FastGeography.Server/Data/Entities/ToponymStory.cs
@@ -0,0 +1,29 @@
+namespace FastGeography.Server.Data.Entities;
+
+using FastGeography.Shared;
+
+///
+/// One AI-generated travel micro-story for a verified place.
+/// Several rows may exist per (NormalizedName, Category, LanguageCode) to form a pool.
+/// Stories are stored independently of a language-specific
+public sealed class ToponymStory
+{
+ public Guid Id { get; set; }
+
+ public string NormalizedName { get; set; } = string.Empty;
+
+ public LocationType Category { get; set; }
+
+ /// ISO 639-1 game language of the story body ("en" or "mk").
+ public string LanguageCode { get; set; } = "en";
+
+ /// The 40–70 word story paragraph.
+ public string Body { get; set; } = string.Empty;
+
+ /// Prompt angle used when generating (e.g. "history"). Null for migrated stories.
+ public string? Angle { get; set; }
+
+ public DateTime CreatedAtUtc { get; set; }
+}
diff --git a/src/FastGeography.Server/Data/Seed/ToponymSeedRecord.cs b/src/FastGeography.Server/Data/Seed/ToponymSeedRecord.cs
new file mode 100644
index 0000000..5f854fb
--- /dev/null
+++ b/src/FastGeography.Server/Data/Seed/ToponymSeedRecord.cs
@@ -0,0 +1,50 @@
+namespace FastGeography.Server.Data.Seed;
+
+using System.Security.Cryptography;
+using System.Text;
+
+using FastGeography.Shared;
+
+///
+/// A single entry in the well-known toponym catalog. Ids are deterministic
+/// (MD5 of the lookup key) so re-running the seeder never creates duplicate PKs.
+///
+public sealed record ToponymSeedRecord
+{
+ private static readonly DateTime SeedVerifiedAt =
+ new(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+ public ToponymSeedRecord(
+ string displayName,
+ LocationType category,
+ string languageCode,
+ double latitude,
+ double longitude)
+ {
+ DisplayName = displayName;
+ NormalizedName = displayName.Trim().ToLowerInvariant();
+ Category = category;
+ LanguageCode = languageCode;
+ Latitude = latitude;
+ Longitude = longitude;
+ Id = ComputeId(NormalizedName, category, languageCode);
+ VerifiedAtUtc = SeedVerifiedAt;
+ }
+
+ public Guid Id { get; }
+ public string DisplayName { get; }
+ public string NormalizedName{ get; }
+ public LocationType Category { get; }
+ public string LanguageCode { get; }
+ public double Latitude { get; }
+ public double Longitude { get; }
+ public DateTime VerifiedAtUtc { get; }
+ public string Provider => "Seed";
+
+ private static Guid ComputeId(string normalized, LocationType category, string lang)
+ {
+ var input = $"{normalized}|{(int)category}|{lang}";
+ var hash = MD5.HashData(Encoding.UTF8.GetBytes(input));
+ return new Guid(hash);
+ }
+}
diff --git a/src/FastGeography.Server/Data/Seed/ToponymSeeder.cs b/src/FastGeography.Server/Data/Seed/ToponymSeeder.cs
new file mode 100644
index 0000000..b8a4bff
--- /dev/null
+++ b/src/FastGeography.Server/Data/Seed/ToponymSeeder.cs
@@ -0,0 +1,55 @@
+namespace FastGeography.Server.Data.Seed;
+
+using FastGeography.Server.Data.Entities;
+
+using Microsoft.EntityFrameworkCore;
+
+///
+/// Idempotent runtime seeder that inserts any Toponyms table.
+///
+/// Called from Program.cs after MigrateAsync / EnsureCreatedAsync .
+/// On PostgreSQL the migration already ran ON CONFLICT DO NOTHING , so this is
+/// effectively a no-op. On InMemory (dev / tests that use EnsureCreated )
+/// migrations never run, so this seeder does the initial population.
+///
+public static class ToponymSeeder
+{
+ public static async Task SeedAsync(
+ ApplicationDbContext db,
+ CancellationToken cancellationToken = default)
+ {
+ var seeds = WellKnownToponyms.All;
+ if (seeds.Count == 0) return;
+
+ // Load all existing lookup keys in one round-trip.
+ var rawKeys = await db.Toponyms
+ .Select(t => new { t.NormalizedName, Cat = (int)t.Category, t.LanguageCode })
+ .ToListAsync(cancellationToken);
+
+ var existing = rawKeys
+ .Select(x => (x.NormalizedName, x.Cat, x.LanguageCode))
+ .ToHashSet();
+
+ var toAdd = seeds
+ .Where(r => !existing.Contains((r.NormalizedName, (int)r.Category, r.LanguageCode)))
+ .Select(r => new Toponym
+ {
+ Id = r.Id,
+ NormalizedName = r.NormalizedName,
+ DisplayName = r.DisplayName,
+ Category = r.Category,
+ LanguageCode = r.LanguageCode,
+ Latitude = r.Latitude,
+ Longitude = r.Longitude,
+ Provider = r.Provider,
+ VerifiedAtUtc = r.VerifiedAtUtc,
+ })
+ .ToList();
+
+ if (toAdd.Count == 0) return;
+
+ db.Toponyms.AddRange(toAdd);
+ await db.SaveChangesAsync(cancellationToken);
+ }
+}
diff --git a/src/FastGeography.Server/Data/Seed/WellKnownToponyms.cs b/src/FastGeography.Server/Data/Seed/WellKnownToponyms.cs
new file mode 100644
index 0000000..e2bc2e1
--- /dev/null
+++ b/src/FastGeography.Server/Data/Seed/WellKnownToponyms.cs
@@ -0,0 +1,484 @@
+namespace FastGeography.Server.Data.Seed;
+
+using FastGeography.Shared;
+
+///
+/// Curated bilingual (EN + MK) seed catalog of well-known toponyms.
+///
+/// Coverage goal: at least one real place per letter × category for
+/// EN (A–Z) and MK (А–Ш) where a genuine place exists.
+///
+/// Helper E() creates up to two
+public static class WellKnownToponyms
+{
+ // ──────────────────────────────────────────────────────────────────────
+ // Public catalog
+ // ──────────────────────────────────────────────────────────────────────
+ public static readonly IReadOnlyList All = Build();
+
+ // ──────────────────────────────────────────────────────────────────────
+ // Helpers
+ // ──────────────────────────────────────────────────────────────────────
+ private static IReadOnlyList Build()
+ {
+ var list = new List(400);
+
+ void Add(LocationType cat, double lat, double lon, string? en, string? mk)
+ {
+ if (en is not null) list.Add(new ToponymSeedRecord(en, cat, "en", lat, lon));
+ if (mk is not null) list.Add(new ToponymSeedRecord(mk, cat, "mk", lat, lon));
+ }
+
+ const LocationType Cty = LocationType.City;
+ const LocationType Vlg = LocationType.Village;
+ const LocationType Ctr = LocationType.Country;
+ const LocationType Riv = LocationType.River;
+ const LocationType Mtn = LocationType.Mountain;
+
+ // ── CITIES ──────────────────────────────────────────────────────
+ // EN:A MK:А
+ Add(Cty, 52.37, 4.90, "Amsterdam", "Амстердам");
+ Add(Cty, 37.98, 23.73, "Athens", "Атина");
+ // EN:B MK:Б
+ Add(Cty, 52.52, 13.41, "Berlin", "Берлин");
+ Add(Cty, 47.50, 19.05, "Budapest", "Будимпешта");
+ Add(Cty, -34.61, -58.38, "Buenos Aires", "Буенос Аирес");
+ // EN:C MK:Ч (Chicago → Чикаго)
+ Add(Cty, 41.88, -87.63, "Chicago", "Чикаго");
+ // EN:C MK:К
+ Add(Cty, 30.06, 31.24, "Cairo", "Каиро");
+ // EN:D MK:Д
+ Add(Cty, 53.34, -6.27, "Dublin", "Даблин");
+ Add(Cty, 28.61, 77.21, "Delhi", "Делхи");
+ // EN:E MK:Е
+ Add(Cty, 55.95, -3.19, "Edinburgh", "Единбург");
+ // EN:F MK:Ф
+ Add(Cty, 50.11, 8.68, "Frankfurt", "Франкфурт");
+ Add(Cty, 43.77, 11.25, "Florence", "Фиренца");
+ // EN:G MK:Ж (Geneva → Женева)
+ Add(Cty, 46.20, 6.15, "Geneva", "Женева");
+ // EN:G MK:Г
+ Add(Cty, 41.80, 20.91, null, "Гостивар"); // Macedonian city
+ // EN:H MK:Х
+ Add(Cty, 60.17, 24.93, "Helsinki", "Хелсинки");
+ Add(Cty, 23.13, -82.38, "Havana", "Хавана");
+ // EN:I MK:И
+ Add(Cty, 41.01, 28.95, "Istanbul", "Истанбул");
+ // EN:J MK:Ј
+ Add(Cty, -26.20, 28.04, "Johannesburg", "Јоханесбург");
+ // EN:J MK:Џ (Jakarta → Џакарта)
+ Add(Cty, 6.21, 106.85, "Jakarta", "Џакарта");
+ // EN:K MK:К extra
+ Add(Cty, 35.01, 135.77, "Kyoto", "Кјото");
+ // EN:L MK:Л
+ Add(Cty, 51.51, -0.13, "London", "Лондон");
+ Add(Cty, 38.72, -9.14, "Lisbon", "Лисабон");
+ // MK:Љ (Ljubljana → Љубљана)
+ Add(Cty, 46.05, 14.51, null, "Љубљана"); // MK:Љ
+ // EN:M MK:М
+ Add(Cty, 40.42, -3.70, "Madrid", "Мадрид");
+ Add(Cty, 55.75, 37.62, "Moscow", "Москва");
+ // EN:N MK:Н
+ Add(Cty, -1.29, 36.82, "Nairobi", "Најроби");
+ Add(Cty, 40.85, 14.27, "Naples", "Напул");
+ // EN:N MK:Њ (New York → Њујорк)
+ Add(Cty, 40.71, -74.01, "New York", "Њујорк");
+ // EN:O MK:О
+ Add(Cty, 59.91, 10.75, "Oslo", "Осло");
+ Add(Cty, 45.42, -75.69, "Ottawa", "Отава");
+ // EN:P MK:П
+ Add(Cty, 48.86, 2.35, "Paris", "Париз");
+ Add(Cty, 50.07, 14.44, "Prague", "Прага");
+ // EN:Q (Macedonian has no Q; Катар MK:К already covered)
+ Add(Cty, -0.23, -78.52, "Quito", null);
+ // EN:R MK:Р
+ Add(Cty, 41.90, 12.50, "Rome", "Рим");
+ Add(Cty, 64.15, -21.94, "Reykjavik", "Рејкјавик");
+ // EN:S MK:С
+ Add(Cty, 42.00, 21.43, "Skopje", "Скопје");
+ Add(Cty, -33.87, 151.21, "Sydney", "Сиднеј");
+ // EN:S MK:Ш (Shanghai → Шангај)
+ Add(Cty, 31.23, 121.47, "Shanghai", "Шангај");
+ // EN:T MK:Т
+ Add(Cty, 35.69, 139.69, "Tokyo", "Токио");
+ Add(Cty, 41.33, 19.83, "Tirana", "Тирана");
+ // EN:U MK:У
+ Add(Cty, 52.09, 5.12, "Utrecht", "Утрехт");
+ Add(Cty, 47.91, 106.89, "Ulaanbaatar", "Улан Батор");
+ // EN:V MK:В
+ Add(Cty, 48.21, 16.37, "Vienna", "Виена");
+ Add(Cty, 49.25,-123.12, "Vancouver", "Ванкувер");
+ // EN:W (Варшава starts with В, already covered; МК В done)
+ Add(Cty, 52.23, 21.01, "Warsaw", null);
+ // EN:X
+ Add(Cty, 34.27, 108.93, "Xian", null);
+ // EN:Y MK:Ј extra
+ Add(Cty, 40.18, 44.51, "Yerevan", "Јерван");
+ // EN:Z MK:З
+ Add(Cty, 45.81, 15.98, "Zagreb", "Загреб");
+ // EN:Z MK:Ц (Zurich → Цирих)
+ Add(Cty, 47.37, 8.55, "Zurich", "Цирих");
+ // MK-only coverage for rare letters
+ Add(Cty, 41.99, 21.37, null, "Ѓорче Петров"); // MK:Ѓ (municipality of Skopje)
+ // MK:Ѕ — documented gap; no commonly-known city
+ // MK:Ќ — documented gap; extremely rare initial letter for cities
+
+ // ── VILLAGES ────────────────────────────────────────────────────
+ // EN:A MK:А
+ Add(Vlg, 40.78, 17.24, "Alberobello", "Алберобело");
+ // EN:B MK:Б
+ Add(Vlg, 51.76, -1.83, "Bibury", "Бибури");
+ // EN:C MK:К (Castle Combe → Касл Ком)
+ Add(Vlg, 51.48, -2.22, "Castle Combe", "Касл Ком");
+ // EN:D MK:Д
+ Add(Vlg, 58.57, -4.74, "Durness", "Дурнес");
+ // EN:E MK:Е
+ Add(Vlg, 43.73, 7.36, "Eze", "Ез");
+ // EN:F (Fiscardo; МК Ф covered via Фариш below)
+ Add(Vlg, 38.45, 20.58, "Fiscardo", null);
+ // EN:G MK:Г
+ Add(Vlg, 46.62, 8.04, "Grindelwald", "Гриндевалд");
+ Add(Vlg, 41.28, 20.80, null, "Галичник"); // MK:Г extra (famous Macedonian village)
+ // EN:H MK:Х
+ Add(Vlg, 47.56, 13.65, "Hallstatt", "Халштат");
+ // EN:I MK:И
+ Add(Vlg, 36.44, 25.42, "Imerovigli", "Имеровигли");
+ // EN:J (MK:Ж — Желино covers it below)
+ Add(Vlg, 43.87, 5.27, "Joucas", null);
+ // EN:K MK:К extra
+ Add(Vlg, 51.24, 4.98, "Kasterlee", "Кастерли");
+ // EN:L MK:Л
+ Add(Vlg, 46.59, 7.91, "Lauterbrunnen", "Лотербрунен");
+ // EN:M MK:М
+ Add(Vlg, 38.44, -7.37, "Monsaraz", "Монсараз");
+ // EN:N MK:Н
+ Add(Vlg, 48.85, 10.49, "Nordlingen", "Нердлинген");
+ // EN:O MK:О
+ Add(Vlg, 36.46, 25.37, "Oia", "Оиа");
+ // EN:P MK:П
+ Add(Vlg, 44.30, 9.21, "Portofino", "Портофино");
+ // EN:Q (no easy MK pairing)
+ Add(Vlg, 51.79, 11.15, "Quedlinburg", null);
+ // EN:R MK:Р
+ Add(Vlg, 49.38, 10.18, "Rothenburg", "Ротенбург");
+ // EN:S (MK:С — Смилево below)
+ Add(Vlg, 50.21, -5.48, "St Ives", null);
+ // EN:T MK:Т
+ Add(Vlg, 40.71, 14.64, "Tramonti", "Трамонти");
+ // EN:U MK:У
+ Add(Vlg, 47.54, 11.07, "Unterammergau", "Унтерамергау");
+ // EN:V MK:В
+ Add(Vlg, 43.84, 5.98, "Valensole", "Валансол");
+ // EN:W
+ Add(Vlg, 46.61, 7.92, "Wengen", null);
+ // EN:X (Xàbia / Javea)
+ Add(Vlg, 38.79, 0.17, "Xabia", null);
+ // EN:Y
+ Add(Vlg, 49.74, 0.31, "Yport", null);
+ // EN:Z MK:Ц (Zermatt → Цермат; German Z = "ts" → Ц in MK)
+ Add(Vlg, 46.02, 7.75, "Zermatt", "Цермат");
+ // MK-only villages to cover remaining letters
+ Add(Vlg, 41.15, 21.23, null, "Фариш"); // MK:Ф (Macedonian village)
+ Add(Vlg, 41.94, 21.04, null, "Желино"); // MK:Ж
+ Add(Vlg, 41.77, 21.53, null, "Ѓуѓанци"); // MK:Ѓ (Macedonian village)
+ Add(Vlg, 41.23, 20.95, null, "Јабланица"); // MK:Ј
+ Add(Vlg, 41.98, 21.48, null, "Љубанци"); // MK:Љ (village near Skopje)
+ Add(Vlg, 42.76, 21.37, null, "Смилево"); // MK:С (famous Macedonian village)
+ Add(Vlg, 41.09, 22.87, null, "Зрновци"); // MK:З (Macedonian village)
+ Add(Vlg, 41.52, 21.56, null, "Чашка"); // MK:Ч (Macedonian village)
+ Add(Vlg, 41.87, 21.34, null, "Шишево"); // MK:Ш (near Matka Canyon)
+ Add(Vlg, 41.12, 22.18, null, "Богданци"); // MK:Б extra
+ Add(Vlg, 42.04, 21.47, null, "Лешок"); // MK:Л extra
+ // MK:Ѕ — documented gap
+ // MK:Ќ — documented gap
+ // MK:Њ — documented gap
+
+ // ── COUNTRIES ───────────────────────────────────────────────────
+ // EN:A MK:А
+ Add(Ctr, 41.15, 20.17, "Albania", "Албанија");
+ Add(Ctr, -38.42, -63.62, "Argentina", "Аргентина");
+ Add(Ctr, -25.27, 133.78, "Australia", "Австралија");
+ // EN:B MK:Б
+ Add(Ctr, 50.50, 4.47, "Belgium", "Белгија");
+ Add(Ctr, 42.73, 25.49, "Bulgaria", "Бугарија");
+ Add(Ctr, -14.24, -51.93, "Brazil", "Бразил");
+ // EN:C MK:Ч (Chile → Чиле)
+ Add(Ctr, -35.68, -71.54, "Chile", "Чиле");
+ // EN:C MK:Х (Croatia → Хрватска)
+ Add(Ctr, 45.10, 15.20, "Croatia", "Хрватска");
+ // EN:C MK:К
+ Add(Ctr, 35.86, 104.20, "China", "Кина");
+ // EN:D MK:Д
+ Add(Ctr, 56.26, 9.50, "Denmark", "Данска");
+ // EN:D MK:Џ (Djibouti → Џибути)
+ Add(Ctr, 11.59, 43.14, "Djibouti", "Џибути");
+ // EN:E MK:Е
+ Add(Ctr, -1.83, -78.18, "Ecuador", "Еквадор");
+ Add(Ctr, 26.82, 30.80, "Egypt", "Египет");
+ Add(Ctr, 9.15, 40.49, "Ethiopia", "Етиопија");
+ // EN:F MK:Ф
+ Add(Ctr, 46.23, 2.21, "France", "Франција");
+ Add(Ctr, 61.92, 25.75, "Finland", "Финска");
+ // EN:G MK:Г
+ Add(Ctr, 51.17, 10.45, "Germany", "Германија");
+ Add(Ctr, 39.07, 21.82, "Greece", "Грција");
+ Add(Ctr, 42.32, 43.36, "Georgia", "Грузија");
+ // EN:H MK:У (Hungary → Унгарија — great EN:H / MK:У pair!)
+ Add(Ctr, 47.16, 19.50, "Hungary", "Унгарија");
+ // EN:I MK:И
+ Add(Ctr, 20.59, 78.96, "India", "Индија");
+ Add(Ctr, 41.87, 12.57, "Italy", "Италија");
+ Add(Ctr, 53.41, -8.24, "Ireland", "Ирска");
+ // EN:J MK:Ј
+ Add(Ctr, 36.20, 138.25, "Japan", "Јапонија");
+ Add(Ctr, 31.24, 36.51, "Jordan", "Јордан");
+ // EN:K MK:К extra
+ Add(Ctr, -1.29, 36.82, "Kenya", "Кенија");
+ Add(Ctr, 42.60, 21.04, "Kosovo", "Косово");
+ // EN:L MK:Л
+ Add(Ctr, 56.88, 24.60, "Latvia", "Летонија");
+ Add(Ctr, 55.17, 23.88, "Lithuania", "Литванија");
+ Add(Ctr, 47.81, 2.10, "Luxembourg", "Луксембург");
+ // EN:M MK:М
+ Add(Ctr, 31.79, -7.09, "Morocco", "Мароко");
+ Add(Ctr, 23.63,-102.55, "Mexico", "Мексико");
+ // EN:M MK:Ц (Montenegro → Црна Гора)
+ Add(Ctr, 42.71, 19.37, "Montenegro", "Црна Гора");
+ // EN:N MK:Н
+ Add(Ctr, 60.47, 8.47, "Norway", "Норвешка");
+ Add(Ctr, 9.08, 8.68, "Nigeria", "Нигерија");
+ // EN:N MK:М extra (North Macedonia → Македонија)
+ Add(Ctr, 41.61, 21.75, "North Macedonia","Македонија");
+ // EN:O MK:О
+ Add(Ctr, 21.51, 55.92, "Oman", "Оман");
+ // EN:P MK:П
+ Add(Ctr, 39.40, -8.22, "Portugal", "Португалија");
+ Add(Ctr, 30.38, 69.35, "Pakistan", "Пакистан");
+ Add(Ctr, 51.92, 19.15, "Poland", "Полска");
+ // EN:Q MK:К extra (Qatar → Катар)
+ Add(Ctr, 25.35, 51.18, "Qatar", "Катар");
+ // EN:R MK:Р
+ Add(Ctr, 45.94, 24.97, "Romania", "Романија");
+ Add(Ctr, 61.52, 105.32, "Russia", "Русија");
+ // EN:S MK:С
+ Add(Ctr, 44.02, 21.09, "Serbia", "Србија");
+ Add(Ctr, 46.15, 14.99, "Slovenia", "Словенија");
+ // EN:S MK:Ш (Spain → Шпанија)
+ Add(Ctr, 40.46, -3.75, "Spain", "Шпанија");
+ // EN:T MK:Т
+ Add(Ctr, 38.96, 35.24, "Turkey", "Турција");
+ Add(Ctr, 33.89, 9.54, "Tunisia", "Тунис");
+ Add(Ctr, -6.37, 34.89, "Tanzania", "Танзанија");
+ // EN:U MK:У extra
+ Add(Ctr, 49.00, 31.39, "Ukraine", "Украина");
+ Add(Ctr, 1.37, 32.29, "Uganda", "Уганда");
+ // EN:V MK:В
+ Add(Ctr, 14.06, 108.28, "Vietnam", "Виетнам");
+ // EN:W — documented gap (no universally recognised sovereign state)
+ // EN:X — documented gap (no UN member)
+ // EN:Y MK:Ј extra
+ Add(Ctr, 15.55, 48.52, "Yemen", "Јемен");
+ // EN:Z MK:З
+ Add(Ctr, -19.02, 29.15, "Zimbabwe", "Зимбабве");
+ Add(Ctr, -13.13, 27.85, "Zambia", "Замбија");
+ // MK extra countries to improve coverage
+ Add(Ctr, 47.52, 14.55, null, "Австрија"); // MK:А extra (Austria)
+ Add(Ctr, 22.35, 114.14, null, "Хонг Конг"); // MK:Х extra
+ Add(Ctr, -16.29, -63.59, null, "Боливија"); // MK:Б extra (Bolivia)
+ Add(Ctr, 12.35, -1.56, null, "Буркина Фасо"); // MK:Б extra
+ Add(Ctr, 12.86, 30.22, null, "Судан"); // MK:С extra (Sudan)
+ Add(Ctr, -24.69, 25.91, null, "Боцвана"); // MK:Б extra
+ Add(Ctr, 1.35, 103.82, null, "Сингапур"); // MK:С extra (Singapore)
+ // MK:Ж — documented gap
+ // MK:Ѓ — documented gap
+ // MK:Ѕ — documented gap
+ // MK:Њ — documented gap (New Zealand = Нов Зеланд starts with Н)
+ // MK:Ќ — documented gap
+
+ // ── RIVERS ──────────────────────────────────────────────────────
+ // EN:A MK:А
+ Add(Riv, -3.47, -58.48, "Amazon", "Амазон");
+ Add(Riv, 47.91, 106.89, null, "Амур"); // MK:А extra
+ // EN:B MK:Б
+ Add(Riv, 26.10, 90.00, "Brahmaputra", "Брахмапутра");
+ Add(Riv, 49.83, 24.03, null, "Буг"); // MK:Б extra
+ // EN:C MK:К (Congo → Конго)
+ Add(Riv, -4.32, 15.32, "Congo", "Конго");
+ Add(Riv, 36.20, 36.16, "Ceyhan", null); // EN:C extra
+ // EN:D MK:Д
+ Add(Riv, 45.77, 29.70, "Danube", "Дунав");
+ Add(Riv, 48.46, 39.99, null, "Дон"); // MK:Д extra
+ // EN:E MK:Е
+ Add(Riv, 35.73, 38.63, "Euphrates", "Евфрат");
+ // EN:F MK:Ф
+ Add(Riv, 49.27,-123.15, "Fraser", "Фрејзер");
+ // EN:G MK:Г
+ Add(Riv, 23.48, 87.32, "Ganges", "Ганг");
+ // EN:H MK:Х (Hudson → Хадсон)
+ Add(Riv, 40.70, -74.00, "Hudson", "Хадсон");
+ // EN:I MK:И
+ Add(Riv, 24.09, 67.47, "Indus", "Инд");
+ // EN:J MK:Ј
+ Add(Riv, 31.47, 35.56, "Jordan", "Јордан");
+ // EN:K MK:К extra
+ Add(Riv, 10.82, 79.00, "Kaveri", "Кавери");
+ // EN:L MK:Л
+ Add(Riv, 72.52, 126.95, "Lena", "Лена");
+ // EN:M MK:М
+ Add(Riv, 29.15, -89.25, "Mississippi", "Мисисипи");
+ Add(Riv, 15.60, 105.87, null, "Меконг"); // MK:М extra
+ // EN:N MK:Н
+ Add(Riv, 30.16, 31.09, "Nile", "Нил");
+ // EN:O MK:О
+ Add(Riv, 66.69, 69.12, "Ob", "Об");
+ // EN:P MK:П
+ Add(Riv, -25.29, -57.63, "Parana", "Парана");
+ Add(Riv, 45.65, 13.77, "Po", "По");
+ // EN:Q MK nothing
+ Add(Riv, 30.27, 120.17, "Qiantang", null);
+ // EN:R MK:Р
+ Add(Riv, 51.97, 4.12, "Rhine", "Рајна");
+ // EN:S MK:С
+ Add(Riv, 49.44, 0.15, "Seine", "Сена");
+ Add(Riv, 44.84, 20.44, "Sava", "Сава");
+ // EN:T MK:Т
+ Add(Riv, 51.50, -0.13, "Thames", "Темза");
+ Add(Riv, 38.71, -9.14, "Tagus", "Тахо");
+ // EN:U MK:У
+ Add(Riv, 51.23, 51.34, "Ural", "Урал");
+ // EN:V MK:В (Vardar → Вардар; major Macedonian river)
+ Add(Riv, 40.35, 22.78, "Vardar", "Вардар");
+ Add(Riv, 45.79, 47.95, "Volga", "Волга");
+ // EN:W MK:В extra
+ Add(Riv, 53.54, 8.57, "Weser", null);
+ // EN:X MK nothing
+ Add(Riv, -1.52, -51.95, "Xingu", null);
+ // EN:Y MK:Ж (Yellow River → Жолта Река)
+ Add(Riv, 37.82, 119.18, "Yangtze", null);
+ Add(Riv, 37.82, 119.18, "Yellow", "Жолта Река"); // EN:Y extra; MK:Ж
+ // EN:Z MK:З
+ Add(Riv, -17.88, 25.26, "Zambezi", "Замбези");
+ // MK-only rivers
+ Add(Riv, 42.07, 21.47, null, "Пчиња"); // MK:П extra (Macedonian river)
+ Add(Riv, 41.55, 21.77, null, "Треска"); // MK:Т extra (Macedonian river)
+ Add(Riv, 42.10, 21.93, null, "Брегалница"); // MK:Б extra (Macedonian river)
+ Add(Riv, 41.00, 22.50, null, "Цена"); // MK:Ц (small river)
+ Add(Riv, 41.95, 20.47, null, "Дрим"); // MK:Д extra (Drim/Drin river)
+ Add(Riv, 51.92, 19.15, null, "Висла"); // MK:В extra (Vistula)
+ Add(Riv, 59.95, 30.32, null, "Нева"); // MK:Н extra (Neva)
+ Add(Riv, 65.37, 25.44, null, "Оулу"); // MK:О extra (Oulu river Finland)
+ Add(Riv, -9.64, 34.18, null, "Лимпопо"); // MK:Л extra
+ Add(Riv, 14.32, -9.19, null, "Сенегал"); // MK:С extra (Senegal river)
+ Add(Riv, 13.46, 2.11, null, "Нигер"); // MK:Н extra
+ Add(Riv, 13.45, 100.57, null, "Чао Праја"); // MK:Ч (Chao Phraya)
+ // MK:Ѓ — documented gap
+ // MK:Ѕ — documented gap
+ // MK:Ќ — documented gap
+ // MK:Љ — documented gap (no commonly-known river)
+ // MK:Њ — documented gap
+ // MK:Ш — documented gap
+ // MK:Џ — documented gap
+
+ // ── MOUNTAINS ───────────────────────────────────────────────────
+ // EN:A MK:А
+ Add(Mtn, 46.83, 9.93, "Alps", "Алпи");
+ Add(Mtn, -32.65, -70.01, "Aconcagua", "Аконкагуа");
+ Add(Mtn, -16.00, -68.00, null, "Анди"); // MK:А extra (Andes)
+ // EN:B MK:Б
+ Add(Mtn, 56.80, -5.00, "Ben Nevis", "Бен Невис");
+ // EN:C MK:К (Chimborazo → Чимборасо; EN:C but MK:Ч — different!)
+ Add(Mtn, -1.47, -78.82, "Chimborazo", "Чимборасо"); // EN:C MK:Ч
+ Add(Mtn, 39.72, 44.28, null, "Кавказ"); // MK:К (Caucasus)
+ // EN:D MK:Д
+ Add(Mtn, 63.07,-151.00, "Denali", "Денали");
+ // EN:E MK:Е
+ Add(Mtn, 27.99, 86.93, "Everest", "Еверест");
+ Add(Mtn, 43.35, 42.45, "Elbrus", "Елбрус");
+ // EN:F MK:Ф
+ Add(Mtn, 35.36, 138.73, "Fuji", "Фуџи");
+ // EN:G MK:Г (Grossglockner → Гросглокнер)
+ Add(Mtn, 47.07, 12.69, "Grossglockner", "Гросглокнер");
+ // EN:H MK:Х
+ Add(Mtn, -9.12, -77.61, "Huascaran", "Хуаскаран");
+ // EN:I MK:И
+ Add(Mtn, -16.64, -67.78, "Illimani", "Илимани");
+ // EN:J MK:Ј
+ Add(Mtn, 46.54, 7.96, "Jungfrau", "Јунгфрау");
+ // EN:K MK:К extra
+ Add(Mtn, -3.07, 37.35, "Kilimanjaro", "Килиманџаро");
+ // EN:L MK:Л
+ Add(Mtn, 60.57,-140.40, "Logan", "Логан");
+ // EN:M MK:М
+ Add(Mtn, 45.98, 7.66, "Matterhorn", "Матерхорн");
+ Add(Mtn, 45.83, 6.87, "Mont Blanc", "Монблан");
+ // EN:N MK:Н
+ Add(Mtn, 35.24, 74.59, "Nanga Parbat", "Нанга Парбат");
+ // EN:O MK:О
+ Add(Mtn, 40.09, 22.36, "Olympus", "Олимп");
+ // EN:P MK:П
+ Add(Mtn, 38.47, -28.40, "Pico", "Пико");
+ Add(Mtn, 42.62, 1.08, "Pyrenees", "Пиринеи");
+ // EN:Q MK nothing
+ Add(Mtn, 38.33, 100.17, "Qilian", null);
+ // EN:R MK:Р
+ Add(Mtn, 46.85,-121.73, "Rainier", "Рајнир");
+ // EN:S MK:Ш (Snowdon; Šar/Шар is the great Macedonian range)
+ Add(Mtn, 53.07, -4.08, "Snowdon", null);
+ Add(Mtn, 42.15, 21.00, "Sar", "Шар Планина"); // EN:S MK:Ш
+ // EN:T MK:Т
+ Add(Mtn, -33.96, 18.40, "Table Mountain", "Трпезаста Планина");
+ // EN:U MK:У
+ Add(Mtn, 40.11, 29.22, "Uludag", "Улудаг");
+ // EN:V MK:В
+ Add(Mtn, 40.82, 14.43, "Vesuvius", "Везув");
+ Add(Mtn, -78.54, -85.62, "Vinson", "Винсон");
+ // EN:W MK:В extra
+ Add(Mtn, 36.58,-118.29, "Whitney", null);
+ // EN:X MK nothing
+ Add(Mtn, 30.48, 103.56, "Xuebaoding", null);
+ // EN:Y MK:Ј extra
+ Add(Mtn, 10.27, -76.90, "Yerupaja", "Јерупаха");
+ // EN:Z MK:З extra
+ Add(Mtn, 47.42, 10.99, "Zugspitze", "Цугшпице"); // EN:Z MK:Ц extra
+ Add(Mtn, 42.16, 21.28, null, "Јакупица"); // MK:Ј extra (highest in MK)
+ Add(Mtn, 41.76, 22.88, null, "Беласица"); // MK:Б extra (Macedonian mountain)
+ Add(Mtn, 41.97, 20.73, null, "Стогово"); // MK:С extra (Macedonian mountain)
+ Add(Mtn, 41.67, 20.80, null, "Галичица"); // MK:Г extra (Macedonian mountain)
+ Add(Mtn, 42.09, 22.37, null, "Осогово"); // MK:О extra (Macedonian mountain)
+ Add(Mtn, 41.40, 21.68, null, "Козјак"); // MK:К extra (Macedonian mountain)
+ Add(Mtn, 41.60, 20.57, null, "Дешат"); // MK:Д extra (Macedonian mountain)
+ Add(Mtn, 41.78, 22.40, null, "Плачковица"); // MK:П extra (Macedonian mountain)
+ Add(Mtn, 41.75, 21.73, null, "Водно"); // MK:В extra (hill above Skopje)
+ Add(Mtn, 41.86, 22.50, null, "Малешевски Планини"); // MK:М extra
+ Add(Mtn, 41.07, 21.35, null, "Нидже"); // MK:Н extra (on MK-GR border)
+ Add(Mtn, 41.33, 21.75, null, "Тито Врв"); // MK:Т extra (peak in Šar range)
+ Add(Mtn, 41.87, 21.98, null, "Лисец"); // MK:Л extra (peak)
+ Add(Mtn, 42.26, 22.08, null, "Руен"); // MK:Р extra (highest in Osogovo)
+ Add(Mtn, 41.60, 20.70, null, "Китка"); // MK:К extra (peak near Skopje)
+ // MK:Ж — documented gap
+ // MK:З — documented gap
+ // MK:Ѓ — documented gap
+ // MK:Ѕ — documented gap
+ // MK:Ќ — documented gap
+ // MK:Љ — documented gap
+ // MK:Њ — documented gap
+ // MK:Џ — documented gap
+ // MK:Ш — covered by Шар Планина
+
+ return list.AsReadOnly();
+ }
+}
diff --git a/src/FastGeography.Server/FastGeography.Server.csproj b/src/FastGeography.Server/FastGeography.Server.csproj
index 23ea75e..e45ca38 100644
--- a/src/FastGeography.Server/FastGeography.Server.csproj
+++ b/src/FastGeography.Server/FastGeography.Server.csproj
@@ -4,10 +4,24 @@
net8.0
enable
enable
+ FastGeography-Server
+
+
+
+
+ runtime; build; native; contentfiles; analyzers; buildtransitive
+ all
+
+
diff --git a/src/FastGeography.Server/Hubs/GameHub.cs b/src/FastGeography.Server/Hubs/GameHub.cs
new file mode 100644
index 0000000..43a4791
--- /dev/null
+++ b/src/FastGeography.Server/Hubs/GameHub.cs
@@ -0,0 +1,372 @@
+namespace FastGeography.Server.Hubs;
+
+using System.Security.Claims;
+
+using FastGeography.Server.Data;
+using FastGeography.Server.Data.Entities;
+using FastGeography.Server.Services;
+using FastGeography.Shared;
+using FastGeography.Shared.Dtos;
+
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.SignalR;
+using Microsoft.EntityFrameworkCore;
+
+[Authorize]
+public sealed class GameHub : Hub
+{
+ private readonly IRoomService _roomService;
+ private readonly IGeocodingService _geocodingService;
+ private readonly ApplicationDbContext _db;
+ private readonly ILogger _logger;
+
+ public GameHub(
+ IRoomService roomService,
+ IGeocodingService geocodingService,
+ ApplicationDbContext db,
+ ILogger logger)
+ {
+ _roomService = roomService;
+ _geocodingService = geocodingService;
+ _db = db;
+ _logger = logger;
+ }
+
+ // ── Connection lifecycle ────────────────────────────────────────────────
+
+ public override async Task OnDisconnectedAsync(Exception? exception)
+ {
+ var userId = UserId();
+ if (userId is not null)
+ {
+ var room = _roomService.FindRoomByConnection(Context.ConnectionId);
+ if (room is not null)
+ {
+ var displayName = room.Players.TryGetValue(userId, out var n) ? n : null;
+ bool wasHost = room.HostUserId == userId;
+ string roomCode = room.Code;
+
+ _roomService.Leave(userId, Context.ConnectionId);
+
+ if (displayName is not null && _roomService.GetRoom(roomCode) is { } updatedRoom)
+ await NotifyLeaveAsync(GroupKey(roomCode), updatedRoom, displayName, wasHost);
+ }
+ else
+ {
+ _roomService.Leave(userId, Context.ConnectionId);
+ }
+ }
+
+ await base.OnDisconnectedAsync(exception);
+ }
+
+ // ── Hub methods (client → server) ──────────────────────────────────────
+
+ public async Task JoinRoom(string roomCode)
+ {
+ var userId = UserId();
+ if (userId is null) { await SendError("Not authenticated."); return; }
+
+ var displayName = DisplayName();
+ var joined = _roomService.TryJoin(roomCode, userId, displayName, Context.ConnectionId);
+
+ if (!joined) { await SendError($"Room '{roomCode}' not found."); return; }
+
+ await Groups.AddToGroupAsync(Context.ConnectionId, GroupKey(roomCode));
+
+ var room = _roomService.GetRoom(roomCode)!;
+ var players = room.Players
+ .Select(kv => new RoomPlayerDto(kv.Key, kv.Value))
+ .ToList();
+ var hostName = room.Players.TryGetValue(room.HostUserId, out var h) ? h : "Host";
+ var myHistory = room.PlayerSetHistory.TryGetValue(userId, out var hist) ? hist : [];
+
+ await Clients.Caller.SendAsync("RoomJoined", new RoomStateDto(
+ roomCode,
+ players,
+ hostName,
+ room.RoundActive,
+ room.RoundsCompletedInSet,
+ room.SetComplete,
+ myHistory,
+ room.LanguageCode));
+
+ await Clients.OthersInGroup(GroupKey(roomCode))
+ .SendAsync("PlayerJoined", new RoomPlayerDto(userId, displayName));
+ }
+
+ public async Task LeaveRoom(string roomCode)
+ {
+ var userId = UserId();
+ if (userId is null) return;
+
+ var room = _roomService.GetRoom(roomCode);
+ if (room is null) return;
+
+ var displayName = room.Players.TryGetValue(userId, out var n) ? n : null;
+ bool wasHost = room.HostUserId == userId;
+
+ _roomService.Leave(userId, Context.ConnectionId);
+ await Groups.RemoveFromGroupAsync(Context.ConnectionId, GroupKey(roomCode));
+
+ if (displayName is not null && _roomService.GetRoom(roomCode) is { } updatedRoom)
+ await NotifyLeaveAsync(GroupKey(roomCode), updatedRoom, displayName, wasHost);
+
+ await Clients.Caller.SendAsync("LeftRoom");
+ }
+
+ public async Task StartRound(string roomCode)
+ {
+ var userId = UserId();
+ var room = _roomService.GetRoom(roomCode);
+
+ if (room is null) { await SendError("Room not found."); return; }
+ if (room.HostUserId != userId) { await SendError("Only the host can start a round."); return; }
+ if (room.RoundActive) { await SendError("A round is already active."); return; }
+ if (room.Players.Count < 1) { await SendError("Need at least one player."); return; }
+ if (room.SetComplete) { await SendError("Set complete. Start a new set first."); return; }
+
+ var language = GameLanguageExtensions.Parse(room.LanguageCode);
+ var letter = Alphabet.RandomLetter(language);
+ var endsAt = DateTime.UtcNow.AddSeconds(ScoringRules.DefaultTimerSeconds);
+ var roundNumber = room.RoundsCompletedInSet + 1;
+
+ room.CurrentLetter = letter;
+ room.RoundEndsAt = endsAt;
+ room.RoundActive = true;
+ room.Submissions.Clear();
+ room.RoundTimerCts?.Cancel();
+ room.RoundTimerCts = new CancellationTokenSource();
+
+ await Clients.Group(GroupKey(roomCode))
+ .SendAsync("RoundStarted", new RoundStartedMessage(letter, endsAt, roundNumber));
+
+ _ = AutoScoreAfterDeadlineAsync(roomCode, room.RoundTimerCts.Token);
+ }
+
+ public async Task StartNewSet(string roomCode)
+ {
+ var userId = UserId();
+ var room = _roomService.GetRoom(roomCode);
+
+ if (room is null) { await SendError("Room not found."); return; }
+ if (room.HostUserId != userId) { await SendError("Only the host can start a new set."); return; }
+ if (room.RoundActive) { await SendError("A round is still active."); return; }
+ if (!room.SetComplete) { await SendError("Set is not yet complete."); return; }
+
+ room.RoundsCompletedInSet = 0;
+ room.PlayerSetHistory.Clear();
+
+ await Clients.Group(GroupKey(roomCode)).SendAsync("NewSetStarted");
+ }
+
+ public async Task SubmitAnswers(string roomCode, SubmitAnswersRequest answers)
+ {
+ var userId = UserId();
+ var room = _roomService.GetRoom(roomCode);
+
+ if (room is null || !room.RoundActive) { await SendError("No active round."); return; }
+ if (userId is null) { await SendError("Not authenticated."); return; }
+
+ if (room.Submissions.ContainsKey(userId))
+ {
+ await SendError("Already submitted.");
+ return;
+ }
+
+ room.Submissions[userId] = answers;
+ await Clients.Caller.SendAsync("AnswersAccepted");
+
+ if (room.Submissions.Count >= room.Players.Count)
+ {
+ await FinalizeRoundAsync(roomCode);
+ }
+ }
+
+ // ── Private helpers ────────────────────────────────────────────────────
+
+ private async Task NotifyLeaveAsync(
+ string groupKey, GameRoom room, string displayName, bool wasHost)
+ {
+ await Clients.Group(groupKey).SendAsync("PlayerLeft", displayName);
+
+ if (wasHost && room.Players.Count > 0)
+ {
+ var newHostId = room.Players.Keys.First();
+ room.HostUserId = newHostId;
+ var newHostName = room.Players[newHostId];
+ await Clients.Group(groupKey).SendAsync("HostChanged", newHostName);
+ }
+ }
+
+ private async Task AutoScoreAfterDeadlineAsync(string roomCode, CancellationToken ct)
+ {
+ try
+ {
+ await Task.Delay(
+ TimeSpan.FromSeconds(ScoringRules.DefaultTimerSeconds + 5), ct);
+
+ if (!ct.IsCancellationRequested)
+ await FinalizeRoundAsync(roomCode);
+ }
+ catch (TaskCanceledException) { }
+ }
+
+ private async Task FinalizeRoundAsync(string roomCode)
+ {
+ var room = _roomService.GetRoom(roomCode);
+ if (room is null || !room.RoundActive) return;
+
+ room.RoundActive = false;
+ room.RoundTimerCts?.Cancel();
+
+ var letter = room.CurrentLetter!.Value;
+ var language = GameLanguageExtensions.Parse(room.LanguageCode);
+
+ var scoringTasks = room.Submissions
+ .ToDictionary(
+ kv => kv.Key,
+ kv => ScoreSubmissionAsync(letter, language, (SubmitAnswersRequest)kv.Value));
+
+ await Task.WhenAll(scoringTasks.Values);
+
+ var rawResults = scoringTasks.Select(kv => (
+ UserId: kv.Key,
+ Details: kv.Value.Result,
+ Total: kv.Value.Result.Sum(d => d.Points)
+ )).ToList();
+
+ var ranked = rawResults.OrderByDescending(r => r.Total).ToList();
+ var playerResults = new List();
+
+ for (int i = 0; i < ranked.Count; i++)
+ {
+ var entry = ranked[i];
+ var playerName = room.Players.TryGetValue(entry.UserId, out var n) ? n : "Player";
+ playerResults.Add(new PlayerRoundResult(entry.UserId, playerName, entry.Total, i + 1, entry.Details));
+ }
+
+ // Store per-player row for the set history
+ foreach (var entry in ranked)
+ {
+ var row = new CompletedRoundRow(letter, entry.Details);
+ room.PlayerSetHistory.AddOrUpdate(
+ entry.UserId,
+ _ => [row],
+ (_, existing) => { existing.Add(row); return existing; });
+ }
+
+ room.RoundsCompletedInSet++;
+
+ await Clients.Group(GroupKey(roomCode))
+ .SendAsync("RoundResults", new RoundResultsMessage(
+ playerResults,
+ room.RoundsCompletedInSet,
+ room.SetComplete));
+
+ await PersistMultiplayerRoundAsync(roomCode, ranked, letter, room.LanguageCode);
+ }
+
+ private async Task> ScoreSubmissionAsync(
+ char letter, GameLanguage language, SubmitAnswersRequest req)
+ {
+ var tasks = new[]
+ {
+ ValidateOneAsync(LocationType.City, req.City, letter, language),
+ ValidateOneAsync(LocationType.Village, req.Village, letter, language),
+ ValidateOneAsync(LocationType.Country, req.Country, letter, language),
+ ValidateOneAsync(LocationType.River, req.River, letter, language),
+ ValidateOneAsync(LocationType.Mountain, req.Mountain, letter, language),
+ };
+
+ await Task.WhenAll(tasks);
+ return tasks.Select(t => t.Result).ToList();
+ }
+
+ private async Task ValidateOneAsync(
+ LocationType type, string? answer, char letter, GameLanguage language)
+ {
+ if (string.IsNullOrWhiteSpace(answer))
+ return new LocationResult(type, answer, ScoringRules.EmptyPoints, null);
+
+ if (!Alphabet.StartsWithLetter(answer, letter))
+ return new LocationResult(type, answer, ScoringRules.WrongLetterPoints, null);
+
+ var result = await _geocodingService.ValidateAsync(answer, type, language);
+ return new LocationResult(type, answer, result.Points, result.Coordinates);
+ }
+
+ private async Task PersistMultiplayerRoundAsync(
+ string roomCode,
+ List<(string UserId, List Details, int Total)> ranked,
+ char letter,
+ string languageCode)
+ {
+ try
+ {
+ var round = new GameRound
+ {
+ Id = Guid.NewGuid(),
+ Mode = GameMode.Multiplayer,
+ Letter = letter,
+ LanguageCode = languageCode,
+ StartedAt = DateTime.UtcNow - TimeSpan.FromSeconds(ScoringRules.DefaultTimerSeconds),
+ EndsAt = DateTime.UtcNow,
+ RoomCode = roomCode
+ };
+ _db.GameRounds.Add(round);
+
+ for (int i = 0; i < ranked.Count; i++)
+ {
+ var entry = ranked[i];
+ var details = entry.Details;
+ int P(LocationType t) => details.FirstOrDefault(d => d.Type == t)?.Points ?? 0;
+ string? A(LocationType t) => details.FirstOrDefault(d => d.Type == t)?.Answer;
+
+ _db.RoundSubmissions.Add(new RoundSubmission
+ {
+ Id = Guid.NewGuid(),
+ RoundId = round.Id,
+ UserId = entry.UserId,
+ CityAnswer = A(LocationType.City),
+ VillageAnswer = A(LocationType.Village),
+ CountryAnswer = A(LocationType.Country),
+ RiverAnswer = A(LocationType.River),
+ MountainAnswer = A(LocationType.Mountain),
+ CityPoints = P(LocationType.City),
+ VillagePoints = P(LocationType.Village),
+ CountryPoints = P(LocationType.Country),
+ RiverPoints = P(LocationType.River),
+ MountainPoints = P(LocationType.Mountain),
+ RankInRound = i + 1
+ });
+
+ var profile = await _db.PlayerProfiles.FirstOrDefaultAsync(p => p.UserId == entry.UserId);
+ if (profile is not null)
+ {
+ profile.CareerPoints += entry.Total;
+ profile.GamesPlayed++;
+ }
+ }
+
+ await _db.SaveChangesAsync();
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError(ex, "Failed to persist multiplayer round for room {RoomCode}", roomCode);
+ }
+ }
+
+ private string? UserId() => Context.User?.FindFirstValue(ClaimTypes.NameIdentifier);
+
+ private string DisplayName() =>
+ Context.User?.FindFirstValue("display_name")
+ ?? Context.User?.FindFirstValue(ClaimTypes.Name)
+ ?? Context.User?.FindFirstValue(ClaimTypes.Email)
+ ?? "Player";
+
+ private static string GroupKey(string roomCode) => $"room:{roomCode.ToUpperInvariant()}";
+
+ private async Task SendError(string message) =>
+ await Clients.Caller.SendAsync("Error", message);
+}
diff --git a/src/FastGeography.Server/Migrations/20260828172459_InitialSchema.Designer.cs b/src/FastGeography.Server/Migrations/20260828172459_InitialSchema.Designer.cs
new file mode 100644
index 0000000..49301a3
--- /dev/null
+++ b/src/FastGeography.Server/Migrations/20260828172459_InitialSchema.Designer.cs
@@ -0,0 +1,470 @@
+// ("Id")
+ .HasColumnType("text");
+
+ b.Property("AccessFailedCount")
+ .HasColumnType("integer");
+
+ b.Property("ConcurrencyStamp")
+ .IsConcurrencyToken()
+ .HasColumnType("text");
+
+ b.Property("DisplayName")
+ .IsRequired()
+ .HasColumnType("text");
+
+ b.Property("Email")
+ .HasMaxLength(256)
+ .HasColumnType("character varying(256)");
+
+ b.Property("EmailConfirmed")
+ .HasColumnType("boolean");
+
+ b.Property("LockoutEnabled")
+ .HasColumnType("boolean");
+
+ b.Property("LockoutEnd")
+ .HasColumnType("timestamp with time zone");
+
+ b.Property("NormalizedEmail")
+ .HasMaxLength(256)
+ .HasColumnType("character varying(256)");
+
+ b.Property("NormalizedUserName")
+ .HasMaxLength(256)
+ .HasColumnType("character varying(256)");
+
+ b.Property("PasswordHash")
+ .HasColumnType("text");
+
+ b.Property("PhoneNumber")
+ .HasColumnType("text");
+
+ b.Property("PhoneNumberConfirmed")
+ .HasColumnType("boolean");
+
+ b.Property("SecurityStamp")
+ .HasColumnType("text");
+
+ b.Property("TwoFactorEnabled")
+ .HasColumnType("boolean");
+
+ b.Property("UserName")
+ .HasMaxLength(256)
+ .HasColumnType("character varying(256)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("NormalizedEmail")
+ .HasDatabaseName("EmailIndex");
+
+ b.HasIndex("NormalizedUserName")
+ .IsUnique()
+ .HasDatabaseName("UserNameIndex");
+
+ b.ToTable("AspNetUsers", (string)null);
+ });
+
+ modelBuilder.Entity("FastGeography.Server.Data.Entities.GameRound", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("uuid");
+
+ b.Property("EndsAt")
+ .HasColumnType("timestamp with time zone");
+
+ b.Property("Letter")
+ .HasColumnType("char(1)");
+
+ b.Property("Mode")
+ .HasColumnType("integer");
+
+ b.Property("RoomCode")
+ .HasColumnType("text");
+
+ b.Property("StartedAt")
+ .HasColumnType("timestamp with time zone");
+
+ b.HasKey("Id");
+
+ b.ToTable("GameRounds");
+ });
+
+ modelBuilder.Entity("FastGeography.Server.Data.Entities.PlayerProfile", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("uuid");
+
+ b.Property("CareerPoints")
+ .HasColumnType("integer");
+
+ b.Property("GamesPlayed")
+ .HasColumnType("integer");
+
+ b.Property("UserId")
+ .IsRequired()
+ .HasColumnType("text");
+
+ b.HasKey("Id");
+
+ b.HasIndex("UserId")
+ .IsUnique();
+
+ b.ToTable("PlayerProfiles");
+ });
+
+ modelBuilder.Entity("FastGeography.Server.Data.Entities.RoundSubmission", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("uuid");
+
+ b.Property("CityAnswer")
+ .HasColumnType("text");
+
+ b.Property("CityPoints")
+ .HasColumnType("integer");
+
+ b.Property("CountryAnswer")
+ .HasColumnType("text");
+
+ b.Property("CountryPoints")
+ .HasColumnType("integer");
+
+ b.Property("MountainAnswer")
+ .HasColumnType("text");
+
+ b.Property("MountainPoints")
+ .HasColumnType("integer");
+
+ b.Property("RankInRound")
+ .HasColumnType("integer");
+
+ b.Property("RiverAnswer")
+ .HasColumnType("text");
+
+ b.Property("RiverPoints")
+ .HasColumnType("integer");
+
+ b.Property("RoundId")
+ .HasColumnType("uuid");
+
+ b.Property("SecondsPlayed")
+ .HasColumnType("integer");
+
+ b.Property("UserId")
+ .IsRequired()
+ .HasColumnType("text");
+
+ b.Property("VillageAnswer")
+ .HasColumnType("text");
+
+ b.Property("VillagePoints")
+ .HasColumnType("integer");
+
+ b.HasKey("Id");
+
+ b.HasIndex("RoundId");
+
+ b.HasIndex("UserId");
+
+ b.ToTable("RoundSubmissions");
+ });
+
+ modelBuilder.Entity("FastGeography.Server.Data.Entities.Toponym", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("uuid");
+
+ b.Property("Category")
+ .HasColumnType("integer");
+
+ b.Property("DisplayName")
+ .IsRequired()
+ .HasMaxLength(200)
+ .HasColumnType("character varying(200)");
+
+ b.Property("Latitude")
+ .HasColumnType("double precision");
+
+ b.Property("Longitude")
+ .HasColumnType("double precision");
+
+ b.Property("NormalizedName")
+ .IsRequired()
+ .HasMaxLength(200)
+ .HasColumnType("character varying(200)");
+
+ b.Property("Provider")
+ .IsRequired()
+ .HasMaxLength(50)
+ .HasColumnType("character varying(50)");
+
+ b.Property("VerifiedAtUtc")
+ .HasColumnType("timestamp with time zone");
+
+ b.HasKey("Id");
+
+ b.HasIndex("NormalizedName", "Category")
+ .IsUnique();
+
+ b.ToTable("Toponyms");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+ {
+ b.Property("Id")
+ .HasColumnType("text");
+
+ b.Property("ConcurrencyStamp")
+ .IsConcurrencyToken()
+ .HasColumnType("text");
+
+ b.Property("Name")
+ .HasMaxLength(256)
+ .HasColumnType("character varying(256)");
+
+ b.Property("NormalizedName")
+ .HasMaxLength(256)
+ .HasColumnType("character varying(256)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("NormalizedName")
+ .IsUnique()
+ .HasDatabaseName("RoleNameIndex");
+
+ b.ToTable("AspNetRoles", (string)null);
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("integer");
+
+ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("Id"));
+
+ b.Property("ClaimType")
+ .HasColumnType("text");
+
+ b.Property("ClaimValue")
+ .HasColumnType("text");
+
+ b.Property("RoleId")
+ .IsRequired()
+ .HasColumnType("text");
+
+ b.HasKey("Id");
+
+ b.HasIndex("RoleId");
+
+ b.ToTable("AspNetRoleClaims", (string)null);
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("integer");
+
+ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("Id"));
+
+ b.Property("ClaimType")
+ .HasColumnType("text");
+
+ b.Property("ClaimValue")
+ .HasColumnType("text");
+
+ b.Property("UserId")
+ .IsRequired()
+ .HasColumnType("text");
+
+ b.HasKey("Id");
+
+ b.HasIndex("UserId");
+
+ b.ToTable("AspNetUserClaims", (string)null);
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
+ {
+ b.Property("LoginProvider")
+ .HasColumnType("text");
+
+ b.Property("ProviderKey")
+ .HasColumnType("text");
+
+ b.Property("ProviderDisplayName")
+ .HasColumnType("text");
+
+ b.Property("UserId")
+ .IsRequired()
+ .HasColumnType("text");
+
+ b.HasKey("LoginProvider", "ProviderKey");
+
+ b.HasIndex("UserId");
+
+ b.ToTable("AspNetUserLogins", (string)null);
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b =>
+ {
+ b.Property("UserId")
+ .HasColumnType("text");
+
+ b.Property("RoleId")
+ .HasColumnType("text");
+
+ b.HasKey("UserId", "RoleId");
+
+ b.HasIndex("RoleId");
+
+ b.ToTable("AspNetUserRoles", (string)null);
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
+ {
+ b.Property("UserId")
+ .HasColumnType("text");
+
+ b.Property("LoginProvider")
+ .HasColumnType("text");
+
+ b.Property("Name")
+ .HasColumnType("text");
+
+ b.Property("Value")
+ .HasColumnType("text");
+
+ b.HasKey("UserId", "LoginProvider", "Name");
+
+ b.ToTable("AspNetUserTokens", (string)null);
+ });
+
+ modelBuilder.Entity("FastGeography.Server.Data.Entities.PlayerProfile", b =>
+ {
+ b.HasOne("FastGeography.Server.Data.ApplicationUser", "User")
+ .WithOne("Profile")
+ .HasForeignKey("FastGeography.Server.Data.Entities.PlayerProfile", "UserId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+
+ b.Navigation("User");
+ });
+
+ modelBuilder.Entity("FastGeography.Server.Data.Entities.RoundSubmission", b =>
+ {
+ b.HasOne("FastGeography.Server.Data.Entities.GameRound", "Round")
+ .WithMany("Submissions")
+ .HasForeignKey("RoundId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+
+ b.HasOne("FastGeography.Server.Data.ApplicationUser", "User")
+ .WithMany()
+ .HasForeignKey("UserId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+
+ b.Navigation("Round");
+
+ b.Navigation("User");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
+ {
+ b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+ .WithMany()
+ .HasForeignKey("RoleId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
+ {
+ b.HasOne("FastGeography.Server.Data.ApplicationUser", null)
+ .WithMany()
+ .HasForeignKey("UserId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
+ {
+ b.HasOne("FastGeography.Server.Data.ApplicationUser", null)
+ .WithMany()
+ .HasForeignKey("UserId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b =>
+ {
+ b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+ .WithMany()
+ .HasForeignKey("RoleId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+
+ b.HasOne("FastGeography.Server.Data.ApplicationUser", null)
+ .WithMany()
+ .HasForeignKey("UserId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
+ {
+ b.HasOne("FastGeography.Server.Data.ApplicationUser", null)
+ .WithMany()
+ .HasForeignKey("UserId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+
+ modelBuilder.Entity("FastGeography.Server.Data.ApplicationUser", b =>
+ {
+ b.Navigation("Profile");
+ });
+
+ modelBuilder.Entity("FastGeography.Server.Data.Entities.GameRound", b =>
+ {
+ b.Navigation("Submissions");
+ });
+#pragma warning restore 612, 618
+ }
+ }
+}
diff --git a/src/FastGeography.Server/Migrations/20260828172459_InitialSchema.cs b/src/FastGeography.Server/Migrations/20260828172459_InitialSchema.cs
new file mode 100644
index 0000000..d6bca5b
--- /dev/null
+++ b/src/FastGeography.Server/Migrations/20260828172459_InitialSchema.cs
@@ -0,0 +1,349 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace FastGeography.Server.Migrations
+{
+ /// (type: "text", nullable: false),
+ Name = table.Column(type: "character varying(256)", maxLength: 256, nullable: true),
+ NormalizedName = table.Column(type: "character varying(256)", maxLength: 256, nullable: true),
+ ConcurrencyStamp = table.Column(type: "text", nullable: true)
+ },
+ constraints: table =>
+ {
+ table.PrimaryKey("PK_AspNetRoles", x => x.Id);
+ });
+
+ migrationBuilder.CreateTable(
+ name: "AspNetUsers",
+ columns: table => new
+ {
+ Id = table.Column(type: "text", nullable: false),
+ DisplayName = table.Column(type: "text", nullable: false),
+ UserName = table.Column(type: "character varying(256)", maxLength: 256, nullable: true),
+ NormalizedUserName = table.Column(type: "character varying(256)", maxLength: 256, nullable: true),
+ Email = table.Column(type: "character varying(256)", maxLength: 256, nullable: true),
+ NormalizedEmail = table.Column(type: "character varying(256)", maxLength: 256, nullable: true),
+ EmailConfirmed = table.Column(type: "boolean", nullable: false),
+ PasswordHash = table.Column(type: "text", nullable: true),
+ SecurityStamp = table.Column(type: "text", nullable: true),
+ ConcurrencyStamp = table.Column(type: "text", nullable: true),
+ PhoneNumber = table.Column(type: "text", nullable: true),
+ PhoneNumberConfirmed = table.Column(type: "boolean", nullable: false),
+ TwoFactorEnabled = table.Column(type: "boolean", nullable: false),
+ LockoutEnd = table.Column(type: "timestamp with time zone", nullable: true),
+ LockoutEnabled = table.Column(type: "boolean", nullable: false),
+ AccessFailedCount = table.Column(type: "integer", nullable: false)
+ },
+ constraints: table =>
+ {
+ table.PrimaryKey("PK_AspNetUsers", x => x.Id);
+ });
+
+ migrationBuilder.CreateTable(
+ name: "GameRounds",
+ columns: table => new
+ {
+ Id = table.Column(type: "uuid", nullable: false),
+ Mode = table.Column(type: "integer", nullable: false),
+ Letter = table.Column(type: "char(1)", nullable: false),
+ StartedAt = table.Column(type: "timestamp with time zone", nullable: false),
+ EndsAt = table.Column(type: "timestamp with time zone", nullable: false),
+ RoomCode = table.Column(type: "text", nullable: true)
+ },
+ constraints: table =>
+ {
+ table.PrimaryKey("PK_GameRounds", x => x.Id);
+ });
+
+ migrationBuilder.CreateTable(
+ name: "Toponyms",
+ columns: table => new
+ {
+ Id = table.Column(type: "uuid", nullable: false),
+ NormalizedName = table.Column(type: "character varying(200)", maxLength: 200, nullable: false),
+ DisplayName = table.Column(type: "character varying(200)", maxLength: 200, nullable: false),
+ Category = table.Column(type: "integer", nullable: false),
+ Latitude = table.Column(type: "double precision", nullable: false),
+ Longitude = table.Column(type: "double precision", nullable: false),
+ Provider = table.Column(type: "character varying(50)", maxLength: 50, nullable: false),
+ VerifiedAtUtc = table.Column(type: "timestamp with time zone", nullable: false)
+ },
+ constraints: table =>
+ {
+ table.PrimaryKey("PK_Toponyms", x => x.Id);
+ });
+
+ migrationBuilder.CreateTable(
+ name: "AspNetRoleClaims",
+ columns: table => new
+ {
+ Id = table.Column(type: "integer", nullable: false)
+ .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+ RoleId = table.Column(type: "text", nullable: false),
+ ClaimType = table.Column(type: "text", nullable: true),
+ ClaimValue = table.Column(type: "text", nullable: true)
+ },
+ constraints: table =>
+ {
+ table.PrimaryKey("PK_AspNetRoleClaims", x => x.Id);
+ table.ForeignKey(
+ name: "FK_AspNetRoleClaims_AspNetRoles_RoleId",
+ column: x => x.RoleId,
+ principalTable: "AspNetRoles",
+ principalColumn: "Id",
+ onDelete: ReferentialAction.Cascade);
+ });
+
+ migrationBuilder.CreateTable(
+ name: "AspNetUserClaims",
+ columns: table => new
+ {
+ Id = table.Column(type: "integer", nullable: false)
+ .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+ UserId = table.Column(type: "text", nullable: false),
+ ClaimType = table.Column(type: "text", nullable: true),
+ ClaimValue = table.Column(type: "text", nullable: true)
+ },
+ constraints: table =>
+ {
+ table.PrimaryKey("PK_AspNetUserClaims", x => x.Id);
+ table.ForeignKey(
+ name: "FK_AspNetUserClaims_AspNetUsers_UserId",
+ column: x => x.UserId,
+ principalTable: "AspNetUsers",
+ principalColumn: "Id",
+ onDelete: ReferentialAction.Cascade);
+ });
+
+ migrationBuilder.CreateTable(
+ name: "AspNetUserLogins",
+ columns: table => new
+ {
+ LoginProvider = table.Column(type: "text", nullable: false),
+ ProviderKey = table.Column(type: "text", nullable: false),
+ ProviderDisplayName = table.Column(type: "text", nullable: true),
+ UserId = table.Column(type: "text", nullable: false)
+ },
+ constraints: table =>
+ {
+ table.PrimaryKey("PK_AspNetUserLogins", x => new { x.LoginProvider, x.ProviderKey });
+ table.ForeignKey(
+ name: "FK_AspNetUserLogins_AspNetUsers_UserId",
+ column: x => x.UserId,
+ principalTable: "AspNetUsers",
+ principalColumn: "Id",
+ onDelete: ReferentialAction.Cascade);
+ });
+
+ migrationBuilder.CreateTable(
+ name: "AspNetUserRoles",
+ columns: table => new
+ {
+ UserId = table.Column(type: "text", nullable: false),
+ RoleId = table.Column(type: "text", nullable: false)
+ },
+ constraints: table =>
+ {
+ table.PrimaryKey("PK_AspNetUserRoles", x => new { x.UserId, x.RoleId });
+ table.ForeignKey(
+ name: "FK_AspNetUserRoles_AspNetRoles_RoleId",
+ column: x => x.RoleId,
+ principalTable: "AspNetRoles",
+ principalColumn: "Id",
+ onDelete: ReferentialAction.Cascade);
+ table.ForeignKey(
+ name: "FK_AspNetUserRoles_AspNetUsers_UserId",
+ column: x => x.UserId,
+ principalTable: "AspNetUsers",
+ principalColumn: "Id",
+ onDelete: ReferentialAction.Cascade);
+ });
+
+ migrationBuilder.CreateTable(
+ name: "AspNetUserTokens",
+ columns: table => new
+ {
+ UserId = table.Column
-
- @Title
-
-
- Please take our
- brief survey
-
- and tell us what you think.
-
-
-@code {
- // Demonstrates how a parent component can supply parameters
- [Parameter]
- public string? Title { get; set; }
-}
diff --git a/src/FastGeography.Client/Shared/UserAvatar.razor b/src/FastGeography.Client/Shared/UserAvatar.razor
new file mode 100644
index 0000000..0b257cb
--- /dev/null
+++ b/src/FastGeography.Client/Shared/UserAvatar.razor
@@ -0,0 +1,26 @@
+@using FastGeography.Shared
+
+
+