Machaira's Space: Blog

Great XNA Zune game video

Mon, 09 Jun 2008 21:47:08 GMT

Found this video on a post on Michael Klucher’s blog. This looks pretty good for a PC game so the fact that it’s running on the Zune is very cool.

Yeah, I'm a slacker...

Thu, 29 May 2008 20:47:15 GMT

I'm recovering from back surgery that I had just over a week ago, so I figured I'm entitled. :)

What I'm doing:

Working on my second XNA book - this one on RPG development. I'm been going over the proof for the first one. Hopefully it'll be out early next month.
Trying out the new Creators Club site. If you haven't been there in a while, check it out. If you're a CC Premium member, there's over a dozen XNA games available on the Xbox 360 for you to try out. Woot!
Writing a design doc for a game I've been trying to get done. Hopefully I'll get the game done in time for the next Dream-Build-Play contest.
Trying out games on the Zune. Woot again!
I uploaded a couple of videos to YouTube of me (and Ziggy) doing some Rock Band that Z-Man was kind enough to take at the 2008 MVP Summit.
Other (boring to you guys, and sometimes me) non-games development related stuff. :(

Back from the MVP Summit

Mon, 21 Apr 2008 19:44:03 GMT

Yes, I've been slacking off again, but for the past week I had an excuse (kinda). I was at the Microsoft MVP Summit learning about all the cool stuff that's coming and playing with my new Zune. :)

All kinds of silly (and not so silly) ideas were tossed around by the XNA MVPs and I threw together one of them - Endurance. It's a silly little game, but knowing the competitive nature of gamers, someone will keep it going for wayyyyy too long. :D

Our friend George was the originator of this one, so go blame him if you'd like.

XNA Game Studio Quickie

Wed, 26 Mar 2008 11:15:05 GMT

Channel 10 has been giving XNA GS some love for a while now. Laura Foy made another post last night that you can check out here. Hit the XNA tag on the post for more good stuff.

Some bad news and some good news

Thu, 20 Mar 2008 17:56:27 GMT

The bad news would be for those 2 or 3 people that were following my RPG series and waiting for the next part. I'm afraid that series is going to be discontinued. :( The good news is that I'm starting a much larger version of it. More info will follow soon. :)

I've been fiddling around with this RPG and associated book/text since my VB 6 days. It's great that it'll finally see the light of day.

Dishwasher makes OXM

Wed, 05 Mar 2008 21:28:32 GMT

Check out the latest issue (April 08) of the Official Xbox Magazine. On page 54 you'll notice that The Dishwasher: Dead Samurai game created with XNA Game Studio is included in the list of upcoming Xbox Live Arcade games. Very nice. Another known commercial XNA GS game, Schizoid, is also included on that page. It looks like XNA Game Studio is set to take over the gaming industry, especially come the end of this year when we'll have the ability to publish XNA GS games to Live Arcade. :)

A picture is worth a thousand words

Wed, 05 Mar 2008 14:19:06 GMT

Or a thousand HP in this case:

Iron Man Movie Trailer

Wed, 05 Mar 2008 03:44:41 GMT

OK, so this is a little old, but it's still freakin' cool! The movie is looking great so far. It might actually live up to us fanboy's expectations. :)

GDC Expo Floor Video

Mon, 03 Mar 2008 17:58:46 GMT

So you didn't get to attend this year's GDC (like me :( ) and you missed all the goodness of the GDC Expo. We'll Dave Mark has come to your rescue. Here's his "Expo in 10 minutes" post with accompanying video.

XNA Game Distribution Info

Fri, 22 Feb 2008 20:58:08 GMT

Gamasutra has posted a nice article detailing the steps for the up-coming XNA community game distribution model.

Zune XNA Game Video

Thu, 21 Feb 2008 15:45:23 GMT

Unfortunately, I can't embed from MSN Video (at least I couldn't figure it out in the 2 minutes I spent trying), but you can check it out here.

MS GDC Keynote Information Revealed

Wed, 20 Feb 2008 20:32:50 GMT

I've posted this to a couple of places already, but this post is probably a good one to link to.

/me gets back to work on a game for the beta

edit: Gamasutra now has their review up

XNA Live Arcade extensions unveiled

Tue, 19 Feb 2008 22:42:12 GMT

From this article, looks like MS revealed something before the keynote tomorrow. Pro developers that aren't doing cutting edge games shouldn't have many reasons left not to adopt XNA Game Studio now.

Dream-Build-Play Warm-up Winners Announced

Tue, 19 Feb 2008 13:24:16 GMT

Five winners were announced yesterday. Congrats to all. I haven't had a chance to play any of the games, but I'm hoping to find some time. Now we just have to wait for the main competition to start. :)

New Xbox Live in the works?

Tue, 19 Feb 2008 00:36:41 GMT

According to this article, it's possible. Combine that with the title of the MS keynote at the Game Developers Conference and I think we'll see some interesting things in the near future from Microsoft. Stay tuned Wednesday when MS will reveal what's in store.

Attend the GDC virtually through your Xbox 360

Fri, 15 Feb 2008 03:47:32 GMT

See here.

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

2007 Darwin Awards

Mon, 14 Jan 2008 14:15:59 GMT

Seems there's no limit to the amount of stupid people in this world. It continually amazes me that people willingly do things that they don't need to do that are potentially fatal. You can read about the departed here.

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
                }
            }

        }
    }

MVP Status Renewed!

Tue, 08 Jan 2008 21:19:49 GMT

Yes, MS saw fit to renew my MVP Award for another year. I guess I did something worthwhile during the year to earn it. Since George will make me look bad with his list, I'll have to do one myself. :)

XBL Radio Podcast

I started the year off by participating in a podcast with the guys over at XBL Radio and a couple of developers talking about XNA and the possibility for gamers and game developers. You can download the podcast from here.

Tech Editing

I did the tech edits for two XNA books, Ben Nitschke's Pro XNA Game Programming book and the as-yet-unreleased Expert One-on-One XNA Game Programming book.

Forums

I continued helping out on a couple of forums - the Creators Club site forums, GameDev.net, and the Game Programming Wiki forums, although my posts on the CC forums lagged behind a couple of others. But hey, one of them is on the XNA team and another sits around the house for a living, supposedly doing software development (yes, I'm talking about the Z-Man ;) ). I'm guessing Nick just doesn't have a life (even more so than me) to have upped his post count so greatly.

Blog

Although I didn't make as many posts as I wanted on this blog, I think I did manage to get a couple out there that someone hopefully found useful. I'm determined to finish my serious on RPG game dev using XNA and get my RPG Starter Kit out there before MS releases theirs. :)

XNA Book

I guess the biggest thing I worked on was the book I'm co-authoring for Wordware. While not quite aimed at the same audience as Ben's, hopefully it'll help people out. The fact that it's been updated for XNA Game Studio 2.0 (which threw a big wrench in the works and has delayed it a bit) is a plus. I'd love opportunity to do another, maybe on RPG game development in XNA (maybe even an MMORPG!!! :D OK, so it wouldn't be an MMO, but it's cool to dream, right!?)

Maybe George and I will set a precedent for the other XNA MVPs and we'll get more of us talking about how great game development using XNA GS can be! ;)

Fun Quiz Time

Fri, 04 Jan 2008 18:55:33 GMT

Stumbled across these in one of my net wanderings. Nice to know I have a good chance of surviving a zombie apocalypse. :) Click them and see how you match up.

72% Geek

60%

Free Xbox Live Arcade Game Coming

Fri, 04 Jan 2008 18:47:26 GMT

Marc Whitten, the General Manager of Xbox LIVE says in an upcoming letter:

Dear Xbox LIVE Members:
During this past holiday season you helped us break a number of Xbox LIVE records. This included our largest sign-up of new members to Xbox LIVE in our 5 year history and just yesterday you broke the record for the single biggest day of concurrent members ever on the service.
As a result of this massive increase in usage we know that some of you experienced intermittent Xbox LIVE issues over the holiday break. While the service was not completely offline at any given time, we are disappointed in our performance. I would like to take this moment to thank you each and every one of you for your patience and understanding as our team has worked around the clock to return the service to a stable state.
At the same time we would like to offer a token of our appreciation to all of you in celebration of record success for the service. And as a thank you for your loyalty during this holiday period, we will be offering all of our Xbox LIVE members around the world access to a full Xbox LIVE Arcade game that will be available to download free of charge. In the coming weeks we will be sharing the specific details of this offer with you.
Thank you again for helping make Xbox LIVE everything that it is today!
Sincerely,
Marc Whitten
General Manager, Xbox LIVE

Gotta love free stuff. I wonder if we'll get to choose which game? Probably not, but it's still nice that they're doing this.

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.

Hotkey Bar Component

Mon, 24 Dec 2007 18:16:13 GMT

A post on the Creators Club forums got me thinking about how a typical MMORPG hotkey bar interface could be done that would use the 360 Gamepad controller. I took a couple minutes to whip up a component with one idea on how to do this. Grab it from the Downloads page on my site and let me know what you think by posting in my forums.

XNA 2.0 and VS 2008

Wed, 19 Dec 2007 13:04:48 GMT

Yup, although it's not officially supported, you can use them together. Check out Ultrahead's great article and then be sure to vote for it.

XNA Game Installer

Wed, 19 Dec 2007 12:38:30 GMT

Cygon has come up with an installer template for Wix for your XNA games. Looks like it could be the answer many people are looking for. Check it out over at CodePlex.

RPG Game Development - Part 5

Wed, 19 Dec 2007 12:35:35 GMT

Almost every RPG, no matter what type, has some kind of system that allows for extra-normal abilities. Whether it's called magic in a fantasy RPG or psionics in a sci-fi RPG doesn't matter. It's easy enough to build a system that allows for both and that's what we'll do here.

We'll start out with the Spell class:

    [Serializable()]
    public class Spell
    {
        private SpellType _type;
        private string _name;
        private string _description;
        private string _effectAmount;
        private string _range;
        private List<int> _classesRequired;
        private string _duration;
        private byte _levelRequired;
        private short _manaCost;
        private AlignmentBitwise _alignmentsRequired;
        private SpellCastRate _castRate;
        private List<Bonus> _defBonuses;
        private List<Bonus> _offBonuses;
        private List<Bonus> _miscBonuses;

        //graphic used in the spellbook in-game
        [NonSerialized()]
        private Texture2D _spellBookGraphic;

        private string _spellBookGraphicFilename;

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

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

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

        public string EffectAmount
        {
            get { return _effectAmount; }
            set { _effectAmount = value; }
        }

        public string Range
        {
            get { return _range; }
            set { _range = value; }
        }

        public List<int> ClassesRequired
        {
            get { return _classesRequired; }
            set { _classesRequired = value; }
        }

        public string Duration
        {
            get { return _duration; }
            set { _duration = value; }
        }

        public byte LevelRequired
        {
            get { return _levelRequired; }
            set { _levelRequired = value; }
        }

        public short ManaCost
        {
            get { return _manaCost; }
            set { _manaCost = value; }
        }

        public AlignmentBitwise AlignmentsRequired
        {
            get { return _alignmentsRequired; }
            set { _alignmentsRequired = value; }
        }

        public SpellCastRate CastRate
        {
            get { return _castRate; }
            set { _castRate = value; }
        }

        public List<Bonus> DefensiveBonuses
        {
            get { return _defBonuses; }
            set { _defBonuses = value; }
        }

        public List<Bonus> OffensiveBonuses
        {
            get { return _offBonuses; }
            set { _offBonuses = value; }
        }

        public List<Bonus> MiscBonuses
        {
            get { return _miscBonuses; }
            set { _miscBonuses = value; }
        }
        
        public bool Cast(ref Object target, ref Entity caster)
        {


            return true;
        }

        public bool Cast(ref Entity target, ref Entity caster)
        {
            short mr = target.MagicResistance;
            short roll = GlobalFunctions.GetRandomNumber(DieType.d100);

            //Get caster's skill bonus
            roll += (short)caster.GetCastingSkillBonus();

            //resistance not applicable for any but offensive spells
            if (_type == SpellType.Offensive)
                roll -= mr;

            if (roll >= 100)
            {
                switch (_type)
                {
                    case SpellType.BuffAny:
                    case SpellType.BuffSelf:
                    {

                        break;
                    }
                    case SpellType.Defensive:
                    {

                        break;
                    }

                    case SpellType.Miscellaneous:
                    {

                        break;
                    }

                    case SpellType.NonCombat:
                    {

                        break;
                    }

                    case SpellType.Offensive:
                    {
                        target.Damage((int)GlobalFunctions.GetRangeAmount(_effectAmount), DamageType.Magical);

                        break;
                    }

                }

                return true;
            }

            return false;
        }
    }

SpellType is an enum with the following members:

    public enum SpellType
    {
        Offensive,
        Defensive,
        BuffSelf,
        BuffAny,
        NonCombat,
        Miscellaneous
    }

_effectAmount, _range, and _duration are declared as strings as they could be a range, say 1-20.

_classesRequired is a list of IDs of EntityClass objects. In almost every RPG system I've seen spells can overlap between classes. This allows us to do so here.

_levelRequired could be set to 0 if you're using a level-less system.

_alignmentsRequired is an Enum with a [Flags] attribute tacked to it which allows it to be treated as a bit field so multiple alignments can use the spell. Unlike entity classes, this will be unchangeable with just 3 alignments. If you want to have a more in-depth alignment system, you could set it up similar to how classes are handled. Here's the enum:

    [Flags] 
    public enum AlignmentBitwise
    {
        None = 0,
        Good = 1,
        Neutral = 2,
        Evil = 4
    }

_castRate is another property that could be adjusted to fit your system. Currently these are the values:

    public enum SpellCastRate
    {
        None=-1,             //No restrictions
        Round,           //Once per round of combat
        Minute,
        Hour,
        Day,
        Week,
        Month
    }

The Bonus structure for the _defBonuses, _offBonuses, and _miscBonuses looks like this:

    public enum BonusType
    {
        Disease,
        Magic,
        Poison,
        Potion,
        Other
    }

    public struct Bonus
    {
        public BonusType Type;
        public short Amount;
        public int  TimeStarted;
        public int Duration;
        public int ElapsedTime;
    }

The Cast function is overloaded to allow different handling if the spell is cast on an entity or an object. This might not be necessary but I thought it would allow a bit more flexibility. For my system resolution works like this - a random number from 1 to 100 is generated. The total of any resistances the entity might have is subtracted and any bonuses the cast might have is added. If the result is 100 or greater the casting succeeds. If the spell is an offensive type, a function is called to get the random amount of damage in the spell's damage range and the entity's Damage method is called, passing the amount and type of damage, since even though the casting succeeded, the entity could have a bonus that reduces the amount.

Like most other base classes, we'll have a class between the Spell class and the Entity class:

    [Serializable]
    public class EntitySpell
    {
        private int _id;
        private bool _learned;
        private bool _memorized;
        private byte _skillPointsAllocated;
        private long _lastCast;
        private string _hotKey;

        public int ID
        {
            get { return _id; }
            set { _id = value; }
        }

        public bool Learned
        {
            get { return _learned; }
        }

        public bool Memorized
        {
            get { return _memorized; }
        }

        public byte SkillPointsAllocated
        {
            get { return _skillPointsAllocated; }
        }

        public long LastCast
        {
            get { return _lastCast; }
            set { _lastCast = value; }
        }

        public string HotKey
        {
            get { return _hotKey; }
            set { _hotKey = value; }
        }

        public void AllocatePoints(byte amount)
        {
            _skillPointsAllocated += amount;
        }

        public bool Learn()
        {
            short roll = GlobalFunctions.GetRandomNumber(DieType.d100);

            if (roll + (_skillPointsAllocated * 5) >= 100)
            {
                _learned = true;
                _skillPointsAllocated = 0;
            }

            return _learned;
        }

        public void Memorize()
        {
            if (_learned)
                _memorized = true;
        }
    }

The class is set up so that you have to learn a spell by allocating points that you get each level. If you're going with a level-less system you'll have to make some changes. The character also has to memorize the spell after learning it before he can use it. If you want the character to be able to cast any spell he knows at any time, you'll want to just ignore the _memorized property. You could add a MustMemorize property to the Spell class or a MustMemorizeSpells property to the EntityClass objects that have spell casting ability and key off that.

That's pretty much the basics of the magic system. We'll be adding things later like a spell book to display the spells known by a character. Once we have our Entity class we'll hook it into using the spells (and skills and items :D ).

As always, please post feedback on the forums.

RPG Game Development - Part 4

Tue, 18 Dec 2007 17:02:40 GMT

An RPG wouldn't be an RPG without all the cool loot, right (I resisted the temptation to spell it k3w1 13w7 or however it's spelled in leet speak :D). In order to get some loot in the game, we'll need some classes to create them. Since almost every type of item has some of the same properties we'll start out with a base class:

    abstract public class BaseItem : Object
    {
        protected int _id;

        protected string _name;
        protected string _description;
        protected float _weight;
        protected byte _strengthRequired;
        //Used for different purposes depending on the type of derived item
        protected string _tag;

        protected Texture2D _picture;   //used in inventory/vendor dialogs

    }

The Texture2D is an XNA Framework class, so if you're doing a non-XNA game you'll need to replace it with whatever class is similar.

We'll have one type of object that inherits from this, money:

    public class Money : BaseItem
    {
        private const int NUM_COINS_TO_WEIGHT_UNIT = 100;

        private int _amount;

        //Overrides since the strength required changes as the amount changes
        public Byte StrengthRequired()
        {
            return (byte)(_amount * 0.01);
        }

        public int Total()
        {
            return _amount;
        }
        
        public Money()
        {

        }

        public static int GetWeight(int amount)
        {
            return (int)(amount / NUM_COINS_TO_WEIGHT_UNIT);
        }

        public int TotalWeight
        {
            get { return GetWeight(_amount); }
        }

        //Called for things like buying items
        public void Subtract(int amount)
        {
            if (amount <= _amount)
                _amount -= amount;
        }

        //Parameter is declared as ref so we can modify it to let the calling code know
        //that we couldn't hold the full amount. This should never happen however
        //as the weight alone should limit what an entity can carry
        public void Add(ref int amount)
        {
            if (amount + _amount <= int.MaxValue)
            {
                _amount += amount;
            }
            else
            {
                amount = (int)(int.MaxValue - _amount);
                _amount = int.MaxValue;
            }
        }

        //Called for things like dropping on the ground etc
        //Added simply for making sense in the context for which it's used
        public void Drop(int amount)
        {
            Subtract(amount);
        }

        public void Give(ref int amount, ref Entity target)
        {
            if (amount <= _amount)
            {
                target.AddMoney(ref amount);

            }
        }
    }

All our other item types will inherit from the Item class, which itself inherits BaseItem:

    public abstract class Item : BaseItem
    {
        protected ItemType _type;

        protected int _cost;
        protected bool _magical;
        protected AlignmentBitwise_alignment;

        protected bool _questItem;
        protected byte _questItemPiece;
        protected int _questID;
        protected bool _questReward;

        protected bool _droppable;
        protected bool _tradeable;

        protected int _baseHP;

        protected List<Spell> _spells;

        protected List<Bonus> _defBonuses;
        protected List<Bonus> _offBonuses;
        protected List<Bonus> _miscBonuses;

        //Is item automatically put in character's hand when picked up
        protected bool _autoReady;

        protected bool _repairable;

        protected bool _unique;

        //ID of the skill required to use this
        protected int _skillRequired;

        //All classes that derive from this one must implement this function
        public abstract bool Use(ref Object target, ref Entity wielder);

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

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

        public float Weight
        {
            get { return _weight; }
            set { _weight = value; }
        }
//other property accessors snipped for brevity

ItemType is one of the following:

    public enum ItemType
    {
        Armor,
        Chest,
        Key,
        Potion,
        Scroll,
        Shield,
        Weapon,
        Money         //Placed out of order since we don't create money in the Editor
    }

For the game I'm creating using this framework, I have an editor that I use to create items. I load the names of the items in this enum into a combobox but since money isn't created I just put it at the end of the list and load all the items except that last one. A bit of a hack, but it works in this case. Any items that a developer wants to add to the list should be placed before Money to avoid breaking any existing created items.

If you want to have character alignments in your game the _alignment property allows you to have items that are only used by characters of a certain alignment. In the case of my game it's a pretty simple enum:

    [Flags] 
    public enum AlignmentBitwise
    {
        None,
        Good,
        Neutral,
        Evil
    }

The [Flags] attribute allows for multiple alignments to be selected.

Every good RPG has quests and the rewards are sometimes items so there's a group of properties to allow you to tell if an item is the object of a quest or the reward of a quest. You can also have items that are broken into pieces. You can also have the item be unique in your world if you'd like so everyone in your multiplayer game isn't running around with the most powerful item in the game.

If you're doing a multiplayer RPG you can allow items to not be tradeable between players by setting the _tradeable property. You can also not allow items to be dropped so other players can pick them up, requiring that the item be destroyed if the player wants to get rid of it (or put in a bank if you have that functionality).

If you want to have your items be capable of being destroyed and repaired those properties exist.

A set of properties exist to allow you to add defensive, offensive, or miscellaneous bonuses to the item and to specify if the item is magical and has spells embedded in it that allows the character to use them as if they knew them. The Bonus structure looks like this:

    public struct Bonus
    {
        public BonusType Type;
        public short Amount;
        public int  TimeStarted;
        public int Duration;
        public int ElapsedTime;
    }

It allows for temporary bonuses. If the bonus is permanent you would just set the Duration to 0. The Type member is an enum with the following:

    public enum BonusType
    {
        Disease,
        Magic,
        Poison,
        Potion,
        Other
    }

You could have a dagger with that does additional poison damage by adding a Bonus object to the _offBonuses list with a BonusType of Poison. When the damage is calculated this additional bonus amount would be handled separately since the target could have a weakness or resistance to poison. If the target had neither, the bonus amount would apply even if the other damage doesn't get applied for some reason. Again, flexibility is key in what I'm trying to put together.

Depending on how you want your engine to work you can either have the calculation of whether or not using the item succeeds as a member of the item itself or of the Entity class (which we'll build in a couple of posts). At this point I haven't determined how I'm going to do it so the Use method just exists. I'm leaning towards just having the Entity object do it, but having the method in the Item class allows me to go either way.

The classes that derive from Item have additional properties and methods depending on the type of item. The Armor class looks like the following:

    [Serializable()]
    public class Armor : Item
    {
        private ArmorArea _location;
        private short _defValue;
        private bool _equipped;

        public ArmorArea Location
        {
            get { return _location; }
            set { _location = value; }
        }

        public short DefensiveValue
        {
            get { return _defValue; }
            set { _defValue = value; }
        }

        public bool Equipped
        {
            get { return _equipped; }
        }

        public override bool Use(ref Object target, ref Entity wielder)
        {
            //Use for this class means to equip, so set member if it's being equipped
            short loc = (short)target;

            if (loc > -1)
            {
                //the value tells us where it's trying to be equipped so check it
                //for instance, a piece is dragged onto the wrong location in the character screen
                if (loc != (short)_location)
                    return false;

                _equipped = true;
            }
            else
                _equipped = false;
            
            return true;
        }
    }

The _location is an enum with the following:

    public enum ArmorArea
    {
        None=-1,
        Head,
        Neck,
        Chest,
        LeftUpperArm,
        UpperArms,
        LeftLowerArm,
        LowerArms,
        LeftWrist,
        Wrists,
        LeftHand,
        //Could add fingers here for rings
        Hands,
        RightUpperArm,
        RightLowerArm,
        RightWrist,
        RightHand,
        //Could add fingers here for rings
        Waist,
        Groin,
        LeftUpperLeg,
        UpperLegs,
        LeftKnee,
        Knees,
        LeftLowerLeg,
        LowerLegs,
        LeftFoot,
        Feet,
        RightUpperLeg,
        RightKnee,
        RightLowerLeg,
        RightFoot
    }

I've tried to account for any type of armor you could want to create. If you can think of an area I've missed feel free to let me know.

The Armor class is one example of where I've overridden the Use method. It simply sets the _equipped member if the armor is trying to be used in the correct area of the body.

Your character is probably going to need some weapons in the course of the game so we have a Weapon class that derives from Item:

    public enum WeaponType
    {
        OneHandSword,
        TwoHandSword,
        Staff,
        Mace,
        Bow
    }

    public class Weapon : Item
    {
        //array of Damager objects
        private List<Damager> _damagers;
        private WeaponType _weaponType;

        public void AddDamager(Damager item)
        {
            _damagers.Add(item);
        }

        public void AddDamager(DamageType type, String amount, String affects)
        {
            Damager item = new Damager();

            item.Affects = affects;
            item.DamageAmount = amount;
            item.Type = type;

            _damagers.Add(item);

        }

        protected int GetDamage(Byte damageType)
        {
            String min, max;

            min = _damagers[damageType].DamageAmount.Substring(0, _damagers[damageType].DamageAmount.IndexOf("-"));
            max = _damagers[damageType].DamageAmount.Substring(_damagers[damageType].DamageAmount.IndexOf("-")+1);

            return GlobalFunctions.GetRandomNumber(Convert.ToInt32(min), Convert.ToInt32(max));
        }

        public override bool Use(ref Object target, ref Entity wielder)
        {



            return true;
        }
    }

I've allowed a weapon to be able to affect different types of entities differently by using the _damagers member. The type of damage can be one or more of the following:

    public enum DamageType
    {
        Crushing,
        Piercing,
        Slashing,
        Fire,
        Water,
        Magical,
        Disease,
        Poison
    }

If you want to create a Dagger of Troll Vanquishing, you could add a damager with the Affects member set to "Troll" and the Type member set to Poison or Magic and, assuming you have Entity objects in your game with the name "Troll" you can have the dagger cause damage to them even if they resist any normal damage. Every weapon will have at least one damager item in the list with a Type of Crushing, Piercing, or Slashing to represent the normal damage of that type of weapon. Add a Fire damager to the Dagger of Troll Vanquishing and stack the possible damage that can be done. A Water Sprite creature would probably have a weakness to fire based attacks so a Fire type damager would do more than normal damage and probably couldn't be resisted.

Another item type we can have is the ever-present treasure chest. This one is a little more complicated than most because of all the options that can exist - does it require a key to open, is it locked; if so, how hard would it be to pick the lock, is it trapped; if so, what type of trap is it and how difficult is it to disarm, what items does it contain, etc.? Here's a first cut of the Chest class:

    class Chest : Item
    {
        private bool _locked;

        //tag property of the key item required to open the lock, 
        //set to "" if a generic key item will open the lock
        private string _keyRequired;   

        private bool _open;

        private bool _randomlyGenerate;
        private int _randomType;
        private int _maxValue;

        private bool _trapped;
        private TrapType _trapType;
        private Difficulty _trapLevel;
        private int _damage;

        private List<Item> _items;

        public bool Open
        {
            get { return _open; }
            set 
            { 
                _open = value; 
                if (_open)
                    _locked = false; 
            }
        }

        public override bool Use(ref object target, ref Entity wielder)
        {
            //if the chest is already open return
            if (_open)
                return true;

            //target in this case is null, since the chest is the target
            //wielder is the entity trying to open the chest
            //call PickLock if the chest is locked
            if (_locked)
            {
                if (!wielder.HasItemByTag(_keyRequired))
                    return false;

                _open = true;
            }

            return true;
        }

        public bool PickLock(ref Entity entity)
        {
            //function should never be called for an unlocked chest but just in case...
            if (_locked)
            {
                if (entity.HasSkillByID(_skillRequired))
                {
                    Object chest = (Object)this;

                    return entity.UseSkill(ref chest, _skillRequired, _trapLevel);

                }
                else
                    return false;
            }

            return true;
        }

        public List<Item> GetItems()
        {
            if (_randomlyGenerate)
            {
                int value = 0;
                Item item = null;

                do
                {
                    //get a random item type


                    //get a random item of that type


                    //add the value of that item to the value of the items in the list
                    value += item.Cost;

                }
                while (value < _maxValue);

                return _items;
            }
            else
            {
                if (!(_items == null))
                    return _items;
                else
                    throw (new Exception("Invalid items list"));
            }
        }
    }

There's a lot of other item types that we can create - potions, scrolls, wands, etc. but this will do for now. Hopefully this will guide you in a good direction for the Item system for your RPG. We'll probably update and possibly change some things as we go along. I know that's not an ideal way to do development, but we'll get there. :)

I think for the next post we'll cover the magic system I'm currently using. After that maybe quests and conversation, then we'll tie everything together in our Entity class. From there it's a short step to actually throwing all this stuff into some kind of game. I'm just as anxious to get there as hopefully everyone else is, so stay tuned.

XNA GS 2.0 Available

Thu, 13 Dec 2007 18:42:49 GMT

So you've been living under a rock or just escaped your kidnappers and haven't heard that XNA Game Studio 2.0 was released this morning. This is your wake up call to go here and download it and get started making those multiplayer games you've always wanted to make. Let me know when you make them so I can play too. :)