On Wednesday I was given the opportunity to display my work at an exhibition for Teesside School of Computing Students, ExpoTees. I had a fantastic time, and was given some excellent feedback on Steve the Starfish and Teddy Defender. I was shortlisted for an award – and won in the “Games Programming” category, judged by Reflections (An ubisoft studio), at the end of the day.

Myself and other winners in the art and animation categories, with Reflections

We were also fortunate enough to have an area set up for Teddy Defender on a projector, in which people could come and play. This was very exciting, and it was great to have feedback from students and industry professionals.

I also displayed Steve the Starfish on the iPad and Laptop, and was given good feedback for both the iOS and Antix versions of the game.
Here are some of the images from Steve the Starfish, as displayed on the day:

Lighting and occlusion are calculated at the same time, sampling from a noise texture. Directional occlusion is calculated and stored in a gbuffer. A blur pass is then applied twice, once vertically, and once horizontally.

I then calculate my lighting in the final pass and apply the directional occlusion result. This gives a decent effect. The more times I sample, the greater the result. For this example I sample 8 times, with a result of 40FPS and 20.1 MS/Frame on the graphics card.

In the future I need to improve the performance. My next step is to apply bounding volumes during the light pass, to render only the part of the texture which has lighting.

To calculate the performance, I used Direct3D queries. Here is a quick code snippet which could be used within future projects, to help determine how long it takes the graphics card to draw a pass.

void DeferredHUB::beginProfiling()
{
	D3D10_QUERY_DESC desc;
	desc.Query = D3D10_QUERY_TIMESTAMP_DISJOINT;
	desc.MiscFlags = 0;
	device()->CreateQuery(&desc, &m_disjointQuery);

	desc.Query = D3D10_QUERY_TIMESTAMP;
	device()->CreateQuery(&desc, &m_timeStampStartQuery);
	device()->CreateQuery(&desc, &m_timeStampEndQuery);

	m_disjointQuery->Begin();
	m_timeStampStartQuery->End();

	m_queryStarted = true;
	m_queryEnded = false;
}

void DeferredHUB::endProfiling()
{
	m_timeStampEndQuery->End();
	m_disjointQuery->End();

	m_queryEnded = true;
}

void DeferredHUB::render(ID3D10RenderTargetView* target)
{
    if(!m_queryStarted)
	{
		beginProfiling();
	}

	//Draw here.

	if(!m_queryEnded)
	{
		endProfiling();
	}

       D3D10_QUERY_DATA_TIMESTAMP_DISJOINT timestamp;
	HRESULT result = m_disjointQuery->GetData(&timestamp, m_disjointQuery->GetDataSize(),           D3D10_ASYNC_GETDATA_DONOTFLUSH);

        //If the result is ready, then calculate and display the time
	if(result == S_OK)
	{
		UINT64 startTime = 0;
		UINT64 endTime = 0;

		m_timeStampStartQuery->GetData(&startTime, m_timeStampStartQuery->GetDataSize(), 0);
		m_timeStampEndQuery->GetData(&endTime,  m_timeStampEndQuery->GetDataSize(), 0);

		UINT64 delta = endTime - startTime;
		float frequency = static_cast(timestamp.Frequency);
		float time = (delta / frequency) * 1000.0f; //Get the time in MS/Frame

		std::cout <<  "Timestamp: " << time << std::endl;

		m_queryStarted = false;
	}
}

After 6 months of development, Teddy Defender has been approved by the Microsoft Indie Developer community, and released onto the marketplace.

You can buy it now on your XBOX by going to Games -> Downloadable Games -> Indie -> Teddy Defender.
The game costs 80 Microsoft points, but has a free trial if you’d like to play a quick demo.

In the demo you are limited to 8 minutes.
Two enemies (The Spider and Wasp).
One boss (The evil bear).

In the full version you’ll get:
All  four enemies (Bat, Snake, Wasp, Spider)
Two Bosses (Evil bear and Evil plane)
Leaderboards

We’ve worked very hard on this game for the last 6 months, so congratulations to the entire team!
Go play it as soon as possible!

In my free time I’ll be updating the game, incase of any bugs, tweaks to the gameplay, or just general improvements.
If you encounter a bug, please let us know at teddydefender.blogspot.com

On this project I’ve worked on almost  every aspect of the game, programming wise.

I’ve worked on:

• Animations
• Sounds
• Interface
• Particle effects
• Bear movement and Controls
• Quality Assurance
• Threading
• Game states
• Xbox live Guide features
• Core Gameplay and Mechanics
• XML File Reading
• Drawing Graphics to screen and Custom Shaders

Plus many more things. I’ll be posting up some of the code for Teddy Defender at a later date.

Thanks, and enjoy playing!

The gameplay mechanics are based upon two of my favourite iPad games to date – Whale Trail and Temple Run. Both are excellent titles. They are simple games, with high replayability.
The mechanics behind these games seem to take inspiration from old arcade games, in which the game would end when you ran out of lives – and you’d enter your name if your score made it to the leaderboards.

I’ve thoroughly enjoyed these types of games during my time at uni – where I’ve had little time to sit down and play through a huge RPG, or even have a couple rounds on the latest shooter. The idea that I can pick something up and go from start to finish in a couple of minutes is brilliant, and is something we really wanted to achieve when creating Teddy Defender. To create a game which is easy to pick up, but difficult to master.

The goal of Steve the Starfish is easy. Try and build up the highest score possible with only three lives.

Steve can move between three lanes, by using touch controls or the accelerometer, and can shoot by tapping on the screen.
Enemy jellyfish and sea urchins are trying to stop Steve by crashing into him!
The player can fire a star by pressing anywhere on the screen.

At the end of each wave, a boss appears. Once the boss is defeated, the player moves onto the next wave. Each wave gets quicker and quicker.

To add a twist to the gameplay – the player can access a “Weather Bonus” on the main menu when connected to the internet.
The weather information is updated from World Weather Online.

Steve the Starfish is set under the Pacific Ocean – around the ship graveyard of “Bikini Atoll.” Depending on the conditions, a bonus may occur.
For example, if the condition is “Partly Cloudy” – then the sea urchins become orange, and give double the amount of points when hit!
If the condition is “Heavy Rain”, then the Jellyfish boss becomes red – and takes double the damage!
All this information can be seen on the main menu, before loading up the game.

The idea of pervasive gaming that I’m exploring is to take real world information, and apply it to a game situation. There are hundreds of ways I can
use this information to add to Steve the Starfish, and over the next month I’ll be trying to add more features to demonstrate this.

Over the next few weeks I hope to have an almost complete version on each of the three platforms. And by May I hope to have fully polished versions for each platform.
There is still quite a lot of work to go. In the next few days I will be writing a font class to draw custom fonts to the screen, as well as working on the core gameplay.
I will be uploading example code to this post in the next week.

Fortunately it worked just fine, and this is what we showed:

We’ve entered beta, and are testing our project with as many people as possible on the xbox 360. So far we’ve had positive feedback, and we’re currently polishing to ensure that the game is at its best before we release to the marketplace.

Any comments would be great!

In the mean time I’m working with the Antix Development Kit. The ADK allows me to create my project for multiple devices, including mobile phones, for web player, and tablet PCs.
I am very excited about this version of my project and look forward to releasing a demo in browser form later in the year.

In the meantime, here’s some recent screen shots displaying the Phoenix car park. Once I have my scene fully established with control input I will begin working with the weather information, along with a day night cycle. This will affect the car’s data, which you will be able to see in real time. I am writing this with C++ using OpenGL ES 1.1 for now, however I will be experimenting with 2.0 over the next week. 2.0 will give me freedom with GLSL ES and shaders.

Steve the Starfish is a retro style game, influenced by “Galaga” and other arcade classics. You play as Steve, an overly
happy Starfish, fighting various creatures under the sea. In order to end these inconvenient confrontations, Steve must
defeat Ollie the Octopus, who wields a deadly water gun.

The game is scheduled for release (completely free!) in March 2012.

Artwork by Anisa Sanusi.
Music by 8BitFanboy