Definitions of “Game” from Game Studies Literature

This is a chronological overview illustrating the diverse perspectives on what constitutes a game, reflecting the evolving understanding within game studies:

Author Title Year Definition Type Mentions Rules? Mentions Mechanics? Mentions Goals/Outcomes? Mentions Play/Voluntary? Other Notable Concepts
Johan Huizinga Homo Ludens: A Study of the Play-Element in Culture 1938 Activity Yes No No Yes “Tension, joy, and consciousness that it is different from ordinary life.”
Roger Caillois Man, Play and Games 1958 Activity Yes No No Yes “Separation, uncertainty, unproductivity, make-believe.”
Bernard Suits The Grasshopper: Games, Life and Utopia 1978 Activity Yes Yes Yes Yes “Voluntary attempt to overcome unnecessary obstacles.”
Chris Crawford Chris Crawford on Game Design 1984 System Yes Yes Yes No “Interactive, goal-oriented activity with active agents to play against.”
Greg Costikyan “I Have No Words & I Must Design” 1994 System Yes Yes Yes No “Form of art in which players make decisions to manage resources through game tokens in pursuit of a goal.”
Clark C. Abt Serious Games 1970 Activity Yes Yes Yes No “Activity among two or more independent decision-makers seeking to achieve objectives in a limiting context.”
Elliot Avedon & Brian Sutton-Smith The Study of Games 1971 Activity Yes Yes Yes Yes “Exercise of voluntary control systems in which there is opposition between forces, confined by rules.”
Kevin J. Maroney “My Entire Waking Life” 2001 Activity Yes Yes Yes No “Form of play with goals and structure.”
Katie Salen & Eric Zimmerman Rules of Play: Game Design Fundamentals 2004 System Yes Yes Yes No “System in which players engage in artificial conflict, defined by rules, resulting in a quantifiable outcome.”
Jesper Juul Half-Real: Video Games between Real Rules and Fictional Worlds 2005 System Yes Yes Yes No “Rule-based system with variable and quantifiable outcomes, where different outcomes are assigned different values.”
Jane McGonigal Reality is Broken 2011 Activity Yes Yes Yes Yes “Games share four defining traits: a goal, rules, a feedback system, and voluntary participation.”

Examples of Games classified according to the elements found in the definitions of what a Game is

Here is a comprehensive table that incorporates all the elements of games (Rules, Goals, Mechanics, Competition/Conflict, Voluntary Participation, Outcome, and Environment/Space) for the games previously discussed. The Rules column contains bullet points for each game.

Game Rules Goals Mechanics Competition/Conflict Voluntary Participation Outcome Environment/Space
Soccer - No hands allowed except for the goalkeeper.
- Score by getting the ball into the opponent’s net.
- Offside rules restrict player positioning.
- Fouls lead to free kicks/penalties.
- The team with the most goals wins.		 Score more goals Passing, dribbling, kicking Opposition from another team Yes Win/Draw/Lose Physical field
Basketball - Players must dribble while moving.
- Shots are worth 1, 2, or 3 points.
- Fouls result in free throws or turnovers.
- The game is divided into quarters.
- The team with the most points wins.		 Score more points Shooting, passing, defending Opposition from another team Yes Win/Draw/Lose Physical court
Super Mario - Navigate levels by running, jumping, and avoiding enemies.
- Collect coins and power-ups.
- Complete levels by reaching the flagpole or defeating a boss.
- Limited lives define retries.		 Complete levels Jumping, collecting items Obstacles and enemies Yes Level progress/completion Virtual game world
Chess - Each piece has specific movement rules (e.g., pawns move forward, bishops diagonally).
- Objective: checkmate the opponent’s king.
- Moves must follow a turn-based sequence.
- Cannot move into/through check positions.		 Checkmate opponent’s king Moving pieces strategically Direct opposition from opponent Yes Win/Lose/Draw Board (defined space)
Monopoly - Roll dice to move around the board.
- Buy properties when landed on.
- Pay rent when landing on another player’s property.
- Special spaces (e.g., Chance) create random effects.
- Bankruptcy eliminates players.		 Amass wealth, bankrupt others Rolling dice, managing resources Opposition from other players Yes Win/Lose Board (defined space)
Tennis - Players hit the ball over the net within bounds.
- A point is lost if the ball is out, into the net, or not returned within one bounce.
- Matches are divided into sets.
- Players alternate serves after every game.		 Win sets Hitting ball, positioning Opposition from another player/team Yes Win/Lose Physical court
Minecraft - Survival Mode:
- Gather resources to craft tools and build.
- Avoid environmental hazards like monsters.
- Creative Mode:
- Unlimited resources, no health constraints.
- Goals are player-defined.		 Open-ended creation or survival Building, exploring, crafting Environmental hazards or competition Yes Open-ended, personal Virtual open world
The Sims - Manage Sims’ needs (hunger, hygiene, etc.).
- Use in-game currency to build homes and buy items.
- Failure to meet needs can result in death or negative events.
- Open-ended gameplay allows players to set objectives.		 Simulate life objectives Managing characters’ actions Self-imposed challenges Yes Open-ended Virtual house and community
Tag - “It” chases and tags others.
- Players avoid being tagged.
- Stay within the designated play area.
- Game ends when a pre-defined condition is met (e.g., time limit).
- Physical interference is not allowed.		 Avoid being “it” Running, tagging Opposition from other players Yes Win/Lose (caught or not) Physical space
Poker - Players receive hands of cards.
- Bet chips based on hand strength or bluffing.
- Turn order governs betting.
- Highest-ranking hand wins at showdown.
- Revealing cards outside phases is forbidden.		 Win chips/money Betting, bluffing, hand ranking Competition among players Yes Win/Lose Table (defined space)

A Game Engine View on what is a Game

Here’s a table detailing how a game is structured and viewed from a game engine perspective, highlighting the terminology and elements for popular engines like Unity, Unreal Engine, Godot, and others. Each row explains key aspects of how games are designed and implemented in these engines.

Aspect Unity Unreal Engine Godot General Notes
Game Elements - Scenes
- GameObjects
- Components		 - Levels
- Actors
- Components		 - Scenes
- Nodes
- Resources		 Games are divided into hierarchical structures like scenes, levels, or objects.
Entities - GameObjects: Core building blocks.
- Components: Add functionality to GameObjects.		 - Actors: Basic objects with behavior.
- Components: Define specific attributes/abilities.		 - Nodes: Fundamental objects organized hierarchically.
- Resources: Shared data for nodes.		 Entities are fundamental building blocks. Components add specific functionality.
Rules - Scripted using C# scripts.
- Managed via logic in the Unity Editor.		 - Scripted in Blueprints (visual scripting) or C++.
- Rules defined in level/game logic.		 - Scripted using GDScript, C#, or Visual Script.
- Managed by nodes or signals.		 Rules are implemented through code or visual scripting tied to entities.
Assets - Stored in the Assets folder.
- Imported via the Unity Editor.		 - Managed via the Content Browser.
- Supports many formats, stored in the project folder.		 - Managed in the FileSystem tab.
- Resources are stored and loaded dynamically.		 Assets include textures, models, sounds, and scripts managed by a project hierarchy.
Physics - Rigidbody and Colliders define physical interactions.
- Includes built-in 2D/3D physics.		 - Uses PhysX for realistic physics.
- Simulations applied to actors via physics components.		 - Physics managed via Rigidbody2D/3D and Colliders nodes.
- Customizable properties.		 Engines integrate physics systems with customizable rigidbody and collider components.
UI System - Canvas is the base element.
- UI elements (buttons, images, etc.) are children of Canvas.		 - Uses Widgets through the UMG (Unreal Motion Graphics) editor.
- Supports 2D/3D UI.		 - Control Nodes handle UI elements (e.g., buttons, labels).
- Flexible layout control.		 UI systems are hierarchical, with layouts managed via dedicated elements like Canvas or Widgets.
Game Logic - C# scripting controls behaviors.
- Event-driven logic via Unity’s Event System.		 - Blueprint visual scripting or C++ manages behaviors.
- Logic can be node-based in Blueprints.		 - GDScript or Visual Script manages behaviors.
- Signals manage event-driven logic.		 Game logic is highly scriptable, with support for visual and textual programming.
Rendering - Uses a Render Pipeline (URP or HDRP) for graphics.
- Handles shaders through a Shader Graph or custom code.		 - Built-in rendering with Material Editor and shaders.
- Real-time ray tracing supported.		 - Uses a flexible rendering engine with Material Nodes.
- Supports custom shaders.		 Rendering systems handle visuals with built-in pipelines or custom shader systems.
Audio - Managed via AudioSource and AudioListener components.
- Advanced features in the Audio Mixer.		 - Uses Audio Components.
- Spatialized sound supported for 3D games.
- Sound Cues handle complex audio behaviors.		 - AudioStreamPlayer and AudioBus nodes control sounds.
- Supports 2D/3D audio spatialization.		 Audio systems support basic playback, spatial sound, and advanced mixing features.
Collaboration - Supports Plastic SCM, Git, and other VCS.
- Unity Collaborate available for smaller teams.		 - Integrates with Perforce, Git, and Source Control tools.
- Optimized for large teams.		 - Git-based workflows supported natively.
- Light tools for smaller teams.		 Collaboration tools are essential for teams, with built-in or external integrations.
Scripting Language - Primarily C#.
- Supports third-party visual scripting tools like Bolt.		 - C++ for advanced logic.
- Blueprints for visual scripting.		 - GDScript (Python-like), C#, or Visual Script.
- Customizable and lightweight.		 Engines support multiple scripting options, balancing simplicity and performance.
Setting Up Rules - Scripts attached to GameObjects.
- Rules executed as game loops or triggered by events.		 - Rules are embedded in Blueprints or coded in C++.
- Level-specific logic is common.		 - Rules defined by node-based hierarchy and signals.
- Scripting manages logic for specific nodes.		 Rules are closely tied to entity behaviors, implemented as code or visual flowcharts.