Traversal is the act of going through the environment to either reach an objective or a goal.
Based on the type of game that you are making this can come in a variety of ways:
- Horseback Riding
- Climbing / Parkour
And this leads to a lot of variety in the way you shape your world maps:
Ex: A game built around the idea of high-speed vehicular racing is going to look a lot different than a game build for on foot navigation traversal.
One important tip to consider here before anything else: Make sure you understand your avatar speed, size, proportions, and metrics.
I am referring to the player character as an avatar, because it can inhabit a variety of forms: Cars, Planes, Spider Bots, Drones, People, Giant Robots, so on and so forth.
To facilitate better driving a driving lane is 8 meters wide.
In driving games road width is there to facilitate erratic and out of control gameplay. In Watch Dogs or GTA games the roads are wide to facilitate a lot of swirling and take overs while at the same time supporting system gameplay.
Generally, what you want to get out of building a traversal track for whatever type of game you are building is to make sure that the “fun” of traversing it there.
Fun might sound like a pretentious term, but it is short for a way of sustaining player enjoyment while they are traversing your map. It can be achieved in a variety of ways:
- The track can be custom designed and build to follow a progression curve.
- Or it can be organic, beingly loosely tied to a progression curve but relying on more systemic implementations. This is more suitable for sandboxes where achieving a sense of progression trough Level Design can be a bit more difficult.
There are exceptions of course but it usually goes down to attempting to implement a linear progression chart in an open world map, which leads to a linear map sequence within the open world map.
When dealing with Linear Progression the key is to ensure that you can encapsulate the experience in a sequence of events, and the modulate their intensity/difficulty of execution based on what you want your progression curve to look like.
What do I mean by that? Let us take the example of a concrete mission:
Grand Washington Hotel — The Division 2:
This mission is one of the earliest missions in the game.
It can be played on a variety of game difficulties with a variety of game modifiers that slightly enhance the experience.
The story is simple: You must go in there and rescue a civilian that is being held up on the roof. While you are trying to get up there you are confronted by a variety of enemy encounters that you need to fend off to reach the end.
If we were to break it down into how many encounters, we are facing it would look something like this:
If we look at the similarities, the numbers may vary but the outputting chart is very similar in both situations.
I took some time to look at other difficulties as well and the results were only marginally different. The overall outcome is the same
If we draw a progression line, we can notice all the beats we will eventually end up having it resembling the Basic Plot structure and upon implementation that’s how the player is going to perceive it.
And this can be applied to any kind of traversal designs you are working on. I call this Segmentation.
In a nutshell you segment your experience into smaller sequences and then follow-up to adjust the difficulty of execution for each segment to fit progression curve you are intending for your map.
Let’s assume that we want to build a rally race track for an arcade racing game and we want it to follow the following progression structure:
Also let’s assume we want the track to be completed in 90 seconds in optimal circumstances.
First thing we need to do is segment the structure into smaller digestible beats
What we want out of this is to ensure that each segment has:
- A beginning
- A middle
- An end
If your progression curve has a lot of peaks and valleys, then it is safe to assume there will be a lot of beats.
Now that we have established the flow let’s figure out what each beat equates to.
For this example, I will take into consideration the angle of turns:
How do we rationally know if these Angles are harder or easier? We play the game, and we note down our experience
Now that we have our difficulty of execution tracker and we know what each curve does we can go fort and assemble the track according to our difficulty chart. It’s a matter of determining what goes where however.
We can assume the track will have 5 beats:
- 1 -Easy
- 2 -Medium
- 1-Easy — At the end.
Since racing is all about timing, we can split the beats into:
- Fast Beats — Shortest to progress trough
- Slow Beats — Players will slow down here
- Medium Beats — Medium Timings
Compiling all this data ensures you are getting the optimal difficulty of execution distribution for your track.
Once everything is set the track could either look like this, or it could look completely different based on what you are going for, however the aim should be for the curve not to change (too much).
Here’s how to apply this to other game types as well:
- Platformers — Catalog jumps based on the difficulty of their execution (Height, Length, Momentum Needed)
- Adventure games with a lot of climbing — Catalog the climbing challenges in the game based on their difficulty coefficients (How far apart the elements are? Are there any risks involved? How many buttons to I need to push to make this work?)
Difficulty of Execution
Every action you perform in traversing a video game world involves a certain amount of effort. In order to figure out how much effort it takes to do a certain action, as a designer you will need to dissociate yourself (the designers) from yourself (the gamer).
You will need to understand that there is a difference between
- Input counts, Timing needed, Input frequency, etc. — Needed to complete an action under normal conditions. (Mechanical factors that never change)
- Skills developed by the player while playing the game for a long time. => (Skills you develop when you play COD for 20 years?)
When developing gameplay challenges and you are thinking about their implementation you will need to understand that player skill doesn’t matter. It only becomes important if comes into existence as a consequence of a progression you have defined as designer, trough mechanical factors.
A PS5 controller has 14 Buttons and 2 Joy Sticks:
- Each Button supports various degrees of interactions: Push, Push Hold, Pressure Touch, Etc.
- Each Thumbstick supports various tilt angles that can be programmed into controlling the character in various ways → Stop, Walk, Run, etc.
Each action represents an Input.
Difficulty of execution is determined by the various ways a player gets to interact with those inputs, rather than how the player interprets the difficulty based on his past experience.
Difficulty of execution is quantifiable immediately.