Welcome to Null City Software
Tasty, tasty software.
Null City Logo Home Kitae Breeze Products Login Forums Contact Us About Us
By NullCityAdmin on 27th Mar 2012 @ 06:01PM
It's finally complete, last night I put the finishing touches on the Kitae State Machine editor. I actually had the idea for this a while back, and built all the base classes and tested them, but wanted to finish the IK editor for Skeletal Actors before moving on to the editor for State Machines.

Kitae's state machines mean that at code-time you do not need to worry about what actions lead to what states. For example, player on a ladder would usually not be able to either jump or run left or right. He would likely only be able to climb up, down and drop. This kind of switch from state to state is handled entirely by the state machine based on the actions you feed in and the transitions you build to link one state to another. The whole point of the StateMachine classes are to remove large nested switch statements from your main loop. These are typically difficult to follow, hard to debug at runtime, and a pain to maintain. Anyone who has written any game before will be all too familiar with the spaghetti code that often plagues character update methods. Hopefully StateMachines will allow you to take control of this problem much more easily. Update loops can typically be written as a single switch state against the current state of the StateMachine, and StateMachines are much easier to visually debug in the Game Editor.

StateMachines can be used anywhere you would normally manage state, e.g. character Update methods, managing menu selection, etc.

I'm not 100% sure I've covered everything people will want to do with state machines, but for now, they are still very useful.
NOT dead!

I've had more time recently to concentrate on Kitae again, and the upshot is... Kitae now has fully working 2D IK Skeletal Actors and animations. Rather than explain all this, I'll let the following video do the explaining:

Skeletal Actors are composite actors made from Sprite Actors, and positioned specifically around a bone structure. You can build new and interesting bone structures easily in the new editor and you are not limited to humanoid figures. The character in the video was built from a few simple renders, and then carefully cut into sprites for each individual bone in the structure. Once you have your sprites, you can build a new actor with ease, it takes only a few minutes to piece the sprites together in a useful structure.

After constructing the skeleton, you can move and rotate the joints along keyframes in the animation editor and build smooth, interpolated animations from very simple keyframes, as demonstrated in the video.

Features / Reasons to use Skeletal Actors:
* Handles the animation and bone structure entirely for you.
* Easily add geometry to parts of the body, and collide against other actors on a per bone basis.
* Easily add new animations to game characters.
* Swap out graphics for parts of the body. Skeletal Actors allow you to switch look/feel (e.g armour).
* Control bone structures via code to animate programatically.
* It's just cool!

This is the product of about 2 months work on and off and has been a fun little addition to Kitae. It was fantastic seeing the animations work for the first time in the game editor. However, getting geometry and flipping working correctly - not as much fun. Hopefully I'll be able to leverage this into a new game at some point soon.

Next up - editor support for State Machines.
Then maybe a release? Who knows. Will try to keep this space more updated.
By NullCityAdmin on 22nd Aug 2011 @ 12:59AM
Nope, Kitae isn't dead, it's just sleeping (a little).
Some of the stuff added recently includes:

- Undo buffer for the Game Editor.
- New extensions library for WinForms, allows you to easily consume Kitae in WinForms controls.
- New SpriteActor rendering mode which allows for tiled sprite rendering (texturing).
- New SpriteActor edge cropping.
- New simple TileMap culling.
- New examples such as the Windows Forms Test shown in the shot below:


Things are progressing with Kitae, just at a very slow pace. Hopefully I'll be able to make clear why this is within the next month or so, and hopefully you'll understand.
By RobHutchinson on 30th Aug 2010 @ 10:54PM
When Breeze was released a lot of the reviews for it were incredibly positive, here are a snapshot of some of the reviews:


I think I only saw one negative review, whereby it was slated for basically being too hard. <-- by design, but point taken. So I've decided to issue a re-release of Breeze to try encourage more people to give it a whirl without sacrificing the original vision for the game. Breeze was always meant to be a difficult game, sometimes even 'rip your hair out'-difficult. But hopefully for those who enjoy a challenge, Breeze gives you a very quick restart and sets you on your way again to give the difficult levels another blast.

This experience isn't for everyone, and for that reason I've tweaked the difficulty settings a bit and a new V1.1 is now in review. V1.1 has a completely new feature: Air-Brakes. This new addition can be activated with the B button on the Xbox controller and will very quickly bring the flower to a grinding halt. This allows you to whip across levels without the fear of having to stop the flower at the other end. To those already hardened to the Breeze experience this may seem like it will make the game too easy. Firstly, it actually doesn't make the game too easy, it's still a challenge but more of a manageable one. Secondly, if you wish to take on the true challenges of Breeze, there is now a 'Hardcore' mode, which is basically the original game. In this new hardcore mode you have no air-brakes on any levels and you will earn a gold cup next to all levels you complete. The new air-brakes mode is now 'Normal' mode and the easy mode has not changed. Also in 'Normal' mode the flower will not be shredded by the fan if the fan is not spinning, so you get a little added protection.

The new version 1.1 will be released hopefully in a few days, or whenever it passes review.

Oh one more thing, there's a hidden bonus stage in Breeze (there's also a few other easter eggs), has anyone found them? I'm betting not. First person to find them gets their name in 'lights'. Here's a hint: the bonus stage is accessed through a level completed in a certain way, somewhere near the 'middle' of the game.
By RobHutchinson on 15th Aug 2010 @ 11:46PM
Breeze has made it through peer review on XBox Live today and can now be found on the Marketplace: http://marketplace.xbox.com/en-GB/games/offers/00000001-0000-4000-8000-0000585505fa. Breeze costs 240 MSP and is available in the Indie Games section of the guide.

I'll do a mini-review round up tomorrow once sites have had a chance to review the game. Hopefully there's some people out there enjoying it now. And if any of you manage to beat the times, or even just the game (it's not easy) then go post on the forums or reply here, because I'd be interested to see who's first (screenshot or it didn't happen).
By RobHutchinson on 15th Aug 2010 @ 11:46PM
I'm pleased to announce that the first Null City game is almost ready!

Introducing Breeze!

Breeze is a single player game written for the XBox and later to be released for the PC. It was written entirely in XNA using the Null City Kitae game engine and features 60 unique levels of flowery twitch action for you to feast upon.

Breeze is light entertainment for persons of any age. Take control of a fan as you strive to gently blow a flower to the goal. Control the flower by proxy across the 60 levels using only the power of wind. Take the flower through all four seasons to reach the goal. Breeze comes with a chilled, lilting soundtrack and an emphasis on the smooth. There's plenty of content to explore with unique and interesting traps and game mechanics.

Teaser Trailer:


The official address for breeze is http://www.breezegame.com and future information will be posted there.
By RobHutchinson on 15th Aug 2010 @ 11:46PM
Breeze has now been submitted for peer review and will hopefully be released sometime in the near future. If you've got access to an XNA Creators Club account for the XBox 360, feel free to download it and review it through the usual channels on the Microsoft XNA website.
By RobHutchinson on 08th Aug 2010 @ 11:45PM
I've just added a feature to Kitae that a few people have been asking for: Actor Base Typing. Kitae produces objects automatically when you run your game, it's part of what it does in terms of editor > code. When your application is run, your modules are loaded and any definitions of actors, scenes, fonts, etc are turned from their binary saved format into game objects through a process of custom serialization. Kitae has had a feature for a while now, whereby you can specify the base type that it should create for Scenes. However this feature was never extended to actors (even though it was requested). Basically it allows you to have your in-editor actors hooked directly to a base class so you can gain internal control over it at runtime. I've added a new example to the Kitae example set which demonstrates this new feature. Here's a video of the feature in action:

The example has a FireFly SpriteActor which has the following class as its base type actor:

namespace Kitae.Example.ActorBaseTypes
    public class FireFly : SpriteActor
        public FireFly() : base()

        public override void Update(KitaeGame game, GameTime gameTime, float distance)
            base.Update(game, gameTime, distance);

            // [snipped] logic for this actor only here...

This allows you to keep your code right next to the actor it is meant for, no more wrapping of actors inside controlling classes. This feature comes with a slight performance penalty if you do use it, as it has to use Activator.CreateInstance when making copies. No access to expression trees on the 360 to speed this up :(.

For the testers, this feature will be in the next release. As soon as I've rebuilt the Tile Map editor the next release will go live.
By RobHutchinson on 26th Jul 2010 @ 08:38PM
Below are a group of screenshots for Breeze.

By RobHutchinson on 26th Jul 2010 @ 08:10PM
:: Breeze 360 Forums
:: Breeze Windows Phone 7 Forums

Null City is pleased to announce Breeze, a new game for the XBox 360. Breeze is now finished and available on Xbox Live Marketplace.

Breeze is light entertainment for persons of any age. Take control of a fan as you strive to gently blow a flower to the goal. Control the flower by proxy across 60 levels using only the power of wind. Take the flower through all four seasons to reach the goal. Breeze comes with a chilled, lilting soundtrack and an emphasis on the smooth. There's plenty of content to explore with unique and interesting traps and game mechanics.

Breeze cost 240 MS Points and is now available on Xbox Live Marketplace
The trial version of Breeze features up to 10 levels of the total 60 levels or 8 minutes of game play whichever comes first.


By RobHutchinson on 13th Jun 2010 @ 01:36AM
I’ve not updated the blog for a while, but it’s not because nothing has been happening - far from it! In fact, Kitae is still being developed full steam, as well along with other projects which I’ll go into in a minute. This new release provided to the testers today contains a bunch of new functionality that I’ve been meaning to add for a while now. You can now toggle visibility of layers on the scene dock, which allows you to build even more complex scenes without having to fight to select the correct actor with the mouse; this can be seen in the shot below.

Kitae now has a simple storage management mechanism, which deals with a large amount of the grunt involved with cross-platform support for storage devices (namely the storage dialog on the 360). Kitae’s main Game class KitaeGame now has a link to a Store object, which allows you to binary serialize simple flat (graph-less) data classes and contains a mini basic value serializer. It will serialize most of the base types (int, float, long, etc) and some of the commonly used types (Rectangle, Vector2, etc) but will not serialize custom data types. This can be used in the following way in Kitae:

game.Store.SaveFlatObject(myData, “filename.dat”);
game.Store.SaveFlatList<T>(myList, “filename.dat”);

I’m willing to bet, most people can get away with this in their XNA games. Of course, you won’t be serializing complex save state data like this. But for arcade games that basically have option data and maybe some highscores or record times, this is all you will need.
If you do need to serialize more complicated data, you can of course simply use the Xml version of the same function:

game.Store.SaveXmlObject(myData, “filename.dat”);

Simple? Hopefully this will speed up the time it takes people to implement data storage for their game cross-platform. As well as these features more bugs are getting squashed and some of the long-standing issues are being addressed.

Additionally, there have been a couple of new examples since I last posted on the blog, one which shows you how to use this new storage class and one that creates emitter based animated sprites.

And finally a side note about the other projects I'm working on related to Kitae:

When I originally started work on Kitae about a year ago, the goal was not to write a saleable product. It was always simply to build an engine that I would feel comfortable building games on top of, and to provide integration in such a way that doing so could be achieved as quickly as possible.

Every, maybe, 2 months or so in the development of Kitae I come up with some new crack-pot idea for a game. I now have about 5 games in the pipelines which are all yet to be finished and they are being written in tandem with Kitae. While I don’t like having 5 unfinished games sitting there, I think this has greatly improved the quality of Kitae, mainly because it constantly introduces me to things I’ve not yet thought about or missing functionality/functionality that needs work in the engine. Probably the best side-effect of this is that I’m continuously using the Game Editor during Kitae’s development. While it’s not perfect yet, so much of the functionality in the editor is there because I’ve been annoyed by some quirk or have needed some specific feature. Upshot is that these games are basically driving the development of Kitae, that and the bugs the testers are finding.
One of these games I’ve been developing is now roughly 75% complete and I’m expecting to complete work on it in the next 2 weeks. Once it’s nearly complete there will be more information available here and I’ll be uploading it to Indie games for peer review. This will most likely be the first finished game written with Kitae.

As always, if you still want to be part of the beta test, sign up today, there’s plenty of time to participate.

For more updates, follow NullCity on twitter: http://twitter.com/NullCity.
By RobHutchinson on 12th Apr 2010 @ 12:06AM
Kitae sports a variety of complex scene transitions using pixel shaders. These transitions run at very high speed on reasonably modern hardware and can be invoked with very minimal effort. This allows you to smoothly move from one area of your game to another with ease. Simply create two scenes, for example a main menu and an options menu, and then make a call to StartTransition as shown below.

game.StartTransition(mainMenu, options, new TimeSpan(0, 0, 2), InterpolationMethod.Cubic, new RadialWiggleTransition());

Transitions can be checked and stopped at any point, and the engine will leave your game in a state showing the destination scene. Scenes, layers and actors all still continue to update and render whilst the effect is in operation so animations still show through the transitions.

Supported Transitions

• Banded Swirl
• Blinds
• Blood
• Circle Stretch
• Circle
• Circular Blur
• Cloud
• Crumble
• Disolve
• Drop Fade
• Fade
• Line
• Pixelate In
• Pixelate Out
• Pixelate
• Radial Blur
• Radial Wiggle
• Random Circle
• Ripple
• Rotate Crumble
• Saturate
• Shrink
• Slide In
• Smooth Swirl Grid
• Swirl Grid
• Swirl
• Water
• Wave

All of the above transitions can be seen in the video below:

By RobHutchinson on 11th Apr 2010 @ 11:44PM
I realise it's been a while since I've posted, I've been very busy with various projects, including Kitae. Fear not, much development time has been sunk into Kitae over the last few months and it appears to be coming together very nicely (barring some nasty PC laptop graphics card issues).

Anyway I wanted to share the latest feature of Kitae: Scene Transitions. Kitae now sports 30 unique transitions out-of-the-box. All ready to use with a few lines of code! Thanks to the great work done on the WPF-FX project, I've managed to convert the transition shader effects to XNA and build them as re-usable content into the engine. We've got swirl effects, circle tranistions, disolves, pixelations, saturations, water effects, blur effects, you name it, it's probably there.

Here's a video of the transition example which I'm planning to release with the engine:

Sorry for the poor framerate on the video, YouTube seems to have made a bit of a mess of it. Fear not, it runs at a nice 60FPS solid @ high resolution.
Thanks to Eifion Bedford for the fantastic photos, his work can be found here.
Additional information on Kitae's transitions feature can be found in the Kitae Transitions section.

Alpha Testing
Kitae will be entering Alpha Test phase hopefully in the next week. For anyone that is interested in testing, please read the FAQ.

By RobHutchinson on 09th Apr 2010 @ 06:55PM
Using the Game Editor, you can add sound effects to your modules with ease. Once added to a module, the sound effect can be accessed at run-time and played at will. Additionally, sound effects can automatically be triggered during certain events, such as frame-replay in an animated sprite. This allows you to always play sound effects when your characters perform certain actions. For example, you might want to play a 'punch' sound effect when a fighter take a swing, or a 'scream' sound effect when the main character dies. This reduces the amount of event programming you have to perform.

Video will be supported but not directly handled by Kitae.

By RobHutchinson on 09th Apr 2010 @ 06:54PM
Kitae provides a built-in physics engine that supports rudimentary 2D physics and collision detection. While not as powerful as full physics engines such as Farseer, the built-in physics can be used easily and are sufficient for most games and particle effects.

• Gravity.
• Wind.
• Drag.
• Friction.
• Attractors and repellers.

Other Engines
If you really need that extra physics power, Kitae was built with other engines in mind. It is fairly straightforward to add these engines to your project. Kitae provides access to polygon collision data created in the Game Engine, which can be used to build rigid body geometry in 3D party engines.

By RobHutchinson on 09th Apr 2010 @ 06:44PM
Kitae is a rich, rapid development 2D in 3D game engine for use with the Microsoft XNA platform. Kitae provides a rich application development toolset that supplements Visual Studio or Game Studio Express, allowing you to concentrate on the design and logic of your games without having to worry about the grunt work. Kitae is feature rich, allowing you to create just about any game you can imagine with relative ease. Kitae is not a Game Maker and is not designed to remove programming from the equation. Kitae is a powerful asset management system and middleware engine that facilitates modern 2D game development for both Windows and XBox 360.

Screen Shots

Here are just some of the features that the full release version of the Kitae Framework will support:

• Full 2D in 3D engine. Supporting sprite scale and rotation.
• Built around a powerful module system. Modules house your game assets, level and setup.
• One of Kitae's most powerful features is that it handles the entire lifetime of your graphic assets.
   • Graphics are added to the Game Editor and saved against your modules.
   • Graphic frames are automatically mapped and fitted to larger textures for optimal rendering performance.
   • Frames can be padded and edge doubled automatically to assist with filtering problems inherant to 3D.
   • Game Editor has tools and features for extracting tiles from larger tiled images and screenshots.
   • The Game Editor can be we used to quickly cut and extract sprites from screenshots.
• Modules are created in the Game Editor and can be easily loaded and unloaded at run time.
• UI driven scene management. Build and setup as many scenes as your game needs.
• UI driven layer management. Add as many layers as you require to scenes.
• Layering effects allow you to create breathtaking effects with ease.
• Supports additive, multiplicative, alpha, block, subtractive, inverse, min and max blending modes.
• Supports refraction and other pixel shader effects on a per layer or per scene basis.
   • Post processing effects such as blur, desaturation and convolution can be added with ease.
• Use the simple built-in physics engine or add external engines such as Farseer with ease.
• Global geometric collision detection.
• Actor system makes creating animations, sprites, emitters, text, huds and menu systems a doddle.
   • Tile map actors allow the creation of tile mapped levels.
   • Collision detection against tile maps is performed geometrically.
   • Sprite actors can be used for sprites with no animations, such as decals.
   • Game Editor supports texture splatting through a simple easy to use actor painting mechanism.
   • Animated sprite actors can be used for sprites with frame based animations.
   • EmitterActors provide particle emitter systems for your games.
   • Controller system allows you to easily snap built-in and custom functionality into your actors.
• Custom font rendering mechanism provides fast bitmap font rendering.
• Fonts can be entirely created through an easy to use user interface and wizard.
• Camera system supports multiple cameras for easy split screen and picture-in-picture effects.
• Camera system supports pivoting, scaling, and rotation making it easy to follow the action.
• Engine supports global game speed, allowing you to create stunning slow motion effects easily.
• Automatic handling of resolution independence with separation of screen resolution and render resolution.
• Choose from stunning ~30 transition pixel shader effects to switch smoothly from one scene to another.
+ Many many more features.

Release Information
Kitae is currently under development and will be released in the near future.

For more information about the Kitae feature set, click the links in the Item list on the right.
I've not posted for a while, so I thought I'd drop in a quick update before I snooze. I'm now on to the final hurdle for an alpha release of Kitae. Kitae in it's current form has now been in development for about 9 months maybe? I'm hoping to get a working version 1 release up and out by end of January or February 2010. As such, to keep up with that schedule I am aiming for an private alpha and maybe even a public alpha release for early December.

As of writing, Kitae now has at least the basics of everything I wanted it to have in version 1. Obviously there's a few holes, I've not implemented Bloom yet, although I have spent a lot of time getting the effect system working nicely in the past few weeks, so that's all in place now. However I am noticably reaching my target feature list for V1. Kitae has never intentionally been a composite of other game editors on the market, there is obvious overlap with others, but I've basically built in the feature set that I've always wanted access to for writing 2D games. I've been writing 2D games on and off for about 12 years now, and I consider myself to have a reasonable understanding of the developer needs for such games. However this method of development will undoubtably lead to feature holes. That's fine - I expect that, once V1 is out, I'd like to spend a good portion of my time implementing any user feature requests for stuff I think makes sense, and fits into the framework.

What's left is mostly clean up. I need to spend about a week writing documentation for the Game Editor. But expect documentation to be a bit sparse to start with, I'm only one man, and that's what the forums are for! On top of this, I've written down about 40 minor (ish) issues in my fat black book of features/bugs that I've been scribbling in as I've worked on this project. I'd like to resolve a large amount of those, and those that don't get resolved I'd like to transfer to the nice new Forum bug tracker. But after that I'm going to be putting out a release.

I've not advertised Kitae in any way shape or form, and this site is fairly low traffic at the moment, yet I've still had about 10 test requests via the Members section. I'd like to get a good few more than that before alpha, so if you're interested in testing. Please submit a request.

I've spent most of my time recently getting the effect system up and running. So far you've got easy access to Guassian Blur, Refraction and Saturation pixel effects out of the box. That list will extend to a few others including bloom in V1 or very soon after. Of course you can write your own effects and snap them into your game at runtime. Although the refraction effect is based on that supplied with the XNA examples, so you can quickly and easily create all kinds of sworl and distortion effects at design time by specifying a texture to use for displacement (a default is supplied).

All effects in Kitae are post processing. Which means they do carry an overhead. My own tests, on both the XBox360 and my slightly out of date PC suggest this is fairly negligible on the kind of games you're likely to write in Kitae. However it does mean you can apply them at both the layer and scene level. So they are essentially post layer/scene processing, which gives them a great flexibility. Additionally, you can attach as many effects as you wish to any layer or scene. For example, you could apply both a refraction, 2 x blur and desaturation all at the same time on an individual layer. If you apply no effects, layers are rendered directly, so you don't incur the overhead of rendering to an off-screen buffer.
By RobHutchinson on 29th Sep 2009 @ 08:00PM
I'm currently working quite hard on the particle engine at the moment. So I'm not going to write a lot here today, I just wanted to drop this video on the blog:

This fireworks particle effect was created entirely at design time using the Game Editor. Unfortunately the video codec obscures the nice detail of the effect, but you get the picture. The effect is simply a particle emitter which emits a spark particle. On despawn of the particle, another particle effect is spawned to create the explosion. There is absolutely no user code behind this effect what-so-ever. Nifty! Next I'll put up a blizzard effect.

One more thing, I'm currently re-thinking the pricing stategy for Kitae. Kitae may end up free for development use. More on that soon.

So you can actually see what this is meant to look like before the codec filtered out all the details, here's a piccy:

By RobHutchinson on 23rd Sep 2009 @ 08:14PM
The Game Editor application has a fully integrated particle editor which allows you to build and test complicated and often convoluted particle emitter effects on a design surface, rather than in code. This particle system is incredibly powerful, any kind of actor - be it sprite, animation, text, tile map a can be used as a particle within the system and all particles have the same abilities and functionality as any other actor. This of course means you can perform collision detection and other actions against particles. Each particle has a set of controllers which can assist in giving it additional behavior elements, such as physics. Additionally, controllers are also used to manage the lifetime of particles, attaching a LocationCullController object to a particle will remove the particle when it leaves an area specified by the controller and there are plenty of built-in controllers to choose from.

The engine has no problem producing thousands of particles and is quick enough for extreme real-time effects. The editor can be used to build weather, fire, wind, or even water effects.



By RobHutchinson on 23rd Sep 2009 @ 07:17PM
I've not worked on the engine a great deal recently, as I've been working quite heavily on the game I'm writing with the engine. However, after manually building a lot of the particle effects I wanted to use in the game, I finally knocked that on the head and started working on the main particle building editor for Kitae. I thought I'd share some of the early results. The particle builder is fully integrated into the Game Editor application and allows you to build and test complicated and often convoluted particle emitter effects on a design surface, rather than in code.

The particle system in Kitae is probably not as high performance as others out there, however it is incredibly powerful. Any kind of actor, be it sprite, animation, text, tile map can be used as a particle within the system and all particles have the same abilities and functionality as any other actor. This of course means you can perform collision detection and other actions against particles. Each particle has a set of controllers which can assist in giving it additional behavior elements, such as physics. Additionally, controllers are also used to manage the lifetime of particles, attaching a CameraCullController object to a particle will remove the particle when it leaves the visible camera area. There are plenty of controllers and that's the bit I've not finished yet.

Having said the performance is a bit squiff, the engine has no problem belting out 10s of thousands of particles in tests I've performed myself. It's easily performant enough for most games. You would have no problem building weather, fire, wind, or even some water effects with the system. Hopefully I'll be able to put up a lot more video demonstrations of different effects in the future.

Here's the editor in playback mode.

On my nearly 2 year old PC, the above effect, despite there being thousands of off-screen particles runs at way above 60fps without ever dropping a frame.

This effect is simply two particle types (essentially sprites), one sort of firey smudge, which provides the outer glow, and one thick white fire spark which is the white particles you can see the most of in the image. These are sprayed from the emitter at differing force, scale, direction, etc. All controlled from the editor. So you can play and test the effects as you build. The editor already supports zoom, pan and layer effects so you can look around as you watch and build your particle effect. Here's a video of me doing exactly that in the editor:

This effect was the first thing I've come up with, and did so in about five minutes, so the potential is there already to build some very impressive particle effects. Of course, once you're done with the designer, all you need do is drag and drop the emitter onto your scene and activate it in game, productivity WIN!

One quite important aspect of creating particles with Kitae is the 'spawn rate' - how and when after the emitter is activated should particles begin appearing. Because this is tricky thing to implement yourself and 'spawn one every X milliseconds' is not good enough, I've gone for the most robust approach I could think of - timeline curves! Each emitter either repeats or is one shot. The spawn rate is responsible for deciding when the emitter has completed, and of course you are alerted to this in the form of an event or simply by monitoring the state of the emitter in your game loop.

As you can see, over a set time period, you can adjust the rate at which particles are spawned, allowing you to, for example, launch an arrow every 3 seconds from a trap, or produce a dealy timed flame-thrower effect that the player must avoid. I'm hoping that this along with the diversity of the controller system will allow users to build just about any effect they can think of, and test it without ever having to launch their game.

That's enough jabber for now, I'll put up some more interesting effects once I've gotten a bit further with the editor.
Rob - Null City Admin
Since I've not written much about the engine for a little while I thought I'd drop a quick post on here to demonstrate a few of the advanced features of Kitae and the Kitae Game Editor.

First of all I wanted to demonstrate something I seem to have self-termed "temporal collision detection". Someone please drop me a note if this is a fairly well understood collision detection term, as I can't find mention of it anywhere and I'm not sure where I heard it. Anyway, pretty much any game developer that has written a game will have encountered the problem of objects moving too quickly to detect a collision with a thin or small object. This problem can be particularly annoying with common objects, such as fast moving bullets or particles. Solving the problem can be equally difficult, depending on your objects.

In the above picture, you can see that during the first update frame at time index 0ms the object is to the left of the green wall object. By the time the second update occurs at time index 16ms (60 FPS)  the object has moved quickly from x50,y50 to x200,y100 on the right side of the wall, completely missing the wall as far as the game in concerned. Enter "temporal collision detection". Kitae simply performs multiple collision detections across the line that describes where the object was in the previous frame and where the object is now. The algorithm can be told to either let the collision occur but leave the moving actor alone, or to stop the object from passing through the wall.

Kitae now employs a full cached geometric collision detection system. Every graphic in your game can have an attached geometry set used to perform collisions against other objects. The Game Editor allows you to build these geometry sets quickly and easily for your game assets. Below is a screenshot of the geometry set editor and two groups of vertices that make up the gun and circle sections of the graphic.

Collision detection code can be enabled on a per-actor basis so long as a geometry set has been created for the underlying art asset. These geometry sets are incredibly powerful, as they allow the engine to perform geometrically perfect collision detection. Any sprite based actor with any rotation or scale can be collision detected against any other. As long as the geometry set correctly depicts the shape of the sprite, the collision detection looks very accurate. Additionally, these geometry sets are basically groups of vertices, which means that collision detection results return the exact groups which collided during the detection. An example of where this could be useful might be in a beat'em up. Every frame of a character animation can have a set of geometry with multiple groups. In such a game you might opt to put groups on the "feet", "torso", "head" and "fist" of the character. During a "punch" cycle, the collision detection algorithm would return you the exact body parts that collided, perhaps then you would assign a higher damage factor to a "fist -> head" collision than a "fist -> torso" collision. This is just one example, grouping is useful in just about any game genre.

Geometic collision detection is not quite as accurate as per-pixel detection, however per-pixel detection is difficult to manipulate with objects that can be rotated and scaled, since it basically requires 2d bit-mask arrays. The geometric collisions Kitae uses are generally very quick and return immediately when there's no chance two objects have collided. For further optimisation I may consider using quad trees.

Of course you have full access to the data contained in geometry sets built at design time, so you could for example feed this information into Farseer or other third party physics engine. On that note, I have decided that Farseer will not directly be part of Kitae, but examples will be made available showing you how to utilise Farseer within Kitae.

Right, ok, time for a demonstration. Below is a short video of an example I plan to bundle with the engine:

The darts in this video have a simple rectangular geometry set, and so does the wall, the darts are approximately 100 pixels wide and the wall is approximately 15 pixels. The darts are fired at random velocities in the range of 1...450 pixels per update from the cannon - when the space bar is held. Without temporal collision detection, the faster moving darts would completely miss the wall and pass straight through it. Kitae correctly detects the collisions with the wall irrespective of speed.

To show you how easy this process has been made, here is the relevant collision code used to perform the detection shown in the example video above:

CollisionResult result = actor.CollideTemporal(this.wall, CollisionAction.None);
if (result.Collided)
    // Deactivate the dart.
    actor.Velocity = Vector2.Zero;
    actor.Location = new Vector2(wall.X, actor.Location.Y);

This collision detection can also be applied when detecting sprites against tile maps. This is very useful for arkanoid style games as it provides an easy way to build block grids.

Release date. Still not sure yet. I'm working on Kitae in tandem with a game I've always wanted to develop. I figure there's no way I'm going to release the engine until I've proven it works in a released game. This is also incredibly useful from a user-interface stand point, as I'm feeling the rough clunky bits of the editor and smoothing them out as I go. All good for anyone who ends up using the engine. Kitae should be released somewhere near christmas at current development rate. The particle emitter system and effect system are the only large chunks of the engine that have seen little development at this point. Obviously documentation too :)
I'm very happy to announce the development of Kitae. A new rapid development 2D engine for XNA that enables 2D game developers to build games for both Windows and the XBox 360. The engine is currently under heavy development and will be released within the next 3-4 months.

If you are interested in 2D game development and particularly XNA game develepment. We are looking for beta testers for the Kitae application which will go into beta phase within the next month or so. If you would like to test the application you can submit a request to test over at the also newly introduced Members section of the site.

Check out Kitae over at the the new Kitae Section.

About Kitae
Kitae is a rich, rapid development 2D in 3D game engine for use with the Microsoft XNA platform. Kitae provides a rich application development toolset that suplements Visual Studio or Game Studio Express, allowing you to concentrate on the design and logic of your games without having to worry about the grunt work. Kitae is feature rich, allowing you to create just about any game you can imagine with relative ease. Kitae is not a Game Maker and is not designed to remove programming from the equation. Kitae is a powerful asset management system and middleware engine that facilitates modern 2D game development for both Windows and XBox 360.

Screen Shots

Rob - Null City Admin
By RobHutchinson on 02nd Jul 2009 @ 08:15PM
Hopefully this section will answer any queries you might have about the Kitae product at this stage of development. If you are interested in Kitae and your question was not answered here, drop us a line using the Contact Us form and let us know.


Q. Is the engine 2D or 3D?
A. The engine is "2D in 3D". It is 3D projected into 2D space. Kitae provides 1:1 pixel rendering where no transforms are used and supports 2D transforms for most objects (scale, rotation).

Q. Will the engine ever support true 3D.
A. No. However Kitae has a CustomRenderActor which can be used to render 3D to an actor that can be placed within a scene for custom rendering of 3D. This is particularly useful for Avatars.

Q. Why not?
A. Because we will be concentrating on producing the most powerful, full featured 2D engine out there.

Purchase and Release

Q. When will Kitae be released?
A. When it's ready.

Q. Will Kitae be a free product on release?
A. No, you will need to buy a Kitae licence in order to create games with it.

Q. Will there be a trial version on release?
A. Possibly not as soon as the engine is released, but soon after. The trial version will be limited in some fashion, we've not decided how/where yet. There will also be demonstration projects with binaries as separate downloads for anyone to download and try.

Q. How much will Kitae cost?
A. There is nothing set in stone right now, however, we are looking at a price point of between 50GBP - 80GBP (up to ~120USD) per developer licence for indie developers and ~320GBP (~500USD) for commercial developers.

Q. Will I get all updates for free?
A. All updates for the current Major version you purchase will be free. New Major versions (e.g V1 -> V2) will be charged upgrades at reduced rates.

Q. What payments will you accept?
A. The plan is to use a common online payment provider which will accept all major credit cards.

Beta Testing

Q. Will there be a public beta release?
A. No, not a public beta.

Q. Will there be a private beta release?
A. Yes.

Q. Can I participate in the private beta?
A. At this point the private beta is by request only, please use the Contact Us form to contact us about joining the beta program. Please provide details of your machine specs and reasons for wanting to test Kitae.

Q. What if I already joined the old Beta Program, will I still get my free copy on release?
A. Of course, once Kitae is released, drop us a message via the Contact Us page and we'll activate the product for you. Provided that you participated.
By RobHutchinson on 02nd Jul 2009 @ 08:15PM
Actors are the fundamental building blocks in Kitae. There are currently five different types of actor in the system. Each of the actor types are created as base actors within a module and then 'dropped' onto scenes within the same or other modules for active use.

Sprite Actors are the most primitive actors in the system, and simply display a single graphic on screen. Sprite Actors are very useful for particle effects using emitters, texture splatting and foreground and background objects.

Tile maps contain a single layer of map data which is rendered using a single Graphic. Tile maps can be used to build foregrounds, backgrounds and most importantly, map based levels. Maps contain not only the tile graphic frame data, but also additional information such as miscellaneous flags, colour and x/y flip details.

Text Actors are used to render text through the use of fonts. These are useful for ingame text, huds, menus, options and game instructions amongst other things.

Emitters create new instances of other actors to produce particle effects and generators. The most simple of which is an emitter that generates SpriteActor objects to create a particle fountain effect. However, the EmitterActor can be used for many other tasks. Here are some examples:

• A fire trap that produces damaging fire particles in a sequence.
• An arrow trap that continuously releases poisoned arrows across a scene.
• The flame atop a torch.
• Enemy generators ala the classic game Gauntlet.

Emitters can also be used for smoke effects, explosions, turrets, blood splatter, magic, sparks, volcanoes and many many other game effects. For more information on emitters, see the Particle Effects section.

Animated Sprites are similar to standard Sprites, however, they contain animations. Any actor can be playing any one of it's animations at any time within a scene. Animated Sprite actors can have unlimited animations, based on graphics created in the Game Editor. The Game Edtior provides tools to facilitate the creation of animated sprites from frame images. Animated sprites would usually be used for main characters and enemies, or anything in the world that moves.
By RobHutchinson on 02nd Jul 2009 @ 08:15PM
Scenes are the place where all your game action occurs. Scenes contain any number of layers which in turn contain deep and shallow copies of your base actors. Each of these actors is rendered when a scene is rendered.

Layers are contained within a Scene, and each layer can have different rendering qualities, such as blend mode and pixel shader effects.

Scene trees can be completely managed within the Game Editor and building your game environment couldn't be easier.


By RobHutchinson on 02nd Jul 2009 @ 08:15PM
Kitae furnishes the developer with a complete set of Tile Map creation and manipulation tools. The Game Editor can be used to create TileMapActor objects. These are a single layer of tile map entity which can be either shallow or deep copied onto a layer within a scene. The tile map can then be geometrically collided with and modified at run time.

Multiple tile maps can be edited and built simultaneously, and you can position tile maps over each other in a scene to create multi-layered tile map effects. This way, adding foreground and background as well as parallax effects is made very easy.

Tile Maps are relatively expensive where memory is concerned. Therefore, Kitae supports shallow copying of complex actors. Each actor on a scene can either be a 100% duplication of a base actor or a shallow copy. Shallow copying is currently supported on tile maps and animated sprites. Shallow copied tile maps hook into map data taken from a base tile map but have their own location, rotation, etc information. This allows you to build large complex tile maps and re-use them in multiple places without increasing memory usage by having duplicated map data. Currently Kitae uses approximately 20 bytes per map tile for each tile that does not have any attributes, but provides practically unlimited configurability and flagging options. Each tile can have it's own colour and transparency value, can be flipped either vertically, horizontally or both and can have unlimited key-value attributes which can either be provided at the tile or graphic level.

The Game Editor's tile map editor is essentially a full-featured WYSIWYG 2D game level designer, allowing you to create whole game levels just by painting tiles onto a map surface. The editor supports, fill, line draw, rectangle draw, filled rectangle draw, selection, cut, copy, paste and many other tools.


By RobHutchinson on 02nd Jul 2009 @ 08:15PM
One of the design goals with Kitae was to have the engine completely manage your game resources, so all your graphics, sound, music, level data, etc. All these resources can be added at design time to your project's modules. At its heart Kitae is a complete content management system for games.

A project can have any number of modules and you decide how you want your modules to be arranged. Modules can be loaded and unloaded as whole units during run-time and you can pick the modules you want to be loaded automatically at startup using the Game Editor. This gives you a streamlined way to implement game levels and shared resources. For example, in a platform game you may decide that your main character and all enemies are common resources that are used on all levels of the game. Therefore building these resources into a 'Common' module that is always loaded makes sense. In a platform game, usually you're only dealing with one whole level at a time, or one set of levels (a world) that all use the same resource set. Here it makes sense to have each world or level type have it's own module. That way you can reload levels simply by unloading the module (and therefore all it's resources) and reloading it. This provides you with an extremely simple way of managing your game's life cycle. From the point at which the player enters the game world on the first level, through to the last level of the game, switching scenes and expunging groups of unused assets is simple using Kitae.

Modules are expressed in XML with embedded resources. The modules (.kmo) and the project file (.kpf) are the only files you need to add to your content projects, and even this is handled for you by the Game Editor application that is provided with Kitae. The module files contain information about your graphics, graphic data, scenes, actors, layers, sounds, sound data, etc. All in one nice neat package. These modules are transformed at runtime using the XNA content pipeline into XNB files (one per module), making it even harder for 3rd parties to access or modify your game resources and reducing the number of files you need to provide to end users.

Addional to all this, Kitae provides a very powerful graphics handling feature that can help you improve performance and build more maintainable games. Graphics in Kitae work as 'Sprite Sheets'. A single Graphic object contains many images, which are automatically managed by the framework. So for example, you may have a single Graphic that contains all the frames of animation for your main character. At build time, each image in a Graphic is packed into a single texture which is embedded into your module binary. You have certain options available to you as to how you want that texture to be created, but by and large, this process is handled for you completely automatically.

Graphics cards like to work without being interupted by developers switching textures all the time. Because of this, having all your resources in a single sheet alone can increase performance across the board, particularly in Tile Map rendering processes. Keeping all your tiles together in a single texture and using only that texture to render an entire Tile Map keeps performance high. With a little bit of thought, this is done automatically for you by Kitae.

By RobHutchinson on 02nd Jul 2009 @ 08:15PM
The Kitae Game editor is where you'll spend a lot of your time designing your games. Everything from setting up your sprites, animations and scenes, to creating innovative levels and designs. The Game Editor provides a professional interface that is similar to that of Visual Studio or Game Studio Express, so it will be familar to those who have already written games in XNA.

Here are just some of the main features of the Game Editor.

• Project Manager provides a tree-view of your game assets.
• The Graphic Editor provides a fast, easy way to insert and manage your art assets.
   • Sprite Cutter tool can be used to extract sprites from other images.
   • Tile Cutter tool can be used to extract tiles from uniform tile-mapped images.
• Font Editor provides an interface for building fonts.
• Font Wizard allows you to quickly create Kitae GraphicFonts from True Type fonts and allows you to add effects.
• The Property Grid allows quick and easy editing of all your game objects.
• The Scene Editor allows you to create scenes with layers and actors and position them for first run.
• The Tile Map Editor gives you the power to quickly build game levels and maps.
• Powerful Magnifine Glass tool - helps with pixel perfect positioning.
• Keyboard shortcuts for all major actions.

By RobHutchinson on 02nd Jul 2009 @ 08:15PM
Other than actually running and playing your game, the Game Editor gives you almost complete access to everything in the engine. This allows you to build a large portion of your game using a design interface rather than manually coding everything from scratch.

Here are a few of the additional features not discussed in other sections:

Effects work on a per-layer basis. Each layer can have a range of different effects. Firstly, each layer has the option to render in either filtered or nearest neighbour rendering mode for different qualities. Secondly, layers have a blend mode, which describes how they mix with other layers and scenes. Finally, each layer can render with any number of built-in or custom pixel shader effects such as blur and convolution effects.

Post Processing Effects
Kitae will provide simple interfaces for post processing effects and there will be a number of built-in effects which can be used out of the box. Post processing effects can be applied to create overall screen pixel deformations such as blur, convolution and desaturation.

Controllers are an integral part of the Kitae engine. Controllers are used to 'control' the actions of actor within the system. Each actor can have any number of controllers assigned to it. Controllers can perform just about any action and are called every time the actor needs to update.
Null City Software
Null City is dedicated to developing top quality sofware products for Windows PC, XBox and Windows Phone. We specialise in games and .NET applications & components.