public void Start(NetServer server_, string saveFilename_, GamePlatform platform_)
{
server = server_;
saveFilename = saveFilename_;
platform = platform_;
mainThreadActionsLock = platform.MonitorCreate();
}
static void testNetClient()
{
NetServer server = new NetServer(9556);
server.ClientConnected.Subscribe(tracked =>
{
Console.WriteLine("[SERVER]: Client connected.");
tracked.Value.MessageRecieved.Subscribe(
next_msg => Console.WriteLine("[SERVER]: Client Message: " + Encoding.UTF8.GetString(next_msg.Message)),
next_err => Console.WriteLine("[SERVER]: Client Read Error: " + next_err.Message),
() => Console.WriteLine("[SERVER]: Client Disconnected."));
var sClient = tracked.Observe();
sClient.Write(Encoding.UTF8.GetBytes("Hello, new client!"));
});
server.Start();
NetClient client = new NetClient("localhost", 9556);
client.MessageRecieved.Subscribe(
next_msg => Console.WriteLine("[CLIENT]: Server Message: " + Encoding.UTF8.GetString(next_msg.Message)),
next_err => Console.WriteLine("[CLIENT]: Server Read Error: " + next_err.Message),
() => Console.WriteLine("[CLIENT]: Server Disconnected."));
client.Connect();
Console.WriteLine("[CLIENT]: Connected.");
client.Write(Encoding.UTF8.GetBytes("Hello back!!!"));
Console.ReadLine();
}
public void StartListening()
{
if (nS != null && nS.IsOnline)
nS.Stop();
nS = new NetServer();
nS.EchoMode = NetEchoMode.EchoAll;
nS.OnClientConnected += nS_OnClientConnected;
nS.OnClientDisconnected += nS_OnClientDisconnected;
nS.OnReceived +=nS_OnReceived;
try
{
nS.Start(IPAddress.Any, SERVERPORT);
}
catch (SocketException e)
{
MessageBox.Show("This port it's already in use, select a new one!", "Port already in use", MessageBoxButton.OK, MessageBoxImage.Error);
}
Application.Current.Dispatcher.Invoke(new Action(() =>
{
MainWindow mw = (MainWindow)Application.Current.MainWindow;
IPHostEntry ipHost = Dns.GetHostEntry(Dns.GetHostName());
foreach (IPAddress item in ipHost.AddressList)
{
if(!item.IsIPv6LinkLocal)
mw.appendConsole("Server IP: " + item.ToString() + ":" + SERVERPORT.ToString());
}
}));
}
public static void Main(string[] args)
{
//chargement de la configuration du server
settings = new Config();
//configuration du logging
InitLogging();
//configuration du serveur
server=new NetServer();
server.OnClientAccepted+=server_OnClientAccepted;
server.OnClientConnected+= server_OnClientConnected;
server.OnClientDisconnected+= server_OnClientDisconnected;
server.OnClientRejected+= server_OnClientRejected;
server.OnReceived += server_OnReceived;
server.OnStarted+= server_OnStarted;
server.OnStopped+=server_OnStopped;
server.TickRate = 1000;
// configuration du port
serialPort = new SerialPort { BaudRate = settings.BaudRate,
DataWidth = settings.DataWidth,
Port = settings.Port,
StopBits = settings.StopBits,
ParityBits = settings.ParityBits,
Priority = ThreadPriority.Highest };
serialPort.Received += serialPort_Received;
serialPort.Connected += serialPort_Connected;
if (!serialPort.Open())
{
logger.Error("Le port est occupé");
Console.Write("Press any key to exit . . . ");
Console.ReadKey(true);
return;
}
try
{
server.Start(IPAddress.Parse(settings.Server),
settings.ServerPort,settings.Capacity);
if(server.IsOnline)
{
running=new Thread(Run);
running.Start();
running.Join();
}
}
catch(Exception e)
{
logger.Error(e.Message);
}
finally
{
Console.Write("Press any key to exit . . . ");
Console.ReadKey(true);
}
}
void Start()
{
_dataWriter = new NetDataWriter();
_netServer = new NetServer(this, 100, "sample_app");
_netServer.Start(5000);
_netServer.DiscoveryEnabled = true;
_netServer.UpdateTime = 15;
}
/// <summary>
/// Creates a server that listens on a given port.
/// </summary>
/// <returns>The server object.</returns>
/// <param name="maxConnections">Max connections.</param>
/// <param name="port">Port.</param>
public static NetServer CreateServer( int maxConnections , int port )
{
NetServer s = new NetServer( maxConnections , port );
// If we were successful in creating our server and it is unique
if(s.mIsRunning && mServers.Contains (s) != true ){
mServers.Add (s);
}
return s;
}
public void StartServer()
{
NetPeerConfiguration config = new NetPeerConfiguration("UnityFPSFramework");
config.Port = 44644;
config.MaximumConnections=64;
NetServer server = new NetServer(config);
server.Start();
ServerStarted=true;
Debug.Log ("Network Server Started");
}
private LocalServerImpl(Peer peer)
{
Peer = peer;
Peer.Start();
_writerStream = new MemoryStream();
_readerStream = new MemoryStream();
_clients = new Dictionary<NetConnection, Client>();
_lastClientCheck = DateTime.Now;
}
static void Test6()
{
var pfx = new X509Certificate2("../newlife.pfx", "newlife");
//Console.WriteLine(pfx);
//using var svr = new ApiServer(1234);
//svr.Log = XTrace.Log;
//svr.EncoderLog = XTrace.Log;
//var ns = svr.EnsureCreate() as NetServer;
using var ns = new NetServer(1234)
{
Name = "Server",
ProtocolType = NetType.Tcp,
Log = XTrace.Log,
SessionLog = XTrace.Log,
SocketLog = XTrace.Log,
LogReceive = true
};
ns.EnsureCreateServer();
foreach (var item in ns.Servers)
{
if (item is TcpServer ts)
{
ts.Certificate = pfx;
}
}
ns.Received += (s, e) =>
{
XTrace.WriteLine("收到：{0}", e.Packet.ToStr());
};
ns.Start();
using var client = new TcpSession
{
Name = "Client",
Remote = new NetUri("tcp://127.0.0.1:1234"),
SslProtocol = SslProtocols.Tls,
Log = XTrace.Log,
LogSend = true
};
client.Open();
client.Send("Stone");
Console.ReadLine();
}
protected CommunicatorProviderBase(NetPeerConfiguration configuration, ConverterBase converter, IAuthenticator authenticator = null, string[] requiredAuthenticationRoles = null)
{
Configuration = configuration;
Converter = converter;
if (authenticator != null)
{
RequiredAuthenticationRoles = requiredAuthenticationRoles;
configuration.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
}
NetConnector = new NetServer(configuration);
NetEncryptor = new ServerTripleDesNetEncryptor(NetConnector, 4096);
Authenticator = authenticator;
Initialize(typeof(ICallbackContract), typeof(IProviderContract));
}
public static void start()
{
net = new NetServer(config);
net.RegisterReceivedCallback(new SendOrPostCallback((e) =>
{
message = ((NetServer)e).ReadMessage();
messageRecieved(message);
}), new SynchronizationContext());
print("info", "Starting...");
net.Start();
print("info", "Server running");
}
public static void SendToGameRoomPlayers(NetServer server, NetOutgoingMessage outmsg, GameRoom room)
{
var recipients = new List <NetConnection>();
for (int i = 0; i < room.Players.Count; i++)
{
recipients.Add(room.Players[i].Conn);
}
if (recipients.Count <= 0)
{
return;
}
server.SendMessage(outmsg, recipients, NetDeliveryMethod.ReliableOrdered, 0);
}
public void Init(string app_identifier, int listen_port, int max_connections, int interval_ms, bool use_multi_thread)
{
this.app_identifier = app_identifier;
this.interval_ms = interval_ms;
NetPeerConfiguration config = new NetPeerConfiguration(this.app_identifier);
config.MaximumConnections = max_connections;
config.Port = listen_port;
net_server = new NetServer(config);
if (SynchronizationContext.Current == null)
{
SynchronizationContext.SetSynchronizationContext(new STASynchronizationContext());
}
if (use_multi_thread == false && SynchronizationContext.Current != null)
{
net_server.RegisterReceivedCallback(new SendOrPostCallback(GotMessage));
}
else
{
net_worker = new BackgroundWorker();
net_worker.DoWork += new DoWorkEventHandler(net_worker_DoWork);
net_worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(net_worker_RunWorkerCompleted);
}
tick_timer = new Timer(e =>
{
try
{
if (OnTick != null && use_multi_thread && SynchronizationContext.Current != null)
{
SynchronizationContext.Current.Post(x =>
{
OnTick();
}, null);
}
else
{
OnTick();
}
}
catch (System.Exception ex)
{
Console.WriteLine("Tick timer exception = {0}", ex.Message);
}
});
}
public IMessageHandler ProcessMessage(IMessageHandler interface37_0)
{
if (!NetServer.IsServerUser(interface37_0.Header.DestUserID))
{
this.interface40_0.SendMessage(interface37_0, interface37_0.Header.DestUserID, ActionTypeOnChannelIsBusy.Continue);
return(null);
}
if (interface37_0.Header.MessageType == base.object_0.ContinueTransFile)
{
new ContinueTransFile().method_0();
return(null);
}
return(base.method_5(interface37_0));
}
private static void OnAgarServerProgerss()
{
NetPeerConfiguration config = new NetPeerConfiguration("CozyKxlol");
config.MaximumConnections = 10000;
config.Port = 48360;
AgarServer = new NetServer(config);
AgarServer.Start();
RegisterAgarMessage();
FixedBallMgr.Update();
}
public Lobby(string id, NetConnection nc, string owner, NetServer masterServer)
{
MasterServer = masterServer;
LobbyData = new LobbyData(id, owner, new string[] { owner }, new List <ChatEntry>
{
new ChatEntry("Server", owner + "joined to lobby.")
}
);
Members = new Dictionary <string, NetConnection>
{
{ owner, nc }
};
}
/// <summary>
/// Initializes as server.
/// </summary>
/// <param name="port">The server's sending port. Server's receiving port is set to port+1.</param>
public static void InitAsServer(int port)
{
InitBasic(true);
NetServer server = new NetServer();
m_network.m_deserializer.Init(server, m_network.m_dispatcher);
server.SetDeserializer(m_network.m_deserializer);
server.Start(port);
ServerManager manager = new ServerManager(server);
m_network.m_server = manager;
}
public GameServer()
{
server = new NetServer();
this.server.Connected += new EventHandler <NetSocketConnectedEventArgs>(server_Connected);
this.server.ConnectionRequested += new EventHandler <NetSockConnectionRequestEventArgs>(server_ConnectionRequested);
this.server.DataArrived += new EventHandler <NetSockDataArrivalEventArgs>(server_DataArrived);
this.server.Disconnected += new EventHandler <NetSocketDisconnectedEventArgs>(server_Disconnected);
this.server.StateChanged += new EventHandler <NetSockStateChangedEventArgs>(server_StateChanged);
netImpl = new C2SImplement();
PlayerManager = new PlayerManager();
RankManager = new RankManager();
// Disconnected = new EventHandler<NetSocketDisconnectedEventArgs>(local_Disconnected);
}
public Server(ManagerLogger managerLogger)
{
this.managerLogger = managerLogger;
players = new List <PlayerAndConnection>();
abilities = new List <AbilityOutline>();
config = new NetPeerConfiguration("networkGame")
{
Port = 14241
};
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
NetServer = new NetServer(config);
random = new Random();
}
/// <summary>
/// Initiates the NetServer.
/// </summary>
/// <param name="port"></param>
public NetManager(int port)
{
// Configure server
NetPeerConfiguration config = new NetPeerConfiguration("smc20")
{
Port = port
};
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
// Start server
NetServer = new NetServer(config);
NetServer.Start();
}
public void StartServer(int PortNumber)
{
NetPeerConfiguration myConfig = new NetPeerConfiguration("Client");
myConfig.Port = PortNumber;
myServer = new NetServer(myConfig);
//myConfig.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
Console.WriteLine("Intializing Server Connection...");
SynchronizationContext myContext = new SynchronizationContext();
SynchronizationContext.SetSynchronizationContext(myContext);
myServer.RegisterReceivedCallback(ProcessServerRequests, SynchronizationContext.Current);
myServer.Start();
}
///
/// <summary>
/// Initializes a new instance of the <see cref="ServerForm"/> class.
/// </summary>
///
/// <param name="autoStart">Whether or not to automatically start the server.</param>
///
public ServerForm(Boolean autoStart)
{
InitializeComponent();
// Set up the file system.
serverDataDirectory = Path.Combine(Environment.CurrentDirectory, "server_data");
// Set up the RNG.
random = new Random();
#region Networking Setup
// Set up the config.
netConfig = new NetPeerConfiguration("Everblaze");
netConfig.Port = 1945;
netConfig.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
netConfig.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
netConfig.PingInterval = 1.5F;
netConfig.ConnectionTimeout = 8.0F;
// Set up the server object.
server = new NetServer(netConfig);
ServerTimer.Interval = 17;
#endregion
#region Game Setup
// Set up the server configuration.
// This will automatically load existing server data or create new data.
serverConfiguration = new ServerConfiguration(
Path.Combine(serverDataDirectory, "main.cfg"),
ref world);
#endregion
if (autoStart)
{
log("INFO", "Automatic startup command received. Starting automatically.");
Thread.Sleep(750);
StartMenuItem_Click(null, null);
}
}
// When pressed StartGame button, it tries to create server
private void OnStartGameButtonPressed(object source, EventArgs args)
{
NetPeerConfiguration config = new NetPeerConfiguration("DefaultConfiguration");
config.Port = _globals.Port;
config.EnableUPnP = true;
config.LocalAddress = NetUtility.Resolve("localhost");
NetServer server = new NetServer(config);
server.Start();
_globals.Server = server;
_globals.PlayingAsHost = true;
GD.Print("OK: Created Server");
}
public UdpServer(PacketHandler packetHandler, PlayerManager playerManager, EntitySimulation entitySimulation, ServerConfig serverConfig)
{
this.packetHandler = packetHandler;
this.entitySimulation = entitySimulation;
this.playerManager = playerManager;
portNumber = serverConfig.ServerPort;
maxConn = serverConfig.MaxConnections;
NetPeerConfiguration config = BuildNetworkConfig();
server = new NetServer(config);
thread = new Thread(Listen);
}
static void Test1()
{
var svr = new NetServer <WebSocketSession>();
svr.ProtocolType = NetType.Tcp;
svr.Port = 8888;
svr.Received += Svr_Received;
svr.Log = XTrace.Log;
svr.LogSend = true;
svr.LogReceive = true;
svr.Start();
Console.ReadKey();
}
public void Start(bool isServer, int port, string url = null)
{
_isServer = isServer;
_url = url;
_port = port;
_cancellationTokenSource = new CancellationTokenSource();
OnClose += Close;
if (_isServer)
{
var config = new NetPeerConfiguration("networkGame")
{
Port = _port,
PingInterval = 1f,
ConnectionTimeout = 5f
};
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
config.EnableMessageType(NetIncomingMessageType.ConnectionLatencyUpdated);
config.EnableMessageType(NetIncomingMessageType.WarningMessage);
config.EnableMessageType(NetIncomingMessageType.VerboseDebugMessage);
config.EnableMessageType(NetIncomingMessageType.ErrorMessage);
config.EnableMessageType(NetIncomingMessageType.Error);
config.EnableMessageType(NetIncomingMessageType.DebugMessage);
_server = new NetServer(config);
_server.Start();
}
else
{
var config = new NetPeerConfiguration("networkGame")
{
PingInterval = 1f,
ConnectionTimeout = 5f
};
config.EnableMessageType(NetIncomingMessageType.WarningMessage);
config.EnableMessageType(NetIncomingMessageType.VerboseDebugMessage);
config.EnableMessageType(NetIncomingMessageType.ErrorMessage);
config.EnableMessageType(NetIncomingMessageType.Error);
config.EnableMessageType(NetIncomingMessageType.DebugMessage);
_client = new NetClient(config);
_client.Start();
_client.Connect(_url, _port);
}
_task = new Task(() =>
{
Run(_cancellationTokenSource.Token);
});
_task.Start();
}
public void Start()
{
Console.WriteLine("Started server: " + serverName + ".");
NetPeerConfiguration config = new NetPeerConfiguration("DATX02");
config.Port = port;
serverThread = new NetServer(config);
serverThread.Start();
running = true;
Run();
}
public override void OnEnabled()
{
NetPeerConfiguration Configuration = new NetPeerConfiguration(ConstantValues.ServerString)
{
Port = (int)ConstantValues.Port
};
Configuration.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
Configuration.EnableMessageType(NetIncomingMessageType.StatusChanged);
server = new NetServer(Configuration);
server.Start();
base.OnEnabled();
}
public LidgrenServer()
{
var config = new NetPeerConfiguration("test");
config.Port = 12345;
config.MaximumConnections = 10;
config.ConnectionTimeout = 10;
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
m_Server = new NetServer(config);
m_Server.Configuration.ConnectionTimeout = 10;
m_MessageTypes = new Dictionary <Type, Action <IConnection, object> >();
}
public NetServer StartServer()
{
var config = new NetPeerConfiguration("tests")
{
Port = 27015,
MaximumConnections = 1024
};
var server = new NetServer(config);
server.Start();
return(server);
}
private void InitServer()
{
string nameServer = GameConst.serverName;
int port = GameConst.port;
config = new NetPeerConfiguration(nameServer)
{
Port = port
};
config.MaximumConnections = 2048;
server = new NetServer(config);
server.Start();
Console.WriteLine("MaxConnections=" + config.MaximumConnections);
}
public static void Start()
{
if (Settings.Instance.Server.EnableWebSocketServer)
{
WebSocketListener.Start();
}
pingTimer = new Timer(PingTimerCallback, null, 7500, 10000);
HighResolutionTimer.LoopTimer.Elapsed += HubLoop;
HighResolutionTimer.LoopTimer.AfterElapsed += (sender, e) =>
{
if (ListenerServer != null)
{
ListenerServer.FlushSendQueue();
}
};
HighResolutionTimer.VoIPTimer.AfterElapsed += (sender, e) =>
{
if (ListenerServer != null)
{
ListenerServer.FlushSendQueue();
}
};
_lastTick = DateTime.Now;
NetPeerConfiguration Config = new NetPeerConfiguration("BeatSaberMultiplayer")
{
Port = Settings.Instance.Server.Port,
EnableUPnP = Settings.Instance.Server.TryUPnP,
AutoFlushSendQueue = false,
MaximumConnections = 512
};
Config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
ListenerServer = new NetServer(Config);
ListenerServer.Start();
if (Settings.Instance.Radio.EnableRadio)
{
RadioController.StartRadio();
}
if (Settings.Instance.Server.TryUPnP)
{
ListenerServer.UPnP.ForwardPort(Config.Port, "Beat Saber Multiplayer ServerHub");
}
}
public void SetupLidgrenServer()
{
if (PortIsInUse(ServerContext.Config.Port))
{
throw new HandledException($"Port {ServerContext.Config.Port} is already in use");
}
ServerContext.Config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
ServerContext.Config.EnableMessageType(NetIncomingMessageType.NatIntroductionSuccess);
Server = new NetServer(ServerContext.Config);
Server.Start();
ServerContext.ServerStarting = false;
}
public static void Initialize()
{
var config = new NetPeerConfiguration("LidgrenChat")
{
Port = 5555
};
NetServer = new NetServer(config);
NetServer.Start();
StartThread();
Started = true;
}
public void CreateServer()
{
NetManager.Init();
NetServer s = NetManager.CreateServer(30, 7777);
Assert.IsNotNull(s);
Assert.IsTrue(NetUtils.IsSocketValid(s.mSocket));
Assert.IsTrue(s.mIsRunning);
Assert.AreEqual(7777, s.mPort);
NetworkTransport.RemoveHost(s.mSocket);
NetManager.Shutdown();
}
/**
* Will start the server with the given port and game settings.
*/
private void StartServer(int port, GameSettings gameSettings)
{
Logger.Get().Info(this, $"Starting server v{Version.String}");
var packetManager = new PacketManager();
var netServer = new NetServer(packetManager);
var serverManager = new ServerManager(netServer, gameSettings, packetManager);
new CommandManager(gameSettings, serverManager);
serverManager.Start(port);
}
public Server()
{
players = new List <Player>();
var config = new NetPeerConfiguration("networkGame")
{
Port = 4207
};
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
config.EnableMessageType(NetIncomingMessageType.Data);
server = new NetServer(config);
server.Start();
}
public void CheckForMessageAvailable()
{
NetIncomingMessage message;
NetServer server = ServerNetworkSceneComponent.GetNetServer();
if ((message = server.ReadMessage()) != null)
{
if (message.MessageType == NetIncomingMessageType.ConnectionApproval)
{
message.SenderConnection.Approve();
}
CheckForMessage(message);
}
}
public Server(int port)
{
config = new NetPeerConfiguration("cars");
config.Port = port;
config.MaximumConnections = MaxNumConnectedClients;
config.ConnectionTimeout = 15.0f;
Players = new RemotePlayerSet();
Players.SetNumSlots(MaxSlots);
Players.OnPlayerSetSlot += OnPlayerSetSlot;
Players.OnPlayerAdded += OnPlayerAdded;
Players.OnPlayerStatusChanged += OnPlayerStatusChanged;
server = new NetServer(config);
}
public NetworkServer()
: base(SEND_RATE)
{
instance = this;
is_server = true;
is_client = false;
host_id = 0;
host_id_counter = 0;
actor_id_counter = 0;
var config = CreateConfig();
config.Port = NetworkPeer.APP_PORT;
net_peer = netServer = new NetServer(config);
netServer.Start();
}
void Start()
{
GameObject.DontDestroyOnLoad(this);
GameObject.DontDestroyOnLoad(gameObject);
NetPeerConfiguration config = new NetPeerConfiguration("LidgrenDemo");
config.Port = port;
server = new NetServer(config);
server.Start();
SetPeer(server);
Connected += onConnected;
Disconnected += onDisconnected;
RegisterMessageHandler(LidgrenMessageHeaders.RequestSpawn, onRequestSpawn);
RegisterMessageHandler(LidgrenMessageHeaders.Movement, onMovement);
RegisterMessageHandler(LidgrenMessageHeaders.Position, onPosition);
}
/// <summary>
/// This will create a server socket on a random port, used to initiate a connection
/// we send address of this server to the remote server to connect using a client socket
/// The only exception is gateway socket that has no peerId (is null)
/// </summary>
/// <param name="_parentId"></param>
/// <param name="_peerId"></param>
public PeerSocket(ResponseHandlersCollection handlers, string _parentId, string _peerId)
{
responseHandlers = handlers;
parentId = _parentId;
peerId = _peerId;
string myName = "";
if (peerId == null)
{
myName = _parentId + ".Gateway";
}
else
{
myName = parentId + "." + peerId + ".Server";
}
serverSocket = new NetServer(myName);
serverSocket.OnReceived += new NetClientReceivedEventHandler<byte[]>(onServerReceiveData);
serverSocket.Start(IPAddress.Parse(defaultHost), random.Next(1025, 65500));
}
public void Dispose()
{
//if client is sending some data, wait for finish
if (clientSocket != null)
{
clientSocket.Disconnect();
clientSocket = null;
}
if (serverSocket != null)
{
serverSocket.DisconnectAll();
serverSocket.Stop();
serverSocket = null;
}
}
static void Main(string[] args)
{
int loopStartTime = 0;
int loopEndTime = 0;
float deltaSecond = 0;
//Frequency to return data
const float ReturnDataPerSecond = 20;
float lastSentData = 0;
//Team containers
ShapeTeamContainer greenTeam = new ShapeTeamContainer(ShapeTeam.GREEN);
ShapeTeamContainer redTeam = new ShapeTeamContainer(ShapeTeam.RED);
NetPeerConfiguration config = new NetPeerConfiguration("ShapeSpace");
config.Port = 55678;
config.MaximumConnections = maxPlayers;
config.ConnectionTimeout = 10;
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
server = new NetServer(config);
//Console.WriteLine(server.Configuration.LocalAddress);
physicsWorld = new World(Vector2.Zero);
//50px = 1m
ConvertUnits.SetDisplayUnitToSimUnitRatio(50f);
try
{
server.Start();
}
catch(Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(e);
Console.ForegroundColor = ConsoleColor.White;
WaitForKeyPress();
}
Console.WriteLine("Server Started Sucessfully!");
//Main program loop
while(true)
{
deltaSecond = (loopEndTime - loopStartTime) / 1000f;
lastSentData += deltaSecond;
loopStartTime = Environment.TickCount;
//Handle incoming messages
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
//Console.WriteLine(msg.MessageType);
switch (msg.MessageType)
{
case NetIncomingMessageType.Data:
//A swith handling ShapeSpace custom message types
switch((ShapeCustomNetMessageType)msg.ReadByte())
{
case ShapeCustomNetMessageType.InputUpdate:
int playerIndex = msg.ReadInt32();
float timeSinceLast = msg.ReadFloat();
Vector2 input = msg.ReadVector2();
connectedPlayers[playerIndex].inputs.Add(new InputWithTime(timeSinceLast,input));
//Console.WriteLine(timeSinceLast + ": " + input.ToString());
break;
case ShapeCustomNetMessageType.SetupRequest:
NetOutgoingMessage returnMessage = server.CreateMessage();
NetworkPlayer newPlayer = new NetworkPlayer(physicsWorld, msg.SenderConnection, new Vector2(0,0));
//ShapeTeam team = (ShapeTeam)msg.ReadByte();
string username = msg.ReadString();
try
{
//newPlayer.SetTeam(team);
newPlayer.SetUserName(username);
int spot = AddNewPlayer(newPlayer);
newPlayer.indexOnServer = spot;
//Assign the new player to the team with the least amount of players
ShapeTeamContainer newPlayerTeam = greenTeam.GetNumberOfMembers() < redTeam.GetNumberOfMembers() ? greenTeam : redTeam;
bool isBank = newPlayerTeam.AddPlayer(newPlayer.indexOnServer);
newPlayer.SetTeam(newPlayerTeam.GetTeam());
newPlayer.body.Position = ConvertUnits.ToSimUnits(newPlayerTeam.basePosition);
if (isBank)
newPlayer.SetClass(new ShapeClassBank());
else
newPlayer.SetClass(new ShapeClassKnocker());
newPlayer.OnCreateRemnant += CreateRemnant;
}
catch(Exception e)
{
returnMessage.Write((byte)ShapeCustomNetMessageType.SetupFailed);
returnMessage.Write(e.Message);
server.SendMessage(returnMessage, newPlayer.netConnection, NetDeliveryMethod.ReliableUnordered);
break;
}
returnMessage.Write((byte)ShapeCustomNetMessageType.SetupSuccessful);
returnMessage.Write(newPlayer.indexOnServer);
returnMessage.Write((byte)newPlayer.team);
returnMessage.Write(connectedPlayersActual);
for (int i = 0; i < connectedPlayers.Length; i++)
{
if(connectedPlayers[i] != null)
{
returnMessage.Write(connectedPlayers[i].indexOnServer);
returnMessage.Write((byte)connectedPlayers[i].team);
returnMessage.Write(connectedPlayers[i].power);
}
}
server.SendMessage(returnMessage, newPlayer.netConnection, NetDeliveryMethod.ReliableUnordered);
if(connectedPlayersActual > 1)
{
NetOutgoingMessage newPlayerMessage = server.CreateMessage();
newPlayerMessage.Write((byte)ShapeCustomNetMessageType.NewPlayerJoined);
newPlayerMessage.Write(newPlayer.indexOnServer);
newPlayerMessage.Write((byte)newPlayer.team);
newPlayerMessage.Write(/*newPlayer.power*/5);
server.SendMessage(newPlayerMessage, GetRecipients(newPlayer.indexOnServer), NetDeliveryMethod.ReliableUnordered, 0);
}
Console.WriteLine("Player connected");
break;
}
break;
case NetIncomingMessageType.DiscoveryRequest:
NetOutgoingMessage response = server.CreateMessage();
response.Write("This is a Shape Space server");
server.SendDiscoveryResponse(response, msg.SenderEndPoint);
break;
case NetIncomingMessageType.ConnectionApproval:
Console.WriteLine("A client is asking to connect");
//Approve the connection and send back a hailmessage containing server info back
NetOutgoingMessage hailMessage = server.CreateMessage();
hailMessage.Write(maxPlayers);
msg.SenderConnection.Approve(hailMessage);
break;
case NetIncomingMessageType.StatusChanged:
if(msg.ReadByte() == (byte)NetConnectionStatus.Disconnected)
{
//Console.WriteLine("Player disconnected: " + FindPlayerByNetConnection(msg.SenderConnection).Username);
RemovePlayer(msg.SenderConnection);
}
break;
default:
Console.WriteLine("Unhandled type: " + msg.MessageType + " Info: \"" + msg.ReadString() + "\"");
break;
}
server.Recycle(msg);
}
//Move players
UpdatePlayers(deltaSecond);
//Simulate the world
physicsWorld.Step(1f/100f);
//Return data to clients
if (lastSentData >= 1f/ReturnDataPerSecond && connectedPlayersActual > 0)
{
//List<NetConnection> recipients = new List<NetConnection>();
NetOutgoingMessage outMess = server.CreateMessage();
outMess.Write((byte)ShapeCustomNetMessageType.LocationUpdate);
outMess.Write(connectedPlayersActual);
for (int i = 0; i < maxPlayers; i++)
{
if (connectedPlayers[i] != null)
{
outMess.Write(connectedPlayers[i].indexOnServer);
outMess.Write(connectedPlayers[i].power);
outMess.Write(lastSentData);
outMess.Write(ConvertUnits.ToDisplayUnits(connectedPlayers[i].body.Position));
int trailCount = connectedPlayers[i].trail.Count;
outMess.Write(trailCount);
for(int j = 0; j < trailCount; j++)
{
//outMess.Write(connectedPlayers[i].trail[j].Id);
outMess.Write(connectedPlayers[i].trail[j].position);
outMess.Write(connectedPlayers[i].trail[j].size);
}
}
}
//Write all remnants positions
int remnantCount = remnants.Count;
outMess.Write(remnantCount);
for (int j = 0; j < remnantCount; j++)
{
outMess.Write(remnants[j].position);
outMess.Write(remnants[j].size);
}
server.SendMessage(outMess, GetRecipients(-1), NetDeliveryMethod.UnreliableSequenced, 2);
lastSentData = 0;
}
//Make sure the server runs at about 60 frames per second
if(deltaSecond * 1000 < 1000/17)
Thread.Sleep(Convert.ToInt32(1000/17 - deltaSecond * 1000));
loopEndTime = Environment.TickCount;
}
}
/// <summary>
/// Runs network test to determine interface functionality status. Currently has bug where running twice crashes.
/// </summary>
/// <returns>The local test.</returns>
/// <param name="args">Arguments.</param>
public string FullLocalTest( params string[] args )
{
int port = Random.Range( 100 , 99999 );
int maxUsers = Random.Range( 2 , 100 );
string ip = "127.0.0.1";
Debug.Log ("FullLocalTest() START : Port( " + port.ToString () + " ) MaxUsers( " + maxUsers.ToString() + ")");
mServer = NetManager.CreateServer( maxUsers , port );
mServer.OnMessage = OnServerMessage;
if(mServer == null){ Debug.Log ("FullLocalTest() ERROR : Server instance not created!" ); return ""; }
if(!NetUtils.IsSocketValid( mServer.mSocket )){ Debug.Log ("FullLocalTest() ERROR : Server socket invalid!" ); return ""; }
if(!mServer.mIsRunning){ Debug.Log ("FullLocalTest() ERROR : Server is not running after create server called!" ); return ""; }
Debug.Log ("FullLocalTest() : Server started successfully!");
mClient = NetManager.CreateClient ();
if(mClient == null){ Debug.Log ("FullLocalTest() ERROR : Client instance not created!" ); return ""; }
if(!NetUtils.IsSocketValid ( mClient.mSocket ) ){ Debug.Log ("FullLocalTest() ERROR : Client socket invalid!"); return ""; }
mClient.OnMessage = OnClientMessage;
Debug.Log ("FullLocalTest() : Client started successfully!");
if(! mClient.Connect ( ip , port ) ){ Debug.Log ("FullLocalTest() ERROR : Client connect failed!"); return ""; }
// Now we go to our On*Message delegates to do the rest of the testing
return "";
}
/// <summary>
/// Destroys the server.
/// </summary>
/// <returns><c>true</c>, if server was destroyed, <c>false</c> otherwise.</returns>
/// <param name="s">NetServer to destroy</param>
public static bool DestroyServer( NetServer s )
{
if( mServers.Contains (s) == false){
Debug.Log ("NetManager::DestroyServer( " + s.mSocket.ToString() + ") - Server does not exist!");
return false;
}
NetworkTransport.RemoveHost( s.mSocket );
mServers.Remove( s );
return true;
}
private static Task StartServer()
{
NetPeerConfiguration config = new NetPeerConfiguration("Kludge");
config.MaximumConnections = 100;
config.Port = 14343;
config.AutoFlushSendQueue = true;
NetPeer peer = new NetServer(config);
network = new NetworkManager(peer);
network.Connected += OnConnected;
network.Disconnected += OnDisconnected;
network.OtherStatus += OnOtherStatus;
handler = new MessageHandler(network);
handler.RecommendationRequested += RecommendationRequested;
handler.RecommendationSelected += RecommendationSelected;
handler.ObjectsFreed += ObjectsFreed;
handler.Sentiments += SentimentsSent;
Task serverTask = new Task(() => RunServer(network));
serverTask.Start();
return serverTask;
}
/// <summary>
/// Console command for starting a server.
/// </summary>
public string ConsoleServerStart( params string[] args )
{
if( args.Length < 3 ){
return "Invalid Number of Arguments : server.start <maxconnections> <port>";
}
mServer = NetManager.CreateServer( int.Parse ( args[1] ) , int.Parse( args[2] ) );
if(mServer != null){
mServer.OnMessage = OnServerMessage;
return "Server is running!";
} else {
return "Server failed to start!";
}
}
