The flow chart below shows how the host handles a loss request.

These code blocks show the two methods used to decide whether a player wins, loses, or draws.

//Decides on what decision to make based on the time difference from the requests
private void DecideOnEndGameState(NetworkingRequest finishedRequest, NetworkingRequestType type, int targetViewId)
{
    //Create array of requests ordered by their timestamp
    KeyValuePair<int, string>[] requests = finishedRequest.timeStamps.OrderBy(timeStamp => DateTime.Parse(timeStamp.Value)).ToArray();
    Dictionary<int, int> content = new Dictionary<int, int>();

    //Get the amount of players still alive
    IEnumerable<PhotonPlayer> players = PhotonNetwork.PlayerList.Where(player => (int)player.CustomProperties[PlayerPropertyHandler.PlayerStateKey] == (int)PlayerState.Playing);
    int amountOfPlayersAlive = players.Count();

    if (requests.Length < amountOfPlayersAlive)
    {
        //If the amount of request is smaller than the amount of players alive all players requesting will lose
        for (int i = 0; i < requests.Length; i++)
        {
            content.Add(requests[i].Key, (int)NetworkingLoseDesicionType.Lost);
        }

        if (requests.Length == amountOfPlayersAlive - 1)
        {
            //If there is only one player left that didn't make a loss request that player will win
            Dictionary<int, string> dict = requests.ToDictionary(x => x.Key, x => x.Value);

            foreach (var player in players)
            {
                if (!dict.ContainsKey(player.ActorNumber))
                {
                    //Raise event to notify the winner cliet it won
                    RaiseEvent(NetworkingEventType.PlayerWinGame, null, new int[] { player.ActorNumber }, true);
                    break;
                }
            }
        }
    }
    else { content = GetCloseEndGameStateResults(requests); }

    PhotonNetwork.RaiseEvent((byte)NetworkingRequestDecision.LoseDecision, new object[] { content, targetViewId }, GetEventOptions(finishedRequest), SendOptions.SendReliable);
}

//Gets the EndGame state result when it needs to decide if between winning, losing or a draw
private Dictionary<int, int> GetCloseEndGameStateResults(KeyValuePair<int, string>[] requests)
{
    Dictionary<int, int> content = new Dictionary<int, int>();

    NetworkingLoseDesicionType endState = NetworkingLoseDesicionType.Lost;

    for (int i = 0; i < requests.Length; i++)
    {
        //Once it is draw all other request will be draw so no logic needs to be applied
        if (endState != NetworkingLoseDesicionType.Draw)
        {
            if (i == requests.Length - 1)
            {
                //Win if request is the latest and no other requests are draw
                endState = NetworkingLoseDesicionType.Win;
            }
            else if ((DateTime.Parse(requests[i].Value) - DateTime.Parse(requests[requests.Length - 1].Value)).TotalMilliseconds < GameStateManager.Instance.DrawMargin)
            {
                //Draw if the time between the the last request and this request is inside of the drawMargin
                endState = NetworkingLoseDesicionType.Draw;
            }
            else { endState = NetworkingLoseDesicionType.Lost; }
        }
        //Add the state with player to the content dictionary
        content.Add(requests[i].Key, (int)endState);
    }

    return content;
}

The flow chart below shows how the scene loading solution works inside Hunter Gatherer.

The following code snippet shows the LoadGameScene method which loads the new scene and if needed the UI. After the new scene is loaded it unloads the previous scene.

//Loads a game scene
public void LoadGameScene(string sceneName)
{
    //Don't continue if scene doesn't exits
    if (!SceneIsLoadable(sceneName))
    {
        return;
    }

    //Don't load the scene if it's already loaded
    if (!UnitySceneManager.GetSceneByName(sceneName).isLoaded && !isLoading)
    {
        isLoading = true;

        //Load new game scene
        UnitySceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive).completed += loadOperation =>
        {
            //Unload current game scene
            UnitySceneManager.UnloadSceneAsync(UnitySceneManager.GetActiveScene()).completed += unloadOperation =>
            {
                //Set new game scene as active scene
                UnitySceneManager.SetActiveScene(UnitySceneManager.GetSceneByName(sceneName));
            };

            isLoading = false;

            StartCoroutine(CheckPlayersLoaded());

            //Load the GameUI scene
            LoadGameUIScene(gameUISceneName);
        };
    }
    else
    {
        LoadLoadedOrLoadingSceneError(sceneName);
    }
}