Dev Notes
Unity3D Dev Notes
The articles below are technical Unity3D write-ups on subjects that came up directly during the development of Scraps: Modular Vehicle Combat, covering vehicle effects, object pooling, AI navigation, basic networking, and rendering performance. Each one has been checked and rewritten against Unity's current APIs rather than reproduced as-is, since some of the original techniques predate features like the built-in object-pooling API and newer rendering pipelines. They're aimed at developers working through similar problems, not at readers following the game's story, which lives in the History section instead.
Most of these topics started as ordinary devlog posts written by Scraps' developer while he was solving a specific, unglamorous problem: vehicle parts leaving skid trails that looked right, AI opponents that could actually find their way across a battle map, projectiles that didn't allocate a fresh object every time a weapon fired. None of that made for exciting screenshots, which is probably why the posts ended up being read mostly by other Unity developers rather than by players following the game itself. That's still who this section is written for.
- A Skidmark Effect for Vehicles in Unity →
A TrailRenderer-based skidmark technique originally written for Scraps’ vehicles, checked against current Unity behavior and expanded with the particle-trail alternative most projects end up asking about next.
- Object Pools in Unity →
Why Instantiate and Destroy get expensive fast in a vehicle-combat game full of projectiles and debris, and how the native ObjectPool<T> API replaced the hand-rolled pooling Scraps originally used.
- AI Player Navigation with Unity NavMeshes →
The navmesh work that took the original project the better part of a year to settle, covered here against the modern com.unity.ai.navigation package rather than the built-in system it replaced.
- Multiplayer and Client Prediction in Unity →
How client-side prediction hides network latency in a real-time multiplayer game, and what Netcode for GameObjects hands you today versus what Scraps had to build by hand.
- Performance: Draw Call Batching →
A 2015-era trick for batching a vehicle’s independently moving parts into one draw call, plus why the SRP Batcher and GPU Resident Drawer changed what "batching" even means in a current render pipeline.
- Some Unity Extension Methods →
A small set of GetComponentsInChildren and find-child-by-name helpers worth keeping in any Unity project, along with the includeInactive detail that trips people up most often.
Frequently Asked Questions
Are these the original Scraps devlog posts?
No. Each article is new editorial writing on the same subject, verified against current Unity APIs and documentation, rather than a reproduction of the developer's original first-person posts.
Which Dev Notes article should I read first?
The skidmark effect and object pooling articles are the most self-contained starting points; the multiplayer and navmesh pieces assume a bit more familiarity with Unity's component system.
Do these techniques still work in current Unity versions?
Yes, with the caveat noted on each page: some of the original approaches, like manual object pooling or CPU-side dynamic batching, have since been replaced by native Unity APIs, and the articles cover both the old and current approach where it matters.
Why does a vehicle combat game's devlog cover general Unity techniques?
Vehicle-combat games surface a specific mix of problems, moving parts, projectile-heavy combat, AI opponents on uneven terrain, that happen to be common to a lot of other genres too, which is part of why these particular write-ups kept getting linked to by unrelated Unity projects over the years.
Who originally wrote about these Unity techniques?
Bill Borman, the New Zealand-based developer who built Scraps largely alone, wrote most of the original devlog posts these subjects are drawn from, including two longer pieces later published in full on Game Developer.