/// <summary>
/// Connect to your EdgeMultiplay server based on location and carrier info
/// <para>
/// use <b>public override void OnConnectionToEdge()</b> to get the server response
/// </para>
/// </summary>
/// <param name="useAnyCarrierNetwork"> set to true for connection based on location info only </param>
/// <param name="useFallBackLocation"> set to true to use overloaded location sat in setFallbackLocation()</param>
/// <param name="path"> You can specify a path for your connection to be verified on the server side </param>
/// <returns> Connection Task, use OnConnectionToEdge() to listen to the async task result </returns>
public async Task ConnectToServer(bool useAnyCarrierNetwork = true, bool useFallBackLocation = false, string path = "")
{
if (useLocalHostServer)
{
try
{
gameSession = new Session();
wsClient = new MobiledgeXWebSocketClient();
Uri uri = new Uri("ws://" + hostIPAddress + ":" + defaultEdgeMultiplayServerTCPPort + path);
if (wsClient.isOpen())
{
wsClient.Dispose();
wsClient = new MobiledgeXWebSocketClient();
}
await wsClient.Connect(@uri);
EdgeMultiplayCallbacks.connectedToEdge();
}
catch (Exception e)
{
EdgeMultiplayCallbacks.failureToConnect(e.Message);
Debug.LogError("EdgeMultiplay: Failed to connect to your Local Host, Check console for more details");
}
}
else
{
try
{
gameSession = new Session();
integration.UseWifiOnly(useAnyCarrierNetwork);
integration.useFallbackLocation = useFallBackLocation;
wsClient = new MobiledgeXWebSocketClient();
await integration.RegisterAndFindCloudlet();
integration.GetAppPort(LProto.L_PROTO_TCP);
string url = integration.GetUrl("ws") + path;
Uri uri = new Uri(url);
if (wsClient.isOpen())
{
wsClient.Dispose();
wsClient = new MobiledgeXWebSocketClient();
}
await wsClient.Connect(@uri);
EdgeMultiplayCallbacks.connectedToEdge();
}
catch (Exception e)
{
EdgeMultiplayCallbacks.failureToConnect(e.Message);
Debug.LogError("EdgeMultiplay: Failed to connect to Edge, Check console for more details");
}
}
}
void CreateObserverableObject(GamePlayEvent newObserverableEvent)
{
if (localPlayer.playerId == newObserverableEvent.stringData[0])
{
return;
}
NetworkedPlayer playerCreatedObserver = GetPlayer(newObserverableEvent.stringData[0]);
Observable observerable = playerCreatedObserver.CreateObservableObject(
prefabName: newObserverableEvent.stringData[1],
startPosition: Util.ConvertFloatArrayToVector3(newObserverableEvent.floatData, 0),
startRotation: Quaternion.Euler(Util.ConvertFloatArrayToVector3(newObserverableEvent.floatData, 3)),
syncOption: (SyncOptions)Enum.ToObject(typeof(SyncOptions), newObserverableEvent.integerData[0]),
interpolatePosition: newObserverableEvent.booleanData[0],
interpolateRotation: newObserverableEvent.booleanData[1],
interpolationFactor: newObserverableEvent.floatData[6]);
EdgeMultiplayCallbacks.newObservableCreated(observerable);
}
void HandleUDPMessage(string message)
{
GamePlayEvent gamePlayEvent = JsonUtility.FromJson <GamePlayEvent>(message);
switch (gamePlayEvent.type)
{
case "GamePlayEvent":
if (gamePlayEvent.eventName == "EdgeMultiplayObserver")
{
SyncObject(gamePlayEvent);
}
else
{
// if used for other than that Syncing GameObjects Position & Rotation
// it wil trigger OnUDPMessagesReceived()
EdgeMultiplayCallbacks.udpEventReceived(gamePlayEvent);
}
break;
default:
Debug.LogError("Unknown UDP message arrived: " + message);
break;
}
}
void ReflectEvent(GamePlayEvent receivedEvent)
{
EdgeMultiplayCallbacks.eventReceived(receivedEvent);
}
void HandleWebSocketMessage(string message)
{
var msg = MessageWrapper.UnWrapMessage(message);
switch (msg.type)
{
case "register":
Register register = Messaging <Register> .Deserialize(message);
gameSession.sessionId = register.sessionId;
gameSession.playerId = register.playerId;
EdgeMultiplayCallbacks.registerEvent();
break;
case "notification":
Notification notification = Messaging <Notification> .Deserialize(message);
switch (notification.notificationText)
{
case "left-room":
gameSession.roomId = "";
EdgeMultiplayCallbacks.leftRoom();
break;
case "join-room-faliure":
EdgeMultiplayCallbacks.joinRoomFaliure();
break;
case "new-room-created-in-lobby":
EdgeMultiplayCallbacks.newRoomCreatedInLobby();
break;
}
EdgeMultiplayCallbacks.notificationEvent(notification);
break;
case "roomsList":
RoomsList roomsList = Messaging <RoomsList> .Deserialize(message);
EdgeMultiplayCallbacks.roomsList(roomsList.rooms);
break;
case "roomCreated":
RoomCreated roomCreated = Messaging <RoomCreated> .Deserialize(message);
gameSession.roomId = roomCreated.room.roomId;
EdgeMultiplayCallbacks.roomCreated(roomCreated.room);
break;
case "roomJoin":
RoomJoin roomJoin = Messaging <RoomJoin> .Deserialize(message);
gameSession.roomId = roomJoin.room.roomId;
EdgeMultiplayCallbacks.roomJoin(roomJoin.room);
break;
case "playerJoinedRoom":
PlayerJoinedRoom playerJoinedRoom = Messaging <PlayerJoinedRoom> .Deserialize(message);
EdgeMultiplayCallbacks.playerRoomJoined(playerJoinedRoom.room);
break;
case "gameStart":
GameStart gameStart = Messaging <GameStart> .Deserialize(message);
gameSession.currentPlayers = gameStart.room.roomMembers.ToArray();
foreach (Player player in gameStart.room.roomMembers)
{
if (player.playerId == gameSession.playerId)
{
gameSession.playerIndex = player.playerIndex;
}
}
CreatePlayers(gameSession.currentPlayers);
gameStarted = true;
EdgeMultiplayCallbacks.gameStart();
if (useLocalHostServer)
{
udpClient = new MobiledgeXUDPClient(hostIPAddress, defaultEdgeMultiplayServerUDPPort);
}
else
{
udpClient = new MobiledgeXUDPClient(integration.GetHost(), integration.GetAppPort(LProto.L_PROTO_UDP).public_port);
}
SendUDPMessage(new GamePlayEvent()
{
eventName = "Start"
});
break;
case "GamePlayEvent":
GamePlayEvent gamePlayEvent = Messaging <GamePlayEvent> .Deserialize(message);
switch (gamePlayEvent.eventName)
{
case "NewObservableCreated":
CreateObserverableObject(gamePlayEvent);
break;
case "ObservableOwnershipChange":
UpdateObserverOwnership(gamePlayEvent);
break;
default:
ReflectEvent(gamePlayEvent);
break;
}
break;
case "memberLeft":
RoomMemberLeft playerLeft = Messaging <RoomMemberLeft> .Deserialize(message);
EdgeMultiplayCallbacks.playerLeft(playerLeft);
break;
default:
Debug.LogError("Unknown WebSocket message arrived: " + msg.type + ", message: " + message);
break;
}
}
