Space Jazz

Space Jazz

As your attempt to create a teleporter goes wrong,
you find yourself stranded in what looks like an American diner from the 50s,
except that it is filled with robots and aliens who barely know what a human is.
Explore the diner and talk to the other guests until you find your way home.

Space Jazz is an interactive virtual reality experience where you explore the eponymous retro-styled diner, interact with various robots and alien species, uncover the story of the others and of humanity, all with the ultimate goal of going home.

This game is being made by a team of five people as a 3rd semester project for the Animation and Game study programme at the Darmstadt University of Applied Sciences.
Production is currently in progress and the site will be updated accordingly.

Information

Philipp Bodor Composing Sound design SFX
Martin Gil Olmedo Game design Management
Elisabeth Möller Art direction Animation 2D and 3D art
Oliver Rosengarth Programming Writing
Marah Siemko Game direction 2D and 3D art Writing
Platform Valve Index HTC Vive Oculus Rift
Genre VR experience
Mode Singleplayer
Engine Unity (C#)
Development October 2019 - now (ongoing)

Story Writing

For this project, I am collaborating on the story with game director Marah Siemko and game designer Martin Gil.

At first, Marah Siemko and I worked together to create an overview of the whole story.
We decided to use a five-act structure for the dramaturgy and have each act focus on one of five characters.
We thought about what big revelation each act would give the player and what we want each act to evoke and then assigned the central characters accordingly.
For the characters, we came up with backstories and depths the player would find and considered how they relate to the story's themes and how they fit into the game's setting and aesthetic as a mix of science fiction and American 50s.

When Marah Siemko had written general character descriptions, I came up with ways to show their personalities through dialogue and created a dialogue guide for each character containing a description of their dialogue style and a few dialogue samples. Since the game will have full voice acting, these samples were also used for auditions.

Our general workflow for writing story acts is as follows:
  1. During group brainstorming sessions, Marah Siemko, Martin Gil and I create a basic overview of how the player gets the necessary information on plot and characters, how to evoke the intended emotions, how to trigger character development and what gameplay we need for these aspects.
  2. Martin Gil then fleshes out the gameplay, creating rough diagrams that show how the player reaches the end of the chapter.
  3. Marah Siemko and I use this as a reference for creating an interactive story prototype in Twine. We work together both by working on different parts and by rewriting each other's drafts.
  4. We test these prototypes with various users, which is organized by Martin Gil.
  5. Based on user feedback, the dialogue is edited and finalized into the voice acting guide, which I am in charge of. This document is used during the voice recording sessions, containing character descriptions as well as all the dialogue with annotations that describe context and the character's tone and emotion if not obvious.

Programming

Since the scripting language I made for Perpetomb worked well for the team, I wanted to create one for Space Jazz that would be optimized for the game's own core mechanics, such as the following:
  • The player can start a conversation with characters by waving at them.
  • Other characters may also react to the player bringing objects into their vicinity, getting close to them or causing collisions between certain objects, among others.
  • Other characters can ask the player questions, which the player answers by gestures, such as thumbs up for yes. How the other character's dialogue then continues depends on the gesture used.
I noticed a common thread: something that happens (usually an action the player takes) causes a chain of reactions by the game, such as lines of dialogue being played. Since not all possible player actions or game reactions were known at this point, the system would also need to be very flexible.
I realized that the perfect solution would be a trigger/event system that allows me to create any trigger or event that the game designer wants to use, so in order to implement the game logic, one would only need to define which triggers cause which events.
Syntax
The basic syntax is as follows:

LABEL:
event name: event parameters

OTHERLABEL:
// comment that is ignored by the game
event name: event parameters;
event name 2: event parameters 2

There are certain things that make the game go to a label.
It then takes all of the events that are defined directly underneath this label and executes them in order from top to bottom.
If the line an event is defined on ends with a semicolon (;), this means that the game waits until the event is complete before starting the next event. This can be used for playing two sound files after each other, for example. Otherwise, the game will start the next event in the same frame as the current event.

By default, the game will not go to a new label while it is busy executing the events from another.
Labels that contain an exclamation mark (!), however, have priority over other labels and will force quit the currently running events and run their own events instead.
Meanwhile, labels that contain a plus sign (+) allow their events to run on top of the currently running events.

Usually, the things that make the game go to a label are triggers, which can be player actions such as waving at characters or collisions between objects, for example.
Which triggers exist and which labels they lead to is defined in the set trigger event, which looks like this:
set trigger: trigger description -> LABEL

At the start, the game automatically goes to the START label.
For the game to recognize a certain character or object, one can give it a tag in the inspector in Unity and refer to it using this tag in the game scripts.
For convenience, the parser is set up to be lenient regarding issues such as varying capitalization and superfluous spaces.
Special features
For more flexibility (and for me to practice regular expressions), the game's scripting language has its own expression engine that allows for complex statements such as a += (b+5)/3 + (c*(a+b)), conditions like (a++ > b*5 || c == 42) && d%2 == 0 and nestable if / else if / else clauses.

Gesture recognition in VR can also be challenging.
For waving, for example, I had various players do a waving motion in VR and recorded the position and rotation parameters of the head and hand.
After analyzing this data, I created a basic algorithm that essentially calculates the rotational axis the hand is currently moving around using quaternions and compares it to the other character's position and the angle of the camera.
However, as of now, this method suffers from either too many false positives or too many false negatives, depending on certain parameters. I intend to research and test other methods in the future. For example, Fast Fourier Transform could be an option, considering the oscillating nature of waving.
Share by: