public static void Disconnect()
{
myClient.Disconnect();
CleanUpClient();
NetworkServer.Shutdown();
SceneManager.LoadScene(offlineSceneName);
}
// Update is called once per frame
void Update()
{
Quaternion rawRotation = Input.gyro.attitude;
batonTrans.rotation = rawRotation;
batonTrans.Rotate(90, 0, 0, Space.World);
batonTrans.Rotate(0, -deltaAngle, 0, Space.World);
batonTrans.position = new Vector3(0, 0, 0);
batonTrans.Translate(new Vector3(0, -batonTrans.localScale.y, 0), Space.Self);
if (client.isConnected)
{
if (networkState == NetworkState.Connecting)
{
Debug.Log("Connected");
networkState = NetworkState.Connected;
client.SetMaxDelay(0);
}
UserMessage msg = new UserMessage();
msg.orientation = batonTrans.rotation;
msg.profile = Setting.a.name;
client.Send(64, msg);
Debug.Log("Sending");
}
else if (networkState == NetworkState.Connected)
{
Debug.Log("Disconnected, trying to reconnect...");
client.Disconnect();
Connect();
}
}
private void OnDestroy()
{
if (myClient != null && myClient.isConnected)
{
myClient.Disconnect();
}
}
void Server_ClientConnected(object sender, ServerClientEventArgs e)
{
Logger.Log.Info(Language.Instance.GetMessageFromKey("NEW_CONNECT") + e.Client.ClientId);
NetworkClient customClient = e.Client as NetworkClient;
if (!CheckConnectionLog(customClient))
{
Logger.Log.WarnFormat(Language.Instance.GetMessageFromKey("FORCED_DISCONNECT"), customClient.ClientId);
customClient.Disconnect();
return;
}
ClientSession session = new ClientSession(customClient);
session.Initialize(_encryptor, _packetHandler);
ClientLinkManager.Instance.sessions.Add(session);
if (!_sessions.TryAdd(customClient.ClientId, session))
{
ClientLinkManager.Instance.sessions.Remove(session);
Logger.Log.WarnFormat(Language.Instance.GetMessageFromKey("FORCED_DISCONNECT"), customClient.ClientId);
customClient.Disconnect();
_sessions.TryRemove(customClient.ClientId, out session);
return;
}
;
}
private void Server_ClientConnected(object sender, ServerClientEventArgs e)
{
Logger.Log.Info(Language.Instance.GetMessageFromKey("NEW_CONNECT") + e.Client.ClientId);
NetworkClient customClient = e.Client as NetworkClient;
if (!CheckGeneralLog(customClient))
{
Logger.Log.WarnFormat(Language.Instance.GetMessageFromKey("FORCED_DISCONNECT"), customClient.ClientId);
customClient.Initialize(_fallbackEncryptor);
customClient.SendPacket($"fail {Language.Instance.GetMessageFromKey("CONNECTION_LOST")}");
customClient.Disconnect();
customClient = null;
return;
}
ClientSession session = new ClientSession(customClient);
session.Initialize(_encryptor, _packetHandler);
if (IsWorldServer)
{
ServerManager.Instance.RegisterSession(session);
if (!_sessions.TryAdd(customClient.ClientId, session))
{
Logger.Log.WarnFormat(Language.Instance.GetMessageFromKey("FORCED_DISCONNECT"), customClient.ClientId);
customClient.Disconnect();
_sessions.TryRemove(customClient.ClientId, out session);
ServerManager.Instance.UnregisterSession(session);
return;
}
;
}
}
//отключение от сервера и вывод на экран сообщения
public void DisconnectClick()
{
client.Disconnect();
MessageLog.text = "Disconnected from " + ip;
ButtonDisconnect.interactable = false;
ButtonConnect.interactable = true;
}
private void UpdateLoadingState()
{
// Wait until we got level info
if (m_LevelName == null)
{
return;
}
// Load if we are not already loading
var level = Game.Instance.levelManager.currentLevel;
if (level == null || level.name != m_LevelName)
{
if (!Game.Instance.levelManager.LoadLevel(m_LevelName))
{
_networkClient.Disconnect();
return;
}
level = Game.Instance.levelManager.currentLevel;
}
// Wait for level to be loaded
if (level.state == LevelState.Loaded)
{
_stateMachine.SwitchTo(ClientState.Playing);
}
}
public void Connect()
{
if (connected)
{
client.Disconnect();
}
ResetStatus();
client.Connect(serverIP, port);
}
public void LocalClientActiveTest()
{
Assert.That(server.LocalClientActive, Is.False);
client.ConnectHost(server);
Assert.That(server.LocalClientActive, Is.True);
client.Disconnect();
}
public void Start()
{
if (_nc != null)
{
_nc.Disconnect();
_nc = null;
}
_nc = new NetworkClient();
_nc.RegisterHandler(new StartGameMsg().id, OnStartGame);
_nc.RegisterHandler(new NewTurnMsg().id, OnServerTurn);
_nc.RegisterHandler(new StopGameMsg().id, OnStopGame);
_nc.Connect("localhost", Constants.PORT);
}
public static bool Connect(String hostname, int port)
{
if (_client == null)
{
_client = new NetworkClient();
}
if (_client.IsConnected())
{
_client.Disconnect();
}
return(_client.Connect(hostname, port));
}
private void net_onAskEnterWorldResponse(NetworkMessage netMsg)
{
S2GC_EnterWorldResponse Message = netMsg.ReadMessage <S2GC_EnterWorldResponse>();
if (Message.errorCode == -1)
{
e.getScene().scene_LoadLevel("World_Client");
}
else
{
Client.Disconnect();
e.getUI().ui_login_Disconnected("Something went wrong...");
}
}
void ReceiveServerPlayerConnected(NetworkMessage message)
{
StringMessage msg = message.ReadMessage <StringMessage>();
string[] deltas = msg.value.Split('|');
if (deltas[0].Equals("NotAllowed"))
{
client.Disconnect();
GameManagerMobile.Instance.ResetVariable();
GameManagerMobile.Instance.playerNumber = -1;
// Debug.LogError("Can't connect server not allowed");
}
else if (deltas[0].Equals("Allowed"))
{
GameManagerMobile.Instance.playerInfo.playerId = int.Parse(deltas[1]);
GameManagerMobile.Instance.playerInfo.connectionChannel = message.conn.connectionId;
GameManagerMobile.Instance.playerNumber = int.Parse(deltas[2]);
SendPlayerInfo();
if (GameManagerMobile.Instance.state == GameManagerMobile.GameState.Controller ||
GameManagerMobile.Instance.state == GameManagerMobile.GameState.TutorialController)
{
GameManagerMobile.Instance.BackToMeu();
}
else
{
GameManagerMobile.Instance.ConnectedSuccessfull();
}
}
else if (deltas[0].Equals("G"))
{
if (GameManagerMobile.Instance.playerInfo.playerId < 0 || !GameManagerMobile.Instance.gameSession.Equals(deltas[1]))
{
client.Disconnect();
GameManagerMobile.Instance.ResetVariable();
GameManagerMobile.Instance.playerNumber = -1;
//Debug.LogError("Game Still Playing, You can't interrupt them");
}
else
{
//Debug.Log("You reconnect to server");
SendPlayerInfo();
GameManagerMobile.Instance.ConnectedSuccessfull();
}
}
}
private void OnError(NetworkMessage msg)
{
Debug.LogError("Encountered a network error. Shutting down.");
Term.Println("Encountered a network error. Shutting down.");
NetClient.Disconnect();
Running = false;
}
public bool DoStep(NetworkClient networkClient, GameClient client)
{
//Get game servers list
List<object> gameServersList = client.AdditionalData[ObjectPropertyName.GAME_SERVER];
//If servers list is available
if (gameServersList != null)
{
//Connect to the game server
while (gameServersList.Count > 0)
{
//Pop a first game server in the list
string server = (string) gameServersList[0];
gameServersList.Remove(server);
//Out log message
networkClient.OutLogMessage(string.Format("Connecting to the game server: {0}...", server));
//Try to connect
bool isConnected = networkClient.ConnectToGameServer(server);
if (isConnected)
{
if (networkClient.DoAuthorization())
{
return true;
}
}
}
}
//Connection failed
networkClient.Disconnect();
return false;
}
private static void OnMatchFound(GameServerInfo match, PlayerManagerClient pm)
{
print("match found " + match.ip + " " + match.port);
NetworkClient gameClient = new NetworkClient();
gameClient.RegisterHandler(MsgType.Connect, x =>
{
print("connected to gameServer");
gameClient.RegisterHandler((short)CustomMessageTypes.ApprovalResponse, netMsg =>
{
IntegerMessage msg = netMsg.ReadMessage <IntegerMessage>();
bool isApproved = msg.value == 1;
print("approval status " + isApproved);
if (!isApproved)
{
gameClient.Disconnect();
}
else
{
//Start playing ,
//Teel server i'm ready and addPlayerRequest if needed
//ClientScene.AddPlayer()
// or
//ClientScene.Ready();
}
});
gameClient.Send((short)CustomMessageTypes.RequestPlayerApproval, new IntegerMessage(pm.myInfo.gameServerID));
});
gameClient.Connect(match.ip, match.port);
}
public void HandleLoginRequest(string username)
{
// "Login request" message already received
if (_username != null)
{
return;
}
if (!GameAdapters.IsSupported(NetworkClient.Version.Protocol))
{
NetworkClient.Disconnect(new TextComponentString("Unsupported version " + NetworkClient.Version.Protocol)
{
Color = TextColor.Red
});
return;
}
_username = username;
using (var rngProvider = new RNGCryptoServiceProvider())
{
_signature = new byte[4];
rngProvider.GetBytes(_signature);
}
NetworkClient.Send(new MessageClientEncryptionRequest.Message(
string.Empty,
Cryptography.PublicKey,
_signature
));
}
public IEnumerator UnityTearDown() => UniTask.ToCoroutine(async() =>
{
// check active, it might have been stopped by tests
if (client.Active)
{
client.Disconnect();
}
if (server.Active)
{
server.Stop();
}
await AsyncUtil.WaitUntilWithTimeout(() => !client.Active);
await AsyncUtil.WaitUntilWithTimeout(() => !server.Active);
Object.DestroyImmediate(playerPrefab);
Object.DestroyImmediate(serverGo);
Object.DestroyImmediate(clientGo);
Object.DestroyImmediate(serverPlayerGO);
Object.DestroyImmediate(clientPlayerGO);
TearDownTestObjects();
ExtraTearDown();
await ExtraTearDownAsync();
Console.WriteLine($"[MirageTest] UnityTearDown class:{TestContext.CurrentContext.Test.ClassName} method:{TestContext.CurrentContext.Test.MethodName}");
});
public IEnumerator ShutdownHost() => UniTask.ToCoroutine(async() =>
{
// check active, it might have been stopped by tests
if (client.Active)
{
client.Disconnect();
}
if (server.Active)
{
server.Stop();
}
await AsyncUtil.WaitUntilWithTimeout(() => !client.Active);
await AsyncUtil.WaitUntilWithTimeout(() => !server.Active);
Object.DestroyImmediate(playerPrefab);
Object.DestroyImmediate(serverGo);
Object.DestroyImmediate(clientGo);
Object.DestroyImmediate(serverPlayerGO);
Object.DestroyImmediate(clientPlayerGO);
foreach (GameObject obj in toDestroy)
{
if (obj != null)
{
Object.DestroyImmediate(obj);
}
}
ExtraTearDown();
});
public void Disconnect()
{
if (netClient != null)
{
netClient.Disconnect(false);
}
}
protected override IEnumerator Init()
{
NetworkClient nc = CustomNetworkManager.AddPlayer();
if (nc != null)
{
TerrainController tc = GameObject.FindObjectOfType <TerrainController>();
if (tc != null)
{
yield return(tc.GenerateTerrain(LoadingPanel.OnProgress));
}
tc.CreateLight();
if (Parent != null)
{
Parent.Activate <GameState_Play>();
}
}
else
{
nc.Disconnect();
CustomNetworkManager.Stop();
Deactivate <GameState_AddPlayer>();
}
yield return(base.Init());
}
public void Exiting()
{
if (connection.IsConnected())
{
connection.Disconnect();
}
}
protected static void MyExitHandler(object sender, ConsoleCancelEventArgs args)
{
Console.WriteLine("MyExitHandler");
nc.Disconnect();
//args.Cancel = true;
}
private void DestroyClient()
{
client.UnregisterHandler(MsgType.Connect);
client.UnregisterHandler(MsgType.Disconnect);
client.UnregisterHandler(MsgType.Error);
client.UnregisterHandler(ScopeMsgType.EnterScope);
client.UnregisterHandler(ScopeMsgType.ExitScope);
client.UnregisterHandler(ScopeMsgType.SwitchScope);
client.UnregisterHandler(ScopeMsgType.DisconnectMessage);
client.UnregisterHandler(ScopeMsgType.RedirectMessage);
client.Disconnect();
client.Shutdown();
client = null;
}
void OnApplicationQuit()
{
if (nc != null && nc.isConnected)
{
nc.Disconnect();
}
}
public void TearDown()
{
// stop server/client
NetworkClient.DisconnectLocalServer();
NetworkClient.Disconnect();
NetworkClient.Shutdown();
NetworkServer.Shutdown();
// destroy left over objects
foreach (GameObject item in spawned)
{
if (item != null)
{
GameObject.DestroyImmediate(item);
}
}
spawned.Clear();
NetworkIdentity.spawned.Clear();
GameObject.DestroyImmediate(Transport.activeTransport.gameObject);
}
//Login & Classeviva Stuff
void OnSceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
{
if (scene.name == "Main" && nc.isConnected)
{
nc.Disconnect();
}
}
private static void MyExitHandler(object sender, ConsoleCancelEventArgs args)
{
Console.WriteLine("ScenCon exiting...");
c.Disconnect();
//args.Cancel = true;
}
/// <summary>Finish the disconnect process and clean everything up</summary>
private void CancelConnection()
{
NetworkClient.Disconnect();
InvokeHandler(new DisconnectMessage(), 0);
isConnecting = false;
}
private void OnGUI()
{
if (!NetworkServer.active && !NetworkClient.active)
{
if (GUILayout.Button("Host Game"))
{
SetupServer();
}
if (GUILayout.Button("Start Client"))
{
SetupClient();
}
if (GUILayout.Button("Host & Launch Client"))
{
SetupServer();
SetupLocalClient();
}
}
if (NetworkClient.active)
{
if (GUILayout.Button("Disconnect"))
{
myClient.Disconnect();
}
}
}
private void OnServerShutdown(ShutdownMessage msg)
{
_messageWindow.Title.text = "Shutdown In Progress";
_messageWindow.Message.text = "Server has issued a shutdown.";
_messageWindow.gameObject.SetActive(true);
NetworkClient.Disconnect();
}
public static void OnInvalidVersionResponse(ref NetworkClient Client, ProcessedPacket Packet)
{
Client.Disconnect();
}
/// <summary>
/// Reconnects to a CityServer.
/// </summary>
public void Reconnect(ref NetworkClient Client, CityInfo SelectedCity, LoginArgsContainer LoginArgs)
{
Client.Disconnect();
if (LoginArgs.Enc == null)
{
Debug.WriteLine("LoginArgs.Enc was null!");
LoginArgs.Enc = new GonzoNet.Encryption.AESEncryptor(Convert.ToBase64String(PlayerAccount.Hash));
}
else if (LoginArgs.Username == null || LoginArgs.Password == null)
{
Debug.WriteLine("LoginArgs.Username or LoginArgs.Password was null!");
LoginArgs.Username = PlayerAccount.Username;
LoginArgs.Password = Convert.ToBase64String(PlayerAccount.Hash);
}
Client.Connect(LoginArgs);
}
/// <summary>
/// Reconnects to a CityServer.
/// </summary>
public void Reconnect(ref NetworkClient Client, CityInfo SelectedCity, LoginArgsContainer LoginArgs)
{
Client.Disconnect();
Client.Connect(LoginArgs);
}
/// <summary>
/// Occurs when the client was not authenticated by the loginserver.
/// Called by UILoginDialog.cs.
/// </summary>
/// <param name="Client">The client that received the packet.</param>
/// <param name="Packet">The packet that was received.</param>
/// <param name="Screen">A UIScreen instance on which to display a messagebox to inform the player of the
/// failure state.</param>
public static void OnLoginFailResponse(ref NetworkClient Client, ProcessedPacket Packet)
{
EventObject Event;
switch (Packet.ReadByte())
{
case 0x01:
Event = new EventObject(EventCodes.BAD_USERNAME);
EventSink.RegisterEvent(Event);
break;
case 0x02:
Event = new EventObject(EventCodes.BAD_PASSWORD);
EventSink.RegisterEvent(Event);
break;
}
Client.Disconnect();
}
