Design Patterns Quiz

Introduction to Games Engineering

• A practical guide to games engineering, focusing on good practice rather than deep theory
• Aims to make coding easier and improve overall intuition
• Will not delve into complex theoretical backgrounds

Overview

• Object-Oriented Programming (OOP) principles
• Problem-solving strategies
• Design patterns
• Software Engineering (SE) principles

OOP Overview

• Object-Oriented Design with Applications (Grady Booch, 1991)
• Object-Oriented Programming (OOP): Abstraction, Encapsulation, Hierarchy, Polymorphism

Abstraction

• Defining aspects of the computation as objects (e.g. graphical components)
• Booch defines abstraction as the characteristics of an object distinguishing it from others and crisply defining conceptual boundaries relative to the perspective of the view

Encapsulation

• Binding data and operations together within each class
• Includes interface and implementation
• Information hiding: Enforcing modularity and reducing coupling
• Liskov emphasizes encapsulation for abstractions to function effectively

Hierarchy

• Organizing relationships through inheritance and composition
• Simplifies code, promotes clarity and reflects real-world relationships

Polymorphism

• "Many shapes" Objects respond to operations based on their type
• Extending with new behaviors without modifying existing behaviors

Other Principles

• Modularity: Architecting loosely coupled, reusable modules
• Reusability: Encouraging component reuse
• Dynamic Binding: Determining method calls at runtime

Random Walk Problem

• Simulating a robot's movement in a Cartesian grid
• Different movement chip types (e.g., compass directions, diagonal movements) and field types (e.g., uniform, diagonal warp space, slanting)
• Movement varies depending on field configurations (e.g., uniform, diagonal shifts, etc.). These details are explained in a) to i) on slide 10.

Coding (Implementation details)

• Utilizing location.h for position tracking
• Separating the concerns into distinct classes (e.g., location, movement, robot, field, simulation)
• Promoting a clear modular design

Abstraction (Implementation)

• Classes abstract functionality across the system's classes: (e.g., Location, Movement, Robot, Field, Simulation).

• Interacting with these components without knowing implementation details.

Encapsulation (Implementation)

• Classes protect data; allowing controlled access (e.g. Robot access to location)
• Internal implementation details are not visible or manipulated directly.

Hierarchy (Implementation)

• Inheritance for movement and field implementation
• Composition in the robot and simulation components to represent a cohesive system

Polymorphism (Implementation)

• Use virtual functions (movement::move(), field::moveInField()) to support varied movement modes with ease.

Design Patterns

• Principles stemming from Booch's OOP
• Design Patterns (Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides, 1994) address recurring problems in software development
• Abstract Factory: Handles families of related objects without specifying concrete classes.
• Builder: Separates object construction from its representation.
• Factory Method: Creates objects by copying an existing object.
• Prototype: Creates new objects by cloning existing ones (important for avoiding redundant instantiation).
• Singleton: Creates a single instance of a class and provides a global access point.
• Adapter: Converts an existing interface into another interface clients expect.
• Bridge: Decouples abstraction from implementation to allow independent variation.

Singleton Pattern

• Ensures only one instance of a class exists globally
• Provides a controlled access point often used for managing global resources such as loggers, configuration managers, database connections, etc or as a pattern for getting the one single instance of a class (eg. a random engine).

Factory Method Pattern

• Encapsulates object creation logic as an interface, allowing flexibility
• Client code then relies on the factory to produce the correct object instance, without knowing specific classes.
• Solves the problem of adding many different types of objects that vary in a multitude of ways/conditions/strategies.

Strategy Pattern

• Encapsulates interchangeable algorithms and allows runtime selection of those specific algorithms. This facilitates swapping out different movement/field types.

Template Method Pattern

• Base classes define algorithms and derived class override specific steps
• Enforces a consistent structure for handling a set of operations (eg. rendering pipeline) in a consistent way across subclasses.

Mediator Pattern

• Simplifying interaction between objects; reduces the code necessary for implementation in multiple places. The mediator handles the interaction between objects without requiring them to know of each other's existence.

Applications of Mediator Pattern

• Networking: Communicating with remote components without involving other components directly.
• Entity Component Systems (ECS): Managing interactions between components (eg. attack and health systems) without needing to alter the core entities.
• Combat calculators: Handling calculations between different entities (characters) without requiring them to know of each other's existence.

Iterator Pattern

• Iterating through objects, particularly for container structures.
• This promotes code reusability, making it easy to implement iterative traversals in consistent ways.

Prototype Pattern

• Creating unique instances for objects (eg. robots, fields).
• Cloning previously instantiated objects (using clone) rather than instantiation helps in avoiding redundant instantiation. This is helpful in ECS.

Observer Pattern

• Establishing a relationship for listening to updates and informing multiple other elements in the system of changes.

• Useful in circumstances requiring a multiple observer system, or a system requiring awareness to changes in state.

State Pattern

• Enables flexible changes in object behavior based on its internal state.
• Useful when object behavior depends on its various states (eg. traffic light).

Software Engineering Principles

• Broad guidelines for efficient, high-quality, reliable systems.
• Covers design, implementation, testing and maintenance.

Modularity, Abstraction, Encapsulation, Separation of Concerns, Single Responsibility Principle, Open/Closed Principle, DRY, KISS, YAGNI, High Cohesion and Low Coupling, Scalability, Maintainability, Testability, Reusability

• Principles used to define and construct consistent and reliable programming.

Composition vs. Inheritance

• Composition over Inheritance: Emphasizes how to use relationships and composition to build dynamic systems that are easily changeable and maintainable.

Multiple Inheritance Diamond Problem

• Detailed overview, including the difficulties of multiple inheritance and how to avoid them

Entity Component System (ECS)

• Detailed overview of architecture, including component structure, operations and game entity management.

Test your knowledge of essential design patterns in software engineering. This quiz covers various patterns, including the Singleton, Observer, and Adapter, and their roles in creating efficient software architectures. Perfect for software designers and developers looking to deepen their understanding of design principles.