Unity Cloud
Engineering

Company Name:  YourStudio           // affects bundle ID
Product Name:  CloudPOC
Bundle ID:     com.yourstudio.cloudpoc

Scripting Backend:   IL2CPP          // REQUIRED for production builds
API Compatibility:   .NET Standard 2.1

<linker>
  <assembly fullname="Unity.Services.Core" preserve="all"/>
  <assembly fullname="Unity.Services.Authentication" preserve="all"/>
  <assembly fullname="Unity.Services.Lobby" preserve="all"/>
  <assembly fullname="Unity.Services.Relay" preserve="all"/>
  <assembly fullname="Unity.Services.CloudSave" preserve="all"/>
  <assembly fullname="Unity.Services.RemoteConfig" preserve="all"/>
  <assembly fullname="Unity.Netcode.Runtime" preserve="all"/>
</linker>

{
  "dependencies": {
    "com.unity.services.core":           "1.13.0",
    "com.unity.services.authentication":  "3.3.3",
    "com.unity.services.lobby":           "1.2.2",
    "com.unity.services.relay":           "1.3.1",
    "com.unity.services.cloudsave":       "3.2.1",
    "com.unity.services.remoteconfig":   "4.1.1",
    "com.unity.netcode.gameobjects":     "1.9.1",
    "com.unity.transport":               "2.3.0"
  }
}

using Unity.Services.Core;
using Unity.Services.Authentication;
using UnityEngine;
using System.Threading.Tasks;

public class UGSManager : MonoBehaviour
{
    public static UGSManager Instance { get; private set; }

    async void Awake()
    {
        if (Instance != null) { Destroy(gameObject); return; }
        Instance = this;
        DontDestroyOnLoad(gameObject);

        await InitializeUGS();
    }

    async Task InitializeUGS()
    {
        try
        {
            // Step 1: Initialize UGS Core (required before ANY service call)
            await UnityServices.InitializeAsync();

            // Step 2: Subscribe to auth events before signing in
            AuthenticationService.Instance.SignedIn += OnSignedIn;
            AuthenticationService.Instance.SignInFailed += OnSignInFailed;
            AuthenticationService.Instance.Expired += OnTokenExpired;

            // Step 3: Sign in (anonymous for POC)
            if (!AuthenticationService.Instance.IsSignedIn)
                await AuthenticationService.Instance.SignInAnonymouslyAsync();
        }
        catch (AuthenticationException ex)
        {
            // AuthenticationErrorCode tells you exactly what went wrong
            Debug.LogError($"Auth failed: {ex.ErrorCode} — {ex.Message}");
        }
        catch (RequestFailedException ex)
        {
            // Network-level or service errors (503, 429, etc.)
            Debug.LogError($"UGS request failed: {ex.ErrorCode}");
        }
    }

    void OnSignedIn()
    {
        Debug.Log($"Signed in! PlayerID: {AuthenticationService.Instance.PlayerId}");
    }

    void OnSignInFailed(RequestFailedException err)
    {
        Debug.LogError($"Sign in failed: {err.ErrorCode}");
    }

    void OnTokenExpired()
    {
        // Token expires after 1 hour. Auto-refresh usually handles this,
        // but for robust apps, show a "session expired" prompt or re-auth.
        Debug.LogWarning("Auth token expired. Re-authenticating...");
        _ = AuthenticationService.Instance.SignInAnonymouslyAsync();
    }
}

using Unity.Services.Lobbies;
using Unity.Services.Lobbies.Models;
using System.Collections.Generic;

public class LobbyManager
{
    Lobby _currentLobby;
    ILobbyEvents _lobbyEvents;   // for real-time subscriptions
    float _heartbeatTimer;

    public async Task<Lobby> CreateLobbyAsync(string lobbyName, int maxPlayers)
    {
        var options = new CreateLobbyOptions
        {
            IsPrivate = false,
            Player = GetLocalPlayer(),  // your player data for the lobby
            Data = new Dictionary<string, DataObject>
            {
                // We'll set RelayJoinCode here once we have it
                { "RelayJoinCode", new DataObject(DataObject.VisibilityOptions.Member, "") },
                { "MapName",      new DataObject(DataObject.VisibilityOptions.Public,  "Forest") }
            }
        };

        _currentLobby = await LobbyService.Instance.CreateLobbyAsync(lobbyName, maxPlayers, options);
        Debug.Log($"Lobby created: {_currentLobby.Id} | Code: {_currentLobby.LobbyCode}");

        // CRITICAL: Start heartbeating or the lobby deletes itself after 30s
        StartHeartbeat();

        return _currentLobby;
    }

    // Must be called from Update() — lobby heartbeat every 15 seconds
    public async Task HandleHeartbeatAsync(float deltaTime)
    {
        _heartbeatTimer -= deltaTime;
        if (_heartbeatTimer <= 0f && _currentLobby != null)
        {
            _heartbeatTimer = 15f;
            await LobbyService.Instance.SendHeartbeatPingAsync(_currentLobby.Id);
        }
    }

    public async Task UpdateRelayCodeInLobbyAsync(string joinCode)
    {
        _currentLobby = await LobbyService.Instance.UpdateLobbyAsync(
            _currentLobby.Id,
            new UpdateLobbyOptions
            {
                Data = new Dictionary<string, DataObject>
                {
                    { "RelayJoinCode", new DataObject(DataObject.VisibilityOptions.Member, joinCode) }
                }
            }
        );
    }
}

// Join by the 6-character short lobby code shown in your UI
public async Task<Lobby> JoinLobbyByCodeAsync(string code)
{
    var options = new JoinLobbyByCodeOptions { Player = GetLocalPlayer() };
    _currentLobby = await LobbyService.Instance.JoinLobbyByCodeAsync(code, options);
    return _currentLobby;
}

// Quick-join: finds any available lobby automatically
public async Task<Lobby> QuickJoinAsync()
{
    var options = new QuickJoinLobbyOptions
    {
        Player = GetLocalPlayer(),
        // Filter by map (using indexed lobby data)
        Filter = new List<QueryFilter>
        {
            new QueryFilter(QueryFilter.FieldOptions.AvailableSlots,
                           "0", QueryFilter.OpOptions.GT)
        }
    };
    return await LobbyService.Instance.QuickJoinLobbyAsync(options);
}

// Subscribe to real-time lobby changes (v1.2+ of Lobby SDK)
public async Task SubscribeToLobbyEventsAsync()
{
    var callbacks = new LobbyEventCallbacks();
    callbacks.LobbyChanged += OnLobbyChanged;
    callbacks.KickedFromLobby += OnKicked;
    callbacks.LobbyEventConnectionStateChanged += OnConnectionStateChanged;
    _lobbyEvents = await LobbyService.Instance.SubscribeToLobbyEventsAsync(_currentLobby.Id, callbacks);
}

void OnLobbyChanged(ILobbyChanges changes)
{
    if (changes.LobbyDeleted) { /* host left, handle cleanup */ return; }
    changes.ApplyToLobby(_currentLobby);  // mutates the local copy
    
    // Check if host set the relay code
    if (_currentLobby.Data.TryGetValue("RelayJoinCode", out var relay) && !string.IsNullOrEmpty(relay.Value))
    {
        // Time to join relay and start netcode!
        _ = JoinRelayAndStartClientAsync(relay.Value);
    }
}

using Unity.Services.Relay;
using Unity.Services.Relay.Models;
using Unity.Networking.Transport.Relay;
using Unity.Netcode;
using Unity.Netcode.Transports.UTP;

public class RelayManager
{
    public async Task<string> StartHostWithRelayAsync(int maxConnections)
    {
        // maxConnections = max number of OTHER players (not counting host)
        Allocation allocation = await RelayService.Instance.CreateAllocationAsync(maxConnections);
        
        // Get the join code clients will use to find this relay slot
        string joinCode = await RelayService.Instance.GetJoinCodeAsync(allocation.AllocationId);

        // Convert to Unity Transport relay data
        RelayServerData relayData = AllocationUtils.ToRelayServerData(allocation, "dtls");
        // Note: use "wss" protocol for WebGL builds instead of "dtls"

        // Wire up the Netcode transport with relay data
        var transport = NetworkManager.Singleton.GetComponent<UnityTransport>();
        transport.SetRelayServerData(new RelayServerData(allocation, "dtls"));

        NetworkManager.Singleton.StartHost();

        Debug.Log($"Host started. Relay join code: {joinCode}");
        return joinCode;
    }

    public async Task JoinRelayAndStartClientAsync(string joinCode)
    {
        JoinAllocation joinAllocation = await RelayService.Instance.JoinAllocationAsync(joinCode);

        var transport = NetworkManager.Singleton.GetComponent<UnityTransport>();
        transport.SetRelayServerData(new RelayServerData(joinAllocation, "dtls"));

        NetworkManager.Singleton.StartClient();
        Debug.Log("Client connected via Relay.");
    }
}

using Unity.Netcode;
using UnityEngine;

public class PlayerController : NetworkBehaviour
{
    // NetworkVariable: server writes, all clients read. Synced automatically.
    public NetworkVariable<Vector3> NetworkPosition = new(Vector3.zero,
        NetworkVariableReadPermission.Everyone,
        NetworkVariableWritePermission.Server);

    public NetworkVariable<int> Health = new(100,
        NetworkVariableReadPermission.Everyone,
        NetworkVariableWritePermission.Server);

    void Update()
    {
        // IsOwner = true only on the client that owns this object
        if (!IsOwner) return;

        Vector3 input = new(Input.GetAxisRaw("Horizontal"), 0, Input.GetAxisRaw("Vertical"));
        if (input.sqrMagnitude > 0.1f)
        {
            // Tell the server to move us — server validates, then writes NetworkPosition
            MoveServerRpc(input.normalized);
        }
    }

    // [ServerRpc] runs on the server. Called from owner client.
    // RequireOwnership = true is the default. It rejects calls from non-owners.
    [ServerRpc]
    void MoveServerRpc(Vector3 direction)
    {
        Vector3 newPos = transform.position + direction * 5f * Time.deltaTime;
        // Server validates (check walls, etc.) then commits
        NetworkPosition.Value = newPos;
        transform.position = newPos;
    }

    // [ClientRpc] runs on ALL clients. Called from server only.
    [ClientRpc]
    public void PlayHitEffectClientRpc(Vector3 hitPoint)
    {
        // Spawn VFX locally on every client
        Debug.Log($"Hit effect at {hitPoint} on {gameObject.name}");
    }

    public override void OnNetworkSpawn()
    {
        // Called on all clients when this object is networked-spawned
        if (IsOwner)
        {
            // Enable camera follow, input, etc. only for local player
            Camera.main.GetComponent<CameraFollow>().SetTarget(transform);
        }
    }
}

using Unity.Netcode;

public class GameManager : NetworkBehaviour
{
    [SerializeField] GameObject playerPrefab;

    public override void OnNetworkSpawn()
    {
        if (!IsServer) return;
        NetworkManager.Singleton.OnClientConnectedCallback += OnClientConnected;
    }

    void OnClientConnected(ulong clientId)
    {
        Vector3 spawnPoint = GetSpawnPoint();
        GameObject player = Instantiate(playerPrefab, spawnPoint, Quaternion.identity);
        
        // Spawn with ownership assigned to the connecting client
        player.GetComponent<NetworkObject>().SpawnAsPlayerObject(clientId);
    }
}

using Unity.Services.CloudSave;
using Unity.Services.CloudSave.Models;
using System.Collections.Generic;
using Newtonsoft.Json;  // comes with UGS core

[System.Serializable]
public class PlayerSaveData
{
    public int    Level   = 1;
    public int    XP      = 0;
    public string Skin    = "default";
}

public class CloudSaveManager
{
    const string SAVE_KEY = "player_data";

    public async Task SaveAsync(PlayerSaveData data)
    {
        var payload = new Dictionary<string, object>
        {
            { SAVE_KEY, data }  // UGS serializes this to JSON automatically
        };
        await CloudSaveService.Instance.Data.Player.SaveAsync(payload);
        Debug.Log("Player data saved to cloud.");
    }

    public async Task<PlayerSaveData> LoadAsync()
    {
        var keys = new HashSet<string> { SAVE_KEY };
        var results = await CloudSaveService.Instance.Data.Player.LoadAsync(keys);

        if (results.TryGetValue(SAVE_KEY, out var item))
            return item.Value.GetAs<PlayerSaveData>();

        // First time player: return defaults
        return new PlayerSaveData();
    }
}

using Unity.Services.RemoteConfig;
using System.Threading.Tasks;

public class RemoteConfigManager
{
    struct UserAttributes { }   // optional: AB test targeting
    struct AppAttributes  { }

    // Local defaults — used if fetch fails or key doesn't exist in dashboard
    public int   MaxPlayers    = 4;
    public float RespawnDelay  = 3f;
    public bool  EventEnabled  = false;

    public async Task FetchAndApplyAsync()
    {
        // RemoteConfigService listens to this event when fetch completes
        RemoteConfigService.Instance.FetchCompleted += OnFetchCompleted;
        await RemoteConfigService.Instance.FetchConfigsAsync(new UserAttributes(), new AppAttributes());
    }

    void OnFetchCompleted(ConfigResponse response)
    {
        switch (response.requestOrigin)
        {
            case ConfigOrigin.Default:
                Debug.Log("RemoteConfig: using hardcoded defaults"); break;
            case ConfigOrigin.Cached:
                Debug.Log("RemoteConfig: using cached values"); break;
            case ConfigOrigin.Remote:
                Debug.Log("RemoteConfig: fresh from server"); break;
        }

        MaxPlayers   = RemoteConfigService.Instance.appConfig.GetInt("max_players",   4);
        RespawnDelay = RemoteConfigService.Instance.appConfig.GetFloat("respawn_delay", 3f);
        EventEnabled = RemoteConfigService.Instance.appConfig.GetBool("event_active",   false);

        Debug.Log($"Config: MaxPlayers={MaxPlayers} Respawn={RespawnDelay} Event={EventEnabled}");
    }
}

var regions = await RelayService.Instance.ListRegionsAsync();

// Ping each region and pick the fastest
string bestRegion = "auto";
long   bestLatency = long.MaxValue;

foreach (var region in regions)
{
    long ping = await PingRegionAsync(region.Id);
    if (ping < bestLatency) { bestLatency = ping; bestRegion = region.Id; }
}

var allocation = await RelayService.Instance.CreateAllocationAsync(
    maxConnections: 3,
    region: bestRegion  // null or "auto" lets Unity pick — usually fine
);