Andy Gainey

Game Programmer & Designer Portfolio

Thank you for visiting my gamedev portfolio. Below you will find highlights of some of the products and projects I've worked on, including games and game-related technology. The first section contains tools and software libraries I have developed and sold which are built on rendering, geometry, and mathematical technologies and techniques. The second section is a selection of games and prototypes I have worked on, including a published Android game and a number of successful game jam entries.

Tool and Library Development

Worldbuilder (2015)

Standalone procedural planet generator for Windows.

Technologies: C++, LuaJIT, GLSL, OpenGL, wxWidgets

Back­ground: Built in re­sponse to the posi­tive re­cep­tion to my 2014 blog post Pro­ced­ural Pla­net Gen­er­ation and assoc­iated web demo, World­buil­der is based on ir­reg­ular til­ings of a sphere, com­bined with a plate tec­ton­ics sim­u­la­tion to gen­er­ate land­forms which are more real­is­tic and dis­tinct than those typ­ic­al­ly pro­duced by Per­lin noise and sim­i­lar meth­ods.

All pro­ced­ural gener­ation code is ex­posed and edit­able in Lua, using high-speed util­ities pro­vided through the LuaJIT com­piler. Gener­ation com­po­nents are modu­lar, con­nected and exe­cuted accor­ding to a cus­tom­iz­able de­pen­den­cy graph.

Make It Tile (2016-2017)

Tile and topology framework for Unity.

Technologies: C#, winged-edge data structure, graph traversal algorithms, A* path-finding, planar & spherical spatial partitioning

Back­ground: Bringing many of the underlying data structures and algorithms used in World­buil­der above, Make It Tile offers a highy flexible library to Unity developers building novel tile-based games. Starting with standard square and hexagonal tiles, Make It Tile extends support to include irregular tiles, and algorithms that seamlessly handle them.

Extensively documented.

Make It Random (2016-2017)

Extensive random number generation library for Unity.

Technologies: C#, various PRNGs, statistics, probability, geometry, and shuffle algorithms, color theory, bit manipulation

Background: Initially created to support the RNG needs of Make It Tile, Make It Random became a standalone library, replacing and substantially surpassing Unity's built-in RNG. Through the use of careful algorithm selection and aggressive and creative use of integer and bitwise operations, Make It Random is able to simultaneously offer better performance and higher quality distributions than Unity's RNG, despite being entirely written in customer-hackable C#.

Extensively documented.

Game Design and Development

Minesweeper (Android, 2016-09)

Technologies: Unity, C#, Make It Tile, Make It Random

Expanded from a sample of my Unity library Make It Tile, this project became a collaboration with Nathan Walker of Mooncalf to release a version of the classic Minesweeper game, adapted for efficient play on a touch device and with more modernized and pleasing visuals.

Much of the work focused on user experience design. Half of this was that touch input was optimized by reducing the need for what was traditionally a right mouse button operation: marking flags. Instead, trivially identifiable flags are marked automatically, easing the flow of gameplay without removing the challenge.

Visual feedback through palettes and animations were the other half of user experience design. Various styles were experimented with and iterated on, before we were satisfied that the presentation did an excellent job of letting the player know what was available or happening, without slowing down the speediest of players.

Deserializer (Ludum Dare 32, 2015-04)

Technologies: Unity, C#

Action puzzle game, inspired by Frogger, but with the twist that you need to laterally intercept segments of the moving objects in order to complete a pattern and unlock a password.

This was my third solo game jam entry, and the first Unity project in which I felt I was finally working with Unity, not against it. (Learning to get along with a new tool can take some time!)

It ranked #12 in the category of innovation, out of 1468 total entries, and managed a respectable #165 in both the fun category and overall.

Symptomatic (Ludum Dare 29, 2014-04)

Technologies: HTML, JavaScript, CreateJS

Puzzle game, loosely inspired by Minesweeper, in which most information about the game world is hidden and the player has to indirectly determine that information based on other information that is exposed, as well as SpaceChem and Tsuro, in which objects move systematically along winding paths.

In Symptomatic, this hidden information are the shapes of the squiggling paths that cross each hexagonal cell, and the public information is the locations of game objects relative to each other and their locations on previous turns.

This was only my second game jam, first solo, and I was thrilled to rank #5 in the category of innovation out of 1493 entries. #203 overall wasn't bad, but #459 in fun did clearly indicate that the rules of my game were very hard to discern.

Trial 21 (Ludum Dare 35, 2016-04)

Technologies: Unity, C#, Spine, Ferr2D Terrain

Platformer with puzzle-like level design.

This was my seventh game jam, and third that I had done in collaboration with a local group of developers, musician, and artist.

This experience reinforced in my mind that platformer physics is really hard to get right, a lesson that I had already been taught during my very first game jam. Repetition is good for learning!

Kvetch-A-Sketch (Ludum Dare 36, 2016-08)

Technologies: Unity, C#, HLSL

Physics-based action puzzle game, using the Etch-A-Sketch drawing toy as an inspiriation for the aesthetics and input method. Draw walls in order to bounce the ever respawning ball into the black hole within a given number of bounces.

This was my eighth game jam, and fourth that I had done in collaboration with a local group of developers, musician, and artist. Ludum Dare chose to disable ratings for this iteration of the game jam (problems with rising abuse and cheating, I guess), but we were encouraged by the Tech Valley Game Sapce Let's Play, during which the lady playing the game was getting sucked in by the mechanics, and was thus highly reluctant to move onto the next game in their list.

In addition to procedurally drawing the line and wrestling with the physics engine, I had fun experimenting with shaders for the various environmental effects.

Emily Vs. Everything (Ludum Dare 37, 2016-12)

Technologies: Unity, C#

A beat-em-up which all takes place in a single room: a young girl's bedroom. But through the power of her imagination, it transforms into a wide ranging series of epic battles.

This was my ninth game jam, and fifth that I had done in collaboration with a local group of developers, musician, and artist. We were getting our process figured out fairly well, and the game did reasonably well across the board, ranking within the top 200 out of 1489 in the categories audio, humor, mood, and fun.

Our method of mixing 2D environment art with sort-of 3D physics was perhaps a bit hacky, but it worked. I was also able to play around with some enemy movement AI. I was particularly proud of my efforts to include the between-level upgrades, which barely made it in during the last hours of the jam, but added a lot to the gameplay experience.

Automation Survival Prototypes (2017)

Technologies: Unity, C#; HTML, JavaScript, CreateJS, jQuery; Excel

An experiment in combining the engaging exploration and the creative construction of games such as Terraria and Minecraft with the logic and engineering of games like Factorio and Infinifactory. The goal is a compelling feedback loop between exploration and construction: Each activity facilitates the other, and both are necessary for long-term survival.

Starting with raw tools such as an image editor and a spreadsheet, I tested core ideas regarding, on one hand, the moment-to-moment details of user interface (both input from the player and visual output to the player), and on the other hand, the larger scale subject of pacing, involving attributes like avatar strength, exploration depth, and tech tree progression. Later development led to an interactive UI demo as well as an incremental clicker (a great tool, I discovered, for abstracting away non-pacing elements of the game).

City Simulator Prototypes (2014-2015)

Technologies: C++, OpenGL; Unity, C#; HTML, JavaScript, CreateJS

Real cities have stories to tell. Real neighbors have character. The same should be true for a game in the city builder genre.

That is central theme that grew out of these series of prototypes, the last of which began experimentation with using mechanics and insights gleaned from CCGs like Magic: The Gathering and deck-building games such as Dominion in order to generate compelling narratives, and make each city a player builds feel unique and intriguing. My process for reaching this focus was admittedly less efficient that perhaps it could have been, but I learned a lot from the process.

And I still believe that the central concepts of neighborhoods as explicit game objects, deck building (such as through appointing city officials, enacting policies, and building civic resources), and a well-managed dose of randomness hold great promise for creating a superb city builder. Further development merely was stopped due to shifting my business focus over to the planet generator and Unity assets; perhaps that was the wrong move, but that's just the nature of tough business decisions.

Other Projects (2014-2017)

Additional projects, prototypes, and game jams can be found here.