public virtual void Stop()
{
IsRunning = false;
_cancellationToken.Cancel();
NetworkTimer.Stop();
NetManager.Stop();
}
public void DisconnectNetworkHost()
{
if (server != null)
{
server.Stop();
}
}
public void StopClient()
{
netClient.Stop();
Destroy(gameObject);
started = false;
}
public void Close()
{
_peer.Stop();
_peer.DisconnectAll();
_serverPeer?.Disconnect();
_endPointReceivers.Clear();
}
void OnDestroy()
{
Console.WriteLine("Gracefully killing client");
StopAllCoroutines();
client.DisconnectAll();
client.Stop();
}
public void Stop()
{
_server.Stop();
_unknownPlayers.Clear();
Players.Clear();
Logger.WriteLine("Stop server of port {0}", Port);
}
public void Stop()
{
if (client != null)
{
client.Close();
client.State = ConnectionStateEnum.Disconnected;
}
if (localServer != null)
{
localServer.running = false;
serverThread.Join();
}
if (netClient != null)
netClient.Stop();
if (arbiter != null)
{
arbiter.TryKill();
arbiter = null;
}
Log.Message("Multiplayer session stopped.");
}
private void MainLoop(NetManager client, NetPeer peer)
{
var writer = new NetDataWriter();
Task.Run(() =>
{
while (_isRunning)
{
// var input = ReadLine.Read(">> ");
// if (string.IsNullOrWhiteSpace(input))
// {
// continue;
// }
//
// if (input.Trim(new[] {' '}) == "/ping")
// {
// Console.WriteLine($"<ping: {peer.Ping}ms>");
// continue;
// }
writer.Reset();
writer.Put(DateTime.Now.ToString(CultureInfo.CurrentCulture));
peer.Send(writer, DeliveryMethod.Unreliable);
Thread.Sleep(33);
}
});
while (_isRunning)
{
client.PollEvents();
Thread.Sleep(15);
}
client.Stop();
}
public void Server()
{
EventBasedNetListener listener = new EventBasedNetListener();
NetManager server = new NetManager(listener);
server.Start(9050 /* port */);
listener.ConnectionRequestEvent += request =>
{
if (server.ConnectedPeersCount < 10 /* max connections */)
{
request.AcceptIfKey("SomeConnectionKey");
}
else
{
request.Reject();
}
};
listener.PeerConnectedEvent += peer =>
{
Console.WriteLine("We got connection: {0}", peer.EndPoint); // Show peer ip
NetDataWriter writer = new NetDataWriter(); // Create writer class
writer.Put("Hello client!"); // Put some string
peer.Send(writer, DeliveryMethod.ReliableOrdered); // Send with reliability
};
while (!Console.KeyAvailable)
{
server.PollEvents();
Thread.Sleep(15);
}
server.Stop();
}
public SpeedDateClient()
{
_handlers = new Dictionary <ushort, IPacketHandler>();
_kernel = new SpeedDateKernel();
_listener = new SpeedDateNetListener();
_listener.NetworkErrorEvent += (point, code) =>
{
Logs.Error($"NetworkError: ({code}): {point}");
};
_listener.PeerConnectedEvent += peer =>
{
_netPeer.MessageReceived += HandleMessage;
_logger.Info("Connected");
Started?.Invoke();
};
_listener.NetworkReceiveEvent += (peer, reader, method) =>
{
_netPeer.HandleDataReceived(reader.Data);
};
_listener.PeerDisconnectedEvent += (peer, info) =>
{
_manager.Stop();
AppUpdater.Instance.Remove(this);
_logger.Info("Disconnected");
Stopped?.Invoke();
};
_manager = new NetManager(_listener);
}
/// <summary>
/// Clears the net manager.
/// </summary>
public virtual void ClearNetManager()
{
if (_netManager != null)
{
_netManager.Stop();
}
}
void OnDestroy()
{
if (_netClient != null)
{
_netClient.Stop();
}
}
public RUdp() : base(NetworkProtocol.RUDP)
{
listener = new EventBasedNetListener();
client = new NetManager(listener)
{
DisconnectTimeout = 20 * 1000
};
client.UpdateTime = 15;
listener.PeerConnectedEvent += (NetPeer peer) =>
{
LogProxy.WriteLine("Connect Success : " + peer.EndPoint);
this.peer = peer;
fireCompleteConnect();
};
listener.PeerDisconnectedEvent += (NetPeer peer, DisconnectInfo disconnectInfo) =>
{
client.Flush();
client.Stop();
fireCompleteDisconnect();
};
listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) =>
{
byte[] packet = new byte[dataReader.AvailableBytes];
dataReader.GetBytes(packet, dataReader.AvailableBytes);
fireCompleteReadFromServerStream(packet);
dataReader.Recycle();
};
}
public void Terminate()
{
if (_netClient != null)
{
_netClient.Stop();
}
}
public void Shutdown()
{
if (_netClient != null)
{
_netClient.Stop();
}
}
public void BlockingStart()
{
SetupDB();
GameState gameState = new GameState(_db);
Listener listener = new Listener();
_server = new NetManager(listener);
listener.Setup(gameState);
_server.Start(GameConfig.Instance().config.port);
Console.WriteLine("Server started.");
Stopwatch _precisionTime = new Stopwatch();
_precisionTime.Start();
while (true)
{
long unadjustedTickStartTime = _precisionTime.ElapsedMilliseconds;
GameTime.Instance().UpdateTickStartTime(_precisionTime.ElapsedMilliseconds); // Update the tick start time.
_server.PollEvents();
gameState.Tick();
if (_precisionTime.ElapsedMilliseconds - unadjustedTickStartTime > 1000 / GameConfig.Instance().config.ticksPerSecond)
{
Console.WriteLine(String.Format("Tick took {0} milliseconds which is past the tick rate.", _precisionTime.ElapsedMilliseconds - unadjustedTickStartTime));
}
// Wait until time for next tick.
while (_precisionTime.ElapsedMilliseconds - unadjustedTickStartTime < 1000 / GameConfig.Instance().config.ticksPerSecond)
{
Thread.Sleep(1);
}
}
_server.Stop();
}
static void Main(string[] args)
{
GameServer game_server = new GameServer();
NetManager _netServer = new NetManager(game_server, 20, "unimoba");
//server.ReuseAddress = true;
if (!_netServer.Start(9050))
{
Console.WriteLine("Server start failed");
Console.ReadKey();
return;
}
game_server._netServer = _netServer;
while (!Console.KeyAvailable)
{
_netServer.PollEvents();
Thread.Sleep(15);
}
_netServer.Stop();
Console.ReadKey();
Console.WriteLine("ServStats:\n BytesReceived: {0}\n PacketsReceived: {1}\n BytesSent: {2}\n PacketsSent: {3}",
_netServer.BytesReceived,
_netServer.PacketsReceived,
_netServer.BytesSent,
_netServer.PacketsSent);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
public void ConnectionDualMode()
{
var listener = new EventBasedNetListener();
var server = new NetManager(listener, new Crc32cLayer());
server.IPv6Mode = IPv6Mode.DualMode;
server.Start(DefaultPort);
listener.ConnectionRequestEvent += request => request.AcceptIfKey(DefaultAppKey);
var client1 = ManagerStack.Client(1);
var client2 = ManagerStack.Client(2);
client1.Connect("127.0.0.1", DefaultPort, DefaultAppKey);
client2.Connect("::1", DefaultPort, DefaultAppKey);
while (server.ConnectedPeersCount != 2 || client1.ConnectedPeersCount != 1 || client2.ConnectedPeersCount != 1)
{
Thread.Sleep(15);
server.PollEvents();
}
Assert.AreEqual(2, server.ConnectedPeersCount);
Assert.AreEqual(1, client1.ConnectedPeersCount);
Assert.AreEqual(1, client2.ConnectedPeersCount);
server.Stop(false);
}
void OnDestroy()
{
if (client != null)
{
client.Stop();
}
}
private void OnApplicationQuit()
{
if (_netManager != null && _netManager.IsRunning)
{
_netManager.Stop();
}
}
public void Shutdown()
{
if (_netServer != null)
{
_netServer.Stop();
}
}
public void Stop()
{
_logger.Debug("Stopping NetworkServer...");
_cancellationToken.Cancel();
_server.Stop();
_logger.Debug("Stopping NetworkServer...Done.");
}
public void Stop()
{
_manager.Stop();
_isRunning = false;
_thread = null;
}
private void OnDestroy()
{
if (netClient != null)
{
netClient.Stop();
}
}
public void NetPeerDisconnectTimeout()
{
NetManager client = ManagerStack.Client(1);
NetManager server = ManagerStack.Server(1);
//Default 5 sec timeout for local network is too mach, set 1 for test
server.DisconnectTimeout = 1000;
NetPeer clientServerPeer = client.Connect("127.0.0.1", DefaultPort, DefaultAppKey);
while (clientServerPeer.ConnectionState != ConnectionState.Connected)
{
Thread.Sleep(15);
server.PollEvents();
client.PollEvents();
}
Assert.AreEqual(ConnectionState.Connected, clientServerPeer.ConnectionState);
Assert.True(server.ConnectedPeersCount == 1);
ManagerStack.ClientListener(1).PeerDisconnectedEvent += (peer, info) =>
{
Assert.AreEqual(clientServerPeer, peer);
Assert.AreEqual(DisconnectReason.Timeout, info.Reason);
};
server.Stop();
Assert.True(server.ConnectedPeersCount == 0);
while (client.ConnectedPeersCount == 1)
{
Thread.Sleep(15);
}
}
public override void StopClient()
{
base.StopClient();
// Run in own task to not block the main thread
Task.Factory.StartNew(() => { netManager.Stop(false); }, TaskCreationOptions.LongRunning);
}
void UpdateNetwork()
{
networkListener = new EventBasedNetListener();
networkListener.NetworkReceiveEvent += ReceivePackage;
client = new NetManager(networkListener);
client.Start();
client.Connect("localhost", 9050, "SomeConnectionKey");
NetDataWriter writer = new NetDataWriter();
while (true)
{
foreach (var obj in NetworkObjects)
{
if (obj.Value.networkId == MyNetworkId)
{
if (!obj.Value.CheckChanges())
{
writer.Reset();
obj.Value.WriteData(writer);
Send(writer, DeliveryMethod.Unreliable);
}
}
}
client.PollEvents();
Thread.Sleep(16);
}
client.Stop();
}
void OnDestroy()
{
if (clientInstance != null)
{
clientInstance.Stop();
}
}
void OnDestroy()
{
if (_netServer != null)
{
_netServer.Stop();
}
}
private NetManager ListenServer()
{
var listener = new EventBasedNetListener();
listener.ConnectionRequestEvent += OnConnectionRequestEvent;
listener.PeerConnectedEvent += OnConnectedEvent;
listener.PeerDisconnectedEvent += OnDisconnectedEvent;
listener.NetworkReceiveEvent += OnNetworkReceiveEvent;
var server = new NetManager(listener);
for (var i = 0; i < 10; i++)
{
if (!server.Start())
{
continue;
}
// 10000 - 60000 の範囲外の場合は再度ポートを割り当ててみる
var port = server.LocalPort;
if (10000 <= port && port <= 60000)
{
break;
}
_logger.InfoFormat("out of port range: {0}, restart server", port);
server.Stop();
}
return(server);
}
