Ahlquist Software - Major Shipped Projects:

Bahubali: The Game

Client: Moonfrog Labs, Bangalore India

Project: Bahubali: The Game. Shipped April 2017

Platform: Mobil - Android and IOS.

Tech: Cocos2D-X, C++, Server Tech NodeJS + C++

Rendering: 2D sprites, 2D skeletal animations.

Term: 24 Months (ongoing)

Artwork copyright Moonfrog Labs.

I led the development of this game and it was created and shipped from March 2016 – April 2017. The first 8 months of the project I was the only engineer. Art was working the entire time. I created the game engine and initial server code during this time, including the embedded server (a light server that allowed the game to be played stand alone) and the client rendering code. Additional staff was added in October (1 producer, 1 designer, 4 engineers) and in February (2 engineers, QA dept. help, 3 producers, 1 designer). We shipped the game on time with the movie release, and it was rated “Best Game” and “Most Competitive Game” by the Google Play Store India editorial staff.

The development had to be done very rapidly, and robustly. The choice of Cocos2d-X was driven by several project needs. First, the target was a 20 MB download that would run on a low end Android phone (Samsung J1-Ace for example). Second, we wanted to do server side battle validation, so we needed the core simulation to be deterministic and cross platform. The server platform preferred was NodeJS, which supported C++ plugins. In addition, the compile and launch cycle for Cocos on Mac was about 10 seconds, and a minute and a half for an Android build. This gave us a rapid compile and test cycle.

As I was the only engineer I was responsible for the initial design and prototype. I chose/designed a number of features in the development process to support rapid, robust development.

Bahubali rapid development features:

• Test version on Mac: We could compile and run on the Mac, giving us a quick turnaround compile and test cycle.
• Embedded server: I designed two versions of the server using shared C++ code for the core functionality. The embedded server was run in a background thread in the client app, allowing the game to be played and tested before the server was completed. In addition, it allowed designers to test changes locally without having to push changes to a dev server. Again, very short (20 second) edit to test turnaround.
• Automated test: I wrote unit test functions for the core server and RTS classes. The Mac project included a build target that ran the tests and produced a pass/fail result. This was also excellent for initial development debugging, as you could put your unit test call in the front, and get to your breakpoints immediately.
• Coding standards: We used the Google C++ coding standards, and cpplint.py to check for compliance. I modified the project to automatically run cpplint before compiles, so the standards were followed. This resulted in a clean, consistent code base.
• Treat warnings as errors: I cleaned up the warnings in the initial project and set -Wall and treated warnings as errors. This prevented the creep of warnings into the code base and resulted in a number of actual errors being corrected in the compile phase.
• Database format JSON: We used JSON for the player database, as it was quick to deal with using rapidjson, and was compatible with the Mongo database preferred by the client. In addition, the database files created by the embedded server could be hand edited during the initial development process when necessary.
• Game data format JSON with comment extensions enabled: Same format as db, hand editable to start, comments allow annotations directly in data files.
• Tools: Game runs on mac, so a dev mode available on mac. Includes features for base editing, as well as additional mac GUI panels to provide a graphical interface to design and debug features.
• Performance sampling tool. Low overhead sampling tool built into the game, produces per frame timing stats in .csv format for use in excel.
• Robo test mode - automated scripting that would play the common modes of the game repeatedly. Excellent for tracking down memory leaks.
• Customized malloc code: that tracked all allocations and frees, producing generation ordered unfree allocation reports, including stack trace of allocation. Again very useful in tracking down memory leaks.

Bahubali RTS features

• Data driven unit and structure code.
• Map logic.
• Path finding logic including optimized A* algorithm.
• Attack logic including attack movement for two units moving towards each other.
• Map rendering code.
• Unit rendering code supporting flip frame animation and 2d skeletal animation.
• Building rendering with animated attachments.
• Weapons and projectiles, both game logic and visual rendering.

UDP Networking:

Implemented coop play mode on Bahubali app using UDP networking. Created full UDP reliable transport layer with ack capability to handle packet drops.

Empires & Allies II

Client: Zynga, San Francisco

Project: Empires & Allies. Shipped May 2015

Platform: Mobile – IOS and Android

Tech: Unity, C#, Server tech C#

Rendering: 3D meshes, 3D skinned animations.

Term: 32 Months

Splash screen copyright Zynga.

Tasks:

RTS development (AI, pathfinding, unit behaviors), Custom Unit development of behavior and display, game optimization.

Features developed:

• Data driven RTS game logic - path finding, target selection, weapons and damage. Game logic was deterministic to support replays on device, and battle verification on server.
• Unit implementation of special behaviors and visuals such as spider bot movement with jumping and helicopter movement.

Optimization:

• Separated the game simulation logic so that the bulk of it was executed in a background thread. As our target devices had 2+ CPU cores, this allowed the goal of less than 5% time spent in simulation in the main thread.
• Performed code and draw call optimizations on the shipping game. Reduced frame time from 50ms to 30ms on mid-range devices, improving frame rate to our target of 30 fps. On high end devices produced a noticeable drop in battery use as the frame rate was locked to 30 so the CPU load was reduced substantially.

Reading Rainbow Kid’s Library App

Client: RRKidz, Inc., San Francisco

Project: Reading Rainbow reading and video app. Shipped June 2012

Platform: Mobile – IOS Tablet, Kindle Fire

Tech: Native (XCode ui kit, Objective C, Java and OpenGL on Kindle)

Rendering: UI kit / OpenGL.

Term: 14 Months

Artwork copyright RRKidz

I joined the project when it became apparent to the company that their developer was unable to complete the app. The initial app was written in HTML5, using the PhoneGap wrapper. Unfortunately that resulated in an app that was incomplete, using excessive memory (crashed on launch on IPad 1 due to memory pressure) and ran slowly, with jerky animations and choppy scrolling on an iPad 3.

In 4 months I wrote the initial Reading Rainbow app from scratch.

Feature Development:

· UI – Main island scene and all of the individual islands.

· Book reader: the books were written in HTML5, so a full screen web view was launched to play the books. This required unloading the main UI so that the web view would have enough memory to run the graphically rich books.

· Book manager: The books were provided by subscription, so were downloaded on demand from the RRKidz server. Background downloads with progress in the library ui provided feedback as to the progress and completion of downloads.

· Video manager: Similarly videos could be downloaded and viewed.

Reading Rainbow App – post-ship work:

The next technical challenge was the production of a Kindle Fire version of the app. The UI for the Kindle app was assigned to another developer. As noted before, the initial failed developer created the app in HTML5, and the books were written using snippets of HTML5 animation code to play animations in the books. The initial development was done on iPad, so the iPad app used a webview to play the HTML5 code directly. Unfortunately, the previous developers did not test on Kindle and other Android devices, so the books only worked on iOS.

In order to support Kindle Fire without requiring rework of the existing book library I wrote an interpreter in Java that read the book HTML5 code as data, parsed it, and then emulated page turn and other animation code. This only included the code used in the books but covered a substantial part of the image animation capability.

IPriorityMail productivity app

Client: Bullseye Studio, Los Angeles

Project: IPriorityMail. 1.0 Shipped Mar 2013

Platform: IOS

Tech: Objective C, Linux C++, MySql

Rendering: IOS UIKit.

Term: 15 Months part time

Splash Screen copyright Ahlquist Software

Ahlquist Software designed and implemented the client, UI and server components of this app, and subcontracted the artwork. The app was an email notification app with a server component that ran and checked for new emails, and notified the user via push notifications when emails were available. In addition, it provided the ability to set rules matching senders. The rules could be used to set the notification (badge number, popup notification, and customizable sound). This way you would only be notified for messages from senders that were important.

C++ Server Components:

· Email interface – the server supported POP and IMAP email servers. POP was polled by necessity, whereas IMAP usually supported the IDLE command, allowing the server to immediately receive updates from the IMAP server without having to spam the IMAP server with FETCH requests.

· Summary: The server read the header and start of new messages in order to save the origin (from, to, send time, subject) and the couple of K bytes of the message. This allowed the server to pass From, Subject and the first line of the message in the push notification. When the app connected to the server, it could instantly download this information for multiple messages, rather than having to connect to the mail server.

· Reliability: The final version of the server, running on an Amazon Web Services instance, ran 3 to 4 months between faults.

Client components:

· UI to create rules to match by sender, subject, contact.

· Included a “Do Not Disturb” type capability, allowing notifications to be automatically disabled or muted during a time period, as well as manually.

· Included a setup “Wizard” to walk users through the email and rule setup process.

IPriorityMail Security Features:

· A HIPAA compliant version was created with security features to support HIPAA regulations.

· A new C++ server was created that used a Federal Information Processing Standards publication 145-2 approved cryptographic module. This was accomplished by using the OpenSSL FIPS Object module.

· Email data was encrypted using a public key provided by the client application. This was done before storing messages to the MySQL database. The private key was only stored on the client device, so only that device could decrypt the email data.

· Secure push notifications including subject and message content were done using a custom socket connection between client and server, and the content was sent encrypted. Normal push notifications are sent plain text and are not secure. When it was necessary to use normal push notifications, a simple notification was sent without subject and text to maintain security..

CityVille

Client: Zynga, San Francisco

Project: CityVille. Shipped December 2010

Platform: Facebook game

Tech: Flash / LAMP, ActionScript, PHP

Rendering: Flash.

Term: 15 Months

Splash Screen copyright Zynga

I joined the CityVille project fairly early in the initial development, I created a number of the systems and
gameplay features for the game. Features were implemented as a Flash ActionScript front end, and
required server code was written in PHP.

Systems:

• Waterways – Implemented terrain mapping, including multiple types of terrain:
• Normal buildable area
• Can’t build
• Water
• Expansion - can build here after you build a bridge
• Roads – Implemented road layout and rendering code that enabled 3x3 units and roads to be
  placed on a 1-unit grid, permitting the creation of offset layouts.
• Implemented “Daily Mail” system.

Features:

· Train feature delivering gifts.

· Various other minor features and UI.

Optimization:

· Periodic optimization of the Flash client.

Hunted

Client: InXile Entertainment, Newport Beach

Project: Hunted: The Demon’s Forge. Shipped May 2011

Platform: Unreal 3, PC Xbox 360, PS3

Tech: C++

Rendering: 3D mesh, 3D skinned animations.

Term: 10 Months

Box art copyright Bethesda Softworks.

I was hired to design and implement the system to allow users on Xbox 360 and PS3 to create, share, and play custom dungeons in a co-op mode.

Damnation

Client: Codemasters, Universal City, CA

Project: Damnation. Shipped May 2009

Platform: Unreal 3 – PC, Xbox 360, PlayStation 3

Tech: C++

Rendering: 3D mesh, 3D Skeletal animations.

Term: 7 Months

I was brought on to this project about half way through development. My primary task was to fix framerate issues, primarily stalls.

Tasks:

· Scene framerate analysis – captured per frame timings broken down by custom profiling code.

· Identified that the character animation tree which had several hundred bones was taking 100MSEC to load. This resulted in a half second stall when 4 AI characters were spawned. As the art and animations were completed at this point, it was not possible to rework the assets. I developed a system for caching the skeletons, and reusing the skeletons. In addition, just doing the frame update on the skeleton took significant time, so I made data specific optimizations to the update function.

· Analyzed and optimized AI code. Identified stalls in the pathfinding code (Kynapse library)

· Analyzed and optimized audio loading to remove hitches.

· Converted Unrealscript functions to C++.

· Identified issues with redundant data loaded in scenes and eliminated the redundant data.

· Identified and corrected streaming stalls on PC due to shader compile time.

Rise of the Argonauts

Client: Codemasters, Universal City, CA

Project: Argonauts. Shipped December 2008

Platform: Unreal 3 – PC, Xbox 360, Playstation 3

Tech: C++

Rendering: 3D mesh, 3D Skeletal animations.

Term: 6 Months

I was brought on to this project for the last 6 months before shipping in order to perform framerate optimizations.

Tasks:

· Scene framerate analysis – captured per frame timings broken down by custom profiling code.

· Unrealscript to C++ : Identified high use scripts, and converted them to C++. Functions converted included unit control code (Pawn), HUD code, and combat hit calculation code.

· Analyzed and optimized background level streaming code.

flOw

Client: thatgamecompany, Los Angeles

Project: flOw. PS3 version shipped mid 2007

Platform: PS3

Tech: PS3 native development tools.

Rendering: PS3.

Term: 2 Months

I was hired to produce an Synergistic Processing Element (SPU) implementation of the fluid simulation for the game. The original simulation code ran on the general-purpose core (PPE), and the game ran approx. 10 fps. I created a SPU version of the code, including the inter processor data transfer code. The new simulation ran more than an order of magnitude faster. The benefits include completely removing the computation from the PPE, and resulted in a framerate of 40+ fps.

Published Book:

Book: Game Development Essentials: Game Artificial Intelligence

Published: July 2007

Topics:

• Creating AI Agents using finite state machines.
• Hierarchical state machines vs Goal Oriented AI.
• Using scripting to create customizable AI systems.
• Creating rule based Expert System AI.
• Pathfinding: A*, then how to apply the resulting path.
• Advanced pathfinding: Hierarchical pathfinding, group pathfinding.

Games Shipped as Employee:

The Battle for Middle-Earth

Employer: Electronic Arts, Los Angeles

Project: The Lord of the Rings: The Battle for Middle-Earth. Shipped December 6, 2004

Platform: PC Direct X

Tech: C++

Rendering: 3D mesh, 3D skinned animations.

Project Term: 22 Months

Box art copyright Electronic Arts.

I worked on this project from start to finish. We started the BFME engine using the Generals engine.

Tasks:

• Refactor and optimize battle simulation to support a maximum of 300 units, rather than the Generals maximum of 40 units.
• Improve pathfinding to support the convoluted maps required by the fiction, such as Minas Tiritih, and Helms Deep.
• Implement game logic for game play features such as the Army of the Dead.
• Modify game rendering to support “Interior” maps for the Moria level.

Generals

Employer: Electronic Arts, Irvine

Project: Command & Conquer: Generals. Shipped February 2003

Platform: PC Direct X

Tech: C++

Rendering: 3D mesh, 3D skinned animations.

Project Term: 24 Months

Box art copyright Electronic Arts.

I started work on Generals at the beginning of the project, initially tasked to do the game map editor for the design team.

Features:

• Editor. Provided the map and mission editor for the design team, including editing the height map, trigger areas, waypoints, behavior rules GUI, roads and terrain fill textures.
• AI System – I took over and completed the AI systems for the game including pathfinding, state machined low level behaviors, designer controlled higher level behaviors and rule system.
• Unit movement, logical and visual. I implemented code that provided the basic capabilities such as movement speed, acceleration, turn radius. Also advanced behaviors such as 3 point backup and turn. I implemented the fine detail code that allowed visual tuning of the independent suspension on the rocket buggy. The code was data driven allowing design to fine tune the visual and movement behaviors.
• Optimization: Provided tools for analyzing performance in production builds, and fixed issues as they were identified.

Desktop Publishing products Shipped as an Employee:

Fireworks

Employer: Macromedia, Dallas (Acquired Altsys in 1995)

Project: Macromedia: Fireworks. Versions 1, 2, 3 shipped 1998, 1999, 2000

Platform: Macintosh & PC

Tech: C++

Rendering: Custom porting layer.

Project Term: 36 Months

Splash Screen copyright Adobe.

I was the lead engineer and developed Fireworks’ best in class image compression and export. I also created the export code that resulted in Fireworks being the first tool to automatically export HTML and Images that could be used for rollover buttons directly in a web site. As a result, Fireworks became the dominant web publishing software in the industry. Subsequent releases included customization to generate Dreamweaver compatible, Adobe GoLive compatible, and user modifiable custom html formats.

FreeHand

Employer: Altsys, Dallas (Subsequently acquired by Macromedia)

Project: Macromedia: Freehand. Versions 3, 4, 5, 7 shipped 1991, 1994, 1995, 1996

Platform: Macintosh & PC

Tech: Custom C with object extensions

Rendering: Custom porting layer.

Project Term: 7 years

Splash Screen copyright Adobe.

When I joined the project FreeHand 2 was a Macintosh only product, and 3.0 development on the Mac was just started. My first assignment was to create the Windows 3.0 version of FreeHand. We used a mixture of custom UI code (ui was native to each platform) and shared code for rendering, with a platform specific rendering layer to support PostScript style rendering.

I became the lead engineer for both Mac and Windows for FreeHand 5 and was the product manager for FreeHand 7.