Dom Curry
Hello,

I'm a game developer, a programmer, with recent experience at Inertia Games Stutios and Unit9. You can read more on my LinkedIn profile.

Here you can find information on some of the projects I've worked on in the last couple of years.

If you want to work together, get in touch.
Upside Down
Upside Down Game
This is the gameplay demo to the game I am currently working on. It will be released on mobile first and other devices if there is an audience for it. Currently working on the menu and back end parts of the game, but there is still some polish to be done.

I've written shaders and event mangagers, databases and procedural algorithms. I still enjoy playing it but I'll also enjoy finishing it.
more

play
Technologies: Unity3D, C#
Dragon Words
Dragon Words
A free to play puzzle game. Released for Facebook, iOS and android, this is a casual word based grid game. During this project I worked on the server side, the dragon mascot character animations, storing the player data for seamless offline play, integrating Facebook story and all store purchases in a robust manner, the architecture for all of the dialogs and the navigation of the levels in the map mode.

Map Scrolling

The most difficult part of the map mode was scrolling from side to side, in particular, trying to keep it fluid. If you've good eyes you can spot the position the next constellation is loaded and the previous one is unloaded. There's a small pause in the swiping which could have been eliminated with significant restructuring. The big change would be to load in each level icon in a frame after loading the large constellation image.

I like the animations of the map elements as you progress, in particular the level stars. It was a bit of a pain to animate the from and to of each formation. i.e. 1 star to 2 stars. So almost all of these animations are made of multiple tweens, so we tween the stars scale, distance from an origin point and the rotation around the origin point. these all go up to the resting point, then there is a pair of tweens after that which go past the resting point a bit and then back.

Mascot

The mascot presented a complicated problem. We could use a set of timeline animations to animate the character. But this would cause some optimization issues with especially long play times. As each animation runs, the swf tags create and destroy new clips. So it was decided that the animations should be done by code. This way we control when we create and destroy the images. In addition we can also switch animations more quickly and the mascot's reactions will feel more responsive.

Animating each part by code was pretty repetitive, I feel like I could have streamlined things by creating some kind of reflection call, similar to how tweens work. However, I made a series of functions that would control different bodyparts. There are also times when an event should trigger once at a certain time but just testing the progress value will either almost never call the event or always call the event. To solve this I created a custom frame event class which calls a callback the first time a progress has past a defined point, then we can remove this object to make sure that it isn't called more than once.

Player Data

The control of the progression data was something that could have been improved. A lot of things were done well such as how uploading/saving the scores were handled. Each score is recorded individually and can be uploaded in any order whether completed offline or online. Also merging a mobile account with a Facebook account to consolidate their progress is made easier with this as we can just change the owner of the score record.

Attempting to play for extended periods offline is not something that is handled well, your energy won't regenerate as that only happens when you connect to the internet, and blockades won't unlock or even begin their countdown. Both these processes require a timestamp and attempting to guess the timestamp if the player is offline is not allowed. As a direct result of this we retain direct server control over the player progress events to prevent cheaters but normal players can only play a maximum of 16 levels offline before coming online again.
more

play
With: Inertia
Technologies: Flash, HaXe, Facebook, iOS, Android, PHP, SQL
Clicker Prototype
Clicker Prototype
This game was constructed over one weekend in Unity3D. A cross between a casual clicker game and a complicated puzzle, this game is a short exploration experience.

Design

The flat shaded, square design was born out of speed initially, but It's grown on me as a kind of child-like drawing. The pastel colours were chosen to exaggerate this and the objects were re-designed to fit with a kind of fairy-tale aesthetic. I like the cramped feeling of the pseudo skybox and the disorientating feel of having a low horizon that can be approached. I like the juxtaposition of the cramped skybox and the childlike art.

There is no GUI because I wanted to have a kind of noticeboard with different news articles which would have the information the player needs to make decisions in the game. However, I had reservations about how this would look in terms of how functional it would be. I decided to start a bit clearer by using the wooden signs at the sides of the scene.

I also wanted the controls to be as simple to control as possible, ideally the controls would be to click to interact and click to move. But for the prototype, the typical wasd controls will suffice. In addition the interaction colliders were designed to be much larger than the objects so that players wouldn't have to aim too hard.

Improvments Implemented

I increased feedback by popping a piece of coin out of the cow when it's hit and a gem out of the horse. This tells the player what they're getting and why they're getting it. This also allows the mechanic of walking around and picking up the gold and new points object.

I've let these new collectable objects slip off of the sides to give more reason to the blocks that fall out of the sky, as they clog up the players' game space with things they can't interact with. It introduces a kind of difficulty curve.

Improvements to Come

So the feedback to the player is a big problem, I can make interacting more reliable by separating the collider and the trigger for objects that are intractable. This would improve player movement when moving towards solid objects.

The signs could do with a bit of work, I'm still not happy with the GUI replacement. I'm considering some kind of pile or perhaps a tank of liquid which would be more contained.
more

play
source
Technologies: Unity3D 5, C#
Fuzzlepuff Frenzy
Fuzzlepuff Frenzy
I lead the programming work on this title. Having developed the prototype I was best suited to take this game through to release. A casual game, I created gameplay (above), back end and Facebook integration on both the web and mobile devices.

So, there's a couple of things I like about how I did this. But I can't show you the code.

Lightning

Yeah, the lightning. So it's made out of two bitmaps. A rounded end piece and middle piece that's one pixel wide. These are stretched over a bunch of triangles that I pass to a draw job. The triangle position, and size are based on how far along the line they are and where the previous triangle ended. Then there are a random number of these triangles that make their way to the end.

All of this is pretty standard as far as how computers draw. The thing I really like about this was how I optimized it. I was thinking that "I am destroying this set of triangles every frame to draw them in a slightly different position" that's dumb. Right?

Right.

All I need is to use the same number of triangles, then I can keep the same triangles and just move the position data around.

Works like a dream.

Tutorial Darkener

So it's not in the video, but the tutorial darkener is a big bitmap that we draw when we want to highlight a tooltip or a tooltip and something on the screen.

Crucially we sometimes want to be able to click or tap anywhere on the screen to indicate that we've read the tooltip and sometimes we want to restrict the player input so we can teach them some mechanics.

So how the mouse/touch listeners work in this game is if a listener is hit, listeners below that aren't hit. Using this I overrode the hit test function to see if the player was clicking in one of the darkeners holes, rather than hitting the bitmap. I could then use the position data of the hole rather than testing the alpha of the pixel I'm clicking on.

Components

It might not be obvious in the video above each type of fuzzlepuff is a tile component. This way we can combine different types on the same tile.

These tile components handle all of the grid events, the tile components have permissions and actions on all events ranging from normal matching to any events from special tiles.

If I Had To Do It All Again

So, the grid has this settling function loop, part of which spawns new fuzzlepuffs. However, the falling logic is not part of this loop. All of which means that the grid is prone to having gaps at the top of the grid. I also would have created the game completely offline first, so the player can progress without the internet, it would have made mobile work much easier. I changed all of the logic to remove any waiting on the server, now the game tries to update the server but can continue if the server doesn't respond. Because of this the server has a miriad of checks for people trying to abuse the game.
more

watch
With: Inertia
Technologies: Flash, HaXe, Facebook, OpenGL, iOS, Android, PHP, SQL
Flocking Prototype
Flocking Prototype
This game represents my first 25 hours in Unreal Engine 4, I quite enjoyed fumbling around in the new API and I feel like it's quite a powerful engine, but I don't know the minutia of Unreal vs. Unity really.

The game I made is a flight game where the player tries to follow the flock. I wanted to make a simple, mechanical game while I was learning the engine. I like the mechanics though and I'm looking to expand on this mechanic.

Design

The skybox and the clouds are shamelessly lifted from the default unreal project, and they are the nicest looking things in the game. The birds, which I made, are simple models that I quickly made to convey their rotation and their direction. When I continue with this game I'll update the models to something better looking.

At the moment there's only 3 physical mechanics on display, these being: player movement, AI movement and AI flocking. The basic motion of birds is that they adjust their roll and pitch to change their direction and, of course, their speed. So this was the basic movement that the birds would use. The player controls this movement by using a joystick or the mouse, I've combined the control axis for pitch and roll. The speed is controlled by various keyboard controls e.g. arrow keys.

Player Movement Algorithm

So I had to use quaternions here to change the rotation, this was the only non-standard thing here, compared to normal transnational control systems. I found the Unreal rotator conversions pretty handy here, as I didn't need to define the different rotations.

AI Movement Algorithm

So to replicate the bird motion I described earlier as the bird tried to adjust its velocity to some other velocity I took the projection of the difference between the desired velocity and the current velocity.

FVector DeltaVelocity = DesiredVelocity - Velocity;
float RollProjection = FVector::DotProduct(DeltaVelocity, GetActorRightVector());
float PitchProjection = FVector::DotProduct(DeltaVelocity, GetActorUpVector());
float SpeedProjection = FVector::DotProduct(DeltaVelocity, GetActorForwardVector());

I can then clamp these adjustments and time delta the changes to simulate their agility and these projections can be interpreted similar to the players input.

Flocking Algorithm

So the AI movement depends on having some desired velocity. How do we get that? Flocking is a complicated, complex system. (Scientifically, complex means that you can't predict the system behaviour from the examination of one element.) There are some points needed for flocking, we need alignment, cohesion and separation.

We should align our velocity with the average velocity of the group.

FVector APreyBird::GetAlignment(TArray PreyList) {
    FVector FlockVelocity = FVector(0,0,0);
    for (int i = 0; i < PreyList.Num(); i++) {
        if (PreyList[i] == this)
            continue;
        FlockVelocity += PreyList[i]->Velocity;
    }
    FlockVelocity /= PreyList.Num();
    return FlockVelocity;
}

We also need to make sure that we're close to the other parts of the flock.

FVector APreyBird::GetCohesion(TArray PreyList) {
    FVector FlockCenter = FVector(0, 0, 0);
    for (int i = 0; i < PreyList.Num(); i++) {
        if (PreyList[i] == this)
            continue;
        FlockCenter += PreyList[i]->GetActorLocation();
    }
    FlockCenter /= PreyList.Num();
    return FlockCenter - GetActorLocation();
}

But we don't want to hit anybody else in the flock.

FVector APreyBird::GetSeparation(TArray PreyList) {
    FVector PersonalBubble = FVector(0, 0, 0);
    FVector Displacement;
    float Distance;
    for (int i = 0; i < PreyList.Num(); i++) {
        if (PreyList[i] == this)
            continue;
        Displacement = GetActorLocation() - PreyList[i]->GetActorLocation();
        Distance = Displacement.Size();
        Displacement.Normalize();
        PersonalBubble += Displacement;
    }
    PersonalBubble /= PreyList.Num();
    return PersonalBubble;
}

We also want to avoid the predator.

void APreyBird::PredatorAvoidance(APlayerBird* Player) {
    FVector Displacement;
    float Distance;
    Displacement = GetActorLocation() - Player->GetActorLocation();
    Distance = Displacement.Size();
    Displacement.Normalize();
    DesiredVelocity += AvoidanceWeight * Displacement;
}

Notice that while these all have a desired or target velocity the velocity that is used for the alignment is the current velocity of the other elements in the flock so that the flocking isn't completely solved in each iteration and produces some dynamic behaviour.

Implemented Improvements

I've added player objective in this mechanics demo. The pressure on the player is introduced by adding an energy mechanic, so the more aggressively the player moves their bird the more energy it consumes and you have to catch the members of the flock, the other birds, to increase your energy.

To prevent the problem, if the flock members can be eaten then the flock can be depleted. What happens when the flock is completely depleted, is that a win? Should it be made more difficult? Should it be infinitely spawning? We can draw from the player mechanic of energy to help us with this. Let's say that the members of the flock use energy in the same way as the player, for movement. The flock can't feed on anything else as there's no other entities in the system, so it'll just regenerate a set amount of energy over time. The spawning of new elements of the flock can now be treated similarly to cell division, in that an entity reaches some threshold energy and it'll spawn a new bird and give it half it's energy.

Improvements

The next problem is when the game is running it no longer gets any harder, there is not much more of a challenge. If the flock members can reproduce we can slightly mutate the values of the weights that the algorithms use to determine the direction that the prey bird flies in. If the rate of the evolution is quick enough, we can get a flock that adapts to the player and how the player plays. This means that the player will have to have some different strategies to consitently feed themselves. I like the idea of demanding this high level of gameplay for long term success. However, due to the small size of the flock and the short timescales most players play for I'm uncertian that a reproductive evolution difficulty system is the best version, perhaps a decision evolution should be investigated.

Also I feel like the shader is too good for the models, the shading on the shapes doesn't look clean. I have two choices here, I can change the shader used to make the shapes flatter, or I can lessen the abstractness of the model. While both are good possibilites, a higher quality model presents an interesting opertunity. After checking out the Firewatch talk at GDC I realised I could shamelessly copy their tree animation and apply it to the feathers on my new bird models, where I have bend from the wing joint to the tip and I have flap on the indiviual feathers.
more

play
source
Technologies: Unreal Engine 4, C++
Pong
Pong Game
This game was a test to see what had changed from Unity 4 going into Unity 5. The classic game, Pong, provided simple mechanics and had a clear design so I could focus on the advancements made in Unity 5.

The game has a base movement class which both the player and the AI inherit, this made making the local multiplayer and singleplayer pretty neat. I could initialize each paddle with either an AI component or a Player component.
more

play
source
Technologies: Unity3D, C#
Jetpacker
Sidescroll Game
This game was made to a brief in 24hrs. The game had to have automatic aiming, firing and some enemies or obstacles. The objective of the game needed to be to gain the most height possible and it had to be controlled by only one button. This game balances risk and reward in the mind of the player, the higher they fly the faster they can rise but the margins for error are slimmer.

We have a parallax effect on the background created by starting the textures at different points. and wrapping it around a box that follows the player. We also have a construtor trigger and a destructor trigger which create the level and unload the level respectively This means that we can keep any unnecessary operations to a minimum, which will have a massive impact on mobile performance.
more

play
source
Technologies: Unity3D, C#