Streamerbot Hangman Game

using System;
using System.Globalization;
using System.Collections.Generic;

public class CPHInline
{
    public bool Execute()
    {
        // your main code goes here
        CPH.TryGetArg("user", out string user);
        CPH.TryGetArg("msgId", out string replyId);
        CPH.TryGetArg("commandName", out string commandName);
        CPH.TryGetArg("rewardName", out string rewardName);
        CPH.TryGetArg("rewardId", out string rewardId);
        string gameState = CPH.GetGlobalVar<string>("HangmanState", false);

        // check gameState to determine what to do
        // Hangman game initializer
        if ((gameState == "offline" || string.IsNullOrEmpty(gameState)) && rewardName == "Play Hangman")
        {
            // initialize all the variables to set up the game
            Dictionary<string, List<string>> possibleWordsByCategory = new Dictionary<string, List<string>>();
            possibleWordsByCategory["Animals"] = new List<string>{"alligator", "bear", "cheetah", "deer", "elephant", "fox", "giraffe", "hippo", "jaguar", "kangaroo", "lion", "monkey", "otter", "penguin", "rabbit", "shark", "tiger", "wolf", "yak", "zebra"};
            possibleWordsByCategory["Food and Drink"] = new List<string>{"apple", "banana", "broccoli", "champagne", "cocktail", "coffee", "courgette", "croissant", "curry", "eggs", "espresso", "hamburger", "juice", "kimchi", "lollipop", "macaroni", "onions", "orange", "pasta", "pesto", "porridge", "potatoes", "poutine", "steak", "sushi", "tofu", "vodka", "water", "zucchini"};
            possibleWordsByCategory["Game Characters"] = new List<string>{"alduin", "cloud", "dogmeat", "doomguy", "glados", "guybrush", "haiku", "kassandra", "kratos", "luigi", "mario", "megaman", "owlboy", "parrapa", "pikachu", "ratchet", "rayman", "samus", "sonic", "spyro", "steve", "sylvanas", "toad", "yoshi"};
            possibleWordsByCategory["Sports"] = new List<string>{"badminton", "baseball", "basketball", "bowling", "cycling", "dodgeball", "fencing", "football", "golf", "hockey", "lacrosse", "rowing", "rugby", "soccer", "skiing", "snowboarding", "swimming", "tennis", "volleyball", "wrestling"};
            possibleWordsByCategory["Video Games"] = new List<string>{"balatro", "bloodborne", "broforce", "brotato", "civilization", "crosscode", "dishonored", "exapunks", "hearthstone", "journey", "maplestory", "megaman", "monaco", "morrowind", "oblivion", "owlboy", "phasmophobia", "pokemon", "splodey", "starcraft", "subnautica", "terraria", "tetris", "tunic", "warcraft"};

            List<string> categories = new List<string>(possibleWordsByCategory.Keys);

            string currentCategory = categories[CPH.Between(0, categories.Count - 1)];
            CPH.SetGlobalVar("Hangman Category", currentCategory, false);

            int lengthOfCategory = possibleWordsByCategory[currentCategory].Count;
            string wordToGuess = possibleWordsByCategory[currentCategory][CPH.Between(0, lengthOfCategory - 1)];

            CPH.SetGlobalVar("Word To Guess", wordToGuess, false);

            // intialize the array for the output with _'s for guessed characters
            char[] outputList = new char[wordToGuess.Length];
            for (int i = 0; i < wordToGuess.Length; i++)
            {
                outputList[i] = '_';
            }

            CPH.SetGlobalVar("Hangman Output List", outputList, false);

            string guessedOutput = string.Join(" ", outputList);
            CPH.SendMessage("Let's play Hangman! Guess a letter or try to guess the word! Use !hm to guess");
            CPH.SendMessage(guessedOutput + $" (Category: {currentCategory})");

            // set non-persisted global variables for guessed letters, game state, and how many guesses are left
            List<string> previousGuesses = new List<string>();
            CPH.SetGlobalVar("Previous Guesses", previousGuesses, false);
            CPH.SetGlobalVar("HangmanState", "playing", false);
            CPH.SetGlobalVar("Guesses Left", 10, false);
            CPH.SetGlobalVar("Hangman Reward ID", rewardId, false);
            CPH.PauseReward(rewardId);

        }
        // if player uses !hmstate, just output the current guessed string
        else if (gameState == "playing" && commandName == "Hangman State")
        {
            char[] outputList = CPH.GetGlobalVar<char[]>("Hangman Output List", false);
            string currentCategory = CPH.GetGlobalVar<string>("Hangman Category", false);
            CPH.SendMessage(string.Join(" ", outputList));
            return true;
        }
        // someone performed a guess
        else if (gameState == "playing" && commandName == "Hangman Guess")
        {
            string wordToGuess = CPH.GetGlobalVar<string>("Word To Guess", false);
            char[] outputList = CPH.GetGlobalVar<char[]>("Hangman Output List", false);
            CPH.TryGetArg("rawInput", out string rawInputEscaped);
            rawInputEscaped = rawInputEscaped.ToLower();
            List<string> previousGuesses = CPH.GetGlobalVar<List<string>>("Previous Guesses", false);

            // player didn't provide a letter or a word
            if (string.IsNullOrEmpty(rawInputEscaped))
            {
                CPH.TwitchReplyToMessage("Guess either a single character or a word of the correct length", replyId);
                return true;
            }
            // player entered a single character
            else if (rawInputEscaped.Length == 1)
            {
                if (previousGuesses.Contains(rawInputEscaped))
                {
                    CPH.TwitchReplyToMessage("That character has already been guessed!", replyId);
                }
                else
                {
                    bool correctGuess = false;
                    char guessedChar = char.Parse(rawInputEscaped);
                    previousGuesses.Add(rawInputEscaped);
                    CPH.SetGlobalVar("Previous Guesses", previousGuesses, false);

                    for (int i = 0; i < wordToGuess.Length; i++)
                    {
                        if (wordToGuess[i] == guessedChar)
                        {
                            outputList[i] = guessedChar;
                            correctGuess = true;
                        }
                    }
                    if (correctGuess)
                    {
                        CPH.SendMessage("Good guess! That's a hit!");
                        CPH.SetGlobalVar("Hangman Output List", outputList, false);
                    }
                    else
                    {
                        int guessesLeft = CPH.GetGlobalVar<int>("Guesses Left", false) - 1;
                        CPH.SetGlobalVar("Guesses Left", guessesLeft, false);
                        if (guessesLeft > 0)
                        {
                            CPH.SendMessage("Oof, that's a miss!");
                        }
                    }
                }
            }
            // player guessed a word
            else if (rawInputEscaped.Length == wordToGuess.Length && !(rawInputEscaped.Contains(" ")))
            {
                if (previousGuesses.Contains(rawInputEscaped))
                {
                    CPH.TwitchReplyToMessage("That word has already been guessed!", replyId);
                }
                else if (rawInputEscaped == wordToGuess)
                {
                    for (int i = 0; i < wordToGuess.Length; i++)
                    {
                        outputList[i] = wordToGuess[i];
                    }
                }
                else
                {
                    previousGuesses.Add(rawInputEscaped);
                    CPH.SetGlobalVar("Previous Guesses", previousGuesses, false);
                    int guessesLeft = CPH.GetGlobalVar<int>("Guesses Left", false) - 2;
                    CPH.SetGlobalVar("Guesses Left", guessesLeft, false);
                    if (guessesLeft > 0)
                    {
                        CPH.SendMessage("Oof, that's a miss! That costs you 2 guesses!");
                    }

                }
            }
            // player provided a guess, but the guess is either a sentence or a word of incorrect length
            else
            {
                CPH.TwitchReplyToMessage("Guess either a character or a word of the correct length", replyId);
                return true;
            }

            // construct the word guessed so far from the outputList
            string guessedWord = string.Join("", outputList);
            // the word has been guessed, either by letters or outright
            if (guessedWord == wordToGuess)
            {
                CPH.SendMessage($"Amazing! {user} guessed the word! It was \"{guessedWord}\"!");
                CPH.SetGlobalVar("HangmanState", "offline", false);
                CPH.UnPauseReward(CPH.GetGlobalVar<string>("Hangman Reward ID", false));
            }
            // the word has not been fully guessed yet
            else
            {
                int guessesLeft = CPH.GetGlobalVar<int>("Guesses Left", false);
                // players ran out of guesses and lose
                if (guessesLeft <= 0)
                {
                    CPH.SendMessage($"Oof, you ran out of guesses! The word we were looking for was \"{wordToGuess}\"");
                    CPH.SetGlobalVar("HangmanState", "offline", false);
                    CPH.UnPauseReward(CPH.GetGlobalVar<string>("Hangman Reward ID", false));
                }
                // players still have more guesses, continue the game
                else
                {
                    string guessedOutput = string.Join(" ", outputList);
                    string currentCategory = CPH.GetGlobalVar<string>("Hangman Category", false);
                    CPH.SendMessage(guessedOutput + $" (Category: {currentCategory})");

                    previousGuesses.Sort((x, y) => {
                        int ret = x.Length.CompareTo(y.Length);
                        return ret != 0 ? ret : x.CompareTo(y);});
                    string previousGuessesOutput = string.Join(", ", previousGuesses);
                    CPH.SendMessage($"You can still make {guessesLeft} error(s). Already guessed: {previousGuessesOutput}.");
                }
            }
        }
        return true;
    }
}