/projects/procedural-racing-combat-game

TurboThrill: Procedural Racing Game

Unity racing-combat game featuring procedural terrain, multithreaded chunk generation, AI navigation, GPU-instanced foliage, and physics-driven vehicle combat.

Procedural racing game terrain and vehicle view

game development

TurboThrill: Procedural Racing Game

Procedural Racing Combat Game is a Unity-based project built with a team to explore game development, graphics programming, and real-time systems. The core idea was to create a replayable racing experience set on an infinite procedurally generated landscape, where the player drives a physics-based car, fights AI-controlled opponents, and navigates toward a finish line. A major focus of the project was building the world generation pipeline: Perlin-noise-based terrain, level-of-detail chunking, multithreaded mesh generation, and terrain texturing through shaders. Beyond world generation, the project also included AI pathfinding, GPU-instanced grass rendering, world-save serialization, projectile combat systems, minimap and waypoint logic, particle effects, camera transitions, and post-processing. The result was a technically ambitious game prototype that emphasized both replayability and learning across gameplay, rendering, optimization, and team-based development.

date: 2024status: shipped

GitHub LinkedIn

overview

The project aimed to build a replayable racing game that felt larger than a fixed handcrafted track while also serving as a learning platform for graphics, optimization, AI, and gameplay programming. Generating an expansive world in real time without sacrificing performance became the central technical challenge.

implementation

Built a Perlin-noise-based terrain pipeline that maps world coordinates to height values, converts them into mesh data, and generates visible terrain chunks on demand.

Integrated multithreading and level-of-detail logic so terrain generation and mesh updates could scale more efficiently as the player traversed the world.

Used Unity URP shader graph to build shaders for water, terrain texture blending, and early foliage rendering, then explored lower-level GPU techniques for performance optimization.

Implemented GPU-instanced grass after identifying CPU bottlenecks with naïve foliage placement, working across compute, vertex, and fragment shader stages with transformation matrix math.

Added world serialization so seeds and terrain-generation parameters could be saved as JSON and used to recreate prior worlds later.

Built gameplay features including AI movement with A* pathfinding, a car turret, projectile bullet physics, a health system, particle effects, minimap logic, waypoints, and camera transitions.

challenges

Procedural terrain had to balance visual scale with runtime efficiency, which required careful use of chunking, culling, and level-of-detail.

Grass and foliage initially consumed too many CPU resources, forcing a redesign toward GPU instancing and more advanced shader-based rendering.

Working across gameplay code, rendering systems, and engine tooling meant constantly switching between higher-level Unity workflows and lower-level graphics concepts.

Because the project was team-based, technical progress also depended on planning, communication, and keeping implementation goals aligned across the group.

outcomes

Delivered a functional prototype with procedural terrain, AI, physics-driven vehicle gameplay, combat systems, and a broad range of rendering features.

Gained hands-on experience with multithreading, shaders, the GPU rendering pipeline, serialization, optimization, and game-system design.

Used the project as a strong introduction to graphics programming and real-time engine development while also improving collaboration and scrum-based teamwork.

architecture notes

Terrain generation starts from pseudo-random noise maps configured by variables such as octaves, persistence, and lacunarity, which are converted into height values and then into mesh data.

Mesh construction is separated into noise generation, triangle/normal/UV creation, and chunk-based level-of-detail requests so terrain can be generated efficiently as the player moves.

The rendering stack combines Unity URP shader graph workflows with lower-level shader experimentation, including water rendering, terrain texturing, and GPU-driven grass generation.

Gameplay systems connect world simulation and combat, including AI navigation, projectile physics, finish-line logic, minimap guidance, and health-based despawning.

stack

C#UnityUnity URPShader GraphHLSLCompute ShadersJSONA*

highlights

Built a multithreaded procedural terrain system using Perlin noise, chunked mesh generation, and level-of-detail rendering.

Implemented shader-driven visuals including water, terrain texture blending, and an early grass pipeline before moving to GPU instancing.

Optimized foliage rendering by replacing CPU-heavy spawning with GPU-instanced grass using compute, vertex, and fragment shaders.

Added gameplay systems including AI pathfinding, vehicle combat, projectile physics, minimap navigation, health logic, and world saving.

metrics

terrain system

infinite

render path

GPU-instanced foliage

world replayability

seed-based

media

The game starts with a menu where players can choose to start a new save or load an existing one. Each save corresponds to a unique seed that generates a specific world, allowing for replayability and exploration of different terrains.

Showcases the procedural rendering of the world from developer + player perspective

Grass and foliage rendering + Water shader

GPU-instanced grass and procedurally placed foliage improved visual density without overwhelming CPU-side performance.