Friday, November 21, 2014

Mecromage November update

The november Mecromage update is posted, detailing more main character details. BannerUpdateNov

Tuesday, October 14, 2014

Mecromage monthly updates.

A few months ago we started posting Mecromage developer diaries. The latest post details some main character work. Here it is!

Sunday, August 31, 2014

New Mecromage Track - Blade Hugger

Here's another track from Mecromage. It's called Blade Hugger. As we draw closer to finishing the game, we'll continue to make monthly update posts at the game's site in a this-is-how-we're-making-the-sausage style, placeholder art included! Take care.

Monday, November 4, 2013

New track, "Krush Kontrol"

Krush Kontrol is a Castlevania: Rondo of Blood track I did for the Vampire Variations II project. It's a remix of "Former Room," a spooky chiptuney song that lets you know the boss is near.

Friday, October 25, 2013

"Mecromage"

Pleased to share more music! The game I'm working on is called Mecromage. It's heavily inspired by classic adventure platformers, and more info will be forthcoming. In the meantime, here's a music track from the game, To the Death

Monday, August 6, 2012

Asset management–roll ‘em up

An “asset” is a relatively large chunk of data used by a game. Examples include sound effects, textures, meshes, music and movies. While it’s important to have a runtime resource management system to avoid duplicate assets residing in memory, it’s also important to have a way to track runtime assets during development. Games tend to have a lot of assets.

One way to ease asset tracking is to reduce the number of assets by rolling some up together. In a 3D game, it’s often necessary to keep individual texture assets separate as they are reused across different meshes. In a 3D game, textures often describe surface materials but rarely do they describe object contours (that’s left to mesh geometry).

In a 2D game, however, textures usually define both surface material *and* contour, and as such there’s less likelihood that textures will be reused across different meshes. One example is sprite sheets. Some characters are defined by sprite sheets that span multiple textures. There is never going to be a case where these sprite-sheet textures have meaning outside the shape/material they represent. As a result, our runtime asset representing the visual characteristics of a character is a single asset: an “animation” asset. While we can “nest” animations, the exposed assets (file-wise) never drop below “animation asset” level (for example, the runtime files visually representing a guy holding a sword are a “guy” and “sword” animation asset). Animation data, mesh data and sprite-sheet textures are generated/rolled into one asset on export from our animation tool.

Similarly, larger backgrounds may span multiple textures at runtime, and thus there is no reason for the runtime to need these textures to be floating around separately. Thus, just like character assets, a background asset accumulates multiple textures on background export and all reside in a single asset file.

Reducing the asset count by rolling up “atomic” asset groups is good practice, both for runtime and for tools.

Tuesday, July 17, 2012

Don’t hide the flow!

Design patterns have their place in C++. Don’t abuse them! Let’s look at one of the most common design patterns used in games- the “strategy” pattern. Games often define an “Entity” base class which specifies an interface that all game objects adhere to. Game objects derive from this Entity class and, via polymorphism,  exhibit different behavior without the underlying engine having to know anything other than the base Entity interface.

It’s tempting to stuff as much common behavior in the base class as possible, and, when that becomes too bloated, create more classes in an inheritance scheme between the base and the final child (for example Entity<---WalkingEntity<---Human).

Don’t get in the habit of stuffing tons of behavior towards base classes! As the behavior is spread out amongst more classes, it’s very hard to track the program flow, and more difficult to anticipate the effects of changing something.

What’s an alternative way to get code reuse? You’ll often hear “use composition” floated. Instead of a deep inheritance chain, you get your reuse via attributes- in the case above, Human would derive from Entity, and then have, as an attribute, an instance of a Walking behavior class. Now, the flow can be more easily tracked at the Human level…there’s no hide and seek with virtual overrides. Components are nice because unintended side effects are low, and program flow can be traced at the Human level more easily.

That being said, in practice I use both. There is some functionality that is *so* widespread and *so* predictable and *so* self-contained that stuffing it in an intermediate class in an inheritance chain makes sense. This is more a walling-off intent- I know that 100% of the children that derive from that class will not override those methods.

Finally, I’ve found a place where neither inheritance nor composition does the trick- AI. I use state machines for AI, and I’ve found two annoyances. One, a lot of boiler-plate code is needed. Two, it’s difficult to get reuse out of state machines. To solve the first problem I rely on macros (yes, #defines, to a hilarious extent- whole state classes in a single macro, and hooking up the states to their owner’s callbacks). The second problem, reuse in state machines, is interesting. There doesn’t seem to be a good solution without destroying the flow. For reuse of actual behavior, I mostly fall back on functional programming. I go oldschool and create functions with no side effects…they operate solely on data passed to them by the AI state execution, and they live independently of everything else. This way, to decipher an AI state’s behavior I at most have to remind myself what those functions do.