Game Programming Patterns In Unity With C#

Introduction

Game Programming Patterns  – Software design patterns are generic, reusable solutions to common problems in specific software design contexts in software development. It is not a complete design that can remain converted directly to the source or machine code, and this is an explanation or template for solving a problem that can do used in various situations. Design patterns are formalized best practices that programmers can use to solve common difficulties when designing applications and systems.

Most of the basic ideas used here came from the free book Game Programming Patterns. So if you want to absorb more about design patterns, read on. However, the code in this book is C++ and incomplete, so you cannot add the code to your game engine to run it. The total C# code here does run in Unity with just a few clicks.

1. Object Pool  – Game Programming Patterns

If you have a gun that fires shots, consider reusing them rather than destroying them to spawn new ones. So if the bullet hits the target (or exits the screen), disable it. Then when you fire a new shot, activate the old one to move it to the gun position and give it velocity. Improves game performance and memory. This pattern already covers Unity itself.

2. Dirty Flag  – Game Programming Patterns

Suppose you have a game object with a specific position and rotation. This game object has a child game object with its work and process. If the parent game object moves, the part of the child objects must be recalculated (which is expensive in terms of performance). Otherwise, do not recalculate. To determine if the child’s position and rotation should do recalculated, we set a boolean value called the “dirty flag” if the parent has moved. If the parent hasn’t moved, keep the old position and rotation. Another example is letting a player build something and uploading that build to a server. You can then flag the changes as dirty and upload only the differences.

3. Data Locality

You need to know here that while processors are fast, memory is slow. The CPU saves a small amount of memory, known as CPU cache, to compensate. It is much quicker than accessing any other memory, so small memory should do optimized. These improvements do measure by measuring “cache errors.” To optimize for cache misses, you should organize your data structures so that the things you work on are adjacent to each other in memory. Easier said than done, this book states that you should avoid unnecessary pointers, not cache invalidated GameObjects or other unnecessary data, and prevent subclassing.

4. Service Locator

A service could be as simple as a random number generator, and it is a system that should be available throughout the game. The Service Locator pattern is, therefore, similar to the Singleton pattern, and the service Locator is like a phone book where you can find names and addresses. However, creating a global one always causes problems, so use this pattern only when necessary. Unity uses this and his Component pattern for the GetComponent() method.

5. Event Queue  – Game Programming Patterns

This design pattern is similar to the Witness pattern and does use for high-level communication between game systems that should remain isolated. An event queue is a list. When an event ensues (such as when a key remains pressed), add that event to the list, and another part of the game picks the oldest event from the queue and processes it. This pattern is beneficial when creating tutorials. We don’t want to mix tutorial codes with other game codes. So the game code will send events to the event queue, and the tutorial code will pick them up from the line. It can so use to play sound effects. If the sound effects are the same, combine them before adding them to the list (then play only the loudest one). The reason is that it is impossible to play multiple identical sound effects simultaneously. If the waveform of the sound effect is the same, it is the same as playing a good product twice as loud.

6. Enter The Object

Let’s say you have a base monster class and several different monsters that inherit from that base class. The basic idea late the type object pattern is to give a base monster class a monster type (or race, as the book calls it) instead of multiple monsters inheriting from the base class. So there are only two classes. Monsters and races instead of dragons, trolls, etc. Therefore, all monsters in the game are instances of monster classes, and race classes contain information shared by all monsters of the same race, such as dragon races. Creating a new breeding object is much easier than creating another subclass. Also, if you have different dragon types, that dragon type can inherit from a more general dragon type. This design pattern is beneficial when allowing users to download new monster races. The downside, however, is that it’s difficult to specialize in different monster actions.

7. Factor

The idea behind this shape is why Unity has various components that can be attached to game objects. You can add helpful features, rigid body components, particle system components, or both. What if they were all part of the same class? Now you can change each piece individually without worrying about the others, and components can still communicate.

8. Double Buffer  – Game Programming Patterns

According to Wikipedia, “Multi-buffering is using multiple buffers to store data blocks so that the reader sees the complete data rather than a partially updated version. You can see the (probably older) version, author.”If you need to see it in action, check out my waterguard tutorial. We use two arrays that look at the surrounding heights and calculate new sizes for all points in the mesh. You cannot add the results of a single-point computation to the same array, and the perimeter’s old height should do uses as it affects other height calculations. So I store the flowers in a new variety and flip the collection when done.

9. Game Loop

Unity built its game loop, but you can’t create your game loop. However, to better understand how Unity works and why Time.deltaTime is not a constant. It would help if you read this chapter of the book.

10. How To Update

This design pattern is Unity’s Update() method. The game world has a gathering of objects whose behavior needs to be updated every frame. Each object needs an update method, and the game updates everything in the pool in every frame.

11. Bytecode

It is the most complex pattern in the book. Develop your programming language called Bytecode. It is beneficial if you want the user to modify the game because the Bytecode accidentally ends up in some weird part of your game engine, and you have no control over how much memory it uses.

Conclusion

Game Programming Patterns bring the benefits of ecological design patterns to the creation of game programming. Commercial game progress expert Robert Nystrom presents a series of standard solutions to problems encountered in game development. For example, double-buffering allows the player to perceive smooth, realistic movements or how service locator patterns can remain used to interpret sound without locking the code to a specific sound driver or a couple of suitable hardware.