Legend of the Rune Lords is Now Available on XBLIG!

Legend of the Rune Lords Box Art (Official)

Check out the official Xbox Marketplace entry below:
http://marketplace.xbox.com/en-US/games/media/66acd000-77fe-1000-9115-d8025855054d

Legend of the Rune Lords is in Peer Review for XBLIG

My first XBLIG (Xbox Live Indie Games) game is up for peer review on the XNA Creator’s Club! Once it passes peer review, “Legend of the Rune Lords” will be available for download from the Indie Games section of Xbox Live on the Xbox 360.

“Legend of the Rune Lords” is a short RPG I put together for the Dream.Build.Play Old Spice competition. You can see a video of my entry here. I have since de-spiced the game and submitted it for normal release on XBLIG.

If you have a premium Creator’s Club account, you can check the game out (and play it!) here.

For those without Creator’s Club accounts, you can see the box art and screenshots below:
Legend of the Rune Lords Box Art
Legend of the Rune Lords Screenshot
Legend of the Rune Lords Screenshot
Legend of the Rune Lords Screenshot
Legend of the Rune Lords Screenshot

Programming Tips: Organize Long Functions

Conventional wisdom and a lot of research on programming practices generally agree that functions that are short enough not to need to be scrolled are easier to read and less prone to error. Of course, in practice, it’s more often than not that the typical programmer finds themselves writing functions often several pages in length.

At times like those, it’s crucial to take the time out to reorganize and refactor such functions. The long-term benefits in code organization and readability are almost always worth it.

So, dear programmer, when you’re looking over your most recent changes and you find yourself having to scroll down (or, even worse, right!) more than once, take some time out and consider: How can I organize these functions to make them easier to understand? Is this function doing more than it was originally designed to do? Can I split this very large function into distinct sub-parts?

Read the rest of this entry »

Programming Tips: Assign Properly Typed Literals

Do you know the difference between the following two statements?

float myVal = 1.0;
float myVal = 1.0f;

If your best answer is: “There’s an ‘f’ after the 1.0,” then this tip is for you.

Read the rest of this entry »

Burger Time: That Which Should Not Be

In celebration of the release of Windows 7, Burger King has released the following monstrosity in Japan:

Big Whopper

A 7-patty Whopper for 777 yen. God help us.

Target Engaged!

Engagement

Engagement

Engagement

Programming Tips: Make your Booleans Readable

The boolean variable is one of the simplest programming constructs in the programmer’s toolbox. Just two values: true or false. Throw it in an IF statement to execute one set of code in favor of another. Of course, things never seem to stay so simple once multiple conditions begin to overlap and create complicated webs of execution. There are techniques, however, to keep boolean logic as easy-to-read as possible.

Use Implicit Comparisons
Implicit boolean comparisons, i.e. not using explicit comparisons to the values true and false is a simple technique for increasing readability. This compact form of writing boolean comparisons not only saves a tiny bit of time when writing boolean comparisons, it also makes such logic read more like natural English.

Read the rest of this entry »

Programming Tips: Take a Walk

This is a simple tip that is important for programmers both novice and experienced:

When you run into a programming problem you just can’t seem to solve, take a walk.

Indeed, a major difference between experienced and novice programmers is often how much time they spend attacking a problem before they make the crucial decision to step away from their desk. Often, the worst thing you can do when you’ve run out of ideas is to simply stay at your desk, staring at your screen, hacking away at the same problem. The resulting loop of tweak-recompile-fail-repeat behavior almost becomes like some sort of programming slot machine which wholly invalidates the point of hiring ostensibly intelligent human beings to be programmers.

If you find yourself falling into the tweak-and-recompile loop, it’s time to stop yourself and change your approach. Take a short walk. Break out the old paper and pen. Redefine the problem. Maybe the best solution is a completely different approach than the one you were trying to implement.

One of the most important skills of the experienced programmer is knowing when not to code.

Programming Tips: Const Correctness

Const correctness, the disciplined use of const modifiers when declaring variables and functions, is a practice that most experienced programmers would tell you is a good idea. However, const correctness often ends up being a technique that many programmers never actually use, even when they know they should. The is due in a large part to the rather all-or-nothing nature of const correctness. Once you have non-const correct functions floating around your project, it becomes harder to have them interact with const correct code without degrading the const correctness of that code.

Writing const correct code basically boils down to using const declarations for variables and parameters you never expect to change and for member functions that you expect to never modify their own class data.

Read the rest of this entry »

Programming Tips: Know your UML Class Diagram Relationships

The various types of relationships used between classes in UML class diagrams represent many of the ways classes and other objects can interact in actual code. As such, having a working knowledge of these relationships and the kind of source code they can represent can be extremely useful. When you figure out what sort of UML relationship best represents the way two classes interact, you answer several crucial questions (Is class A a base class for class B or should class A hold an instance of class B? What is the lifetime of the classes involved? Are these classes shared? ) that can dictate just what sort of code you should be writing.

Here is a quick cheat sheet of the relationships I use most often and the sort of code I end up deriving from them:

GENERALIZATION
The classic “is-a” relationship of class inheritance.
UML Generalization

class A : public class B
{
};

Read the rest of this entry »

  • Language

  • Sponsored Links

  • Rob's Portfolio

    Games Writing Contributions