Can't get variable to sync with time

Hi everyone,

I am trying to follow this guide (Accurately syncing Unreal’s network clock | by Josh Sutphin | Medium) to synching the GetServerWorldTimeSeconds() function more accurately, as I need the client time and server times to match very accurately for a few purposes. If there is a better way to go about this, please tell me (maybe something to do with Online subsystems or something?).

Anyway, the code seems to perform the right function, with the following files:
FPSGameState.h

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/GameState.h"
#include "FPSGameState.generated.h"
/**
 * 
 */
UCLASS()
class FPSGAME_API AFPSGameState : public AGameState
{
	GENERATED_BODY()

protected:
	//Stores the maximum allowed latency (s) for a rewind to be allowed, otherwise it gives an unfair advantage to laggy bois
	UPROPERTY()
		float MaxAllowedLatencyForRewind = 0.400f;

	

public:
	float GetServerWorldTimeSeconds() const override;

	UFUNCTION()
		float GetMaxAllowedLatency() { return MaxAllowedLatencyForRewind; }
	
	
	
};

FPSGameState.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "FPSPlayerController.h"
#include "FPSGameState.h"

float AFPSGameState::GetServerWorldTimeSeconds() const
{
    AFPSPlayerController* pc = Cast<AFPSPlayerController>(GetGameInstance()->GetFirstLocalPlayerController(AActor::GetWorld()));
    if (pc)
    {
        UE_LOG(LogTemp, Warning, TEXT("Getting time"));
        return pc->GetServerTime();
    }
    else
    {
        return GetWorld()->GetTimeSeconds();
    }
}


FPSPlayerController.h

// Fill out your copyright notice in the Description page of Project Settings.

#include "fpsgame.h"
#include "FPSPlayerController.h"




void AFPSPlayerController::ServerRequestServerTime_Implementation(
    APlayerController* requester,
    float requestWorldTime
)
{
    float serverTime = GetWorld()->GetGameState()->
        GetServerWorldTimeSeconds();
    ClientReportServerTime(requestWorldTime, serverTime);
}

bool AFPSPlayerController::ServerRequestServerTime_Validate(
    APlayerController* requester,
    float requestWorldTime
)
{
    return true;
}

void AFPSPlayerController::ClientReportServerTime_Implementation(
    float requestWorldTime,
    float serverTime
)
{
    // Apply the round-trip request time to the server's         
    // reported time to get the up-to-date server time
    float roundTripTime = GetWorld()->GetTimeSeconds() -
        requestWorldTime;
    float adjustedTime = serverTime + (roundTripTime * 0.5f);
    ServerTime = adjustedTime;
}

//Performs time synching handshake at start of join
void AFPSPlayerController::ReceivedPlayer()
{
    Super::ReceivedPlayer();

    if (IsLocalController())
    {
        ServerRequestServerTime(
            this,
            GetWorld()->GetTimeSeconds()
        );
    }
}

FPSPlayerController.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/PlayerController.h"
#include "GameFramework/GameStateBase.h"
#include "FPSPlayerController.generated.h"

/**
 * 
 */
UCLASS()
class FPSGAME_API AFPSPlayerController : public APlayerController
{
    GENERATED_BODY()


public:

    //https://medium.com/@invicticide/accurately-syncing-unreals-network-clock-87a3f9262594
    /** Returns the network-synced time from the server.
      * Corresponds to GetWorld()->GetTimeSeconds()
      * on the server. This doesn't actually make a network
      * request; it just returns the cached, locally-simulated
      * and lag-corrected ServerTime value which was synced
      * with the server at the time of this PlayerController's
      * last restart. */
    UFUNCTION()
        virtual float GetServerTime() { return ServerTime; }

    virtual void ReceivedPlayer() override;

protected:

    /** Reports the current server time to clients in response
      * to ServerRequestServerTime */
    UFUNCTION(Client, Reliable)
        void ClientReportServerTime(
            float requestWorldTime,
            float serverTime
        );

    /** Requests current server time so accurate lag
      * compensation can be performed in ClientReportServerTime
      * based on the round-trip duration */
    UFUNCTION(Server, Reliable, WithValidation)
        void ServerRequestServerTime(
            APlayerController* requester,
            float requestWorldTime
        );

    //The actual synched server time
    UPROPERTY(EditAnywhere, BlueprintReadOnly)
        float ServerTime = 0.0f;

};

The variable in question is the ServerTime.
At the ReceivedPlayer handshake, it seems to update successfully, but then it gets stuck at that same time, and does not advance. How would I go about making it advance at the same rate as server time (World->GetTimeSeconds())?

Thank you in advance for any help, it will be much appreciated

I’m thinking that I have to update it in a tick function, by adding DeltaTime to it, however, I do not know how to tick a playercontroller-derived class either