[Solved] Need advice on how to do 6DOF spaceship movement

woopdeedoo

I'm trying to do a spaceship movement much in the same way of the old game Descent. For reference:

In short, the ship has full "6 degrees of freedom": it can move in 3 axes and roll around 3 axes. Plus some auto-corrections to make it easier to handle.

I can see several ways of doing this, but I'm not sure which way to go.

1- Using a KinematicBody. I'm positive this will require using Quaternions, which I admit is intimidating me. I gave it a little go, using the same node structure that I use for FPS controllers, and Euler angles:

Kinematic
  Spatial (roll)
    Spatial (yaw)
      Camera (pitch)
  ... other nodes

But I still had problems of the sort that when you turn the ship upside down, the controls for left and right get inverted.

2- Using a RigidBody and applying forces to it. I gave it a little go as well, but then colliding on walls makes my ship rotate out of control. On top of that, I tried using the mouse to control the yaw and pitch (using event.relative values) and the ship gets skewed pretty easily. This is how I did it so far:

func _physics_process(delta: float) -> void:
    if Input.is_key_pressed(KEY_W): apply_central_impulse(-transform.basis.z)
    if Input.is_key_pressed(KEY_S): apply_central_impulse( transform.basis.z)
    if Input.is_key_pressed(KEY_A): apply_central_impulse(-transform.basis.x)
    if Input.is_key_pressed(KEY_D): apply_central_impulse( transform.basis.x)

    apply_torque_impulse(transform.basis.x * pitch)
    apply_torque_impulse(transform.basis.y * yaw)
    pitch = 0
    yaw = 0
	
func _input(event: InputEvent) -> void:
    if event is InputEventMouseMotion:
        yaw = -event.relative.x*0.065
        pitch = -event.relative.y*0.065

Applying forces seems quite tempting to me as a solution. It's easy enough to reason about, and takes no quaternions. If only I could keep collisions from affecting its rotations...

3- Using a Generic6DoFJoint... somehow... I haven't given this a try. It just crossed my mind. Probably not a good idea.

Possibly there might some other ways I can't think of. Would really appreciate if someone could give some insights on this.

woopdeedoo

Someone on discord guided me through solving the rotation problems I was having when doing this the KinematicBody way (1), using some quaternions. It might be possible to do this using a RigidBody, but I couldn't figure out how to deal with the collisions.

This is the code I'm using (minus the movement code):

var mouse_sens_pitch = 2.5
var mouse_sens_yaw = 2.5
var angular_velocity:Quat
var roll_speed = 25

func _input(event: InputEvent) -> void:
    if event is InputEventMouseMotion:
        yaw = fmod(yaw - event.relative.x * mouse_sens_yaw, 360)
        pitch = fmod(pitch - event.relative.y * mouse_sens_pitch, 360)


func _physics_process(delta: float) -> void:
    # (...) movement code

    roll = 0

    if Input.is_key_pressed(KEY_Q): roll += roll_speed
    if Input.is_key_pressed(KEY_E): roll -= roll_speed

    var rotation_vec = Vector3(deg2rad(pitch), deg2rad(yaw), deg2rad(roll)) * delta
    var relative_velocity = Quat(rotation_vec)
    angular_velocity = (angular_velocity * relative_velocity).slerp(Quat.IDENTITY, 0.15)

    var current_rotation = Quat(transform.basis)
    var final_rotation = current_rotation * angular_velocity
    transform.basis = Basis(final_rotation)

    transform = transform.orthonormalized()

    pitch = 0	# zero these out, or else it rotates forever
    yaw = 0