You’re on the right track, and as ever, there are a few ways of doing this, but here is one based on your existing code.

```
Vector3 direction = other.transform.position - collider.transform.position;
direction = direction.normalized;
Vector3 flattenedDirection = direction;
flattenedDirection.y = 0;
direction = Vector3.Lerp(direction, flattenedDirection, verticalityBias);
other.GetComponent<Rigidbody>().velocity = direction * bounceForce;
```

Rather than doing anything with scaling, I’ve made a copy of “direction” and then set its y to 0, and then you can lerp between those two vectors in the same way.

Small nitpick while I’m here, its best practice to make sure your variable names start lowercase, as it quickly gets confusing trying to tell if “Collider” is the class, or an object with that name, so I’ve renamed them in my example.

##
edit: Fix for removing RELATIVE up

Meet your new friend: Vector3.Dot() It lets you get the magnitude of a component of a vector that is in a particular direction:

```
Vector3.Dot(direction, transform.up)
```

Gives us the scale of the direction vector, but only the part of it in the direction of transform up.

So then if we multiply that *by* transform up we get the unwanted component of our direction vector:

```
Vector3 unwantedDirection = Vector3.Dot(direction, transform.up) * transform.up;
```

So then to get our new version of flattenedDirection we subtract that from the total direction:

```
Vector3 flattenedDirection = direction - unwantedDirection;
```

So this is what we end up with now:

```
Vector3 direction = other.transform.position - collider.transform.position;
direction = direction.normalized;
float upwardMagnitude = Vector3.Dot(direction, transform.up);
Vector3 unwantedDirection = Vector3.Dot(direction, transform.up) * transform.up;
Vector3 flattenedDirection = direction - unwantedDirection;
direction = Vector3.Lerp(direction, flattenedDirection, verticalityBias);
other.GetComponent<Rigidbody>().velocity = direction * bounceForce;
```