Since it seems that a character can’t take a dozen steps in some RPGs without encountering some type of creature or NPC that wants to bash in his skull, a character will need to know how to defend himself at the least and hopefully deal out some damage of his own. There are almost as many types of combat systems as there are RPGs. Some are fairly simple, while others are incredibly complex, almost requiring an advanced mathematics degree to figure out. Most hide the calculations from the player though, some even going so far as to show actual damage on the entities and hiding the numbers, leaving the player to figure out how badly hurt his character and opponent are in order to determine whether to run or continue fighting. You can normally divide them into two categories, however — real time and turn based.

Real time means that characters are able to attack as fast as they can, given the type of weapon they’re wielding and other factors. Depending on how deep the combat system is, there could be any number of additional factors that affect the character’s rate of attack, such as the type of armor the character is wearing (heavy armor will slow down the character), one or more of the character’s stats (Strength, Agility, and Dexterity are some of the favorites), and the amount of skill the character has with his weapon. With real-time combat the player normally only has to click on the target and the character will start attacking until that target is dead (or the character dies) unless you intervene. Some RPGs allow you to queue up special attacks or tactics while the character is fighting. For example, in the story at the beginning of the chapter several characters are fighting a group of goblins. Normally the character would only be able to attack one at a time. If the character has the ability to attack more than one target with a small penalty for each attack, the player may want to use this special attack when one or more of the goblins were hurt and less able to defend themselves. The player selects this attack at an appropriate time and as soon as the character is able he’ll use the special attack, and then go back to his normal attack. That’s assuming the character is able to use it at the time. If only one goblin were in range, the character would just do a normal attack. Neverwinter Nights is one example of an RPG that does this. In the following screenshot, the actions that are queued up are represented by icons in the upper left-hand corner.

Figure 6-1

A turn-based combat system usually means that one combatant will attack and then the other will have his turn. The order of combat is usually determined by a roll of the dice (called an initiative roll). This roll can be modified by stats or some other factor. Dungeons and Dragons worked this way. Combatants would compare their Dexterity stat, and whichever had the highest would strike first. Combat is very structured in a turn-based system. Usually magic spells are cast first and then any ranged combat is resolved. Lastly, melee attacks, if possible, are calculated. All of these actions together are called a round. In every round a player could decide to have his character do something different and usually has plenty of time to make that decision.

In this chapter we’ll create a turn-based system where the order of action for each turn is determined by multiple factors — the Dexterity stat of the entity, the type of weapon he’s using and its weight, any bonuses that are affecting the character positively or negatively, etc. We’ll also create a combat simulator application that can be used to test combat without having to start an actual game, allowing the developer to quickly fine-tune all the data that pertains to combat (item and entity stats, spell stats, etc.).

In our game we’ll represent the different actions an entity can take during combat using an enum:

public enum AttackTypes
{
    Normal,
    Parry,
    Riposte,
    CalledShot,
    LongRangeShot,
    Disengage
}

If a player doesn’t specify an attack type, it defaults to Normal. The remaining attack types affect the player’s offensive or defensive bonus, or both. Here’s a description of the attack types:

There is no problem using these attack types in a turn-based system, of course. For real-time combat, the use of attack types fits in nicely with a queue type system, as was explained earlier. One possible problem would be if the character performed the attack when the player wasn’t expecting it to occur. If you decide to use attack types in a real-time combat system, you need to make sure that this doesn’t occur and that how the system works is well explained to the player.

Ready… Fight

A player will initiate combat in one of several ways, but it always starts by selecting a target, which is done by simply clicking on the sprite on the screen. Some kind of visual indicator should be used to show the player that the target has been selected. There are a number of ways to do this:

After the player has selected a target he then usually chooses to attack, although sometimes he can do both at once. If both actions are done simultaneously, the attack will normally be the default for the character using whatever weapon he’s currently carrying. This could be problematic if the player has forgotten to equip a weapon. (I’ve done this more than once!) No matter how the player initiates the fight, once it starts you’ll have to change the game state to whatever combat mode the game uses. This could be an entirely different screen, as we see in the RPG Starter Kit that’s available for XNA Game Studio:

Figure 6-2

You may choose to use the same view for combat as you do for the noncombat state. Doing so means you’ll probably want to change or disable some things such as the ability to save and/or quit the game or perform actions that shouldn’t be done in combat (such as trade items with party members or chat with NPCs). More than likely you’ll find during testing that you can do some things that you don’t want the player to be able to do during combat. Players will take advantage of whatever bugs you miss during testing. Stories abound about bugs in MMORPGs that allow players to cheat. A search for “MMORPG exploits” on the Internet will show site after site that lists ways to use bugs to literally get away with murder in almost every big-name MMORPG.

Assuming you’re using a game state system for your RPG (and why wouldn’t you? Microsoft has even made a sample available on the Creators Club web site that shows how to do it), simply setting the game state to whatever value you use for combat and only allowing certain types of input in your code that checks input devices is a start. You’ll probably want to have substates or variables that allow you to check for things like whether it is the player’s turn, or whether the player has selected an attack from the interface provided and, if so, which attack, etc. The easiest way to do all of this is to wrap everything up into a combat engine that gets turned on when the game state changes to combat mode.

The Combat Engine

As stated earlier, we’ll be creating a turn-based combat system. The CombatEngine class will be used to resolve this combat system. It’s a fairly simple class for what it does:

public delegate void CombatEngineAttackEventHandler(
    Entity attackingEntity, Entity defendingEntity);
public delegate void CombatEngineEntityKilledEventHandler(Entity entity);
public delegate void CombatEngineCombatCompletedEventHandler();

public class CombatEngine
{
    private List<Entity> _players;
    private List<Entity> _enemies;

    private bool _isPlayersTurn;

    //using an int here so that we can set it to 0
    //to indicate an attack hasn't been selected yet
    //we'll cast to AttackTypes as necessary
    private int _attackSelected;

    private bool _isCastingSpell;
    private int _spellID;

    private Random _rnd;

    public event CombatEngineAttackEventHandler AttackResolved;
    public event CombatEngineEntityKilledEventHandler EntityKilled;
    public event CombatEngineCombatCompletedEventHandler CombatCompleted;

    public CombatEngine(Entity player, Entity enemy)
    {
        _players = new List<Entity>();
        _players.Add(player);

        _enemies = new List<Entity>();
        _enemies.Add(enemy);

        _rnd = new Random();
    }

    public CombatEngine(List<Entity> players, List<Entity> enemies)
    {
        _players = players;
        _enemies = enemies;

       _rnd = new Random();
    }
    public string Start(bool randomStart)
    {
        string turnName = "";

        //roll to see who goes first
        //1-50 - enemy, 51-100 - player

        int roll = _rnd.Next(1, 101);
        _isPlayersTurn = (roll > 50);

        if (_isPlayersTurn)
        {
            if (_players.Count == 1)
                turnName = _players[0].Name;
            else
                turnName = "Players'";
        }
        else
        {
            if (_enemies.Count == 1)
                turnName = _enemies[0].Name;
            else
                turnName = "Enemies'";
        }

        return turnName;
    }

    public string Start()
    {
        string turnName = "";

        //figure out who goes first
        //order of attacks is highest to lowest combination of AGI+DEX


         return turnName;
     }

     public void AttackSelection(AttackTypes type)
     {
         _attackSelected = (int)type;

         ResolveAttack();
     }

     public void SpellSelected(int id)
     {
         _spellID = id;

         ResolveAttack();
     }

     private void ResolveAttack()
     {
         _curAttacker.SelectedAttack = (AttackTypes)_attackSelected;
         _curAttacker.UseSkill(GlobalData.Items[_curAttacker.Inventory.
             EquippedItem(ArmorArea.RightHand).ID].SkillRequired,
             Difficulty.Normal);

         //if entity being attacked is killed, call event
         if (!((Entity)_curAttacker.Target).IsAlive)
             EntityKilled((Entity)_curAttacker.Target);

         //reset selected attack and spell id
         _attackSelected = 0;
         _spellID = 0;

         AttackResolved(_curAttacker, (Entity)_curAttacker.Target);

         if (_attackOrder.IndexOf(_curAttacker) == _attackOrder.Count-1)
             _curAttacker = _attackOrder[0];
         else
             curAttacker = _attackOrder[
                 _attackOrder.IndexOf(_curAttacker) + 1];
     }
}

The engine has two Start methods, but one is only really used in the combat simulator. In a game, the nonrandom start method would be called. I put the random start in to simulate things like sneak and surprise attacks.

Take a look at the code for the ResolveAttack function. Surprisingly it’s fairly short considering what it does. That’s because the real work is done in the UseSkill method of the Entity class.

private void ResolveAttack()
{
    _curAttacker.SelectedAttack = (AttackTypes)_attackSelected;
    _curAttacker.UseSkill(GlobalData.Items[
        _curAttacker.Inventory.EquippedItem(
        ArmorArea.RightHand).ID].SkillRequired, Difficulty.Normal);

    //if entity being attacked is killed call event
    if (!((Entity)_curAttacker.Target).IsAlive)
        EntityKilled((Entity)_curAttacker.Target);

    //reset selected attack and spell id
    _attackSelected = 0;
    _spellID = 0;

    AttackResolved(_curAttacker, (Entity)_curAttacker.Target);

    if (_attackOrder.IndexOf(_curAttacker) == _attackOrder.Count-1)
        _curAttacker = _attackOrder[0];
    else
        _curAttacker = _attackOrder[_attackOrder.IndexOf( _curAttacker) + 1];
}

We’re assuming the entity was using his weapon in his right hand. If you implement something like weapons that can be wielded in either hand or ambidextrous entities, you’ll need to change this, but this will work for our purposes.

The skill for the weapon being used is retrieved and the Entity class’s UseSkill method called. We make another assumption that the attack has a difficulty value of Normal. This could be another area for improvement.

If the entity being attacked is killed as a result of the attack, we notify the form by firing the EntityKilled event. We then reset the _attackSelected and _spellID members for the next attacker.

The AttackResolved event is fired and the current attacker in the list of entities sorted by order of attack is incremented, resetting it to the first entity if all the entities have attacked.

The Combat Simulator

Now that we have a combat system, we need a way to test it out. Here’s a screenshot of the combat simulator that you’ll find the code for in this chapter:

Figure 6-3

Here we have Aragorn fighting a troll. It’s Aragorn’s turn and he is attacking using a Normal attack type with the Longsword weapon, having 18 ranks for the Melee Weapons skill. He has hit for 24 points of damage, even with a relatively low random die roll. We can also see that the option for him to cast a spell is disabled as he’s not a magic-using character. If he were a magic-using character and had selected a spell, the name of the spell would show in the Attack Selected box and the Weapon combo box would have been filled with the offensive spells he’s learned.

You can stop combat at any time and select different combatants. The simulator assumes the entity on the left is the player and the entity on the right is a creature or monster. When you click the Select button, you can select an entity in the Entities folder for either side. It doesn’t matter if you reverse the entities — putting the player on the right or the creature on the left — or even if you pit player against player or monster against creature.

Clicking either of the Start buttons creates the combat engine, passing it the selected entities. The associated Start method of the engine is called and the buttons are enabled or disabled appropriately.

private void btnStart_Click(object sender, EventArgs e)
{
    _engine = new CombatEngine(_player, _enemy);

        _engine.AttackResolved +=
           new CombatEngineAttackEventHandler(AttackResolved);
        _engine.CombatCompleted +=
           new CombatEngineCombatCompletedEventHandler(CombatCompleted);
        _engine.EntityKilled +=
           new CombatEngineEntityKilledEventHandler(EntityKilled);

    _engine.Start(true);

    btnStart.Enabled = false;
    btnStop.Enabled = true;
    btnClose.Enabled = false;
}

You simply select the type of attack you want the attacking entity to make, and the combat engine’s ResolveAttack method is called. This is similar to the way the RPG Starter Kit works, as we can see in Figure 6-4:

Figure 6-4

When an attack is resolved, the form is notified via the delegate and the controls are updated with the results. The engine then waits for input from the entity whose turn it is. When combat is resolved one way or the other, the form is again notified. In an actual game, this would set the game state back to whatever it was before combat or normal mode.

You’ll probably spend a lot of time in the simulator, tweaking the numbers until combat is fair and somewhat realistic.

There’s Always Room for Improvement

The combat system we’ve developed is one of the simpler kinds. There’s lots of room to make it even better without making it overly complex though. Here are some options:

The possibilities are numerous. It all depends on how realistic you want to make the system. You can always implement one feature at a time to gradually improve the engine. It’s always a good idea to plan out the improvements on paper before actually incorporating them into your game, however. You can usually tell how well the engine will work without wasting time writing code.

Summary

While having the character fight it out with all kinds of creatures and monsters is cool, an essential element is missing. The sounds of combat — the clang of a weapon on a shield or armor, the explosion of a magic spell hitting a group of monsters, the cries of the wounded — all are important to the realism of the gameplay. We could also use some cool music that plays while combat is taking place. We’ll take care of that in the next chapter, implementing a sound manager and importing three sounds for combat as well as some music to play when the game starts. Once you’ve completed that chapter, combat will take on a whole new dimension.