Tom’s Magic Cube – The Beginning

As anyone reading this likely already knows, I like to make controllers. Like a lot. I’ve fallen into the pit of always having input at the very forefront of my mind with anything (maybe not a pit!), so whenever a game comes around my first thought is “What controller could I make for this?”

Magnets and Pirate Ships

This brings me to a project I’ve been working on for about… half a year now: Tom’s Magic Cube! That’s a pending name. When I was in San Fran showcasing OVERTIME in alt.ctrl.GDC, the game that took home the badass trophy for best game in alt.ctrl was Hot Swap. I had the chance to meet Peter Gyory, one of the developers, and fell in love with the mechanisms that allowed for fast, entertaining and refreshing input. To summarize the game, two players must take small, plastic and magnetic control pieces and plug them into one of two slots in their own control board. These components control a pirate ship that has to both keep itself afloat, find treasure, and defend against other ships shooting cannon balls at them. The pieces range from a steering wheel to a water pump that extinguishes fire, but are in limited amount. This forces the players to exchange pieces, implicitly define responsibilities, and explore what configuration works best. Until getting hit by another five cannon balls on one side, and sinking fast.


What got me most excited was the construction of the controller. Magnets hold the buttons down, a notch on one corner enforces proper orientation, and a series of pins allow for electronic input from each piece. The parts themselves are Mechamagnets, an input exploration designed by Clement Zheng, one of the other team members on the project. Mechamagnets “…explore[] a technique to rapidly prototype haptic and functional physical interfaces through desktop 3D printing and embedded static magnets.” I immediately started exploring use-cases for them in my own projects, but the spark didn’t come until about a week or two after I returned from GDC.

3D Controllers for 2D Platformers

A new quarter at DePaul started a week after I returned, and one of the courses I began was Professor Peter McDonald‘s Topics in Game Design class, with this session being about 2D platformers. The course is a deep dive into 2D platformers and the impact every small element has on shaping the design of everything around it. My good friend Kailey Phan Mitchell and I started working on an auto-scrolling, colorful platformer where a cube must venture across colorful platforms (ROYGBV) while collecting various items. The game itself was simple and entertaining, but from the start we knew we wanted some sort of alternative input. Now, here’s where the Magic Cube finally enters.

The shape was the first focus. We wanted some input that could allow for individual coloring of six different colors to connect to the platforms. Naturally, that let us to a cube! It’s a familiar shape and provides easily grip-able edges so that players don’t accidentally press anything. The size was essentially defined by a custom PCB I made to house an ESP32 board and some extra bits for input. An embedded Fusion file is presented below.

I utilized the Mechamagnets design mentioned previously to rapidly create inputs that had more impact than a standard push button, and added a slit in the button intake wall to place the hall sensor needed to read the magnet movement. Each hall sensor shares power and ground, with pull-up resistors places between the 5V out and the input pin. You can read more about the wiring of the sensors here. The ESP32 inside was powered by a LiPo battery, and sends serial output of all button values over Bluetooth, while Unity reads com port data every frame.

Looking to the Future

The ending result, both controller and game, were fairly simple, but extremely satisfying in their input. We further explored button input by introducing wall obstacles of certain colors, requiring the player to hold down that button color to make it disappear while still managing jumping around. For a few weeks of work (outside of other classes, student employment, and life), it’s not too shabby! Shortly after finishing the class, I began work on version two of the controller. This includes, but is not limited to: gyroscope input, LEDs, custom circuit board panels, clean, repairable design, increased size, resin-printed light-up buttons, heat-inserted threads and low-profile socket cap screws, and more! Stay tuned on my social media and feel free to reach out with any questions! Twitter, Instagram




About a month and a half ago, I hopped in on a game jam run by IGDA Chicago in association with DePaul’s Junior Development Experience and Columbia’s AlphaLab called Retro Game Jam. The aim of the jam was to create a game that loosely fit within the constraints of an original Atari. This mainly dictated resolution and color palette.

I had a personal challenge within this jam: I did it entirely solo. This dictated the scope of the game, so I went with a simple tag game using a mechanic I have been tossing around in the context of a cheesy, story driven game about a son who wants to make his father proud by becoming a professional tag champ (that context was left out for this one unfortunately, but maybe I’ll drop that back in at another time!).

The game plays fairly simply. Player one and two must try to tag each other by getting close enough for the white circle to turn green, then hitting the tag button. The catch is, if they try to tag but are not close enough, they stun themselves and are open to attack. Players and juke each other out and end up winning pretty quickly. The first to three tags wins the game.

I had the opportunity to allow for the use of original Atari joysticks as input, which they were utilized for at BitBash Chicago in August!

Below is a full list of details about the game and a link to download for Windows!




Quit Game: Escape Key

Player 1:

Movement: WASD

Tag: Space Bar

Player 2:

Movement: Arrow Keys

Tag: Enter on Keypad


Engine: Unity

Sound: BFXR

Music: BeepBox

Pixel Shader: World of Zero

Color Limiter Shader: Color Quantization

Art (Title and UI): Pyxel Edit


OVERTIME Controller 2.0

After taking a step back on projects to focus on school and work, I’ve returned to lay out my process of developing the OVERTIME Controller 2.0.



For those not familiar with the project, OVERTIME is a game originally created for the Extra Credits first ever Game Jam under the theme of “Awesome-Per-Second.” It’s a wario-ware-style game centered around anime basketball, tropes and all. After it’s initial creation, the team who made it approached me with the goal of creating some eye-catching controller based on a classic 90s basketball toy off amazon (see previous post for that).

Time passed and the game was showcased at Dreamhack Atlanta and Minefaire, where it faced a good bit of user testing, feedback and wear and tear. After those conferences, we were accepted to alt.ctrl.GDC, a major personal achievement of mine. With this acceptance came a need for improvement, however. The controller was too heavy for easy handling, the belt input was chunky and inconsistent, and it often risked being damaged because of certain sections of fragility (it was a rather rushed project). This began my quest of answering all those problems and adding a bit of style too.

The first issue was input. The belt and rotary encoder was okay for small cases, but was lumpy and people didn’t feel confident in maneuvering it. After exploring a few options, I landed on using a linear potentiometer for its durability, minute detail of positioning and affordability (this one specifically). The input could be processed by the analog pin in of an Arduino Uno, so no issues there. One problem I did encounter with this particular potentiometer is that it had occasional value bouncing, jumping from its true value to somewhere a bit left of middle. This was just counteracted with lerping movement within Unity, so not a big deal. 

The next challenge was weight and height, which in turn provided an opportunity to modify aesthetic. Since the first version of the controller was originally a toy with hardware stuffed inside, I chose to create a base which added a lot of heft. It also was blue, which was a bit out-of-theme since the game’s main colors are purple and yellow. So for version two, I remodeled the entire controller in Fusion 360, and made it purple.

It is modeled after the original constraints of the first controller, with the inclusion of more space underneath and a specific insert of the potentiometer on the front and openings for button wires to pass through. It also retained the detachable hoop stand to make transport a bit safer and assure that it would *likely* not snap. 

The base was made of two pieces of wood, one hollowed out to allow for the arduino and wires to fit on the inside. I used small metal rods to attach the top and bottom, which still allows me to remove the wood if necessary.

Looking back on the controller, there are definite things I would change. For one, the button I designed for the front was the first button I ever designed, so it was a bit rough around the edges. It was essentially only secured by a spring, and was able to last all through GDC, but began disconnecting after that. I’d also set up COM port canning so that it can instantly work with any computer, rather that whichever is set up specifically in the code.

After getting the opportunity to showcase in so many places, I’m super thankful that I had a hand in the project. I’ve met so many cool people, developed new skills, and opened up new avenues of exploration that I am pursuing with new projects. 



VFX Graph – First Tests

I recently challenged myself to get familiar with Unity’s VFX Graph system that is currently in development stages. There isn’t a whole lot of clear documentation on the system so there was a good bit of trial and error, but I’m excited with the results!

For an upcoming project, I plan on implementing a visualization of a cube controller I’ve been working on for a while as the main interaction piece. The mesh itself isn’t very exciting to throw into unity, so I thought I’d use VFX to spice it up a bit. The process I followed is from this video: that demonstrates how to implement Signed Distance Fields into the VFX Graph.

To start, I exported my mesh from Fusion 360 with only the frame included, and imported the STL into Houdini. The reason for using Houdini is that its apprentice version is free, and has the ability to export SDFs quite easily. After using the IsoEffect node to simplify and add mass to the object, I used the VFX toolbox to export a SDF with around 60,000 points.

I am using a basic scene in Unity that has the High Definition Render Pipeline built in. The Visual Effect started off as a template one for particles, and I expanded upon it with a few adjustments. I originally started with using the point cache file from Houdini as a position map for the particles to spawn from, but I discovered no way of rotating the point cache map to adjust the angle over time. Might dive even deeper on that for later. Instead, I’m using the SDF and the “Conform to SDF” block in the particle editor. I’ve included images of all the VFX Graph settings used at the end of the article, just click them to open a full size in a new tab!

I also played around with pulsing of various elements using the sine wave block and Time block  to add some cool intensity effects to the cube. This one below is bouncing the SDF Attraction Force, Stick Force, and Turbulence Intensity. Since the particle brightness is implicitly affected by speed, the color dims when the turbulence and attraction force is lowered.

In the future, I plan on experimenting with external value inputs to have the user rotate and affect the cube, but for now I’m back to work on the physical controller itself!


OVERTIME Trophy Controller

This past college quarter, I worked with some DePaul students and alumni to create a physical, alternative controller for a game they were developing. The game, OVERTIME, is a collection of tongue and cheek mini games revolving around a colorful basketball rivalry. The controller idea originated from one of the developers spotting a basketball toy online, and wondering how that could be turned into something readable by a computer. 

Most of the supplies used for the project were materials found in the lab I manage at DePaul, the Idea Realization Lab. The basic functioning components of the controller are an Adafruit Flora board, a simple button, and a rotary encoder. Since the game’s inputs are very minimal, I was able to pack the functionality into the main handle of the toy, while stuffing the ugly parts of the controller on the insides of a trophy-style wooden box. The rotary encoder is attached to a belt normally used for computer controlled systems like 3D printers or CNC routers, and is attached to the movable handle. When the belt rotates, it moves the encoder, which outputs A and D values for moving left and right. There is a button superglued to the inside of the handle, so that when the handle is pushed down it emits a value of W, and S upon release. You can take a look at the code here.

For aesthetics, there is a router milled gold-tint plaque on the front with the names of the developers, and a coin slot that serves no other purpose than to steal your precious coins and have a nice *clang* when they fall inside. No additional software needs to be installed to use the controller, as micro controller keyboard input commands are universal.

This device was a lot of fun to make, and had me tackling some issues I hadn’t encountered before, like how to effectively keep belts from coming apart and the awkwardness of soldering and stuffing wires into a manageable area. It was a intriguing challenge nonetheless!

On a final note, I was fortunate enough to get the controller showcased at the Atlanta Dreamhack student work area. And though I couldn’t attend, I was still super grateful to have such a random project showcased in places outside of Chicago. The game and controller have been submitted to Alt.Ctrl at GDC and Magfest, so lets hope it gets more coverage!


Abstract Typography


IGDA Spooky Game Jam 2018 ~SEARCHING~

This past weekend, I participated in the 2018 IGDA Spooky Game Jam on a team with my friend Kailey (@Kvpm on twitter), and joined by several other DePaul students and alumni on different teams (see below).

I have to say, this jam was one of the strangest and rewarding experiences I’ve had since coming to DePaul. I’m normally one to prioritize sleep, so when  I finished the game on time with only 3 hours of rest under my belt, I felt a bit wacky. But enough about MY feelings, let’s talk about the game!

The theme of this jam was Fear. Our game, Searching, is a game about navigating the battlefield of social interaction, specifically the “Fear” of knowing the right things to say in a conversation with someone you’ve just met. The player moves around the space, and can interact with NPCs by bumping into them. This will start a “Conversation Sequence”, where if you can keep your confidence from dropping to 0 by the end of the sequence, they become your friend and will follow you. There is a garden in the school that also lets the player have self reflection time and they regain some confidence, but can only be used once per play through. 

After the player traverses to the dreaded cafeteria, all his friends leave him because they never truly wanted to hang with him or get along in the first place. This devastation leaves the player with no choice but to talk to the one lonely kid at the lunch table, who turns out to be just as strange, if not stranger, than the player. This change subverts what the player sees as the “correct” responses or statements in the sequence, so they must quickly adapt and keep their confidence up since this is their last shot at a friend. 

Check it out here!

Also, be sure to check out all the other awesome submissions for this jam, there are some crazy cool ones!

Special thanks to IGDA Chicago, The Voxelles, Sugar Gamers and 2112 Chicago for making this event happen.

Technical info: The game was made in Unity and art was made in Illustrator


Thomas: Game design, Gameplay Programming

Kailey: Game Design, Art


Summer Game Jams

This summer, outside of working at the Idea Realization Lab, I participated in three game jams hosted by DePaul’s Junior Developer Experience (JDE) group. It was a ton of fun, and a great way to stretch my legs in areas I don’t normally work in like modeling and audio. Below are links to each game and details about my roles for each game. Hope you enjoy!

Root Note is a game where you spread the seeds of music to appease the inhabitants of your planet. I did modeling and UVs for the game.

En House Decorator is a game where you are a house that decorates itself, and then decorates the house inside that house. I did modeling and a few animations for the game.

Flipped is a game about the subtle conflict and understanding between a fast food worker and a person late for work. I did sound and UV mapping.




Escape From Haven Hospital

A game created for a short game-dev course. I did production, audio and programming.