Using Unity's `transform.translate()` to translate relative to an object but only using two axis

Question

I'm using transform.translate() to move an object around the world space, relative to the camera that is following it. The camera has an angle of 23 degrees on the X axis.

The problem is that when I move forward the object tries to go into the ground and when going backward the object starts jumping because of the angle of the camera. What I want to do is freeze the Y axis of the object However if I did this the object would no longer be able to jump.

The other solution to this would be to write a method which rests the object to the ground when not jumping but them if the object was jumping and going backwards it would go flying backwards again.

How do I solve this issue?

Answer 1

Figured it out. Essentially i'm taking the position of the object before and after then taking the difference of both of then then adding it back into the position, so that the difference in Y-axis position that is introduced from the camera transform.Translate() is compensated for.

//compensate for the rotation of the camera while moving
void CompensateTransform(float X, float Y)
{
    float diffrence = transform.position.y;
    transform.Translate(speed * Time.deltaTime * X, 0,
            Time.deltaTime * Y * speed, camera.transform);
    diffrence -= transform.position.y;
    transform.position = new Vector3(transform.position.x, 
        transform.position.y + diffrence, 
        transform.position.z);
}

Answer 2

Here's a method that won't foreshorten your forward & backward movement:

Quaternion GetGroundFrame()
{
    // You can replace this with a raycast if you have more complex levels,
    // to get the direction of the collision plane under the character.
    Vector3 groundNormal = Vector3.up;

    transform cam = Camera.main.transform;

    // Construct a rotation that points your nose away from the ground,
    // and your chin roughly toward the camera's forward direction.
    Quaternion frame = Quaternion.LookRotation(groundNormal, -cam.forward);

    // Note that this will need a little special handling if your camera
    // can ever look nearly straight up/down along the ground normal.

    // Rotate the coordinate frame 90 degrees forward.
    frame = frame * Quaternion.AngleAxis(90f, Vector3.right);

    return frame;
}

(See more on the derivation of this coordinate frame here)

Then you can do something like:

Quaternion frame = GetGroundFrame();
Vector3 offset = new Vector3(r, 0, f) * speed * Time.deltaTIme;

// Multiplying by frame transforms the movement-space offset
// into worldspace.
transform.translate(frame * offset, Space.World);

Answer 3

you should simply use transform.position += vector3.forward * speed * time.deltatime;

make a variable of type float for speed like below: private float speed = 2f;

also use vector3.back or vector3.right and so on... for other directions