2D platformer mixing “beat ‘em up” and “run ‘n gun” styles for mobile platform (work done having iOS as primary focus).
NOTE: Despite of the fact a video containing a gameplay preview of this project was already released and myself and other team members were authorized to reveal the project name for external people, with no NDA signed, and have done so, this game is related to a quite popular animation series, for which there are expectations on the community about the game release and also rumors about it. Therefore, I prefer to avoid revealing its name on this public website. However, I can provide extra details on private to potential employers / partners.
- Advanced C++ (mostly)
- 2D engine architecturing and implementation
- Game dev design patters
- Python (for scripting tools)
- Objective-C (occasionally)
Distributed, being 3 full time coders, lead designer, 2 level designers, three 2D artists, plus game producer and QA from Halfbrick.
October, 2011 to November, 2012
- Working with the team, taking the technical leadership role, on planning, making estimatives, executing and delivering the sprint goals inside VERY strict deadlines aiming to satisfy multiple stakeholders.
- Taking the Scrum Master role when the company CEO could not be present.
- Interfacing with the lead designer and stakeholders regarding core technical topics.
- Creating and maintaining a robust and extendable architecture for the game being developed in order to allow an smooth team work on the C++ code.
- Keeping the source code “quality” for a healthy grow across the daily work of the team, mainly by watching for issues like logic replication and creating solutions and guidelines to overcome them.
- Leading a successful junior coder recruitment process by defining role, advertising, interviewing, creating and applying technical tests and assessing candidates from a technical perspective.
- Conceiving and implementing the core engine modules aiming for future reuse on other projects (we were authorized by Halfbrick to reuse our code and also their engine on future own IP projects).
Main Programming Tasks Performed
- Component based “Scene Object” Architecture with integrated parsing features: started the project before the rest of the team jumping in, creating flexible and clean component based architecture for the “scene objects”, taking advantage from unique features the C++ language provides. This included a datablock managing system for quickly instancing new scene objects based on parsed XML data, plus several XML parsing utilities, mostly macros, assisting the fast creation of new scene object types having their attributes externalized for design tweaks.
- Character AI (and State Machine System): worked with artists and designers to develop more than 20 different enemies with unique behaviors, including hand to hand and projectile based combat and also including a mini-boss and main boss having different attacking and defeating phases. The State Machine system was also reused to control game play states and camera states.
- 2D physics components: was the developer of the first and main 2D physics components, with features including dynamics, collision and ray tracing.
- Powerful 2D Animation System with support to frame events: Thanks to the good choices made for the component based architecture this component started as being a common sprite animation system and ended up easily integrated with the cinematic system (explained below) to support big sized characters animation (with each frame being composed of multiple sprites instead of of just one). Animations were easily defined on XML files, being all the process assisted by python scripts integrated with sprite packing and animation tools (third part). Also, it was possible to set frame events via XML, supporting multiple parameters for easily creating frame based behaviors.
- 2D Cinematic System: Conceived and implemented a scene object component to play animations exported from Adobe Flash to an specific XML based format. This system established a very efficient “art to game” pipeline and cinematics started to be extensively used through the levels of the game, not only for storytelling, but also for multiple enemy spawning animations. These animations could include multiple character, vehicles, effects, etc. Also, they had support to frame based events for stuff such as sound effects.
- UI Container System: Implemented an UI system with setup based on XML, supporting also hierarchical containers and integration to the code via the “Caller System” (explained below), allowing input actions to be taken without the need to define and implement specific callback interfaces.
- Caller and Tween system: exploring advanced C++ features this module allow calls to functions or object methods to be schedule for being called after some time and/or with some specific frequency. Also it can “save calls” to be called at any time from a specific id, this allows the creation of callback methods with great flexibility, avoiding the need of defining specific callback interfaces in several situations. The system can also simulates a call stack, allowing methods/functions to generate a tree or tail of calls to be tracked and controlled by the same id, which was very useful for creating 2D animation effects or simple particle effects.
- Loading Management System: Implemented a set of classes and macros that could be easily integrated on methods doing heavy loading operations requiring almost no changes on them in order to breakup their execution in pieces across multiple frames, this would allow simulating a loading thread in single thread code, something important due limitations coming from the engine and low spec mobile platforms.