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.
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.
RTS development (AI, pathfinding, unit behaviors), Custom Unit development of behavior and display, game optimization.
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.
·
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.
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.
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.
· 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.
· 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.
· 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..
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.
· Train feature delivering gifts.
· Various other minor features and UI.
· Periodic optimization of the Flash client.
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.
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.
·
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.
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.
·
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.
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
Games Shipped as
Employee:
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.
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.
Desktop Publishing products
Shipped as an Employee:
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.
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.