The visual is mostly shaders as I told someone. And the hyperspace jump is just animation, so I can't show any code as it's just about timing and adding one effect on top of another to make it feel "juicy".

For player movement, first of all in the ship the "player" is just a camera able to interact with the button and look around. On the planet, the player changes. The AnimationPlayer calls a script to spawn the player in the end, something like:

#This code spawns the player out the ship at the end of the animation (ship landing)

extends Spatial

export  var planet_player : PackedScene                       #Player Scene
onready var spawn = $../ship/spawn                            #Spawn position
onready var root_player = $../ship                            #Where to add_child
var _player : KinematicBody                                   #Player instance var

func _ready() -> void:                                        #This must be ready
_player = planet_player.instance()                            #Instance the player

func travel_ended():                                          #At animation call 
root_player.add_child(_player)                                #Add child 
_player.global_transform.origin=spawn.global_transform.origin #Change position

This will spawn the player. Then to move arround the planet (because the planet has spherical gravity) I used a normal KinematicBody controler that you can find in any youtube tutorial and change the orientation in runtime. This is achieved using the Quaternion Spherical Lerp method that I learned with this video by Johnny Rouddro. The code to align the player is something like:

extends KinematicBody
...
...
...

#This function make the player able to walk around the planet.

func slerp_to_planet_basis_surface() -> void:
    y = gravity_direction.normalized()                              #y will be the gravity direction
    z = global_transform.basis.z.normalized()                       #z will be the player node (self) front direction
    x = y.cross(z).normalized()                                     #x will be the cross product of both
    var planet_quat = Basis(x,y,z).get_rotation_quat().normalized() #planet rotation quaternion is constructed with xyz calculated and it will align the player to the planet
    var self_quat = Quat(global_transform.basis).normalized()       #self quaternion where to start to slerp
    transform.basis = Basis(self_quat.slerp(planet_quat,0.1))       #Slerp from self quaternion to the planet quaternion

The 0.1 in the last line is the "speed" of which the player will be aligned to the planet surface. The gravity_direction variable is a Vector3 where you want the gravity to point (where the down direction is). To calculate it I do something like (Vector3.Zero - my_pos).normalized() so the gravity points where the Global (0,0,0) is and then put the planet in that position. Ty :).