public Character CreateCharacter(string factionType, string characterType, string name)
    {
        if (!Enum.TryParse <Faction>(factionType, out var factionObj))
        {
            throw new ArgumentException(string.Format(OutputMessage.InvalidFaction, factionType));
        }

        Character character = null;

        switch (characterType)
        {
        case "Warrior":
            character = new Warrior(name, factionObj);
            break;

        case "Cleric":
            character = new Cleric(name, factionObj);
            break;

        default:
            throw new ArgumentException(string.Format(OutputMessage.InvalidCharacter, characterType));
        }

        return(character);
    }
Exemple #2
0
        public string JoinParty(string[] args)
        {
            string faction       = args[0];
            string characterType = args[1];
            string name          = args[2];

            if (!Enum.TryParse(faction, out Faction factionResult))
            {
                throw new ArgumentException($"Invalid faction \"{faction}\"!");
            }

            if (characterType != "Warrior" && characterType != "Cleric")
            {
                throw new ArgumentException($"Invalid character type \"{characterType}\"!");
            }

            Character character;

            if (characterType == "Warrior")
            {
                character = new Warrior(name, factionResult);
            }
            else
            {
                character = new Cleric(name, factionResult);
            }

            characters.Add(character);

            return($"{name} joined the party!");
        }
        public string JoinParty(string[] args)
        {
            string faction       = args[0];
            string characterType = args[1];
            string name          = args[2];

            if (!Enum.TryParse <Faction>(faction, out var parsedFaction))
            {
                throw new ArgumentException($"Invalid faction \"{faction}\"!");
            }
            else
            {
                switch (characterType)
                {
                case "Warrior":
                    Warrior warrior = new Warrior(name, parsedFaction);
                    characters.Add(warrior);
                    break;

                case "Cleric":
                    Cleric cleric = new Cleric(name, parsedFaction);
                    characters.Add(cleric);
                    break;

                default:
                    throw new ArgumentException($"Invalid character type \"{characterType}\"!");
                }
                return($"{name} joined the party!");
            }
        }
    public string Heal(string[] args)
    {
        var healerName          = args[0];
        var healingReceiverName = args[1];

        if (!this.characters.Any(ch => ch.Name == healerName))
        {
            throw new ArgumentException(string.Format(Messages.CharacterNotFound, healerName));
        }
        if (!this.characters.Any(ch => ch.Name == healingReceiverName))
        {
            throw new ArgumentException(string.Format(Messages.CharacterNotFound, healingReceiverName));
        }

        var healer   = this.characters.First(ch => ch.Name == healerName);
        var receiver = this.characters.First(ch => ch.Name == healingReceiverName);

        if (healer is Warrior)
        {
            throw new ArgumentException(string.Format(Messages.CannotHeal, healerName));
        }

        Cleric healerAsCleric = (Cleric)healer;

        healerAsCleric.Heal(receiver);


        return($"{healer.Name} heals {receiver.Name} for {healer.AbilityPoints}! {receiver.Name} has {receiver.Health} health now!");
    }
Exemple #5
0
        public Character CreateCharacter(string factionAsString, string type, string name)
        {
            var isParsed = Enum.TryParse <Faction>(factionAsString, out var faction);

            if (!isParsed)
            {
                throw new ArgumentException(string.Format(ExceptionMessages.InvalidFaction, factionAsString));
            }

            Character newCharacter = null;

            switch (type)
            {
            case "Cleric":
                newCharacter = new Cleric(name, faction);
                break;

            case "Warrior":
                newCharacter = new Warrior(name, faction);
                break;

            default:
                throw new ArgumentException(string.Format(ExceptionMessages.InvalidCharacterType, type));
            }

            return(newCharacter);
        }
    public Character CreateCharacter(string[] args)
    {
        string faction       = args[0];
        string characterType = args[1];
        string name          = args[2];

        Character character = null;

        bool validFaction = Enum.TryParse(typeof(Character.Faction), faction, out object factionObj);

        if (!validFaction)
        {
            throw new ArgumentException($"Invalid faction \"{faction}\"!");
        }

        if (characterType != "Warrior" && characterType != "Cleric")
        {
            throw new ArgumentException($"Invalid character type \"{ characterType }\"!");
        }

        if (characterType == "Warrior")
        {
            character = new Warrior(name, (Character.Faction)factionObj);
        }
        else if (characterType == "Cleric")
        {
            character = new Cleric(name, (Character.Faction)factionObj);
        }
        return(character);
    }
Exemple #7
0
        public Character CreateCharacter(string factionStr, string characterType, string name)
        {
            if (factionStr != "CSharp" && factionStr != "Java")
            {
                string message = factionStr;
                throw new ArgumentException($"Invalid faction \"{message}\"!");
            }

            if (characterType != "Cleric" && characterType != "Warrior")
            {
                throw new ArgumentException($"Invalid character type \"{characterType}\"!");
            }

            Faction   faction   = Enum.Parse <Faction>(factionStr);
            Character character = null;

            if (characterType == "Cleric")
            {
                character = new Cleric(name, faction);
            }
            else
            {
                character = new Warrior(name, faction);
            }

            return(character);
        }
Exemple #8
0
    public string Heal(string[] args)
    {
        string healerName          = args[0];
        string healingReceiverName = args[1];

        Cleric    healer   = (Cleric)characterParty.FirstOrDefault(x => x.Name == healerName);
        Character receiver = characterParty.FirstOrDefault(x => x.Name == healingReceiverName);

        if (healer == null)
        {
            throw new ArgumentException($"Character {healerName} not found!");
        }
        if (receiver == null)
        {
            throw new ArgumentException($"Character {healingReceiverName} not found!");
        }
        if (healer.GetType().Name != "Cleric")
        {
            throw new ArgumentException($"{healerName} cannot heal!");
        }

        healer.Heal(receiver);

        return($"{healer.Name} heals {receiver.Name} for {healer.AbilityPoints}! {receiver.Name} has {receiver.Health} health now!");
    }
Exemple #9
0
        public Character CreateCharacter(string factionArg, string characterType, string name)
        {
            Faction faction = new Faction();

            if (factionArg == "CSharp")
            {
                faction = Faction.CSharp;
            }
            else if (factionArg == "Java")
            {
                faction = Faction.Java;
            }
            else
            {
                throw new ArgumentException($"Invalid faction \"{factionArg}\"!");
            }

            Character character = null;

            if (characterType == "Warrior")
            {
                character = new Warrior(name, faction);
            }
            else if (characterType == "Cleric")
            {
                character = new Cleric(name, faction);
            }
            else
            {
                throw new ArgumentException($"Invalid character type \"{characterType}\"!");
            }

            return(character);
        }
        public Character CreateCharacter(string[] charArgs)
        {
            string factionStr = charArgs[0];
            string type       = charArgs[1];
            string name       = charArgs[2];

            bool isFactionValid = Enum.TryParse(typeof(Faction), factionStr, out object factionResult);

            if (!isFactionValid)
            {
                throw new ArgumentException(string.Format(ErrorMessages.InvalidFactiont, factionStr));
            }

            Faction faction = (Faction)factionResult;

            Character character = null;



            if (type == "Warrior")
            {
                character = new Warrior(name, faction);
                return(character);
            }
            else if (type == "Cleric")
            {
                character = new Cleric(name, faction);
                return(character);
            }

            throw new ArgumentException(string.Format(ErrorMessages.InvalidCharacter, type));
        }
Exemple #11
0
    public Character CreateCharacter(string[] args)
    {
        string faction       = args[0];
        string characterType = args[1];
        string name          = args[2];

        Character newCharacter;

        if (faction != "CSharp" && faction != "Java")
        {
            throw new ArgumentException($"Invalid faction \"{ faction }\"!");
        }

        Faction parsedFaction;
        var     toBeParsed = Enum.TryParse(faction, out parsedFaction);

        switch (characterType)
        {
        case "Warrior":
            newCharacter = new Warrior(name, parsedFaction);
            break;

        case "Cleric":
            newCharacter = new Cleric(name, parsedFaction);
            break;

        default:
            throw new ArgumentException($"Invalid character type \"{ characterType }\"!");
        }
        return(newCharacter);
    }
Exemple #12
0
    public string Heal(string[] args)
    {
        string healerName          = args[0];
        string healingReceiverName = args[1];

        Character healer          = this.partyList.FirstOrDefault(c => c.Name == healerName);
        Character healingReceiver = this.partyList.FirstOrDefault(c => c.Name == healingReceiverName);

        if (healer == null)
        {
            throw new ArgumentException($"Character {healerName} not found!");
        }

        if (healingReceiver == null)
        {
            throw new ArgumentException($"Character {healingReceiverName} not found!");
        }

        if (healer is Warrior)
        {
            throw new ArgumentException($"{healerName} cannot heal!");
        }

        Cleric cleric = (Cleric)healer;

        cleric.Heal(healingReceiver);

        return
            ($"{healer.Name} heals {healingReceiver.Name} for {healer.AbilityPoints}! {healingReceiver.Name} has {healingReceiver.Health} health now!");
    }
        public Character CreateCharacter(string factionName, string characterType, string name)
        {
            if (factionName != "CSharp" && factionName != "Java")
            {
                throw new ArgumentException(string.Format(ExceptionMessages.InvalidFactionException, factionName));
            }

            Faction faction = Enum.Parse <Faction>(factionName);

            if (characterType != "Warrior" && characterType != "Cleric")
            {
                throw new ArgumentException(string.Format(ExceptionMessages.InvalidCharacterTypeException, characterType));
            }

            Character character = null;

            if (characterType == "Warrior")
            {
                character = new Warrior(name, faction);
            }
            else if (characterType == "Cleric")
            {
                character = new Cleric(name, faction);
            }
            else
            {
                throw new ArgumentException(string.Format(ExceptionMessages.InvalidCharacterTypeException, characterType));
            }

            return(character);
        }
Exemple #14
0
        public Character CreateCharacter(string faction, string characterType, string name)
        {
            Character character = null;


            if (!Enum.TryParse(faction, out Faction factionResult))
            {
                throw new ArgumentException($"Invalid faction \"{faction}\"!");
            }

            switch (characterType)
            {
            case "Warrior":
                character = new Warrior(name, factionResult);
                break;

            case "Cleric":
                character = new Cleric(name, factionResult);
                break;

            default:
                throw new ArgumentException($"Invalid character type \"{characterType}\"!");
            }

            return(character);
        }
Exemple #15
0
    public Character CreateCharacter(string faction, string type, string name)
    {
        if (!Enum.TryParse <Faction>(faction, out var parsedFaction))
        {
            throw new ArgumentException($"Invalid faction \"{faction}\"!");
        }

        Character character;

        switch (type)
        {
        case "Warrior":
            character = new Warrior(name, parsedFaction);
            break;

        case "Cleric":
            character = new Cleric(name, parsedFaction);
            break;

        default:
            throw new ArgumentException($"Invalid character type \"{type}\"!");
        }

        return(character);
    }
Exemple #16
0
    public string JoinParty(string[] args)
    {
        object factionParse;

        if (!Enum.TryParse(typeof(Faction), args[0], out factionParse))
        {
            throw new ArgumentException($"Invalid faction \"{args[0]}\"!");
        }

        Faction faction = (Faction)factionParse;

        if (args[1] != nameof(Cleric) && args[1] != nameof(Warrior))
        {
            throw new ArgumentException($"Invalid character type \"{ args[1] }\"!");
        }

        Character temp = null;

        switch (args[1])
        {
        case nameof(Warrior):
            temp = new Warrior(args[2], faction);
            break;

        case nameof(Cleric):
            temp = new Cleric(args[2], faction);
            break;
        }
        characters.Add(temp.Name, temp);

        return($"{temp.Name} joined the party!");
    }
Exemple #17
0
        public string JoinParty(string[] args)
        {
            var faction        = args[0];
            var characterClass = args[1];
            var name           = args[2];

            Faction parsedFaction;

            if (!Enum.TryParse(faction, out parsedFaction))
            {
                throw new ArgumentException($"Invalid faction \"{faction}\"");
            }

            Character character;

            switch (characterClass)
            {
            case "Warrior":
                character = new Warrior(name, parsedFaction);
                break;

            case "Clerik":
                character = new Cleric(name, parsedFaction);
                break;

            default:
                throw new ArgumentException($"Invalid character type \"{characterClass}\"");
            }

            return($"{character.Name} joined the party!");
        }
Exemple #18
0
        public Character CreateCharacter(string factionParam, string typeParam, string nameParam)
        {
            Faction faction;
            var     factionCurrect = Faction.TryParse(factionParam, out faction);
            var     type           = typeParam;
            var     name           = nameParam;

            if (!factionCurrect)
            {
                throw new ArgumentException($"Invalid faction \"{factionParam}\"!");
            }
            if (type != "Warrior" && type != "Cleric")
            {
                throw new ArgumentException(/*string.Format(Inputs.InvalidCaracterType, type)*/ $"Invalid character type \"{type}\"!");
            }
            if (type == "Warrior")
            {
                var warrior = new Warrior(name, faction);
                return(warrior);
            }
            else
            {
                var cleric = new Cleric(name, faction);
                return(cleric);
            }
        }
Exemple #19
0
        public void SetClericLevelTest()
        {
            Dictionary <Dungeons_and_Dragons.Attribute, int> dict = new Dictionary <Dungeons_and_Dragons.Attribute, int>();

            dict.Add(Dungeons_and_Dragons.Attribute.Strength, 12);
            dict.Add(Dungeons_and_Dragons.Attribute.Dexterity, 15);
            dict.Add(Dungeons_and_Dragons.Attribute.Intelligence, 3);
            dict.Add(Dungeons_and_Dragons.Attribute.Wisdom, 12);
            dict.Add(Dungeons_and_Dragons.Attribute.Constitution, 17);
            dict.Add(Dungeons_and_Dragons.Attribute.Charisma, 9);
            int    xp     = 0;
            int    hp     = 1;
            Cleric cleric = new Cleric("Fryer Ben", Race.Halfling, dict, hp, xp);

            cleric.IncreaseExperiencePoints(0);

            Assert.AreEqual(1, cleric.currentLevel, "TEST1: The level is not as expected");

            cleric.IncreaseExperiencePoints(1499);

            Assert.AreEqual(1, cleric.currentLevel, "TEST2: The level is not as expected");

            cleric.IncreaseExperiencePoints(1);

            Assert.AreEqual(2, cleric.currentLevel, "TEST3: The level is not as expected");

            cleric.IncreaseExperiencePoints(1499);

            Assert.AreEqual(2, cleric.currentLevel, "TEST4: The level is not as expected");

            cleric.IncreaseExperiencePoints(1);

            Assert.AreEqual(3, cleric.currentLevel, "TEST5: The level is not as expected");
        }
Exemple #20
0
    public void Show()
    {
        //Debug.Log("<b>Log</b>");
        //Debug.LogWarning("<i>Warning</i>");
        //Debug.LogError("<color=#ff0000ff>Error</color>");

        //Debug.Log("1 - square");
        //Debug.Log("2 - circle");
        string shapeSelected = inputField.text;//Console.ReadLine();

        Class Class = null;

        switch (shapeSelected)
        {
        case "1":
            Class = new Knight("NewKnight");
            break;

        case "2":
            Class = new Cleric("NewCleric");
            break;

        case "3":
            Class = new Warrior("NewWarrior");
            break;
        }

        if (Class != null)
        {
            Debug.Log("Your selected " + Class.Area());
        }
    }
        public Character CreateCharacter(string[] args)
        {
            Faction?factionType   = Enum.TryParse <Faction>(args[0], out var faction) ? faction : (Faction?)null;
            string  characterType = args[1];
            string  name          = args[2];

            if (factionType == null)
            {
                throw new ArgumentException($"Invalid faction \"{args[0]}\"!");
            }

            Character character;

            switch (characterType)
            {
            case "Warrior":
                character = new Warrior(name, (Faction)factionType);
                break;

            case "Cleric":
                character = new Cleric(name, (Faction)factionType);
                break;

            default:
                throw new ArgumentException($"Invalid character type {characterType}");
            }

            return(character);
        }
        public string Heal(string[] args)
        {
            var healerName          = args[0];
            var healingReceiverName = args[1];
            var giver = Party.FirstOrDefault(c => c.Name == healerName);

            if (giver == null)
            {
                throw new ArgumentException(string.Format(Inputs.CharacterNotFound, healerName));
            }
            var reciver = Party.FirstOrDefault(c => c.Name == healingReceiverName);

            if (reciver == null)
            {
                throw new ArgumentException(string.Format(Inputs.CharacterNotFound, healingReceiverName));
            }
            if (giver.GetType().Name != "Cleric")
            {
                throw new ArgumentException($"{healerName} cannot heal!");
            }

            Cleric cleric = (Cleric)giver;

            cleric.Heal(reciver);

            return
                ($"{giver.Name} heals {reciver.Name} for {giver.AbilityPoints}! {reciver.Name} has {reciver.Health} health now!");
        }
        public string JoinParty(string[] args)
        {
            string faction       = args[0];
            string characterType = args[1];
            string name          = args[2];

            if (!Enum.TryParse(faction, out Faction factionResult))
            {
                throw new ArgumentException($"Invalid faction \"{faction}\"!");
            }

            Character character;

            switch (characterType)
            {
            case "Warrior":
                character = new Warrior(name, factionResult);
                break;

            case "Cleric":
                character = new Cleric(name, factionResult);
                break;

            default:
                throw new ArgumentException($"Invalid character type \"{characterType}\"!");
            }

            this.characters.Add(character);
            return($"{name} joined the party!");
        }
 public static void AddCleric(Character character)
 {
     Cleric.Base(character);
     Cleric.Features(character);
     Cleric.Equipment(character);
     character.Archetype = Cleric.DivineDomain;
 }
        public Character CreateCharacter(string faction, string type, string name)
        {
            Faction newFaction;

            bool isParsed = Enum.TryParse <Faction>(faction, out newFaction);

            if (!isParsed)
            {
                throw new ArgumentException($"Invalid faction \"{faction}\"!");
            }


            Character character;

            if (type == "Warrior")
            {
                character = new Warrior(name, newFaction);
            }
            else if (type == "Cleric")
            {
                character = new Cleric(name, newFaction);
            }
            else
            {
                throw new ArgumentException($"Invalid character \"{type}\"!");
            }

            return(character);
        }
        public AllSpells(string classStr)
        {
            Stat = "Cha";
            switch (classStr)
            {
            case "Cleric":
                Cleric.Add(0, ClericSpells.Cantrips);
                Cleric.Add(1, ClericSpells.FirstLvls);
                Cleric.Add(2, ClericSpells.SecondLvls);
                Cleric.Add(3, ClericSpells.ThirdLvls);
                Cleric.Add(4, ClericSpells.FourthLvls);
                Cleric.Add(5, ClericSpells.FifthLvls);
                Cleric.Add(6, ClericSpells.SixthLvls);
                Cleric.Add(7, ClericSpells.SeventhLvls);
                Cleric.Add(8, ClericSpells.EigthLvls);
                Cleric.Add(9, ClericSpells.NinthLvls);
                break;

            case "Sorcerer":
                Sorcerer.Add(0, SorcererSpells.Cantrips);
                Sorcerer.Add(1, SorcererSpells.FirstLvls);
                Sorcerer.Add(2, SorcererSpells.SecondLvls);
                Sorcerer.Add(3, SorcererSpells.ThirdLvls);
                Sorcerer.Add(4, SorcererSpells.FourthLvls);
                Sorcerer.Add(5, SorcererSpells.FifthLvls);
                Sorcerer.Add(6, SorcererSpells.SixthLvls);
                Sorcerer.Add(7, SorcererSpells.SeventhLvls);
                Sorcerer.Add(8, SorcererSpells.EigthLvls);
                Sorcerer.Add(9, SorcererSpells.NinthLvls);
                break;
            }
        }
Exemple #27
0
        public void ResetClassStats(List <CharClass> partyMembers)
        {
            foreach (var member in partyMembers)
            {
                switch (member.classType)
                {
                case CharClass.WARRIOR:
                {
                    Warrior freshClass = new Warrior();
                    member.itemFind          = freshClass.itemFind;
                    member.xpBonus           = freshClass.xpBonus;
                    member.coinBonus         = freshClass.coinBonus;
                    member.preventDeathBonus = freshClass.preventDeathBonus;
                    member.successChance     = freshClass.successChance;
                } break;

                case CharClass.MAGE:
                {
                    Mage freshClass = new Mage();
                    member.itemFind          = freshClass.itemFind;
                    member.xpBonus           = freshClass.xpBonus;
                    member.coinBonus         = freshClass.coinBonus;
                    member.preventDeathBonus = freshClass.preventDeathBonus;
                    member.successChance     = freshClass.successChance;
                } break;

                case CharClass.ROGUE:
                {
                    Rogue freshClass = new Rogue();
                    member.itemFind          = freshClass.itemFind;
                    member.xpBonus           = freshClass.xpBonus;
                    member.coinBonus         = freshClass.coinBonus;
                    member.preventDeathBonus = freshClass.preventDeathBonus;
                    member.successChance     = freshClass.successChance;
                } break;

                case CharClass.RANGER:
                {
                    Ranger freshClass = new Ranger();
                    member.itemFind          = freshClass.itemFind;
                    member.xpBonus           = freshClass.xpBonus;
                    member.coinBonus         = freshClass.coinBonus;
                    member.preventDeathBonus = freshClass.preventDeathBonus;
                    member.successChance     = freshClass.successChance;
                } break;

                case CharClass.CLERIC:
                {
                    Cleric freshClass = new Cleric();
                    member.itemFind          = freshClass.itemFind;
                    member.xpBonus           = freshClass.xpBonus;
                    member.coinBonus         = freshClass.coinBonus;
                    member.preventDeathBonus = freshClass.preventDeathBonus;
                    member.successChance     = freshClass.successChance;
                } break;

                default: break;
                }
            }
        }
Exemple #28
0
        private void BtnCreate_Click(object sender, RoutedEventArgs e)
        {
            String option = CboxCharacter.Text;

            List <IDescribable> objectList = new List <IDescribable>();

            objectList.Add(new Axe());
            objectList.Add(new Potion());
            objectList.Add(new Wizard {
                Level = 10
            });

            IDescribable i = new Fighter();


            TxtOutput.Text = "";

            foreach (IDescribable d in objectList)
            {
                TxtOutput.Text += d.ShowInformation() + "\n";
            }


            Character myCharacter = null;

            switch (option)
            {
            case "Cleric":
                myCharacter = new Cleric();
                break;

            case "Fighter":
                myCharacter = new Fighter();
                break;

            case "Rouge":
                myCharacter = new Rouge();
                break;

            case "Wizard":
                myCharacter = new Wizard();
                break;

            default:
                myCharacter = null;
                MessageBox.Show("You MUST select a type");
                break;
            }


            myCharacter.Name       = "Solrac";
            myCharacter.Level      = 2;
            myCharacter.Experience = 10000;

            if (myCharacter != null)
            {
                TxtOutput.Text = myCharacter.Taunt();
            }
        }
Exemple #29
0
        private static string[] getSubClassDnD(CLASSES C, int lv)
        {
            string[] Sub = new string[20];// may need to change temp size

            if (C == BARBARIAN)
            {
                Sub = Barbarian.getDnD(lv);
            }
            else if (C == BARD)
            {
                Sub = Bard.getDnD();
            }
            else if (C == CLERIC)
            {
                Sub = Cleric.getDnD(D5Core);
            }
            else if (C == DRUID)
            {
                Sub = Druid.getDnD(D5Core);
            }
            else if (C == FIGHTER)
            {
                Sub = Fighter.getDnD(D5Core, lv);
            }
            else if (C == MONK)
            {
                Sub = Monk.getDnD(D5Core, lv);
            }
            else if (C == PALADIN)
            {
                Sub = Paladin.getDnD(D5Core);
            }
            else if (C == RANGER)
            {
                Sub = Ranger.getDnD(D5Core, lv);
            }
            else if (C == ROGUE)
            {
                Sub = Rogue.getDnD(D5Core);
            }
            else if (C == SORCERER)
            {
                Sub = Sorcerer.getDnD(D5Core, lv);
            }
            else if (C == WARLOCK)
            {
                Sub = Warlock.getDnD(D5Core, lv);
            }
            else if (C == WIZARD)
            {
                Sub = Wizard.getDnD(D5Core);
            }

            Sub = Vars.shorten <string>(Sub);

            return(Sub);
        }
Exemple #30
0
        public void SetClass(string user, string choice, IrcClient whisperClient)
        {
            switch (choice.ToLower())
            {
            case "c1":
            {
                classList[user]            = new Warrior();
                classList[user].name       = user;
                classList[user].level      = determineLevel(user);
                classList[user].itemEarned = -1;
                SaveClassData();
                whisperClient.sendChatMessage(".w " + user + " You successfully selected the Warrior class!");
            } break;

            case "c2":
            {
                classList[user]            = new Mage();
                classList[user].name       = user;
                classList[user].level      = determineLevel(user);
                classList[user].itemEarned = -1;
                SaveClassData();
                whisperClient.sendChatMessage(".w " + user + " You successfully selected the Mage class!");
            } break;

            case "c3":
            {
                classList[user]            = new Rogue();
                classList[user].name       = user;
                classList[user].level      = determineLevel(user);
                classList[user].itemEarned = -1;
                SaveClassData();
                whisperClient.sendChatMessage(".w " + user + " You successfully selected the Rogue class!");
            } break;

            case "c4":
            {
                classList[user]            = new Ranger();
                classList[user].name       = user;
                classList[user].level      = determineLevel(user);
                classList[user].itemEarned = -1;
                SaveClassData();
                whisperClient.sendChatMessage(".w " + user + " You successfully selected the Ranger class!");
            } break;

            case "c5":
            {
                classList[user]            = new Cleric();
                classList[user].name       = user;
                classList[user].level      = determineLevel(user);
                classList[user].itemEarned = -1;
                SaveClassData();
                whisperClient.sendChatMessage(".w " + user + " You successfully selected the Cleric class!");
            } break;

            default: break;
            }
        }