Traversal and Exploration

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:

• Driving
• Horseback Riding
• Climbing / Parkour
• Flying
• Walking

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.

In order to facilitate better driving, a driving lane is 8 meters wide.

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.

The sidewalk is there to signal the edge of the safe driving are while the road furniture on the side is there to signal a failure to stay within those bounds.

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.

Classic Plot structure — Follows the player’s journey.

• 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.

Dark Souls world map vs GTA5 open world map.

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.

Linear Progression

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:

The Grand Washington Hotel — The Division 2.

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:

Each Fight Represents and encounter. Each Step represents an extra wave. The Graph calculates how many AI are in each encounter wave.

Same deal here except here we are tracking the actual AI rarity count and distribution (per total).

If we look at the similarities, the numbers may vary but the outputting chart is very similar in both situations.

A look at the Normal Difficulty

A look at the Hard Difficulty

I took some time to look at other difficulties as well and the results were only marginally different. The overall outcome is the same

AI Distribution vs Players Journey

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.

An example:

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:

0–45 Degree Angle

90–180 Degree Angle

How do we rationally know if these Angles are harder or easier? We play the game, and we note down our experience

Difficulty of execution Tracker

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-Hard
• 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

90 seconds divided into 5 Different Beats

Timing Readjustment

More Iterations

Compiling all this data ensures you are getting the optimal difficulty of execution distribution for your track.

Track Segments put together — Artists rendition.

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)

and

Player Skill:

• 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.

PS5 Controller

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.