- AABB / hitbox
- An invisible rectangle around an object whose sides line up with the screen edges (it never tilts). Overlap tests for them are very cheap, so games use them as hitboxes.
- Acceleration
- How quickly velocity changes. A car going from 0 to 60 mph is accelerating; one cruising steadily is not.In games: Measured in "pixels per second, per second".
- Algorithm
- A step-by-step recipe a computer follows to solve a problem.
- Angular velocity
- Spin speed: how fast an angle is changing, like the speed of a turning wheel. Angular acceleration is how fast that spin speed changes.
- atan2
- The reverse of sine and cosine. Give it "how far across" and "how far down" and it tells you the angle that points that way.
angle = atan2(dy, dx)In games: How a turret works out which way to face its target. - Broad phase / narrow phase
- Collision checking in two passes. A cheap first pass rules out things that are obviously far apart (broad), then careful checks run only on the few that might really touch (narrow).
- Calculus
- The math of change (how fast things are changing) and accumulation (adding up lots of tiny changes). You do not need it to build games: games turn its ideas into simple "add a little each frame" steps.
- Clamp
- Squeeze a number into a range. Clamping 15 to the range 0 to 10 gives 10; clamping −3 gives 0; clamping 7 leaves it at 7.In games: Keeps speeds, health and positions from going past their limits.
- Closed list
- In pathfinding: the squares you have already explored, so you never waste time on them twice.
- Convex
- A shape with no dents. Any straight line drawn between two points inside it stays inside. Squares, triangles and hexagons are convex; a crescent or a star is not.
- Damping
- Gradually removing energy from a wobble so it settles. With no damping something bounces forever; with a lot it creeps back slowly.
- Delta time (dt)
- The tiny slice of time, in seconds, that passed since the last frame. At 60 frames per second it is about 0.0167 seconds.
distance this frame = speed × dtIn games: Multiply any speed by it and things travel the same distance per second on every computer, fast or slow. - Denominator / divide by zero
- The denominator is the bottom number of a fraction. Dividing by zero has no answer: the computer gives back infinity or NaN and anything that touches it breaks.In games: Always check that the number you are dividing by is not zero.
- Derivative
- A calculus word for "how fast something is changing right now". Think of a car speedometer: it shows the derivative of your position. Velocity is the derivative of position, and acceleration is the derivative of velocity.In games: You almost never calculate derivatives yourself. Games just keep track of the results: velocity and acceleration.
- Dijkstra's algorithm
- A pathfinding method that always explores the cheapest route found so far, spreading out evenly in every direction. A* is Dijkstra plus a guess about where the goal is.
- Dot product
- Multiply two arrows' matching parts and add them up. The answer says how much they point the same way: large and positive is the same way, zero is at right angles, negative is opposite.In games: Used for "is that enemy in front of me?" and for measuring how fast two things are closing in.
- Drag
- Resistance from moving through air or water. The faster you go, the harder it pushes back.
- Easing
- Reshaping a movement so it speeds up or slows down smoothly instead of moving at a constant rate. Ease-out slows to a gentle stop; ease-in starts gently.
- Elastic collision
- A collision where the total movement energy (kinetic energy) is the same before and after, with nothing lost to heat, sound or dents. Two billiard balls come close.
- Ellipse
- A stretched circle, like an oval. Planets travel around stars on ellipses.
- Euler method
- The simplest way to move a simulation forward: add acceleration × dt to velocity, and velocity × dt to position. "Semi-implicit" just means you update the velocity first, which behaves much more stably.
- exp (exponential)
- A curve where something shrinks or grows by the same percentage every moment. exp(−k × dt) is how games say "lose the same percentage of the speed each second", and it works at any frame rate.
e^(−x), where e is about 2.718 - Force
- A push or pull. The bigger the force on the same object, the faster it speeds up.
force = mass × acceleration - Frame
- One single picture in the animation. A game draws dozens of these every second, the same way a flip-book shows many pages quickly.
- Frame rate (FPS)
- How many pictures (frames) the game draws each second. 60 FPS means 60 pictures per second. Faster computers can reach higher numbers.In games: It differs from player to player, so your game logic should never assume a particular frame rate.
- Frame-rate independent
- Behaves the same no matter how many frames per second the game runs at. You get there by scaling every change by delta time.
- Friction
- The rubbing that slows sliding things down. A hockey puck on ice has very little; on carpet it has a lot.
- Gravity
- A steady pull toward the ground (or toward a planet).In games: In a platformer it is just a number added to the downward velocity every frame.
- Heuristic
- An educated guess that speeds up a search. In pathfinding it is a quick estimate of how far is left to the goal.
- Hooke's law
- The more you stretch or squash a spring, the harder it pulls back, in exact proportion. Double the stretch, double the pull.
force = −stiffness × stretch - Hz (hertz)
- Times per second. A 144 Hz screen refreshes 144 times every second.
- Impulse
- A sudden push that changes velocity instantly, like a bat hitting a ball.
- Integration
- Adding up many tiny changes over time to get the total. Each frame you add a little velocity to the position, and after many frames those small additions build the whole path. Calculus calls this an integral.In games: Every game that moves things frame by frame is doing integration, even if nobody says the word.
- Inverse-square law
- A pattern where an effect weakens quickly with distance: twice as far means one quarter as strong, three times as far means one ninth.
pull = strength ÷ distance²In games: Gravity and light both follow it. - Kinetic energy
- The energy an object has because it is moving. Bouncy collisions keep it; sticky ones turn some of it into heat.
½ × mass × speed² - Lerp
- Short for "linear interpolation": slide part of the way from A to B. lerp(0, 100, 0.25) gives 25. A fraction of 0 gives A, 1 gives B, and 0.5 gives the midpoint.
lerp(a, b, t) = a + (b − a) × t - Line segment
- A straight line with a start and an end, unlike a true line that goes on forever.
- Magnitude
- The length of a vector: how big the arrow is, ignoring which way it points.
length of (x, y) = √(x² + y²) - Manhattan distance
- Distance counted only with horizontal and vertical steps, like walking city blocks with no diagonal shortcuts.
|dx| + |dy| - Mass
- How much "stuff" an object has, and so how hard it is to push. A heavy object speeds up less than a light one for the same push.
- Minimum translation vector
- The shortest push that would separate two overlapping shapes: which way to push, and how far.
- Momentum
- Mass × velocity: how hard something is to stop. A truck and a bicycle moving at the same speed have very different momentum.
momentum = mass × velocityIn games: In a collision the total momentum is shared between the objects, not lost. - NaN
- "Not a Number": what code gives you for impossible math like 0 ÷ 0. It spreads: anything calculated with NaN becomes NaN too, and objects can vanish from the screen.
- Node & graph
- A node is a spot on a map you can stand on, like one square of a grid. Nodes plus the connections between them are called a graph, which is the picture a pathfinding algorithm works with.
- Normal
- An arrow of length 1 pointing straight out of a surface, at a right angle to it. The "collision normal" says which way things should bounce or be pushed apart.
- Normalize
- Resize an arrow so its length is exactly 1 while keeping its direction. What is left is a pure "which way", with no "how much".
normalized = (x, y) ÷ lengthIn games: Multiply the result by the speed you want and every direction moves at exactly that speed. - O(n²) (Big-O)
- A shorthand for how fast the work grows. O(n²) means that doubling the number of objects makes the work four times bigger, which gets slow very quickly.
- Open list
- In pathfinding: the squares you have discovered but not explored yet, like a to-do list. Each turn you pick the most promising one.
- Parabola
- The smooth arch a thrown ball traces: steady sideways speed plus steady gravity pulling it down.
- Parallel
- Running side by side in the same direction and never meeting, like train tracks.
- Perpendicular
- At a right angle (90°) to something, like the corner of a sheet of paper.
- Pixel
- One tiny dot on the screen. Positions and sizes in 2D games are usually measured in pixels.
- Priority queue
- A to-do list that always hands you the most urgent item first, without re-sorting everything each time.
- Projection
- Squashing a shape flat onto a line, like the shadow it would cast on a wall. Comparing shadows is how the separating axis test works.
- Proportional
- Rising and falling together at the same rate. If A is proportional to B, doubling B doubles A.
- Pythagorean theorem
- In a right-angled triangle, the two short sides, each multiplied by itself and added together, equal the long side multiplied by itself. It is how you measure the straight-line distance between two points.
a² + b² = c²In games: Any time you need "how far apart are these two things?", this is what runs underneath. - Radians
- An angle unit that code prefers over degrees. A full turn is 2π (about 6.28) instead of 360°, and a half turn is π (about 3.14).
radians = degrees × π ÷ 180 - Restitution
- Bounciness. A number from 0 to 1 for the fraction of its speed an object keeps after a bounce: 1 is a perfect super-ball, 0 is a lump of clay.
- Separating Axis Theorem
- A rule for testing whether two convex shapes touch: if you can find any line where their shadows do not overlap, the shapes are apart.
- Sine & cosine
- Give them an angle and they tell you how far across (cosine) and how far up or down (sine) you would end up after one step in that direction.
vx = cos(angle) × speed, vy = sin(angle) × speedIn games: Multiply by a speed to turn an angle into a velocity. Plotted over time they also draw smooth waves, handy for bobbing and swaying. - Speed
- How fast something moves, ignoring direction.
- Sprite
- A 2D picture that represents a character or object on screen.
- Square root
- The number that gives you the original when multiplied by itself. The square root of 9 is 3, and of 25 is 5.In games: Distance formulas use it. It is slower for a computer than plain arithmetic, so games skip it when they can.
- Squared
- Multiplied by itself: 4 squared is 4 × 4 = 16, written 4². Squaring a number between 0 and 1 makes it smaller (0.5 squared is 0.25).In games: Comparing squared distances avoids the slower square root. Squaring also makes an effect ramp up gently, then hit hard near the top.
- Stiffness
- How strong a spring is. A high number snaps back fast; a low number is soft and floppy.
- Substeps
- Splitting one frame into several smaller updates, like taking ten small steps instead of one big leap. It stops fast or springy things from going wrong.
- Trigonometry
- The math of angles and triangles. In games it converts between "an angle" and "a direction", for example turning "point 30 degrees" into "move this far across and this far down".
- Vector
- An arrow: a direction plus a length. It is written as a pair of numbers, like (3, 4), meaning "3 across and 4 down".In games: Positions, velocities, pushes and aiming directions are all stored as vectors.
- Velocity
- How fast something moves and in which direction, like "200 pixels per second to the right".In games: Speed is the same idea without the direction.
- Verlet
- A way of moving points that remembers where each point was last frame. The difference between "now" and "before" is the velocity, so you never store it. Great for ropes and cloth.