Status : Current Employment

Team : Niantic x RIT Geo Games and Media Research Lab

Tools : Varies

Platform :

Focusing on researching well-being, physical and mental, in the context of Geo Games

Status : Retired

Team : -

Tools : Varies

Platform : Power 8, Power 9

Developer - Cloud

Switched teams in 2019 to IBM Spectrum Scale, and began working on cloud integration.

• Leveraged the operator-sdk to produce an operator for the IBM Spectrum Scale CSI driver.
• Managed certification and validation of the operator for public releases.

Technology:

• OpenShift, Kubernetes, Docker
• Go, Python, Bash, Ansible
• RHEL
• Git, Zenhub, ReadTheDocs

Developer - Full Stack

One aspect of this position is to contribute to ongoing projects as a developer:

• Development of Python code samples and use cases for end user evaluation and usage.
• API developer working in a combination of C, C++ and bash (for meta programming).
  • APIs are designed to provide an interface to a postgresql database and remote nodes.
• Worked on standardizing development processes in internal organization.
• Implemented a Big Data Solution end to end for the CORAL project to aggregate data from over 5000 nodes.

Technology:

• C++, C, Python, Go (limited), Bash, Perl
• Power8, Power9
• RHEL, PoweKVM
• Git, Zenhub, ReadTheDocs
• ELK Stack
• Docker, Microservice development (Limited)

A portion of my work is visible on github with contributions to the following repositories:

• IBM CAST
  • IBM CAST Fork
• CAST ReadTheDocs
• xCAT

System Administrator

Acting as a system administrator to several development clusters of x86 (less after 2017) and Power systems. Tasks include, but are not limited to:

• Bring up of nodes (includes determining where the node should be physically installed, networking configuration and talking with support on the raised floor to ensure this happens in a timely manner).
• Managing and repairing package installs for users.
• Troubleshooting and resolving issues for users.
• Learning how to interact with and maintain early user hardware not currently on the market.
• Documentation of bring up procedures for customers and fellow administrators.

Tools:

• Log Analysis, GPFS, Logstash, Hadoop

Additionally, I have developed new tools to better facilitate my job as a system administrator through use of ksh, bash, awk, sed, python and java programming (depending on which language is best suited for the job).

Status : Complete

Team : John Dunham

Tools : Unity3d, C#

Platform : PC

Designed and implemented for my AI in game environments course JohnGen is a terrain generator that leverages Unity3d's built in terrain system. The terrain generator was created over the course of one month, utilizing a variety of noise generation, combination and optimization techniques.

When the player begins to play level they are dropped into the center of the currently rendered map. The map in question consists of 49 unique unity terrain objects tiled seven wide by seven deep measuring in at 400 by 400 units a piece. As the player navigates the map these tiles are reused and shifted in an effort to reduce garbage collection calls and general memory usage. Seven terrain objects at 400 units was selected as I found it hid the "pop in" effect well when a bit of fog was added to the scene to emulate atmospheric conditions.

In terms of generating the terrain I employed two algorithms: Simplex Noise and Diamond Square. Simplex Noise was initially selected for its ability to perform higher dimensional noise generation, however, I quickly found this was out of the scope for the project so I abandoned this approach in relatively short order. Simplex Noise remained after this realization chiefly because I had gotten it working with my terrain system. Simplex Noise is the primary noise function for most aspects of this environment.

Diamond Square was selected for the interesting patterns it created and its speed, which didn't slow the runtime to a crawl like voronoi. That being said getting it to tile with simplex took some doing (as the two are inherently not tileable out of the box with one another). I found a workaround in ensuring that edges were deterministically similar to their neighbors with the Midpoint Displacement algorithm. It must be noted that this produces ridges (a known drawback to Diamond Square).

For terrain the two noise algorithms were averaged with a weight towards Simplex Noise as I preferred the rolling hills it produced to Diamond Square's ragged mountain ranges. Not content with the terrain alone I added a somewhat faked biome system modeled after a Whittaker Diagram: Biomes could be hot or cold based on a simplex driven temperature and could exist somewhere on the scale of ocean to mountain based on a simplex driven humidity value. Hot/cold would drop a snow texture on the splat if it were cold and the humidity would directly affect the combination for the height map.

To finish it all out I scattered trees, dropped in a water table and added fog ultimately to make what I consider an awesome environment.

• Employed a variety of noise generation techniques to create interesting terrain and environments.
• Leveraged Unity3d's built in terrain objects.
• Learned how to use coroutines in a unity context.

Status : Complete

Team : John Dunham, Nicholas Buonarota, Matt Mundell, Alex Herdzik

Tools : C++, Unreal Engine

Platform : PC

A multiplayer First Person Shooter developed in Unreal Engine 4.5. Crystalline, while being largely an FPS, incorporates elements of MOBA and RTS games to enhance gameplay with strategic choices.

I acted as the Chief Gameplay Engineer, handled networking, ui and variety of other "glue tasks" to ensure the product shipped on time.

• Weapon Design and Development
• Game Mode Design
• Technical Research (engines, physics, etc.)
• Networking
• GUI
• General Programming.

Status : Complete

Team : John Dunham, Bryan O Neil, Matt Mundell, Bob Lumsden, Will Hagen

Tools : C++, DirectX 11

Platform : PC

Alpha was a semester long project written in C++ using the DirectX11 graphics API. As a game Alpha focused more on the experience and less on mechanics. The player assumed the role of a wolf, exploring a small box canyon.

While the game looks nice, it's not a very game like experience. This is primarily due to the fact that we became bogged down in the graphical elements as opposed to the gameplay design and implementation. That being said the project was a success in that it exposed myself and my team to game engine and graphics programming.

• Terrain Rendering
• User Controls
• Git repo management

Status : Complete

Team : John Dunham

Tools : JavaScript

Platform : HTML5 Canvas

A rough prototype that leverages webkit audio and waveform processing to create a platformer that procedurally generates the game world from user supplied music. In its current form the game is more or less a tech demo, a proof of concept.

At present the player is able to make the character jump by clicking their mouse and play music that is dragged onto the web page, which is then visualized with the Fast Fourier Transform data produced by the webkit audio. The blue line represents the instant energy and the reddish bars represent the values present in the FFT frequency bins.

The top portion of the screen represents the processed information extracted from audio file. Local is the instant energy of the waveform, Average is the moving average energy, Time represents the fractal dimension of the domain data of the FFT, aFreq is the fractal dimension of the average frequency, Freq is the fractal dimension of the current batch of frequencies and Beat is an attempt at beat detection using the local and average energies of the waveform.

At the time of writing this idea is still being ironed out and I'm still attempting to determine exactly how to handle the generation algorithm.

• Leverage the HTML5 webkit audio processing tools.
• Implemented a basic sprite animator and loader.
• Explored audio processing techniques.

Status : Complete

Team : John Dunham

Tools : Objective-C, Tiled, Texture packer, Box2d, Cocos-2d

Platform : iOS

This was the first game I ever worked on inspired by the Mega Man rock group The Protomen. It was an attempt to make a Mega Man styled game that recreated the second half of The Protomen's Act II: The Father of Death. Gameplay was rather simple, emulating Mega Man's platforming, with the player's primary goal being to reach the golden gear at the end of each level. The player also had the ability to fire energy balls that would destroy enemies in one hit.

I placed a fair amount of emphasis on the GUI elements: the controls and menu system. The control system was inspired by other iOS games at the time, focusing on player usability and responsiveness. The menu system had a similar focus on responsiveness and ease of use, although in retrospect certain elements and semiotics should have been better clarified.

In total the game was my first attempt at anything in this field and I still have a fair amount of pride for it, even if I wish I had worked with some teammates to make an all-around better experience.

• Sprite and Asset creation.
• Designed and implemented a responsive controller for a touch environment.
• Level design and implementation.
• Ladders and fall through platforms.
• Implemented a camera system that prevented the player's hands from blocking visibility of the game world.

Status : Complete

Team : John Dunham, Matt Mundell, Ruiwei Bu, Leigh Raze

Tools : Unity3d, C#

Platform : PC

Perhaps my favorite prototype to date, this game is an attempt at creating an escort quest fun through the use of time travel. The player is a chrononaut, something like The Doctor, who has entered a solar system with the intent to stabilize its dying Sun with a fleet of "sun stabilizing ships", protecting them from a myriad of obstacles. To achieve their goal, the player must employ time travel to stop and/or reverse time to ensure their convoy reaches the target.

The game was amazingly fun to work on and it was actually quite well scoped for the time frame that we completed it in (one week). At the time of writing the AI still requires some polish and the chasing behaviors still need a fair share of tweaks, but the hosted prototype more than adequately outlines the rough concept.

• GUI
• Controls
• Time travel tweaking
• Refined AI behaviors (enemy and convoy)/finite state machines.
• General programmatic polishing

Status : Complete

Team : John Dunham

Tools : Tiled, JavaScript

Platform : HTML5 Canvas

This arena style combat game is an exercise in grey box prototyping, with the combat system being the subject of the prototype. Initially the game was simple: two circles in a white square with the ability to move, attack, dash and shield. The three combat abilities (dashing, attacking and shielding) were designed to be roughly balanced using a balance table that I made for the project. Additionally, the prototype features five levels that emphasize different arena layouts. Each layout attempts to express the dash bounce mechanic through paths emphasized with the green "bounce pads".

HTML5 was chosen as a platform due to the fact that I had some experience with it. My goal was to enhance my knowledge of the platform and try some things I hadn't done with the tool in the past.

• Implemented a collision system that was capable of simulating bounces.
• Wrote level loader for the HTML5 canvas using the Tiled map editor.
• Balanced the combat system.

Status : Complete

Team : John Dunham

Tools : JavaScript

Platform : HTML5 Canvas

My first foray into HTML5 game development, which I threw together in about a day, based off of the classic Tron light cycle game. The gameplay and AI is extremely simple and the game supports up to two human players and four AI players. It should be noted that, at the time of writing, the AI is little more than a random number generator with limited knowledge of the game world. As a result the AI will frequently turn the same direction if the starting conditions are the same (it does make some cool designs however).

• Used HTML5 Canvas to draw the game world.
• Controls
• Basic AI

Status : Complete

Team : John Dunham

Tools : JavaScript

Platform : HTML5 Canvas

An operating system written in JavaScript built upon a virtual 6502.

I created this for a senior year Operating Systems course in my at Marist College. The Virtual 6502 and a bare-bones console were supplied to us, all scheduling, virtual 6502 instructions, memory and storage was written by me.

• UI
• Scheduling (round robin, FCFS, and priority)
• File System
• Memory

Status : Complete

Team : John Dunham

Tools : JavaScript

Platform : HTML5

Gene Runner is a genetic "walk-cycle" generator entirely written in HTML5 and JavaScript with Box2d.js.

A detailed description of the algorithm and process is linked above.

• Designed and implemented a system to draw bones using box2d-js and HTML5
• Designed and implemented a genome for joint movement

Status : Complete

Team : John Dunham, Ruiwei Bu, Benjamin Snyder, Anush Raman

Tools : Unity3d, C#

Platform : PC, Oculus Rift

Created with the prompt to create a prototype based on a public domain work, with our group electing to create a horror game based on the works of H.P. Lovecraft. T he gameplay is roughly inspired by *Gone Home, but with an attempt to place horror at the forefront. The player must wander a house in search of several books that unveil the games story while progressively going insane.

This game was definitely over scoped for the time frame we had allotted to complete the project, but it served as a valuable lesson in how to best scope a prototype (read: what not to do). This game also featured the Oculus Rift in one version, but due to merge issues this version was rendered unplayable.

• Level layout (originally designed for non-euclidean space, a lost feature).
• Teleportation Mechanic.
• Oculus Rift Integration (dropped due to lack of time).

Status : Complete

Team : John Dunham

Tools : C++, DirectX 11

Platform : PC

Upon finishing JohnGen I was somewhat disappointed in the lack of variety in the actual terrain. Most of the terrain was mountains and lakes, which is fine for fjords, but not terribly varied. Additionally, I wanted to play with GPGPU technologies in the form of DirectX 11's Compute Shaders.

The choice to move to DirectX 11 was driven by the fact that I was working on Alpha and had taken on the role of Terrain programmer. As a result I had a test bed to play with DirectX 11's compute shaders.

To generate the noise for the terrain features I used a two pass approach. The first defined the overall topography of the terrain (e.g. mountains, plains, oceans) and the second defined local detail, making the terrain surface look interesting. Both passes used simplex noise to generate the features in a compute shader which was stored to a texture on the GPU. Simplex noise was used as I had familiarity with it, and based on my tests and experiments I found it to produce the most interesting noise.

While I found JohnGen 2.0 to be a success it did have some flaws. It was less interesting to look at when compared to JohnGen. Not because of the terrain shape, but rather due to the fact that I didn't have a system in place for terrain details such as trees. Additionally, the rendering fell apart at a distance, something that was a given in Unity. Finally, while it looks good JohnGen 2.0 did not have collision detection and wasn't designed to interact with a physics engine.

If I were to revisit JohnGen 2.0 I would likely focus my efforts on three areas: render distances, collision detection, and less naive tessellation.

• Wrote Compute Shaders to perform simplex noise.
• Wrote Tessellation Shaders for actual rendering.
• Configured noise input to generate "interesting" features and variation

Status : Complete

Team : John Dunham

Tools : C++, Tiled output

Platform : iOS, Windows

The fruits of an independent study this is an XML specified procedural generation tool. Originally this was designed to work with Breaking Out and create a traversable game map. The underlying algorithm for Maptals is the Drunkard's walk, as I found it was the simplest manner in which to ensure that the map was at least theoretically traversable. The XML specification is used to absolutely ensure that the game world would be traversable, as it was programmer defined. With the XML the Algorithm produces a numeric array that represents a tile map for an associated tile sheet. Additionally, any possible objects are be generated and kept track of. After creating the map it is then converted to the tiled map file type for easy engine consumption.

Maptals has been tested in Breaking Out and was capable of making game worlds measuring in at least 6 by 500 hundred tiles in a matter of seconds.

• Implemented a directed variation of the Drunkard's Walk.
• Specified an XML format for map creation.
• Wrote a Tiled .tmx file type exporter.

Status : Complete

Team : John Dunham, Nicholas Buonarota, Bryan O Neil, Anush Raman

Tools : Unity3d, C#

Platform : Microsoft Pixelsense

This prototype was created with the goal of helping rehabilitate people undergoing physical therapy. The setting is a picturesque Koi Pond with soft, calming music and the sound of a small waterfall. All of these components seek to calm the player as they undergo what is likely a very stressful time in their life. The player is given three tools (a skimmer, fish food and a watering can)that they can switch between by drawing either a circle or another shape set by
modifiable broad gesture recognition (the recognition code was modified from the (unity wiki)[http://wiki.unity3d.com/index.php?title=Gesture_Recognizer]). We offer no explanation for how to use any of the tools, as the prototype focuses more on being a toy than an explicit game.

The game was targeted for the Microsoft Pixelsense to take advantage of the large touch area, which was of great value for the sake of rehabilitation. Touch was "faked" using mouse clicks as my team and I had limited access to devices that could develop multi-touch for the Pixelsense.

• Level design (polished by Nick)
• GUI and menu systems
• Gesture recognition tweaking
• Sound effects (music was found by Bryan)
• General "glue" work

Status : Complete

Team : John Dunham, Samuel Trapp, Leigh Raze, Nicholas Buonarota, Praveen Nagarajan

Tools : Wiki

Platform : PC

Web of Lives was designed as a rougue-like game that was targeted for mobile and web platforms. The core of the game was the divorce of the player from the character. Upon character death the character would transfer ownership from one player to another through a cloud service.

• Character Creation
• Monsters (limited)
• Items (everything but the images)
• Procedural Generation
• Labyrinths (specified what a room specification should look like)
• Main Menu design