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:

Bahubali RTS features

 

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

Image result for Empires and alliesClient: 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.

 

 

Image result for Empires and alliesTasks:

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

Features developed:

Optimization:


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

Image result for cityvilleClient: 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:

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:


 

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:


 

 

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:


 

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.