Andre Duvoisin

Blog · Portfolio · Resume

Composite Engine

Composite Engine is a game engine technical demo created to explore the core low-level components required to make a video game, while attempting to push the envelope on some of the more frustrating or mundane elements. It currently sports a graphics engine, scene and camera support, an animation processing tool, an event system, and a user interface.

Composite Engine is created by Kevin Viglucci and me. The engine is written in C++ for Windows and Mac and features OpenGL, a CMake build system, and Chromium Embedded Framework (CEF) for a JavaScript user interface layer.


  • Graphics engine with rendering, texturing, skinning, and animations in OpenGL
  • Animation processing tool to import via FBX SDK and export to a custom format
  • Event system to marshal events between different engine systems
  • CMake build and dependency management system for Windows and Mac
  • Chromium Embedded Framework (CEF) integration to support a JavaScript user interface with React and Redux



Piston Shooty

Piston Shooty is a 2D puzzle game where the player shoots guns that each shoot more guns. When they’re ready, the player can spend their one bullet shot - which shoots a bullet out of all guns in play at once! Can they time their bullet shot accurately to kill all enemies in one click?

Puns are a non-negotiable. Every level name and gun name must be pun-based. Here’s our current running list of puns! (Now accepting lowbrow comments and suggestions. Puns must be level 7 or higher to be accepted.)

Piston Shooty is created by Dru Erridge and me. The game is written in Rust and utilizes the Piston game engine.


  • Gameplay, including gun selection, guns shooting guns, guns shooting a final bullet, and basic enemy behavior
  • Game flow, including level selection, level advancement, and win and lose states
  • Level editor involving a grid-based system loaded from CSV files
  • Main menu
  • Audio
  • User interface and heads-up display


Twitter: @gamesfromrust


Chambara is a networked multiplayer stealth-deathmatch game with only two colors, allowing players to seamlessly camouflage themselves with the environment. This empowers players to sneak, search, and ambush each other in dramatic, stylish duels.

Chambara was created with a team of 20 people. The game client and game server were created with Unity3D, while the platform consisted of Node.js and MongoDB on Linux.

It was released for PC and PS4 on Steam and the PlayStation Store. See the Links section below for more details!


  • Designed and implemented the back end platform to communicate with both the game client (on PC and PS4) and game server (on Linux). Includes player profiles, matchmaking, analytics, and game server management
  • Ported the game to PS4 and Xbox One. Includes adding controls, handling achievements, coordinating localization, and ensuring accessibility
  • Created a build system with Jenkins for a cross-platform game (PS4, PC, Mac, Linux)
  • Fleshed out the deploy system from build servers to production Azure boxes


Steam: Chambara
PlayStation: Chambara


Polyseum is a team-focused first person shooter where the goal is to knock enemies into hazards or off of the stage in order to kill them. In a sense, it’s akin to a cross between Super Smash Bros. and the first person shooter genre, with emphasis on teamwork and player roles rather than headshots and twitch reactions.

Polyseum was created with a 20-person team in C++ using Unreal Engine 4.


  • Architected in-game chat system
  • Added on to our status effect system

    • Hitstun - After hit by an attack, the player is input locked for a short amount of time.
    • Gravity Reset - When hit by a certain attack, gravity is lost and slowly regained.
    • Damage Over Time - When hit by an attack, the player takes a small amount of damage every interval for a certain amount of time.
    • Area Damage Over Time - Damage Over Time applied to a player if they’re located within a certain area.
  • Game Flow: Pre-Game to Match (round-based) to Post-Game

    • Pre-Game - Before the game begins, players may freely choose their weapon kit, face off against players on the other team, and “ready up” to move on to the match. Once the match begins, players are locked into their weapon choice.
    • Game Modes - Responsible for the Arena game mode in which the goal is to eliminate the enemy team. Surviving team wins the round, and first to three rounds wins!
  • Spectator mode with a free-flying camera
  • Handled reconnecting to the game while maintaining player stats
  • Formula for the player’s dash ability



The Maestros

The Maestros is a fast-paced 3v3 real time strategy game in which killing neutral enemies gives the player base units that can then be transformed into more powerful units. Each player controls a commander who has unique abilities and supplements their army. Players can customize their strategy by choosing between 6 different commanders and a selection of 12 units on 2 unique races. Kill enemy commanders to score points and win!

The Maestros was created on a team of 35 people using Unreal Development Kit (UDK).

It was released for PC on Steam. See the Links section below for more details!


  • Implemented the user interface for the main menu, lobby, commander selection, and in-game heads-up display (HUD) using Scaleform GFx, UnrealScript, ActionScript 3, and Flash
  • Deigned and created the front-end for a 3D Main Menu system
  • Implemented the front-end for a login system with session information
  • Integrated against a web API using HTTP and TCP to form a working lobby system. Lobby flow includes:

    • Creating a lobby or selecting from a list of available lobbies.
    • Changing and replicating game settings (e.g. Game Mode, Team Select)
    • Lobby chat
    • Commander select with live updates to teammates, so that you may see which commanders your teammates are choosing before locking in.
    • After everyone locks in their commander, a message is sent to the lobby server to transition to the game. The client connects to the game server upon receiving its network information from the lobby server.
  • In-game status overlay with information such as kills, deaths, assists, commander information, and army composition information.
  • In-game pause menu
  • Victory and defeat overlays
  • Post-game score screen with final match results and statistics.


Steam: The Maestros

Super Smash Skyrim

Super Smash Skyrim is a networked multiplayer game where the object is to attack and grab enemies in order to hurl them off the stage.

Super Smash Skyrim was created with a team of 4 people. It is written using Prime Engine, a custom C++ game engine, with Maya, Lua, and Python for level editing.


  • Loading assets on level start
  • Networked 4-player support using both TCP and UDP
  • Movement and attack mechanics
  • Physics system (as it relates to gameplay)
  • Time syncing and client-side prediction
  • Win conditions


Spirit is a free-flowing rhythm game created for mobile. The player traverses the cosmos as Spirit and taps on the screen when Spirit comes in contact with a pad, which are laid out to the beat of the song. Keeping the rhythm is essential to maintaining your flow.

Spirit was developed with Unity in a 3-person team - two engineers and a sound designer.


  • Wrote a sound wave analyzer in order to distinguish the strong beats in a given sound file.
  • Dynamic level generation based on the timing of the beats.
  • Spirit movement from pad to pad throughout the levels.
  • Scoring system based on input timing.

    • “Sweetspotting” the pads netted more points.
  • Overall game flow: traversing the level, pad input timing, and beginning/death/end states.
  • UI and Menu system



Starfox 65

Starfox 65 is a 4-player split-screen 3D space shooter. The object of the game is to fly around an arena and shoot down the ships of opposing players, using either normal shots or lock-on targetting.

Starfox 65 was made in a 4-person team with C# using the Microsoft XNA game engine.


  • Spring camera that follows each ship
  • Shooting, including regular and homing projectiles
  • Lock-on targetting
  • Reticle projected in front of the player’s ship
  • Xbox 360 controller input
  • Split-screen gameplay
  • Main menu



Game Engine

As part of a class on game engines, I developed a game engine demo in C++ that included:

  • SIMD math library
  • DirectX 9 graphics
  • Skeletal animation
  • Custom shaders, including phong shading
  • Camera, along with mouse and keyboard controls
  • Memory allocators (stack and pool)




As a final project for an agent-focused multithreaded programming course, our team of 8 people created a city simulation that would run independent of human input. The city had many different facets:

  • Citizens who eat, sleep, pay their rent, have jobs, travel about the city, go to the market, visit the bank, and go to restaurants
  • 8 restaurants that citizens may choose to eat at
  • A market that citizens may buy food or cars at
  • A bus system to traverse the city
  • A control panel that controlled things like number of citizens and different real-world scenarios (e.g. a restaurant runs out of food)


  • Bank GUI
  • Bank integration
  • Citizen technical design
  • Base and city-wide GUI technical design
  • Control panel design, implementation, and integration
  • Zoom-in view functionality
  • Trace panel integration
  • Restaurant integration management

    • Responsible for merging individual restaurant projects into one working city
  • Dynamic weekend behaviors

    • Disabling and enabling workspaces
  • Role-switching events in which citizens had the ability to change jobs
  • Transportation integration
  • Bug squashing

    • Fun Fact: I was nicknamed Fix-It Felix for my mad bug squashing skills!



© 2024 Andre Duvoisin