Projects

Pentiment

I returned to Obsidian in order to be the lead programmer for Pentiment. I was on a smaller team at Obsidian (fewer than 15 people) with a total of 2 programers for the duration of the project. I oversaw the game from a very basic initial proof of concept and learned the tooling support and oversaw the engineering through release and post-release support over a period of 3.5 years.

I inherited a proof of concept product that had a few systems implemented in it as well as legacy support code from the Pillars of Eternity projects. The legacy code was primarily the tooling support for Obsidian’s proprietary Obsidian Tools application that is used to manage/modify data such as conversations, strings/localization, save/load, quests and more. In order to maintain this support I took that codebase over and supported the game-side of that integration. From the proof of concept I started developing workflows for the other members of the team leveraging the Unity3D engine as much as possible. This included using TextMesh Pro, Timeline, and worked with animation on integrating maintaining functionality with the Spine 2D animation library.

Major points of focus were the text effects and font rendering. I spent multiple months of work to develop the shader animation and effects to make sure that we were getting to targets that satisfied the director’s needs. This included developing a new way to render the fonts and reveal the letters as if they were being written out by hand. This included a stroke mask texture that revealed the text, showing that the ink was wet, finally absorbed by the paper and drying. The text system also needed to support a printed font system that came with its own animation sequence that included plating of lettering (upside down like it would historically be done) stamping the text into the paper as well as ink effects like voids and overfills on the lettering.

Another aspect that was utilized heavily was rendering mini scenes to texture in order for them to be mapped to a 3D mesh and then developing the flow that would transition from the 2D game into the 3D journal. Each page of the journal or 3D books were rendered to texture in order to ensure that the texture would be appropriately mapped to a 3D object. I also stubbed out the process of how the transitions would work between these spaces.

I also development various other data-driven systems that the designers would be able to utilize in the game. This included a cutscene system that relied heavily on Unity’s timeline. A weather system that was driven by a timing schedule. Character waypoint, schedules, global weather systems, scene setup navigation, and more. I also developed a 2D tile streaming system that utilized streaming mipmaps in order to reduce load times as much as possible between navigating between environments. I also worked closely with designers to make sure that any needed new systems and workflows were promptly added in order to understand how the systems were being utilized.

MobilityWare Solitaire Products (2017-2019 iOS and Android)

MobilityWare is known for its casual free-to-play titles that appeal to a wide audience. The solitaire team was responsible for some of the largest mobile titles in the industry with millions of active users. The solitaire products are the financial core of the company with ad-driven revenue. Extreme care was taken to make sure that these products were treated well. I was hired onto the Solitaire card suite team to help the team transition their solitaire line of native iOS/Android titles over to Unity.

My responsibility on the team was to help provide Unity knowledge and experience to the team transitioning from a native workflow into a Unity-driven one. I worked with other engineers in a agile environment on a shared code library that was shared between multiple Unity projects. I also assisted with providing training to artists and others in regards to Unity asset management. I assisted with the release of Crown Solitaire as well as the update and maintenance of Pyramid. I developed systems for visual customization, localization, and general optimization. I also assisted with engineering efforts in porting features and functionality from the native apps into Unity for use across the entire suite of solitaire products.

Throughout my time I have also updated and maintained a codebase that was used for over a 8 products. Including a refactor of the codebase to help future titles that may not be as closely tied to the previous titles. This included engineering discussion meetings and approvals. I also helped work on the client-side replacement from our cross promo solution that was driven completely by in-house servers.

Tyranny (2016 Windows, Mac, Linux)
Pillars of Eternity (2015 Windows, Mac, Linux)

Pillars of Eternity was my first big production game that I worked on at Obsidian Entertainment. The team size was approximately 25 people and I started work on the project very late in the development (2 months before shipping a 3-year developed game). My primary responsibility was to get up to speed as quickly as possible and try to alleviate some of the bugs of the other programmers. I worked closely with the existing programmers to learn the large code base and Obsidian’s engineering and development culture. I worked primarily with the UI programmer and worked with their custom version of NGUI. I worked for approximately 4 months on the Eternity team (prior to the first White March expansion). In that time, I added various functionality and features including Area Loot, refactored the crafting UI, and added a news system to the game. In my short time on the project, I worked on the main menu news system, redesign of the crafting UI, and some small scripted interaction shader tweaks. I also worked with their lead artist to find and update any temporary art still in the game late in beta and updated art to a more final look.

After Pillars shipped, I was moved to the Tyranny team where I took up the role of helping a shape a new game that used the inherited engine from Pillars. My primarily roles were to improve the UI workflow, ensure platform compatibility across our three main platforms, as well as be the first line of fixing graphics/shader related bugs and issues. I spent the next 1.5 years working on Tyranny. Team size fluctuated but at the highest was approximately the same size as Pillars. My main priority was to help transition and add functionality to the UI to make it a better UI experience. While a lot of the same functionality was reused from Eternity, I consolidated UI atlases and improved UI workflows. I also worked on or touched most the UI in the main game and worked closely with a UI artist to improve the UX of the game. I also focused on world map including developing systems that designers could use to edit the game map without programmer intervention.

t_mainmenut_ingame t_loott_conversationt_fieldinteraction_2t_talentst_storet_reputationt_worldmap t_combat_2poe_newspoe_autoloot

XCOM: The Board Game (2014 Android, iOS, Standalone)

My last project at Fantasy Flight Games was to write the companion application to the XCOM board game that FFG was developing and publishing. During the production of the board game, a temporary app was prototyped by another developer in the company using Unity3D and the IMGUI. The prototype was intended to be redone and I rewrote the app to get a production version ready. I kept a lot of the foundational logic the same, but worked with a creative director to improve the look and usability. I was the sole programmer on this project, and worked with all parties (both board game and software design) to meet requirements. The app included an xml-based help guide allowing quick changes by non-programmers. XML elements would be created at runtime and reused in a basic help page. Supported elements were things like titles, text blocks, and images. The app also supported basic localization support. The project took approx. 2 months of time to reach the late beta stage seen below.

The app is a required to play XCOM: The Board Game. The app is required because it contains game rules and manages gameplay. The game is broken up into 2 phases. In the timed phase, players receive actions from the app that must be completed within a certain amount of time. This phase sets up the game and requires players to perform actions and make decisions within a constrained period of time. The second phase is the resolution phase. This phase reminds players how, and in what order, they can resolve the state of the board. This phase is when actions performed during the timed phase would resolve using dice rolls and card use. After the resolution phase is complete, the players input information from the current state of the board into the app. This information affects the generation of the next round of timed phase events. These two phases repeat until the game is over.

XCOM_Main XCOM_Help3 XCOM_Help2 XCOM_StartTimed XCOM_Timed2 XCOM_Help XCOM_Timed XCOM_Resolution XCOM_ContinentPanic

BattleLore: Command (2014 Android and iOS)

BattleLore: Command was the largest project I worked on while at FFG. The game was prototyped by me and another programmer in approximately 5 months. After the prototyping stage, we hired on a new team that was created to help complete the project. The team consisted of 2 programmers, 1 junior programmer, 1 environment artist, creative director, and external contract artists. The project took approximately 16 months from initial pitch to final deliverable in November 2014 with approx. 6 months dedicated to prototyping. The app was made in the Unity3D engine using features such as lightmapping, mecanim, and the shuriken particle engine. I was primarily responsible for the UI, campaign, and gameplay programming. I also assisted with camera movement and multiplayer. The app was released on iOS and Android platforms.

BattleLore: Command is a digital adaptation of the BattleLore: Second Edition strategy board game. The game is a turn-based strategy game where you play in the campaign as the Daqan lords as you fight against the Uthuk barbarians. Each player’s turn is broken down into 4 phases that allow the user to move and attack with their units to do damage to their opponent and achieve mission objectives. The app has more than a dozen unique campaign missions, as well as skirmish maps. The gameplay in the digital version is streamlined from the board game. This allows players to play out their whole turn without choices or interruptions. This allows for a more engaging multiplayer experience. The game includes fully playable Daqan and Uthuk sides. Each side contains unique graphics, units, and powers.

BattleLore_Title IMG_0054 IMG_0053 BL_Campaign IMG_0056 IMG_0062  IMG_0066 BL_tutorial_Lore Screen Shot 2014-12-09 at 9.39.03 PM Screen Shot 2014-12-09 at 9.39.53 PM IMG_0067 Screen Shot 2014-12-09 at 9.53.24 PM

Star Wars Dice (2012 Android and iOS)

Star Wars: Dice was an app developed to support Fantasy Flight Games’ Star Wars products including board games, miniature games, and tabletop RPG games. I was the primary programmer on this project. The app was developed in the Unity3D engine utilizing the NGUI UI framework. The project’s timeline was approximately 3 months. I worked with the Unity3D physics engine to resolve dice rolls and prevent the dice from getting stuck on edges and on each other. The app was released on iOS and Android.

The app features the ability to add/remove dice, enable or disable certain dice types, save presets, change backgrounds, sound effects, and tabulate results using game rule cancellation. The app also includes a unique radial menu interface that allowed users to quickly interact with many different features quickly and easily.

SWD_Main SWD_ActiveDice SWD_RPGRoll SWD_RadialMenu SWD_LeiaRoll SWD_Preset SWD_PresetSave SWD_Settings

Elder Sign: Omens (2011-2013 Android, iOS, and Steam)

Elder Sign: Omens was my second project at FFG and was a conversion of the Elder Sign dice game. I continued to build my experience with Unity3D engine using the EZ GUI/SM2. The application was originally designed, prototyped, and released in an extremely ambitious 6-month time cycle that I participated in from the beginning. After the success of the app, we continued to support the application with expansion content. During my time at FFG we released 3 expansions. Each expansion included new adventures, monsters, investigators, cutscenes, and adventures. The app was released initially on iOS, Android, and later Steam.

Elder Sign: Omens is a digital conversion of the tabletop dice game Elder Sign. Players use a set of dice to complete adventures. Each die side has a symbol that will correspond to task requirements that needs to be fulfilled. All symbols on a task must be fulfilled at the same time and only 1 task may be completed per roll. After completion of all tasks the adventure is complete and you earn the rewards. If you run out of dice, you fail the adventure and must suffer the penalties. You win the game by acquiring enough Elder Sign rewards. You lose the game when all your investigators are incapacitated or if the Ancient One’s doom track is filled. Investigators have inventory and abilities that modify rules to improve your chances at completing tasks.

ESO_MainMenu ESO_PickAncientOne ESO_PickInvestigators ESO_MapEntrance ESO_AdventureIntro ESO_Adventure ESO_Clue ESO_Ocean ESO_IthaquaMap ESO_Success

Hey, That’s My Fish! (2011 Android and iOS)

Hey, That’s My Fish! was my first project at Fantasy Flight Games. I came into the project about halfway through production. The prototype in Unity3D was done and functional when I started work on it. No UI or AI was final and I was immediately tasked with learning and updating UI using the EZ GUI plugin. I also worked on implementing a basic AI for the game. This was my first production experience with the Unity engine and I learned a lot about how best to work in Unity and to quickly prototype ideas. I worked for about 3 months on UI, gameplay, and AI before releasing the app. Post release, I also handled user technical support and bug fixes and releases. The app was released on iOS and Android platforms.

The game is based on the board game called Hey, That’s My Fish!. The game involves players placing their penguins on a randomized tile board. Players take turns moving one of their penguins from one tile to another. Each tile is worth 1-3 points (represented by the number of fish on the tile). When a penguin becomes stuck without any places to move, the penguin is removed from the board. The player with the highest score wins. The digital version includes achievements, multiple level layouts, and AI.

HTMF_MainMenu HTMF_SetupGame HTMF_Layout HTMF_GreenMove HTMF_Score HTMF_RedMove HTMF_Orca HTMF_HowToPlay

Jam Party (2010 Windows)

JamParty was my first professional programming experience for a company called Zivix. Zivix was a startup focused on creating music-based software and hardware at the time. We released 2 products called JamParty while I was there. My primary responsibility was to work in the Scaleform UI. I learned both Flash and ActionScript and integrated the UI into the Gamebryo C++ engine. I worked in a team of around 5 people of various disciplines. Towards the end of the project I became responsible for C++ programming as well. Within the Gamebryo C++ engine I implemented gameplay, profiles/achievements, and maintained 3D HUD functionality. During my time at Zivix, JamParty was released on Windows PC.

The software application is meant to act as a loop machine that you can control with your Guitar Hero/Rock Band controller. You have banks (drums, bass, vocals, etc.) and each bank has 5 music loops inside. The loops are in sync with each other. This allows users with lower musical skill to be able to enable and disable tracks easily and in time with each other. The gameplay is time-based and players would gain bonus if they turned on loops in time with the beat. Users have profiles that record their total points earned while they play. Points unlock new venues and songs. The venues and HUD react to the music volume and energy giving a visual interpretation of the music that you are creating. Players can also record and export songs to an MP3 that could then be shared online.

JP_MainMenu JP_Profile JP_SongSelect JP_BronzeMedal JP_BanksetChange JP_Underwater JP_Export JP_ElectricTree JP_Cubes2JP_ElectricLandscape

Game Buddy (2009 iOS)

Built in my spare time over a period of a couple months, GameBuddy was meant as a project to teach myself the iPhone SDK and Objective-C. This app also taught me how to release apps on the App store. This tool contained 4 different views, a coin flipper, sand timer, scorecard, and dice roller. The most impressive view was the dice roller. The dice roller allowed players to add/edit the standard RPG dice types (D4, D6, D8, D12, D20) and simulate rolls with up to 10 dice in a 3D environment. Users could also save/load die sets and change the color of the dice. I used fixed-function OpenGL ES programming to get the 3D dice rendering. I also implemented a basic physics simulation that would make the dice interact with each other and the edges of the screen. The app also included a basic UIView-based scorecard system that would allow users to quickly keep score in their favorite tabletop games.

GB_Main GB_DiceRoll GB_DiceList GB_NewDie GB_Scorecard GB_SandTimer