Fixed some crashes in response strings source generator, reorganized more submodules into their folders

src/NadekoBot/Modules/Games/Hangman/DefaultHangmanSource.cs

@@ -0,0 +1,62 @@
+using NadekoBot.Common.Yml;
+using System.Diagnostics.CodeAnalysis;
+
+namespace NadekoBot.Modules.Games.Hangman;
+
+public sealed class DefaultHangmanSource : IHangmanSource
+{
+    private IReadOnlyDictionary<string, HangmanTerm[]> _terms = new Dictionary<string, HangmanTerm[]>();
+    private readonly Random _rng;
+
+    public DefaultHangmanSource()
+    {
+        _rng = new NadekoRandom();
+        Reload();
+    }
+
+    public void Reload()
+    {
+        if (!Directory.Exists("data/hangman"))
+        {
+            Log.Error("Hangman game won't work. Folder 'data/hangman' is missing.");
+            return;
+        }
+
+        var qs = new Dictionary<string, HangmanTerm[]>();
+        foreach (var file in Directory.EnumerateFiles("data/hangman/", "*.yml"))
+            try
+            {
+                var data = Yaml.Deserializer.Deserialize<HangmanTerm[]>(File.ReadAllText(file));
+                qs[Path.GetFileNameWithoutExtension(file).ToLowerInvariant()] = data;
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "Loading {HangmanFile} failed.", file);
+            }
+
+        _terms = qs;
+
+        Log.Information("Loaded {HangmanCategoryCount} hangman categories.", qs.Count);
+    }
+
+    public IReadOnlyCollection<string> GetCategories()
+        => _terms.Keys.ToList();
+
+    public bool GetTerm(string? category, [NotNullWhen(true)] out HangmanTerm? term)
+    {
+        if (category is null)
+        {
+            var cats = GetCategories();
+            category = cats.ElementAt(_rng.Next(0, cats.Count));
+        }
+
+        if (_terms.TryGetValue(category, out var terms))
+        {
+            term = terms[_rng.Next(0, terms.Length)];
+            return true;
+        }
+
+        term = null;
+        return false;
+    }
+}

src/NadekoBot/Modules/Games/Hangman/HangmanCommands.cs

@@ -0,0 +1,68 @@
+using NadekoBot.Modules.Games.Hangman;
+
+namespace NadekoBot.Modules.Games;
+
+public partial class Games
+{
+    [Group]
+    public partial class HangmanCommands : NadekoSubmodule<IHangmanService>
+    {
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        public async partial Task Hangmanlist()
+            => await SendConfirmAsync(GetText(strs.hangman_types(Prefix)), _service.GetHangmanTypes().Join('\n'));
+
+        private static string Draw(HangmanGame.State state)
+            => $@". ┌─────┐
+.┃...............┋
+.┃...............┋
+.┃{(state.Errors > 0 ? ".............😲" : "")}
+.┃{(state.Errors > 1 ? "............./" : "")} {(state.Errors > 2 ? "|" : "")} {(state.Errors > 3 ? "\\" : "")}
+.┃{(state.Errors > 4 ? "............../" : "")} {(state.Errors > 5 ? "\\" : "")}
+/-\";
+
+        public static IEmbedBuilder GetEmbed(IEmbedBuilderService eb, HangmanGame.State state)
+        {
+            if (state.Phase == HangmanGame.Phase.Running)
+                return eb.Create()
+                         .WithOkColor()
+                         .AddField("Hangman", Draw(state))
+                         .AddField("Guess", Format.Code(state.Word))
+                         .WithFooter(state.missedLetters.Join(' '));
+
+            if (state.Phase == HangmanGame.Phase.Ended && state.Failed)
+                return eb.Create()
+                         .WithErrorColor()
+                         .AddField("Hangman", Draw(state))
+                         .AddField("Guess", Format.Code(state.Word))
+                         .WithFooter(state.missedLetters.Join(' '));
+            return eb.Create()
+                     .WithOkColor()
+                     .AddField("Hangman", Draw(state))
+                     .AddField("Guess", Format.Code(state.Word))
+                     .WithFooter(state.missedLetters.Join(' '));
+        }
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        public async partial Task Hangman([Leftover] string? type = null)
+        {
+            if (!_service.StartHangman(ctx.Channel.Id, type, out var hangman))
+            {
+                await ReplyErrorLocalizedAsync(strs.hangman_running);
+                return;
+            }
+
+            var eb = GetEmbed(_eb, hangman);
+            eb.WithDescription(GetText(strs.hangman_game_started));
+            await ctx.Channel.EmbedAsync(eb);
+        }
+
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        public async partial Task HangmanStop()
+        {
+            if (await _service.StopHangman(ctx.Channel.Id)) await ReplyConfirmLocalizedAsync(strs.hangman_stopped);
+        }
+    }
+}

src/NadekoBot/Modules/Games/Hangman/HangmanGame.cs

@@ -0,0 +1,113 @@
+#nullable disable
+using AngleSharp.Text;
+
+namespace NadekoBot.Modules.Games.Hangman;
+
+public sealed class HangmanGame
+{
+    public enum GuessResult { NoAction, AlreadyTried, Incorrect, Guess, Win }
+
+    public enum Phase { Running, Ended }
+
+    private Phase CurrentPhase { get; set; }
+
+    private readonly HashSet<char> _incorrect = new();
+    private readonly HashSet<char> _correct = new();
+    private readonly HashSet<char> _remaining = new();
+
+    private readonly string _word;
+    private readonly string _imageUrl;
+
+    public HangmanGame(HangmanTerm term)
+    {
+        _word = term.Word;
+        _imageUrl = term.ImageUrl;
+
+        _remaining = _word.ToLowerInvariant().Where(x => x.IsLetter()).Select(char.ToLowerInvariant).ToHashSet();
+    }
+
+    public State GetState(GuessResult guessResult = GuessResult.NoAction)
+        => new(_incorrect.Count,
+            CurrentPhase,
+            CurrentPhase == Phase.Ended ? _word : GetScrambledWord(),
+            guessResult,
+            _incorrect.ToList(),
+            CurrentPhase == Phase.Ended ? _imageUrl : string.Empty);
+
+    private string GetScrambledWord()
+    {
+        Span<char> output = stackalloc char[_word.Length * 2];
+        for (var i = 0; i < _word.Length; i++)
+        {
+            var ch = _word[i];
+            if (ch == ' ')
+                output[i * 2] = ' ';
+            if (!ch.IsLetter() || !_remaining.Contains(char.ToLowerInvariant(ch)))
+                output[i * 2] = ch;
+            else
+                output[i * 2] = '_';
+
+            output[(i * 2) + 1] = ' ';
+        }
+
+        return new(output);
+    }
+
+    public State Guess(string guess)
+    {
+        if (CurrentPhase != Phase.Running)
+            return GetState();
+
+        guess = guess.Trim();
+        if (guess.Length > 1)
+        {
+            if (guess.Equals(_word, StringComparison.InvariantCultureIgnoreCase))
+            {
+                CurrentPhase = Phase.Ended;
+                return GetState(GuessResult.Win);
+            }
+
+            return GetState();
+        }
+
+        var charGuess = guess[0];
+        if (!char.IsLetter(charGuess))
+            return GetState();
+
+        if (_incorrect.Contains(charGuess) || _correct.Contains(charGuess))
+            return GetState(GuessResult.AlreadyTried);
+
+        if (_remaining.Remove(charGuess))
+        {
+            if (_remaining.Count == 0)
+            {
+                CurrentPhase = Phase.Ended;
+                return GetState(GuessResult.Win);
+            }
+
+            _correct.Add(charGuess);
+            return GetState(GuessResult.Guess);
+        }
+
+        _incorrect.Add(charGuess);
+        if (_incorrect.Count > 5)
+        {
+            CurrentPhase = Phase.Ended;
+            return GetState(GuessResult.Incorrect);
+        }
+
+        return GetState(GuessResult.Incorrect);
+    }
+
+    public record State(
+        int Errors,
+        Phase Phase,
+        string Word,
+        GuessResult GuessResult,
+        List<char> missedLetters,
+        string ImageUrl)
+    {
+        public bool Failed
+            => Errors > 5;
+    }
+}

src/NadekoBot/Modules/Games/Hangman/HangmanService.cs

@@ -0,0 +1,128 @@
+using Microsoft.Extensions.Caching.Memory;
+using NadekoBot.Common.ModuleBehaviors;
+using NadekoBot.Modules.Games.Services;
+using System.Diagnostics.CodeAnalysis;
+
+namespace NadekoBot.Modules.Games.Hangman;
+
+public sealed class HangmanService : IHangmanService, ILateExecutor
+{
+    private readonly ConcurrentDictionary<ulong, HangmanGame> _hangmanGames = new();
+    private readonly IHangmanSource _source;
+    private readonly IEmbedBuilderService _eb;
+    private readonly GamesConfigService _gcs;
+    private readonly ICurrencyService _cs;
+    private readonly IMemoryCache _cdCache;
+    private readonly object _locker = new();
+
+    public HangmanService(
+        IHangmanSource source,
+        IEmbedBuilderService eb,
+        GamesConfigService gcs,
+        ICurrencyService cs,
+        IMemoryCache cdCache)
+    {
+        _source = source;
+        _eb = eb;
+        _gcs = gcs;
+        _cs = cs;
+        _cdCache = cdCache;
+    }
+
+    public bool StartHangman(ulong channelId, string? category, [NotNullWhen(true)] out HangmanGame.State? state)
+    {
+        state = null;
+        if (!_source.GetTerm(category, out var term))
+            return false;
+
+
+        var game = new HangmanGame(term);
+        lock (_locker)
+        {
+            var hc = _hangmanGames.GetOrAdd(channelId, game);
+            if (hc == game)
+            {
+                state = hc.GetState();
+                return true;
+            }
+
+            return false;
+        }
+    }
+
+    public ValueTask<bool> StopHangman(ulong channelId)
+    {
+        lock (_locker)
+        {
+            if (_hangmanGames.TryRemove(channelId, out var game)) return new(true);
+        }
+
+        return new(false);
+    }
+
+    public IReadOnlyCollection<string> GetHangmanTypes()
+        => _source.GetCategories();
+
+    public async Task LateExecute(IGuild guild, IUserMessage msg)
+    {
+        if (_hangmanGames.ContainsKey(msg.Channel.Id))
+        {
+            if (string.IsNullOrWhiteSpace(msg.Content))
+                return;
+
+            if (_cdCache.TryGetValue(msg.Author.Id, out _))
+                return;
+
+            HangmanGame.State state;
+            long rew = 0;
+            lock (_locker)
+            {
+                if (!_hangmanGames.TryGetValue(msg.Channel.Id, out var game))
+                    return;
+
+                state = game.Guess(msg.Content.ToLowerInvariant());
+
+                if (state.GuessResult == HangmanGame.GuessResult.NoAction)
+                    return;
+
+                if (state.GuessResult is HangmanGame.GuessResult.Incorrect or HangmanGame.GuessResult.AlreadyTried)
+                    _cdCache.Set(msg.Author.Id,
+                        string.Empty,
+                        new MemoryCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(3) });
+
+                if (state.Phase == HangmanGame.Phase.Ended)
+                    if (_hangmanGames.TryRemove(msg.Channel.Id, out _))
+                        rew = _gcs.Data.Hangman.CurrencyReward;
+            }
+
+            if (rew > 0)
+                await _cs.AddAsync(msg.Author, "hangman win", rew, gamble: true);
+
+            await SendState((ITextChannel)msg.Channel, msg.Author, msg.Content, state);
+        }
+    }
+
+    private Task<IUserMessage> SendState(
+        ITextChannel channel,
+        IUser user,
+        string content,
+        HangmanGame.State state)
+    {
+        var embed = Games.HangmanCommands.GetEmbed(_eb, state);
+        if (state.GuessResult == HangmanGame.GuessResult.Guess)
+            embed.WithDescription($"{user} guessed the letter {content}!").WithOkColor();
+        else if (state.GuessResult == HangmanGame.GuessResult.Incorrect && state.Failed)
+            embed.WithDescription($"{user} Letter {content} doesn't exist! Game over!").WithErrorColor();
+        else if (state.GuessResult == HangmanGame.GuessResult.Incorrect)
+            embed.WithDescription($"{user} Letter {content} doesn't exist!").WithErrorColor();
+        else if (state.GuessResult == HangmanGame.GuessResult.AlreadyTried)
+            embed.WithDescription($"{user} Letter {content} has already been used.").WithPendingColor();
+        else if (state.GuessResult == HangmanGame.GuessResult.Win)
+            embed.WithDescription($"{user} won!").WithOkColor();
+
+        if (!string.IsNullOrWhiteSpace(state.ImageUrl) && Uri.IsWellFormedUriString(state.ImageUrl, UriKind.Absolute))
+            embed.WithImageUrl(state.ImageUrl);
+
+        return channel.EmbedAsync(embed);
+    }
+}

src/NadekoBot/Modules/Games/Hangman/HangmanTerm.cs

@@ -0,0 +1,8 @@
+#nullable disable
+namespace NadekoBot.Modules.Games.Hangman;
+
+public sealed class HangmanTerm
+{
+    public string Word { get; set; }
+    public string ImageUrl { get; set; }
+}

src/NadekoBot/Modules/Games/Hangman/IHangmanService.cs

@@ -0,0 +1,10 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace NadekoBot.Modules.Games.Hangman;
+
+public interface IHangmanService
+{
+    bool StartHangman(ulong channelId, string? category, [NotNullWhen(true)] out HangmanGame.State? hangmanController);
+    ValueTask<bool> StopHangman(ulong channelId);
+    IReadOnlyCollection<string> GetHangmanTypes();
+}

src/NadekoBot/Modules/Games/Hangman/IHangmanSource.cs

@@ -0,0 +1,10 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace NadekoBot.Modules.Games.Hangman;
+
+public interface IHangmanSource : INService
+{
+    public IReadOnlyCollection<string> GetCategories();
+    public void Reload();
+    public bool GetTerm(string? category, [NotNullWhen(true)] out HangmanTerm? term);
+}