#games programming

command

Putting an extra layer between the input and the execution that allows you to swap out what each input actually does at run time, it also means that the input doesn't call the execution directly meaning you can delay it. Most known for its use in undo and redoing actions.

flyweight

Pulling all common data from an object which will be displayed multiple times, loading it into memory once and referencing this data wherever it needs to be displayed on screen. Each instance of the object will hold its own unique parameters but will be far more lightweight. E.g. when displaying trees the model and basic data will be held as common data and only loaded once. but the position will be stored in the instance

Observer

Using events to decouple different systems in the game. A script sends out an event and any class which may need to know about it will add a listener with an attached function to implement if that event is called. Doesn't require classes to explicitly know each other, and the broadcasting class shooting off the event needs no knowledge of its listeners.

prototype

Creating a parent class with base virtual functions with the basic functionality for a given set of objects, then overriding those functions in its child classes for custom behaviour (if necessary). Means that a set of objects always has the same function names for another class to call on and reduces how much code is needed when child Classes do not need to override functions to their own implementation.

singleton

A class which can only have one instance and has global access to it. Is initialized at runtime and only if needed. However they're global, discourage concurrency and encourages coupling

State

Creating a set of states and transitions (finite state machine) with different functionalities and behaviours you can switch between when certain conditions are met. You can only be in one state at a time.

double buffer

Having two frame buffers, one displaying the current frame and another loading the next one. It then swaps the frames one in once it's fully loaded rather than writing over the current frame which can lead to rendering errors.

game loop

Functionality that loops so long as gameplay is active e.g. update or tick (called each frame), fixed update (called at a fixed interval 50 times a second)

update

All a game objects behaviour is kept within its own update rather than the main game loops update. The main game loop calls on these update functions each frame and then the object handles its own behaviour.

event queue

Storing requests in first in first out to prevent them being processed simultaneously. Allows for control over when certain actions happen.

type object

Instead of inheriting from a class directly, have two classes which reference each other, one which stores the objects base data that's similar across all objects (e.g. animal, pathfinding) and one which stores specific information and implementation (e.g. Breed) allows for creation of lots of different breeds just by changing parameters instead of creating new inherited children of animal

dirty flag

Second game made with a team in Unity. Actually got time to test and polish it before releasing.

Link to the game: https://oleglo.itch.io/winter-rush

Lessons taken from the project:

- Make sure the artist has some kind of reference for the resolutions to use. Print them and give them to them.

- Paint + ScreenToGif does wonders when it comes to communicating with an artist. Much clearer than words.

- For the GameManager, take the time to make a small description at the start of the script that describes the structure of the file.

- Make sure the GameManager handles situations where there is accidently more than one GameManager in the game.

- For scripts that require a lot of references, make sure to create some kind of Init() function and a isInit boolean. This avoids a spam of errors if some references are missing. Makes it easier to handle errors.

- Organize your tilemap palette well. You’ll be shaving off half a second every time you need to switch tiles if the palette is well organized, which in the end will save you time.

- Create variables to work with that are updated each frame rather than checking values inside statements. This avoids unnecessary function calls and makes code more readable.

First game made on Unity in a team with another Games Prog + Games Art.

Link to the game: https://oleglo.itch.io/bubble-gum

Organization lessons taken from the project:

- Better stress management.

- Be mindful to keep things tidy, anything done in a messy manner is amplified ten times when working in a team.

- Modify file structure only after receiving acknowledgement from the rest of the team.

- Manage sounds with a specialized script.

- Push changes to main branch only after they are working properly and there aren’t any major bugs. No half-assed pushing.

- Separate game into different scenes when possible.

- READ UNITY DOCUMENTATION.

- Separate badly readable code into functions.

- If doing any kind of trigger and/or collision detection with tilemaps, use composite colliders. Makes AI coding thousands times easier.

- When possible, take the time to merge code with your colleagues and clean and explain the code before merging.

- If creating a WebGL build of the game, create a Standalone as well.

- Make sure the player sees the game’s controls before playing.

- BE A HEARTLESS BASTARD WITH YOUR GAME ART.

- Aim for a MVP: Minimal Viable Product.

- Use Debug.LogError() and similar to catch errors.