PROMETEO Car Controller: Learning Vehicle Dynamics Through One Script That Kept Growing
Driving physics looks simple until you try making a car feel believable. Turning is easy. Weight transfer is harder. Drifting without making the car uncontrollable is harder still. That was the problem this project revolved around.
PROMETEO started as an attempt to understand vehicle control deeply enough to tune it, not just use Unity defaults. It became a reusable controller because the logic kept expanding around the edges. Input, friction, effects, camera behavior. Everything touched everything.
Most Of It Was Friction
The most interesting decision in the project was treating drifting as a friction problem, not a visual effect. Instead of faking drift, I spent time manipulating WheelCollider friction curves so losing traction could still feel controllable.
That changed the whole controller. Steering, braking, recovery, and handbrake behavior all had to agree. Drifting only feels good when exiting the drift feels good too.
- WheelCollider based physics tuned around traction and weight behavior
- Custom drifting logic built through friction curve manipulation
- Modular controller systems for input, effects, sound, and camera
That friction tuning taught me more than anything else in the project. Small parameter changes could completely change the car's personality.
Input And Feel Were The Same Problem
I learned quickly that physics alone does not create handling feel. Input smoothing mattered as much as torque. Lerp and Slerp logic for steering and camera movement ended up carrying a lot of perceived realism.
That was also why I kept both keyboard and touch support in mind. Different inputs expose weaknesses differently.
Even simple things like using periodic updates for some systems instead of checking everything every frame came from trying to keep the controller responsive without becoming messy.
What Stayed Messy
The project had rough edges. Some systems were overcomplicated, especially parts of the drift recovery logic. There were hardcoded values I would absolutely expose as parameters now.
The commented out UI code is a good example of something unfinished. It existed, but not in a way I was satisfied shipping as part of the controller.
I would also reduce hidden setup assumptions. Requiring specific collider, effect, and wheel arrangements made the asset harder to drop into a project than it should have been.
What It Taught Me
This project taught me that physics systems are mostly tuning systems. The equations matter, but iteration matters more.
It also pushed me toward thinking in reusable systems. Once inspector parameters controlled behavior well, the project stopped feeling like a one off experiment and started feeling like a component.
The camera follow script taught a smaller version of the same lesson. Sometimes a little smoothing does more for realism than adding more complexity.
Why This Project Mattered
This was one of the first projects where I spent as much time adjusting feel as writing features. That was new.
Good control systems are built in the tuning, not the headline features.