// An opcode defined by client and your server script that represents a custom message type
/// Initialize a client for GameLift Realtime and connect to a player session.
/// <param name="endpoint">The DNS name that is assigned to Realtime server</param>
/// <param name="remoteTcpPort">A TCP port for the Realtime server</param>
/// <param name="listeningUdpPort">A local port for listening to UDP traffic</param>
/// <param name="connectionType">Type of connection to establish between client and the Realtime server</param>
/// <param name="playerSessionId">The player session ID that is assigned to the game client for a game session </param>
/// <param name="connectionPayload">Developer-defined data to be used during client connection, such as for player authentication</param>
public RealTimeClient(string endpoint, int remoteTcpPort, int listeningUdpPort, ConnectionType connectionType,
string playerSessionId, byte[] connectionPayload)
{
// Create a client configuration to specify a secure or unsecure connection type
// Best practice is to set up a secure connection using the connection type RT_OVER_WSS_DTLS_TLS12.
ClientConfiguration clientConfiguration = new ClientConfiguration()
{
// C# notation to set the field ConnectionType in the new instance of ClientConfiguration
ConnectionType = connectionType
};
// Create a Realtime client with the client configuration
Client = new Client(clientConfiguration);
// Initialize event handlers for the Realtime client
Client.ConnectionOpen += OnOpenEvent;
Client.ConnectionClose += OnCloseEvent;
Client.GroupMembershipUpdated += OnGroupMembershipUpdate;
Client.DataReceived += OnDataReceived;
// Create a connection token to authenticate the client with the Realtime server
// Player session IDs can be retrieved using AWS SDK for GameLift
ConnectionToken connectionToken = new ConnectionToken(playerSessionId, connectionPayload);
// Initiate a connection with the Realtime server with the given connection information
ConnectionStatus res = Client.Connect(endpoint, remoteTcpPort, listeningUdpPort, connectionToken);
}
public void Connect(string endpoint, int remoteTcpPort, int listeningUdpPort, ConnectionType connectionType,
string playerSessionId, byte[] connectionPayload)
{
ConnectionToken connectionToken = new ConnectionToken(playerSessionId, connectionPayload);
Client.Connect(endpoint, remoteTcpPort, listeningUdpPort, connectionToken);
}
private static IConnectionProvider LoadProviderByConnectionToken(ConnectionToken token)
{
IConnectionProvider provider;
if (TryLoadAssemblyUsingAttribute(token.ConnectionString, token.ProviderName, out provider))
{
return(provider);
}
provider = ComposeProvider(token.ProviderName);
if (provider == null)
{
throw new InvalidOperationException(string.Format("Provider '{0}' could not be resolved.", token.ProviderName));
}
provider.SetConnectionString(token.ConnectionString);
var schemaConnectionProvider = provider as ISchemaConnectionProvider;
if (schemaConnectionProvider != null)
{
schemaConnectionProvider.SetSchema(token.SchemaName);
}
return(provider);
}
/// Initialize a client for GameLift Realtime and connect to a player session.
/// <param name="endpoint">The DNS name that is assigned to Realtime server</param>
/// <param name="remoteTcpPort">A TCP port for the Realtime server</param>
/// <param name="listeningUdpPort">A local port for listening to UDP traffic</param>
/// <param name="connectionType">Type of connection to establish between client and the Realtime server</param>
/// <param name="playerSessionId">The player session ID that is assigned to the game client for a game session </param>
/// <param name="connectionPayload">Developer-defined data to be used during client connection, such as for player authentication</param>
public RealTimeClient(string endpoint, int remoteTcpPort, int listeningUdpPort, ConnectionType connectionType,
string playerSessionId, byte[] connectionPayload)
{
// Create a client configuration to specify a secure or unsecure connection type
// Best practice is to set up a secure connection using the connection type RT_OVER_WSS_DTLS_TLS12.
ClientConfiguration clientConfiguration = new ClientConfiguration()
{
// C# notation to set the field ConnectionType in the new instance of ClientConfiguration
ConnectionType = connectionType
};
// Create a Realtime client with the client configuration
Client = new Client(clientConfiguration);
// Initialize event handlers for the Realtime client
Client.ConnectionOpen += new EventHandler(OnOpenEvent);
Client.ConnectionClose += new EventHandler(OnCloseEvent);
Client.DataReceived += new EventHandler <DataReceivedEventArgs>(OnDataReceived);
Client.ConnectionError += new EventHandler <Aws.GameLift.Realtime.Event.ErrorEventArgs>(OnConnectionErrorEvent);
// Create a connection token to authenticate the client with the Realtime server
// Player session IDs can be retrieved using AWS SDK for GameLift
ConnectionToken connectionToken = new ConnectionToken(playerSessionId, connectionPayload);
// Initiate a connection with the Realtime server with the given connection information
Client.Connect(endpoint, remoteTcpPort, listeningUdpPort, connectionToken);
activateListeners();
Debug.Log("RTC instantiated");
}
private static IConnectionProvider LoadProviderByFilename(ConnectionToken token)
{
string extension = GetFileExtension(token.ConnectionString);
var provider = ComposeProvider(extension);
provider.SetConnectionString(string.Format("data source={0}", token.ConnectionString));
return(provider);
}
private static IConnectionProvider LoadProviderByConnectionToken(ConnectionToken token)
{
var provider = ComposeProvider(token.ProviderName);
if (provider == null)
{
throw new InvalidOperationException("Provider could not be resolved.");
}
provider.SetConnectionString(token.ConnectionString);
return(provider);
}
private IConnectionProvider LoadProviderByConnectionString(ConnectionToken token)
{
var dataSource = GetDataSourceName(token.ConnectionString);
if (dataSource.EndsWith("sdf", StringComparison.CurrentCultureIgnoreCase) && File.Exists(dataSource))
{
return(GetProviderByFilename(dataSource));
}
var provider = ComposeProvider();
provider.SetConnectionString(token.ConnectionString);
return(provider);
}
public byte[] Serialize()
{
using (var m = new MemoryStream()) {
using (var writer = new BinaryWriter(m)) {
writer.Write(Type);
writer.Write((byte)_mode);
if (Type != (short)MessageType.Empty && Type != (short)MessageType.Handshake)
{
writer.Write(ConnectionToken.Serialize());
}
writer.Write(MessageId.ToShort());
}
return(m.ToArray());
}
}
/// <summary>
/// Enables synchronization of the object with the
/// client specified by <paramref name="connectionId"/>.
/// </summary>
/// <param name="connectionId">Connection ID</param>
/// <param name="key">The key that is used to access the object</param>
internal void AddConnection(string connectionId, string key)
{
lock (_lock)
{
if (_connections.Any(t => t.Id == connectionId))
{
return;
}
var token = new ConnectionToken(connectionId, key);
_connections.Add(token);
}
// Push the object to the new client
_syncHub.Clients.Client(connectionId).InitializeObject(key, Object);
}
private static IConnectionProvider LoadProviderByConnectionToken(ConnectionToken token)
{
IConnectionProvider provider;
if (TryLoadAssemblyUsingAttribute(token.ConnectionString, token.ProviderName, out provider))
{
return(provider);
}
provider = ComposeProvider(token.ProviderName);
if (provider == null)
{
throw new InvalidOperationException("Provider could not be resolved.");
}
provider.SetConnectionString(token.ConnectionString);
return(provider);
}
private void RealtimeClientConnect(string endpoint, int remoteTcpPort, int listeningUdpPort, ConnectionType connectionType,
string playerSessionId, byte[] connectionPayload)
{
ClientLogger.LogHandler = (x) => GD.Print(x);
// Create a client configuration to specify a secure or unsecure connection type
// Best practice is to set up a secure connection using the connection type RT_OVER_WSS_DTLS_TLS12.
ClientConfiguration clientConfiguration = new ClientConfiguration()
{
// C# notation to set the field ConnectionType in the new instance of ClientConfiguration
ConnectionType = connectionType
};
realtimeClient = new Aws.GameLift.Realtime.Client(clientConfiguration);
realtimeClient.DataReceived += OnDataReceived;
ConnectionToken connectionToken = new ConnectionToken(playerSessionId, connectionPayload);
realtimeClient.Connect(endpoint, remoteTcpPort, listeningUdpPort, connectionToken);
}
private IEnumerator ConnectToServer(string ipAddr, int port, string tokenUID)
{
ClientLogger.LogHandler = (x) => Debug.Log(x);
ConnectionToken token = new ConnectionToken(tokenUID, null);
ClientConfiguration clientConfiguration;
if (!usingTLS)
{
clientConfiguration = new ClientConfiguration
{
ConnectionType = ConnectionType.RT_OVER_WS_UDP_UNSECURED
}
}
;
else
{
clientConfiguration = new ClientConfiguration
{
ConnectionType = ConnectionType.RT_OVER_WSS_DTLS_TLS12
}
};
_client = new Aws.GameLift.Realtime.Client(clientConfiguration);
_client.DataReceived += OnDataReceived;
int ListenPort = 8921;
clientManager.MessageReceived($"[client] TLS: {usingTLS} with Port: {ListenPort}");
_client.Connect(ipAddr, port, ListenPort, token);
while (true)
{
if (_client.ConnectedAndReady)
{
clientManager.MessageReceived("[client] Connected to server");
break;
}
yield return(null);
}
}
// common code whether we are connecting to a GameLift hosted server or
// a local server
private IEnumerator ConnectToServer(string ipAddr, int port, string tokenUID)
{
ClientLogger.LogHandler = (x) => Debug.Log(x);
ConnectionToken token = new ConnectionToken(tokenUID, null);
ClientConfiguration clientConfiguration = ClientConfiguration.Default();
_client = new Aws.GameLift.Realtime.Client(clientConfiguration);
_client.ConnectionOpen += new EventHandler(OnOpenEvent);
_client.ConnectionClose += new EventHandler(OnCloseEvent);
_client.DataReceived += new EventHandler <DataReceivedEventArgs>(OnDataReceived);
_client.ConnectionError += new EventHandler <Aws.GameLift.Realtime.Event.ErrorEventArgs>(OnConnectionErrorEvent);
int UDPListenPort = FindAvailableUDPPort(DEFAULT_UDP_PORT, DEFAULT_UDP_PORT + 20);
if (UDPListenPort == -1)
{
Debug.Log("Unable to find an open UDP listen port");
yield break;
}
else
{
Debug.Log($"UDP listening on port: {UDPListenPort}");
}
Debug.Log($"[client] Attempting to connect to server ip: {ipAddr} TCP port: {port} Player Session ID: {tokenUID}");
_client.Connect(string.IsNullOrEmpty(ipAddr) ? DEFAULT_ENDPOINT : ipAddr, port, UDPListenPort, token);
while (true)
{
if (_client.ConnectedAndReady)
{
IsConnectedToServer = true;
Debug.Log("[client] Connected to server");
break;
}
yield return(null);
}
}
public IConnectionProvider GetProviderByFilename(string filename)
{
var token = new ConnectionToken(filename, "System.Data.SqlCeClient");
return(_connectionProviderCache.GetOrAdd(token, LoadProviderByFilename));
}
public IConnectionProvider GetProviderByConnectionString(string connectionString)
{
var token = new ConnectionToken(connectionString, string.Empty);
return(_connectionProviderCache.GetOrAdd(token, LoadProviderByConnectionString));
}
private bool RemoveConnection(ConnectionToken connection)
{
_syncHub.Clients.Client(connection.Id).RemoveObject(connection.ObjectKey);
return(_connections.Remove(connection));
}
