# Accomplishments of Brian Ernst

## Preface:

This is my own **personal** document for tracking what I've worked on, it is word vomit. 

Some things may be a little inaccurate, as I didn't vet everything thoroughly, and I am working from fallible human memory afterall. 

Some of these notes were written many years later, or I just didn't actively track everything I worked on, so there are things I've worked on that I've forgotten about and didn't get to note here.

## Professional Work

### WB Games

[**In-Progress**]

- Audit Unreal plugin from Rocksteady Games for CGT to take over - RockDevTools
  - Solved database connection string bug when working with a Developer edition of the database.
  - Patched in local file SQLite database that would work out of the box without setup
  - Patched plugin bugs with UE5.
  - Been maintaining and updating it to work with newer engine versions.
- Working on WB Lyra game sample integrating WB products into the game showing game teams how they can put them to use
  - Setup initial automatic UUID login against Hydra backend for testing online
  - Hooked up legal document serving Harbinger which fetches EULA, Terms of Service, etc.
  - Hooked up CrashPipeline and updated Hydra env to feed crashes into
  - WBLogin
    - Created WBLogin screen supporting different login methods connecting to two different WB backends simultaneously
    - I was told this UI I setup was top tier to look at and interact with, and going forward future widgets shouldn't need to be as polished (b/c sample game)
    - I made sure my login screen matched the Lyra UI theming relatively closely
    - Hooked up detailed login failure conditions
    - Hooked up maintenance mode support to relay why login failed in that scenario
  - Hooked up WB online Calendar backend that has data driven timespan to read events for, configured polling, and triggering delegates for Calendar event start and stops that happen while game was running.
  - Setup frontend carousel promotions tile that opens to fullscreen carousel, upon closing updates the smaller version back to the one the player was on

### S6

- Worked on many gameplay systems
  - Ability System (S6, not Unreal's GAS)
    - This predated our use of GAS. I wrote and maintained our entire ability system. It was  data driven rather than BP driven.
      - Design goals made it seem like we needed a custom ability system, when it turns out we should have made engineering first decisions rather than design first. We could have made them work in GAS anyway.
    - I created all Abilities using this system I wrote.
    - When we pivoted to GAS some people helped with creating new abilities like Tilling & Watering.
    - We ended up realizing this system wasn't as flexible as GAS and was more daunting to carry to a AAA polish with the time we had left and features we needed to support.
  - Buff System
    - Created our Buff Components systems.
    - Hasn't really needed to be touched since we created it.
  - Crafting
    - I didn't write the *initial* Crafter prototype system, but I've primarily supported crafters during the prototype phase and past launch.
    - I did make Autocrafters though.
    - After Palia shipped some people started lightly modifying it.
  - Compass UI
    - Wrote the entire Compass UI myself from scratch. 
      - I've always wanted to write a Compass UI, and I finally got my chance!!
    - There were different ways we could take the UI, and I opted  to allow the markers to be independent wigets for maximum flexibility on extending the Compass.
    - We shipped the prototype system that was built on UMG, definitely not perfect by any means. 
      - A more optimized version would involve Slate directly. With all of the performance enhancements we had to do to ship on Switch, while Compass could use work, it was not the main outliers we had to deal with; it performed well enough to ship on Switch basically as-is if I recall correctly!
  - Cooking (Complex Crafting)
    - Co-created the complex cooking system on top of Crafting systems.
    - Lots of UI work; I did all of the Cooking Minigame UI and animations.
  - Equipper (player tools)
    - I didn't create the initial equipper, but I evolved it.
    - Equipper ended up supporting temporary equips during the cooking minigame, and temporary tools during the Crafting animation.
  - Gardening
    - Wrote initial tilling and watering functionality and abilities (pre-GAS)
    - Wrote custom dynamic tilling shader mask to clear the dirt texture
      - Rectangular shaped mask, could change the (X,Y) scale to account for different level tills (lower level smaller mask, higher level larger mask), and it rotated in-place to support clearing based on player's world relative rotation and driving relatively accurate till clearing
    - I did a lot of work supporting gardening, hard to remember everything.
    - I created the companion buff effects where neighboring garden plants boost each other
    - Setup the fertilizer system, including combining fertilizer with companion buffs effects
    - Lots of passes on garden optimization
    - Created async render task to read pixels from the dirt texture so we could figure out if player tilled 90% of the mask
      - If the texture wasn't low pixel, we could have read a lower MIP level to iterate over
      - Alternatively instead of reading from the gpu texture, we could have attempted to calculate and clear a small array that tried to match the gpu texture
        - but this would have been tricky to get right, since it would duplicate shader behavior and try to match up
      - Reading the gpu textures was stalling the game on certain platforms/setups, and making the async one significantly improved things, notably on Nintendo Switch
  - Gatherables
    - Gatherable component and how it's setup on gatherable things in the main world, and on your housing plot (placed things).
  - Interactables
    - I didn't write the initial interactable prototype system, but I evolved the heck out of it.
    - There was a bug when pressing F multiple times to gather something where technically by the time the server processed there would be nothing to gather since we only needed to process the first input, so code triggered an error saying the Gather failed. I evolved our setup so we could not trigger errors for successive inputs and wait for a server response, and batch certain inputs as being part of the same intended action; we were able to put this to use in multiple areas, which devs extended years later for housing plot purposes.
    - Setup actors to support multiple interact points so player could interact with different parts of an actor or so you could have multiplayer interaction with a single actor (like people sitting around a table or operating different parts of a machine), player facing direction if any required, player distance required.
    - Added the ability for players to "lock" to an Interactable and claim an exclusive interaction point (Crafters) and track the context for what system is handling the lock, and ability to support lock passing if desired depending on changing context.
    - A late evolution included getting Input contexts from the Interactable so we could know what the Interactor could do with that actor.
    - A late evolution included being able to async preload assets or animation when a player started interacting with an Interactable that they might be using.
    - Etc.
  - Inventory
    - Overall iteration on adding features and improving it and fixing bugs, also hardening permissions to support Autocrafter using it's own inventory bags.
    - But also making it a base component so other things could use it, and Player Inventory was a child class of Inventory.
  - Loot
    - I created the foundation for most of our looting systems. From loot generated per vital hit, when vitals are completely decimated, and to the loot weighting and random roll. We ended up doing *some* iteration to bring it to where it is today.
    - Fishing loot used its own system, but everywhere else uses the Loot systems that I setup.
      - I added a templated loot weight roll function that can be used by any system, rather than having to be hardcoded like Fishing.
  - Player Skills
    - Fishing
      - Fishing Rod ability.
    - Gardening
      - I created the Tilling and Watering functionality, tilling mask and clearing the patch all from scratch, from the custom shader to the calculations to match about where the till head is to where we should clear.
      - Did some touching up on the Tilling & Watering abilities.
    - Chopping
      - Lumberjacking
      - Mining
  - Recipe Inventory
    - Created our recipe inventory system. Recipes are unlocked by quests.
    - Hasn't really needed to be touched since we created it.
  - Storage Inventory

- ### Some Unreal systems I've worked with

  - #### Animation

    - I set the foundation for our character animation since we didn't have a tech artist to handle that for a couple years. As far as I know, much of what I setup is still there.
    - **Animation Blueprints**
      - **Anim Graph**
        - Lays out the different layers via state machines
        - Base locomotion, idle/walking and jumping.
        - Lower body vs upper body animation mixing.
        - Action sets, for anything not montage driven.
      - **Anim Notifies**
        - Animation cancelling, allowing movement/other actions before entire outro is finished
        - Anim Notify State
          - Safe way to indicate something should be equipped then be unequipped within an animation, like coming up to a crafter station and using a hammer, then detaching the hammer.
      - **Blendspaces**
        - 1D and 2D.
        - 1D Fishing aim blendspace (left to right side).
        - 2D Character speed and direction.
        - Back in the day I also had character left/right turn leans blended into the character
      - **Event Graph**
        - Driving the Anim Graph, via grabbing data from actors and components,  even doing calculations, and caching to variables for Anim Graph to use.
    - **Montages**
      - Montage sections, looping, blending out
      - Making sure if animation changed in length it didn't break montages; ended up finding setting to allow anim notifies to be relative to an animation and automatically be moved.
    - Worked with Jamie to iterate on player animations, fish minigame animations, and fishing rod animation.
    - **Worked on all the Complex Cooking animations, including setting up the networked prop handling, food in pan flipping, etc.**
  
  - #### Asset Manager

    - Iterating primary assets for validating, automated tests, populating cheat menus with different available objects (fish, items, etc.), etc.
    - Async loading animation/abilities/IMC/UI when you near vicinity of an interactable object.
      - We didn't get to finish that entire pass, but it was "mindblowing" I didn't think of  that before; was a big polish improvement to not have to stall the game to wait to load things.
  
  - #### Console Commands/Variables

    - I set the standard for our studio that we should use these as the low level game interface to drive cheats (as allowed by or through Cheat Manager of course), as feature flags, and as a way to test/tweak/tune features at run-time (outside of data driven testing, since last I checked Unreal doesn't support changing data assets at run-time).
  
  - #### Controller Component / Input

    - Enhanced Input
      - Input Actions (IA) and Input Mapping Contexts (IMC)
      - Palia has some really awkward bad uses of IMCs around in-world interactables.
        - I moved IMC handling away from WBP and into the Player's Interactor Component
    - Player Controller
      - Drove pre-Enhanced Input/legacy controls, movement, sprint modes, Interactor, equipped tools, etc.
  
  - #### Data Assets

    - We started using Data Assets for things  that quickly became bottlenecks and contained a lot of different kinds of data that didn't make sense in a Data Table.
    - Items became their own Data Asses, Quests, Fish Minigame Configs, gameplay feature global configs, etc.
  
  - #### Data Tables

    - Good for tabular data like you'd find in excel.
    - Easily abused with complex data that doesn't fit cleanly into an exported table.
      - Because of bottle neck issues, and us clearing abusing tables, we realized how powerful Data Assets are, and pivoted to those as much as possible for non-tabular data.
    - Ended up realizing tables became a bottle neck, started using composite data tables.
    - Don't use FName row names directly, use Data Table Row Handles; we made that mistake early on, and didn't get a chance afaik to fix up every case.
  
  - #### Gameplay Tags

    - As soon as I found out we could use FGameplayTags instead of manually typed FNames I started switching to them immediately.
  
  - #### Gameplay Debugger

    - I realized the power of UE's GameplayDebugger, so I set it up on our project, and did a presentation on how we could empower our whole team to help debug issues in the game, not just Engineering.
    - I created and maintained 95% of Palia's gameplay debuggers, I'm such a huge proponent of them.
  
  - #### GAS

    - Setup many Gameplay Ability System abilities for Gathering, Crafting, player tools, etc.
    - I tried to leverage base classes for reusing shared behavior and not having to rewrite or fix things up over and over again when I could do it in one place.
    - Continued to improve our PlayMontageByMapping and PlayMontageByMappingAndWaitForEvent
      - This is to make sure body + head + attachments all play the same animations in sync across the network
      - Fixing networked/sync issues
      - Made sure replaying existing montage with section worked flawlessly and seamlessly rather than trying to start a new playing animation.
      - Fixed issues with tasks left running due to uncalled events, and even server character being in the wrong state to properly process the montage, etc.
    - Created Gameplay Effects and Gameplay Cues
    - Ability System Component handling for making sure abilities were granted before they could be used, of course.
      - Aiming for async loading abilities just before they're needed.
  
  - #### Interfaces

    - For example, expanded our Interactable and Gatherable Blocker interfaces
    - Interactable was an interface for a character interacting with an Object in the world, either an Actor or Actor Component, code or BP, or even interacting with some logic on themselves if needed.
    - Gatherable Blocker interface was a way to allow anything to block something from being gathered for some reason without having to code for everything under the sun in one place in the Gatherable, which seemed messy and undesirable.
  
  - #### LOD

    - Spotting some LOD issues and raising awareness. Wrong LOD, bad LOD, or something missing from an LOD.
  
  - #### Networking

    - Replication and RPCs, oh yeah this was something I had to get very involved in.
    - Trying to keep many replicating actors in sync, double lock across two replicating actors and multiple replicating components, etc.
    - Having to develop an understanding of replication guarantees, so I wrote up a doc on it from my learnings.
    - I haven't had to do much work with our Replication Graph; the guy who wrote Unreal's Rep Graph system wrote ours once, and we haven't had to touch it too much.
  
  - #### Objects

    - Actor Components
      - Don't put lots of junk on Actor, use components liberally. Unreal handles replication well these days I think, though probably still not as cheap.
    - Actor CDO
  
  - #### Pointers

    - SoftObjectPtr, SoftClassPtr, TWeakObjectPtr
    - Palia under utilized smart pointers which caused a lot of bloat.
  
  - #### Profiling

    - Unreal Insights, I did the Switch profiling, and lots of PC client and server profiling
    - Created a guide on Switch for all of my teams features, and some guidance on how we could fix many of the issues I noticed.
  
  - #### Shaders

    - Garden tilling shader for a scalable brush sized based on the tilling level, and also rotates in-place based on the user orientation to clear the garden dirt mask.
    - Linear and radial custom progress bars; as well as custom gradient backed progress bars where the gradient defines how the bar animates from 0.0 to 1.0 progress.
    - In-place icon drop shadow to add drop shadows to all icons. Scalable drop shadow, scalable source image, shadow color & alpha, with cheap Kawase blur and blur param options.
      - In-place means the image and shadow are drawn in the same pass with the single texture, you don't need to add the shadow as a second texture.
  
  - #### Teleporting

    - Trying to do seamless inner world teleporting (no server transition), kicking the streamer to stream content for the new player location, screen fade-out to black, wait at least X time (even try to wait until the streamer is settled), fade-in from black.
    - (We didn't have time to do seamless server transitions while being in-world.)
  
  - #### UI

    - Making Item Slot handling in Inventory/Storage/Crafter as fast as possible.
      - This was years ago, so things have potentially degraded a little bit since then.
    - Worked with User Widgets and CommonUI.
    - Coming out of Palia, I was most comfortable with UMG, working with Slate near the end.
    
- Misc.
  - Bug spotting
    - I can spot certain kinds of bugs instantly that other Senior Engineers don't immediately catch
  - Sprint Modes
    - Added Palia's first accessibility feature, 3 different sprint modes so players can choose their preferred mode
  - Switch Performance
    - Documented performance sweeps across all of my team's features, and checked in weekly with remaining expensive issues, including occasionally checking in on our new events map.
    - I documented suggestions on how to improve many areas of performance for my team's features.
    - I took charge fixing performance on issues I had familiarity with.
    - Fixed average frame rate issues, hitches, and in some cases death by a thousand cuts.
    - Pinged other teams on issues I noticed.
    - Fixed systems responding to events that shouldn't be, UI issues, NPC movement performance throttling, etc.
  - Scripts
    - Setup initial gameplay bat files for building and launching the game that some people still used to this day.
    - I ported those bat files to a Python configuration backed implementation, inspired by Saul's editor scripts.
- Team efforts
  - It seemed I was a go-to engineer for members of our Audio team
  - Created an RFC to set our foundation for cheats and debugging.
    - outline setting up cheats and debug tooling for every gameplay features as we added them.
  - Created RFC to set our foundation for creating and maintaining test maps for every gameplay feature.
    - Before this, people made bespoke throwaway personal test maps without consideration for other people who might need to test their gameplay features. It was expected other people should create and maintain their own test maps on features, rather than the people who wrote the gameplay features.
  - Wrote RFCS for Animation Blueprint best practices.
  - I felt like a go-to guy for VFX hookups, and SFX frequently came to me for help.
- Scripts
  - Setup initial gameplay bat files for building and launching the game that some people still used to this day.
  - I ported those bat files to a Python configuration backed implementation, inspired by Saul's editor scripts.
- Handled the merge to UE4 4.24.

- ### Learnings

  - Consider using throwaway prototypes that are isolated from your codebase
    - Chances are you will ship on prototype systems if they are part of your core codebase.
  - Don't abuse Data Tables when Data Assets may be a better fit.
    - Don't use manually typed row FName's directly, use Data Table Row Handle that auto populate.
  - Use soft/weak references instead of hard references
    - Makes loading the editor take longer, makes loading the game take longer.
    - Game memory is worse because then everything  is loaded all of the time.
  - Object/UI/vfx pooling to avoid construction and destruction costs, but also paying for GC searching and hitches.
  - Use Blueprint Assist for auto formatting BP, save to much time from organizing BP.
  - When adding/updating assets, verify/test all LOD levels when it's easier to validate them, rather than waiting for LOD issues to bite you later on.
  - Careful with how you grant/remove Enhanced Input IMC's, they should be in a centralized location that handles your player input or object interactions
    - Each of those (player input, object interactions) places can be separate from each other, what matters is each controls add/remove the IMC's they're responsible for and no one else.
  - Use Common UI for cross-platform UI that supports Controller and Mouse & Keyboard.
  - Make sure ABP are disabled from ticking if they're not set to draw
    - You can do this if ABP doesn't have any critical gameplay driving logic, and if it can seamlessly resume ticking without issue and jump to where it needs to be.
  - Having RFC's to serve as a studio's/game's tenets of your development process is actually pretty helpful.
    - I've already started encouraging them on a side project with co-workers; while they're very simple right now, I think it gets our team off on the right foot.
  - Team should be aligned on how documentation is organized and updated.
    - I've seen people create duplicate documentation intentionally for no *great* reason, it's a waste of resources. People are just stuck in their ways sometimes.
    - Pick a document system that everyone is happy to use, easy to use, and serves as a centralized source of truth.
  - When you have hundreds of moving replicating actors updating overlaps and with child objects, ticking movement can be surprisingly expensive.
    - Step up on floor calls, correcting for ground and other terrain, too.
    - You can do cheap ticking for anything not drawn on screen, or anything far away.
    - You can adjust ticking for small objects so they do cheap  ticking past a certain distance where they aren't easily visible; on smaller screen platforms you can crank this down even more.
  - Camera distance and FOV from big to small screen can be overlooked, something that looks great on a big screen can be too much of an eye strain on a small screen
    - Consider having a closer camera distance and smaller FOV on a small screen device; depends on the type of game you're making and your audience.
  - Leverage AssetManager so you can iterate assets without needing to load them first
  - Actually use and wait for Asynch loading, don't slam LoadBlocking, it flushes the whole pipeline and cause a frame stall.
  - Blendspace has a wrap option for things like -180 to 180 so they can lerp as expected across the boundary rather than taking the long distance lerp.

### Treyarch

- Black Ops 4 (T8 - Title 8)
  - All
  - Fixed new script serverfield system which communicate from client to server, hadn't been used before so not tested.
  - Extended gadget functionality, fix weapon/gadget/equipment bugs.
  - Fixed Script VM bugs
  - CP
  - Player Abilities
  - Three minigames of four      (one existed already from prototype phase over a year ago)
  - Prototype vehicle flares for impacting incoming missiles
  - Barrel roll evasive maneuver for flying vehicles with fancy cam
  - Vehicle AI behavior
    - Handling location movement, aiming for a spot and braking to a stop.
    - It's been a while, but I think I handled combat engagement, this was for singleplayer (didn't ship) vehicle finding a spot to target you from, move around, and targeting you again, running away if it takes too much damage, etc.
  - Hookup material physics affecting vehicle handling, friction and depth resistance. Added hydroplaning on low friction surfaces.
  - Setup vehicle tail/brake/reverse lights.
  - CT
  - Helped all designers with issues they ran into
  - Worked on general purpose utilities, like player loadout handling,
  - ZM
  - Added gesture perk bottle
  - Bug fixing
  - MP
  - Scorestreaks, weapons, equipment.
  - Bug fixing
  - UI
  - Setup Black Market Reserve's scene
  - Hooked up Black Market VO
  - Hooked up missing VO
  - Fixed gesture animation ending and fx ending bugs.
- From old resume
  - C++, game scripting, and Lua. Worked on weapons, gadgets, scorestreaks, etc. I was the single engineer who worked with our designer and scripters on Combat Training; worked on general utilities, like player loading handling. Helped out across Multiplayer (MP) and Zombies (ZM). Well after ship helped out with scene scripting on Black Market, and fixed UI bugs.
  - More specifically: fixed script serverfield system, hadn’t been put to the test before; fixed Script VM bugs; (not shipped) player abilities, created three minigames, vehicle flare for impacting incoming missiles, flying vehicle roll with fancy cam, vehicle AI behavior, vehicle tail/brake/reverse lights; hooked up material physics to affect vehicle handling, friction and fluid depth resistance in water, mud, sand, etc., and added hydroplaning on low friction surfaces; added gesture perk bottle (ZM); setup Black Market Reserve’s scene; hooked up Black Market VO; fixed gesture animation ending and fx ending bugs, etc.

### Blind Squirrel Games

- Camera's were frame dependent, I made them time based.
- Fixed controller issues:  hooked up trigger held messages; fixed controller chord issues, button up only worked if chord was also released, I fixed it so the chord or secondary button release would trigger the action release message, and button release would leave chord intact for use with another button action.
- Fixed PS4 controller issues; deadzone was incorrectly setup; stick range values were incorrect in several places, they were larger than the actual range.
- Extended our virtual keyboard support to show default string and description string.
- Implemented aim assist with auto locking, and slowing down camera when target was locked.
- I came up with an improved controller mapping for aimed actions that ended up being the design our designer settled on himself.
- Setup controller fishing w/ context sensitive fishing.
- ActionScript lacked a way to get the actual height of the textfield, so I created a helper method to do that, and to vertical center a textfield since ActionScript also lacked that.
- Added platform/controller quest strings, StringId*platform, and StringId*controller.
- Setup inline button images and shared image library for Iggy and Flash/ActionScript.
- Setup Iggy helpers to allow AS to get return values from C++ with a:
  - var ret = ExternalInterface.call("GetPlatform");
- Improved EULA scroll, starting scrolling slowly, accelerates the longer you hold it. Made it so the d-pad and stick work well; a single press to d-pad should scroll a single line; a quick flick to stick should also scroll a single line.
- Created carousel animation in store.
  - Extended the existing behavior by changing the position to be based off of the normalized scroll value, where 0 is it's starting position from the previous selection to 1 at it's ending position as the current selection.
- Fixed a gpu memory violation on Trove. There wasn't a compute shader setup for the compute gpu memmove, so the previously set compute shader was operating on the wrong data.
- Fixed a compute issue where we try to set and run a compute shader while still using another one, so I changed the gpu_memcpy to use gdraw->gfxc->copyData.
- Setup input action bindings through ini file, so code didn't have to be modified.
- Saved UI week of work. Trying to help indicate which UI screen is in focus, they wanted to do an opaque cover and screen highlight. I pointed out with the opaque cover, you wouldn't really notice if there was a highlight or not, the opaque would handle the screen standing out enough to look like it's in focus.
  - Trying to do two pieces of work to accomplish one goal, one of those pieces was very time consuming. I pointed out they only needed to do the first bit of work to accomplish the goal, the second piece wouldn't be noticed enough to bother with.
  - Two UI members were so happy when I pointed this out, they gave me a hug.
- From old resume
  - Helped port PC MMO, Trove, to PS4 and XBox One. Made camera movement frame independent (time based), fixed controller issues including a PS4 deadzone bug, extended action input system and fixed chord action bugs, implemented aim assist with auto locking and camera slow down when target locked, textfield inline image support, Iggy shared image library, Iggy/Actionscript helpers, fixed memory violations, fixed compute shader issue, worked on a lot of UI systems, etc.
  - Fixed a gpu memory violation, there wasn’t a compute shader setup for the compute memmove, the previously set compute shader ended up operating on wrong data; fixed compute issue where it tried to set and run a compute shader while another was still running.
  - Setup input action bindings through ini files, so code didn’t have to be modified. Saved UI weeks of work through problem solving on a design problem, and the designers were so happy with my solution they hugged me.

### Red 5 Games

- From old resume
  - Helped ready Firefall for the Chinese market, implemented a couple new features (like a time warp bubble) with designers, fixed documented bugs, finding and fixing bugs, fixing crashes, and helped with x64 client port.

### IllFonic

- Worked on networked ladders
  - Only one player at a time
- Handled player rotation and movement
  - including making CryEngine support zero-gravity player movement.
- Implemented magnetic boots (internally praised by Crytek) for walking up/down/around arbitrary surfaces.
- Initially hooked up all weapons and gadgets.
- Created grapple beam gadget with impulses to cancel extra velocity, speed player towards a wall, and slow them down before hitting it.
- We worked with and setup animation driven movement via root motion
- With procedural gun control I had to worry about frame by frame perfection and performance
  - Ended up finding some lag depending on a system I used, so found ways to remove as much lag input as possible
- Revamped weapon sway and recoil with procedural systems
  - Created player sway system, for which I implemented procedural helmet sway to replace animation based helmet movement.
- (trying to recall this a decade later) I setup the player mounted light
  - worked on tweaking the lighting settings to get it to look good, but also working with different textures to affect the look of the output light as if it was through a certain kind of lens but also still visible and useable.
  - Working on how it was attached to the player and how it moved when the player moved, didn't induce sickness (hopefully), but also lit up where the player expected the light to move (body vs head; I think we started with body because that *seemed* nice, but quickly realized that didn't work well compared to head mounted)

### Gameloft

- Responsible for tutorial systems
- Packaged/hooked in sound
- Extended data tool
- Performance improvements
- dynamic loading/unloading sprites
- fixed memory leak
- hooked up social library that others couldn't (cross game promo screen)
- seamless social library log-in
- created a mini-game for monetization
- built fonts
- built/uploaded DLC
- managed a DLC release
- did QA and Gold builds for iOS App store.
- Headed up a licensed mobile prototype project with Gameloft's 3D engine
  - hooked in all needed lib
  - Maintained device builds
  - Created and reiterated upon Python-driven data pipeline that efficiently handled gigabytes of data.
- Worked on Android game using Java with C preprocessor
  - gameplay/GUI elements
  - took over archaic tutorial system
  - implemented cross game promo screen
  - hooked up tracking library
  - fixed z-order drawing
  - worked on Python scripts and C# tools that made once tedious work quickly manageable
  - Debugged build issues.

### 1st Playable Productions

- Used C++ to
  - World of Zoo
    - Create mini-games that are pictured on the back of the box
    - Helped create a portable version of World of Zoo
  - Ben 10
    - Programmed a control scheme that became an advanced unlockable; etc.
- Used C++ and Lua scripting on Club Penguin Herbert's Revenge
  - Programmed the story sequences
  - Set up items used for puzzles
  - Added a scripting queue system;
  - Fixed bugs, etc.

## Academic Projects

### 2D PlasmaTech Engine

- C++ DirectX 10
- Setup rendering systems: abstracted effect file, sprite sheet, camera, frustum, mesh, mesh object, etc.
- Wrote content manager for loading textures and models
- Added math-helpers (ray picking screen-to-world, wrap parts of DirectX 10 libs, etc.)
- Created API for game objects to interact with components of different types (physics, chasing, or other movement behavior evolved)

### Upwards

- C++ with DirectX 9
- Conducted lots of research, looked at various preexisting engines (e.g. Ogre 3D, Irrlicht, Allegro, and Wild Magic 3)
- First iteration of my personal engine, Warp Engine, cross-platform w/ components abstracting platform functionality
- Handled UI implementation, gadgets, font renderer with Unicode code points, etc.

### Robo Assault

- C# XNA
- Setup camera & controls
- Initial setup of physics system with the player
- Setup test bed of the game environment for people to test in
- (If I recall) Also did path prediction and path smoothing
- Created Network Manager, Network Messaging system (I think this means Chat)
- Networked game statistics, and game state handling
- Robust kill-feed messaging, gracefully handle kill spamming

### RTS game (todo find title)

- C# XNA
- AI (reusing some parts I created from previous project)
  - A* pathfinding
  - Designed spatial store (I don't remember what that means, but if I had to guess...)
    - Spatial store for cached A* paths
  - Flocking/boidal behavior (steering)
  - State machine using pathfinding and steering behaviors, resource mining, etc.
  - Setup our NPC units
- Created flexible UI form system for our GUI
- Worked on other game systems and state handling, etc.
- Resource mining system (think Starcraft)

### Fluffymancer

- C# XNA
- I was the researcher for the team
- AI
  - A* pathfinding
  - Flocking/boidal behavior (steering)
  - State machine
- Created debug primitive batch drawing system
- Created height map system for characters to travel over
- Setup XnaAnimation to work with our project and figured out how to properly export modals from Maya
- Skinned animation
- Wrote HLSL shaders
