Removed module projects because it can't work like that atm. Commented out package commands.

NadekoBot.Core/Modules/Games/Common/Acrophobia/Acrophobia.cs

@@ -0,0 +1,177 @@
+using NadekoBot.Common;
+using NadekoBot.Extensions;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace NadekoBot.Modules.Games.Common.Acrophobia
+{
+    /// <summary>
+    /// Platform-agnostic acrophobia game
+    /// </summary>
+    public class Acrophobia : IDisposable
+    {
+        private const int VotingPhaseLength = 30;
+
+        public enum Phase
+        {
+            Submission,
+            Voting,
+            Ended
+        }
+
+        public enum UserInputResult
+        {
+            Submitted,
+            SubmissionFailed,
+            Voted,
+            VotingFailed,
+            Failed
+        }
+
+        public int SubmissionPhaseLength { get; }
+
+        public Phase CurrentPhase { get; private set; } = Phase.Submission;
+        public ImmutableArray<char> StartingLetters { get; private set; }
+
+        private readonly Dictionary<AcrophobiaUser, int> submissions = new Dictionary<AcrophobiaUser, int>();
+        private readonly SemaphoreSlim locker = new SemaphoreSlim(1, 1);
+        private readonly NadekoRandom _rng;
+
+        public event Func<Acrophobia, Task> OnStarted = delegate { return Task.CompletedTask; };
+        public event Func<Acrophobia, ImmutableArray<KeyValuePair<AcrophobiaUser, int>>, Task> OnVotingStarted = delegate { return Task.CompletedTask; };
+        public event Func<string, Task> OnUserVoted = delegate { return Task.CompletedTask; };
+        public event Func<Acrophobia, ImmutableArray<KeyValuePair<AcrophobiaUser, int>>, Task> OnEnded = delegate { return Task.CompletedTask; };
+
+        private readonly HashSet<ulong> _usersWhoVoted = new HashSet<ulong>();
+
+        public Acrophobia(int submissionPhaseLength = 30)
+        {
+            _rng = new NadekoRandom();
+            SubmissionPhaseLength = submissionPhaseLength;
+            InitializeStartingLetters();
+        }
+
+        public async Task Run()
+        {
+            await OnStarted(this).ConfigureAwait(false);
+            await Task.Delay(SubmissionPhaseLength * 1000);
+            await locker.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                if (submissions.Count == 0)
+                {
+                    CurrentPhase = Phase.Ended;
+                    await OnVotingStarted(this, ImmutableArray.Create<KeyValuePair<AcrophobiaUser, int>>()).ConfigureAwait(false);
+                    return;
+                }
+                if (submissions.Count == 1)
+                {
+                    CurrentPhase = Phase.Ended;
+                    await OnVotingStarted(this, submissions.ToArray().ToImmutableArray()).ConfigureAwait(false);
+                    return;
+                }
+
+                CurrentPhase = Phase.Voting;
+
+                await OnVotingStarted(this, submissions.ToArray().ToImmutableArray()).ConfigureAwait(false);
+            }
+            finally { locker.Release(); }
+
+            await Task.Delay(VotingPhaseLength * 1000);
+            await locker.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                CurrentPhase = Phase.Ended;
+                await OnEnded(this, submissions.ToArray().ToImmutableArray()).ConfigureAwait(false) ;
+            }
+            finally { locker.Release(); }
+        }
+
+        private void InitializeStartingLetters()
+        {
+            var wordCount = _rng.Next(3, 6);
+
+            var lettersArr = new char[wordCount];
+
+            for (int i = 0; i < wordCount; i++)
+            {
+                var randChar = (char)_rng.Next(65, 91);
+                lettersArr[i] = randChar == 'X' ? (char)_rng.Next(65, 88) : randChar;
+            }
+            StartingLetters = lettersArr.ToImmutableArray();
+        }
+
+        public async Task<bool> UserInput(ulong userId, string userName, string input)
+        {
+            var user = new AcrophobiaUser(userId, userName, input.ToLowerInvariant().ToTitleCase());
+
+            await locker.WaitAsync();
+            try
+            {
+                switch (CurrentPhase)
+                {
+                    case Phase.Submission:
+                        if (submissions.ContainsKey(user) || !IsValidAnswer(input))
+                            break;
+
+                        submissions.Add(user, 0);
+                        return true;
+                    case Phase.Voting:
+                        AcrophobiaUser toVoteFor;
+                        if (!int.TryParse(input, out var index)
+                            || --index < 0
+                            || index >= submissions.Count
+                            || (toVoteFor = submissions.ToArray()[index].Key).UserId == user.UserId
+                            || !_usersWhoVoted.Add(userId))
+                            break;
+                        ++submissions[toVoteFor];
+                        var _ = Task.Run(() => OnUserVoted(userName));
+                        return true;
+                    default:
+                        break;
+                }
+                return false;
+            }
+            finally
+            {
+                locker.Release();
+            }
+        }
+
+        private bool IsValidAnswer(string input)
+        {
+            input = input.ToUpperInvariant();
+
+            var inputWords = input.Split(' ');
+
+            if (inputWords.Length != StartingLetters.Length) // number of words must be the same as the number of the starting letters
+                return false;
+
+            for (int i = 0; i < StartingLetters.Length; i++)
+            {
+                var letter = StartingLetters[i];
+
+                if (!inputWords[i].StartsWith(letter.ToString())) // all first letters must match
+                    return false;
+            }
+
+            return true;
+        }
+
+        public void Dispose()
+        {
+            this.CurrentPhase = Phase.Ended;
+            OnStarted = null;
+            OnEnded = null;
+            OnUserVoted = null;
+            OnVotingStarted = null;
+            _usersWhoVoted.Clear();
+            submissions.Clear();
+            locker.Dispose();
+        }
+    }
+}

NadekoBot.Core/Modules/Games/Common/Acrophobia/AcrophobiaUser.cs

@@ -0,0 +1,28 @@
+namespace NadekoBot.Modules.Games.Common.Acrophobia
+{
+    public class AcrophobiaUser
+    {
+        public string UserName { get; }
+        public ulong UserId { get; }
+        public string Input { get; }
+
+        public AcrophobiaUser(ulong userId, string userName, string input)
+        {
+            this.UserName = userName;
+            this.UserId = userId;
+            this.Input = input;
+        }
+
+        public override int GetHashCode()
+        {
+            return UserId.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is AcrophobiaUser x
+                ? x.UserId == this.UserId
+                : false;
+        }
+    }
+}

NadekoBot.Core/Modules/Games/Common/ChatterBot/ChatterBotResponse.cs

@@ -0,0 +1,8 @@
+namespace NadekoBot.Modules.Games.Common.ChatterBot
+{
+    public class ChatterBotResponse
+    {
+        public string Convo_id { get; set; }
+        public string BotSay { get; set; }
+    }
+}

NadekoBot.Core/Modules/Games/Common/ChatterBot/ChatterBotSession.cs

@@ -0,0 +1,37 @@
+using System.Net.Http;
+using System.Threading.Tasks;
+using NadekoBot.Common;
+using NadekoBot.Extensions;
+using Newtonsoft.Json;
+
+namespace NadekoBot.Modules.Games.Common.ChatterBot
+{
+    public class ChatterBotSession : IChatterBotSession
+    {
+        private static NadekoRandom Rng { get; } = new NadekoRandom();
+
+        private readonly string _chatterBotId;
+        private int _botId = 6;
+
+        public ChatterBotSession()
+        {
+            _chatterBotId = Rng.Next(0, 1000000).ToString().ToBase64();
+        }
+
+        private string apiEndpoint => "http://api.program-o.com/v2/chatbot/" +
+                                      $"?bot_id={_botId}&" +
+                                      "say={0}&" +
+                                      $"convo_id=nadekobot_{_chatterBotId}&" +
+                                      "format=json";
+
+        public async Task<string> Think(string message)
+        {
+            using (var http = new HttpClient())
+            {
+                var res = await http.GetStringAsync(string.Format(apiEndpoint, message)).ConfigureAwait(false);
+                var cbr = JsonConvert.DeserializeObject<ChatterBotResponse>(res);
+                return cbr.BotSay.Replace("<br/>", "\n");
+            }
+        }
+    }
+}

NadekoBot.Core/Modules/Games/Common/ChatterBot/CleverbotResponse.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NadekoBot.Modules.Games.Common.ChatterBot
+{
+    public class CleverbotResponse
+    {
+        public string Cs { get; set; }
+        public string Output { get; set; }
+    }
+}

NadekoBot.Core/Modules/Games/Common/ChatterBot/IChatterBotSession.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NadekoBot.Modules.Games.Common.ChatterBot
+{
+    public interface IChatterBotSession
+    {
+        Task<string> Think(string input);
+    }
+}

NadekoBot.Core/Modules/Games/Common/ChatterBot/OfficialCleverbotSession.cs

@@ -0,0 +1,33 @@
+using Newtonsoft.Json;
+using System.Net.Http;
+using System.Threading.Tasks;
+
+namespace NadekoBot.Modules.Games.Common.ChatterBot
+{
+    public class OfficialCleverbotSession : IChatterBotSession
+    {
+        private readonly string _apiKey;
+        private string _cs = null;
+
+        private string queryString => $"https://www.cleverbot.com/getreply?key={_apiKey}" +
+            "&wrapper=nadekobot" +
+            "&input={0}" +
+            "&cs={1}";
+
+        public OfficialCleverbotSession(string apiKey)
+        {
+            this._apiKey = apiKey;
+        }
+
+        public async Task<string> Think(string input)
+        {
+            using (var http = new HttpClient())
+            {
+                var dataString = await http.GetStringAsync(string.Format(queryString, input, _cs ?? "")).ConfigureAwait(false);
+                var data = JsonConvert.DeserializeObject<CleverbotResponse>(dataString);
+                _cs = data?.Cs;
+                return data?.Output;
+            }
+        }
+    }
+}

NadekoBot.Core/Modules/Games/Common/Connect4/Connect4.cs

@@ -0,0 +1,364 @@
+using NadekoBot.Common;
+using System;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace NadekoBot.Modules.Games.Common.Connect4
+{
+    public class Connect4Game : IDisposable
+    {
+        public enum Phase
+        {
+            Joining, // waiting for second player to join
+            P1Move,
+            P2Move,
+            Ended,
+        }
+
+        public enum Field //temporary most likely
+        {
+            Empty,
+            P1,
+            P2,
+        }
+
+        public enum Result
+        {
+            Draw,
+            CurrentPlayerWon,
+            OtherPlayerWon,
+        }
+
+        public const int NumberOfColumns = 6;
+        public const int NumberOfRows = 7;
+
+        public Phase CurrentPhase { get; private set; } = Phase.Joining;
+
+        //state is bottom to top, left to right
+        private readonly Field[] _gameState = new Field[NumberOfRows * NumberOfColumns];
+        private readonly (ulong UserId, string Username)?[] _players = new(ulong, string)?[2];
+
+        public ImmutableArray<Field> GameState => _gameState.ToImmutableArray();
+        public ImmutableArray<(ulong UserId, string Username)?> Players => _players.ToImmutableArray();
+
+        public string CurrentPlayer => CurrentPhase == Phase.P1Move
+            ? _players[0].Value.Username
+            : _players[1].Value.Username;
+
+        public string OtherPlayer => CurrentPhase == Phase.P2Move
+            ? _players[0].Value.Username
+            : _players[1].Value.Username;
+
+        //public event Func<Connect4Game, Task> OnGameStarted;
+        public event Func<Connect4Game, Task> OnGameStateUpdated;
+        public event Func<Connect4Game, Task> OnGameFailedToStart;
+        public event Func<Connect4Game, Result, Task> OnGameEnded;
+
+        private readonly SemaphoreSlim _locker = new SemaphoreSlim(1, 1);
+        private readonly NadekoRandom _rng;
+
+        private Timer _playerTimeoutTimer;
+
+        /* [ ][ ][ ][ ][ ][ ]
+         * [ ][ ][ ][ ][ ][ ]
+         * [ ][ ][ ][ ][ ][ ]
+         * [ ][ ][ ][ ][ ][ ]
+         * [ ][ ][ ][ ][ ][ ]
+         * [ ][ ][ ][ ][ ][ ]
+         * [ ][ ][ ][ ][ ][ ]
+         */
+
+        public Connect4Game(ulong userId, string userName)
+        {
+            _players[0] = (userId, userName);
+
+            _rng = new NadekoRandom();
+            for (int i = 0; i < NumberOfColumns * NumberOfRows; i++)
+            {
+                _gameState[i] = Field.Empty;
+            }
+        }
+
+        public void Initialize()
+        {
+            if (CurrentPhase != Phase.Joining)
+                return;
+            var _ = Task.Run(async () =>
+            {
+                await Task.Delay(15000).ConfigureAwait(false);
+                await _locker.WaitAsync().ConfigureAwait(false);
+                try
+                {
+                    if (_players[1] == null)
+                    {
+                        var __ = OnGameFailedToStart?.Invoke(this);
+                        CurrentPhase = Phase.Ended;
+                        return;
+                    }
+                }
+                finally { _locker.Release(); }
+            });
+        }
+
+        public async Task<bool> Join(ulong userId, string userName)
+        {
+            await _locker.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                if (CurrentPhase != Phase.Joining) //can't join if its not a joining phase
+                    return false;
+
+                if (_players[0].Value.UserId == userId) // same user can't join own game
+                    return false;
+
+                if (_rng.Next(0, 2) == 0) //rolling from 0-1, if number is 0, join as first player
+                {
+                    _players[1] = _players[0];
+                    _players[0] = (userId, userName);
+                }
+                else //else join as a second player
+                    _players[1] = (userId, userName);
+
+                CurrentPhase = Phase.P1Move; //start the game
+                _playerTimeoutTimer = new Timer(async state =>
+                {
+                    await _locker.WaitAsync().ConfigureAwait(false);
+                    try
+                    {
+                        EndGame(Result.OtherPlayerWon);
+                    }
+                    finally { _locker.Release(); }
+                }, null, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(30));
+                var __ = OnGameStateUpdated?.Invoke(this);
+
+                return true;
+            }
+            finally { _locker.Release(); }
+        }
+
+        public async Task<bool> Input(ulong userId, string userName, int inputCol)
+        {
+            await _locker.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                inputCol -= 1;
+                if (CurrentPhase == Phase.Ended || CurrentPhase == Phase.Joining)
+                    return false;
+
+                if (!((_players[0].Value.UserId == userId && CurrentPhase == Phase.P1Move)
+                    || (_players[1].Value.UserId == userId && CurrentPhase == Phase.P2Move)))
+                    return false;
+
+                if (inputCol < 0 || inputCol > NumberOfColumns) //invalid input
+                    return false;
+
+                if (IsColumnFull(inputCol)) //can't play there event?
+                    return false;
+
+                var start = NumberOfRows * inputCol;
+                for (int i = start; i < start + NumberOfRows; i++)
+                {
+                    if (_gameState[i] == Field.Empty)
+                    {
+                        _gameState[i] = GetPlayerPiece(userId);
+                        break;
+                    }
+                }
+
+                //check winnning condition
+                // ok, i'll go from [0-2] in rows (and through all columns) and check upward if 4 are connected
+                
+                for (int i = 0; i < NumberOfRows - 3; i++)
+                {
+                    if (CurrentPhase == Phase.Ended)
+                        break;
+
+                    for (int j = 0; j < NumberOfColumns; j++)
+                    {
+                        if (CurrentPhase == Phase.Ended)
+                            break;
+
+                        var first = _gameState[i + j * NumberOfRows];
+                        if (first != Field.Empty)
+                        {
+                            //Console.WriteLine(i + j * NumberOfRows);
+                            for (int k = 1; k < 4; k++)
+                            {
+                                var next = _gameState[i + k + j * NumberOfRows];
+                                if (next == first)
+                                {
+                                    //Console.WriteLine(i + k + j * NumberOfRows);
+                                    if (k == 3)
+                                        EndGame(Result.CurrentPlayerWon);
+                                    else
+                                        continue;
+                                }
+                                else break;
+                            }
+                        }
+                    }
+                }
+
+                // i'll go [0-1] in columns (and through all rows) and check to the right if 4 are connected
+                for (int i = 0; i < NumberOfColumns - 3; i++)
+                {
+                    if (CurrentPhase == Phase.Ended)
+                        break;
+
+                    for (int j = 0; j < NumberOfRows; j++)
+                    {
+                        if (CurrentPhase == Phase.Ended)
+                            break;
+
+                        var first = _gameState[j + i * NumberOfRows];
+                        if (first != Field.Empty)
+                        {
+                            for (int k = 1; k < 4; k++)
+                            {
+                                var next = _gameState[j + (i + k) * NumberOfRows];
+                                if (next == first)
+                                    if (k == 3)
+                                        EndGame(Result.CurrentPlayerWon);
+                                    else
+                                        continue;
+                                else break;
+                            }
+                        }
+                    }
+                }
+
+                //need to check diagonal now
+                for (int col = 0; col < NumberOfColumns; col++)
+                {
+                    if (CurrentPhase == Phase.Ended)
+                        break;
+
+                    for (int row = 0; row < NumberOfRows; row++)
+                    {
+                        if (CurrentPhase == Phase.Ended)
+                            break;
+
+                        var first = _gameState[row + col * NumberOfRows];
+
+                        if (first != Field.Empty)
+                        {
+                            var same = 1;
+
+                            //top left
+                            for (int i = 1; i < 4; i++)
+                            {
+                                //while going top left, rows are increasing, columns are decreasing
+                                var curRow = row + i;
+                                var curCol = col - i;
+
+                                //check if current values are in range
+                                if (curRow >= NumberOfRows || curRow < 0)
+                                    break;
+                                if (curCol < 0 || curCol >= NumberOfColumns)
+                                    break;
+
+                                var cur = _gameState[curRow + curCol * NumberOfRows];
+                                if (cur == first)
+                                    same++;
+                                else break;
+                            }
+
+                            if (same == 4)
+                            {
+                                Console.WriteLine($"Won top left diagonal starting from {row + col * NumberOfRows}");
+                                EndGame(Result.CurrentPlayerWon);
+                                break;
+                            }
+
+                            same = 1;
+
+                            //top right
+                            for (int i = 1; i < 4; i++)
+                            {
+                                //while going top right, rows are increasing, columns are increasing
+                                var curRow = row + i;
+                                var curCol = col + i;
+
+                                //check if current values are in range
+                                if (curRow >= NumberOfRows || curRow < 0)
+                                    break;
+                                if (curCol < 0 || curCol >= NumberOfColumns)
+                                    break;
+
+                                var cur = _gameState[curRow + curCol * NumberOfRows];
+                                if (cur == first)
+                                    same++;
+                                else break;
+                            }
+
+                            if (same == 4)
+                            {
+                                Console.WriteLine($"Won top right diagonal starting from {row + col * NumberOfRows}");
+                                EndGame(Result.CurrentPlayerWon);
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                //check draw? if it's even possible
+                if (_gameState.All(x => x != Field.Empty))
+                {
+                    EndGame(Result.Draw);
+                }
+
+                if (CurrentPhase != Phase.Ended)
+                {
+                    if (CurrentPhase == Phase.P1Move)
+                        CurrentPhase = Phase.P2Move;
+                    else
+                        CurrentPhase = Phase.P1Move;
+
+                    ResetTimer();
+                }
+                var _ = OnGameStateUpdated?.Invoke(this);
+                return true;
+            }
+            finally { _locker.Release(); }
+        }
+
+        private void ResetTimer()
+        {
+            _playerTimeoutTimer.Change(TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(30));
+        }
+
+        private void EndGame(Result result)
+        {
+            if (CurrentPhase == Phase.Ended)
+                return;
+            var _ = OnGameEnded?.Invoke(this, result);
+            CurrentPhase = Phase.Ended;
+        }
+
+        private Field GetPlayerPiece(ulong userId) => _players[0].Value.UserId == userId
+            ? Field.P1
+            : Field.P2;
+
+        //column is full if there are no empty fields
+        private bool IsColumnFull(int column)
+        {
+            var start = NumberOfRows * column;
+            for (int i = start; i < start + NumberOfRows; i++)
+            {
+                if (_gameState[i] == Field.Empty)
+                    return false;
+            }
+            return true;
+        }
+
+        public void Dispose()
+        {
+            OnGameFailedToStart = null;
+            OnGameStateUpdated = null;
+            OnGameEnded = null;
+            _playerTimeoutTimer?.Change(Timeout.Infinite, Timeout.Infinite);
+        }
+    }
+}

NadekoBot.Core/Modules/Games/Common/GirlRating.cs

@@ -0,0 +1,73 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using ImageSharp;
+using NadekoBot.Common;
+using NadekoBot.Extensions;
+using NadekoBot.Core.Services;
+using NLog;
+using SixLabors.Primitives;
+
+namespace NadekoBot.Modules.Games.Common
+{
+    public class GirlRating
+    {
+        private static readonly Logger _log = LogManager.GetCurrentClassLogger();
+
+        public double Crazy { get; }
+        public double Hot { get; }
+        public int Roll { get; }
+        public string Advice { get; }
+        public AsyncLazy<string> Url { get; }
+
+        public GirlRating(IImagesService _images, double crazy, double hot, int roll, string advice)
+        {
+            Crazy = crazy;
+            Hot = hot;
+            Roll = roll;
+            Advice = advice; // convenient to have it here, even though atm there are only few different ones.
+
+            Url = new AsyncLazy<string>(async () =>
+            {
+                try
+                {
+                    using (var ms = new MemoryStream(_images.WifeMatrix.ToArray(), false))
+                    using (var img = Image.Load(ms))
+                    {
+                        const int minx = 35;
+                        const int miny = 385;
+                        const int length = 345;
+
+                        var pointx = (int)(minx + length * (Hot / 10));
+                        var pointy = (int)(miny - length * ((Crazy - 4) / 6));
+
+                        using (var pointMs = new MemoryStream(_images.RategirlDot.ToArray(), false))
+                        using (var pointImg = Image.Load(pointMs))
+                        {
+                            img.DrawImage(pointImg, 100, default(Size), new Point(pointx - 10, pointy - 10));
+                        }
+
+                        string url;
+                        using (var http = new HttpClient())
+                        using (var imgStream = new MemoryStream())
+                        {
+                            img.SaveAsPng(imgStream);
+                            var byteContent = new ByteArrayContent(imgStream.ToArray());
+                            http.AddFakeHeaders();
+
+                            var reponse = await http.PutAsync("https://transfer.sh/img.png", byteContent);
+                            url = await reponse.Content.ReadAsStringAsync();
+                        }
+                        return url;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.Warn(ex);
+                    return null;
+                }
+            });
+        }
+    }
+}

NadekoBot.Core/Modules/Games/Common/Hangman/Exceptions/TermNotFoundException.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace NadekoBot.Modules.Games.Common.Hangman.Exceptions
+{
+    public class TermNotFoundException : Exception
+    {
+        public TermNotFoundException() : base("Term of that type couldn't be found")
+        {
+        }
+    }
+}

NadekoBot.Core/Modules/Games/Common/Hangman/Hangman.cs

@@ -0,0 +1,172 @@
+using NadekoBot.Extensions;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace NadekoBot.Modules.Games.Common.Hangman
+{
+    public class Hangman : IDisposable
+    {
+        public string TermType { get; }
+        public TermPool TermPool { get; }
+        public HangmanObject Term { get; }
+
+        public string ScrambledWord => "`" + String.Concat(Term.Word.Select(c =>
+        {
+            if (c == ' ')
+                return " \u2000";
+            if (!(char.IsLetter(c) || char.IsDigit(c)))
+                return $" {c}";
+
+            c = char.ToLowerInvariant(c);
+            return _previousGuesses.Contains(c) ? $" {c}" : " ◯";
+        })) + "`";
+
+        private Phase _currentPhase = Phase.Active;
+        public Phase CurrentPhase
+        {
+            get => _currentPhase;
+            set
+            {
+                if (value == Phase.Ended)
+                    _endingCompletionSource.TrySetResult(true);
+
+                _currentPhase = value;
+            }
+        }
+
+        private readonly SemaphoreSlim _locker = new SemaphoreSlim(1, 1);
+
+        private readonly HashSet<ulong> _recentUsers = new HashSet<ulong>();
+
+        public uint Errors { get; private set; } = 0;
+        public uint MaxErrors { get; } = 6;
+
+        public event Func<Hangman, string, Task> OnGameEnded = delegate { return Task.CompletedTask; };
+        public event Func<Hangman, string, char, Task> OnLetterAlreadyUsed = delegate { return Task.CompletedTask; };
+        public event Func<Hangman, string, char, Task> OnGuessFailed = delegate { return Task.CompletedTask; };
+        public event Func<Hangman, string, char, Task> OnGuessSucceeded = delegate { return Task.CompletedTask; };
+
+        private readonly HashSet<char> _previousGuesses = new HashSet<char>();
+        public ImmutableArray<char> PreviousGuesses => _previousGuesses.ToImmutableArray();
+
+        private readonly TaskCompletionSource<bool> _endingCompletionSource = new TaskCompletionSource<bool>();
+
+        public Task EndedTask => _endingCompletionSource.Task;
+
+        public Hangman(string type, TermPool tp = null)
+        {
+            this.TermType = type.Trim().ToLowerInvariant().ToTitleCase();
+            this.TermPool = tp ?? new TermPool();
+            this.Term = this.TermPool.GetTerm(type);
+        }
+
+        private void AddError()
+        {
+            Errors++;
+            if (Errors > MaxErrors)
+            {
+                var _ = OnGameEnded(this, null);
+                CurrentPhase = Phase.Ended;
+            }
+        }
+
+        public string GetHangman() => $@". ┌─────┐
+.┃...............┋
+.┃...............┋
+.┃{(Errors > 0 ? ".............😲" : "")}
+.┃{(Errors > 1 ? "............./" : "")} {(Errors > 2 ? "|" : "")} {(Errors > 3 ? "\\" : "")}
+.┃{(Errors > 4 ? "............../" : "")} {(Errors > 5 ? "\\" : "")}
+/-\";
+
+        public async Task Input(ulong userId, string userName, string input)
+        {
+            if (CurrentPhase == Phase.Ended)
+                return;
+
+            if (string.IsNullOrWhiteSpace(input))
+                return;
+
+            input = input.Trim().ToLowerInvariant();
+
+            await _locker.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                if (CurrentPhase == Phase.Ended)
+                    return;
+
+                if (input.Length > 1) // tried to guess the whole word
+                {
+                    if (input != Term.Word) // failed
+                        return;
+
+                    var _ = OnGameEnded?.Invoke(this, userName);
+                    CurrentPhase = Phase.Ended;
+                    return;
+                }
+
+                var ch = input[0];
+
+                if (!(char.IsLetterOrDigit(ch)))
+                    return;
+
+                if (!_recentUsers.Add(userId)) // don't let a single user spam guesses
+                    return;
+
+                if (!_previousGuesses.Add(ch)) // that latter was already guessed
+                {
+                    var _ = OnLetterAlreadyUsed?.Invoke(this, userName, ch);
+                    AddError();
+                }
+                else if (!Term.Word.Contains(ch)) // guessed letter doesn't exist
+                {
+                    var _ = OnGuessFailed?.Invoke(this, userName, ch);
+                    AddError();
+                }
+                else if (Term.Word.All(x => _previousGuesses.IsSupersetOf(Term.Word.ToLowerInvariant()
+                                                                            .Where(c => char.IsLetterOrDigit(c)))))
+                {
+                    var _ = OnGameEnded.Invoke(this, userName); //if all letters are guessed
+                    CurrentPhase = Phase.Ended;
+                }
+                else //guessed but not last letter
+                {
+                    var _ = OnGuessSucceeded?.Invoke(this, userName, ch);
+                    _recentUsers.Remove(userId); // he can guess again right away
+                    return;
+                }
+
+                var clearSpam = Task.Run(async () =>
+                {
+                    await Task.Delay(3000).ConfigureAwait(false); // remove the user from the spamlist after 5 seconds
+                    _recentUsers.Remove(userId);
+                });
+            }
+            finally { _locker.Release(); }
+        }
+
+        public async Task Stop()
+        {
+            await _locker.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                CurrentPhase = Phase.Ended;
+            }
+            finally { _locker.Release(); }
+        }
+
+        public void Dispose()
+        {
+            OnGameEnded = null;
+            OnGuessFailed = null;
+            OnGuessSucceeded = null;
+            OnLetterAlreadyUsed = null;
+            _previousGuesses.Clear();
+            _recentUsers.Clear();
+            _locker.Dispose();
+        }
+    }
+}

NadekoBot.Core/Modules/Games/Common/Hangman/HangmanObject.cs

@@ -0,0 +1,8 @@
+namespace NadekoBot.Modules.Games.Common.Hangman
+{
+    public class HangmanObject
+    {
+        public string Word { get; set; }
+        public string ImageUrl { get; set; }
+    }
+}

NadekoBot.Core/Modules/Games/Common/Hangman/Phase.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NadekoBot.Modules.Games.Common.Hangman
+{
+    public enum Phase
+    {
+        Active,
+        Ended,
+    }
+}

NadekoBot.Core/Modules/Games/Common/Hangman/TermPool.cs

@@ -0,0 +1,54 @@
+using NadekoBot.Common;
+using NadekoBot.Modules.Games.Common.Hangman.Exceptions;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using NLog;
+
+namespace NadekoBot.Modules.Games.Common.Hangman
+{
+    public class TermPool
+    {
+        const string termsPath = "data/hangman3.json";
+        private readonly Logger _log;
+
+        public IReadOnlyDictionary<string, HangmanObject[]> Data { get; } = new Dictionary<string, HangmanObject[]>();
+        public TermPool()
+        {
+            _log = LogManager.GetCurrentClassLogger();
+            try
+            {
+                Data = JsonConvert.DeserializeObject<Dictionary<string, HangmanObject[]>>(File.ReadAllText(termsPath));
+                Data = Data.ToDictionary(
+                    x => x.Key.ToLowerInvariant(),
+                    x => x.Value);
+            }
+            catch (Exception ex)
+            {
+                _log.Warn(ex);
+            }
+        }
+
+        public HangmanObject GetTerm(string type)
+        {
+            type = type?.Trim().ToLowerInvariant();
+            var rng = new NadekoRandom();
+
+            if (type == "random")
+            {
+                var keys = Data.Keys.ToArray();
+
+                type = Data.Keys.ToArray()[rng.Next(0, Data.Keys.Count())];
+            }
+            if (!Data.TryGetValue(type, out var termTypes) || termTypes.Length == 0)
+                throw new TermNotFoundException();
+
+            var obj = termTypes[rng.Next(0, termTypes.Length)];
+
+            obj.Word = obj.Word.Trim().ToLowerInvariant();
+            return obj;
+        }
+    }
+}

NadekoBot.Core/Modules/Games/Common/Hangman/TermType.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NadekoBot.Modules.Games.Common.Hangman
+{
+    [Flags]
+    public enum TermType
+    {
+        Countries = 0,
+        Movies = 1,
+        Animals = 2,
+        Things = 4,
+        Random = 8,
+    }
+}

NadekoBot.Core/Modules/Games/Common/Nunchi/Nunchi.cs

@@ -0,0 +1,181 @@
+using NadekoBot.Common;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace NadekoBot.Modules.Games.Common.Nunchi
+{
+    public class Nunchi : IDisposable
+    {
+        public enum Phase
+        {
+            Joining,
+            Playing,
+            WaitingForNextRound,
+            Ended,
+        }
+
+        public int CurrentNumber { get; private set; } = new NadekoRandom().Next(0, 100);
+        public Phase CurrentPhase { get; private set; } = Phase.Joining;
+
+        public event Func<Nunchi, Task> OnGameStarted;
+        public event Func<Nunchi, int, Task> OnRoundStarted;
+        public event Func<Nunchi, Task> OnUserGuessed;
+        public event Func<Nunchi, (ulong Id, string Name)?, Task> OnRoundEnded; // tuple of the user who failed
+        public event Func<Nunchi, string, Task> OnGameEnded; // name of the user who won
+
+        private readonly SemaphoreSlim _locker = new SemaphoreSlim(1, 1);
+
+        private HashSet<(ulong Id, string Name)> _participants = new HashSet<(ulong Id, string Name)>();
+        private HashSet<(ulong Id, string Name)> _passed = new HashSet<(ulong Id, string Name)>();
+
+        public ImmutableArray<(ulong Id, string Name)> Participants => _participants.ToImmutableArray();
+        public int ParticipantCount => _participants.Count;
+
+        private const int _killTimeout = 20 * 1000;
+        private const int _nextRoundTimeout = 5 * 1000;
+        private Timer _killTimer;
+
+        public Nunchi(ulong creatorId, string creatorName)
+        {
+            _participants.Add((creatorId, creatorName));
+        }
+
+        public async Task<bool> Join(ulong userId, string userName)
+        {
+            await _locker.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                if (CurrentPhase != Phase.Joining)
+                    return false;
+
+                return _participants.Add((userId, userName));
+            }
+            finally { _locker.Release(); }
+        }
+
+        public async Task<bool> Initialize()
+        {
+            CurrentPhase = Phase.Joining;
+            await Task.Delay(30000).ConfigureAwait(false);
+            await _locker.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                if (_participants.Count < 3)
+                {
+                    CurrentPhase = Phase.Ended;
+                    return false;
+                }
+
+                _killTimer = new Timer(async state =>
+                {
+                    await _locker.WaitAsync().ConfigureAwait(false);
+                    try
+                    {
+                        if (CurrentPhase != Phase.Playing)
+                            return;
+
+                        //if some players took too long to type a number, boot them all out and start a new round
+                        _participants = new HashSet<(ulong, string)>(_passed);
+                        EndRound();
+                    }
+                    finally { _locker.Release(); }
+                }, null, _killTimeout, _killTimeout);
+
+                CurrentPhase = Phase.Playing;
+                var _ = OnGameStarted?.Invoke(this);
+                var __ = OnRoundStarted?.Invoke(this, CurrentNumber);
+                return true;
+            }
+            finally { _locker.Release(); }
+        }
+
+        public async Task Input(ulong userId, string userName, int input)
+        {
+            await _locker.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                if (CurrentPhase != Phase.Playing)
+                    return;
+
+                var userTuple = (Id: userId, Name: userName);
+
+                // if the user is not a member of the race,
+                // or he already successfully typed the number
+                // ignore the input
+                if (!_participants.Contains(userTuple) || !_passed.Add(userTuple))
+                    return;
+
+                //if the number is correct
+                if (CurrentNumber == input - 1)
+                {
+                    //increment current number
+                    ++CurrentNumber;
+                    if (_passed.Count == _participants.Count - 1)
+                    {
+                        // if only n players are left, and n - 1 type the correct number, round is over
+
+                        // if only 2 players are left, game is over
+                        if (_participants.Count == 2)
+                        {
+                            _killTimer.Change(Timeout.Infinite, Timeout.Infinite);
+                            CurrentPhase = Phase.Ended;
+                            var _ = OnGameEnded?.Invoke(this, userTuple.Name);
+                        }
+                        else // else just start the new round without the user who was the last
+                        {
+                            var failure = _participants.Except(_passed).First();
+                            EndRound(failure);
+                        }
+                    }
+                    var __ = OnUserGuessed?.Invoke(this);
+                }
+                else
+                {
+                    //if the user failed
+
+                    EndRound(userTuple);
+                }
+            }
+            finally { _locker.Release(); }
+        }
+
+        private void EndRound((ulong, string)? failure = null)
+        {
+            _killTimer.Change(_killTimeout, _killTimeout);
+            CurrentNumber = new NadekoRandom().Next(0, 100); // reset the counter
+            _passed.Clear(); // reset all users who passed (new round starts)
+            if(failure != null)
+                _participants.Remove(failure.Value); // remove the dude who failed from the list of players
+
+            var __ = OnRoundEnded?.Invoke(this, failure);
+            if (_participants.Count <= 1) // means we have a winner or everyone was booted out
+            {
+                _killTimer.Change(Timeout.Infinite, Timeout.Infinite);
+                CurrentPhase = Phase.Ended;
+                var _ = OnGameEnded?.Invoke(this, _participants.Count > 0 ? _participants.First().Name : null);
+                return;
+            }
+            CurrentPhase = Phase.WaitingForNextRound;
+            var throwawayDelay = Task.Run(async () =>
+            {
+                await Task.Delay(_nextRoundTimeout).ConfigureAwait(false);
+                CurrentPhase = Phase.Playing;
+                var ___ = OnRoundStarted?.Invoke(this, CurrentNumber);
+            });
+            
+        }
+
+        public void Dispose()
+        {
+            OnGameEnded = null;
+            OnGameStarted = null;
+            OnRoundEnded = null;
+            OnRoundStarted = null;
+            OnUserGuessed = null;
+        }
+    }
+}

NadekoBot.Core/Modules/Games/Common/Poll.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Discord;
+using Discord.WebSocket;
+using NadekoBot.Extensions;
+using NadekoBot.Core.Services.Impl;
+
+namespace NadekoBot.Modules.Games.Common
+{
+    public class Poll
+    {
+        private readonly IUserMessage _originalMessage;
+        private readonly IGuild _guild;
+        private readonly string[] answers;
+        private readonly ConcurrentDictionary<ulong, int> _participants = new ConcurrentDictionary<ulong, int>();
+        private readonly string _question;
+        private readonly DiscordSocketClient _client;
+        private readonly NadekoStrings _strings;
+        private bool running = false;
+
+        public event Action<ulong> OnEnded = delegate { };
+
+        public Poll(DiscordSocketClient client, NadekoStrings strings, IUserMessage umsg, string question, IEnumerable<string> enumerable)
+        {
+            _client = client;
+            _strings = strings;
+
+            _originalMessage = umsg;
+            _guild = ((ITextChannel)umsg.Channel).Guild;
+            _question = question;
+            answers = enumerable as string[] ?? enumerable.ToArray();
+        }
+
+        public EmbedBuilder GetStats(string title)
+        {
+            var results = _participants.GroupBy(kvp => kvp.Value)
+                                .ToDictionary(x => x.Key, x => x.Sum(kvp => 1))
+                                .OrderByDescending(kvp => kvp.Value)
+                                .ToArray();
+
+            var eb = new EmbedBuilder().WithTitle(title);
+
+            var sb = new StringBuilder()
+                .AppendLine(Format.Bold(_question))
+                .AppendLine();
+
+            var totalVotesCast = 0;
+            if (results.Length == 0)
+            {
+                sb.AppendLine(GetText("no_votes_cast"));
+            }
+            else
+            {
+                for (int i = 0; i < results.Length; i++)
+                {
+                    var result = results[i];
+                    sb.AppendLine(GetText("poll_result",
+                        result.Key,
+                        Format.Bold(answers[result.Key - 1]),
+                        Format.Bold(result.Value.ToString())));
+                    totalVotesCast += result.Value;
+                }
+            }
+
+
+            eb.WithDescription(sb.ToString())
+              .WithFooter(efb => efb.WithText(GetText("x_votes_cast", totalVotesCast)));
+
+            return eb;
+        }
+
+        public async Task StartPoll()
+        {
+            var msgToSend = GetText("poll_created", Format.Bold(_originalMessage.Author.Username)) + "\n\n" + Format.Bold(_question) + "\n";
+            var num = 1;
+            msgToSend = answers.Aggregate(msgToSend, (current, answ) => current + $"`{num++}.` **{answ}**\n");
+            msgToSend += "\n" + Format.Bold(GetText("poll_vote_public"));
+
+            await _originalMessage.Channel.SendConfirmAsync(msgToSend).ConfigureAwait(false);
+            running = true;
+        }
+
+        public async Task StopPoll()
+        {
+            running = false;
+            OnEnded(_guild.Id);
+            await _originalMessage.Channel.EmbedAsync(GetStats("POLL CLOSED")).ConfigureAwait(false);
+        }
+
+        public async Task<bool> TryVote(IUserMessage msg)
+        {
+            // has to be a user message
+            if (msg == null || msg.Author.IsBot || !running)
+                return false;
+
+            // has to be an integer
+            if (!int.TryParse(msg.Content, out int vote))
+                return false;
+            if (vote < 1 || vote > answers.Length)
+                return false;
+
+            IMessageChannel ch;
+            //if public, channel must be the same the poll started in
+            if (_originalMessage.Channel.Id != msg.Channel.Id)
+                return false;
+            ch = msg.Channel;
+
+            //user can vote only once
+            if (_participants.TryAdd(msg.Author.Id, vote))
+            {
+                var toDelete = await ch.SendConfirmAsync(GetText("poll_voted", Format.Bold(msg.Author.ToString()))).ConfigureAwait(false);
+                toDelete.DeleteAfter(5);
+                try { await msg.DeleteAsync().ConfigureAwait(false); } catch { }
+                return true;
+            }
+            return false;
+        }
+
+        private string GetText(string key, params object[] replacements)
+            => _strings.GetText(key,
+                _guild.Id,
+                "Games".ToLowerInvariant(),
+                replacements);
+    }
+}

NadekoBot.Core/Modules/Games/Common/TicTacToe.cs

@@ -0,0 +1,277 @@
+using Discord;
+using Discord.WebSocket;
+using NadekoBot.Extensions;
+using NadekoBot.Core.Services.Impl;
+using System;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace NadekoBot.Modules.Games.Common
+{
+    public class TicTacToe
+    {
+        enum Phase
+        {
+            Starting,
+            Started,
+            Ended
+        }
+
+        private readonly ITextChannel _channel;
+        private readonly IGuildUser[] _users;
+        private readonly int?[,] _state;
+        private Phase _phase;
+        private int _curUserIndex;
+        private readonly SemaphoreSlim _moveLock;
+
+        private IGuildUser _winner;
+
+        private readonly string[] _numbers = { ":one:", ":two:", ":three:", ":four:", ":five:", ":six:", ":seven:", ":eight:", ":nine:" };
+
+        public Action<TicTacToe> OnEnded;
+
+        private IUserMessage _previousMessage;
+        private Timer _timeoutTimer;
+        private readonly NadekoStrings _strings;
+        private readonly DiscordSocketClient _client;
+
+        public TicTacToe(NadekoStrings strings, DiscordSocketClient client, ITextChannel channel, IGuildUser firstUser)
+        {
+            _channel = channel;
+            _strings = strings;
+            _client = client;
+
+            _users = new[] { firstUser, null };
+            _state = new int?[,] {
+                    { null, null, null },
+                    { null, null, null },
+                    { null, null, null },
+                };
+
+            _phase = Phase.Starting;
+            _moveLock = new SemaphoreSlim(1, 1);
+        }
+
+        private string GetText(string key, params object[] replacements) =>
+            _strings.GetText(key,
+                _channel.GuildId,
+                typeof(Games).Name.ToLowerInvariant(),
+                replacements);
+
+        public string GetState()
+        {
+            var sb = new StringBuilder();
+            for (var i = 0; i < _state.GetLength(0); i++)
+            {
+                for (var j = 0; j < _state.GetLength(1); j++)
+                {
+                    sb.Append(_state[i, j] == null ? _numbers[i * 3 + j] : GetIcon(_state[i, j]));
+                    if (j < _state.GetLength(1) - 1)
+                        sb.Append("┃");
+                }
+                if (i < _state.GetLength(0) - 1)
+                    sb.AppendLine("\n──────────");
+            }
+
+            return sb.ToString();
+        }
+
+        public EmbedBuilder GetEmbed(string title = null)
+        {
+            var embed = new EmbedBuilder()
+                .WithOkColor()
+                .WithDescription(Environment.NewLine + GetState())
+                .WithAuthor(eab => eab.WithName(GetText("vs", _users[0], _users[1])));
+
+            if (!string.IsNullOrWhiteSpace(title))
+                embed.WithTitle(title);
+
+            if (_winner == null)
+            {
+                if (_phase == Phase.Ended)
+                    embed.WithFooter(efb => efb.WithText(GetText("ttt_no_moves")));
+                else
+                    embed.WithFooter(efb => efb.WithText(GetText("ttt_users_move", _users[_curUserIndex])));
+            }
+            else
+                embed.WithFooter(efb => efb.WithText(GetText("ttt_has_won", _winner)));
+
+            return embed;
+        }
+
+        private static string GetIcon(int? val)
+        {
+            switch (val)
+            {
+                case 0:
+                    return "❌";
+                case 1:
+                    return "⭕";
+                case 2:
+                    return "❎";
+                case 3:
+                    return "🅾";
+                default:
+                    return "⬛";
+            }
+        }
+
+        public async Task Start(IGuildUser user)
+        {
+            if (_phase == Phase.Started || _phase == Phase.Ended)
+            {
+                await _channel.SendErrorAsync(user.Mention + GetText("ttt_already_running")).ConfigureAwait(false);
+                return;
+            }
+            else if (_users[0] == user)
+            {
+                await _channel.SendErrorAsync(user.Mention + GetText("ttt_against_yourself")).ConfigureAwait(false);
+                return;
+            }
+
+            _users[1] = user;
+
+            _phase = Phase.Started;
+
+            _timeoutTimer = new Timer(async (_) =>
+            {
+                await _moveLock.WaitAsync();
+                try
+                {
+                    if (_phase == Phase.Ended)
+                        return;
+
+                    _phase = Phase.Ended;
+                    if (_users[1] != null)
+                    {
+                        _winner = _users[_curUserIndex ^= 1];
+                        var del = _previousMessage?.DeleteAsync();
+                        try
+                        {
+                            await _channel.EmbedAsync(GetEmbed(GetText("ttt_time_expired"))).ConfigureAwait(false);
+                            if (del != null)
+                                await del.ConfigureAwait(false);
+                        }
+                        catch { }
+                    }
+
+                    OnEnded?.Invoke(this);
+                }
+                catch { }
+                finally
+                {
+                    _moveLock.Release();
+                }
+            }, null, 15000, Timeout.Infinite);
+
+            _client.MessageReceived += Client_MessageReceived;
+
+
+            _previousMessage = await _channel.EmbedAsync(GetEmbed(GetText("game_started"))).ConfigureAwait(false);
+        }
+
+        private bool IsDraw()
+        {
+            for (var i = 0; i < 3; i++)
+            {
+                for (var j = 0; j < 3; j++)
+                {
+                    if (_state[i, j] == null)
+                        return false;
+                }
+            }
+            return true;
+        }
+
+        private Task Client_MessageReceived(SocketMessage msg)
+        {
+            var _ = Task.Run(async () =>
+            {
+                await _moveLock.WaitAsync().ConfigureAwait(false);
+                try
+                {
+                    var curUser = _users[_curUserIndex];
+                    if (_phase == Phase.Ended || msg.Author?.Id != curUser.Id)
+                        return;
+
+                    if (int.TryParse(msg.Content, out var index) &&
+                        --index >= 0 &&
+                        index <= 9 &&
+                        _state[index / 3, index % 3] == null)
+                    {
+                        _state[index / 3, index % 3] = _curUserIndex;
+
+                        // i'm lazy
+                        if (_state[index / 3, 0] == _state[index / 3, 1] && _state[index / 3, 1] == _state[index / 3, 2])
+                        {
+                            _state[index / 3, 0] = _curUserIndex + 2;
+                            _state[index / 3, 1] = _curUserIndex + 2;
+                            _state[index / 3, 2] = _curUserIndex + 2;
+
+                            _phase = Phase.Ended;
+                        }
+                        else if (_state[0, index % 3] == _state[1, index % 3] && _state[1, index % 3] == _state[2, index % 3])
+                        {
+                            _state[0, index % 3] = _curUserIndex + 2;
+                            _state[1, index % 3] = _curUserIndex + 2;
+                            _state[2, index % 3] = _curUserIndex + 2;
+
+                            _phase = Phase.Ended;
+                        }
+                        else if (_curUserIndex == _state[0, 0] && _state[0, 0] == _state[1, 1] && _state[1, 1] == _state[2, 2])
+                        {
+                            _state[0, 0] = _curUserIndex + 2;
+                            _state[1, 1] = _curUserIndex + 2;
+                            _state[2, 2] = _curUserIndex + 2;
+
+                            _phase = Phase.Ended;
+                        }
+                        else if (_curUserIndex == _state[0, 2] && _state[0, 2] == _state[1, 1] && _state[1, 1] == _state[2, 0])
+                        {
+                            _state[0, 2] = _curUserIndex + 2;
+                            _state[1, 1] = _curUserIndex + 2;
+                            _state[2, 0] = _curUserIndex + 2;
+
+                            _phase = Phase.Ended;
+                        }
+                        var reason = "";
+
+                        if (_phase == Phase.Ended) // if user won, stop receiving moves
+                        {
+                            reason = GetText("ttt_matched_three");
+                            _winner = _users[_curUserIndex];
+                            _client.MessageReceived -= Client_MessageReceived;
+                            OnEnded?.Invoke(this);
+                        }
+                        else if (IsDraw())
+                        {
+                            reason = GetText("ttt_a_draw");
+                            _phase = Phase.Ended;
+                            _client.MessageReceived -= Client_MessageReceived;
+                            OnEnded?.Invoke(this);
+                        }
+
+                        var sendstate = Task.Run(async () =>
+                        {
+                            var del1 = msg.DeleteAsync();
+                            var del2 = _previousMessage?.DeleteAsync();
+                            try { _previousMessage = await _channel.EmbedAsync(GetEmbed(reason)); } catch { }
+                            try { await del1; } catch { }
+                            try { if (del2 != null) await del2; } catch { }
+                        });
+                        _curUserIndex ^= 1;
+
+                        _timeoutTimer.Change(15000, Timeout.Infinite);
+                    }
+                }
+                finally
+                {
+                    _moveLock.Release();
+                }
+            });
+
+            return Task.CompletedTask;
+        }
+    }
+}

NadekoBot.Core/Modules/Games/Common/Trivia/TriviaGame.cs

@@ -0,0 +1,266 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Net;
+using Discord.WebSocket;
+using NadekoBot.Extensions;
+using NadekoBot.Core.Services;
+using NadekoBot.Core.Services.Impl;
+using NLog;
+
+namespace NadekoBot.Modules.Games.Common.Trivia
+{
+    public class TriviaGame
+    {
+        private readonly SemaphoreSlim _guessLock = new SemaphoreSlim(1, 1);
+        private readonly Logger _log;
+        private readonly NadekoStrings _strings;
+        private readonly DiscordSocketClient _client;
+        private readonly IBotConfigProvider _bc;
+        private readonly CurrencyService _cs;
+
+        public IGuild Guild { get; }
+        public ITextChannel Channel { get; }
+
+        private readonly int _questionDurationMiliseconds = 30000;
+        private readonly int _hintTimeoutMiliseconds = 6000;
+        public bool ShowHints { get; }
+        public bool IsPokemon { get; }
+        private CancellationTokenSource _triviaCancelSource;
+
+        public TriviaQuestion CurrentQuestion { get; private set; }
+        public HashSet<TriviaQuestion> OldQuestions { get; } = new HashSet<TriviaQuestion>();
+
+        public ConcurrentDictionary<IGuildUser, int> Users { get; } = new ConcurrentDictionary<IGuildUser, int>();
+
+        public bool GameActive { get; private set; }
+        public bool ShouldStopGame { get; private set; }
+
+        public int WinRequirement { get; }
+
+        public TriviaGame(NadekoStrings strings, DiscordSocketClient client, IBotConfigProvider bc,
+            CurrencyService cs, IGuild guild, ITextChannel channel,
+            bool showHints, int winReq, bool isPokemon)
+        {
+            _log = LogManager.GetCurrentClassLogger();
+            _strings = strings;
+            _client = client;
+            _bc = bc;
+            _cs = cs;
+
+            ShowHints = showHints;
+            Guild = guild;
+            Channel = channel;
+            WinRequirement = winReq;
+            IsPokemon = isPokemon;
+        }
+
+        private string GetText(string key, params object[] replacements) =>
+            _strings.GetText(key,
+                Channel.GuildId,
+                typeof(Games).Name.ToLowerInvariant(),
+                replacements);
+
+        public async Task StartGame()
+        {
+            while (!ShouldStopGame)
+            {
+                // reset the cancellation source
+                _triviaCancelSource = new CancellationTokenSource();
+
+                // load question
+                CurrentQuestion = TriviaQuestionPool.Instance.GetRandomQuestion(OldQuestions, IsPokemon);
+                if (string.IsNullOrWhiteSpace(CurrentQuestion?.Answer) || string.IsNullOrWhiteSpace(CurrentQuestion.Question))
+                {
+                    await Channel.SendErrorAsync(GetText("trivia_game"), GetText("failed_loading_question")).ConfigureAwait(false);
+                    return;
+                }
+                OldQuestions.Add(CurrentQuestion); //add it to exclusion list so it doesn't show up again
+
+                EmbedBuilder questionEmbed;
+                IUserMessage questionMessage;
+                try
+                {
+                    questionEmbed = new EmbedBuilder().WithOkColor()
+                        .WithTitle(GetText("trivia_game"))
+                        .AddField(eab => eab.WithName(GetText("category")).WithValue(CurrentQuestion.Category))
+                        .AddField(eab => eab.WithName(GetText("question")).WithValue(CurrentQuestion.Question));
+                    if (Uri.IsWellFormedUriString(CurrentQuestion.ImageUrl, UriKind.Absolute))
+                        questionEmbed.WithImageUrl(CurrentQuestion.ImageUrl);
+
+                    questionMessage = await Channel.EmbedAsync(questionEmbed).ConfigureAwait(false);
+                }
+                catch (HttpException ex) when (ex.HttpCode == System.Net.HttpStatusCode.NotFound ||
+                                               ex.HttpCode == System.Net.HttpStatusCode.Forbidden ||
+                                               ex.HttpCode == System.Net.HttpStatusCode.BadRequest)
+                {
+                    return;
+                }
+                catch (Exception ex)
+                {
+                    _log.Warn(ex);
+                    await Task.Delay(2000).ConfigureAwait(false);
+                    continue;
+                }
+
+                //receive messages
+                try
+                {
+                    _client.MessageReceived += PotentialGuess;
+
+                    //allow people to guess
+                    GameActive = true;
+                    try
+                    {
+                        //hint
+                        await Task.Delay(_hintTimeoutMiliseconds, _triviaCancelSource.Token).ConfigureAwait(false);
+                        if (ShowHints)
+                            try
+                            {
+                                await questionMessage.ModifyAsync(m => m.Embed = questionEmbed.WithFooter(efb => efb.WithText(CurrentQuestion.GetHint())).Build())
+                                    .ConfigureAwait(false);
+                            }
+                            catch (HttpException ex) when (ex.HttpCode == System.Net.HttpStatusCode.NotFound || ex.HttpCode == System.Net.HttpStatusCode.Forbidden)
+                            {
+                                break;
+                            }
+                            catch (Exception ex) { _log.Warn(ex); }
+
+                        //timeout
+                        await Task.Delay(_questionDurationMiliseconds - _hintTimeoutMiliseconds, _triviaCancelSource.Token).ConfigureAwait(false);
+
+                    }
+                    catch (TaskCanceledException) { } //means someone guessed the answer
+                }
+                finally
+                {
+                    GameActive = false;
+                    _client.MessageReceived -= PotentialGuess;
+                }
+                if (!_triviaCancelSource.IsCancellationRequested)
+                {
+                    try
+                    {
+                        var embed = new EmbedBuilder().WithErrorColor()
+                            .WithTitle(GetText("trivia_game"))
+                            .WithDescription(GetText("trivia_times_up", Format.Bold(CurrentQuestion.Answer)));
+                        if (Uri.IsWellFormedUriString(CurrentQuestion.AnswerImageUrl, UriKind.Absolute))
+                            embed.WithImageUrl(CurrentQuestion.AnswerImageUrl);
+
+                        await Channel.EmbedAsync(embed).ConfigureAwait(false);
+                    }
+                    catch (Exception ex)
+                    {
+                        _log.Warn(ex);
+                    }
+                }
+                await Task.Delay(5000).ConfigureAwait(false);
+            }
+        }
+
+        public async Task EnsureStopped()
+        {
+            ShouldStopGame = true;
+
+            await Channel.EmbedAsync(new EmbedBuilder().WithOkColor()
+                    .WithAuthor(eab => eab.WithName("Trivia Game Ended"))
+                    .WithTitle("Final Results")
+                    .WithDescription(GetLeaderboard())).ConfigureAwait(false);
+        }
+
+        public async Task StopGame()
+        {
+            var old = ShouldStopGame;
+            ShouldStopGame = true;
+            if (!old)
+                try { await Channel.SendConfirmAsync(GetText("trivia_game"), GetText("trivia_stopping")).ConfigureAwait(false); } catch (Exception ex) { _log.Warn(ex); }
+        }
+
+        private Task PotentialGuess(SocketMessage imsg)
+        {
+            var _ = Task.Run(async () =>
+            {
+                try
+                {
+                    if (imsg.Author.IsBot)
+                        return;
+
+                    var umsg = imsg as SocketUserMessage;
+
+                    var textChannel = umsg?.Channel as ITextChannel;
+                    if (textChannel == null || textChannel.Guild != Guild)
+                        return;
+
+                    var guildUser = (IGuildUser)umsg.Author;
+
+                    var guess = false;
+                    await _guessLock.WaitAsync().ConfigureAwait(false);
+                    try
+                    {
+                        if (GameActive && CurrentQuestion.IsAnswerCorrect(umsg.Content) && !_triviaCancelSource.IsCancellationRequested)
+                        {
+                            Users.AddOrUpdate(guildUser, 1, (gu, old) => ++old);
+                            guess = true;
+                        }
+                    }
+                    finally { _guessLock.Release(); }
+                    if (!guess) return;
+                    _triviaCancelSource.Cancel();
+
+
+                    if (Users[guildUser] == WinRequirement)
+                    {
+                        ShouldStopGame = true;
+                        try
+                        {
+                            var embedS = new EmbedBuilder().WithOkColor()
+                                .WithTitle(GetText("trivia_game"))
+                                .WithDescription(GetText("trivia_win",
+                                    guildUser.Mention,
+                                    Format.Bold(CurrentQuestion.Answer)));
+                            if (Uri.IsWellFormedUriString(CurrentQuestion.AnswerImageUrl, UriKind.Absolute))
+                                embedS.WithImageUrl(CurrentQuestion.AnswerImageUrl);
+                            await Channel.EmbedAsync(embedS).ConfigureAwait(false);
+                        }
+                        catch
+                        {
+                            // ignored
+                        }
+                        var reward = _bc.BotConfig.TriviaCurrencyReward;
+                        if (reward > 0)
+                            await _cs.AddAsync(guildUser, "Won trivia", reward, true).ConfigureAwait(false);
+                        return;
+                    }
+                    var embed = new EmbedBuilder().WithOkColor()
+                        .WithTitle(GetText("trivia_game"))
+                        .WithDescription(GetText("trivia_guess", guildUser.Mention, Format.Bold(CurrentQuestion.Answer)));
+                    if (Uri.IsWellFormedUriString(CurrentQuestion.AnswerImageUrl, UriKind.Absolute))
+                        embed.WithImageUrl(CurrentQuestion.AnswerImageUrl);
+                    await Channel.EmbedAsync(embed).ConfigureAwait(false);
+                }
+                catch (Exception ex) { _log.Warn(ex); }
+            });
+            return Task.CompletedTask;
+        }
+
+        public string GetLeaderboard()
+        {
+            if (Users.Count == 0)
+                return GetText("no_results");
+
+            var sb = new StringBuilder();
+
+            foreach (var kvp in Users.OrderByDescending(kvp => kvp.Value))
+            {
+                sb.AppendLine(GetText("trivia_points", Format.Bold(kvp.Key.ToString()), kvp.Value).SnPl(kvp.Value));
+            }
+
+            return sb.ToString();
+        }
+    }
+}

NadekoBot.Core/Modules/Games/Common/Trivia/TriviaQuestion.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using NadekoBot.Extensions;
+
+// THANKS @ShoMinamimoto for suggestions and coding help
+namespace NadekoBot.Modules.Games.Common.Trivia
+{
+    public class TriviaQuestion
+    {
+        //represents the min size to judge levDistance with
+        private static readonly HashSet<Tuple<int, int>> strictness = new HashSet<Tuple<int, int>> {
+            new Tuple<int, int>(9, 0),
+            new Tuple<int, int>(14, 1),
+            new Tuple<int, int>(19, 2),
+            new Tuple<int, int>(22, 3),
+        };
+        public static int maxStringLength = 22;
+
+        public string Category { get; set; }
+        public string Question { get; set; }
+        public string ImageUrl { get; set; }
+        public string AnswerImageUrl { get; set; }
+        public string Answer { get; set; }
+        private string _cleanAnswer;
+        public string CleanAnswer => _cleanAnswer ?? (_cleanAnswer = Clean(Answer));
+
+        public TriviaQuestion(string q, string a, string c, string img = null, string answerImage = null)
+        {
+            this.Question = q;
+            this.Answer = a;
+            this.Category = c;
+            this.ImageUrl = img;
+            this.AnswerImageUrl = answerImage ?? img;
+        }
+
+        public string GetHint() => Scramble(Answer);
+
+        public bool IsAnswerCorrect(string guess)
+        {
+            if (Answer.Equals(guess))
+            {
+                return true;
+            }
+            var cleanGuess = Clean(guess);
+            if (CleanAnswer.Equals(cleanGuess))
+            {
+                return true;
+            }
+
+            int levDistanceClean = CleanAnswer.LevenshteinDistance(cleanGuess);
+            int levDistanceNormal = Answer.LevenshteinDistance(guess);
+            return JudgeGuess(CleanAnswer.Length, cleanGuess.Length, levDistanceClean)
+                || JudgeGuess(Answer.Length, guess.Length, levDistanceNormal);
+        }
+
+        private bool JudgeGuess(int guessLength, int answerLength, int levDistance)
+        {
+            foreach (Tuple<int, int> level in strictness)
+            {
+                if (guessLength <= level.Item1 || answerLength <= level.Item1)
+                {
+                    if (levDistance <= level.Item2)
+                        return true;
+                    else
+                        return false;
+                }
+            }
+            return false;
+        }
+
+        private string Clean(string str)
+        {
+            str = " " + str.ToLower() + " ";
+            str = Regex.Replace(str, "\\s+", " ");
+            str = Regex.Replace(str, "[^\\w\\d\\s]", "");
+            //Here's where custom modification can be done
+            str = Regex.Replace(str, "\\s(a|an|the|of|in|for|to|as|at|be)\\s", " ");
+            //End custom mod and cleanup whitespace
+            str = Regex.Replace(str, "^\\s+", "");
+            str = Regex.Replace(str, "\\s+$", "");
+            //Trim the really long answers
+            str = str.Length <= maxStringLength ? str : str.Substring(0, maxStringLength);
+            return str;
+        }
+
+        private static string Scramble(string word)
+        {
+            var letters = word.ToCharArray();
+            var count = 0;
+            for (var i = 0; i < letters.Length; i++)
+            {
+                if (letters[i] == ' ')
+                    continue;
+
+                count++;
+                if (count <= letters.Length / 5)
+                    continue;
+
+                if (count % 3 == 0)
+                    continue;
+
+                if (letters[i] != ' ')
+                    letters[i] = '_';
+            }
+            return string.Join(" ", new string(letters).Replace(" ", " \u2000").AsEnumerable());
+        }
+    }
+}

NadekoBot.Core/Modules/Games/Common/Trivia/TriviaQuestionPool.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using NadekoBot.Common;
+using NadekoBot.Extensions;
+using Newtonsoft.Json;
+
+namespace NadekoBot.Modules.Games.Common.Trivia
+{
+    public class TriviaQuestionPool
+    {
+        public class PokemonNameId
+        {
+            public int Id { get; set; }
+            public string Name { get; set; }
+        }
+
+        private static TriviaQuestionPool _instance;
+        public static TriviaQuestionPool Instance { get; } = _instance ?? (_instance = new TriviaQuestionPool());
+
+        private const string questionsFile = "data/trivia_questions.json";
+        private const string pokemonMapPath = "data/pokemon/name-id_map4.json";
+        private readonly int maxPokemonId;
+
+        private Random rng { get; } = new NadekoRandom();
+        
+        private TriviaQuestion[] pool { get; }
+        private ImmutableDictionary<int, string> map { get; }
+
+        static TriviaQuestionPool() { }
+
+        private TriviaQuestionPool()
+        {
+            pool = JsonConvert.DeserializeObject<TriviaQuestion[]>(File.ReadAllText(questionsFile));
+            map = JsonConvert.DeserializeObject<PokemonNameId[]>(File.ReadAllText(pokemonMapPath))
+                    .ToDictionary(x => x.Id, x => x.Name)
+                    .ToImmutableDictionary();
+
+            maxPokemonId = 721; //xd
+        }
+
+        public TriviaQuestion GetRandomQuestion(HashSet<TriviaQuestion> exclude, bool isPokemon)
+        {
+            if (pool.Length == 0)
+                return null;
+
+            if (isPokemon)
+            {
+                var num = rng.Next(1, maxPokemonId + 1);
+                return new TriviaQuestion("Who's That Pokémon?", 
+                    map[num].ToTitleCase(),
+                    "Pokemon",
+                    $@"http://nadekobot.me/images/pokemon/shadows/{num}.png",
+                    $@"http://nadekobot.me/images/pokemon/real/{num}.png");
+            }
+            TriviaQuestion randomQuestion;
+            while (exclude.Contains(randomQuestion = pool[rng.Next(0, pool.Length)])) ;
+
+            return randomQuestion;
+        }
+    }
+}

NadekoBot.Core/Modules/Games/Common/TypingArticle.cs

@@ -0,0 +1,8 @@
+namespace NadekoBot.Modules.Games.Common
+{
+    public class TypingArticle
+    {
+        public string Title { get; set; }
+        public string Text { get; set; }
+    }
+}

NadekoBot.Core/Modules/Games/Common/TypingGame.cs

@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading.Tasks;
+using Discord;
+using Discord.WebSocket;
+using NadekoBot.Common;
+using NadekoBot.Extensions;
+using NadekoBot.Modules.Games.Services;
+using NLog;
+
+namespace NadekoBot.Modules.Games.Common
+{
+    public class TypingGame
+    {
+        public const float WORD_VALUE = 4.5f;
+        public ITextChannel Channel { get; }
+        public string CurrentSentence { get; private set; }
+        public bool IsActive { get; private set; }
+        private readonly Stopwatch sw;
+        private readonly List<ulong> finishedUserIds;
+        private readonly DiscordSocketClient _client;
+        private readonly GamesService _games;
+        private readonly string _prefix;
+
+        private Logger _log { get; }
+
+        public TypingGame(GamesService games, DiscordSocketClient client, ITextChannel channel, string prefix) //kek@prefix
+        {
+            _log = LogManager.GetCurrentClassLogger();
+            _games = games;
+            _client = client;
+            _prefix = prefix;
+
+            this.Channel = channel;
+            IsActive = false;
+            sw = new Stopwatch();
+            finishedUserIds = new List<ulong>();
+        }
+
+        public async Task<bool> Stop()
+        {
+            if (!IsActive) return false;
+            _client.MessageReceived -= AnswerReceived;
+            finishedUserIds.Clear();
+            IsActive = false;
+            sw.Stop();
+            sw.Reset();
+            try { await Channel.SendConfirmAsync("Typing contest stopped.").ConfigureAwait(false); } catch (Exception ex) { _log.Warn(ex); }
+            return true;
+        }
+
+        public async Task Start()
+        {
+            if (IsActive) return; // can't start running game
+            IsActive = true;
+            CurrentSentence = GetRandomSentence();
+            var i = (int)(CurrentSentence.Length / WORD_VALUE * 1.7f);
+            try
+            {
+                await Channel.SendConfirmAsync($@":clock2: Next contest will last for {i} seconds. Type the bolded text as fast as you can.").ConfigureAwait(false);
+
+
+                var msg = await Channel.SendMessageAsync("Starting new typing contest in **3**...").ConfigureAwait(false);
+                await Task.Delay(1000).ConfigureAwait(false);
+                try
+                {
+                    await msg.ModifyAsync(m => m.Content = "Starting new typing contest in **2**...").ConfigureAwait(false);
+                    await Task.Delay(1000).ConfigureAwait(false);
+                    await msg.ModifyAsync(m => m.Content = "Starting new typing contest in **1**...").ConfigureAwait(false);
+                    await Task.Delay(1000).ConfigureAwait(false);
+                }
+                catch (Exception ex) { _log.Warn(ex); }
+
+                await msg.ModifyAsync(m => m.Content = Format.Bold(Format.Sanitize(CurrentSentence.Replace(" ", " \x200B")).SanitizeMentions())).ConfigureAwait(false);
+                sw.Start();
+                HandleAnswers();
+
+                while (i > 0)
+                {
+                    await Task.Delay(1000).ConfigureAwait(false);
+                    i--;
+                    if (!IsActive)
+                        return;
+                }
+
+            }
+            catch { }
+            finally
+            {
+                await Stop().ConfigureAwait(false);
+            }
+        }
+
+        public string GetRandomSentence()
+        {
+            if (_games.TypingArticles.Any())
+                return _games.TypingArticles[new NadekoRandom().Next(0, _games.TypingArticles.Count)].Text;
+            else
+                return $"No typing articles found. Use {_prefix}typeadd command to add a new article for typing.";
+
+        }
+
+        private void HandleAnswers()
+        {
+            _client.MessageReceived += AnswerReceived;
+        }
+
+        private Task AnswerReceived(SocketMessage imsg)
+        {
+            var _ = Task.Run(async () =>
+            {
+                try
+                {
+                    if (imsg.Author.IsBot)
+                        return;
+                    var msg = imsg as SocketUserMessage;
+                    if (msg == null)
+                        return;
+
+                    if (this.Channel == null || this.Channel.Id != msg.Channel.Id) return;
+
+                    var guess = msg.Content;
+
+                    var distance = CurrentSentence.LevenshteinDistance(guess);
+                    var decision = Judge(distance, guess.Length);
+                    if (decision && !finishedUserIds.Contains(msg.Author.Id))
+                    {
+                        var elapsed = sw.Elapsed;
+                        var wpm = CurrentSentence.Length / WORD_VALUE / elapsed.TotalSeconds * 60;
+                        finishedUserIds.Add(msg.Author.Id);
+                        await this.Channel.EmbedAsync(new EmbedBuilder().WithOkColor()
+                            .WithTitle($"{msg.Author} finished the race!")
+                            .AddField(efb => efb.WithName("Place").WithValue($"#{finishedUserIds.Count}").WithIsInline(true))
+                            .AddField(efb => efb.WithName("WPM").WithValue($"{wpm:F1} *[{elapsed.TotalSeconds:F2}sec]*").WithIsInline(true))
+                            .AddField(efb => efb.WithName("Errors").WithValue(distance.ToString()).WithIsInline(true)))
+                                .ConfigureAwait(false);
+                        if (finishedUserIds.Count % 4 == 0)
+                        {
+                            await this.Channel.SendConfirmAsync($":exclamation: A lot of people finished, here is the text for those still typing:\n\n**{Format.Sanitize(CurrentSentence.Replace(" ", " \x200B")).SanitizeMentions()}**").ConfigureAwait(false);
+                        }
+                    }
+                }
+                catch (Exception ex) { _log.Warn(ex); }
+            });
+            return Task.CompletedTask;
+        }
+
+        private bool Judge(int errors, int textLength) => errors <= textLength / 25;
+
+    }
+}