Machaira's Space: Programming

HLSL Syntax Highlighting

Wed, 16 Jan 2008 12:39:24 GMT

From this post in the Creators Club forums:

InteliShade is an add-in for Visual Studio 2005 non-Express SKUs (Add-ins are not allowed in Express) that enabled syntax highlighting in your HLSL (.fx) files. New features in Beta 1.2 also include auto-completion (hit Ctrl-Space to open intelisense) and tooltip styled documentation (hovering over texture tells you what kind of object it is). All known performance issues have been taken care of.
So try it out and suggest some ideas and opinions on how to improve it!
http://intelishade.net/files/folders/beta_releases/entry41.aspx

Breakout level class

Thu, 10 Jan 2008 20:55:33 GMT

Threw this code together in about 5 minutes in response to a question on gamedev.net and figured I'd throw it out here for anyone that's interested. I make no claims about it being the ideal way to do a Breakout level. :)

    public class Brick
    {
        private BoundingBox _box;
        private Vector2 _location;
        private bool _alive;

        public Brick(Vector2 location)
        {
            _location = location;
            _box = new BoundingBox(new Vector3(location.X, location.Y, 0), new Vector3(location.X * Level.BrickWidth, location.Y * Level.BrickHeight, 0));
            _alive = true;
        }

        public Vector2 Location
        {
            get { return _location; }
        }

        public bool Alive
        {
            get { return _alive; }
        }

        public BoundingBox Box
        {
            get { return _box; }
        }
            
        public void Kill()
        {
            _alive = false;
        }
    }

    public class Level
    {
        public const int BrickWidth = 32;
        public const int BrickHeight = 8;

        private List<Brick> _bricks;

        public Level(int rows, int cols)
        {
            _bricks = new List<Brick>();

            Brick brick;

            for (int x = 0; x<cols;x++)
            {
                for (int y = 0;y<rows;y++)
                {
                    brick = new Brick(new Vector2(x * BrickWidth, y * BrickHeight));
                    _bricks.Add(brick);
                }
            }
        }

        public void LevelUp(int rows, int cols)
        {
            _bricks.Clear();

            Brick brick;

            for (int x = 0; x < cols; x++)
            {
                for (int y = 0; y < rows; y++)
                {
                    brick = new Brick(new Vector2(x * BrickWidth, y * BrickHeight));
                    _bricks.Add(brick);
                }
            }
        }

        public bool CheckForCollision(BoundingBox ball)
        {
            BoundingBox brick;
            Vector2 location;
            bool ret = false;

            for (int i = 0; i < _bricks.Count; i++)
            {
                if (_bricks[i].Alive)
                {
                    ret = ball.Intersects(_bricks[i].Box);

                    if (ret)
                    {
                        _bricks[i].Kill();
                        break;
                    }
                }
            }

            return ret;
        }

        public void Render()
        {
            for (int i = 0; i < _bricks.Count; i++)
            {
                if (_bricks[i].Alive)
                {
                    //render
                }
            }

        }
    }

RPG Game Development - Part 6

Thu, 27 Dec 2007 22:30:54 GMT

A mainstay of RPGs are quests. Usually there's at least one main quest and often several side quests that may or may not be necessary. The main quest may involve many people, places, and/or items. We need an easy way to track all of this so the player knows what he's already done and what needs to be done next. We'll implement a system that should be able to handle most questing needs of a developer.

A quest is made up of one or more steps, so we'll start off with a class to encapsulate the data for a step:

    [Serializable]
    public class QuestStep 
    {
        private string _stepName;
        private int _giveItemID;
        private int _getItemID;
        private int _stepEntityID;
        private InteractionType _stepInteractionType;

        // ID of conversation script which is started when StepEntity is interacted with
        private int _conversationID;

        // array of IDs of subquests
        private List<int> _subQuestIDs;

        private List<Item> _requiredItems;
        
        // required level to start the step, each step may have a different level
        private byte _minimumLevel;

        // number of minutes the step can take
        private long _timeLimit;

        private QuestRewardType _rewardItemType;
        private int _rewardItemID;
        private int _rewardMoneyAmount;
        
        public QuestStep() 
        {
            
        }

        public string StepName
        {
            get {return _stepName;}
            set {if (!string.IsNullOrEmpty(value)) _stepName=value;}
        }

        public int GiveItemID
        {
            get { return _giveItemID; }
            set { if (value > 0) _giveItemID = value; }
        }

        public int GetItemID
        {
            get { return _getItemID; }
            set { if (value > 0) _getItemID = value; }
        }

        public int StepEntityID
        {
            get { return _stepEntityID; }
            set { if (value > 0) _stepEntityID = value; }
        }

        public InteractionType StepInteractionType
        {
            get { return _stepInteractionType; }
            set { _stepInteractionType = value; }
        }

        public int ConversationID
        {
            get { return _conversationID; }
            set { if (value > 0) _conversationID = value; }
        }

        public void AddSubQuest(int ID)
        {
            if (_subQuestIDs == null)
                _subQuestIDs = new List<int>();

            _subQuestIDs.Add(ID);
        }

        public void InsertSubQuestID(int index, int ID)
        {
            if (_subQuestIDs == null)
                _subQuestIDs = new List<int>();

            if (index <= _subQuestIDs.Count - 1)
                _subQuestIDs.Insert(index, ID);
            else
                throw new IndexOutOfRangeException("Number of sub-quests is less than the index passed to the InsertSubQuestID method");
        }

        public List<int> SubQuestIDs
        {
            get { return _subQuestIDs; }
        }

        public void RemoveSubQuestIDByIndex(int index)
        {
            _subQuestIDs.RemoveAt(index);
        }

        public void RemoveSubQuestIDByID(int ID)
        {
            _subQuestIDs.Remove(ID);
        }

        public void AddRequiredItem(Item item)
        {
            if (_requiredItems == null)
                _requiredItems = new List<Item>();

            _requiredItems.Add(item);
        }

        public void RemoveRequiredItemByIndex(int index)
        {
            _requiredItems.RemoveAt(index);
        }

        public void RemoveSubQuestIDByItem(Item item)
        {
            _requiredItems.Remove(item);
        }

        public List<Item> RequiredItems
        {
            get { return _requiredItems; }
        }

        public byte MinimumLevel
        {
            get { return _minimumLevel; }
            set { if (value > 0) _minimumLevel = value; }
        }

        public long TimeLimit
        {
            get { return _timeLimit; }
            set { if (value > 0) _timeLimit = value; }
        }

        public QuestRewardType RewardItemType
        {
            get { return _rewardItemType; }
            set { _rewardItemType = value; }
        }

        public int RewardItemID
        {
            get { return _rewardItemID; }
            set { if (value > -1) _rewardItemID = value; }
        }

        public int RewardMoneyAmount
        {
            get { return _rewardMoneyAmount; }
            set { if (value > 0) _rewardMoneyAmount = value; }
        }
    }

The InteractionType enum contains only two items at this point:

    public enum InteractionType 
    {
        Talk,
        Kill
    }

You could add some other values here - Steal, Subdue, Follow, etc. but for our purposes these two will do.

The QuestRewardType enum has the following in it:

    public enum QuestRewardType 
    {
        Armor,
        Item,
        Money,
        Spell,
        Weapon
    }

You might be asking what the difference between _giveItemID and _rewardItemID are. That's a very good question. Imagine a step where an NPC says "Give this ring to <some other NPC> and here's <some random item> for your trouble". The first item is the _giveItemID and the second is the _rewardItemID. In the case of money as a reward the _rewardItemID is ignored and the _rewardMoneyAmount is used instead.

Here's the main Quest class:

    [Serializable]
    public class Quest 
    {
        private int _id;
        private string _name;
        private string _description;
        private QuestType _type;
        private QuestRewardType _rewardType;
        private int _rewardItemID;
        private int _rewardMoneyAmount;
        private List<int> _requiredClasses;
        private int _requiredLevel;
        private bool _isMultipleAllowed;

        // 0 means no limit
        private long _timeBetweenQuests;

        // total time in which quest must be completed, 0 for none
        private long _timeLimit;

        // is the reward known by the player when accepting the quest
        private bool _isRewardShown;

        private List<FactionAdjust> _factions;

        private List<QuestStep> _steps = new List<QuestStep>();
        
        private string _fileName;
        
        public Quest() 
        {

        }
        
        public int ID 
        {
            get { return _id; }
            set { if (value > 0) _id = value; }
        }

        public string Name
        {
            get { return _name; }
            set { if (!string.IsNullOrEmpty(value)) _name = value; }
        }

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

        public QuestType Type
        {
            get { return _type; }
            set { _type = value; }
        }

        public QuestRewardType RewardType
        {
            get { return _rewardType; }
            set { _rewardType = value; }
        }

        public int RewardItemID
        {
            get { return _rewardItemID; }
            set { _rewardItemID = value; }
        }

        public List<int> RequiredClasses
        {
            get { return _requiredClass; }
            set { _requiredClass = value; }
        }

        public int RequiredLevel
        {
            get { return _requiredLevel; }
            set { if (value > 0) _requiredLevel = value; }
        }

        public bool MultipleAllowed
        {
            get { return _isMultipleAllowed; }
            set { _isMultipleAllowed = value; }
        }

        public long TimeBetweenQuests
        {
            get { return _timeBetweenQuests; }
            set { if (value > -1) _timeBetweenQuests = value; }
        }

        public long TimeLimit
        {
            get { return _timeLimit; }
            set { if (value > -1) _timeLimit = value; }
        }

        public bool RewardShown
        {
            get { return _isRewardShown; }
            set { _isRewardShown = value; }
        }

        public List<FactionAdjust> Factions
        {
            get { return _factions; }
            set { _factions = value; }
        }

        public List<QuestStep> Steps
        {
            get { return _steps; }
            set { _steps = value; }
        }

        public string FileName
        {
            get { return _fileName; }
            set { _fileName = value; }
        }
    }

A quest can be one of the following types:

    public enum QuestType 
    {
        FedEx,
        Item,
        Kill,
        Rescue
    }

A FedEx quest is a delivery of some item from one NPC to another. The Item value means the player has to find some item and return it to the NPC that originates the quest.

Factions are something that allow you to determine how a group of people, guards for instance, react to the player. Most MMORPGs have quests that allow the player to modify their faction value for certain groups. This can be used in single-player RPGs as well. The FactionAdjust class is simply an ID and Value pair:

    [Serializable]
    public class FactionAdjust
    {
        public int ID;
        public int Value;
    }

In your data somewhere you'd have a list of faction types (Merchant, Guard, specific monster type). Value can be positive or negative and a quest could affect one faction positively and lower another. For instance, a quest to kill 10 goblins might positively affect the people in an area where the goblins are a problem but would obviously affect the goblin nation negatively. If you allow players to play as a race that is normally not reacted to hostilely by goblins, this allows you to make them so if the player goes on a goblin killing spree.

One area you might want to change, depending on how you work your classes, is the _requiredLevel member. The way the class is implemented, all classes that are allowed have to be the same. You couldn't have a quest where a warrior has to be level 5 and a mage has to be level 10. That's easily fixed by implementing a list of ID and value pairs, like the FactionAdjust above, and replacing the _requiredClasses and _requiredLevel members with it.

So how do we assign a question to the player? We add an instance of the AssignedQuest class to the player's Entity object:

    // An array of this goes in the Entity class
    [Serializable]
    public class AssignedQuest
    {
        private long _questID;
        private int _curStep;
        private long _timeStepStarted;
        private long _timeStepFinished;
        private long _timeQuestStarted;
        private long _timeQuestFinished;
        
    }

We'll need a manager and service to allow code to get information about quests. Here they are:

    public class QuestManager
    {
        private List<Quest> _quests;

        private static int _numQuests = 0;

        public static int NumQuests
        {
            get { return _numQuests; }
        }

        public QuestManager(string filename)
        {
            if (File.Exists(filename))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(List<Quest>));

                FileStream fs = new FileStream(filename, FileMode.Open);

                _quests = (List<Quest>)serializer.Deserialize(fs);

                _numQuests = _quests.Count;
            }
        }

        public Quest GetQuest(int id)
        {
            foreach (Quest quest in _quests)
            {
                if (quest.ID == id)
                    return quest;
                break;
            }

            return null;
        }
    }

    public interface IQuestManagerService
    {
        Quest GetQuest(int id);
    }

I should probably mention that the Starter Kit that will eventually be developed will contain an interface for creating quests (as it will for all the other objects) so don't feel you need to start working on one (unless you really want to, of course). :)

Here's the usual link to the forums for discussion. I'm sure there's areas for improvement here so feel free to let me know. Hopefully this post will be useful in helping you to design your quest system if you don't want to wait for the release of the Starter Kit or use the code I've provided here.

RPG Game Development - Part 3

Mon, 10 Dec 2007 21:42:42 GMT

An RPG is useless unless the character can do something in the world, thus the need for a Skill class, which we'll talk about in this post.

The first thing we need to do is define what type of skills we can have. For now, we'll limit them to 3:

    public enum SkillType
    {
        Defensive,
        NonCombat,
        Offensive
    }

Our Skill class looks like this:

    [Serializable]
    public class Skill
    {
        private int _id;
        private String _name;
        private String _description;

        private SkillType _type;

        private int _preferredClassID;

        private Dictionary<int, string> _costs;
        private Dictionary<int,int> _classBonuses;
        private List<MinMaxBonus> _levelBonuses;
        private Dictionary<int, int> _raceBonuses;
        private Dictionary<int, MinMaxBonus> _statBonuses;

        private bool _alwaysOn;

        public int ID
        {
            get { return _id; }
        }

        public string Name
        {
            get { return _name; }
            set { if (value.Length > 0) _name = value; }
        }

        public string Description
        {
            get { return _description; }
            set { if (value.Length > 0) _description = value; }
        }

        public SkillType Type
        {
            get { return _type; }
            set { _type = value; }
        }

        public int PreferredClassID
        {
            get { return _preferredClassID; }
            set { _preferredClassID = value; }
        }

        public bool AlwaysOn
        {
            get { return _alwaysOn; }
            set { _alwaysOn = value; }
        }

        public Skill(int id)
        {
            _costs = new Dictionary<int, string>();
            _classBonuses = new Dictionary<int, int>();
            _raceBonuses = new Dictionary<int, int>();
            _levelBonuses = new List<MinMaxBonus>();
            _statBonuses = new Dictionary<int, MinMaxBonus>();
            _alwaysOn = false;

            _id = id;

        }

        public void AddCost(int id, string cost)
        {
            if (_costs == null)
                _costs = new Dictionary<int, string>();

            _costs.Add(id, cost);

        }

        public void RemoveCost(int id)
        {
            if (_costs != null)
                _costs.Remove(id);
        }

        public string GetCost(int id)
        {
            string cost = "";

            if (_costs != null)
                _costs.TryGetValue(id, out cost);

            return cost;
        }

        public void AddClassBonus(int id, string bonus)
        {
            if (_classBonuses == null)
                _classBonuses = new Dictionary<int, int>();

            _costs.Add(id, bonus);

        }

        public void RemoveClassBonus(int id)
        {
            if (_classBonuses != null)
                _classBonuses.Remove(id);
        }

        public int GetClassBonus(int id)
        {
            int bonus = 0;

            if (_classBonuses != null)
                _classBonuses.TryGetValue(id, out bonus);

            return bonus;
        }

        public void AddRaceBonus(int id, int bonus)
        {
            if (_raceBonuses == null)
                _raceBonuses = new Dictionary<int, int>();

            _raceBonuses.Add(id, bonus);

        }

        public void RemoveRaceBonus(int id)
        {
            if (_raceBonuses != null)
                _raceBonuses.Remove(id);
        }

        public int GetRaceBonus(int id)
        {
            int bonus = 0;

            if (_raceBonuses != null)
                _raceBonuses.TryGetValue(id, out bonus);

            return bonus;
        }

        public void AddStatBonus(int id, MinMaxBonus bonus)
        {
            if (_statBonuses == null)
                _statBonuses = new Dictionary<int, MinMaxBonus>();

            _statBonuses.Add(id, bonus);

        }

        public void RemoveStatBonus(int id)
        {
            if (_statBonuses != null)
                _statBonuses.Remove(id);
        }

        public MinMaxBonus GetStatBonus(int id)
        {
            MinMaxBonus bonus = new MinMaxBonus();

            if (_statBonuses != null)
                _statBonuses.TryGetValue(id, out bonus);

            return bonus;
        }

        public void AddLevelBonus(MinMaxBonus bonus)
        {
            if (_levelBonuses == null)
                _levelBonuses = new List<MinMaxBonus>();

            _levelBonuses.Add(bonus);

        }

        public void RemoveLevelBonus(int index)
        {
            if (_levelBonuses != null)
                _levelBonuses.RemoveAt(index);
        }

        public int GetLevelBonus(int level)
        {
            if (_levelBonuses != null)
            {
                foreach (MinMaxBonus bonus in _levelBonuses)
                {
                    if (bonus.IsValueInRange(level))
                        return bonus.Amount;
                }
            }

            return 0;
        }

        public bool Use(ref Object target, ref Entity caster, Difficulty difficulty, ref int result)
        {

            int roll;
            int bns = 0;

            roll = GlobalFunctions.GetRandomNumber(DieType.d100);

            roll += (Int16)difficulty;

            switch (_type)
            {
                case SkillType.Defensive:
                {
                    roll += ((Entity)target).GetTotalOffBonus();
                    break;
                }
                case SkillType.NonCombat:
                {
                    roll += ((Entity)target).GetTotalMiscBonus();
                    break;
                }
                case SkillType.Offensive:
                {
                    roll += ((Entity)target).GetTotalDefBonus();
                    break;
                }
            }

            //Calculate level bonus
            if (_levelBonuses == null)
            {
                Int16 level = caster.Level;
                //use default
                switch (level)
                {
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                    case 5:
                    {
                        bns = (Int16)(10 * level);
                        break;
                    }
                    case 6:
                    case 7:
                    case 8:
                    case 9:
                    case 10:
                    {
                        bns = (Int16)(50 + (5 * (level - 5)));
                        break;
                    }
                    case 11:
                    case 12:
                    case 13:
                    case 14:
                    case 15:
                    {
                        bns = (Int16)(75 + (3 * (level - 10)));
                        break;
                    }
                    case 16:
                    case 17:
                    case 18:
                    case 19:
                    case 20:
                    {
                        bns = (Int16)(90 + (2 * (level - 15)));
                        break;
                    }
                    default:
                    {
                        bns = (Int16)(100 + (1 * (level - 20)));
                        break;
                    }
                }
            }
            else
            {
                foreach (MinMaxBonus bonus in _levelBonuses)
                {
                    if (bonus.IsValueInRange(caster.Level))
                    {
                        bns += bonus.Amount;
                        break;
                    }
                }
            }

            roll += bns;

            result = roll;

            if (roll >= 100)
                return true;
            else
                return false;

        }
    }

The first couple of properties are straightforward. The _preferredClassID property allows a bonus to be added if the character that's using that skill is of the preferred class (for example, rangers tend to be better with at tracking than non-rangers). You can use either that property or just assign a bigger amount to the Ranger item in the _classBonuses member. I've tried to give some flexibility to the class so you can use it how you need to for your game.

The _costs member represents the idea that in some system it costs the character something to train in a skill. This could be points that the character gets each level, in a level-based system, to use in training in whatever skills they desire. In a skill-based system, the character would get better at a skill a little each time he successfully uses it. In that case you could either add a property to tell how often the skill would increase or use the _levelBonuses member, having one or more items in the list to get a range or number of times the skill needs to be used to increase the ability with it.

The _classBonuses and _raceBonuses are a set amount for each class and race. The _levelBonuses and _statBonuses allow you to specify an amount for a range of levels or stat values. The MinMaxBonus is a simple structure that looks like this:

    public struct MinMaxBonus
    {
        public int Min;
        public int Max;
        public int Amount;

        public bool IsValueInRange(int value)
        {
            return (value >= Min && value <= Max);
        }
    }

The _alwaysOn member allows you to have skills that don't require an explicit use of the skill. For example, you could have a Perception skill where the game allows the character a chance of noticing something without the player actively searching the area he's in. The game would just check to see if the character had that skill and use it. If the use succeeded the character would be notified. This is more so that the player can be told that the skill is something that doesn't always require their explicit initiation of the skill (say, in a skill select dialog).

The typical functionality of adding, removing, and getting items in the list exist and the Use function allows the game to see if an attempt by the character at using the skill succeeds and, if so, by how much). The target is an instance of an Object class since a skill can be used on more than just an Entity (say casting a Remove Trap spell on a chest or casting an area effect spell).

The Use function gets a random number from 1-100 (if your system uses a different range you'll have to change this obviously) then checks to see how difficult the task the character is attempting to perform is. This is represented by an enum with values that are added to the roll:

    public enum Difficulty
    {
        Impossible = -50,
        VeryHard = -25,
        Hard = -10,
        Normal = 0,
        Easy = 10,
        VeryEasy = 25
    }

This is another area that you can tweak for your game. After adding this the bonuses for the character performing the attempt and entity the skill is being used on are added up. This value (which can be positive or negative) is added to the roll. If the value of the roll is greater than 100 the attempt succeeds. The roll is returned to the calling code in order to allow for things like critical success or failure results. If the character makes a stupendous effort or fails spectacularly, the calling code can do something specific (say the character drops his weapon is the result is less than a certain amount or the attempt takes less time than normal if the result is a certain amount over 100, allowing him to perform another action when he normally wouldn't be able to).

We'll track the skills an Entity has by keeping a list of EntitySkill objects:

    public class EntitySkill
    {
        private int _id;
        private int _amount;

        public int Amount
        {
            get { return _amount; }
        }

        public EntitySkill(int id, int amount)
        {
            _id = id;
            _amount = amount;
        }

        public void Increase(int amount)
        {
            _amount += amount;
        }

        public void Decrease(int amount)
        {
            _amount -= amount;
        }
    }

This class tells us the ID of the skill and how much he's trained in it. It also allows for the amount to be increased or decreased, say through lack of use.

We now have one more chunk of code done for our system. The next post will probably be a big one as we'll look at our item system. As always feel free to give me your feedback on this post in the forums here.

RPG Game Development - Part 2

Mon, 10 Dec 2007 15:06:50 GMT

If you picture a character from an RPG in your mind what stands out? If you said anything other than the race of the character and their class (or profession), feel free to come back when you've gotten with the program. :)

OK, now that we know what we'll be talking about this time around, let's see what we're dealing with. Every fantasy-based RPG that I can recall and most sci-fi RPGs incorporate multiple races to allow the player some freedom in helping select how they'll play the game as well as make the game a bit more interesting since you're not constantly running into just humans (or whatever the main race is in the game). One race is usually better at one or more things than others, so if you like to play an RPG a certain way you'll probably pick one race the first time around (assuming you play the game more than once).

One of the usual steroetypes have elves as the best class that use a bow (which makes them the best for a ranger-type character or fighter that specializes in long-ranged attacks) and sometimes magic-users, although they're usually weak physically. There's also the added benefit of night-vision and sometimes resistance to magic, poisons, and disease.

Dwarves are stout, hardy fellows that make good fighters. Halflings and sometimes half-elfs make good thiefs. Humans are usually pretty good at everything while specializing in nothing. Playing as a human means you can go in whatever direction you want at any time, assuming you're not locked into a specific class for the entire game (as is the case with RPGs that strictly go the skill-based route).

Looking at these stereotypes it seems we need a way to modify a character's stats, skills, and what we'll call resistances and weaknesses. While we haven't defined anything but stats at this point, it's a fairly safe assumption that the values will be integers. That being said, here's a first cut:

    [Serializable]
    public class Race
    {
        private int _id;
        private string _name = "";
        private string _description = "";

        private Dictionary<int, int> _statModifiers;
        private Dictionary<int, int> _skillModifiers;

        private List<Modifier> _weaknesses;
        private List<Modifier> _resistances;

        public int ID
        {
            get { return _id; }
        }

        public string Name
        {
            get { return _name; }
            set { if (_name.Length > 0) _name = value; }
        }
        
        public string Description
        {
            get { return _description; }
            set { if (value.Length > 0) _description = value; }
        }

        public Race(int id)
        {
            _id = id;
        }

        public int GetStatModifier(int id)
        {
            int value = 0;

            if (_statModifiers != null)
                _statModifiers.TryGetValue(id, out value);

            return value;
        }

        public int GetSkillModifier(int id)
        {
            int value = 0;

            if (_skillModifiers != null)
                _skillModifiers.TryGetValue(id, out value);

            return value;
        }

        public void AddStatModifier(int id, int value)
        {
            if (_statModifiers == null)
                _statModifiers = new Dictionary<int, int>();

            _statModifiers.Add(id, value);
        }

        public void AddSkillModifier(int id, int value)
        {
            if (_skillModifiers == null)
                _skillModifiers = new Dictionary<int, int>();

            _skillModifiers.Add(id, value);
        }

        public void RemoveStatModifier(int id)
        {
            if (_statModifiers == null)
                return;

            _statModifiers.Remove(id);
        }

        public void RemoveSkillModifier(int id)
        {
            if (_skillModifiers == null)
                return;

            _skillModifiers.Remove(id);
        }

        public void AddWeakness(Modifier weakness)
        {
            if (_weaknesses == null)
                _weaknesses = new List<Modifier>();

            _weaknesses.Add(weakness);
        }

        public void AddResistance(Modifier resistance)
        {
            if (_resistances == null)
                _resistances = new List<Modifier>();

            _resistances.Add(resistance);
        }

        public void RemoveWeakness(int index)
        {
            if (_weaknesses == null)
                return;

            _weaknesses.RemoveAt(index);
        }

        public void RemoveResistance(int index)
        {
            if (_resistances == null)
                return;

            _resistances.RemoveAt(index);
        }

        public int CheckResistance(ModifierType type)
        {
            if (_resistances == null)
                return 0;

            foreach (Modifier resistance in _resistances)
            {
                if (resistance.Type == type)
                {
                    return resistance.Amount;
                }
            }

            return 0;
        }

        public int CheckWeakness(ModifierType type)
        {
            if (_weaknesses == null)
                return 0;

            foreach (Modifier weakness in _weaknesses)
            {
                if (weakness.Type == type)
                {
                    return weakness.Amount;
                }
            }

            return 0;
        }
    }

At this point we just have an ID that we'll use as a link in the upcoming Entity class, a name and description, two Dictionary objects for allowing modifications to stats and skills (the first part of the Dictionary is the ID of the stat or skill and the second is the positive or negative value to modify that stat or skill), and two lists for allowing resistances and weaknesses for a race. The Modifer object is a structure whose definition is:

    public struct Modifier
    {
        public ModifierType Type;
        public int Amount;
    }

ModifierType is an enum:

   public enum ModifierType
    {
        Fire,
        Water,
        Magic,
        Disease,
        Poison
    }

Feel free to add to the list. You could even make ModiferType something that's read from a file to make it dynamic. In that case you might want to make it a structure as well with an ID property and a value so it can be changed without breaking the links to objects that use it.

The EntityClass class

The EntityClass class is similar to the Race class in that it allows the character to be better and worse at some skills and it modifies stats to represent the intense training members of that class undergo. It also allows items to only be usable by certain classes and races to be only certain classes. If you want to do race/class restrictions, simply add a List<EntityClass> member to the Race class to indicate the allowed classes that the race may be along with the appropriate code to handle add and removing items from it. Using this class, however, is completely optional if you want your RPG to be strictly skill-based.

    public class EntityClass
    {
        private int _id;

        private string _name = "";
        private string _description = "";

        private Dictionary<int, int> _statModifiers;
        private Dictionary<int, int> _skillModifiers;

        public int ID
        {
            get { return _id; }
        }

        public string Name
        {
            get { return _name; }
            set { if (_name.Length > 0) _name = value; }
        }

        public string Description
        {
            get { return _description; }
            set { if (value.Length > 0) _description = value; }
        }

        public int GetStatModifier(int id)
        {
            int value = 0;

            if (_statModifiers != null)
                _statModifiers.TryGetValue(id, out value);

            return value;
        }

        public int GetSkillModifier(int id)
        {
            int value = 0;

            if (_skillModifiers != null)
                _skillModifiers.TryGetValue(id, out value);

            return value;
        }

        public void AddStatModifier(int id, int value)
        {
            if (_statModifiers == null)
                _statModifiers = new Dictionary<int, int>();

            _statModifiers.Add(id, value);
        }

        public void AddSkillModifier(int id, int value)
        {
            if (_skillModifiers == null)
                _skillModifiers = new Dictionary<int, int>();

            _skillModifiers.Add(id, value);
        }

        public void RemoveStatModifier(int id)
        {
            if (_statModifiers == null)
                return;

            _statModifiers.Remove(id);
        }

        public void RemoveSkillModifier(int id)
        {
            if (_skillModifiers == null)
                return;

            _skillModifiers.Remove(id);
        }
    }

Manager Classes

We'll need some classes to manage the Race and EntityClass objects. They're fairly simple at this point:

    public class StatManager
    {
        private List<Stat> _stats;

        private static int _numStats = 0;

        public static int NumStats
        {
            get { return _numStats; }
        }

        public StatManager()
        {
            _stats = new List<Stat>();
        }

        public StatManager(string filename)
        {
            if (File.Exists(filename))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(Stat));

                FileStream fs = new FileStream(filename, FileMode.Open);

                _stats = (List<Stat>)serializer.Deserialize(fs);

                _numStats = _stats.Count;
            }
        }

        public Stat GetStat(int id)
        {
            foreach (Stat stat in _stats)
            {
                if (stat.ID == id)
                    return stat;
                break;
            }

            return null;
        }
    }

    public class RaceManager
    {
        private List<Race> _races;

        private static int _numRaces = 0;

        public static int NumRaces
        {
            get { return _numRaces; }
        }

        public RaceManager(string filename)
        {
            if (File.Exists(filename))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(Race));

                FileStream fs = new FileStream(filename, FileMode.Open);

                _races = (List<Race>)serializer.Deserialize(fs);

                _numRaces = _races.Count;
            }
        }

        public Race GetRace(int id)
        {
            foreach (Race race in _races)
            {
                if (race.ID == id)
                    return race;
                break;
            }

            return null;
        }
    }

    public class EntityClassManager
    {
        private List<EntityClass> _classes;

        private static int _numClasses = 0;

        public static int NumClasses
        {
            get { return _numClasses; }
        }

        public EntityClassManager(string filename)
        {
            if (File.Exists(filename))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(EntityClass));

                FileStream fs = new FileStream(filename, FileMode.Open);

                _classes = (List<EntityClass>)serializer.Deserialize(fs);

                _numClasses = _classes.Count;
            }
        }

        public EntityClass GetEntityClass(int id)
        {
            foreach (EntityClass entityClass in _classes)
            {
                if (entityClass.ID == id)
                    return entityClass;
                break;
            }

            return null;
        }
    }

Note that I threw in the StatManager class as well that I omitted from the last post.

The classes assume that the items will exist in an XML serialized file. If you want to use another method, such as binary serialization, simply change the serializer object (or all loading code) as appropriate. XML serialization won't prevent players from looking into the files to see the data, but for our purposes it's not worth the effort to try to obfuscate the data. XML is easily read while debugging the code that uses it, making it a nice format for developers to allow tweaking of values in testing. Once you've balanced the data you can simply change the loading and saving code if you'd like.

The nice thing about having a manager class like this is the static member that allows code to get the number of items without having to create an instance of the class.

That's it for this post. It's been a long one since we covered two classes, but we're almost at a point where we can tie it all together in an Entity object that will represent our character (and every other living creature) in a game. The next post will cover skills, which will allow an entity to perform actions, something that'll be fairly useful in a game. :)

You can discuss this post on the forums here.

RPG Game Development - Part 1

Wed, 05 Dec 2007 21:15:12 GMT

I've been kicking around an RPG game for about 4 or 5 years. It's gone through several designs since each time new technology comes out I end up redoing it using that tech. It started out as a Visual Basic 6 game using DirectDraw. When Visual Studio.NET came out I started doing it in VB.NET and Managed DirectX. Now that XNA has come out and it's basically the only thing I'm doing game development in at this time, I've started redesigning it once again. Since many people that start out in game development seem to want to make an RPG (or an MMORPG depending on how old they are and what they were first exposed to in the RPG genre :D) and there seems to be a desire for more XNA starter kits, I thought it might be interesting to make this current version something that could be reused by other people. The next thought was, maybe I should make it generic enough that people that might use it wouldn't be stuck with the specific things I want to do in my RPG - types of stats, magic system, classes, etc. After all, not all RPGs are fantasy based so having just the typical Fighter, Magic-User, Thief, Cleric, Ranger classes in the kit might not be a good thing.

Having made the decision to try to make this as generic as possible, I thought maybe I should solicit ideas from the community, which means getting my ideas and code out there so people can tear it apart... umm, make suggestions. This is the first in what I hope will be many posts that will end up with an RPG starter kit that budding XNA game developers (and even non-XNA developers, assuming they either convert the classes to whatever language they're using or using C# with some other technology) can use to create their dream RPG.

Stats

In thinking about things, it seems the stat is one base for many other code classes. Characters use stats to figure out what profession they can follow (character classes), how well they can do things (skills), and how well they can do them, so it seems to make sense to start with a stat class. Actually, I was thinking there would be multiple classes dealing with stats. The base stat class currently looks like this:

    public enum StatType
    {
        Regular,
        Calculated
    }

    public enum DieType
    {
        d4 = 4,
        d6 = 6,
        d8 = 8,
        d10 = 10,
        d12 = 12,
        d20 = 20,
        d100 = 100,
        MaxDie = 100
    }

    [Serializable()]
    public class Stat
    {
        private int _id;
        private StatType _type;
        private string _name;
        private string _abbreviation;
        private string _description;
        private string _statCalculation;

        private bool _addsToSkillPoints;
        private bool _addsToManaPoints;

        [NonSerialized()]
        public const Int16 MAX_STAT_VALUE = (Int16)DieType.MaxDie;

        public Stat(int id, string name)
        {
            _id = id;
            _name = name;
        }

        public int ID
        {
            get { return _id; }
        }

        public StatType Type
        {
            get { return _type; }
            set { _type = value; }
        }

        public string Name
        {
            get { return _name; }
            set { if (value.Length > 0) _name = value; }
        }

        public string Abbreviation
        {
            get { return _abbreviation; }
            set { if (value.Length > 0) _abbreviation = value; }
        }

        public string Description
        {
            get { return _description; }
            set { if (value.Length > 0) _description = value; }
        }

        public string StatCalculation
        {
            get { return _statCalculation; }
            set { _statCalculation = value; }
        }

        public bool AddsToSkillPoints
        {
            get { return _addsToSkillPoints; }
            set { _addsToSkillPoints = value; }
        }

        public bool AddsToManaPoints
        {
            get { return _addsToManaPoints; }
            set { _addsToManaPoints = value; }
        }
    }

Having the StatType member allows the developer to have stats that are based on some calculation. For example, you could have a MaxCarryWeight stat that is calculated as some multiple of the character's Strength stat. This calculation is stored in the _statCalculation member. There should be some validation on this is the code or UI that populates it.

The AddsTo... members are something that I'm using in my game and I thought might be useful to other developers. A character develops skills by spending a number of points each time he increases in level (the whole level argument is for another post ;D ). The number of points are calculated based on the value of certain stats. The same goes for a character's mana, which is a representation of how much a magic (or psionic for sci-fi RPGs)-using character can cast spells before becoming too drained to cast any more. Certain stats will be flagged as being used in the calculations. Tables will be developed later for the stat value-to-number of points ratio.

Now that we have a basic stat class we need to have a way to tie them to a character. A simple cross-reference class takes care of this:

    [Serializable]
    public class EntityStat
    {
        private int _id;
        private Int16 _curValue;

        public EntityStat(int id, Int16 value)
        {
            _id = id;
            _curValue = value;
        }

        public Int16 CurrentValue
        {
            get { return _curValue; }
        }

        public void IncreaseStat(Int16 val)
        {
            _curValue += val;
            if (_curValue > Stat.MAX_STAT_VALUE)
                _curValue = Stat.MAX_STAT_VALUE;
        }

        public void ReduceStat(Int16 val)
        {
            _curValue -= val;
            if (_curValue < 1)
                _curValue = 1;
        }
    }

The Entity class that will be developed later will have a list of this class.

That's it for this edition of RPG Game Development. Stay tuned for the next post where we'll develop some other classes that will be used to fill out the Entity class, which will represent a player character, non-player character, or creature.

If you want to discuss this post, head over to the post for this entry on the forums on my site. Unfortunately, I have to require registration due to spamming, but it's a quick and painless process, I promise. :)

Silverlight 1.1 tools for VS 2008

Wed, 28 Nov 2007 12:52:36 GMT

I've been meaning to check out Silverlight 1.1. There's been some cool little things released using it. I still have to install VS 2008 but once I do, I'll be installing this and checking it out.

.NET Framework libraries source code to be released

Thu, 04 Oct 2007 11:36:50 GMT

An interesting post on Scott Guthrie's blog has the news that the source code for the .NET Base Class Libraries will be released with the .NET 3.5 and VS 2008 release later this year. It's great to see that Microsoft continues to excel at releasing things to developers.

Visual Studio 2008 Beta 2 Downloads Available

Fri, 27 Jul 2007 12:09:44 GMT

Check it out here or here (for a download using the Microsoft Secure Content Downloader). I had issues with the last beta when installing on the same machine as VS 2005. The beta caused all sorts of problems with VS 2005 so I recommend installing to a separate box if you can.

VS 2008 Beta 2 Coming

Wed, 18 Jul 2007 13:23:17 GMT

From Scott Guthrie's blog:

"Monday, July 09, 2007 10:30 AM by ScottGu

Hi Andreas,

VS 2008 Beta2 should be available for free download in the next three weeks. It will support a go-live license.

Thanks,

Scott"

360 Live API

Mon, 29 Jan 2007 18:24:51 GMT

A post in the MSDN forums led me to a search which pulled up this page. I didn't know that much of the Live service was exposed for our perusal. If I get a chance, I may experiment with this a bit and post the results here. Please post a comment here if you dig into this and let us know what you've done.

C# EE SP1 Beta - come and get it

Tue, 17 Oct 2006 14:57:59 GMT

A new entry on the XNA Team's blog let us know of the download for the beta of SP1 of C# EE. Check it out.