Godot 3.1 Authoritative Server

extends KinematicBody

#############
# VARIABLES #
#############

# PLAYER ATTRIBUTES #
const SPEED = 6
const ACC = 5
const DEC = 5
const GRAVITY = 20
const JUMP_SPEED = 8
const JUMP_DAMP = 0.25 # currently defunct, used for variable jump heights

# ENGINE VARIABLES #
var velocity = Vector3(0,0,0)
var movedir = Vector3()
var animation = "shoot"
var can_jump = false

# CAMERA STUFF #
onready var camera = $Camera
var sensitivity = 0.001

# CLIENT #
var client_timestamp = 0 # keeps track of when inputs take place
var pending_inputs = [] # client-only queue of previous inputs used for server reconciliation
var queued_inputs = [] # similar to above, but is sent to server and cleared once sent
var server_state = [] # state received from server to sync position & velocity

# SERVER #
var server_timestamp = 0 # used for tracking the latest received input
var client_input = [] # queue of inputs received from client
var queued_states = [] # queue of states to send to client

# PUPPETS #
var packet_elapsed_time = 0 # how long it's been since the last packet
var tick_time = 0 # basically the tick rate. synced in game.gd
var old_position = global_transform.origin # position to interpolate from
var new_position = global_transform.origin # position to interpolate to

#############
# FUNCTIONS #
#############

func _ready():
    add_to_group("player")

func _physics_process(delta):
    set_animation()

    can_jump = is_on_floor() # !!this line is dangerous and should eventually be checked by the server!!

    # currently playing player
    if is_network_master():
        camera.current = true
        allow_mouse_capture()
        get_inputs()
        move()

        # if not the server, prepare packets for server
        if !get_tree().is_network_server():
            create_client_input()
            server_reconciliation()

    # the server
    if get_tree().is_network_server():
        # if not the host, process client movements
        if !is_network_master():
            process_client_movement()

        create_server_state() # prepare packets for client

    # puppets
    if !is_network_master() && !get_tree().is_network_server():
        sync_entities()

func update_tick(): # called by game.gd; sends packets
    # server updates to clients
    if get_tree().is_network_server():
        # send all of the states that occured since the last tick
        while queued_states.size() > 0:
            rpc_unreliable("receive_server_state", queued_states[0])
            queued_states.pop_front()

    # client updates to server
    elif is_network_master():
        # send all of the inputs that occured since the last tick
        while queued_inputs.size() > 0:
            rpc_unreliable_id(1, "receive_client_input", queued_inputs[0])
            queued_inputs.pop_front()

# CLIENT FUNCTIONS #
# stuff that happens on your screen (and other players' screens)

remote func receive_server_state(state): # takes received state of server & adds it to a queue (used in reconciliation)
    server_state.append(state)
    packet_elapsed_time = 0

func create_client_input(): # takes inputs and adds it to two queues
    var new_input = {
        movedir = movedir,
        rot = rotation.y,
        timestamp = client_timestamp
    }

    pending_inputs.append(new_input) # used in server_reconciliation
    queued_inputs.append(new_input) # used to send to server
    client_timestamp += 1

func server_reconciliation(): # compares latest received server state & replays unreceived movements
    while server_state.size() > 0:
        var msg = server_state.front() # the earliest unplayed state
        server_state.pop_front()

        # sync player to server state
        global_transform.origin = msg.position
        velocity = msg.velocity

        # replay movements that the state didn't receive at the time
        var current_input = 0
        while current_input < pending_inputs.size():
            var input = pending_inputs[current_input]
            if input.timestamp <= msg.timestamp: # if the server already processed this input, remove it
                pending_inputs.remove(current_input)
            else: # otherwise, reprocess the input on the client
                move(input.movedir)
                current_input += 1

func get_inputs(): # gets currently pressed movement & jump keys
    movedir = Vector3(0,0,0)

    movedir += camera.global_transform.basis.z * (-int(Input.is_action_pressed("up")) + int(Input.is_action_pressed("down")))
    movedir += camera.global_transform.basis.x * (-int(Input.is_action_pressed("left")) + int(Input.is_action_pressed("right")))

    movedir.y = 0
    movedir = movedir.normalized()

    # we just use movedir.y for jumps to save some bandwidth on a jump variable
    if Input.is_action_pressed("jump") && can_jump:
        movedir.y = 1

func allow_mouse_capture(): # lock mouse to screen if clicked
    if Input.is_mouse_button_pressed(BUTTON_LEFT):
        Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)

func _input(event): # rotate camera to mouse && press TAB to unlock mouse
    if !is_network_master():
        return
    if event is InputEventMouseMotion && Input.get_mouse_mode() == Input.MOUSE_MODE_CAPTURED:
        rotation.y -= event.relative.x * sensitivity # left right
        camera.rotation.x = clamp(camera.rotation.x - event.relative.y * sensitivity, deg2rad(-85), deg2rad(85)) # up down

    if event is InputEventKey && event.pressed:
        if event.scancode == KEY_TAB:
            Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)

# SERVER FUNCTIONS #
# processes inputs received by the client and creates the state every peer will adhere to

remote func receive_client_input(input): # takes received client movement & adds it to a queue
    client_input.append(input)

func process_client_movement(): # iterate through and process every input received by the client
    server_timestamp = 0

    while client_input.size() > 0:
        var msg = client_input[0]

        server_timestamp = max(server_timestamp, msg.timestamp)

        # make sure the client isn't trying to punk us with bogus movedirs (speedhacks)
        msg.movedir.x = clamp(msg.movedir.x, -1, 1)
        msg.movedir.z = clamp(msg.movedir.z, -1, 1)

        rotation.y = msg.rot

        move(msg.movedir)
        client_input.pop_front()

func create_server_state(): # saves the player's current state to be sent to every other player
    var new_state = {
        position = global_transform.origin,
        velocity = velocity,
        rot = rotation.y,
        timestamp = server_timestamp,
        }

    queued_states.append(new_state)

# PUPPET FUNCTIONS #
# these are player objects that are not controlled by the client i.e. other players

func sync_entities(): # sync position & velocity to server state
    packet_elapsed_time += get_physics_process_delta_time() # time since last packet (reset in update_tick)

    if server_state:
        var msg = server_state.back()

        old_position = server_state.front().position # the oldest known position that will be interpolated from
        new_position = msg.position # the last position that will be interpolated to

        velocity = msg.velocity
        rotation.y = msg.rot

        server_state.clear() # we don't care about this state anymore

    ### entity interpolation
    #!# currently the host doesn't interpolate the other players on his screen
    global_transform.origin = old_position.linear_interpolate(new_position, packet_elapsed_time / tick_time)

# GENERIC FUNCTIONS #

func move(dir = movedir): # process movement based off of direction & velocity
    var delta = get_physics_process_delta_time()
    var hv = Vector3(velocity.x, 0, velocity.z) # horizontal velocity
    var new_pos = dir * SPEED

    var accel = DEC

    if dir.dot(hv) > 0:
        accel = ACC

    hv = hv.linear_interpolate(new_pos, accel * delta) # I know lerping by delta doesn't work like this but I forgot the other way

    velocity.x = hv.x
    velocity.z = hv.z

    if !is_on_floor():
        velocity.y -= GRAVITY * delta

    if dir.y != 0: # on jump key press (refer to get_input)
        velocity.y = JUMP_SPEED

    velocity = move_and_slide(velocity, Vector3(0,1,0))

func set_animation(): # set Sprite3D animation (also refer to that script for billboard sprites)
    var hspeed = Vector3(velocity.x, 0, velocity.z).length() # horizontal speed

    if !is_grounded():
        animation = "jump"
    elif hspeed < SPEED * 0.2:
        animation = "idle"
    else:
        animation = "walk"

func is_grounded(): # basically is_on_floor combined with a longer RayCast3D to give a little leeway
    if is_on_floor() || $OnGround.is_colliding():
        return true
    return false