Game Server Hosting (Multiplay) SDK for Unity#

async void Example_InitSDK()
{
	try
	{
		await UnityServices.InitializeAsync();
	}
	catch (Exception e)
	{
		Debug.Log(e);
	}
}

using System.Collections;
using System.Collections.Generic;
using Unity.Services.Multiplay;
using UnityEngine;

public class Example_ServerConfiguration
{
	/// <summary>
	/// A simple example of accessing each of the server config's fields and printing them to the debug console.
	/// </summary>
	public static void LogServerConfig()
	{
		var serverConfig = MultiplayService.Instance.ServerConfig;
		Debug.Log($"Server ID[{serverConfig.ServerId}]");
		Debug.Log($"AllocationID[{serverConfig.AllocationId}]");
		Debug.Log($"Port[{serverConfig.Port}]");
		Debug.Log($"QueryPort[{serverConfig.QueryPort}");
		Debug.Log($"LogDirectory[{serverConfig.ServerLogDirectory}]");
	}
}

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

/// <summary>
/// Ready the server. This is to indicate that the server is ready to accept players.
/// Readiness is the server's way of saying it's ready for players to join the server.
/// You must wait until you have been Allocated before you can call ReadyServerForPlayersAsync.
/// </summary>
private async void Example_ReadyingServer()
{
	// After the server is back to a blank slate and ready to accept new players
	await MultiplayService.Instance.ReadyServerForPlayersAsync();
}

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

/// <summary>
/// Unready the server. This is to indicate that the server is in some condition which means it can't accept players.
/// For example, after a game has ended and you need to reset the server to prepare for a new match.
/// </summary>
private async void Example_UnreadyingServer()
{
	// The match has ended and players are disconnected from the server
	await MultiplayService.Instance.UnreadyServerAsync();
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Unity.Services.Multiplay;

/// <summary>
/// An example of how to use SQP from the server using the Multiplay SDK.
/// The ServerQueryHandler reports the given information to the Multiplay Service.
/// </summary>
public class Example_ServerQueryHandler : MonoBehaviour
{
	private const ushort k_DefaultMaxPlayers = 10;
	private const string k_DefaultServerName = "MyServerExample";
	private const string k_DefaultGameType = "MyGameType";
	private const string k_DefaultBuildId = "MyBuildId";
	private const string k_DefaultMap = "MyMap";
	
	public ushort currentPlayers;
	
	private IServerQueryHandler m_ServerQueryHandler;
	
	private async void Start()
	{
		m_ServerQueryHandler = await MultiplayService.Instance.StartServerQueryHandlerAsync(k_DefaultMaxPlayers, k_DefaultServerName, k_DefaultGameType, k_DefaultBuildId, k_DefaultMap);
	}
	
	private void Update()
	{
		m_ServerQueryHandler.UpdateServerCheck();
	}
	
	public void ChangeQueryResponseValues(ushort maxPlayers, string serverName, string gameType, string buildId)
	{
		m_ServerQueryHandler.MaxPlayers = maxPlayers;
		m_ServerQueryHandler.ServerName = serverName;
		m_ServerQueryHandler.GameType = gameType;
		m_ServerQueryHandler.BuildId = buildId;
	}
	
	public void PlayerCountChanged(ushort newPlayerCount)
	{
		m_ServerQueryHandler.CurrentPlayers = newPlayerCount;
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using Unity.Services.Multiplay;
using UnityEngine;

/// <summary>
/// An example of how to access and react to multiplay server events.
/// </summary>
public class Example_ServerEvents : MonoBehaviour
{
	private MultiplayEventCallbacks m_MultiplayEventCallbacks;
	private IServerEvents m_ServerEvents;
	
	/// <summary>
	/// This should be done early in the server's lifecycle, as you'll want to receive events as soon as possible.
	/// </summary>
	private async void Start()
	{
		// We must first prepare our callbacks like so:
		m_MultiplayEventCallbacks = new MultiplayEventCallbacks();
		m_MultiplayEventCallbacks.Allocate += OnAllocate;
		m_MultiplayEventCallbacks.Deallocate += OnDeallocate;
		m_MultiplayEventCallbacks.Error += OnError;
		m_MultiplayEventCallbacks.SubscriptionStateChanged += OnSubscriptionStateChanged;
		
		// We must then subscribe.
		m_ServerEvents = await MultiplayService.Instance.SubscribeToServerEventsAsync(m_MultiplayEventCallbacks);
	}

// Handle Multiplay events.

}

using System;
using System.Collections;
using System.Collections.Generic;
using Unity.Services.Multiplay;
using UnityEngine;

/// <summary>
/// An example of how to access and react to multiplay server events.
/// </summary>
public class Example_ServerEvents : MonoBehaviour
{
	private MultiplayEventCallbacks m_MultiplayEventCallbacks;
	private IServerEvents m_ServerEvents;
	
	/// <summary>
	/// This should be done early in the server's lifecycle, as you'll want to receive events as soon as possible.
	/// </summary>
	private async void Start()
	{
		// We must first prepare our callbacks like so:
		m_MultiplayEventCallbacks = new MultiplayEventCallbacks();
		m_MultiplayEventCallbacks.Allocate += OnAllocate;
		m_MultiplayEventCallbacks.Deallocate += OnDeallocate;
		m_MultiplayEventCallbacks.Error += OnError;
		m_MultiplayEventCallbacks.SubscriptionStateChanged += OnSubscriptionStateChanged;
		
		// We must then subscribe.
		m_ServerEvents = await MultiplayService.Instance.SubscribeToServerEventsAsync(m_MultiplayEventCallbacks);
	}
	
	/// <summary>
	/// Handler for receiving the allocation multiplay server event.
	/// </summary>
	/// <param name="allocation">The allocation received from the event.</param>
	private void OnAllocate(MultiplayAllocation allocation)
	{
		// Here is where you handle the allocation.
		// This is highly dependent on your game, however this would typically be some sort of setup process.
		// Whereby, you spawn NPCs, setup the map, log to a file, or otherwise prepare for players.
		// After you the allocation has been handled, you can then call ReadyServerForPlayersAsync()!
	}
	
	/// <summary>
	/// Handler for receiving the deallocation multiplay server event.
	/// </summary>
	/// <param name="deallocation">The deallocation received from the event.</param>
	private void OnDeallocate(MultiplayDeallocation deallocation)
	{
		// Here is where you handle the deallocation.
		// This is highly dependent on your game, however this would typically be some sort of teardown process.
		// You might want to deactivate unnecessary NPCs, log to a file, or perform any other cleanup actions.
	}
	
	/// <summary>
	/// Handler for receiving the error multiplay server event.
	/// </summary>
	/// <param name="error">The error received from the event.</param>
	private void OnError(MultiplayError error)
	{
		// Here is where you handle the error.
		// This is highly dependent on your game. You can inspect the error by accessing the error.Reason and error.Detail fields.
		// You can change on the error.Reason field, log the error, or otherwise handle it as you need to.
	}
	
	/// <summary>
	/// 
	/// </summary>
	/// <param name="state"></param>
	private void OnSubscriptionStateChanged(MultiplayServerSubscriptionState state)
	{
		switch (state)
		{
			case MultiplayServerSubscriptionState.Unsubscribed: /* The Server Events subscription has been unsubscribed from. */ break;
			case MultiplayServerSubscriptionState.Synced: /* The Server Events subscription is up to date and active. */ break;
			case MultiplayServerSubscriptionState.Unsynced: /* The Server Events subscription has fallen out of sync, the subscription tries to automatically recover. */ break;
			case MultiplayServerSubscriptionState.Error: /* The Server Events subscription has fallen into an errored state and won't recover automatically. */ break;
			case MultiplayServerSubscriptionState.Subscribing: /* The Server Events subscription is trying to sync. */ break;
		}
	}
}

public event Action<MultiplayAllocation> Allocate;

public event Action<MultiplayDeallocation> Deallocate;

public event Action<MultiplayError> Error;

public event Action<MultiplayServerSubscriptionState> SubscriptionStateChanged;