GAME CONCEPT • Considerations & Specifications
Stacked Realities
Abstract: Puzzle adventure in dream layers.
Working title: Till’s Mills
Layer
Each layer is basically an independent reality (ultimately a dream world/hub) with its individual graphical design, engine type, level size, inhabitants, quests, and so on. Even the avatar doesn't have to look the same everywhere - the player will notice which of the figures is moving accordingly at the latest when starting to navigate it.
Neighbouring layers may have structural similarities (such as identical buildings, floor plans, infrastructure, or things/beings with same functionality), hinting at mental overlap.
Normally dreams are directly influenced by real world events, and not the other way around. In the game, however, we're not bound to that one-way street, because we're in fact never dealing with a 'real' unswayable reality. Such freedom allows the layers to influence each other in both directions, which opens up neat possibilities when it comes to creating puzzles and quests.
Players always only see (and act in) a single layer, whose environment is shown in the main viewport.
Layer :: Concept
Vertical navigation through the stack is induced by various triggers:
- ↑ Upwards (dream inception)
- The melatonin level has reached a sufficiantly high value to make the player fall asleep and subsequently enter the next dream layer.
- Special non-lethal circumstances (getting stunned, drugs/anesthesia, magic) can also lead to loss of consciousness, and thus a sleep/dream phase transition.
- ↓ Downwards (awakening)
- A timeout has occurred.
- The player suffers from severe damage or even death.
For reasons of variety we need at least 3 layers. To reduce backtracking, the uppermost and lowermost in the list are directly linked, effectively forming a loop:
| ID | Layer |
| 3 | … |
| 1 | relative dream |
| 2 | Game start |
| 3 | relative reality |
| 1 | … |
Side note: Given aforementioned mechanisms, the avatar will cross reality borders on a regular basis, but with longer lists (5+ layers) it should be possible to skip one or more layers for the sake of faster navigation, namely when ascending into a new dream (of course, a follow-up awakening must go back the same number of levels to ensure consistency).
This way we could implement shortcuts, as seen in other adventure games that use e.g. portals to leapfrog within huge level structures.
Layer :: Relativity
Although a level's content (as of style, engine, puzzles, etc.) is determinated, there's still leeway for variation, e.g. the amount of surrealism, or the number of monsters.
This global strangeness parameter (normalized range 0…1) has a value of 50% at game start. Entering a dream increases it by ~10%, and waking up decreases it accordingly.
Example: When a level containing monsters is initialized, their number might be calculated simply like so:
N = round( Nmax × strangeness )
Layer :: Melatonin level
The degree of fatigue, which is shown in a bar on screen, usually starts at zero, growing very slowly in the beginning. Little by little (following an exponential curve) it accelerates, slightly affecting the avatar reaction times. Above ~75% the player gets increasingly hindered by lagging controls and obfuscating visual effects. Upon finally hitting the 100% mark the avatar falls asleep in situ.
Its unswayed total time needed (to go from 0 to 100%) depends on the minLen and addLen values of the current timeout settings:
barDuration = minLentim + addLentim / 2
As expected, players can manipulate their melatonin level e.g. by consuming sleeping pills to induce a premature nap (thus another dream transition). Ingesting caffeine, on the other hand, will enhance avatar control, and prolong their stay in the layer, that is, until the inevitable timer interrupt.
Side note: The bar (approx. 160×20 px in size, see
Draft: Bar) will be shown near the right top corner, partially overlapping the layer viewport:
Layer :: Falling asleep
Ebbing consciousness is emulated by a cutscene, which fades out to black (or similar overlay), then performs a fade-in of the new dream environment, and passes avatar control back to the player.
The entire procedure may take a handful of seconds.
Layer :: Waking up
Awakening, a fade-out/in cutscene akin to falling asleep, happens rather quickly and is usually - in case of a timeout - unexpected.
It takes just 1 or at most 2 seconds until the avatar finds himself in another quasi-reality, right at the spot where he fell asleep last time.
Layer :: Timeout
There's always a silent timer running in the background, without visual indication on screen. Depending on engine type (turn based, or realtime action) the internal units are either rounds or seconds.
When a layer is initialized (upon entering), the timer is reset to zero. Its duration is calculated individually by first defining a minimal length and then appending a randomly cut additional length:
timeout = minLentim + random() × addLentim
As soon as this timeout is reached, the avatar will wake up from his current dream.
The values for minLen and addLen will probably depend on the layer content. The bigger a level area, and the more puzzle-solving actions have to be taken, the more time should be offered.
Layer :: Timeout :: Configuration
The ratio between minLen and addLen influences a timeout's earliest possible occurrence.
Side note: In the following charts barDuration represents the natural (unmodified) melatonin rise from minimum to 100%, as usual.
The addLen part is shown in red to convey the timeout inside is located at a random point.
Example 1: addLen = 0
barDuration
min
In this special case, where
falling asleep and
awakening would happen at once, we simply define that the avatar will
fall asleep, which also conforms to the player's intuition when facing a 100%
melatonin level.
Example 2: addLen = ½ minLen
barDuration
min
add
A timeout occurs with 50% probability in the
last fifth of
barDuration.
Total chance of…
… ↑ sleep&dream:
9:10 (90%)
… ↓ awakening:
1:10 (10%)
Example 3: addLen = minLen
barDuration
min
add
A timeout occurs with 50% probability in the
last third of
barDuration.
Total chance of…
… ↑ sleep&dream:
5:6 (83%)
… ↓ awakening:
1:6 (17%)
Example 4: addLen = 2 × minLen
barDuration
min
add
A timeout occurs with 50% probability in the
second half of
barDuration.
Total chance of…
… ↑ sleep&dream:
3:4 (75%)
… ↓ awakening:
1:4 (25%)
Example 5: minLen = 0
barDuration
add
A timeout occurs anytime with 50% probability.
Total chance of…
… ↑ sleep&dream:
1:2 (50%)
… ↓ awakening:
1:2 (50%)
Side note: Instead of setting the timeout inside
addLen at an evenly distributed random point, a gaussian probability distribution…
… would statistically shift the interrupt towards the end of
barDuration, hence heightening the total chance of sleep&dream.
Layer :: Death
As opposed to traditional adventures, where it's Game Over when players lose (e.g. by running out of Health Points) their last/only life, in our case dying simply leads to awakening in the 'reality' layer below, and life goes on.
Goal
Win condition might be to accomplish collecting a full set of artifacts. These objects, spread over all layers, and well hidden in all sorts of places, can't be found without additional information that must be gathered either from environmental hints or interactions with characters.
Collected artifacts are automatically stored in an inventory, perhaps even in dedicated slots.
Level design
Each layer/level has a specific type of environment, background audio, characters/creatures and puzzles.
Level design :: Environment
Most environments will be based on a simple grid, each cell often containing a tileset element to assemble a visual background.
Depending on content, each layer can exhibit an appropriate cell/field size and view engine (map view, 30° top down, or isometric).
Level design :: Ambient audio
... loop ... track/noises ...
Level design :: Characters
These are the humanoid or animalistic beings our avatar might communicate with.
As of figure size (bounding box), we're presumably in the range between 32×32 and 64×96 px, depending on view engine properties:
Level design :: Characters :: Dialogue
Rudimentary communication can work (by means of behaviour, gesture, or overlayed icons), but for conveying more complex information, speech bubbles or popups are better choices. It all depends on puzzle types and especially the quest plots, before which some kind of dialogue would probably take place.
Level design :: Creatures
These are non-talking humanoid, animalistic, or even herbal beings. By nature most of them behave neutral, but some are hostile.
Level design :: Puzzles
In general, players have to deal with 3 types of problem-solving:
- Environmental manoeuvres (finding a path, e.g. entering/escaping a building).
- Interconnected levels (spillover effect, e.g. actions impacting other layers).
- Visual clues, e.g. similar path with similar obstacle (removable only in one layer, but then automatically vanishes in another layer too).
- Auditive clues, e.g. switching a radio/tv or playing a CD/DVD provides a required background music in another layer.
- Item/artifact retrieval (discover and collect), mainly to reach the actual goal.
Level design :: Quests
A quest is basically a task (related to a character) that must be accomplished to gain a needed information or item in return. It's pretty much about doing someone a favour to advance the plot.
Controls
Per default, avatar movement is controlled by point&click, by which mouse/touch usage is supported automatically. To keep things simple, dragging shouldn't be required.
Supplemental keyboard control (arrow keys) is recommended.
Inventory
Optional slots in a side panel, to store items.
Number, size, and shape of slots depend on the needs of the current layer.
When entering a new layer, its inventory is usually empty, but it's possible to preset one (or more) items, indicating that the player can already carry stuff in his pockets at the start of a dream.
Of course, upon awakening in a lower level, its inventory content gets restored to what the player owned in the moment he fell asleep.
For artifact collection there's a dedicated area (with a handful of slots) that's always visible in a corner of the screen.
Appendix :: Melatonin function
See also: Draft: Bar
To change this value in a more interesting way than just linearly, we use a general exponential function: f(x)=ex.
Inspecting its curve, we see that the range [-4 … 1]
looks about right for our requirements:
It starts pretty close to zero at f(-4), and ends in
a steep rise at f(1).
As for rendering/calculating the physical bar, we'd prefer to have normalized (0…1) ranges, both for the barDuration and the actual melatonin level. Therefor we define T as the normalized barDuration (the time it takes for the level to naturally rise from minimum to 100%).
First we need to map our range T (0…1) to the chosen range [-4 … 1] of the curve, so the appropriate exponential values can be retrieved:
f(x) = exp((T - .8) × 5)
Then we also normalize the result, by scaling it down, using the maximum at f(1), which happens to be e. Out comes the formula for the desired melatonin level [0 … 1]:
Mel(T) = exp((T - .8) × 5) / e
Side note: The lower bound at Mel(0) is actually non-zero (~.0067), because ex isn't zero in f(-4) either, but this is fine. It mirrors the biochemical fact that a neurotransmitter quantity never reaches absolute zero in the brain.
Also, when it comes to bar rendering, we'll show a minimum width of 1 px (to avoid an empty bar) anyway.
When manipulating Mel manually, its value must be kept in a decent range (here: [.007 … 1]), since numbers <0 or >1 don't make sense in a normalized setting.
Finally, we need an inverse formula, so T can be adjusted after Mel has been altered explicitly, e.g. via caffeine, or barbiturate.
T(Mel) = log(Mel × e) / 5 + .8
Appendix :: Puzzle ideas
