Hangman

AnswerPool.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Hangman
{
    public static class AnswerPool
    {
        public static string[] answerPool = new string[] { 
"HORROR", 
"TURTLE", 
"PEANUT", 
"ANAGRAM", 
"SQUARE", 
"PROPERLY", 
"IDENTITY", 
"YELLOW", 
"MARINE", 
"INNER", 
"SOUND", 
"WAGON", 
"PUBLICATION", 
"RURAL", 
"ITEM", 
"PHONE", 
"ATTEND", 
"DECISION", 
"UNABLE", 
"REPUBLICAN", 
"POSITION", 
"SUPPORT", 
"SYMBOL", 
"MACHINE", 
"DESCRIPTION", 
"TRAIN", 
"SUGGEST", 
"CREATE", 
"FORGET", 
"THOUGHT", 
"PRACTICE", 
"EXPERIENCE", 
"WELFARE", 
"CROWD", 
"LARGEST", 
"HUDSON", 
"PAYMENT", 
"HANDLE", 
"ABSENCE", 
"BITTER", 
"NEGATIVE", 
"VEHICLE", 
"SPEND", 
"JANUARY", 
"REMARK", 
"ASSIGN", 
"GRASS", 
"LOOSE", 
"WONDERFUL", 
"AUGUST", 
"TROOP", 
"SLIGHT", 
"WINDOWS", 
"VERSION", 
"BREAKFAST", 
"EXAMPLE", 
"EXPERIENCE", 
"DEPTH", 
"DISEASE", 
"BREATH", 
"MOTOR", 
"CONTENT",   
"CONFLICT", 
"ELEMENT", 
"DETAIL", 
"EVENTUALLY", 
"THEATER", 
"CORRECT", 
"WIDELY", 
"TRUST", 
"CENTER", 
"DOZEN",  
"BEDROOM", 
"ADVANCE", 
"DETECTIVE",  
"SILENCE", 
"CONTRARY", 
"FLESH",  
"ACHIEVE", 
"APPROVAL", 
"ESTATE", 
"SUPREME", 
"LISTEN", 
"GRADUAL", 
"OCTOBER", 
"ARTHUR", 
"STREAM", 
"ADVICE", 
"SURPRISE", 
"STAGE", 
"PLAYER", 
"AGREE", 
"UNIFORM", 
"ABROAD", 
"PAPER", 
"REAR", 
"COUSIN", 
"SITUATION", 
"BEGUN", 
"COLOR",  
"SHOULDER", 
"SICK", 
"ANGLE", 
"THROAT", 
"WAVES", 
"LAUGH", 
"MENTION", 
"ISSUE", 
"EXPENSE", 
"EXTREME", 
"INSTITUTE", 
"TELEVISION", 
"CHOOSE", 
"ASSEMBLY", 
"CHAIN", 
"LATIN", 
"MANUFACTURE", 
"PROUD", 
"WOODEN", 
"WORSE", 
"ADVERTISE", 
"EXTRA", 
"PHILADELPHIA", 
"ANGLE", 
"BRILLIANT", 
"CONVERSATION", 
"TAUGHT", 
"WELCOME", 
"CONVICTION", 
"FEMALE", 
"STRIKE", 
"ENGINE", 
"MOMENT", 
"DESIRE", 
"CONVINCE", 
"CHILDHOOD", 
"PROTESTANT", 
"EMPLOYEE", 
"SPEAKER", 
"CONSTITUTION", 
"PASSAGE", 
"MILLION", 
"REQUEST", 
"FIRMLY", 
"TENDENCY", 
"ACCEPTANCE", 
"DRIVER", 
"DEPEND", 
"IMPRESSIVE", 
"TRAGEDY", 
"INCIDENT", 
"OPERATOR", 
"PAYMENT", 
"CREATIVE", 
"SILENT", 
"MEASURE", 
"TWELVE", 
"GUARD", 
"INTEGRATION", 
"SCREEN", 
"MANTLE", 
"CHARLIE", 
"SHOOTING", 
"QUIETLY", 
"MISSILE", 
"FUNCTION", 
"FORMAL", 
"OCCASION", 
"COMPARISON", 
"RESISTANCE", 
"PERSONALITY", 
"CONCRETE", 
"PRECISELY", 
"SORRY", 
"MAINTAIN", 
"INTELLIGENCE", 
"ANGER", 
"ATTITUDE", 
"LIQUID", 
"HEARST", 
"CONSIDER",  
"EMPLOYMENT", 
"THOUSAND", 
"PROVISION", 
"PURCHASE", 
"SAFETY", 
"HONEST", 
"DENY", 
"NORTHERN", 
"MOSCOW", 
"EXPENSE", 
"EXPANSION", 
"TESTIMONY", 
"REMARKABLE", 
"SURELY", 
"HUMOR", 
"OPERA", 
"ITALIAN", 
"EVERYWHERE", 
"VACATION", 
"MODEL", 
"BOARD", 
"SUPPLY", 
"STAIRS", 
"CONCENTRATION", 
"UNKNOWN", 
"MOVEMENT", 
"ASPECT", 
"NUMEROUS", 
"INSTRUMENT", 
"ESSENTIALLY", 
"PERIOD", 
"PATTERN", 
"LINCOLN", 
"SUPERIOR", 
"RELATIVE", 
"RECOMMEND", 
"LEGISLATION", 
"CAROLINA", 
"VIOLENCE", 
"INSURANCE", 
"OPPOSITION", 
"CREATION" 
        };
    }
}

Graphics.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace Hangman
{
    class Graphics
    {
        string head, leftArm, rightArm, body, leftLeg, rightLeg;
        int wrongGuesses;
        char[] letters;
        ArrayList wrongLetters;

        public Graphics()
        {
            head = " ";
            body = " ";
            leftLeg = " ";
            rightLeg = " ";
            leftArm = " ";
            rightArm = " ";
            wrongLetters = new ArrayList();
        }

        public void NoOfLetters(int noOfLetters)
        {
                        letters = new char[noOfLetters];
            for (int i = 0; i < letters.Length; i++)
            {
                letters[i] = '_';
            }
        }

        public void WrongGuess(char guess)
        {
            //int wrongGuessed = game.returnGuessesLeft;// <- This doesn't work at all.
            ++wrongGuesses;
            switch (wrongGuesses)
            {
                case 1 :
                    head = "O";
                    break;
                case 2 :
                    body = "|";
                    break;
                case 3 :
                    leftArm = "-";
                    break;
                case 4 :
                    rightArm = "-";
                    break;
                case 5 :
                    leftLeg = "/";
                    break;
                case 6 :
                    rightLeg = "\\";
                    break;
            }

            wrongLetters.Add(guess);
        }

        public void RightGuess(char letter, int placement)
        {
            letters[placement] = letter;
        }

        public void ReloadGraphics()
        {
            Console.Clear();
            Console.WriteLine("===========HANGMAN===========  (v. 2.0 - by Zachary Shuford)\n\n\n");
            Console.WriteLine("         -----|");
            Console.WriteLine("         |   \\|");
            Console.WriteLine("         {0}    |", head);
            Console.WriteLine("        {0}{1}{2}   |", leftArm, body, rightArm);
            Console.WriteLine("        {0} {1}   |", leftLeg, rightLeg);
            Console.WriteLine("              |");
            Console.WriteLine("              |");
            Console.WriteLine("          =========\n\n\n");


            for (int i = 0; i < letters.Length; i++)
            {
                Console.Write("   " + "{0} ", letters[i]);
            }

            Console.Write("\n\n\n\nWrong letters guessed:");
            for (int i = 0; i < wrongLetters.Count; i++)
            {
                Console.Write("{0}, ", wrongLetters[i]);
            }
        }

        public void YouWin()
        {
            Console.WriteLine("\n\n=====================================");
            Console.WriteLine("==============You won!===============");
            Console.WriteLine("=====================================");
        }

        public void YouLose()
        {
            Console.WriteLine("\n\n=====================================");
            Console.WriteLine("==========Sorry, you lost!===========");
            Console.WriteLine("=====================================");
        }

        public void PlayAgain()
        {
            Console.Write("Would you like to play again? (y/n): ");
        }

        public void Error(int error)
        {
            switch (error)
            {
                case 1:
                    Console.WriteLine("You're only allowed to pick one letter at a time! Try again!");
                    break;
                case 2:
                    Console.WriteLine("You have to pick a letter! Try again!");
                    break;
            }
        }

        public void GetGuess()
        {
            Console.Write("\n\n\nGuess a letter:");
        }
    }
}

MainLogic.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Hangman
{
    class Start
    {
        static void Main()
        {
            try
            {
                string play = "y";
                Graphics myGraphics;

                while (play == "y")
                {
                    GameLogic theGame = new GameLogic();
                    myGraphics = theGame.Run();
                    myGraphics.PlayAgain();
                    play = Console.ReadLine().ToLower();
                    while (play != "y" && play != "n")
                    {
                        myGraphics.ReloadGraphics();
                        myGraphics.Error(3);
                        play = Console.ReadLine().ToLower();
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Something went horribly wrong! Please send Zachary the following error message:");
                Console.WriteLine(ex.Message);
            }
        }
    }

    class GameLogic
    {
        int wrongGuessesLeft;
        const int totalWrongGuesses = 6;
        char[] letters;
        char[] lettersCopy;
        int lettersLeft;
        Graphics myGraphics = new Graphics();
        Random myRandom = new Random();

        public GameLogic()
        {
            letters = AnswerPool.answerPool[myRandom.Next(0, AnswerPool.answerPool.Length)].ToCharArray();
            lettersCopy = new char[letters.Length];
            letters.CopyTo(lettersCopy, 0);
            lettersLeft = letters.Length;
            wrongGuessesLeft = totalWrongGuesses;
            myGraphics.NoOfLetters(letters.Length);
        }


       public Graphics Run()
       {
            while (wrongGuessesLeft > 0)
            {
                myGraphics.ReloadGraphics();
                char guess = GetGuess();

                bool answerCorrect = CheckGuess(guess, letters);

                if (answerCorrect == true)
                {
                    for (int i = 0; i < letters.Length; i++)
                    {
                        if (guess == letters[i])
                        {
                            --lettersLeft;
                            myGraphics.RightGuess(guess, i);
                            letters[i] = '\uFFFF';
                        }
                    }
                    if (lettersLeft == 0)
                    {
                        myGraphics.ReloadGraphics();
                        myGraphics.YouWin();
                        break;
                    }
                }
                else
                {
                    --wrongGuessesLeft;
                    myGraphics.WrongGuess(guess, wrongGuessesLeft);
                    myGraphics.ReloadGraphics();
                    if (wrongGuessesLeft == 0)
                    {
                        for (int i = 0; i < lettersCopy.Length; i++)
                        {
                            myGraphics.RightGuess(lettersCopy[i], i);
                        }
                        myGraphics.ReloadGraphics();
                        myGraphics.YouLose();
                    }
                }
            }
            return myGraphics;
       }

       private bool CheckGuess(char guess, char[] letters)
       {
           bool correct = false;
           foreach (int i in letters)
           {
               if (guess == i)
               {
                   correct = true;
               }
           }
           return correct;
       }

       private char GetGuess()
       {
           myGraphics.GetGuess();
           char[] guessArray;
           int errorCode = 0;
           do
           {
               myGraphics.Error(errorCode);
               guessArray = Console.ReadLine().ToCharArray();
               errorCode = GuessErrorCheck(guessArray);
           }
           while (errorCode > 0);
           char guess = Char.ToUpper(guessArray[0]);
           return guess;
       }

       private int GuessErrorCheck(char[] guess)
       {
           int error = 0;
           if (guess.Length > 1)
               error = 1;
           else if (guess.Length < 1 || guess[0] == ' ')
               error = 2;
           return error;
       }
    }
}

This is my own implementation of Hangman I wrote in C# while learning the language. Hope it helps anyone else that finds it. :)