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. We will study combat in detail in Chapter 16, “Fighting, Getting XP, and Leveling Up,” and quests in Chapter 19, “Creating the Quest Editor.” These are the only two ways to get experience and level up. 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 16 for a discussion of the details.

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 Celtic Crusader will be based on classes, we can easily subclass the base character classes to create new types of characters in this manner.

Tables 14.1 to 14.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 14.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 14.6 to 14.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 the 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 much less code in our game for dealing 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! The properties in the class have been omitted to conserve space—so this is not a complete source code listing, just a reference.

Public Class Character
    Public Enum AnimationStates
        Walking
        Attacking
        Dying
    End Enum
    Private p_game As Game
    Private p_position As PointF
    Private p_direction As Integer
    Private p_state As AnimationStates

    REM character file properties
    Private p_name As String
    Private p_class As String
    Private p_race As String
    Private p_desc As String
    Private p_str As Integer
    Private p_dex As Integer
    Private p_sta As Integer
    Private p_int As Integer
    Private p_cha As Integer
    Private p_hitpoints As Integer
    Private p_dropGold1 As Integer
    Private p_dropGold2 As Integer
    Private p_walkFilename As String
    Private p_walkSprite As Sprite
    Private p_walkSize As Point
    Private p_walkColumns As Integer
    Private p_attackFilename As String
    Private p_attackSprite As Sprite
    Private p_attackSize As Point
    Private p_attackColumns As Integer
    Private p_dieFilename As String
    Private p_dieSprite As Sprite
    Private p_dieSize As Point
    Private p_dieColumns As Integer

    Public Sub New(ByRef game As Game)
        p_game = game
        p_position = New PointF(0, 0)
        p_direction = 1
        p_state = AnimationStates.Walking

        REM initialize loadable properties
        REM some code omitted due to space
    End Sub

    REM class properties omitted

    Public ReadOnly Property GetSprite() As Sprite
        Get

              Select Case p_state
                  Case AnimationStates.Walking
                      Return p_walkSprite
                  Case AnimationStates.Attacking
                      Return p_attackSprite
                  Case AnimationStates.Dying
                      Return p_dieSprite
                  Case Else
                      Return p_walkSprite
              End Select
         End Get
    End Property

    REM This function animates and draws the character sprite
    REM based on the current state (walking, attacking, or dying)
    Public Sub Draw()
        Dim startFrame As Integer
        Dim endFrame As Integer
        Select Case p_state
            Case AnimationStates.Walking
                p_walkSprite.Position = p_position
                If p_direction > -1 Then
                     startFrame = p_direction * p_walkColumns
                     endFrame = startFrame + p_walkColumns - 1
                     p_walkSprite.AnimationRate = 30
                     p_walkSprite.Animate(startFrame, endFrame)
                 End If
                 p_walkSprite.Draw()
            Case AnimationStates.Attacking
                 p_attackSprite.Position = p_position
                 If p_direction > -1 Then
                     startFrame = p_direction * p_attackColumns
                     endFrame = startFrame + p_attackColumns - 1
                     p_attackSprite.AnimationRate = 30
                     p_attackSprite.Animate(startFrame, endFrame)
                 End If
                 p_attackSprite.Draw()
             Case AnimationStates.Dying
                 p_dieSprite.Position = p_position
                 If p_direction > -1 Then

                 startFrame = p_direction * p_dieColumns
                 endFrame = startFrame + p_dieColumns - 1
                 p_dieSprite.AnimationRate = 30
                 p_dieSprite.Animate(startFrame, endFrame)
             End If
             p_dieSprite.Draw()
     End Select
End Sub

REM Load a character .char file
Public Function Load(ByVal filename As String)
    Try

        REM open the xml file
        Dim doc As New XmlDocument()
        doc.Load(filename)
        Dim list As XmlNodeList = doc.GetElementsByTagName("character")
        Dim element As XmlElement = list(0)

        REM read data fields
        p_name = getElement("name", element)
        p_class = getElement("class", element)
        p_race = getElement("race", element)
        p_desc = getElement("desc", element)
        p_str = getElement("str", element)
        p_dex = getElement("dex", element)
        p_sta = getElement("sta", element)
        p_int = getElement("int", element)
        p_cha = getElement("cha", element)
        p_hitpoints = getElement("hitpoints", element)
        p_walkFilename = getElement("anim_walk_filename", element)
        p_walkSize.X = Convert.ToInt32( _
            getElement("anim_walk_width", element))
        p_walkSize.Y = Convert.ToInt32( _
            getElement("anim_walk_height", element))
        p_walkColumns = Convert.ToInt32( _
            getElement("anim_walk_columns", element))
        p_attackFilename = getElement( _
            "anim_attack_filename", element)
        p_attackSize.X = Convert.ToInt32( _
            getElement("anim_attack_width", element))

        p_attackSize.Y = Convert.ToInt32( _
            getElement("anim_attack_height", element))
        p_attackColumns = Convert.ToInt32( _
            getElement("anim_attack_columns", element))
        p_dieFilename = getElement( _
            "anim_die_filename", element)
        p_dieSize.X = Convert.ToInt32( _
            getElement("anim_die_width", element))
        p_dieSize.Y = Convert.ToInt32( _
            getElement("anim_die_height", element))
        p_dieColumns = Convert.ToInt32( _
            getElement("anim_die_columns", element))
        p_dropGold1 = Convert.ToInt32( _
            getElement("dropgold1", element))
        p_dropGold2 = Convert.ToInt32( _
            getElement("dropgold2", element))
    Catch ex As Exception
        MessageBox.Show(ex.Message)
        Return False
    End Try

    REM create character sprites (with error handling)
    Try
        If p_walkFilename <> "" Then
            p_walkSprite = New Sprite(p_game)
            p_walkSprite.Image = LoadBitmap(p_walkFilename)
            p_walkSprite.Size = p_walkSize
            p_walkSprite.Columns = p_walkColumns
            p_walkSprite.TotalFrames = p_walkColumns * 8
        End If
        If p_attackFilename <> "" Then
            p_attackSprite = New Sprite(p_game)
            p_attackSprite.Image = LoadBitmap(p_attackFilename)
            p_attackSprite.Size = p_attackSize
            p_attackSprite.Columns = p_attackColumns
            p_attackSprite.TotalFrames = p_attackColumns * 8
        End If
        If p_dieFilename <> "" Then
            p_dieSprite = New Sprite(p_game)
            p_dieSprite.Image = LoadBitmap(p_dieFilename)

                 p_dieSprite.Size = p_dieSize
                 p_dieSprite.Columns = p_dieColumns
                 p_dieSprite.TotalFrames = p_dieColumns * 8
             End If
         Catch ex As Exception
              MessageBox.Show(ex.Message)
              Return False
         End Try
         Return True
    End Function

    Private Function getElement(ByVal field As String, _
             ByRef element As XmlElement) As String
         Dim value As String = ""
         Try
             value = element.GetElementsByTagName(field)(0).InnerText
         Catch ex As Exception
              REM ignore error, just return empty
              Console.WriteLine(ex.Message)
         End Try
         Return value
    End Function

    REM note: portions of this source code have been omitted
    REM refer to the complete project in the chapter's resources

End Class

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 Celtic Crusader 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 14.2 shows the walking animation sprite sheet for the paladin class.

Figure 14.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 Celtic Crusader 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 Celtic Crusader 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 14.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 14.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 the previous chapter. 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 14.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 14.4. We can now kill the player character—wait, is that a good thing?

Since the code for the Character Demo is derived from the previous chapter’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:

Private hero As Character

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

hero = New Character(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 Sub Form1_KeyUp(ByVal sender As System.Object, _
        ByVal e As System.Windows.Forms.KeyEventArgs) _
        Handles MyBase.KeyUp
   Select Case (e.KeyCode)
        Case Keys.Escape : End
        Case Keys.Up, Keys.W : keyState.up = False
        Case Keys.Down, Keys.S : keyState.down = False
        Case Keys.Left, Keys.A : keyState.left = False
        Case Keys.Right, Keys.D : keyState.right = False
        Case Keys.Space
            If portalFlag Then
               level.GridPos = portalTarget
            End If
        Case Keys.D1
            hero.AnimationState = Character.AnimationStates.Walking
        Case Keys.D2
            hero.AnimationState = Character.AnimationStates.Attacking
        Case Keys.D3
            hero.AnimationState = Character.AnimationStates.Dying
    End Select
End Sub

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 AnimationState.

If ticks > drawLast + 16 Then
    drawLast = ticks

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

    REM draw the hero
    hero.Draw()
  ...
End If