Nuclex

I have updated my input library to a level where I think I can release it into the Nuclex Framework now. The design was tailored to make the input manager mockable (replaceable with a dummy object for unit testing), but the effort of mocking the entire input manager (versus just one input device) on an ad hoc basis was a bit too high (or too unreadable when using a dynamic mock object library).

So the final revision has mocked input devices and a matching input manager built in:

I've spent some time thinking about how input is handled by my GUI library. One issue I didn't cover in its initial design is that people might want to use the GUI library at the same time as their game is running (think of a command palette in a strategy game). I've already got some requests on the CodePlex forums (How to determine if a screen-position (i.e. mouseclick) is on any gui-control ? and Unfocusing from GUI) and it's about time I did something about this.

In the old design, an IInputReceiver was fed by one of two classes: one was the XnaInputCapturer which relied completely on XNA's input device classes (Keyboard, Mouse, GamePad) to track the status of any input devices, the other was the WindowInputCapturer which intercepted incoming window message for XNA's main window to obtain the status of input devices:

This wasn't even nearly an ideal solution because now I would have to copy & paste the game pad polling code from the XnaInputCapturer to the WindowInputCapturer if I wanted game pad input on Windows. The new design should fix this, but still follow the concept of routing all input through a single interface (IInputReceiver) to allow users to easily attach the GUI to their own input handling code.

...that my artillery turret could have some issues with its scale!

XNA provides a neat little system for you to organize your game's different parts in: GameComponents. You can use them to modularize your game's subsystems, eg. have a GuiComponent, PhysicsComponent, SceneGraphComponent etc. so you avoid having all that code in your Game class, or can use them for your actual game objects in smaller games.

However, the GameComponent and DrawableGameComponent classes provided by XNA force you to reference the Game class. This is unfortunate if you want to use those components in a WinForms-based XNA application and gets in the way when you try to write unit tests for your components because now you have to create a dummy Game instance as well (and better hope that component won't go shopping for references in the Game's Components and Services collections as well).

Luckily, the GameComponentCollection used by XNA to store your components manages IGameComponents and updating/drawing are based on the IUpdateable and IDrawable interfaces alone, so there's nothing preventing you from rolling your own components without referencing the Game class.

First, let me say sorry if I seemed to be absent for the past months. I was quite burned out and didn't want to do much with computers during that time :)

My "XNA Game Architecture" series was left hanging, and right when it got interesting, too. I'll try to find the time to continue where I left off. For now, here's a small appetizer:

Some weeks ago, Synapse Gaming offered their SunBurn Lighting and Rendering Engine for half the price. This was to good an offer to pass and so I now find myself being able to do much better lighting effects than I had ever hoped to achieve in my game.

The first thing I did was, of course, to adapt SunBurn to Ninject, a very tidy dependency injector that works on the XBox 360 and even on Windows Phone 7, into the SunBurn example application. This article gives a short overview about the overall structure and provides you with an example application if you want to give Ninject a try yourself.

Whenever I needed a screenshot of some application for this website, I used an image editor to cut out the window's drop shadow, generated an alpha channel from its luminance, added that as a layer behind the actual application window and saved the entire thing again.

Today I wrote a small utility to automate this process for me: AeroCapture. Pressing the "Print Screen" key will take a screenshot of the active window, and save it as a .png in the My Pictures directory, retaining the window's drop shadow in the image's alpha channel.

You can download it here: AeroCapture.7z (C# source code included)

This got me thinking. Somehow, whenever I have the choice between...

• spending 2 minutes doing a repetitive task that I've done a few dozen times before already (like fixing up the screenshot for my website)
• or spending 4 hours to automate the task

...I always choose the 2 minutes approach. I can continue working on what I was planning to do and I don't have as many utilities to maintain.

What do you do in this situation?

Two weeks ago, Microsoft released Visual Studio 2010 and with it, .NET 4.0.

I'm very excited about .NET 4.0 because this is the first standalone release of .NET since 2.0 came out, meaning that it doesn't bundle any of the older runtimes. As you may know, .NET 3.5 is actually just .NET 2.0 with some more assemblies - all the magic required for LINQ, extension methods and lambda expressions happens in the compiler.

The new Visual Studio UI also looks very nice and the darker background puts the actual work (the code) into focus. But there have been some changes like the apparent removal of the Debug/Release combo in the toolbar and the ability to add your own External Tools to the Tools menu in the Express Editions (don't worry, both are still there, I explain how to enable them a bit down in this article).

So I decided to write a small heads-up on why I think Visual Studio 2010 and .NET 4.0 are cool and how to get back your favorite options if you're already used to the Visual Studio 2008 Express Editions.

Welcome to day 2 of the XNA Game Architecture series!

I have thought hard about whether I should just assume a certain level of object oriented programming knowledge in this series. People picking up these articles likely already have some knowledge about objects and design, so I settled on a quick run-over of the principles that hopefully won't bore the seasoned developers and provide a good reference for people just starting out!

If you already know all this, feel free to skip ahead until it becomes interesting again or to the next chapter !

Welcome to day 1 of the XNA Game Architecture series! We're about to create a small 3D Shoot 'em Up using the principles of modern software architecture.

If you missed the introduction, this series is about the architecture of games. Instead of focusing on a single concept, we'll be focusing at how it all comes together and how you can keep your game's code manageable and clean. You'll be looking over my shoulder as I write a small game and explain why I do things one way and not the other .

Today, I will start the project by creating a development tree that contains the actual XNA project and some third-party libraries I'm going to use within the game. Normally, I would add those libraries as I go, but I've got a pretty clear idea for this project and it will be easier for you because I can just package them all in a handy zip archive which you'll find at the end of this article.

When I release components, example code or even just helper classes, I often tout 100% test coverage as a feature. Which (as I probably also state often enough :P), means that my unit tests execute 100% of all lines in the source code. But what advantage does this actually bring to a developer, and, just as interesting, what does having complete test coverage not mean?

For people practicing true TDD (test first -> red, green, refactor), 100% coverage is nothing unusual, though even they may decide to not write tests for all invalid inputs possible: if a piece of code satisfies all the tests and the tests cover everything the code should do, it's enough. If you're building a library on the other side, the use case of a customer providing invalid inputs will be a valid concern worthy of a test.

I, however, am currently adding unit tests to an existing code base and I decided to go for 100% test coverage. In this short article, I will explain why I see complete test coverage as a worthwhile goal, what effect going for that level of test coverage has on a project and what it says about the code.