Attributes determine what a character is capable of doing in the game, whether it’s swinging a sword, firing arrows, or defending against attacks from others. The player attributes are the most important part of the character creation process that follows.

One of the most rewarding aspects of an RPG is gaining experience by performing actions in the game (usually combat) and leveling up your character. When you start the game, the character is also just starting out as a level 1 with no experience. This reflects the player’s own skill level with the game itself, and that is the appeal of an RPG: You, the player, gain experience with the game while your character gains experience at the same time in the virtual world. You grow together and become a seamless “person.”

Both you and your character improve as you play the game, so you transfer some of your own identity to the character, and in some cases, younger players even assume some of the identity of their inspiring hero. This fascinating give-and-take relationship can really draw someone into your game if you design it well! Like I have said, cut back on the magic and let players really get in the game world and experience some good, solid combat to make the whole experience feel more real, and less detached. You want to do everything possible to suspend the players’ disbelief that they are in a game—you want to bring them into your game world by doing things that cause them to invest emotionally in their characters.

The most common way to gain experience is through combat with monsters and enemy characters. Since there are a lot of calculations involved in the chance to hit, armor class, melee attack, ranged attack, spell attack, and other factors, I will reserve Chapter 12 for a discussion of the mechanics of combat.

The standard, or base, classes can be used for the player as well as for the non-player characters (NPCs). You should feel free to create as many classes as you want to make your game world diversified and interesting. The classes I have described here are just the usual classes you find in an RPG, which you might consider the stock classes. Each class also has subclasses, or specialties within that class. For instance, Paladins are really just a subclass of the Knight, which may include Teutonic Knight, Crusader, and so on.

When you are designing a game, you can make it as historically accurate or as fictional as you want; don’t feel compelled to make every class realistic or historically based. You might make up a fictional type of Knight subclass, such as a Dark Knight or Gothic Knight, with some dark magic abilities. However, I want to encourage you to shy away from overdoing the magic system in a game. Many RPGs have character classes that might be thought of as wizards on steroids, because the whole game boils down to upgrading spells and magic, with little emphasis on “realistic” combat.

You would be surprised by how effective an RPG can be with just a few magic abilities. You can really go overboard with the hocus pocus, and that tends to trivialize a well-designed storyline and render interesting characters into fireball targets. No warrior should be able to do any magic whatsoever. Think about it: The warriors are basically barbarians—massive, hulking fighters who use brute force to bash skulls on the battlefield (think Arnold Schwarzenegger in the Conan movies). This type of character can become civilized and educated, but so many games blur the line here and allow any class to develop magical abilities. (I’m just pointing out some obvious design concerns with characters. If you really want a world of magic, then go ahead and create magical characters; that sounds like a really fun game, as a matter of fact!) If you are designing a traditional RPG, then be realistic with your classes and keep the magic reasonable. Think about The Lord of the Rings; these stories are a source of inspiration for every RPG ever made. Everything since J.R.R. Tolkien has been derivative!

The character editor tool has the ability to apply modifiers to the basic stats, but this is a manual process. If you add new classes to the cboClass list in the editor, then you’ll have to make changes to the modifiers manually in the code (hint: look for the code in cboClass_SelectedIndexChanged()).

One design consideration that we might use is the concept of class modifiers. Say you have a set of stock classes like those listed in the upcoming tables. Instead of re-creating a class from scratch using similar values, you can create a subclass based on the parent class—and modify the attributes by a small amount to produce the new class with custom attributes. Say, for instance, that you want to create a new type of Warrior called the Berserker, which is an extremely stupid and ugly character with immense strength and stamina. Sounds a little bit scary, doesn’t it? By setting the base class of the Berserker to Warrior, you can then modify the base class at any time and the Berserker automatically is changed along with the base class (Warrior). This works great for balancing the gameplay without requiring that you modify every single subclass that you have used in the game. Since our character class system in the dungeon crawler is based on classes, we can easily subclass the base character classes to create new types of characters in this manner.

Tables 10.1 to 10.4 present my idea of a character class structure that is programmed into the editor. Since this only applies to the editor, and not to any game source code, you may modify the editor to use your own preferred values and classes.

To keep your game character classes balanced, it’s important to use a standard total for all modifiers so that they all add up to the same amount. I have based the following class modifiers on a total of 15 points. In testing the game, it seemed that values much lower made the hero characters less impressive (compared to, say, a peasant), while values much higher resulted in unusually powerful characters. If you want a character to have one very high attribute, then that will have to be balanced with an equally low value for another. Note also that monsters need not follow this standard—go ahead and use whatever factors you want to create unique foes. The goal of this point modifier system is to create player characters that are based on the same fixed number of attribute points.

In addition to these player character classes, you might want to create base classes for some of the regular people in the world, like townsfolk, peasants, farmers, and so on. These non-combat NPCs might all just share the same character class (with weak combat skills, poor experience, and so on). We will need NPCs like this for the quest system coming up later. (See Table 10.5.) NPCs do not need to follow the same modifier rules reserved for player character classes (which, again, should be thought of as heroes). Note that NPCs and monsters generally have more HP than their levels imply to improve gameplay by increasing the difficulty early on—which makes the player eager to level up quickly.

We can also create fantasy creatures and monsters described in Tables 10.6 to 10.9. These creatures are unprecedented because they have no equal on the “good side.” But you will not want to make all of the bad guys too powerful—save that for the unusual monsters that are rarely encountered or the game will be way too hard to play. You will generally want to have at least one type of bad guy for each type of character class available to the player, and duplicate that character all over the game world. In addition, you must add weaker enemy characters that make good fodder for the player to help with leveling up. Another thing to remember is that monsters do not gain experience and level up, so they should start out with higher level stats than a typical level 1 player character. Since the human but otherwise bad characters share the same stats as the human good guys, we don’t need to define them separately.

Remember, these are generic class types, or races, not individuals. Since we don’t need to follow a modifier standard, you may get as creative as you want. Since these classes represent various level ranges, the attributes are calculated with die roll specifications and modifiers (both of which are supported in the character editor).

If you want to create a level 10 monster, then I recommend rolling 10D6 for its attributes. If desired level is L, then each attribute roll is LD6. The modifiers may then be used to adjust the dice rolls to ensure minimum or maximum values are reached for the monster’s intended abilities. For instance, if you want to create a zombie with a minimum of 20 STR while still using the attribute roll, then add 20 to the STR roll and the result will be 20 + STR. As long as the minimums are capped to zero, it’s okay to add negative modifiers. If you want to specify a monster’s level specifically in the editor data, go ahead and add it as a new property—I just prefer to get away from the numbers game and let the player learn each monster’s abilities by fighting them (in the interest of improving the suspense of disbelief!).

As a final note, there is no reason to roll the charisma attribute for monsters so I have set CHA to 0 in these tables. If you have some purpose for this attribute in your own game, by all means go ahead and use it!

The Character class is the biggest class of the entire book so far, but that doesn’t mean it’s overly complex, it just has a lot of data to keep track of and makes use of a lot of convenient properties. This is a very user-friendly class, but that means there’s a lot of code up front in the class. The end result is a lot of code now in the class definition, but much less code in our game required to work with characters. This class will necessarily require changes in the upcoming chapters to accommodate features that we haven’t covered yet, like gaining experience and leveling (which are not found in the class yet!). Not to worry, our characters will gain experience and level up—and loot treasure and go on quests too!

using System;
using System.Collections.Generic;
using System.Xml;
using System.Drawing;
using System.Windows;
using System.Windows.Forms;

namespace RPG
{
    class Character
    {

        public enum AnimationStates
        {
            Walking = 0,
            Attacking = 1,
            Dying = 2
        }

        private Game p_game;
        private PointF p_position;
        private int p_direction;
        private AnimationStates p_state;
        //character file properties;
        private string p_name;
        private string p_class;
        private string p_race;
        private string p_desc;
        private int p_str;
        private int p_dex;
        private int p_sta;
        private int p_int;
        private int p_cha;
        private int p_hitpoints;
        private int p_dropGold1;
        private int p_dropGold2;
        private string p_walkFilename;
        private Sprite p_walkSprite;
        private Size p_walkSize;
        private int p_walkColumns;
        private string p_attackFilename;
        private Sprite p_attackSprite;
        private Size p_attackSize;
        private int p_attackColumns;
        private string p_dieFilename;
        private Sprite p_dieSprite;
        private Size p_dieSize;
        private int p_dieColumns;

        public Character(ref Game game)
        {
            p_game = game;
            p_position = new PointF(0, 0);
            p_direction = 1;
            p_state = AnimationStates.Walking;

            //initialize loadable properties
            p_name = "";
            p_class = "";
            p_race = "";
            p_desc = "";
            p_str = 0;
            p_dex = 0;
            p_sta = 0;
            p_int = 0;
            p_cha = 0;
            p_hitpoints = 0;
            p_dropGold1 = 0;
            p_dropGold2 = 0;
            p_walkSprite = null;
            p_walkFilename = "";
            p_walkSize = new Size(0, 0);
            p_walkColumns = 0;
            p_attackSprite = null;
            p_attackFilename = "";
            p_attackSize = new Size(0, 0);
            p_attackColumns = 0;
            p_dieSprite = null;
            p_dieFilename = "";
            p_dieSize = new Size(0, 0);
            p_dieColumns = 0;

        }

        public string Name
        {
            get { return p_name; }
            set { p_name = value; }
        }

        public string PlayerClass
        {
            get { return p_class; }
            set { p_class = value; }
        }

        public string Race
        {
            get { return p_race; }
            set { p_race = value; }
        }

        public string Description
        {
            get { return p_desc; }
            set { p_desc = value; }
        }

        public int STR
        {
            get { return p_str; }
            set { p_str = value; }
        }

        public int DEX
        {
            get { return p_dex; }
            set { p_dex = value; }
        }

        public int STA
        {
            get { return p_sta; }
            set { p_sta = value; }
        }

        public int INT
        {
            get { return p_int; }
            set { p_int = value; }
        }

        public int CHA
        {
            get { return p_cha; }
            set { p_cha = value; }
        }

        public int HitPoints
        {
            get { return p_hitpoints; }
            set { p_hitpoints = value; }
        }
        public int DropGoldMin
        {
            get { return p_dropGold1; }
            set { p_dropGold1 = value; }
        }

        public int DropGoldMax
        {
            get { return p_dropGold2; }
            set { p_dropGold2 = value; }
        }

        public Sprite GetSprite
        {
            get {

                switch (p_state)
                {
                    case AnimationStates.Walking:
                        return p_walkSprite;
                    case AnimationStates.Attacking:
                        return p_attackSprite;
                    case AnimationStates.Dying:
                        return p_dieSprite;
                    default:
                        return p_walkSprite;
                }
            }
        }

        public PointF Position
        {
            get { return p_position; }
            set { p_position = value; }
        }

        public float X
        {
            get { return p_position.X; }
            set { p_position.X = value; }
        }
        public float Y
        {
            get { return p_position.Y; }
            set { p_position.Y = value; }
        }

        public int Direction
        {
            get { return p_direction; }
            set { p_direction = value; }
        }

        public AnimationStates AnimationState
        {
            get { return p_state; }
            set { p_state = value; }
        }

        public void Draw()
        {
            int startFrame, endFrame;
            switch (p_state)
            {
                case AnimationStates.Walking:
                    p_walkSprite.Position = p_position;
                    if (p_direction > -1)
                    {
                        startFrame = p_direction * p_walkColumns;
                        endFrame = startFrame + p_walkColumns - 1;
                        p_walkSprite.AnimationRate = 30;
                        p_walkSprite.Animate(startFrame, endFrame);
                    }
                    p_walkSprite.Draw();
                    break;

                case AnimationStates.Attacking:
                    p_attackSprite.Position = p_position;
                    if (p_direction > -1)
                    {
                         startFrame = p_direction * p_attackColumns;
                         endFrame = startFrame + p_attackColumns - 1;
                         p_attackSprite.AnimationRate = 30;
                         p_attackSprite.Animate(startFrame, endFrame);
                    }
                    p_attackSprite.Draw();
                    break;

                case AnimationStates.Dying:
                    p_dieSprite.Position = p_position;
                    if (p_direction > -1)
                    {
                        startFrame = p_direction * p_dieColumns;
                        endFrame = startFrame + p_dieColumns - 1;
                        p_dieSprite.AnimationRate = 30;
                        p_dieSprite.Animate(startFrame, endFrame);
                    }
                    p_dieSprite.Draw();
                    break;
            }
        }

        private string getElement(string field, ref XmlElement element)
        {
            string value = "";
            try
            {
                value = element.GetElementsByTagName(field)[0].InnerText;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            return value;
        }


        public bool Load(string filename)
        {
            try
            {
                //open the xml file
                XmlDocument doc = new XmlDocument();
                doc.Load(filename);
                XmlNodeList list = doc.GetElementsByTagName("character");
                XmlElement element = (XmlElement)list[0];

                //read data fields
                string data;
                p_name = getElement("name", ref element);
                p_class = getElement("class", ref element);
                p_race = getElement("race", ref element);
                p_desc = getElement("desc", ref element);

                data = getElement("str", ref element);
                p_str = Convert.ToInt32(data);

                data = getElement("dex", ref element);
                p_dex = Convert.ToInt32(data);

                data = getElement("sta", ref element);
                p_sta = Convert.ToInt32(data);

                data = getElement("int", ref element);
                p_int = Convert.ToInt32(data);

                data = getElement("cha", ref element);
                p_cha = Convert.ToInt32(data);

                data = getElement("hitpoints", ref element);
                p_hitpoints = Convert.ToInt32(data);

                data = getElement("anim_walk_filename", ref element);
                p_walkFilename = data;

                data = getElement("anim_walk_width", ref element);
                p_walkSize.Width = Convert.ToInt32(data);

                data = getElement("anim_walk_height", ref element);
                p_walkSize.Height = Convert.ToInt32(data);
                data = getElement("anim_walk_columns", ref element);
                p_walkColumns = Convert.ToInt32(data);

                data = getElement("anim_attack_filename", ref element);
                p_attackFilename = data;

                data = getElement("anim_attack_width", ref element);
                p_attackSize.Width = Convert.ToInt32(data);

                data = getElement("anim_attack_height", ref element);
                p_attackSize.Height = Convert.ToInt32(data);

                data = getElement("anim_attack_columns", ref element);
                p_attackColumns = Convert.ToInt32(data);

                data = getElement("anim_die_filename", ref element);
                p_dieFilename = data;

                data = getElement("anim_die_width", ref element);
                p_dieSize.Width = Convert.ToInt32(data);

                data = getElement("anim_die_height", ref element);
                p_dieSize.Height = Convert.ToInt32(data);

                data = getElement("anim_die_columns", ref element);
                p_dieColumns = Convert.ToInt32(data);

                data = getElement("dropgold1", ref element);
                p_dropGold1 = Convert.ToInt32(data);

                data = getElement("dropgold2", ref element);
                p_dropGold2 = Convert.ToInt32(data);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return false;
            }

            //create character sprites
            try
            {
                if (p_walkFilename != "")
                {
                    p_walkSprite = new Sprite(ref p_game);
                    p_walkSprite.Image = LoadBitmap(p_walkFilename);
                    p_walkSprite.Size = p_walkSize;
                    p_walkSprite.Columns = p_walkColumns;
                    p_walkSprite.TotalFrames = p_walkColumns * 8;
                }

                if (p_attackFilename != "")
                {
                    p_attackSprite = new Sprite(ref p_game);
                    p_attackSprite.Image = LoadBitmap(p_attackFilename);
                    p_attackSprite.Size = p_attackSize;
                    p_attackSprite.Columns = p_attackColumns;
                    p_attackSprite.TotalFrames = p_attackColumns * 8;
                }

                if (p_dieFilename != "")
                {
                    p_dieSprite = new Sprite(ref p_game);
                    p_dieSprite.Image = LoadBitmap(p_dieFilename);
                    p_dieSprite.Size = p_dieSize;
                    p_dieSprite.Columns = p_dieColumns;
                    p_dieSprite.TotalFrames = p_dieColumns * 8;
                }
            }

            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return false;
            }
            return true;
        }

        private Bitmap LoadBitmap(string filename)
        {
            Bitmap bmp=null;
            try
            {
                bmp = new Bitmap(filename);
            }
            catch (Exception ex){}
            return bmp;
        }

     }
}

Now I’d like to discuss how you can prepare a sprite for use in this game. Each sprite is somewhat different in the number of frames it uses for each type of animation, as well as the types of animation available. All of the character sprites that I’m using in the game have the full eight-direction walking animation sequences, as well as frames for attacking with a weapon. Some sprites have a death animation, and some have running and falling. Normally, to keep the game as uniform as possible, you would use character sprites that have the exact same number of animation frames for the key animation that takes place in the game so that it’s easy to switch character classes without changing any source code. But since our editor stores the sprite data in the character data files, we don’t need to worry about keeping the animations all uniform. Figure 10.2 shows the walking animation sprite sheet for the paladin character.

Figure 10.2. Walking animation for the paladin sprite.

The source artwork from Reiner’s Tilesets does not come in this format, but it comes with each frame of animation stored in a separate bitmap file. The easiest way to combine these frames into a sprite animation sheet is with Cosmigo’s Pro Motion sprite animation program. Because Pro Motion works best with single animation strips, I decided to import each group of bitmaps for the character’s walking animation in all eight directions. Using Pro Motion, I converted all 64 frames of animation into a single sprite sheet.

Nothing beats experimentation, so it is up to you to use the freely available sprites provided by Reiner’s Tilesets (and other sources) to enhance the Dungeon Crawler game to suit your own needs. We can only accomplish so much in this book, so I want to give you as many tools, tips, and tricks as I can possibly squeeze in at this time. There are thousands of sprites and tiles available at www.reinerstilesets.de that you can use for your own games! There is a sprite for everything you can possibly imagine adding to an RPG!

All of the characters and monsters discussed in this chapter have been chosen very carefully because we have artwork available for them. Generally, when a game is being designed from the ground up, the game designer will not limit himself to what artwork is available, because none exists before the game goes into development. But in our case, we have all of this artwork provided by Reiner Prokein (www.reinerstileset.de). I strongly recommend that you start with artwork and design your game characters around that instead of designing first and looking for artwork later (unless you know a talented artist who can do the work!).

All of the sprite sheets used in the game were significantly manipulated from their original sources provided by Reiner Prokein. All of the sprites arranged in columns and rows in a sprite sheet and transparent regions have been converted to an alpha channel in each file, which is saved in the Portable Network Graphics (PNG) file format. When you visit Reiner’s website, you will not find sprite sheets like these, as they are provided in individual bitmaps. Just be aware that additional work will be required on your part to add new characters or animations to your game. Figure 10.3 shows the three sheets used for the warrior character—note the different number of columns for each sheet, which is handled by the character editor and the Character class!

Figure 10.3. The warrior sprite sheets for walking, attacking, and dying.

Let’s take the new Character class and artwork for a spin. The Character demo program is not much different, functionally, from the Portal demo in Chapter 9. However, all of the character code is now transferred over to the Character class, which knows how to load a .char file (created by the character editor tool), parse the XML fields, and create the three sprites needed for each character. In addition, the three animation states can be changed using the standard numeric keys 1, 2, and 3. The result is shown in Figure 10.4. The demo looks a little bit goofy since you have to move in order to show the attack and die animations, but that’s okay, as those animations will not be used during normal walking, only when another action is triggered. The point is, the Character class works!

Figure 10.4. We can now kill the player character—wait, is that a good thing?

Since the code for the Character demo is derived from Chapter 9’s example, I will instead just show you the relevant sections of code related to the new Character class, and let you open the project to see the complete sources. Since the Character class mimics some of the Sprite class’ properties and also makes available the current sprite object via the GetSprite() function, we can replace most of the Sprite-specific code in this demo with Character-based code without making significant changes.

First, we declare a new Character variable:

Character hero;

Next, we create the hero object and set its initial position.

hero = new Character(ref game);
hero.Load("paladin.char");
hero.Position = new Point(400 - 48, 300 - 48);

In the Form1_KeyUp() event, the AnimationState property is changed with the 1, 2, and 3 keys, to test the three different character states (which are Walking, Attacking, and Dying).

private void Form1_KeyUp(object sender, KeyEventArgs e)
{
    switch (e.KeyCode)
    {
        case Keys.Escape: gameover = true; break;
        case Keys.Up:
        case Keys.W: keyState.up = false; break;
        case Keys.Down:
        case Keys.S: keyState.down = false; break;
        case Keys.Left:
        case Keys.A: keyState.left = false; break;
        case Keys.Right:
        case Keys.D: keyState.right = false; break;
        case Keys.Space:
            if (portalFlag) level.GridPos = portalTarget;
            break;
        case Keys.D1:
            hero.AnimationState = Character.AnimationStates.Walking;
            break;
        case Keys.D2:
            hero.AnimationState = Character.AnimationStates.Attacking;
            break;
        case Keys.D3:
            hero.AnimationState = Character.AnimationStates.Dying;
            break;
    }
}

In the main loop function, doUpdate(), we simply call hero.Draw(), which both animates and draws the character sprite. This Draw() function is so smart that it even figures out automatically which sprite to draw based on the Animation State. Notice how very little the code has changed! This is due to the similarities between the Sprite and Character classes (which were intentional!).

int ticks = Environment.TickCount;
if (ticks > drawLast + 16)
{
    drawLast = ticks;

    //draw the tilemap
    level.Draw(0, 0, 800, 600);

    //draw the hero
    hero.Draw();
    ...
}

This is not the entire code listing to the Character demo project, which must be omitted due to length. Please open the complete project (www.courseptr.com/downloads) and peruse the source code for this program.