Game Engine Structure Design Patterns

There are convention for software architecture I understand. However, there is not a single source for design patterns for game engine. I will research with Scrut.Hut Game Studio, LLC to form standard design patterns. We are researching at the current moment. Please follow the provided bellow.

There would also be required tools and a game editor, which should incorperate the ability to be used as a map editor.

Here is a display of some work.

The follow is an abstraction of a layered game engine. Thus you can piece a game engine together in anyway.

Engine Abstraction

Core Abstraction
Domain Layer
Behavior Abstraction

With the following architectures constructed from the abstractions you can construct four different game engines.

Architecture

Core

Kernel Design Pattern
Service Design Pattern

Kernel Design Pattern
Shell Design Pattern

Behavior

Logic Design Pattern
Scene Design Pattern

Layers Design Pattern
Context Design Pattern

Game Engine Design Patterns

Kernel Design Pattern

Shell Design Pattern

Service Design Pattern

Logic Design Pattern

Scene Design Pattern

Layers Design Pattern

Context Design Pattern

This leads us therefor to the following design patterns.

Software Design Patterns

Object Library Design Pattern

Namespace Design Pattern

Existing Design Patterns

Abstract Factory Design Pattern

Prototype Design Pattern

Singleton Design Pattern

Visitor Design Pattern

Command Design Pattern

Observer Design Pattern

State Design Pattern

Interpreter Design Pattern

The cool thing about patterns or other high level design principles is that you can post an entire list of abstract goals, like you just did, while sounding smart without actually saying anything concrete. ;D

Personally i do not really miss a game engine patterns book. Confusion would be the only outcome for sure.

Sir, please allow myself to respond to what you stated regarding my post. You pointed out that I did not explain, thus I must be explicit and expand; thank you for the chance. I also do not agree that it would be cause confusion. Now like I said if given designs like stamp or templates, or simply pieces of a game engine then it is garbage. What I posted is an example due to it being only consisting of one abstraction as a base, as there are many different abstractions, along with other methods to designing a game engine.

Engine Abstraction

Core Abstraction - Facilities logic that incorporate features implementing Services.

Domain Layer - Subsystems such as Graphics, Audio, Physics, etc...

Behavior Abstraction - Centralizes Behavior of the Game Engine.

The scene can be resolved with entities, while implementing mechanics in any given way; component or structured behavior with hieratical design can be used for example, although in my game engine I went a different route.

An important part of a Game Engine is the Logic Loop, or Main Loop. This would be handled in some fashion.

There is much more to be stated, and yes it is easy to break down. Such as context, or game logic; a simple method levels could be the constituents of the engine, as said in such a way that the engine just reloads for a new level. Objectified game behavior would result if designed correctly.

There is abstraction with a patterned architecture, yet the implantation may differ. That is why I am using multiple Kernels for example, such as there already is defined in the industry. However, the patterned architecture design does not change. In reality I might convey in a much more clear while modeling using patterns if I was writing a book.

Core Abstraction - Essential Services and Facilities that is Imposed by the Game Engine

Architecture with conventional Game Engine Kernel

Kernel Design Pattern - Kernel Design Pattern which would include Graphics, Network, Audio, Physics, etc... This can be designed so that there is some managers for each domain compounding behavior.

Service Design Pattern - Functionality of the system by objectifying with facilities such as memory, task, event, etc... This would be composed of systems that are compounded by the resolved the Behavior Abstraction with an implantation.

Architecture with Game Engine Micro-Kernel

Micro-Kernel Design Pattern - Functionality of the system by providing services for such as memory, stream, parallel, etc...

Shell Design Pattern - Interface for the kernel, such as compounding logic / behavior with commands and streams.

Behavior Abstraction - Mechanics with Structured Logic by Design

Scene Design Pattern - Everything within the realm of the map, or level. That is including objects that are not visible, including path finding nodes, triggers, etc...

Logic Design Pattern - Logic is composed of the main Logic Loop, and coordinates the entire Engines behavior such as governor.

Layers Design Pattern - Abstractions of the screen logic, as it can be Object - Scene - Interface.

Context Design Pattern - Controls the switching of Scene, and controls the project; it also includes the main Logic Loop.