Mathematical Skills

Below is an overview of mathematical skills relevant to creative technologists working with interactive applications, ordered by priority according to MoSCoW (Must, Should, Could, Won't). For each skill, concrete applications or problems are mentioned where this knowledge is needed. Modern frameworks and libraries handle much of the mathematical work, which is why advanced or specialized skills are lower on the list.

However, it is valuable to also delve into the mathematical concepts behind the functionalities that tools automatically perform for you. By actively practicing with these concepts, you gain a better understanding of how and when to use certain mathematical techniques to solve problems efficiently. Moreover, it improves your mathematical intuition and strengthens your ability to reason accurately about complex technical issues.

Must (Essential – highest priority)

Vector calculations (addition, subtraction, scaling)

Basic operations with 2D/3D vectors for position, direction, and velocity.

Applications

Updating an object's position with a velocity vector (movement calculation).
Calculating the relative displacement between two objects.
Adding multiple movement influences into one resulting direction vector (e.g., sum of different forces).

Dot product calculation

Determines to what extent two vectors point in the same direction by measuring the angle between them.

Applications

Determining if an enemy is in the field of view by checking the angle between viewing direction and direction to the enemy (dot > 0 = in front, dot < 0 = behind).
Calculating light intensity on a surface (Lambert lighting uses normal·light vector).
Projecting velocity in the direction of a surface to calculate sliding movements.

Cross product calculation

Yields a vector perpendicular to two given vectors, essential in 3D geometry.

Applications

Calculating a surface normal of a triangle from two edges (for lighting or collision response).
Determining a rotation axis perpendicular to two directions (useful when aligning an object in a plane).
Calculating a ricochet or reflection direction of a projectile via normal vectors.

Vector normalization (creating unit vectors)

Scaling a vector to length 1 to preserve only the direction.

Applications

Normalizing the direction to a target to apply a constant speed in that direction.
Normalizing a movement vector before use in an angle calculation or dot product (for consistent results independent of distance).
Bringing a view vector to unit length to scale movement per frame.

Determining a line between two points

Creating a mathematical representation of a straight line through two points in 2D or 3D space, often in the form of a direction vector and a starting point.

Applications

Determining a movement path between the current position and a target position, for example for projectiles or NPCs.
Performing raycasts for interactions or collision detection, such as determining if a shot hits something by drawing a line from weapon to target.

Calculating distance between points

Applying the Euclidean distance formula (Pythagoras in 3D) between coordinates.

Applications

Checking if an object is within range (comparing player-enemy distance with an action radius).
Finding the nearest target by comparing distances.
Determining if a projectile has reached its target based on the distance traveled.

Calculating distance between line and point

Calculating the shortest (perpendicular) distance from a given point to an infinite or finite line, often used for precise positioning problems and collision checks.

Applications

Checking if a moving object comes dangerously close to a certain path (for example, a vehicle almost hitting a wall).
Deciding whether an AI character should adjust its course based on distance to the ideal path.

Basic trigonometry (sine, cosine, tangent)

Working with trigonometric functions for angles and triangle ratios.

Applications

Calculating horizontal and vertical components of a velocity at a certain shooting angle (cosθ for x-direction, sinθ for y-direction).
Creating oscillations or back-and-forth movements (e.g., making an object swing or jump based on sinusoids).
Determining the angle between two 2D directions with atan2 (for example, to turn a turret toward the player).

Conversion between degrees and radians

Converting angle measures (360° system vs. 2π radians) depending on what the engine or mathematical function expects.

Applications

Converting a rotation angle from the user (degrees) to radians for mathematical calculations (Math.sin() in code expects radians).
Keeping rotation inputs consistent (Unity, for example, uses degrees in the editor, but internal calculations use radians).
Correctly controlling animation routines or rotations in code by using the right angle unit.

Linear interpolation (LERP)

Calculating intermediate values based on a ratio, linearly between two known values. LERP is also often used for non-linear 'smoothing'. Additionally, it's useful to familiarize yourself with a number of popular non-linear interpolation functions.

Applications

Smoothly transitioning camera position from A to B with a parameter t (smooth camera movement).
Gradually increasing or decreasing a variable (e.g., health regeneration per second as interpolation between current and max value).
Blending two animation positions or poses for a blend (calculating intermediate state).
Calculating the position of an object moving along a straight line between start and end point based on elapsed time.

Starting Point

Lerp smoothing is broken - Freya Holmér

Should (Important – second priority)

Recognizing and using standard functions

Use of various standard mathematical functions (linear, quadratic, exponential, logarithmic) to realize gameplay effects or scale values in a predictable and effective way.

Applications

Attenuating sound volume or light with distance via a logarithmic scale (dB scale for sound, human perception is logarithmic).
Difficulty grading that increases exponentially per level (each next level requires ~1.5× as much XP as the previous, for example, which is exponential growth).

Determining inverses and transforming functions

Algebraically rewriting and transforming functions to free variables, determine inverses, or make functions easier to calculate for implementation in games.

Applications

Determining inverses is useful when back-calculating gameplay effects such as determining required input (e.g., velocity or force) from a desired result.
Additionally, you sometimes want to free variables to find direct solutions (for example, freeing time or distance from movement equations).

Understanding Big-O notation and time complexity

Big-O notation is used to describe the efficiency (speed and scalability) of algorithms and data structures. Game developers use this to optimize the performance of their code, particularly in complex systems like AI, pathfinding, or data processing.

Applications

When choosing the right algorithm or data structure, time and space complexity play a big role. For example, the choice between data structures like dictionaries (O(1) for searching and inserting) or lists (O(N) when searching).
Additionally, it helps in recognizing performance problems, such as inefficient nested loops (O(N²) or worse) and restructuring these into linear loops (O(N)) if possible.

General ratios and scaling

Applying proportionality in gameplay values.

Applications

Linearly scaling damage or difficulty based on player level (e.g., each level-up +10% damage).
Using inversely proportional relationships, such as light intensity decreasing with distance according to 1/r² (inverse square law) for realistic light or sound.
Normalizing a value to a 0–1 range to easily apply interpolations or percentages (e.g., filling a health bar based on current/maximum health).

Quaternions (3D rotations without gimbal lock)

Use of quaternion mathematics for orientation instead of Euler angles. Quaternions are essential for stable rotations and skeletal animations. Here, it's only important that you understand the differences between Euler angles and quaternions. You don't often need to calculate with these yourself.

Applications

Smoothly interpolating the rotation of an object (spherical interpolation slerp between two quaternions for smooth turning).
Combining rotations by multiplying quaternions (e.g., making a character rotate 90° relative to its current orientation).
Handling bone rotations (bone orientations) in engines – bone animations often use quaternions to prevent unexpected twists (gimbal lock).

Starting Point

Probability and basic statistics

Applying probability and simple statistics in gameplay logic.

Applications

Determining drop chances or random events (e.g., 20% chance of a rare item – understanding probability calculation helps in balancing this).
Generating distribution of random values for AI behavior or damage spread (such as creating variation in shots within a certain spread).
Statistically comparing weapon performance (e.g., calculating average expected damage, or estimating chance of critical hits).

Could (Optional – useful in specific/advanced cases)

Motion equations from physics (kinematics)

Applying simple physical formulas for linear motion. Although physics engines handle much of this, insight is crucial for tuning.

Applications

Calculating how far an object falls in t seconds (s = ½·a·t²) to determine, for example, the damage or animation when something lands.
Calculating required launch velocity to make a projectile reach a certain target (e.g., calculating the initial velocity for a cannonball or jumping player so they reach the desired spot).
Understanding F = m·a when applying forces in the engine (heavier objects need more force for the same acceleration), so you can set realistic movement parameters.

Working with graphs (nodes, edges, paths and graph algorithms)

Use of graphs to solve problems related to connections, relationships, and optimal routes within the game world.

Applications

Determining optimal routes for characters and NPCs through algorithms such as A*, Dijkstra, or Breadth-First Search (BFS), for example to find the shortest path in complex terrains.

Matrices and transformations (4×4 matrix usage)

Understanding matrix operations for translation, rotation, and scale in 3D. This converts object coordinates between different coordinate systems. This kind of mathematics is typically performed by the engine.

Applications

Converting coordinates from local object-space to world-space (and vice versa) using a transformation matrix.
Combining multiple transformations (first rotate, then move – the matrix multiplication order determines the result).
Understanding how an engine rotates or moves an object under the hood, so you can correct any deviations (e.g., making a billboard always point to the camera by applying the right matrix).

Bézier curves and splines

Advanced interpolation techniques with curves for smooth movements and trajectories.

Applications

Making an object move along a curved path (e.g., making a race car go over a curved spline track).
Calculating intermediate positions for camera pathing or cinematic movements with Bézier curves.
Making animations run more smoothly with easing curves (such as ease-in/ease-out functions based on cubic splines in an animation editor).

Calculating reflection and direction vectors

Mirroring a movement or view vector relative to a surface.

Applications

Calculating the angle in which a ball or projectile bounces off after collision with a wall (reflection vector relative to the surface normal).
Mirroring camera directions in a mirror surface for reflection effects.
Determining the direction in which an object should "bounce" with physics materials with high bounciness (using dot product and normal to find the new direction).

Polar and spherical coordinates

Converting between Cartesian (x,y,z) and polar coordinates (angle, radius) or spherical coordinates (azimuth, elevation, radius).

Applications

Generating objects in a circle or spherical formation (determining coordinates based on a radius and an angle, for example spreading enemies around the player in a circle).
Controlling an object with angle settings (such as a turret that rotates based on an angle instead of position differences).
Converting a 3D orientation to yaw/pitch/roll angles for UI display or debugging.

Won't (No focus – outside curriculum scope)

Inverse kinematics calculations

Mathematics for calculating joint angles or positions from desired end positions (in animation).

Applications

Calculating the knee and hip angle needed to place a character's foot at a certain point on the ground (two-leg inverse kinematics, often using the cosine rule in a triangle).
Positioning a robotic arm or tentacle so its end hits a target (solving multiple coupled rotations, requires understanding of angles and iterative solution methods).
Real-time adjustment of hand or foot placement of a character on uneven terrain via IK solutions.

Advanced linear algebra (eigenvalues, matrix decompositions)

Deep linear algebra is not needed in daily game development with existing engines.

Applications

Engine development or specialized systems (e.g., physics engines calculate eigenvalues for inertia tensors, but a regular game developer uses the abstracting engine API for this).

Advanced calculus and differential equations

Complex mathematical analysis is not required for standard gameplay programming.

Applications

Realistic simulations (e.g., fluid dynamics, weather simulation) or graphics research (global illumination calculations with integrals).

Complex numbers and Fourier analysis

Although powerful in certain domains (signal processing, shader-Fourier water waves), these rarely come up directly in gameplay code.

Applications

Audio programming (DSP effects via Fourier transforms), visual effects like holograms or fractals (which can use complex numbers).

Machine learning-oriented mathematics

Linear algebra and statistics at an advanced level for AI/ML (such as training neural networks, regression analysis) fall outside this curriculum for game developers. Game AI in the context of this program focuses more on classical algorithms than purely mathematical ML models.

Applications

Development of ML systems or data analysis in games (e.g., recommendation systems, player behavior analysis).