I’ve been so quiet for a reason…
Last 2 months I’ve been looking for a new position in the games industry, and finally got one in Scotland-Dundee.

You can download the new version here :
Download lastest czPlayer demo

However it lacks some features:

• The quick buffer size is hard-coded in the class, instead of template-based.
• When reverting to heap based, it doesn’t use any mechanisms to minimize allocations/ deallocations, like for example (Reference counting and Copy-On-Write)

Since I’m starting a new hobby project (my own small game engine), to test ideas and learn some new things, the first thing I’m coding is my own String class, which I’m also using as an exercise to test some more advanced templates stuff, instead of the classical “container of values of type T”.

So… about my String class.

Features:

• Completely template based, using policies like described in the book Modern C++. This allows for a great deal of customization.
• Using policies, it supports multiple types of string storage. Currently it support 2 storage types:
  • Heap based with reference counting and Copy-On-Write, to delay memory allocations/deallocations as much as possible.
  • Quick buffer based (like CEGUI), but with fallback to Heap based like described above when the data doesn’t fit the quick buffer. Also, the quick buffer size itself is a template parameter, so we set the size based on the use we have in mind.
• We can mix strings declared with different policies (the ones provided), and internally it will still try to minimize memory allocations/deallocations, by using reference counting and Copy-On-Write when possible.
• We can specify our own Allocator for heap based strings
• Basic methods for manipulations. I need to implement a lot more.

Missing/Todo:

• More methods for manipulations (make it more compatible with the std::string)
• Unicode support. I’ve laid down the bases for that, but currently only works with char type

When coding it, I’ve used CppUnite2 for the tests. See this link for more information (Games from Within: CppUnitLite2 1.1).

I haven’t used this String class in a complex product yet, only in the tests during development, so I can’t talk about performance or bugs yet.

If you want to check it out, download it below:

NOTE: I’ve only tested it with Visual Studio 2005 (with sp1), so the provided project files are for that same compiler.

czString Download

If so, go ahead, download the new version and give it a try:
Download lastest czPlayer demo.

class MODModule
{
// ...
bool m_loaded;
bool m_playing;
bool m_paused;
bool m_reachedEnd;
};

What’s the problem with this approach ?
Let’s see…
Suppose I want to call methods on the MOD object (e.g: Pause(), Resume(), etc)
I need to make some checks in each method.

To pause…

if (!m_loaded || m_playing || m_paused)
return SOME_ERROR;
m_pause = true;
// ... do pause stuff

Then to resume…

if (!m_loaded || !m_paused)
return SOME_ERROR;
m_paused = false;
// ... do resume stuff

When the MOD finishes playing, I needed something like this…

// ... some code that checks for end
m_reachedEnd = true;
//ups... How about m_playing, m_paused?
//We need to change their values, so we don't break code elsewhere
m_playing = false;
m_pause = false;

And similar things when playing, stopping, etc.
See the problems?

• We need checks for multiples variables
• We need to make sure the variables have valid values in relation to each other
• What if we want to add an extra state? For example, “bool m_fading”. We would need to examine a lot of code to check how the other variables are used, and hardwire this new one somewhere. Every time you need to add an extra variable, you’ll need to check more and more code to make sure everything is ok.

Now look at the meaning of the variables. They are mostly mutually exclusive.

• If it’s playing, it can’t be paused and hasn’t reached the end.
• If it’s paused, it’s not playing, and hasn’t reached the end yet.
• … and so on….

The more data members a class has, the harder it gets to keep the object in a valid state, so, the less data to manage, the better. Less maintenance and less bugs.

One technique I use a lot when trying to simplify code is to look at it with state diagrams whenever possible.
Here it is what happens (kind of) with instances of the MODModule class:

I can easily translate it to code with enums.

enum MODState
{
MOD_STATE_NOT_LOADED,
MOD_STATE_STOPPED,
MOD_STATE_PLAYING,
MOD_STATE_PAUSED,
MOD_STATE_REACHED_END
};

class MODModule
{
// ...
MODState m_state; // Now we have only one variable
};

This approach is a lot easier to maintain, and less error prone.
Now the code in most functions become something like this:

To play…

if (m_state!=MOD_STATE_STOPPED)
return SOME_ERROR;
m_state = MOD_STATE_PLAYING;
// ... do play stuff

To pause…

if (m_state!=MOD_STATE_PLAYING)
return SOME_ERROR;
m_state = MOD_STATE_PAUSED;
// ... do pause stuff

To resume…

if (m_state!=MOD_STATE_PAUSED)
return SOME_ERROR;
m_state = MOD_STATE_PLAYING;
// ... do resume stuff

To stop…

// We cannot stop if it's not even loaded yet, or it's already stopped
if (m_state==MOD_STATE_NOT_LOADED || m_state==MOD_STATE_STOPPED)
return SOME_ERROR;
m_state = MOD_STATE_STOPPED;
// ... do stop stuff

The code may look similar, but it’s a lot less error prone, easier to follow and maintain.
Looking at the State Diagram, I could easily squeeze in a “Fading” state and understand the conditions to enter or leave that state.

As a bonus, using enums will enforce more rules and help you out with errors the compiler might catch. Always prefer compile-time errors over run-time errors.

Download lastest czPlayer demo.

There are still things to improve and features to add, but a client is already using it as-is, so I chose to release it right after some documentation updates and small fixes/improvements. I have a huge list of things I want to improve, but I know myself. I’m a perfectionist, and as a result I’m never really happy with my code. So if I just kept on this cycle, I would never release it !
Better release something and work from there, than to be stuck improving and never release it.

As some of you might know already. czPlayer it’s a multiplatform sound system for games. Right now it supports Windows, Windows Mobile (PocketPC/Smartphone), Symbian, and PalmOS (full ARM with prc-tools). The formats supported so far are MOD and IT for music, and WAV for sound. The next ones to come are probably ADPCM and Ogg Vorbis, but that depends on the needs of my clients, and the priority of others things left to do.

If you’re interested in a commercial license, or using it in freeware, check it out: czPlayer Sound System

I have already tried a few.

- BOUML

- UML Pad

- Rational Rose . Only used some years ago, and never liked it.

- Visual Paradigm for UML

So far, and by far… the one I like the most is Visual Paradigm for UML . The first time I looked at it, it scared me a little, with all the buttons, and functionality. But its quite a complete package. Great documentation, somewhat clutter free windows (considering the amount of functionality), and an amazing intuitive interface, that can get you going in no time.

For example, in a State Machine Diagram, just place the initial state, and you can do most stuff from there without ever leaving the design area, simply pulling the other states from that one. Mouse gestures really help with productivity. First time I discovered those, it reminded me of “Black and White”. Depending on the kind of diagram we are working on, we’ll have some specific gestures available. For example, in a Class Diagram, we have a gestures to create classes, packages, add operations, attributes, and so on.

Most gestures are easy to remember, but to make things even easier, we even have a fast lookup window:

That menu option will show you the available mouse gestures for each diagram type, like this:

Thumbs up for Visual Paradigm. Really intuitive interface, that can really boost productivity.

Of course it has a lot more features, but the productivity boost was the most interesting to me.

If you’re looking for a good UML tool, give it a try. Maybe you’ll like it too. You can always use the Community Edition for a while, which is free for non-commercial use.

That was one in a million, I think. hehe

There are still some things to improve, features to add, and more refactoring to do, but its already working on Windows, Windows Mobile, Symbian, and Palm, which are my targeted platforms at the moment, so things should be easier now.

If anyone is interested, I’ll be licensing czPlayer in a very near future.

That means I’m available for any other contracts, if anyone reads this.
Meanwhile, I’m working on my own projects, which should get me some income, particularly with BitRabbit.

Also, soon I’ll start posting some game development articles. I already have some topics planned to start with, like:

- Game states
- GUI
- Sound
- Networking (maybe)

Its just some ideas I want to start with. Graphics is out of that list for a while.
I will most probably concentrate on mundane tasks I encountered and learned during the time I worked on Galactic Melee. Those things we don’t think about when we first start a game, but eventually we’ll get to it, like how to manage game states (menu, gameplay, credits, etc), or how to plan the code for a UI screen, which is in fact easy, but for a non-trivial UI screen, you’ll find yourself complicating the code a lot whenever you want to add more functionality.For that, planning with state-diagrams and implementing it with that approach too, made things a lot easier for me.

Anyway, as soon as I start posting those articles, if they are of any interest to you, you can buy me a coffee (read __donation__). You should see a link on the sidebar for that.