Here can be found information and code samples from any projects I have worked on in the past.
Grave Ghost
Play it here! Made for the Idle Thumbs Wizard Jam some… year. 2015? It’s been a while. You are a ghost and you’ve just awakened in a graveyard. What do? Escape! There’s hardly anything special here, but it was a fun jam. I like the game ideas I have here at least, and one day may revisit them for a more full adventure puzzle type game.
Twirly Bird
Play it here! An entry into the illustrious Flappy Bird Game Jam. Play as a chubby vulture navigating some weird desert environment with floating obstacles. The vulture always turns toward the cursor, which can be hazardous to its health. Eat meat or the vulture loses all of its energy! Eat too much meat, and the vulture goes into a temporary overdrive, flying and turning even faster. The game is hard because it’s supposed to be hard! I’m worried it’s a little too hard. It’s also the first game I finished in Unity. And the first project that went farther than implementing the most basic of ideas. I think it turned out well, but it’s hard to show it to people because it’s so hard! Maybe I should have picked a different first game jam game, huh? C’est la vie! (For the record, my high score is… I forget! But it was 13 or 17 or some odd teen-number.) I was the programmer and designer and sound effect guy for this game, and a friend of mine, David Chalmers, did all of the art. For sound effects, I used the free web-based sound effect generator, as3fxr. For music, I used a public domain version of Johan Strauss II’s The Blue Danube Waltz. That’s not the version I used, but unfortunately, I can’t remember where I found the version I used! I’m so sorry! Here’s a couple of links to code samples, should you be curious. It’s nothing special, as it was a big learning experience for me, but nonetheless!
- This is the movement code for the our friendly vulture. It also handles obstacle and food collision results.
- This is the generation and management code for the obstacles the vulture navigates through. It definitely turned into a sort of mega-class as the project neared its end, but given the game’s small nature, I’m okay with that. Were I to do it again, I’d make a generic obstacle object which would handle its own spawning and destruction, rather than do it all in this class.
…so I ran
A first-person parkour platformer in which the player must navigate from the beginning to the end of each of a given level. It is written almost entirely in C++, with Lua integration for level scripting purposes. We used various open-source libraries to assist our development, such as Bullet Physics and luabind. I was the gameplay mechanics designer and primary gameplay programmer, responsible for all player movement – including but not limited to running, jumping, wallrunning, sliding, and climbing – and interaction with the environment, as well as the dynamic camera modifiers which facilitate smoother transitions from one action to another. Since one of our main goals with the development of this game was to just be able to drag and drop anything into the game and have it work as fast as possible, the movement system is based on dynamic geometry recognition using Bullet’s mesh collision, rather than a simpler but much more restrictive tag system that mark an object as “wallrunnable” or similar. Place a wall, and the game will treat it like a wall. Make it short enough, and the player can climb it. Place a slope, and the player will slide down it. Besides myself, the following people worked on the game. Art: Ryn Goodwin, Stephen Kaplan Music: Jeremy Kings Level Design: Brandon Anderson, Brett Cutler Programming: Jonathan Rust (that’s me!), Malte Skarupke, Paolo Surricchio The following are links to several videos showcasing our game in its current state:
- A technical demonstration of our graphics tech and some of the movement mechanics.
- A gameplay demonstration of the work-in-progress first pass of level two, showing the momentum we want the player to achieve.
- A technical demonstration of our in-engine WYSIWYG editor – of which I played very little part, but has done wonders in helping me to test my movement code!
Our engine is component-based, so most of the movement code is separated into various components. The following are links to a couple of samples of code that I’ve written for our game:
- The WallJump component uses the direction the player is facing (i.e., the rotation of the camera on the Y-axis) – as well as the current velocity and the normal of the wall being jumped off of – to calculate which direction the player should jump. (I’ve included the entire class here, as it’s relatively small.)
- The Climbing component uses Bullet Physics’ ray cast test to find the end position of a climb, should it be successful, and then the collision sweep test to see if the player could actually climb without objects getting in the way. (I’ve only included a single function, climb, here, as it’s relatively large and complicated.)
Drake Savage: Space Guy
If you want to download and play this game, click here! A top-down shooter, pretty heavily inspired by Geometry Wars, where the player must destroy enemy spawners which appear as planets with gravitational pull. It is written entirely in C++. I handled the 2D physics engine, which includes the gravitational effects, collision detection, impulse-based collision resolution, etc. I also programmed all of the user interface, including the menus and in-game HUD. I worked with two fellow DigiPen students on this game. Ryan Scheppler was the game designer, as well as the main gameplay and AI programmer, and Emory Myers was the technical director, as well as the graphics programmer. Here is a video of sample gameplay. At the time of making this game, although I was in charge of the physics engine, I still had yet to really learn how a physics engine, so it was largely a copy-paste job from an engine that I knew already worked, making a few changes here and there for our convenience. One of the things I added was objects that support gravitational pull. This is the function I used to calculate the total gravitational pull on a physics body. It is a pretty simple affair, but it added a little something to our game, although unfortunately, due to time constraints, we didn’t have time to use it to its full potential. Since we had such a large playing field, unlike Asteroids or Geometry Wars, we needed a way to ensure the player would always know where to go. The “waves” in our game consist of enemy spawners – i.e., planets – which grow in number each time a wave is defeated. First one, then two, then four, etc. In order to ensure the player wouldn’t get lost, I implemented a HUD arrow to point to all the planets in the playing field. The above video shows this in effect. This is the code that handles that HUD element.
LeetTweets
A Twitter analyzer written entirely in Python. I worked with three fellow University of Cincinnati students. Its purpose was to find the most influential Twitter users on a given topic, based on replies, retweets, and followers. I was responsible for the crawler, which constantly reads a random selection of incoming Tweets and uses a teammate’s filter to identify and store relevant Tweets. I worked with three fellow University of Cincinnati students on this project. Corey Downing was the producer and primary engine developer; Corry Paxson was responsible for parsing the Tweets as they arrived, throwing out any irrelevant information; and Christopher Theisen was responsible for organizing the filtered Tweets according to various topics.