Game Development Physics

Game development physics is the set of numerical techniques that make virtual worlds feel solid: objects that fall, bounce, stack and break the way you expect, characters that ragdoll convincingly when they lose a fight, and levels that feel handcrafted even when a computer generated them a second before you walked in. None of this is decorative — it is discrete-time numerical simulation, running dozens of times per second, of the same physics you would find in a textbook, simplified just enough to run inside a 16-millisecond frame budget. This hub gathers every interactive game-physics and game-dev simulation on mysimulator.uk into one guided starting point, so instead of reading a physics-engine manual you can drag a ragdoll, throw a rope, and watch a dungeon generate tile by tile in your browser.

The foundation of almost every physics engine is collision detection and response, demonstrated here with 2D Collisions, Elastic Collisions and Billiards: two bodies approach, the engine detects the overlap, and then resolves it by redistributing momentum and kinetic energy so the total of both is conserved (or partially lost, for inelastic collisions like a dropped bag of sand). Real engines split this into a cheap broad phase that quickly rules out pairs that cannot possibly be touching — usually a bounding-volume hierarchy or spatial grid — and an exact narrow phase using algorithms like the Separating Axis Theorem or GJK to compute the precise contact point and normal, which is the subject of the Collision Detection article linked below. Projectile Motion applies the simplest version of this physics without any collision at all: constant gravitational acceleration on a launched body, which is the exact arc behind every thrown grenade, arrow or jump in a 2D or 3D game.

The next layer up is deformable and articulated bodies: Ragdoll Physics, Cloth Simulation, Rope & Chain Physics and the Spring-Mass Network all share the same underlying trick, Verlet integration with iterative constraint solving. Instead of tracking velocity explicitly, Verlet integration stores a point's current and previous position and derives velocity implicitly from their difference, which makes it extremely stable for systems with many interacting constraints — exactly what you need when a ragdoll has a dozen joints, or a piece of cloth has thousands of interconnected points that must not stretch past a fixed distance. The Verlet, Leapfrog and RK4 article explains why this integrator, rather than a naive Euler step, is the one actually shipped in production physics engines. Dzhanibekov Effect pushes rigid-body dynamics into full 3D, showing how Euler's equations of rotational motion predict the surprising flip a tumbling object performs when spun on its unstable intermediate axis — the same equations that govern how a thrown weapon or vehicle tumbles realistically in a physics-driven game.

Fracture Simulation covers destructible environments: on impact, an object is partitioned into Voronoi cells and the cells that receive enough force detach and fall under ordinary rigid-body physics, which is how modern engines make walls, crates and vehicles break apart convincingly without hand-authoring every possible shatter pattern. Particle System — Game VFX Emitter is the visual counterpart: fire, smoke, sparks and explosions in games are rarely simulated fluid dynamics, they are large pools of simple particles with randomised velocity, colour and lifetime, recycled continuously to stay within a performance budget — the Three.js Particle System Tutorial article shows exactly how to push that technique to 100,000 particles in a browser.

The final part of this hub is procedural generation, which solves a different problem: not how objects move, but how a game world is built in the first place. Wave Function Collapse treats level generation as a constraint-satisfaction problem, collapsing the tile with the lowest entropy first and propagating adjacency rules outward until every cell is filled with a tile that is compatible with its neighbours — the same algorithm used to generate believable dungeons, terrain and even textures from a small set of example tiles. Procedural Dungeon Generator demonstrates three complementary approaches side by side — binary space partitioning for room-and-corridor layouts, random placement joined by a spanning tree, and cellular automata for organic cave systems — all seeded so the exact same level can be reproduced for debugging or shared with other players. Field of View — NPC Sight closes the loop between level and character: a shadow-casting visibility algorithm computes exactly what a non-player character can see given the walls in the generated level, which is the core primitive behind every stealth game's detection system.

Together these simulations cover the three pillars of physics-driven game development: rigid-body dynamics and collision response, soft-body and articulated simulation built on Verlet integration, and the procedural systems that generate content and drive NPC behaviour. Follow the learning path below for a suggested order, browse the full grid for anything that catches your eye, or jump straight to the category pages for Game Dev and Physics for the complete lists. Every simulation here is a real numerical solver running live in your browser at 60 frames per second, not a pre-rendered animation — changing a stiffness, a gravity constant or a random seed changes the actual physics, which is exactly the kind of hands-on intuition that reading a game-engine source file alone cannot give you.