Reaching New Heights – G.I.A.N.T.S.

Genre: Local Co-Op Puzzle Platformer
Platform: PC
Players: Multiplayer (4 Players Required)
Status: Released

Team: Tiny Sail Games
Role: Programming
Duration: 7 Months

Team Members:
Jack Kuskoff – Programming
Nic Lyness – Design, Project Management
Nic Staracek – Lead Design
Adam Crompton – Design
Caleb Barton – Lead Programmer
Macauley Bell-Maier – Lead Animator
Kerry Ivers – Animation & Modelling
Peter Buck – Animation & Modelling
Ash Ball – Lead Musician
Pritish Choudhary – Splines

Four explorers find themselves dragged across the universe to a mysterious and unknown planet. Their only guide (and the reason they’ve ended up here) is a cute and friendly robot named E.H.U. The four players must work together to navigate this strange new world, and its many puzzles and mysteries. Maybe then they’ll be able to find their way back home once more.

You can get G.I.A.N.T.S right here!


Reaching New Heights – Nothing Of Interest

Genre: Anonymous Business Espionage
Platform: PC
Players: Multiplayer (Up to ~8 players, online only)
Status: In development

Team: Currently Unnamed…
Role: Network Programmer
Duration: ~2 months, so far…

This slideshow requires JavaScript.

Team Members:
Jack Kuskoff – Network & Gameplay Programming, Design
Deon Chique – Lead Design, Project Management
Sam (Hasn’t said his last name to me) – Lead Animator
Rilla Bray – Lead Musician

Contrary to it’s name, Nothing of Interest has plenty of things to keep your attention. Negotiate tense trades, fool and mislead your opponents, lie, betray, be betrayed, shoot guns, throw suitcases, grab disks, find drop-boxes, hide pistols, and don’t forget your ID. How will you prove your financial worth to your faceless corporate overlords?

Once it’s done, you’ll be able to get it here!

The Great Big Blog of Things I Should Get Marks For – Vol 6

So here we are, for the sixth and hopefully final time. It’s the end of the second last trimester of my studies and I need to summarise all the things that I’ve done. And should get marks for. Right, let’s get to it.


A Hard Look At Hardware – Rendering On The NES

Hey reader! You read that title right, today I’m looking at the rendering systems of the Nintendo Entertainment System. It’s an old system, and one I’m not likely to be developing on in the near future, so it’s an understandably and odd choice to be analysing. However, it’s one of the few consoles that not only has a host of hardware information readily available, but also has an architecture simple enough to get a grasp on with relative ease.

Anyway, the core of what I’m going to be looking at today is the rendering processes and limitations of the console, since I don’t have to break down the entire thing. More importantly, I’m going to be looking at some of the ways these impact how one would design a game for the NES. So let’s get to it.


Making A Garbled Mess – On Purpose, For Once

Hello again, reader! I’m back to talk about shaders again. A number of weeks ago I had the pleasure of working with Jack McClenaghan to create a distortion shader and beat-mapper for an outrun themed project he and some others were working on – Synthracer Maxiumum.

The idea behind the game was that players would drive around a track whilst objects in the world around the them distorted to beat of the music. But this wasn’t any distortion, it had to be glitchy and retro, so as to fit with the game’s 80s outrun aesthetic. All this took some doing, but it turned out pretty damn well.


Optimising – Harder, Better, Faster, Stronger

Well hello there, reader. It’s time to talk about optimisation – the process of realising that what you did the first time was terrible and finding a new way that runs a hundred times better. Fortunately, in the particular example I’m about to go through, I’m not optimising my own code, but a program provided to me.

This idea behind this program is that it renders an image of various 3D shapes by using a series of ray traces. For each and every pixel in the window, the program performs a ray trace that returns the colour of that particular pixel, one by one. Considering there are a few thousand pixels involved, this takes a while. By default, the original took 80.157 seconds to render the entire image on my machine. That’s my time to beat.


The Great Big Blog of Things I Should Get Marks For – Vol 5

So, once more we reach the end of another year, and conveniently, the end of another trimester of my studies. As such, it is time for me to take all of the stuff I’ve been working on as of late, and put it into one big mega-post. Brace yourselves…


Feeding The Forgotten – A Game To Remember

A Post-Mortem

Yet again, dear reader, it’s time for me to ramble on about all the things that did and didn’t go well in a project I recently worked on: Feeding The Forgotten. The project ran for  total of 4 weeks, and I was working entirely on programming. Much like the post-mortem for Arms Race, I’ve elected to write a larger more structured post-mortem, rather than the small showcase style ones, to better convey my ideas.


Soar Like An Angle

Hello again, dear reader! I recently had the pleasure of helping out a colleague of mine, Nic Lyness, with his project The Ride – a game about the feeling of sublime freedom experienced when riding a motorbike (it’s a really quick game, I’d highly recommend you give it a try).

Essentially, I came into the project once everything was done and dusted to convert the controls to work with a gamepad controller. Unfortunately, there was one significant issue that I simply wasn’t able to fix in the time I had, so the current version doesn’t actually have any of my code in it. That’s not going to stop me from rambling about it though.

Just making basic first person controls work on a controller is a relatively simple task, and everything was fine and dandy up until I needed to make the bike lean with the player’s joystick, and right itself when it was released. This is where things began to get complex, and that’s what I’m going to be talking about here.


Throwing Shader

Hey, dear reader! It’s time again for me to ramble on about some programming stuff I did lately and how it all works. This time I’m going to be talking about shaders, or more specifically, a shader I created for Feeding The Forgotten (a game about putting in the effort to help the less fortunate members of our society, you should check it out).


The Complete Shader

The idea behind this shader was that it would outline an object, but also highlight that object through walls and other objects, so it’s always visible. This is why the gentleman in the image above seemingly has no eyes, as they are different objects, so the back of his skull is being highlighted over the top of them. Neat, isn’t it?

So how did I make all this happen?