Everything I've learnt, indexed

Adjacency list

A graph stored as a list of neighbours for each vertex. Cheap on memory when most vertices connect to only a few others.

Big-O notation

How an algorithm's cost grows as the input grows. It describes the shape of the growth, not the exact time.

Binary search

Find an item in a sorted list by halving the range every step. Logarithmic, but only if the data is sorted first.

Blueprints

Unreal's visual scripting. Good for designer-facing glue; heavy or hot-path systems belong in C++.

Breadth-first search

Explore a graph in rings outward from the start using a queue. Finds the fewest-steps path in an unweighted graph.

Collision channels

Unreal's way of saying what can detect what. A query on one channel ignores everything else.

Construction

Bringing an object into existence. For a class type, the constructor creates the object's first, complete state through initialisation: the chosen constructor "is called to initialize the object" ([dcl.init.general]). Construction is the time during that initialisation process, and the object's lifetime only begins once initialisation finishes ([basic.life]).

Dangling pointer

A pointer that still holds the address of an object that has already been destroyed. Using it touches freed memory and crashes.

Data-driven design

Put the numbers and content in data designers can edit, so changing the game does not mean changing the code.

Decrease and conquer

Shrink the problem by a constant amount or factor each step, solve the smaller one, extend the answer.

Delegates

Unreal's event system. Objects bind a function to an event and must unbind it when they stop listening.

Depth-first search

Explore a graph by going as deep as possible before backtracking, using a stack or recursion.

Divide and conquer

Split the problem into independent parts, solve each, then combine. Merge sort is the classic.

Dynamic programming

Solve overlapping subproblems once and store the answers so you never solve the same one twice.

Greedy algorithms

Make the best-looking choice at each step and never look back. Fast, but only correct for some problems.

Hash table

Maps a key to a value in roughly constant time. Unreal's TMap is one; the enemy pool is a TMap from type to array.

Initialisation

The process that gives an object its initial value ([dcl.init.general]). For a class type, the chosen constructor carries it out: each member is initialised in the order it is declared, whatever order the initialiser list uses, and then the constructor body runs ([class.base.init]). The object's lifetime begins once that is complete ([basic.life]), so an Init() or Load() method called afterwards is not initialisation in the standard's sense: it runs on an object that is already alive.

When Init() or Load() runs on the living object:

• Called once and it succeeds: the object goes from its safe empty state to holding its resource.
• It fails: it logs the error and returns false. Written well, it leaves the object in the same safe empty state, so the caller decides what to do next.
• Called again without Release() first: the old resource is overwritten and leaks, unless Load() releases it first.
• Called after Release(): it works, because the object is still alive. Release() only returned what the object pointed to.
• Its dependency isn't ready yet, such as no renderer: it must check and fail cleanly. That's why .PADEL loads in Game::Initialize(), after the renderer exists.
• Never called: every other method must cope with the empty state, such as Draw() skipping a null texture.
• Called after the destructor has run: undefined behaviour: calling a member function on an object outside its lifetime ([basic.life]).

Inverted index

A map from each term to the documents that contain it. It is what powers the search bar on this page.

Linear search

Check items one at a time until you find what you need. Fine for small sets; cost grows with the list.

Memoisation

Cache the result of a function call so the same input returns instantly next time.

Object pooling

Create objects once up front, then hand them out and take them back instead of creating and destroying them during play.

Overlap vs Hit

A Hit means two things block each other. An Overlap means they pass through and the engine just reports the contact.

Queue

First in, first out. The order things arrive is the order they leave.

Recurrence relation

A cost written in terms of the cost of smaller inputs, like T(n) = 2T(n/2) + n. Solve it to get a closed form.

Smart pointers

Pointer types that know about object lifetime. A TWeakObjectPtr becomes invalid on its own when its object is destroyed.

Stack

Last in, first out. The most recent thing added is the first thing out.

Stemming

Cut words down to a shared root so 'pooling', 'pooled' and 'pools' all match 'pool'.

Struct

A named bundle of related data. Define the shape once, then fill in many of them.

TF-IDF

Scores a term higher when it is frequent in this document but rare across all documents.

Timers and lifetime

A timer outlives the call that set it. If it fires after its target is destroyed, it acts on freed memory.

Transform and conquer

Change the problem into an easier form first, such as sorting before searching, then solve that.

UPROPERTY

The Unreal macro that exposes a C++ variable to the editor, Blueprints and the garbage collector.

Vectors

A direction and a length. Subtract two positions to get the vector between them; its length is the distance.