• # Fundamentals of Horror

Game Design and Theory

What is Horror?  Horror is a work that causes a person to feel fear; a feeling induced by perceived danger or threat.  But people have greatly evolved and modern people are sometimes more afraid of taxes than real dangers!

All horror games can be divided into psychological or non-psychological horror games. This is not an indicator of quality, but only the method of frightening a person.  Non-psychological horror games can be very good games, and psychological may well be bad.  Let's see what the difference is between them.

Non-psychological horror games use our primitive fears such as fear of pain and death. These games frighten the player during the game.

This includes survival horror, action horror, stealth horror, simple screamers and much more.  In such games for the life of the game character in the game, there is a direct danger. But the problem is that a person has a mental barrier that turns on during the game. The game needs to break through this barrier in order to scare the player.

To break through the barrier using three methods: flow, pressure, and payback.   Each of the methods greatly affects the gameplay.

## Flow

Flow is one of the reasons why new horror scolds for the fact that the game has more become an action game than a horror. But here it is necessary to understand the developers want to create a good horror game and using this principle is not bad. It's just very difficult to balance it. Developers try to create an endless action in which the boundaries between themselves and the character will blur.  To do this, the player is given a huge number of tasks, the player concentrating on these tasks gradually removes the mental barrier, as a result, unexpected events do start to have effects on the player.

Good examples: dead by daylight, deceit.

## Pressure

Pressure is one of the reasons why most monsters in new projects are either unrecognizable or unresponsive to any player's actions. The skills of players are growing. Now it's hard to find the level of difficulty for the players. The computer is predictable, and if the monster in the game can be destroyed, then the game becomes easy for a large part of the audience. So the developers went to the trick. Now most of the monsters are immortal, and even if they are still so stupid by the standards of the player, now they really begin to create complexity for the player. If you manage to make the monsters smarter the game will really scare the player.

Good examples:  Alien: Isolation, SCP.

## Payback

Payback - adds extra weight to our failure. The player begins to fear not death in the game, but the result of death, punishment. The further the player passes and receives more, the greater the weight becomes on the shoulders of the player, and the stronger the player begins to fear defeat. The player can lose all the progress of the game, or lose all his equipment.

Good examples: Zombiu, DayZ.

# Psychological Horror

Psychological horror uses our subconscious fears: loneliness, sanity of mind, punishment, correctness of choice. These games lay in the player certain thoughts that start to frighten the player behind in the real world.

There are two methods of creating psychological horror: creation and awakening.

Awakening is a method during which one of the person's subconscious conflicts will awaken. Because of this method, many games that are basically the usual horror are called psychological. Since this method can be modular and used in just a couple of moments. This method is easy to use. And he bases on a lot of psychological principles, which is the norm for most people.

Awakening uses such principles: knowledge and understanding, powerless, uncanny valley, disorientation, fishy, against the mirror.

• Knowledge and understanding - Part of good horror is a mystery. The player has too little information, or the person is not able to understand this information.
• Powerless - The main character is weak and insignificant. He is not able to do anything or change anything. Caught in a whirlpool of events, that is much more of a player. The player turns into an involuntary observer in order. Lovecraft loved to use this principle in his works.
• Uncanny valley – Human consciousness is very stereotyped. So we deceive the player. Breaking these stereotypes and forcing the player to doubt his own sanity. This principle works in two ways: looks and functional.
• Looks. If there is something with which you are well acquainted, and will be changed a little. If the change is insignificant and it cannot be found unless specifically looked for it. Then the player will have a strange sense of paranoia and fear. After all, although the player deliberately did not notice the difference, subconsciously the mind noticed everything and began to sound the alarm.
• Functional . If something looks like a mug, then it's a mug, not an alien killer. Until one day you do not fall into an alien killer disguised as a mug. You are used to the fact that bullets do damage to enemies. But that if among the bullets there are blank bullets.
• Disorientation – Disorientation is based on our standard perception of the world: time, space and gravity. Any manipulation of time, space confuses the perception of the world in the player disorienting and frightening him. The first part of the "Evil within" is almost completely built on this principle.
• Fishy - This principle works in contrast to the Uncanny valley. The human brain reacts very peculiarly to events, and if events that seem unlikely or impossible to our mind suddenly occur, then our brain starts to believe that something is wrong.
• Imagine that you were kidnapped. You come to consciousness in a locked warehouse with 30 more people. Everyone starts to communicate and it turns out that everyone in the room is called Larry and only you have a different name. Even if it's just a coincidence, this fact scares you much more than the fact of abduction itself.
• Against the mirror – The principle in which a player is forced to meet the result of his actions.  The player does something that he thinks is right or something that the game asks for. Then he meets with the consequences of his actions. Examples of good games with this principle: spec ops the line, undertale, silent hill.
• Loneliness – The player is isolated from other people or the outside world.

If you simply use these principles without context, then it will lead to nothing. But awakening in good hands can be extremely powerful. Let's look at PT and what it uses.

1. Constant return to the same room. This is the principle of disorientation.
2. At every entry in the room the room changes. Using the Uncanny valley.
3. At some point the radio will ask the player to turn around.. Fishy principle.
4. The game has no background. And the player learns all the information from the environment and the radio. The principle of knowledge and understanding.
5. The player is not able to do anything against the ghost. The principle of powerless.

### Creation

You work from scratch. You do not know what the man is afraid of. But taking as a basis a person who has a specific fear (phobia). Taking his experience, the cause and vision of the world under the influence of this fear. You create this fear for the player from the very beginning. Create a world and experience in which this fear really matters.

Examples of phobias and how to turn them into a game:

• Acrophobia – Imagine a game where the player needs to cross the skyscrapers along the rope. And in case of a fall you will fly to the end down.
• Apiphobia – Imagine a game where all the bees went crazy and made a real apocalypse. Completely exterminating all people and nurturing the nests everywhere including the bodies of men. And throw the player to survive in this. No worse than a zombie apocalypse.
• Haptophobia – The game character gets injured in every physical encounter with any person. Now you need to get out of the huge metropolis on foot. All residents go about their business and do not pay attention to you. And only you need to avoid the clash with people.

Report Article

## User Feedback

Excellent! I recommend everybody to read The Uncanny (Freud). It's a great piece of work that helps you understand and conceptualise horror. I also recommend Foundations on Literary Studies on the uncanny and Frankenstein.

##### Share on other sites

A brilliant article. Please delve more into the categories and pinpoint the details if possible.

##### Share on other sites

Posted (edited)

On 11/10/2018 at 12:57 AM, EagleGamer said:

A brilliant article. Please delve more into the categories and pinpoint the details if possible.

Knowledge and understanding
You give the player a few pieces of information, they may or may not be related. But the main thing in this principle is to confuse the player. Make the player build theories and not understand what is happening around. While the player understands what is happening, he thinks that he is in control. But if he falls into a storm of events and does not understand what is happening, then for the player’s mind this situation will be tense and frightening.
This principle only works once and until the player knows the story of the game. The longer the player will not understand the principles and principles of events that are happening around, the longer this effect will continue.
Examples: Silent Hills, Outlast, Evil within, Alan wake.

Uncanny valley
The human mind is full of stereotypes. Periodically unexpectedly breaking these stereotypes, you can not only frighten a person, but also break his stereotype perception of the world. At such moments, the mind begins to doubt its own sanity rather than accept, then there are exceptions and rules.

These stereotypes can be divided into two types.
Visual and mechanical.

Visual (Looks)

We have stereotypes about how certain things look. If there are certain differences that make a thing stop falling into this category.
For example, you have a computer mouse. By itself, it does not scare you. But if we discreetly stick plastic spider legs to this mouse. Then the other people the first reaction will be an overwhelming fear and disgust. You can take any object or live organism and change it, make it frightening for a person, because it will no longer fit.

A good example: Portraits that follow with their eyes over the player, or pictures that change from the angle at which you look at them are good classic examples. (They also become stereotypical things, but I try to explain the principle.)

Mechanical (Functional)

A person has the same stereotypes about how some objects work. And changing the essence of these mechanics, so that to break steriotypy can be a good scare player. For example, a player knows that with a pistol, you can shoot monsters. And as he went through the whole game, he remembered this mechanic and took it for granted. But if a character gets into a certain level when using a pistol, character will just kill himself, it will be a surprise that will frighten the player.

It is important that when using this principle in mechanics, you add a new rule, so that the player can, over time, understand the essence of the changes of mechanics, and do not think that the game is not fair. You do not tell you what new rules and when you will apply them to him, but the player by trial and error can understand all this himself.

Example: mimik from Prey.

Fishy

Our mind is very specific to probability. If the chance of something is very small, or almost impossible, then our mind decides that this event is impossible. If such an event occurs, then it ceases to be an accident, someone arranged this event. And a person begins to paranoidly search for people or people involved in this event.
A good example:  short film Sequence - by Carles Torrens

These are the most difficult to understand principles, so I'll write them out a little more, in case you don’t understand them. But the goal of this article is for you to understand how these princes work and to find your own use for them.

If there are more questions ... Then write me and I will try to answer.

Edited by White_crow

## Create an account

Register a new account

• ### Game Developer Survey

We are looking for qualified game developers to participate in a 10-minute online survey. Qualified participants will be offered a \$15 incentive for your time and insights. Click here to start!

• 3
• 0
• 4
• 0
• 3

• 12
• 30
• 9
• 16
• 12
• ### Similar Content

• By mujina
What could be a way of avoiding using inheritance and virtual methods when designing components for an entity-component-system?
I'll be more specific about my design issue:
I currently have different classes for different kinds of colliders (let's say, CircleCollider and LineCollider).
My system that checks for collisions and updates the positions and/or velocities of my entities should be something like:
for entity_i in alive_entities { collider_i = get_collider_of_entity(entity_i) // components of same kind are stored contiguously in separate arrays transform_i = get_transform_of_entity(entity_i) for entity_j in alive_entities { collider_j = get_collider_of_entity(entity_j) transform_j = get_transform_of_entity(entity_j) if check_collision(collider_i, collider_j) { update(transform_i) update(transform_j) } } } my problem is that I don't have a generic get_collider_of_entity function, but rather a function get_circle_collider_of_entity and a separate one get_line_collider_of_entity, and so on. (This happens because under the hood I am keeping a mapping (entity_id -> [transform_id, sprite_id, circle_collider_id, line_collider_id, ...]) that tells me whether an entity is using certain kinds of components and which are the indices of those components in the arrays containing the actual components instances. As you can see, each component class is corresponding to a unique index, namely the index position of the array of the mapping described above. For example, transforms are 0, sprites are 1, circle colliders are 2, line colliders are 3, and so on.)
I am in need to write a system as the one in the snippet above. I can write several overloaded check_collision functions that implement the logic for collision detection between different kinds of geometric primitives, but my problem is that I am not sure how to obtain a generic get_collider_of_entity function. I would need something that would get me the collider of an entity, regardless of whether the entity has a circle collider, a line collider, a square collider, etc.
One solution could be to write a function that checks whether in my internal entity_id -> [components_ids] mapping a certain entity has a collider at any of the indices that correspond to colliders. For example, say that the indices related to the collider classes are indices 10 to 20, then my function would do
get_collider_of_entity (entity_id) { for comp_type_id in 10..20{ if mapping[entity_id][comp_type_id] not null { return components_arrays[comp_type_id][entity_id] } } return null } This could turn out to be pretty slow, since I have to do a small search for every collider of every entity. Also, it may not be straightforward to handle returned types here. (I'm working with C++, and the first solution - that is not involving inheritance in any way - would be returning a std::variant<CircleCollider, LineCollider, ... all kinds of components>, since I would need to return something that could be of different types).
Another solution could be having some inheritance among components, e.g. all specific component classes inherit from a base Collider, and overrride some virtual collide_with(const Collider& other) method. Then I would redesign my mapping to probably reserve just one index for colliders, and then I would actual colliders in a polymorphic array of pointers to colliders, instead of having a separate array for CircleColliders, another for LineColliders, and so on. But this would destroy any attempt to be cache-friendly in my design, wouldn't it? That's why I am looking for alternatives.
A third alternative would be to just have a single, only, Collider class. That would internally store the "actual type" ( aka what kind of collider it is ) with dynamic information (like an enum ColliderType). Then I would have all colliders have all members needed by any kind of colliders, and specific collision detection functions which I can dispatch dynamically that only use some of that data. (Practical example: a "Collider" would have a radius, and the coordinate for 2 points, and in case its type was "circle" it would only make use of the radius and of one of the 2 points - used as the center -, while if it was a "segment" it would only make use of the 2 points). My gut feeling is that this would bloat all colliders, and, even if the bloat could be reduced - using unions in some smart way for storing members? I wouldn't know how -, then still the design would be pretty brittle.
I'm clueless and open for ideas and advice! How do you handle in general situations in which you have components that can be naturally modeled as subclasses of a more generic component class? Inheritance? Smart hacks with variants, templates, macros, custom indexing? Dynamic "internal" type?
×