Day 3 — Boat, Not Spaceship.

At the start of Day 3, DETOUR was technically doing most of the things I needed it to do.

You could drive. You could dodge obstacles. You could collect fuel. You could choose between a shortcut and a detour.

But there was a problem.

Driving the car wasn’t very fun.

It felt less like driving a beat-up car down a highway and more like moving a rectangle left and right in a space shooter.

So today became mostly about feel.

Boat, Not Spaceship

The phrase I kept coming back to was:

> “Boat, not spaceship.”

I wanted the car to feel like a big old sedan. Heavy. A little slow to respond. Something where you have to start turning before you actually need to be somewhere.

The first step was simply making the car bigger.

That sounds minor, but it made a pretty significant difference. The original car was so small relative to the road that it felt more like a cursor than a vehicle.

I increased the visual size, adjusted the collider separately, and kept the collision area slightly more forgiving than the visible car.

Then I reorganized the Player scene so the physics and visual movement could be separated.

The tree now looks roughly like this:

Player
  SteeringPivot
    BodyVisual
      BodyRoll
        CarBody
        DamageMark
        Smoke
  CollisionShape2D

That gave me three different layers to work with:

• Player handles the actual movement and collision.
• SteeringPivot rotates around a point closer to the rear of the car.
• BodyRoll handles weight transfer and suspension-style movement.

The important part is that the collision shape stays predictable while the visible car gets to move around and exaggerate things a little.

Giving the Car Momentum

Originally, steering was basically:

velocity.x = direction * steering_speed

Press right and you were immediately moving right at full speed.

Release the button and you stopped.

That was probably the biggest reason it felt like a spaceship.

I replaced that with lateral acceleration and deceleration.

Now the car has to build speed when you steer, and if you suddenly change direction, it has to get rid of its existing momentum before it starts moving the other way.

That changed the feel almost immediately.

There are now moments where I turn and think:

> “Oh. I turned too late.”

Which is exactly what I wanted.

Not because the controls ignored me, but because I had already committed a heavy car in the wrong direction.

Moving the Pivot Point

I also moved the visual steering pivot toward the back of the car.

Instead of the whole car rotating around its center, the rear stays comparatively planted while the front swings left and right.

It’s a subtle thing, but once it was combined with the momentum system, the car started feeling much more physical.

The current visual steering angle is only a few degrees, but that’s enough.

Body Roll

Once the steering felt good, I added a second visual effect.

When the player turns left, the body rolls slightly to the right.

When the player turns right, the body rolls left.

Then a spring/damping calculation lets it settle back through center instead of simply snapping upright again.

The effect is pretty small, but during a hard left-to-right correction you can actually see the weight of the car move across the suspension.

That was probably the point where I thought:

> Okay. This is starting to feel like something.

I Accidentally Launched the Car into Space

Of course, changing the Player scene broke a few things.

At one point, hitting an obstacle would send the visible car flying hundreds of pixels sideways and leave me unable to get back onto the road.

The bug ended up being a coordinate-space mistake.

I was calculating a knockback target using the Player’s world position…

…and then tweening BodyVisual.position.x, which is a local position.

So, I was basically telling a child node that normally lives around x = 0 to move to something like x = 700.

That’ll do it.

I changed impacts so the actual Player receives lateral velocity while the visual body only gets a small local jolt and rotation.

Now getting hit kicks the car sideways, and the player has to counter steer and recover.

That feels much better anyway.

The Obstacles Had to Change Too

Once the car had momentum, I discovered another problem.

Obstacle positions were completely random across the width of the road.

That was fine when the car could instantly change direction.

It was much less fine when the game could effectively ask:

> Far left → far right → far left

in rapid succession.

So instead of completely random X positions, obstacles now spawn using a small set of lanes.

The next obstacle can stay in the same lane or move one lane left or right.

That means the hazard pattern gradually moves across the road instead of teleporting from one extreme to the other.

It feels more deliberate even though there is still randomness involved.

It also helped differentiate the routes.

The detour gets slower, calmer obstacle patterns.

The shortcut gets denser patterns and more frequent lane changes.

After testing both, they finally feel like two different driving experiences instead of just two different timer values.

Building the Beginning of the Game

Toward the end of the day, I moved back to presentation.

DETOUR now has a proper opening flow:

Title
↓
Opening text
↓
Steering prompt
↓
First steering input starts the car
↓
Tutorial obstacle
↓
Normal road
↓
First route choice

The opening text is still intentionally simple:

11:47 PM
HIGHWAY CLOSED
DETOUR 42 MILES  
You promised you'd be home tonight.

Then the player gets:

← → STEER
A / D

The car doesn’t move until they actually steer.

That means the first thing the player does is also the tutorial.

A few seconds later, I spawn one deliberately easy obstacle in the center of the road with plenty of space on either side.

After that, the normal obstacle system takes over.

I like this much more than starting the game with everything already moving and hoping the player figures things out.

Day 3 Takeaway

Today didn’t add a huge new feature.

It mostly changed things that were already there.

But I think this was probably the most important day so far.

Yesterday I had a functioning game loop.

Today I started getting something that actually feels like driving.

The biggest lesson for me was that a mechanic can be completely functional and still not be finished.

Movement speed, acceleration, pivot points, collision behavior, visual weight transfer, obstacle spacing, none of those things individually sound like major features.

Together, they completely changed how the game feels.

And now that the car itself is becoming fun to control, I’m a lot more excited about building everything else around it.

Next Up

Next up: continuing to turn the prototype into an actual game, and probably experimenting with headlights and darkness because apparently, I’ve decided I don’t have enough things to do yet.