Trying something new

I’ve come to the end of my university degree and after final submissions and months of work I need a little bit of a break from writing code and have put my current major project on hold for a bit.

I do however want to keep busy and work on a project.
I had considered doing something little in PICO-8, however I thought maybe something a little different might be a better choice.

I finally decided on a card game!

Now I didn’t want to dive into anything like magic the gathering or even netrunner where you have to collect cards and build different decks, I wanted a contained experience, something with a standard set of available units, more like chess with each player being provided with the same cards.

Having set out scope and some goals of what I wanted to achieve I got down to rapid prototyping.
The most obviously place to start I thought was using a standard set of playing cards.

This provided me with two sets of identical cards, red and black, as well as values to use for some kind of scoring system or card differentiation.

With a set of game pieces to work with, I thought it best to find some kind of theme or idea to base the rule set around.
I thought about chess again, a game based around the strategies of war, and decided on basing it around medieval battles.

After a couple hours of brainstorming and quick play testing I had come up with a base set of rules.

The whole process went a lot smoother and a lot quicker then expected, at first this concerned me as it probably meant the design was trash but after more play testing and showing a number of people, including devs and friends, it seems to be very playable and reasonably fun.

Over the next week I spent time refining, tweaking and adjusting rules.
I have got it to a point were I am happy to start doing more in depth and intensive play testing.
I have started to convert the set of cards from a regular set of playing cards to cards specific to this game, once I have made a prototype set of cards, most likely using my amazing MS paint skills, I will use it to get as much user play testing as possible, getting feedback and making the best version of this game as I can.

Melbourne International Games Week 2017

Each year Melbourne International Games Week  takes place over the October/November period, this week is comprised of many events, but structured around three main one, Unity Unite, GCAP (Game Connect Asia Pacific) and PAX Aus.

With a mix of major industry and consumer events, attending MIGW can prove to be a fantastic opportunity for learning and networking.

However, there is a bit of a barrier, attending any  one of these events can be costly, attending all of them on an indie budget can prove to be extremely hard.

There are a number of options though.
The first of which is volunteering, most of the events put out a call for volunteers, this is a fantastic way of attending the events as you usually work in shifts and get time to attend talks and network with people, volunteering is usually looked well upon when applying for industry events as well.

The second option is applying for scholarships and grants.
There are a number of scholarships available for most events in the games industry, some through the individual events themselves, such as GCAP assist, and others through external foundations such as the IGDA Scholars program.

This year I opted to apply for the IGDA scholarship to attend the entirety of MIGW17, and to my great pleasure I was chosen along with 7 other people from around the world to receive the scholarship.
Along with tickets to the major events the scholarship also paired us with an industry mentor each for the week as well as organised Q&A lunches with various studio heads and industry members.

I was paired with Joshua Sanderson, formerly of Half Brick and co founder of Team Shifty, a pairing I was extremely happy with and learnt a great deal from.

Of the many experiences and connections made over the MIGW scholarship, the one that really stands out is that of spending time with and becoming friends with the other scholars, learning about their experience in pursuing game development in other parts of the world, their experiences and ideas with diversity within the industry and just getting to be around these amazing people was an incredible experience and I will cherish the friendships I made due to the scholarship forever.

I’ll leave this post here as somewhat of an intro and do a a post on each other major events themselves.

I would like to thank the IGDA foundation for providing such a great opportunity to those of us that are just entering the industry and I hope that the program continues on and helps many more budding devs int the future.


Cap’n Cat update 2

So, Captain Cat has come to fair way, over the last couple weeks. more assets have been added and a lot of stability issues and refinements have gone in.
There is now a cute ocean for Captain cat to explore!


So, as usual, I’m going to talk about an issue I ran into getting to this point.
So obviously one of the biggest changes is the environment that’s been added, this proved to be a bit of a headache, unfortunately.
I was told that I was to do a repeating, parallaxing background, which is simple enough and would have looked pretty cool, however, when the art was delivered from the artists it was a single image which did not tile, the designer decided to make some modifications to try and salvage it so we could still use the asset.

In short, no matter how we altered it, it really did not work at all and the artists were unable to redo the asset as they had moved on to another project.

Since the original asset looked good I decided to use it and find another way of conveying movement.
I had a peek at some of the other unused assets and come up with a solution, I made a bubble machine!
Having bubbles rise up from the bottom and move toward the right of the screen along with the ground moving provided the illusion of movement and added a bit of charm that I think looks pretty good.
I still may add a little bit rocking or bobbing to the sub to give it a little more life.

Captain Cat Update

last I talked about Cap’n Cat it was mostly just a proof of concept, and a lot of things hadn’t really been to fleshed out and there was a lot of things still to be done to actually have a proper concept.
So many many brainstorming sessions, a half-baked design document and a doubling in the size of the team, we now have a much clearer goal and some exciting concepts in the works.

Here is a little peek at what it looks like now

So that’s looking pretty good, Now I’m going to talk about how I failed at something but found a different solution.

Spawn Boxes
So the main dilemma the Captain faces on their subaquatic adventure is leaks springing in the hull of the submarine, So to handle this I started building a 2D polygon class, simple enough, it’s essentially just a list of vector2s that contains the position of each vertex.
One of the functions of the class would be to find a random position within the polygon and return it and create a leak at that position.

To achieve this I looked into barycentric coordinates.
This required breaking down the polygon into triangles, weighting each of these triangles, since they would be different sizes, and then find a random position from within one of those triangles based on weight and number of triangles.

So after spending a little too long working on trying to get that to work I reconsidered the problem and just decided to use quads since its simple enough to return a point from within a quad and for the current use its all I really need, so I did that and the spawn boxes became simple to implement.

I am going to continue my work on barycentric coordinate systems if only out of interest, however, I am sure it may come in handy with shader development possibly?


Captain Cat!

Recently I have been a little bit of a holiday, I had a whole two-week break from university!
However, I didn’t spend much of my rather short break relaxing, while I did take a small break from programming I spent a large amount of my break writing documents, teasing out ideas, building asset lists and finding people who might be interested in working on a bit of a bigger project I have coming up (more on that later).

However, there was another project a friend of mine talked me into doing, after pointing out that we’d never collaborated on anything before, she pitched me “Captain Cat!”.

Captain Cat is a cat who is adventuring through the seas in their very own submarine, unfortunately for Captain Cat, their sub is springing leaks!!
The aim of the game is to help Captain Cat patch the leaky holes whilst also trying to catch Octopuses to join him as OctoCrew that can help patch holes and pump leaked water back out of the sub.

The player draws where they would like Captain Cat to go and they will go there!
The very first prototype looked like this

It is a lot more polished and cool now but I, unfortunately, do not have any footage of it yet, I’ll post some soon!

So far it has been a lot of fun working with my friend Naomi on this project and I’m glad she talked me into it.
Here’s a picture of her drawing the sub on the studio office whiteboard

Hello Custom Collision

Recently I’ve been in assigned the task of rapid prototyping, I am to complete 2 prototypes a week for a 6 week period, with each prototype having a small brief with specific items to be included.
At first, this task seemed daunting, however, I thought back to Jam Game weekend and remembered how much fun it had been and jumped on in.

Now this blog isn’t so much about this task as much as it is about what I realised as I approached each prototype, I was given the freedom to choose the tools I used as I saw fit, and as a peer of mine pointed out, I was choosing to work in Unity a lot of the time, this became very evident when I was to tasked with developing a couple of different shaders, now the easiest way of rapid prototyping shaders is most likely in UE4, simple node-based system that is essentially free, however I choose to look around and ended up buying shader forge, which is essentially the same system as UE4 but for unity, with a $90 price tag.

After reflecting on this I had become a little worried I had become too comfortable with using the one tool over and over.
I discussed this with a peer and ended up coming to the conclusion that it isn’t to big a deal to work in the same engine all the time, in fact, it reinforces consistency, however, what might not be terrible good would to get too comfortable with relying on a single API  and forget about what’s happening just a little below the surface.

To this end, I decided to go back to one of the first completed prototypes and strip out any of the Unity API, for example removing any of the Transform.translate or AddForce functions built into Unity and replacing it with my own movement code, that was relatively quick and I was actually very refreshing.

The next thing I decided remove was the Unity Collision stuff.
I started this out thinking it would be pretty quick and easy, make a circle class and a collision manager that checks collision between the circles, which is incredibly easy, HOWEVER, that’s when I realised this wouldnt be sufficient as I have a single sprite that is a long skinny rectangle projectile (think star wars style laser beam) and a circle collision would definitely not do it justice.
I thought about rewriting the whole thing to run on boxes, but decided that if I’m going to rewrite it I might as well make it more robust over all, so I consulted with someone a little more experienced then myself and they suggested I look at the GJK distance algorithm, this is a method of checking the distance between two sets of convex sets, so it doesn’t so much matter what the shapes are you can still test to see what the distance between them are.
Now I’ve seen this before but I have never used it or implemented it myself, which got me a little excited!

So in the next couple days I will continue work on this GJK based collision system and hopefully it will go well, once it is complete I will do a follow up post talking about how I went about it.


Ballerina Battle Arena!

So I mentioned it in the last post but at Global Game Jam, I made a small game using PICO-8 (a fantasy console you can learn more about here) called Ballerina Battle Arena, where you played as a ballerina and you fight waves of  break dancers using ballet moves, it was silly and fun and looked a bit like this.

However, I had so much fun with it and I just kept coming up with so much for it that just wouldn’t have been possible at a game jam that I decided I would continue working on it.

I’ve started from scratch and moved from PICO-8, even though I love it, to Unity, so I can up the scale and hopefully make this something really cool.

The GDD is coming together and I’m learning as much about dance as I can to try and make all the dancing in the game relatively accurate.

I will be dropping the pixel art for something a little bit prettier, I’d love to find an artist to be my partner in this, I have my eye on some people, I just have to sell them on the idea.

The other interesting opportunity the project presents is a focus on a killer soundtrack, I would love to get a really nice theme to go with each style of dance present in the game, I also have some leads on this, so hears hoping that pans out.

I’m very excited about the project and I’ll try and keep up these blogs to keep a log of progress, all posts about the project will be tagged with BallerinaBattleArena.

That’s it for now, I’m going to get back into it!



Global Game Jam 2017

Over the weekend of 20th-22nd of February was Global Game Jam.
For those who don’t know a game jam is when a bunch of people get together and over a set amount of time, usually a weekend, create a game, sometimes there is a theme or sometimes it’s set around a certain software or hardware.
This particular jam, as the title suggests, is a jam that takes place over the same weekend all over the globe, with thousands of people making games at the same time with the same theme.

This was my first ever jam and it was so much fun and learned a lot and meet heaps of awesome people, it was amazing to see what people could do over a single weekend!

Now I had initially planned on working in a team and making something in Unity, however, a separate project of mine game me an idea.
One of my lecturers had recommended to me to check out PICO-8, a fantasy console which has strict hardware limitations and limited API meaning most things have to be done from scratch, now as luck would have it PICO-8 just happened to be in a humble bundle around that time and I bought licence to check it out.
Now I can understand why it could be foolish or ill-advised to use a development environment that you have no experience in, using a language you have never used and having to do it alone due to the platform not really allowing for multiple person projects, and on top of this have never done a game jam before, however it seemed interesting to me so that’s what I decided to do.

A lot of my peers were concerned that it wasn’t a good idea and I should just stick to what I already knew and I’d do better, however, I thought the opposite, the restrictions the PICO-8 provides me with not much opportunity to over scope, something that I’m not too guilty of but having never had to make a game in 48 hours it seemed useful to have a hard limit in place, and since this whole thing was a learning experience I decided I wanted to make the most of it and learn something over the weekend.
To that end working in the PICO-8 meant having to use Lua, a scripting language I’d never used before, My hope was that I would be competent enough as a programmer that with a reference to the API I would be able to pick it up as I went, which, actually went pretty well!

So We got to the jam, had the opening talks from industry people, a video from the guys at extra credits made just for Global Game Jam which was excellent and we found out the theme, which this year was Waves.

As soon as the theme was revealed there was a buzz in the air of people getting straight into brainstorming mode, it was amazing.

At this point, I decided to make a battle arena game where you would fight waves of enemies, not super creative I know, however, earlier that day a friend of mine had asked if I could make my games protagonist a ballerina, which I said sure, and that is how Ballerina Battle Arena was born!

Now I’m super excited about Ballerina Battle Arena, but that is not what this post is about, it’s about the jam, so I will do a follow-up post soon about it so stay tuned for that.

The next 48 hours were full of coffee, little sleep, programming, trying to figure out how to animate a tutu in an 8×8 pixel array.

It was a fantastic experience and I can’t wait for the next one, it was a tremendous growing experience and I feel so much more confident in my programming ability, AND I now have a new project to work on!



Pathfinding Fun

Over the last month, my focus has been on a pathfinding algorithms.
For The final assessment of the year at University, we were tasked with a project of our choice.
My peers choose to work on a variety of interesting ideas and mechanics, and it was exciting to see everyone exploring new programming ideas and methods.
I decided I wanted to learn more about pathfinding, for a couple reasons, one of which being that I have a deep and burning passion for point and click adventure games and have always wanted to know how the walk boxes and movement systems work in those games, the other reason being that I have an interest in video game AI and smooth and natural looking pathfinding is extremely imperative for good game AI.

So, where do I start?
Well, I started reading as much info as I could about the different types of pathfinding commonly used and what their best use cases are, very quickly it became very apparent that, like most things in programming, there are many many different approaches to pathfinding and many many different ways to implement the same algorithms.

So I decided to go with a classic, the “Hello world!” of pathfinding if you will, A*.
A* is relatively simple and effective, it’s not entirely the most efficient but it’s not bad overall.
Now I’m not going to try and explain how A* works, there are much better explanations out there on the web, all you need to know is that my take on it cuts the world up into a grid of “nodes” which hold some values that the A* can use to compare nodes to each other to determine if a node is closer or further away from the destination, I’ll show you the summary I have written up the top of my node class.

It also contains a bool that determines if that node is “walkable”, which determines if it can be used in the path or not, if it’s not the algorithm will ignore that node and build the path around it, hence that actual pathfinding part.
From here it’s as easy as finding the start node, in this case being the player’s position, and the end node, which is a position in the world collected on mouse click (ignoring the Y axis),
then the A* does its thing and compares all the nodes between the start and end node and finds the nodes with the lowest overall cost (f cost), and places them in a list (I’ll talk about lists another time) which then makes up the path.

here’s and example of the grid

The algorithm checks the layer mask of objects and if they are solid it will turn the nodes that the object occupies to “unwalkable”, turning it red and unable to be used in the path.

Ok I’ve rambled enough, I’ll bore you with more details soon.

Thanks for reading!




Welcome to the first official post on The Valentine games blog!

This blog will serve as a collection of posts on various topics and a log of my progression.

Expect to find posts on any current projects I am working on, events I attend or other such things here as well.

I look forward to sharing with you all soon.

Thank you.