this is a working draft.
Mini Motorways is a part zen, part hair-pulling urban planning game from the creators of #Mini Metro. It features a procedurally generated soundscape full of rhythmic & harmonic trickery. It features something scarcely found in games—an entire soundscape created procedurally in code. It also uses many of the same sounds from Mini Metro, just in very different ways. So, in a way, it is not only a sequel but a remix of Mini Metro.
The primary goal of this project was to create a concept that builds upon the existing framework we built for Mini Metro - in other words, reusing the systems and sounds from the first game - while employing some new techniques to differentiate the experience from its predecessor. Care was taken to lean into the uniqueness of the sequel.
Road systems are far messier than metro lines - & as a result, the audio tries to follow suit. Over the two games, we established an approach that seeks to tone down the stress of gameplay. Aesthetically, the sound strives to invite you in, comforting the player as a way to counter the "plate-spinning" nature of the mechanics. Given the timeframe and resources, reusing the sound palette from Metro made sense while finding ways to recontextualize that game's dulcet tones.
Personnel & Logistics
Off the heels of Mini Metro's success in the App Store, Apple funded the development of Mini Motorways as a launch title for their Arcade subscription. Unlike Metro, the turnaround needed to be quick; I participated for less than half a year before the game was live on the app store. That also necessitated that the game's studio, Dinosaur Polo Club, grow to accommodate the timeline. As a result, and surely for many other reasons, my primary collaborator, Pete Curry, had far more to manage. On Mini Metro, Pete and I were a collaborative team, working closely together, and he was a readily available resource to me for various questions about C#, Unity, low-level audio, and programming. Mini Metro was a fantastic education for me in those regards. On Motorways, it had much more of the feeling that I was off on my own in the desert, experimenting and doing wacky stuff. Pete would slot time where he could to help me solve technical issues, improve performance, or implement low-level audio features that I was struggling to do well. The rest of the dev team also tagged in occasionally to help with bug fixing and performance. I tried to stay focused on the creative side of coding, but the holistic nature of the systems meant it wasn't always possible to color within those lines. I was chasing things I thought yielded cool output, with some consideration for performance, but not to the level a commercial game requires. In this generation, you're typically targeting a "low bar" platform, the slowest device your game should be able to run on. I know that the Nintendo Switch has been the low benchmark for this project and some others.
Early Process
Just as I did for Metro, I approached the initial concept phase from multiple angles - I tried to conceptualize the systems in writings and drawings while scoring early beta footage.
In this first draft, I explored the idea that each car engine emits a tonal sound, creating a growing ambient soundscape. This demo sketch feels sluggish, but I was intrigued enough with the concept to try prototyping it further in C#. I discovered that when the road system is flush with cars, these drones can be abstract sounding, & overwhelming. I also explored using just intonation, which causes the drones to meld together. It ended up feeling too dissonant and almost like Sunn 0))) (i.e., a drone metal band). It wasn't the vibe I was hoping for.
In hindsight, I could have made this idea of cars emitting tones work aesthetically. This would have required gameplay elements that are percussive by nature, serving as sonic landmarks to break up the sustained sounds. But the issue was also technical—having 100+ sound sources going at once is CPU intensive.
I enjoy sketching out diagrams like this one. In addition to using more direct approaches, I took time to conceptualize the macro scale—level progression and how the audio would fit into molding the narrative experience. This drawing may be obtuse, but it's an early exploration of the game's progressive stages. I broke things down into a 3 act structure to match the city's growth. In early testing, I could already intuit this arc as I played. I was posing questions like "How long should the music feel introductory for?" and "When should it develop and ultimately reach its apex?".
The gameplay essentially serves as the conductor and does most of the work. It was just a matter of tying into the right gameplay conditions.
I love the idea of a miniature setting full of life and minor details, and that's where I started from a creative standpoint with this type of game. However, it can be hard at times to know when to stop.
Case in point. Here is another early scribble of me trying to understand the probability space of the gameplay.
In the beginning, I pondered which essential objects of the simulations could yield interesting musical analogies—things like cars, roads, destinations, colors, and the in-game clock. Here, I am drawing a comparison to Metro's system and how these new analogies might be explored through things like rhythm and note sequencing.
This second draft is closer to what I eventually settled on. The musical analogies are starting to take shape, mainly with cars and destinations. But I had to let go of achieving the same 1:1' ness we had in Mini Metro. It became clear that it would be too much to manage in the busier simulation of Motorways. The musical behavior we landed on ended up being less data-oriented in general. It's definitely less 1:1 than what we did for Metro, but still with that familiar pulsing backbone.
The coupling between the music and city elements is less tight, favoring a more varied and stylized sound. That lack of coupling informed the direction things would go and inspired me to make the design far more asymmetrical than what we'd done before. Motorways' audio began living up to the weird sibling metaphor, which also rings true for the rest of the game.
One thing to note is that engines, while playing more of a sound design role, can still have a bit of a rhythmic component through baked tremolo effects.
Metro Deltas
I followed the same general design approach I used for Metro while identifying areas where we could explore new ideas. One of the most significant differences between the two games is that Metro is far more controlled, while Motorways is more customizable. Minimalism and Serialism inspire Metro's music, as it uses data sets to inform musical changes while maintaining a relatively clean and straightforward presentation.
The Motorways approach is one of looser limitations, putting more emphasis on fun. The UI chimes along to the music, while chords trigger with generous amounts of pitch bend. Car horns honk slightly out of tune, and funky key changes accompany dark mode toggling on and off. We built upon Metro's audio tools and techniques by diving even deeper into real-time effects, procedurally generating harmony and dramatically expanding the rhythmic palette. This added tech did sometimes lead to more bugs, but Motorways' "wild west" nature made development a lot of fun.
Here are some examples of features unique to Motorways:
Musical Development
Unlike its predecessor, musicality is dealt with in broader terms instead of reacting to every vehicle. In Metro, vehicles generate music through a tightly coupled system. This approach worked because there were only seven train lines at most. Meanwhile, hundreds of active cars can be in a Motorways city, so a different approach was necessary.
As you begin a city, the music is ambient and sparse. As cars start to drive, pad sounds slowly give way to pulsing tones.
The scheduling system that the game uses to send cars to destinations guides the music's progression. The destinations "request" cars. The more requests there are, the busier the city and the less ambient the music gets. This change is tied directly to the number of active requests made by destinations, so the initial "ambient phase" naturally ends as your city grows.
The game groups vehicles and buildings together by color. Each group has a sequence of elements creatively generated, like pitch and rhythm, and elements generated with game data, such as pan and volume. These evolve during gameplay in different ways. As the city grows, the volume of individual pulses tends to get quieter to make room for more sounds. Meanwhile, pitch and rhythm are continuously changing through creative instruction handled by the game's loadout system. Each city typically has its own pitch and rhythm options and instructions.
Less Responsive, More Musical
Both games have a musical soundscape oriented towards a complex weaving of sequenced tones.
Sounds not tied to player input can sometimes be delayed for musicality. For instance, car horns in Motorways are musical and happen on the beat. However, car horns were not a thing until audio stepped in - they are strictly a sonic feature, which makes it a much easier target for this type of approach. Delaying other gameplay elements to happen on the beat can be far more resource-intensive, computationally, but even more so from a personnel standpoint. It typically requires collaboration across departments to delay things like animations or other visual cues.
Mini Metro goes to great lengths to try to have its cake and eat it, too. Its sound is both musical (happening on the beat) and responsive. This is accomplished in some instances by syncing the game to the audio instead of the other way around, which is far more common. After Metro, we vowed not to do that so much unless it make a crucial difference in game feel. When it comes to audio timing, the difference in "feel" between 60fps (game thread, i.e., visuals) and 48kHz (audio thread, i.e., sound equivalent of 48,000fps) is very noticeable at a fast tempo and indiscernible in the case of ambient music. (see: #Paradise Marsh, which triggers music clips on the game thread)
For sounds tied to player input, you typically want them to feel tactile and immediate. You may want things to feel both musical and responsive, but these goals can be at odds, and it's not always possible to accomplish both. We mostly avoid these concerns in Motorways. The game has a messy, "detached" feel, and we chose to lean into that with the game's audio design.
Things like drawing roads happen on a visual grid. Tapping into that analogy, quantizing the timing of the drawing sounds fit conceptually. The delayed onsets give it a satisfying "chunky" feel, putting it squarely in the "more musical" category.
In cases where quantization doesn't feel right, we stick with the responsive feel via immediate playback of the sound. This has its own benefits; the loose nature of the rhythm in relation to the more structured music can feel playful. An example is dragging motorways around, where each time you drag and release, wobbly musical pitches that align with the game's physics encourage players to "play" them like an instrument.
~Training Wheels~
Mini Metro used a JSON architecture to assist in building custom load-outs for each city. It looks something like this:
{
"author": "Disasterpeace",
"id": "saintpetersburg",
"base": "city",
"constants":
{
"Swing" : 0.333,
"Swing_Range" : [0, 6],
"Rhythms" : [24, 12, 6],
"Steps_Double" : [0, 8],
"Steps_Whole" : [0, 8],
"Steps_Half" : [0],
"PeepEmbarks_Flam_Pulse": 8,
"PeepEmbarks_Rhythm" : 4,
"FadeIn_Times" : [0,0,0,0],
"VoiceLimit_Static" : 5,
"Transpositions" : [-6, -4, -2, -1, 0, 1],
"ChordTone_Pulse" : 6,
"PeepAppears_Flam_Pulse": 6,
"Flam_Limit" : 7
},
"harmonies":
{
"assignments": [0, 0, 0, 0, 1],
"weeks" :
[
{
"sequences" : [ ["F#4", "A4", "C#5", "C#4"], ["E4", "A3", "D#4", "F#3"]],
"bass" : ["C#", "F#", "A", "B", "A", "F#"]
},
{
"sequences" : [ ["F#4", "G#4", "C#5", "C#4"], ["E4", "G#3", "A#3", "C#3"]],
"bass" : ["C", "G#", "A#", "E"]
}
]
},
"modules": []
}
The system worked well, but having a hard-coded ruleset limited feasible design choices from level to level. That said, it was great for onboarding other composers to design levels, especially those less comfortable with coding. (see: →Mini Metro: Building Your Own Cityscape|)
Sometimes, I wanted to add custom behavior to a city for a content update. However, that would require changing the architecture, which made the whole process feel heavy-handed.
Variable Systems
Motorways practically eliminates this JSON system by replacing it with unique C# subclasses for every city. This shift allowed me to naturally build out an extensive library of callbacks and overridable properties during development and post-release.
public class Beijing : MusicData
{
public override void Injections()
{
SetRhythms(Rhythm.Duplet.Patterns().Crop(2f), RhythmUpdateType.RandomParallel);
SetQualities(QualityDatabase.Gather("Quartal", "Overtone", "Penta Chromodal"));
SetFadeInProgression(1d, 0d, asMultiplier: false);
SetDrumSequencer(Rhythms.Shortest(), boom: true, bap: true, hat: true, useEuclideanGates: false, attackDuration: 50f);
}
private int bassFreq = 6;
public override void OnHour()
{
if (Get.Hour % bassFreq == 1)
{
bassFreq = Rando.Pick(3, 6, 9, 12, 15, 18, 21, 24);
string note = Rando.Pick(NoteWindow);
Bass?.FadeOutAndStop(Settings.BASS_FADE_OUT);
Bass = AudioPlayer.Default.PlaySample
(
"bass_" + note.Substring(0, note.Length-1), //Note.SCALE[CurrentScale.Key],
gain: Settings.Gain.BASS_AMBIENT,
fadeTime: Settings.BASS_FADE_IN,
pitch: -1f
);
UpdateDrumSequencer(Get.Loadout.DestinationGroupRhythms.Shortest(), boom: true, bap: Rando.FlipCoin(), hat: true);
}
}
}
By solidifying the Metro loadout scheme too early in development, I overengineered it. On the other hand, it prevented me from making radical changes late in development. It was my first commercial project touching code, so that may have been a fortunate decision. One might argue it suited Metro, which is more of an "on rails" game. (pun intended)
The new approach in Motorways was far less restricting and allowed me to be more creative. As a result, every city ended up housing different experiments. Over an in-game week, drums get groovier in Dar es Salaam:
OnDay() => UpdateDrumSequencer(initDrumRhythm.InjectNoise(Get.WeekProgress * 0.1f));
And samples reverse more and more each day in Mexico City:
public override float SamplePitchSign() => Get.Day switch
{
0 => 1f,
1 => Rando.FlipCoin(5f / 6f) ? 1f : -1f,
2 => Rando.FlipCoin(4f / 6f) ? 1f : -1f,
3 => Rando.FlipCoin(3f / 6f) ? 1f : -1f,
4 => Rando.FlipCoin(2f / 6f) ? 1f : -1f,
5 => Rando.FlipCoin(1f / 6f) ? 1f : -1f,
6 => -1f,
_ => 1f,
};
In some cities, music reacts to you connecting roads. In this example, the "boom" (kick), "bap" (snare), and "hat" (hi-hat) randomly toggle on or off each time.
public override void OnConnection()
{
Boom = Rando.FlipCoin();
Bap = Rando.FlipCoin();
Hat = Rando.FlipCoin();
UseEuclideanDrumGates = Rando.FlipCoin();
Get.Loadout.DrumSequencer.Hat.PseudoUpbeatChance = Rando.m();
if (!Boom && !Bap && !Hat)
Rando.Pick(Boom, Bap, Hat).Flip();
}
In others, it reacts to nighttime, weekends, or your overall progression:
// number of new tones ping pongs each week between 1 and all but two.
public override void OnNewWeek()
{
if (Get.Week > 3)
commonTones = Get.MaxGroups - Rando.Range(1, 5);
else if (Get.Week > 0)
commonTones = Get.MaxGroups - (Get.Week + 1);
if (Get.Week == 1)
Boom = Bap = Hat = true;
UpdateNoteWindow(commonTones: commonTones, chordChangeProbability: 1f, keyChangeProbability: 1f, forceChange: true);
}
In some cities, music doesn't pay much attention to you. It has a bit of a jam on its own.
When it comes to harmony, Los Angeles only uses Major modes, omitting Locrian:
Quality q = Quality.Clone(QualityDatabase.MAJOR);
q.Scales.RemoveAt(6); // remove Locrian
SetQualities(Liszt.From(q));
Meanwhile, Moscow uses the entire database, which it inherits from the parent class:
SetQualities(Audio.QualityDatabase.ALL);
This opening significantly impacted the style of the game's music design. It also increases the complexity of things, so in theory, it's more prone to unintended behaviors. However, it's been several years since the game's release in 2019, and it hasn't been an issue so far!
Sometimes, I experiment with a new music design in a particular city, wondering if using it across the entire game would be better. Going through with that impulse rarely happened during development, and since the game's initial release, I've not pursued anything like it. I do my best to resist the temptation to start rewriting features after the fact.
~Training Wheels~ Level Free-For-All
Because we release multiple new maps every new year, level extensibility felt like a super important feature for the game's soundscape. The hope is it keeps things fresh for the players. Working on it still feels fresh for me!
Engine Improvements
We carried over the same audio engine from Metro, a heavily customized version of the long-defunct Unity plugin "G-Audio." We initially decided to use this engine because it was free and could precisely schedule the playback of sounds via the audio thread.
Here are some of the improvements we made for Motorways:
Attenuation
Revolutionary, I know! But in Metro, there's only one instance where attenuation was needed - for trains heading off-screen on the main menu. Motorways lets you zoom into parts of the city, and this is a core feature of gameplay on mobile. As a result, we needed to build a proper attenuation system to handle when things were off-screen. This system also became crucial when we added trains to the game, as they frequently enter and exit the player's viewport.
Infinite Rhythm
Mini Metro was limited to uniform rhythms - pulses made up of equally sized steps. I modified the audio engine for Motorways to remove this restriction and allow for non-uniformity. This change realized the possibility of having rhythmic patterns, not just pulses. Now, all sorts of "loose" grooves were possible.
To achieve this, we had to change the inner workings of G-Audio's scheduling system so that the timing of its pulse callbacks could happen non-uniformly. As an example, I created a set of claves to use in the Rio level:
// A list of 4 bar clave rhythms.
public static readonly List Claves =
[
// custom
new(offsetRatio: 0f, steps: [0.5f, 0.75f, 0.5f, 1.0f, 0.5f, 0.75f]),
// afro-brazilian bell patterns
new(offsetRatio: 0f, steps: [0.75f, 0.75f, 1f, 0.5f, 1f]),
new(offsetRatio: 0f, steps: [0.75f, 0.25f, 0.75f, 0.25f, 0.5f, 0.5f, 0.75f, 0.25f]),
new(offsetRatio: 0f, steps: [0.25f, 0.5f, 0.25f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f]),
// son clave
new(offsetRatio: 0f, steps: [0.75f, 0.75f, 0.75f, 0.75f, 1f]),
// jobim
new(offsetRatio: 0f, steps: [0.75f, 0.75f, 1f, 0.75f, 0.75f]),
// samba A
new(offsetRatio: 0f, steps: [0.25f, 0.5f, 0.5f, 0.5f, 0.25f, 0.5f, 0.5f, 0.5f, 0.5f]),
// samba B
new(offsetRatio: 0.25f, steps: [0.5f, 0.5f, 0.5f, 0.25f, 0.5f, 0.5f, 0.5f, 0.75f]),
// samba C
new(offsetRatio: 0.25f, steps: [0.5f, 0.75f, 1f, 0.75f, 0.5f, 0.5f]),
// partido alto
new(offsetRatio: 0f, steps: [0.5f, 0.75f, 0.5f, 0.5f, 0.75f, 0.5f, 0.5f]),
// maracutu 3:2
new(offsetRatio: 0f, steps: [0.25f, 0.5f, 0.25f, 0.5f, 0.5f, 0.5f, 0.5f, 0.25f, 0.5f, 0.25f]),
// maracutu 2:3
new(offsetRatio: 0f, steps: [0.5f, 0.5f, 0.5f, 0.5f, 0.25f, 0.5f, 0.25f, 0.5f, 0.5f]),
// ijexa
new(offsetRatio: 0f, steps: [0.25f, 0.5f, 0.5f, 0.25f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f])
];
I adopted these rhythms from real-world examples and used them in other cities when appropriate.
DSP
While audio effects played a limited role in Metro's sound, DSP (digital signal processing) played a significant role in developing the charm of the Motorways' sound.
I'm talking specifically about effects handled at audio rate; in other words, in the realm of 48,000 times a second. This distinction is crucial because you can mimic some audio effects on the game thread (~60 times a second). Changing volume over time is the most common example and is likely to sound fine, but most other types of effects need to be implemented at a higher rate of change to sound correct.
Metro had audio-rate volume envelopes, but we also added native support for vibrato, tremolo, portamento, and reversing samples. Tremolo is used to create more variety in the sounds of car engines and the ambient pads of the early game. Vibrato, tremolo, and portamento effects are all deployable per city, where they can increase or decrease with the city's progression. All three are also used in tandem to give screen transition chords a little more flavor. These chords are present throughout the game's menus and the end-of-week screen.
Reverse
We set up reversing samples to be as simple as setting the pitch to a negative value. Reversibility opened up many interesting creative possibilities and stretched the creative reuse of Metro's samples even further. For instance, vehicle engine samples have a 50% chance of using a reversed sample, theoretically doubling the possibilities of what vehicles can sound like. However, the level of effectiveness varied depending on how distinctive each engine sound is. We also use reverse in specific cases, like during end-of-week screens and for city customization. For instance, in Mexico City, samples are more likely to reverse with each passing day of the week before resetting when the next Sunday comes around.
1st Party DSP
In addition to the new custom DSP, we also made better use of Unity's built-in effects on Motorways, especially filters, global pitch-shifting, and echo. We used filters, both low and high pass, to soften the sound of specific screens, like at the end of the week or for road editing. Global pitch-shifting is used momentarily for knocking over trees, zooming in/out of the city, pausing the game, and moving through menus. When switching to night mode, many sounds are pitch-shifted up by 27/16ths - a Pythagorean Major Sixth - alongside the introduction of echo.
More Percussion
For drum sequencing in Metro, the only option outside of sequences generated by game data was to trigger a kick drum sound at some pulsing subdivision. This feature led to things like Berlin's four-on-the-floor kick, one of the few initial Metro levels with standalone percussion.
Continuing in that limited tradition, percussion is not the primary feature of Motorways' music. However, we knew we needed to build a dedicated drum sequencer this time. Adding the sequencer alongside a more extensible loadout system allowed us to create scenarios where drums evolved throughout gameplay.
Percussive Trains
These improvements set the stage for reviving an old, failed Metro concept: trains as drum sequencers. The addition of trains came in a post-release content update. I had them act as drum sequencers with variable tempos tied to the train's speed.
A New Approach to Harmony
In Metro, each city derives harmony from a short, shifting window of authored notes taken from a more extended sequence.
1) ->[B2, C3, E3, G3], B3, D4, A3
2) B2, ->[C3, E3, G3, B3], D4, A3
3) B2, C3, ->[E3, G3, B3, D4], A3
etc...
In Motorways, each city has a bucket of chords and properties instead. You pick these up front, and then the harmony is handled automatically. Let's say the system is in D Dorian. You can tell it to find a new chord with four common tones, and it will pull a random chord scale from a preset list available to that city. Let's say it picks B Melodic Minor, ascending scale. The two scales have three tones in common, so we don't use it. We keep trying until we find something that matches our criteria or until the system times out. Next, we randomly select F Minor Pentatonic, which has four common tones, so it works. This process is possible because of an algorithm I lovingly call:
The Common Tone Chord Network
The algorithm chooses harmony from a pre-defined list of "qualities." Qualities are data containers based on a scale of intervals, but they can also flag which keys, modes, and voicings to use. These qualities are either taken from a database of pre-designed options or can be created bespoke for a level. In hindsight, building a default database may have been overkill, but it did help with exploring all the nooks and crannies of this system.
When a quality has modes, they are primarily used to help with voicing the harmony. For instance, we need to know which note to treat as the lowest or root note. Bass notes sometimes use different samples as well. The low range of voicing tends to be just roots and octaves to prevent muddiness, but the voicing preferences are customizable in each instance. Some qualities have low fifths, for example. It mainly boils down to aesthetic considerations.
Qualities come in many flavors. By default, they don't have keys associated with them. For instance, you could have a quality populated with all the Major modes but sans keys. If you only had this quality loaded, modal scales play in parallel. So if the game is in the key of F, you will get F Dorian, F Lydian, etc. Also, when the system picks a new quality, the music's perceived key will never change.
Other qualities are keyful, which is a nice way of saying that all the scales in the quality are associated with a specific key. For instance, C Major, with all of its relative modes (D Dorian, E Phrygian, etc.). There's no limit on how many scales you can have, though.
You could have a quality with a single scale, like Minor, with no modes, but in all 12 keys. The system calls this a "chromatic" quality. Or you could have a "chromodal" quality: a silly way of saying a container with a scale represented in every key, plus all its modes. Following this logic, Minor Chromodal would have 84 scales.
When the system selects a new tonality, it does not limit itself to the same quality. It will randomly select an option from any of the loaded qualities.
When the system times out, it is always due to human error. In other words, it couldn't find an option with the number of common tones requested by the city's loadout. This result almost always means no qualities were available with the desired number of common tones. The failsafe is 100 attempts, which is usually enough to confirm there are no suitable choices, or at least there aren't enough choices to make the system run smoothly. That said, the system will still work in this scenario - it may even "snap out of it" if some game event like an end-of-week screen transposes the key - otherwise, it will revert to the key and scale currently being used. But the preferred thing to do in this case is to find more suitable qualities. That will always fix the issue.
The loadout system also supports separating qualities for day and night, which means there are two separate buckets. In this case, the current quality will carry over on the day/night change, and the next time a new scale is requested, the system will search across the gap into the new bucket for something with the right number of common tones.
The "Right" Number of Common Tones
Choosing the right number of common tones to search for is contextual. More common tones mean you will have more consonant-sounding chord changes. By default, the game uses a formula based on the number of color groups a level has, MaxGroups - 1. Most levels have around five groups, so this tends to mean four common tones. However, certain cities modify this rule to explore other sounds. Typically, the further we get into the game's progression, the less common tones the system will use. This delta tends to reflect a sense of activity. But we always ask for at least one common tone because zero tones in common can sound pretty intense!
Honk Honk! (Car Horns)
Mini Motorways has cars, so it has car horns. I designed them to be only slightly out of tune. They are musical but dissonant enough to communicate that something negative is happening in your simulation.
Horn logic is quite complex. Horns use a hefty set of conditional parameters to make sure honking happens realistically. They needed to be only as annoying as necessary to alert the player of traffic issues. Many years of driving helped me dial in some of these parameters. Each driver has their own base "generosity score," a random value that says how likely they are to honk their horn given certain game conditions. For instance, drivers will never feel generous when at a light for more than 8 seconds or tailgating another vehicle. But otherwise, assuming they're not parked at home, moving at full speed, or almost at their destination, we'll do a dice roll against the driver's base generosity to see if they're inclined to honk their horn at that moment.
Some cities have special horns. In Los Angeles, there's a slim chance you will hear "La Cucaracha" - just like in real life! But unlike real life, the car horns change keys with the game's music. Yes, I recorded 12 different versions of La Cucaracha.
Big Distinctions
1. Vehicles Don't Matter.
Trains were important in Metro, but individual cars are not in Motorways. We needed a more macro image to tap into.
2. Success is the Absence of Sound.
In Metro, many intermittent sounds you'd hear jutting out of the soundscape were a positive sign of activity. The sound of trains stopping and passengers hopping on and off are some of the most notable. But in Motorways, the absence of discrete sounds is what denotes success. You don't want to hear cars honking or warnings ticking away - just the wash of many cars moving fluidly. If you've ever been in a building next to a freely moving highway, you might notice how the sound of the vehicles turns into white noise, receding into the background. That is the sonic goal of Motorways.
Postmortem
Overall, I am very pleased with how the project turned out, but the complexity was high. And a handful of features were not as successful as they could have been. Let's talk about those.
Rhythm
I spent a lot of time implementing a better pipeline for rhythm and trying to figure out new ways to use it. However, the game doesn't take full advantage of the possibilities. There are more drums, and all the sequences have unique rhythms, but it can all feel subtle at times. I struggled to make rhythm an essential part of the design. It's an area that could've been stronger, though it's also possible that given the game's messy nature, rhythm was never an appropriate candidate to be at the forefront of the design.
Harmony
As you might have guessed from my deep dive into the underpinnings of the Common Tone Chord Network, harmony is another area that I spent a lot of time on. When the systems work, they work fantastically - but the ruleset(s) can leave it prone to occasional dissonances. There were numerous points in playtesting where we heard back that the game could sound too ominous or negative. I addressed these concerns in most cases, but it typically required limiting the harmonic possibilities to more traditional and understandable scopes by omitting modes or sticking to simple scales like major pentatonic.
Sequencing
The game has a sophisticated sequencing system for handling the time, pitch, volume, and panning of how it pulses and bounces around the screen. Cities can handle sequencing differently - a whole system of preset sequence types exists: forward, backward, random, ping-pong, etc. In hindsight, none of this is especially noticeable.
When critiquing these three features, two primary ideas come to mind.
Double-Edged Swords
Both of these can yield great results but are also, by their very nature, double-edged swords:
1. Complexity
On Metro, I worked closely with Pete, whereas Motorways was much more of a siloed experience. Though I had help building out key features, like DSP, this ultimately led to a tendency to tinker with almost everything in my path, sometimes without a clear direction or sense of priority.
It led to many interesting breakthroughs, but it was not an efficient method. This "feature creep by design" approach sometimes creates unneeded complexity.
2. Possibility Space
When designing audio for new cities, having a larger possibility space can allow for more creativity, but it can also be easier to get lost in the details. For instance, trying to keep track of the similarities and differences across two dozen cities was tough. Fortunately, the game has strong audio systems, which helps things feel cohesive across different levels.
Sometimes, the types of customizations just ended up not being that meaningful. It's natural to want to find variations that won't overpower the essential nature of the music. But the flip side is having features that don't do enough to distinguish themselves. Some of these, like custom car horns, occupy a sweet spot regarding variability and noticeability. Others, like sequencing, could come across as too subtle because those pulsing sounds are all very similar, soft, and almost ambient-sounding.
In Closing
Something fascinates me about applying randomness & conditional rulesets to music. When it works well, it can create the illusion of a living environment with a sort of intelligence. Furthermore, no two playthroughs of Mini Motorways sound quite the same, and I'm fond of that, even if it can be subtle! That said, what you may lose in details is made up for by the variability of each playthrough.
It was a labor of love and personal curiosity to work on a game with a team that allowed me to explore crazy systems. Some projects are fun, first and foremost, but working on the Mini games has also been a continuing education.