Deadly Riff reboot

Sep, 2017

Deadly Riff is a rhythm versus fighting game made for the AirConsole Contest 2017. The result was a good prototype but we wanted to push the idea further and see what we can get after a summer.

Type: Rhythm versus fighting
Platforms: Windows
Inputs: Gamepads
Tools: Unity / Wwise


  • Rework and refactoring of the old code
  • Parser for Editor On Fire's project files
  • Long notes mechanic
  • Stats system for the characters
  • New gameplay mechanics
  • Wwise integration

The team

  • Vincent LeMehautée (Project manager)
  • Charlotte Couder (Game designer)
  • Thaïs Arias (Game designer)
  • Alexandre Cornudet (Artist)
  • Noémie Szmrzsik-Cohard (Artist)
  • Yoann D'Orlandi (Artist)
  • Antoine Wert (Sound designer)
  • Thomas Fransisco (Developer)
  • Clément Rondeau (Developer)

The goal of this project was to get a vertical slice from the previous prototype and under 2 months. The team grew to fit the new objectives, unfortunately at the end of the summer we only got a new prototype but with more content and mechanics. My tasks during the project were :

Level design tool

My first task on the project was to create a level design tool usable by our game designers. In order to gain some time on the project, I’ve searched for rhtythm game level design tool.

I’ve found “Editor On Fire” which is an open-source software used to create levels for the game “Frets On Fire”, it’s available on Github under the BSD 3-clause license. Its project file format is available and need to be readen byte per byte. To do so I’ve read the file and put all bytes in an array.

To read it I wanted to mimic the python list slice system, thanks to Linq it was possible to user the Skip() and Take() method to just get the bytes I wanted.

timingFormat = Convert.ToBoolean(file.Skip(20).Take(1).First());

Once I got the informations, I needed to convert them to a usable type, to do so I’ve created a simple utility class to convert bytes to a given type.

public class EOFUtility {
  public static int bytesToInt32(byte[] bytes) {
      return BitConverter.ToInt32(bytes, 0);
  public static int bytesToInt16(byte[] bytes) {
      return BitConverter.ToInt16(bytes, 0);
  public static char bytesToChar(byte[] bytes) {
      return BitConverter.ToChar(bytes, 0);

With that system and a documentation that I had to write for the game designers, we got a new level design tool. Much more convenient than a handwritten JSON file.

Game mechanics

The first mechanic that I wanted to add was the long note mechanic, the goal was to create notes that last and force the player to keep the button done while the note is played.

Thanks to the new tool, the level designers could create notes with a given length and with the parser I could get this data. To spawn a long note I spawn 3 objects, a head, a body and a tail. The head is a normal note that needs to be played, the tail wait the length time (500ms for example) before moving, and the body is an object between the head and the tail that is scaled on the Y axis to get the good size.

An other mechanic that was fun to work on was the “Super attack” and “Solos” system. The idea is that an invisible bar is filling up when you attack, play a long streak or block damages. When this bar is full you can launch a super attack that cause a lot of damage and put the opponent in the “Rock or die” status.

When one player is in “Rock or die” the main song is paused and a solo is launched, the player musn’t miss a note to succeed and reduce the inflicted damages. This mechanic required to use a timer that can be paused to know where we are in the main sond, and after a solo to start one measure back.

This was easily possible with Wwise, and the timer song was in the end given by the Wwise’s API.