public MyMultiplayerPeers() { IPAddress mask; m_localIp = NetUtility.GetMyAddress(out mask); m_netConfig = new NetPeerConfiguration(MyMwcNetworkingConstants.NETWORKING_MULTIPLAYER_ID); m_netConfig.Port = MyMwcNetworkingConstants.NETWORKING_PORT_MULTIPLAYER_PEER; m_netConfig.AcceptIncomingConnections = true; m_netConfig.SetMessageTypeEnabled(NetIncomingMessageType.NatIntroductionSuccess, true); m_netConfig.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, true); // For NAT punch m_netConfig.MaximumTransmissionUnit = 1350; // just to be sure if (MyFakes.MULTIPLAYER_LONG_TIMEOUT) { m_netConfig.PingInterval = 60 * 10 - 2; m_netConfig.ConnectionTimeout = 60 * 10; } // Because of lidgren #if DEBUG if (MyFakes.MULTIPLAYER_SIMULATE_LAGS) { m_netConfig.SimulatedMinimumLatency = 0.1f; // 100ms minimum lag m_netConfig.SimulatedRandomLatency = 0.2f; // +/-200ms lag m_netConfig.SimulatedLoss = 0.05f; // 5% loss m_netConfig.SimulatedDuplicatesChance = 0.03f; // 3% duplicates } #endif }
private NetPeerConfiguration _getBaseNetPeerConfig() { var netConfig = new NetPeerConfiguration("SS14_NetTag"); // ping the client once per second. netConfig.PingInterval = 1f; netConfig.SendBufferSize = _config.GetCVar(CVars.NetSendBufferSize); netConfig.ReceiveBufferSize = _config.GetCVar(CVars.NetReceiveBufferSize); netConfig.MaximumHandshakeAttempts = 5; var verbose = _config.GetCVar(CVars.NetVerbose); netConfig.SetMessageTypeEnabled(NetIncomingMessageType.VerboseDebugMessage, verbose); if (IsServer) { netConfig.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, true); netConfig.MaximumConnections = _config.GetCVar(CVars.GameMaxPlayers); } #if DEBUG //Simulate Latency netConfig.SimulatedLoss = _config.GetCVar <float>("net.fakeloss"); netConfig.SimulatedMinimumLatency = _config.GetCVar <float>("net.fakelagmin"); netConfig.SimulatedRandomLatency = _config.GetCVar <float>("net.fakelagrand"); netConfig.SimulatedDuplicatesChance = _config.GetCVar <float>("net.fakeduplicates"); netConfig.ConnectionTimeout = 30000f; #endif return(netConfig); }
public static NetServer CreateServer(NetworkOptions options) { var config = new NetPeerConfiguration(options.Identifier); config.AcceptIncomingConnections = true; config.UseMessageRecycling = true; config.SetMessageTypeEnabled(NetIncomingMessageType.DiscoveryRequest, true); config.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, true); config.MaximumConnections = options.ClientLimit; config.ConnectionTimeout = 5; if (options.PingInterval > 0) { config.PingInterval = options.PingInterval / 1000f; } if (options.RetryInterval > 0) { config.ResendHandshakeInterval = config.ResendHandshakeInterval / 1000f; } if (options.Host != null && options.Host.Trim().Length > 0) { config.LocalAddress = IPAddress.Parse(options.Host); } config.Port = options.Port; return(new NetServer(config)); }
/// <summary> /// Initialise the server, and store some test users and clients. /// </summary> private void initialise() { LogInManager.StoreNewUser("helen", "potato"); LogInManager.StoreNewUser("test", "tomato"); LogInManager.StoreNewUser("simon", "farshas"); NetPeerConfiguration config = new NetPeerConfiguration(app_identifier); //config.BroadcastAddress = NetUtility.Resolve("* your external IP here in IPv4 format *"); // external IP of a machine that the server might be running on config.LocalAddress = NetUtility.Resolve(host_name); config.MaximumConnections = max_connections; config.Port = port; config.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, true); config.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionLatencyUpdated, true); config.PingInterval = 10f; config.ConnectionTimeout = 100f; server = new NetServer(config); ctSource = new CancellationTokenSource(); server.Start(); Globals_Server.server = server; Globals_Server.logEvent("Server started- host: " + config.BroadcastAddress + ", port: " + port + ", appID: " + app_identifier + ", max connections: " + max_connections); Client client = new Client("helen", "Char_158"); Globals_Server.Clients.Add("helen", client); Client client2 = new Client("test", "Char_196"); Globals_Server.Clients.Add("test", client2); Client client3 = new Client("simon", "Char_283"); Globals_Server.Clients.Add("simon", client3); String dir = Directory.GetCurrentDirectory(); List <string> pcs = Globals_Game.pcKeys; // to potentially add a "create user function" pcs.Remove("Char_158"); pcs.Remove("Char_195"); pcs.Remove("Char_283"); //dir = dir.Remove(dir.IndexOf("RepairHist_mmo")); String path; if (Environment.OSVersion.Platform == PlatformID.Unix || Environment.OSVersion.Platform == PlatformID.MacOSX) { path = Path.Combine(dir, "Certificates"); } else { dir = Directory.GetParent(dir).FullName; dir = Directory.GetParent(dir).FullName; dir = Directory.GetParent(dir).FullName; path = Path.Combine(dir, "Certificates"); } Diplomacy.forgeAlliance("Char_283", "Char_196"); Diplomacy.declareWar("Char_283", "Char_158"); LogInManager.InitialiseCertificateAndRSA(path); }
public static void Run() { var config = new NetPeerConfiguration("Test"); config.EnableMessageType(NetIncomingMessageType.UnconnectedData); if (config.IsMessageTypeEnabled(NetIncomingMessageType.UnconnectedData) == false) { throw new LidgrenException("setting enabled message types failed"); } config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, false); if (config.IsMessageTypeEnabled(NetIncomingMessageType.UnconnectedData) == true) { throw new LidgrenException("setting enabled message types failed"); } Console.WriteLine("Hex test: " + NetUtility.ToHexString(new byte[] { 0xDE, 0xAD, 0xBE, 0xEF })); if (NetBitWriter.BitsForValue(uint.MaxValue + 1ul) != 33) { throw new LidgrenException("BitCountForValue failed"); } Console.WriteLine("Misc tests OK"); }
static void NetPeerConfigInit() { config.Port = MediatorPort; config.LocalAddress = IPAddress.Parse(MediatorIP); config.MaximumConnections = 10000; config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, true); }
public AuthoryMasterServer() { LoadConfig(); Console.WriteLine($"Creating config on port: {defaultServerPort}..."); netPeerConfig = new NetPeerConfiguration(defaultServerAuthString); netPeerConfig.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, true); netPeerConfig.PingInterval = 4f; netPeerConfig.ConnectionTimeout = 6.5f; netPeerConfig.Port = (int)defaultServerPort; Console.WriteLine("Config created."); Console.WriteLine("Creating NetServer..."); NetServer = new NetServer(netPeerConfig); Console.WriteLine($"NetServer created on port: {defaultServerPort}."); DatabaseHandler = new DatabaseHandler(dbServer, dbName, dbUser, dbPassword); DataHandler = DataHandler.Instance; MessageHandler = OutgoingMessageHandler.Instance.Init(NetServer); IncomingMessageHandler = new IncomingMessageHandler(DataHandler, DatabaseHandler, NetServer); Console.WriteLine("Lodaing maps..."); LoadMaps(); Console.WriteLine("Maps loaded."); }
/// <summary> /// Initialize MapServer /// </summary> /// <param name="port">Port where the MapServer will run</param> /// <param name="connName">Connection string for connection</param> /// <param name="mapName">Name of the map</param> /// <param name="mapIndex">Index of the map</param> public void Init(int port, string connName, string mapName, int mapIndex) { MapName = mapName; MapIndex = mapIndex; statisticsStopwatch = new Stopwatch(); mobStopwatch = new Stopwatch(); statisticsStopwatch.Start(); mobStopwatch.Start(); statistics = Statistics.None; _netPeerConfig = new NetPeerConfiguration(connName); _netPeerConfig.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, true); _netPeerConfig.PingInterval = 3f; _netPeerConfig.ConnectionTimeout = 6.5f; //_netPeerConfig.SimulatedMinimumLatency = 0.1f; //_netPeerConfig.SimulatedRandomLatency = 0.01f; _netPeerConfig.Port = (int)port; NetServer = new NetServer(_netPeerConfig); Data = new WorldDataHandler(ServerIndex); OutgoingMessageHandler = new OutgoingMessageHandler(NetServer, Data); IncomingMessageHandler = new IncomingMessageHandler(this); InitTeleporter(new Vector3(450, 0, 450), 2.5f, mapIndex == 0 ? 1 : 0); InitSpawners(mapsFolderPath); Console.WriteLine("Server UP"); ServerUp = true; }
public static void MainServer() { Application.EnableVisualStyles(); ConForm = new NetworkConnector(); // The player pressed host. if (SSEngine.Peer == null) { NetPeerConfiguration config = new NetPeerConfiguration("strange suits"); config.SetMessageTypeEnabled(NetIncomingMessageType.NatIntroductionSuccess, true); SSEngine.Peer = new NetServer(config); SSEngine.Peer.Start(); Debug.WriteLine("Server started; waiting 2 seconds..."); System.Threading.Thread.Sleep(2000); // register with master server NetOutgoingMessage regMsg = SSEngine.Peer.CreateMessage(); regMsg.Write((byte)MasterServerMessageType.RegisterHost); IPAddress mask; IPAddress adr = NetUtility.GetMyAddress(out mask); regMsg.Write(SSEngine.Peer.UniqueIdentifier); regMsg.Write(new IPEndPoint(adr, SSEngine.Peer.Port)); Debug.WriteLine("Sending registration to master server"); SSEngine.Peer.SendUnconnectedMessage(regMsg, SSEngine.MasterServerEndpoint); ConForm.tbxHost.Text = SSEngine.Peer.UniqueIdentifier.ToString(); ConForm.StartUpdate(); } else { ConForm.tbxClient.Text = SSEngine.Peer.UniqueIdentifier.ToString(); } ConForm.ShowDialog(); }
public static void Run(NetPeer peer) { NetPeerConfiguration config = new NetPeerConfiguration("Test"); config.EnableMessageType(NetIncomingMessageType.UnconnectedData); if (config.IsMessageTypeEnabled(NetIncomingMessageType.UnconnectedData) == false) { throw new NetException("setting enabled message types failed"); } config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, false); if (config.IsMessageTypeEnabled(NetIncomingMessageType.UnconnectedData) == true) { throw new NetException("setting enabled message types failed"); } TestContext.Out.WriteLine("Misc tests OK"); TestContext.Out.WriteLine("Hex test: " + NetUtility.ToHexString(new byte[] { 0xDE, 0xAD, 0xBE, 0xEF })); if (NetUtility.BitsToHoldUInt64((ulong)UInt32.MaxValue + 1ul) != 33) { throw new NetException("BitsToHoldUInt64 failed"); } }
internal ClientConnection(bool dummy) { if (!dummy) { SynchronizationContext.SetSynchronizationContext(new SynchronizationContext()); NetPeerConfiguration peerConfig = new NetPeerConfiguration("Qbes"); peerConfig.AutoFlushSendQueue = true; peerConfig.SetMessageTypeEnabled(NetIncomingMessageType.DebugMessage, true); peerConfig.SetMessageTypeEnabled(NetIncomingMessageType.ErrorMessage, true); peerConfig.SetMessageTypeEnabled(NetIncomingMessageType.VerboseDebugMessage, true); peerConfig.SetMessageTypeEnabled(NetIncomingMessageType.WarningMessage, true); _Client = new NetClient(peerConfig); _Client.RegisterReceivedCallback(new SendOrPostCallback(ReceivedMessage)); } }
/// <summary> /// Set up the server, bind to a socket. Use Start to fully start the server after running this /// </summary> /// <param name="configuration"></param> public static void InitializeServer(ServerConfiguration configuration) { Configuration = configuration; if (peer != null && peer.Status != NetPeerStatus.NotRunning) { Debug.LogError("cannot start server while already running"); return; } _netPeerConfiguration = new NetPeerConfiguration(Configuration.AppIdentifier); _netPeerConfiguration.Port = Configuration.ListenPort; _netPeerConfiguration.MaximumConnections = Configuration.MaximumConnections; connections = new IntDictionary <NetConnection>(Configuration.MaximumConnections); _netPeerConfiguration.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, true); peer = new NetServer(_netPeerConfiguration); peer.Start(); var serverId = connections.Add(null); var serverPlayer = new Player(); serverPlayer.Id = (ushort)serverId; Player.Server = serverPlayer; GameState.update += Update; }
public void TestSetMessageTypeEnabled() { var config = new NetPeerConfiguration("Test"); config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, false); Assert.IsFalse(config.IsMessageTypeEnabled(NetIncomingMessageType.UnconnectedData), "setting enabled message types failed"); }
void InitializeClient() { NetPeerConfiguration config = new NetPeerConfiguration("test"); config.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionLatencyUpdated, true); config.ConnectionTimeout = 3000f; client = new NetClient(config); }
private ServerManager() { WorldHelper.SetMessagingProviders(_ClientToServer, _ServerToClient); SynchronizationContext.SetSynchronizationContext(new SynchronizationContext()); NetPeerConfiguration peerConfig = ServerWorldManager.Instance.Configuration.Network.CreateNetPeerConfigurationUdp(); peerConfig.SetMessageTypeEnabled(NetIncomingMessageType.DebugMessage, true); peerConfig.SetMessageTypeEnabled(NetIncomingMessageType.ErrorMessage, true); peerConfig.SetMessageTypeEnabled(NetIncomingMessageType.VerboseDebugMessage, true); peerConfig.SetMessageTypeEnabled(NetIncomingMessageType.WarningMessage, true); _Server = new NetServer(peerConfig); _Server.RegisterReceivedCallback(new SendOrPostCallback(ReceivedMessage)); _WebServer = new WebHost(ServerWorldManager.Instance.Configuration.Network.Web); }
public Program() { NetPeerConfiguration config = new NetPeerConfiguration("masterserver"); config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, true); config.Port = Game.API.MasterServer.MasterServerPort; peer = new NetPeer(config); peer.Start(); }
static void Main(string[] args) { IPEndPoint masterServerEndpoint = NetUtility.Resolve("localhost", CommonConstants.MasterServerPort); NetPeerConfiguration config = new NetPeerConfiguration("game"); config.SetMessageTypeEnabled(NetIncomingMessageType.NatIntroductionSuccess, true); config.Port = 14242; NetServer server = new NetServer(config); server.Start(); Console.WriteLine("Server started; waiting 5 seconds..."); System.Threading.Thread.Sleep(5000); var lastRegistered = -60.0f; while (Console.KeyAvailable == false || Console.ReadKey().Key != ConsoleKey.Escape) { // (re-)register periodically with master server if (NetTime.Now > lastRegistered + 60) { // register with master server NetOutgoingMessage regMsg = server.CreateMessage(); regMsg.Write((byte)MasterServerMessageType.RegisterHost); IPAddress mask; IPAddress adr = NetUtility.GetMyAddress(out mask); regMsg.Write(server.UniqueIdentifier); regMsg.Write(new IPEndPoint(adr, 14242)); Console.WriteLine("Sending registration to master server"); server.SendUnconnectedMessage(regMsg, masterServerEndpoint); lastRegistered = (float)NetTime.Now; } NetIncomingMessage inc; while ((inc = server.ReadMessage()) != null) { switch (inc.MessageType) { case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: Console.WriteLine(inc.ReadString()); break; } } System.Threading.Thread.Sleep(1); } Console.ReadKey(); }
static void ClientServerStart() { NetPeerConfiguration config = new NetPeerConfiguration(" "); config.Port = ClientPort; config.LocalAddress = IPAddress.Parse(ClientIP); config.MaximumConnections = 10000; config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, true); MediatorServer = new NetServer(config); MediatorServer.Start(); }
public override void Open(string bindip, ushort port, bool lan) { var bind = bindip == "*" ? IPAddress.Any : IPAddress.Parse(bindip); NetPeerConfiguration config = new NetPeerConfiguration(GameInfo.NAME) { Port = port, AcceptIncomingConnections = true }; config.SetMessageTypeEnabled(NetIncomingMessageType.NatIntroductionSuccess, true); config.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, true); config.SetMessageTypeEnabled(NetIncomingMessageType.DebugMessage, Debug.isDebugBuild); _server = new NetServer(config); _server.Start(); var con = _server.GetConnection(new IPEndPoint(IPAddress.None, port)); _listen = true; }
public PropertyBag(InfiniminerGame gameInstance) { // Initialize our network device. NetPeerConfiguration netConfig = new NetPeerConfiguration("InfiniminerPlus"); netClient = new NetClient(netConfig); netConfig.SetMessageTypeEnabled(NetIncomingMessageType.ErrorMessage, true); //netClient.SimulatedMinimumLatency = 0.1f; //netClient.SimulatedLatencyVariance = 0.05f; //netClient.SimulatedLoss = 0.1f; //netClient.SimulatedDuplicates = 0.05f; netClient.Start(); // Initialize engines. blockEngine = new BlockEngine(gameInstance); interfaceEngine = new InterfaceEngine(gameInstance); playerEngine = new PlayerEngine(gameInstance); skyplaneEngine = new SkyplaneEngine(gameInstance); particleEngine = new ParticleEngine(gameInstance); // Create a camera. playerCamera = new Camera(gameInstance.GraphicsDevice); UpdateCamera(); // Load sounds. if (!gameInstance.NoSound) { soundList[InfiniminerSound.DigDirt] = gameInstance.Content.Load <SoundEffect>("sounds/dig-dirt"); soundList[InfiniminerSound.DigMetal] = gameInstance.Content.Load <SoundEffect>("sounds/dig-metal"); soundList[InfiniminerSound.Ping] = gameInstance.Content.Load <SoundEffect>("sounds/ping"); soundList[InfiniminerSound.ConstructionGun] = gameInstance.Content.Load <SoundEffect>("sounds/build"); soundList[InfiniminerSound.Death] = gameInstance.Content.Load <SoundEffect>("sounds/death"); soundList[InfiniminerSound.CashDeposit] = gameInstance.Content.Load <SoundEffect>("sounds/cash"); soundList[InfiniminerSound.ClickHigh] = gameInstance.Content.Load <SoundEffect>("sounds/click-loud"); soundList[InfiniminerSound.ClickLow] = gameInstance.Content.Load <SoundEffect>("sounds/click-quiet"); soundList[InfiniminerSound.GroundHit] = gameInstance.Content.Load <SoundEffect>("sounds/hitground"); soundList[InfiniminerSound.Teleporter] = gameInstance.Content.Load <SoundEffect>("sounds/teleport"); soundList[InfiniminerSound.Jumpblock] = gameInstance.Content.Load <SoundEffect>("sounds/jumpblock"); soundList[InfiniminerSound.Explosion] = gameInstance.Content.Load <SoundEffect>("sounds/explosion"); soundList[InfiniminerSound.RadarHigh] = gameInstance.Content.Load <SoundEffect>("sounds/radar-high"); soundList[InfiniminerSound.RadarLow] = gameInstance.Content.Load <SoundEffect>("sounds/radar-low"); soundList[InfiniminerSound.RadarSwitch] = gameInstance.Content.Load <SoundEffect>("sounds/switch"); } // Create a SINGLE SPRITEBATCH FOR THE F*****G GOD DAMN STATES AND SHIT spriteBatch = new SpriteBatch(gameInstance.GraphicsDevice); //Generate a SINGLE 1px white texture shade = new Texture2D(gameInstance.GraphicsDevice, 1, 1, false, SurfaceFormat.Color); shade.SetData(new Color[] { Color.White }); }
public void ConnectToServer() { spawnedSync.Clear(); spawnedPlayers.Clear(); nickname = global.player.Nickname; var config = new NetPeerConfiguration("Ostfront") { EnableUPnP = true, ReceiveBufferSize = 16035, SendBufferSize = 16035, AcceptIncomingConnections = true }; config.SetMessageTypeEnabled(NetIncomingMessageType.NatIntroductionSuccess, true); config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, true); config.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, true); _client = new NetClient(config); _client.Start(); new OF_GameServer.LoopMessages(_client); if (!isOffline) { NetOutgoingMessage connectionMessage = _client.CreateMessage(); //connectionMessage.Write((byte)GlobalServerTransmissionEnum.IntroduceToPublicServer); connectionMessage.Write(serverName); connectionMessage.Write(new IPEndPoint(global.GetInternal(), _client.Port)); _client.SendUnconnectedMessage(connectionMessage, GlobalServerIP); } else { StartCoroutine("OfflineConnection"); } StartCoroutine("CheckConnect"); }
public static NetClient CreateClient(NetworkOptions options) { var config = new NetPeerConfiguration(options.Identifier == null ? "Sirius" : options.Identifier); config.AcceptIncomingConnections = false; config.UseMessageRecycling = true; config.SetMessageTypeEnabled(NetIncomingMessageType.DiscoveryRequest, false); config.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, false); config.ConnectionTimeout = 5; if (options.PingInterval > 0) { config.PingInterval = options.PingInterval / 1000f; } if (options.RetryInterval > 0) { config.ResendHandshakeInterval = config.ResendHandshakeInterval / 1000f; } return(new NetClient(config)); }
/// <summary> /// Start local network peer. /// </summary> public Network() { m_netPeerConfiguration.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, true); m_netPeerConfiguration.Port = APIMain.MasterServerPort; m_netPeer = new NetPeer(m_netPeerConfiguration); m_netPeer.Start(); m_updateThread = new Thread(Update); m_updateThread.Start(); m_updateServersListThread = new Thread(UpdateServerList); m_updateServersListThread.Start(); }
//TODO: Refactor public ServerCore(ILogger loggerInstance, string appName, int port, string hailMessage) : base() { NetworkMessageHandler = new PacketHandler(loggerInstance); NetworkMessageHandler.Register <DiffieHellmanAESEncryptor>(EncryptionBase.DefaultByte); Port = port; UnhandledServerConnections = new List <ConnectionResponse>(); //Register the default serializer this.NetworkMessageHandler.Register <GladNetProtobufNetSerializer>(); ClassLogger = loggerInstance; Clients = new ConnectionCollection <ClientPeer, NetConnection>(); ServerConnections = new ConnectionCollection <ServerPeer, NetConnection>(); //Construction of the Lidgren server listener NetPeerConfiguration config = new NetPeerConfiguration(appName); config.Port = port; //Server needs a much larger than default buffer size because corruption can happen otherwise config.ReceiveBufferSize = 500000; config.SendBufferSize = 500000; //This message type must be set to true so we can manage connections with hailmessages and so that we can //reject the majority of non-malicious malformed connection attempts config.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, true); config.SetMessageTypeEnabled(NetIncomingMessageType.ExternalHighlevelMessage, true); //Reduces GC config.UseMessageRecycling = true; lidgrenServerObj = new NetServer(config); ExpectedClientHailMessage = hailMessage; }
void StartServer() { NetPeerConfiguration config = new NetPeerConfiguration("FPSMod"); Debug.Log("Starting Server"); m_isServer = true; config.Port = ServerSettings.Port; config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, true); m_server = new NetServer(config); m_server.Start(); SpawnLocalPlayer(); Debug.Log("wID: " + m_saveWorkshopID); Debug.Log("p: " + ServerSettings.Private); if (MultiplayerLoading.UseVehiclesAndCitizens) { m_vNetworkManager = gameObject.AddComponent <VehicleNetworkManager>(); m_cNetworkManager = gameObject.AddComponent <CitizenNetworkManager>(); } if (m_saveWorkshopID != UInt64.MaxValue && !ServerSettings.Private) { try { using (var client = new WebClient()) { var values = new NameValueCollection { { "name", ServerSettings.Name.IsNullOrWhiteSpace() ? "No name" : ServerSettings.Name }, { "port", ServerSettings.Port.ToString() }, { "mapId", m_saveWorkshopID.ToString() }, { "modVersion", Settings.ModVersion.ToString() } }; var result = client.UploadValues(Settings.ServerUrl + "/create", "POST", values); string responsebody = Encoding.UTF8.GetString(result); Debug.Log("Sending to masterserver: " + responsebody); } } catch (Exception) { throw; } } }
partial void ImplConnectionSetup() { _serverConfiguration = new NetPeerConfiguration(Configuration.AppIdentifier); _serverConfiguration.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, true); _serverConfiguration.Port = Configuration.ListenPort; //bit of overhead in connection count _serverConfiguration.MaximumConnections = (int)(Configuration.MaximumPlayers * 1.5); #if DEBUG Debug.Log("Debug build. Simulated latency and packet loss/duplication is enabled."); _serverConfiguration.SimulatedLoss = 0.001f; _serverConfiguration.SimulatedDuplicatesChance = 0.001f; _serverConfiguration.SimulatedMinimumLatency = 0.1f; _serverConfiguration.SimulatedRandomLatency = 0.01f; #endif PlayerServer = new NetServer(_serverConfiguration); }
public static void Run(NetPeer peer) { NetPeerConfiguration config = new NetPeerConfiguration("Test"); config.EnableMessageType(NetIncomingMessageType.UnconnectedData); if (config.IsMessageTypeEnabled(NetIncomingMessageType.UnconnectedData) == false) { throw new NetException("setting enabled message types failed"); } config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, false); if (config.IsMessageTypeEnabled(NetIncomingMessageType.UnconnectedData) == true) { throw new NetException("setting enabled message types failed"); } Console.WriteLine("Misc tests OK"); Console.WriteLine("Hex test: " + NetUtility.ToHexString(new byte[] { 0xDE, 0xAD, 0xBE, 0xEF })); }
void Start() { try { Debug.Log("client try Start"); config = new NetPeerConfiguration(" "); DontDestroyOnLoad(this); config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, true); config.Port = 1212; client = new NetClient(config); client.Start(); Debug.Log("client Start"); } catch (Exception e) { Debug.Log(e.Message); } }
protected internal override void Initialize() { SynchronizationContext.SetSynchronizationContext(new SynchronizationContext()); //set up room server var roomConfig = new NetPeerConfiguration(Server.Configuration.AppIdentifier + "DPT") { AutoFlushSendQueue = true, Port = Server.Configuration.RoomListenPort, MaximumConnections = Server.Configuration.MaximumRooms }; roomConfig.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, true); RoomServer = new NetServer(roomConfig); RoomServer.RegisterReceivedCallback(RoomCallback); RoomServer.Start(); //set up player server var playerConfig = new NetPeerConfiguration(Server.Configuration.AppIdentifier) { AutoFlushSendQueue = true, Port = Server.Configuration.PlayerListenPort, MaximumConnections = Server.Configuration.MaximumPlayers }; playerConfig.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, true); #if DEBUG Debug.Log("Debug build. Simulated latency and packet loss/duplication is enabled."); playerConfig.SimulatedLoss = 0.001f; playerConfig.SimulatedDuplicatesChance = 0.001f; playerConfig.SimulatedMinimumLatency = 0.1f; playerConfig.SimulatedRandomLatency = 0.01f; #endif PlayerServer = new NetServer(playerConfig); PlayerServer.RegisterReceivedCallback(PlayerCallback); PlayerServer.Start(); }
/// <summary> /// Start the server /// </summary> public void StartServer() { Clients = new ClientCollection(); // Server basic configuration var config = new NetPeerConfiguration(GameConfiguration.NetworkAppIdentifier) { MaximumConnections = ServerSettings.MaxConnection, Port = ServerSettings.Port, #if DEBUG //PingInterval = 1f, // send ping every 1 second //SimulatedLoss = 0.5f, // half packets lost //SimulatedMinimumLatency = 0.05f, // latency of 50 ms #endif }; // To send ping to each player frequently config.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionLatencyUpdated, true); try { _server = new NetServer(config); _server.Start(); _hostStarted = true; GameManager.Initialize(); Program.Log.Info("[START]Game server has started"); Program.Log.Info("[PORT]: " + config.Port); } catch (NetException ex) { Program.Log.Fatal(ex.Message); throw; } }