Jump to content
  • entries
  • comments
  • views

Making decisions – Dual-process theory




Hello again, I’m sorry for not releasing an article last week. I was on a last minute trip to Sweden to check out Uppsala, the city I will study next year. So with any further ado, let’s start this article about making decisions. Making decisions is essential to any game, no matter the genre or target audience. To play a game is to make decisions. While there are many different theories that approach decision making from different angles, today I will focus on the dual-process thinking proposed by Kahneman (2014).

We have to make decisions every day about what to wear, what to have for breakfast and many more. Some of these decisions are made conscious and deliberate while others are unconscious and automatic. Let’s imagine you want to buy a new phone, this usually is a conscious decision. First you narrow down the options based on your wants and needs but also on intuition and gut feeling. Did you have a good experience with your previous phone? Maybe you will consider phones from the same brand. Once you narrowed down your options you are ready to make your final decision. This time you carefully weigh the pros and cons of the remaining phones. This method of making choices is based on two systems of thinking, otherwise known as the dual-process theory: system 1 thinking and system 2 thinking (Kahneman, 2014). Dual-process theory is not just about making decisions, it’s about thinking and problem solving in general. You use system 1 thinking to narrow down your options to just a few and then you use system 2 thinking to make the final decision. System 1 thinking is automatic and unconscious, it helps you make rapid decisions and develop first impressions. This system is what you would call your gut-feeling or intuition and you cannot turn it off. System 1 thinking can help you make some satisfactory decisions very quickly. However there is no guarantee for correct decisions, most of the times system 1 thinking leads to poor decisions (Stanovich, 2008; Tversky & Kahneman, 1993, 1974). System 2 thinking is more deliberate and controlled. It is otherwise known as reason-based decision-making. The system 2 type of thinking and decision making requires attention, it is effortful and slow. You use logics and reason to come to a conclusion. While this system leads to better choices overall, it can only help when there are just a few options to choose from (Payne & Bettman, 2004). In the case of our phone, you’ll evaluate the characteristics of each phone and use those to compare the phones. It doesn’t matter if you are designing casual games or a hardcore game, all games require the player to make decisions on a regular basis. Being aware of the dual-process theory can help you spot the difference between mindless play (system 1 thinking) and active problem solving or decision making (system 2 thinking). You can make good use of the system 1 thinking mode since its always on in your players. Probably you already aim to design for system 1 thinking in parts of your game with ‘intuitive gameplay’. This is when you use conventions from similar games so the player can make rapid associations and find out how to control the game. But metaphors from the real world can also be used. Think about the gold coins players can collect or buy in many mobile games. A designer’s choice to use gold coins is a conscious one since players associate the metaphor of gold coins with the real coins in their wallet. System 2 thinking is what you should rely on when designing a puzzle game. This more effortful thinking can be a lot fun to people who enjoy these types of games. Being aware that system 2 thinking is a slow process can help you make decisions such as add time pressure to your game for example.

For the design of some games it might be worth-while to learn a little more about dual-process theory. Especially games with many options or choices. Think about Strategy games, city builders and other micromanagement games. But also think about games where creativity is important such as a dress-up game. The player wants to be able to create new and unique things every session. Having many options to choose from can aid this creativity.

Tropico is one of my favorite city builder games because of the humor and setting (go check out the trailer for topico 6 to see what I’m talking about: https://www.youtube.com/watch?v=0J448fXXVFI). Tropico is a micromanagement game for the PC that allows for countless hours of play. This game makes good use of the dual-processing theory in several ways. As a player you have to make lots of choices and the game allows you play a different scenario every time. For many choices the game relies on system 2 thinking but there are little ‘system 1 thinking tricks’ that help the player choose. Think about the layered  menu system they use for selecting buildings. First the player chooses a category, then he/she makes the final choice. This menu system not only allows the player to first use system 1 thinking, but also makes sure the player doesn’t feel overwhelmed by all the options. Another ‘system 1 thinking trick’ is the suggested building that sometimes pops up when a player wants to build something. Without this feature a player has to carefully check all the stats and weight all the options to find that he/she needs to build simple housing a part of the underpaid inhabitants are homeless. The suggested building doesn’t always show up, sometimes the player does need to use system 2 thinking. The two systems of thinking are well balanced in this game.


I was working on a dress-up game for Tingly games (and later CoolGames) called Emma’s dressup party (http://www.coolgames.com/nl/emmas-dress-up-party.html). For a dress-up game it is important to let the player express their creativity. Many choices and options for clothes, accessories and colors ensure that players can create unique outfits every time. I wanted players to be able to express their creativity but at the same time not be overwhelmed by too many options. A layered menu system for all the items was a conscious design choice. It helps the player make one decision at a time from a small range of options. There are 5 categories which each have no more than 4 subcategories. Those subcategories have many items but only 4 are shown per page. And while the player can choose a color for every item it remains an optional decision. Each item comes with a preset color that was set by the artist or me. Also, I limited the choices the player can make during the first session. Many items and colors are locked and can be unlocked with coins. The random button is another little ‘system 1 trick’ I added for the player. A player can let the random button generate a complete outfit when don’t know what to choose just need some inspiration.


As a designer or game developer it is useful to be familiar with the dual-process theory. It can help you improve the way players make decisions or find the correct solution in your game. System 1 thinking is fast and intuitive, your players will rely on this system when there is time pressure in your game. Make sure players can use their intuition or can easily use association to come up with a solution. Are you making a puzzle game? Your players often like these kinds of games because they enjoy effortful thinking. Be careful with time pressure, allow your players time to access their system 2 thinking. Are you thinking to add time pressure to your puzzle game anyways? Make sure the solution is intuitive in some way. Because, players might not get enough time to access their system 2 thinking. Are you designing a strategy game or micromanagement games such as city builder? You might want your players to enjoy your game for countless hours. The game needs to be re-playable over and over again with many different outcomes and decisions to make. Players would like to have many options and choices to make. Adding a layered decision system can help your players to use both system 1 and 2 thinking. In a layered decision system players use their system 1 thinking to first chose a category and then use their system 2 thinking to make an actual decision. Having advisor or suggestions can help your player’s access their system 1 thinking. But deciding on a strategy should largely be up to the player’s system 2 thinking. When you are relying on system 1 thinking for a part of your game, make sure the decision are either almost always correct or that it can be reversed. Many decisions made using system 1 thinking are often wrong, keep this in the back of your mind when designing. Of course, always aim for a healthy balance between system 1 and system 2 thinking depending on the type of game you are making.

Further reading and references:

  • Kahneman, D. & Tversky, A. (1979). Prospect theory: An analysis of decision making under risk. Econometrica, 47, 263-291
  • Stanovich, K. E. (2008). How to Think Straight about Psychology (8thedn). Boston: Allyn & Bacon.
  • Payne, J. W. & Bettman, J. R. (2004). Walking with the scarecrow: The information-processing approach to decision research. In D. J. Koehler & N. Harvey (eds), Blackwell Handbook of Judgment and Descision Making. Malden, MA: Bkackwell Publishing.
  • Kahneman, D. (2014). Thinking, Fast and Slow.JOURNAL OF MANAGEMENT RESEARCH IN EMERGING ECONOMIES, 499.


Recommended Comments

There are no comments to display.

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
  • Advertisement
  • Advertisement
  • Blog Entries

  • Similar Content

    • By OConquestGame
      Hello there!
      I’m the creator and producer of an upcoming visual novel / video game. 
      My team and I are looking for artists (character and background), writers (experienced in writing relatable characters and witty dialogue), and programmers (familiar with unity and creating mini games). 
      Our team is a group of close friends looking to break the mold of the traditional visual novel and create something new and positive. This game will be highly promoted and be a great portfolio piece. Rates are negotiable!
      If you are interested please contact/message us today! OConQuestGame@gmail.com
    • By Gas Lantern Games

      I have spent the last year and a half developing a game in my spare time in Unity! I am releasing it soon on Steam. Ant Empire is a strategic remake of some older games. It is influenced by games such as Ant Empire and Civilization.

      I am currently doing a kickstarter to help fund an AI before launch.

      I have attached some images (tried some gifs but they were too large) to show the current stage of Ant Empire, which is nearly completed.

    • By Shaarigan
      I'm currently starting next iteration on my engine project and have some points I'm completely fine with and some other points and/or code parts that need refactoring so this is a refactoring step before starting to add new features. As I want my code to be modular to have features optional installed for certain projects while others have to stay out of sight, I designed a framework that starting from a core component or module, spreads features to several project files that are merged together to a single project solution (in Visual Studio) by our tooling.
      This works great for some parts of the code, naming the Crypto or Input module for example but other parts seem to be at the wrong place and need to be moved. Some features are in the core component that may belong into an own module while I feel uncomfortable splitting those parts and determine what stays in core and what should get it's own module. An example is Math stuff. When using the framework to write a game (engine), I need access to algebra like Vector, Quaternion and Matrix objects but when writing some kind of match-making server, I wouldn't need it so put it into an own module with own directory, build script and package description or just stay in core and take the size and ammount of files as a treat in this case?
      What about naimng? When cleaning the folder structure I want to collect some files together that stay seperated currently. This files are foir example basic type definitions, utility macros and parts of my Reflection/RTTI/Meta system (which is intended to get ipartially t's own module as well because I just need it for editor code currently but supports conditional building to some kind of C# like attributes also).
      I already looked at several projects and they seem to don't care that much about that but growing the code means also grow breaking changes when refactoring in the future. So what are your suggestions/ oppinions to this topic? Do I overcomplicate things and overengeneer modularity or could it even be more modular? Where is the line between usefull and chaotic?
      Thanks in advance!
    • By PlanetExp
      I've been trying to organise a small-medium sized toy game project to supports macOS, iOS and Windows simultaneously in a clean way. But I always get stuck when I cross over to the target platform. I'll try to explain,
      I have organised my project in modules like so:
      1. core c++ engine, platform agnostic, has a public c++ api
      2. c api bindings for the c++ api, also platform agnostic, this is actually part of 1 because its such a small project
      3. target platform bindings, on iOS and macOS this is in swift. Basically wraps the c api
      4. target platform code. This part just calls the api. Also in swift.
      So in all I have 4 modules going simultaneously, all compiled into a separate static libraries and imported into the next phase/layer. Am I even remotely close to something functional? I seem to getting stuck somewhere between 2 and 3 when I cross over to the target platform. In theory I would just need to call the game loop, but I always end up writing some logic up there anyway.
    • By MarkNefedov
      So, initially I was planning to create a base class, and some inherited classes like weapon/armour/etc, and each class will have an enum that specifies its type, and everything was going ok until I hit "usable items".
      I ended up with creating UsableItem class, and tons of inherited classes, like Drink/Apple/SuperApple/MagickPotato/Potion/Landmine/(whatever that player can use) each with unique behaviour. I planned to store items in the SQLite database, but I discovered that there are not many ways of creating variables(pointers) with type determined at runtime (that preferably get their stats/model/icon/etc from DB). So, I think that I need to use some variation of the Factory pattern, but I have no idea how I should implement it for this particular case (giant switch/case 😂 ).
      It would be really nice if you guys can give me some advice on how I should manage this kind of problem or maybe how I should redesign the inventory.
      Inventory storage is an array of pointers. I'm working with CryEngine V, so RTTI can't be used.
      Example code:
      namespace Inventory { enum ItemType { Static, Building, Usable, Weapon, Armour }; class InventoryItem { public: virtual ~InventoryItem() = default; virtual ItemType GetType() = 0; virtual string GetName() = 0; virtual string GetIcon() = 0; virtual void Destroy() { //TODO: Notify inventory storage delete this; } }; class UsableItem : public InventoryItem { public: struct Usage { int Index; string Use_Name; }; virtual CryMT::vector<Usage> GetUsages() = 0; virtual void UseItem(int usage) = 0; }; class TestItem : public UsableItem { int Counter =0; ItemType GetType() override { return ItemType::Usable; } string GetName() override { return "TestItem"; } string GetIcon() override { return "NULL"; } CryMT::vector<Usage> GetUsages() override { CryMT::vector<Usage> Usages; Usages.push_back(Usage{1, "Dec"}); Usages.push_back(Usage{2,"Inc"}); Usages.push_back(Usage{3,"Show"}); return Usages; } void UseItem(int usage) override { CryMT::vector<Usage> uses = GetUsages(); switch (usage) { case 0: for (int i =0; i<uses.size(); i++) { CryLog(uses[i].Use_Name); } break; case 1: Counter--; CryLog("Dec"); CryLog("%d", Counter); break; case 2: Counter++; CryLog("Inc"); CryLog("%d", Counter); break; case 3: CryLog("%d", Counter); break; default: CryLog("WRONG INDEX"); break; } } }; }  

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!