/// <summary>
/// Starts the game server.
/// </summary>
protected virtual void StartListening()
{
if (useNetworkManager)
{
DontDestroyOnLoad(gameObject);
var networkManager = NetworkManager.singleton as MasterServerNetworkManager;
Assert.IsTrue(networkManager != null, "A Master Server Network Manager was not found.");
networkManager.gameServer = this;
networkManager.networkAddress = gameServerIp;
networkManager.networkPort = gameServerPort;
networkManager.StartServer();
NetworkServer.RegisterHandler(GameServerNetworkProtocol.RequestGameServerRegistration, OnGameServerRegistrationRequested);
NetworkServer.RegisterHandler(BaseServerNetworkProtocol.SendPlayerData, OnPlayerInfoReceived);
}
else
{
webGLServer.SetNetworkConnectionClass <GameServerWebGLCustomNetworkConnection>();
webGLServer.useWebSockets = true;
webGLServer.RegisterHandler(MsgType.Connect, OnWebGLConnected);
webGLServer.RegisterHandler(MsgType.Disconnect, OnWebGLDisconnected);
webGLServer.Listen(gameServerIp, gameServerPort);
webGLHostId = webGLServer.serverHostId;
NetworkServer.Listen(gameServerIp, gameServerPort);
NetworkServer.RegisterHandler(GameServerNetworkProtocol.RequestGameServerRegistration, OnGameServerRegistrationRequested);
}
if (closeWhenEmpty)
{
StartCoroutine(CloseWhenEmptyService());
}
}
public IEnumerator TwoInstancesOfServerSimpleWorkInOneProcessTest()
{
NetworkClient.ShutdownAll();
NetworkServer.Reset();
server1 = new NetworkServerSimple();
server1.RegisterHandler(MsgType.Connect, OnServerConnect1);
server1.RegisterHandler(TestMsgId, OnServerMsg1);
server2 = new NetworkServerSimple();
server2.RegisterHandler(MsgType.Connect, OnServerConnect2);
server2.RegisterHandler(TestMsgId, OnServerMsg2);
Assert.IsTrue(server1.Listen(port1), "Server1 Listen failed");
Assert.IsTrue(server2.Listen(port2), "Server2 Listen failed");
client1 = new NetworkClient();
client1.RegisterHandler(MsgType.Connect, OnClientConnect1);
client1.RegisterHandler(TestMsgId, OnClientMsg1);
client2 = new NetworkClient();
client2.RegisterHandler(MsgType.Connect, OnClientConnect2);
client2.RegisterHandler(TestMsgId, OnClientMsg2);
client1.Connect("localhost", port1);
client2.Connect("localhost", port2);
while (actualMsgCount != expectedMsgCount)
{
yield return(null);
}
}
public void StartServer()
{
if (isStarted)
{
return;
}
startedMutex.WaitOne();
isStarted = true;
discovery.DoStart();
PairingState.Value = ServerPairingState.None;
server = new NetworkServerSimple();
server.RegisterHandler(MsgType.Connect, OnConnect);
server.RegisterHandler(MsgType.Disconnect, OnDisconnect);
server.RegisterHandler(PairingRequestMessage.GetCustomMsgType(), OnPairingRequest);
server.Listen(serverPort);
startedMutex.ReleaseMutex();
}
private void Awake()
{
Application.runInBackground = true;
Screen.sleepTimeout = SleepTimeout.NeverSleep;
Delay = 0f;
VRSettings.enabled = false;
Debug.Log("initialize server to listen on : " + port);
server = new NetworkServerSimple();
server.Listen(port);
server.RegisterHandler(MsgType.Connect, OnServerConnect);
server.RegisterHandler(MsgType.Disconnect, OnServerDisonnect);
server.RegisterHandler(CustomMsgType.Pong, OnPongResponse);
server.RegisterHandler(CustomMsgType.SyncVideoPlaybackTime, OnSyncVideoPlaybackTime);
#if UNITY_IOS
videoPlayer2.audioOutputMode = VideoAudioOutputMode.Direct;
#else
//Set Audio Output to AudioSource
audioSource = gameObject.AddComponent <AudioSource>();
videoPlayer2.audioOutputMode = VideoAudioOutputMode.AudioSource;
videoPlayer2.SetTargetAudioSource(0, audioSource);
#endif
//Assign the Audio from Video to AudioSource to be played
videoPlayer2.EnableAudioTrack(0, true);
PlayLoopVideo2();
}
public void Start()
{
_players = new List <PlayerData>();
_server = new NetworkServerSimple();
_server.RegisterHandler(MsgType.Connect, OnConnect);
_server.RegisterHandler(MsgType.Disconnect, OnDisconnect);
_server.RegisterHandler(WorldMessage.PlayerInput, OnPlayerInput);
_server.Listen(ServerPort);
}
void StartServer()
{
server = new NetworkServerSimple();
server.RegisterHandler(k_myMsg, OnMyMessage);
if (server.Listen(8848))
{
Debug.Log("Start listening port 8848");
}
}
// Use this for initialization
void Start()
{
server = new NetworkServerSimple();
server.RegisterHandler(MsgType.Connect, OnConnect);
server.RegisterHandler(MsgType.Disconnect, OnDisconnect);
server.RegisterHandler(NetMsg.StartCalibration, OnCalibration);
server.RegisterHandler(NetMsg.StartLeap, OnLeap);
server.Listen(serverPort);
}
private void StartNetServer()
{
serverOnClientConnect += ServerOnClientConnect;
serverOnClientDisconnect += ServerOnClientDisconnect;
msgServer.RegisterHandler(MsgType.Connect, serverOnClientConnect);
msgServer.RegisterHandler(MsgType.Disconnect, serverOnClientDisconnect);
msgServer.Listen(serverListenPort);
Debug.Log("Starting message server on port " + serverListenPort);
}
public void Initialize()
{
webGLServer = new NetworkServerSimple();
webGLServer.SetNetworkConnectionClass <WebGLCustomNetworkConnection>();
webGLServer.useWebSockets = true;
webGLServer.RegisterHandler(MsgType.Connect, this.OnWebGLConnected);
webGLServer.RegisterHandler(MsgType.Disconnect, this.OnWebGLDisconnected);
webGLServer.Listen(7777);
hostId = webGLServer.serverHostId;
_active = true;
}
void serverSetup()
{
server = new NetworkServerSimple();
server.RegisterHandler(MsgType.Connect, OnConnect);
server.RegisterHandler(MsgType.Disconnect, OnDisconnect);
server.RegisterHandler(AHMsg.SimpleMessage, OnSimpleMessage);
server.RegisterHandler(AHMsg.VoiceFileInfoMessage, OnVoiceFileInfoMessage);
server.RegisterHandler(AHMsg.VoiceFileMessage, OnVoiceFileMessage);
server.RegisterHandler(AHMsg.VoiceFileCompleteMessage, OnVoiceFileCompleteMessage);
server.RegisterHandler(AHMsg.ShakeMessage, OnShakeMessage);
server.Listen(serverPort);
}
public void SetupServer()
{
server.Listen(4444);
server.RegisterHandler(MsgType.Connect, OnClientConnected);
server.RegisterHandler(RotationMsgId, OnGetRotation);
server.RegisterHandler(SelectMsgId, OnSelect);
server.RegisterHandler(RecenterMsgId, Recenter);
//NetworkServer.Listen(4444);
//NetworkServer.RegisterHandler(MsgType.Connect, OnClientConnected);
//NetworkServer.RegisterHandler(RotationMsgId, OnGetRotation);
isAtStartup = false;
Debug.Log("Server Setup");
}
void Start()
{
server = new NetworkServerSimple();
server.RegisterHandler(MsgType.Connect, OnConnected);
server.RegisterHandler(DataType.Data, OnPos);
server.Initialize();
ConnectionConfig config = new ConnectionConfig();
config.AddChannel(QosType.Reliable);
server.Configure(config, 2);
server.Listen(25000);
Debug.Log("Server Listening on " + server.listenPort);
}
public virtual bool StartServer()
{
if (server != null)
{
return(true);
}
OnStartServer();
server = new NetworkServerSimple();
RegisterServerMessages();
server.useWebSockets = useWebSockets;
server.Configure(connectionConfig, maxConnections);
if (serverBindToIP && !string.IsNullOrEmpty(serverBindAddress))
{
isNetworkActive = server.Listen(serverBindAddress, networkPort);
}
else
{
isNetworkActive = server.Listen(networkPort);
}
return(isNetworkActive);
}
void StartServer()
{
if (server == null)
{
server = new NetworkServerSimple();
server.RegisterHandler(MsgType.Connect, OnConnect);
server.RegisterHandler(MsgType.Disconnect, OnDisconnect);
server.RegisterHandler(DirectiveMessage.GetCustomMsgType(), OnDirective);
server.RegisterHandler(RequestForGameInformationMessage.GetCustomMsgType(), OnRequestForGameInformation);
server.RegisterHandler(ReturnToDivergencePointRequestMessage.GetCustomMsgType(), OnReturnToDivergencePointRequest);
server.Listen(serverPort);
}
}
public void StartServer()
{
clientList = new Dictionary <string, ClientInfo>();
netServer = new NetworkServerSimple();
netServer.RegisterHandler(ClientConnect, OnServerClientConnected);
netServer.RegisterHandler(MsgType.Disconnect, OnClientDisconnected);
if (netServer.Listen(serverIP, serverListenPort))
{
Debug.Log("Started server on " + serverIP + ":" + serverListenPort);
}
}
// Use this for initialization
void Start()
{
NetworkReader read;
srv = new NetworkServerSimple();
ConnectionConfig config = new ConnectionConfig();
config.FragmentSize = 8;
config.PacketSize = 256;
config.MaxSentMessageQueueSize = 4;
config.MaxCombinedReliableMessageSize = 4;
config.WebSocketReceiveBufferMaxSize = 4;
config.AddChannel(QosType.ReliableSequenced);
config.AddChannel(QosType.Unreliable);
srv.Configure(config, 1);
srv.Listen(receiverPort);
NetworkClient cli = new NetworkClient();
srv.RegisterHandler(NetMsgId.hasGyro, (msg) => hasGyro = msg.reader.ReadBoolean());
srv.RegisterHandler(NetMsgId.hasVib, (msg) => hasVib = msg.reader.ReadBoolean());
srv.RegisterHandler(NetMsgId.hasAccel, (msg) => hasAccel = msg.reader.ReadBoolean());
srv.RegisterHandler(NetMsgId.hasCompass, (msg) => hasCompass = msg.reader.ReadBoolean());
srv.RegisterHandler(NetMsgId.inputFloat, InputFloat);
srv.RegisterHandler(NetMsgId.inputVector2, InputVector2);
srv.RegisterHandler(NetMsgId.inputVector3, InputVector3);
srv.RegisterHandler(NetMsgId.inputQuaternion, InputQuaternion);
srv.RegisterHandler(NetMsgId.inputGesture, InputGesture);
srv.RegisterHandler(NetMsgId.inputBool, InputBool);
StartCoroutine("WaitForDisconnection");
List <PDollarGestureRecognizer.Gesture> trainingSetList = new List <PDollarGestureRecognizer.Gesture>();
//Load pre-made gestures
TextAsset[] gesturesXml = Resources.LoadAll <TextAsset>("GestureSet/10-stylus-MEDIUM/");
foreach (TextAsset gestureXml in gesturesXml)
{
trainingSetList.Add(GestureIO.ReadGestureFromXML(gestureXml.text));
}
//Load user custom gestures
string[] filePaths = Directory.GetFiles(Application.persistentDataPath, "*.xml");
foreach (string filePath in filePaths)
{
trainingSetList.Add(GestureIO.ReadGestureFromFile(filePath));
}
trainingSet = trainingSetList.ToArray();
}
private void Initialize(string configPath)
{
LoadConfig(Application.dataPath + "\\..\\master-config.json");
isListenning = server.Listen(config.port);
Debug.Log("master started listenning for nodes");
server.RegisterHandler((short)CustomMessageTypes.StartInstanceRequest, netMsg => { HandleStartInstanceRequest(netMsg); });
server.RegisterHandler((short)CustomMessageTypes.InstanceSlaveConnectRequest, netMsg => { HandleSlaveConnectRequest(netMsg); });
server.RegisterHandler((short)CustomMessageTypes.InstanceSlaveShutdown, x => { HandleSlaveShutDown(x); });
server.RegisterHandler(MsgType.Disconnect, x => { HandleDisconnect(x); });
server.RegisterHandler((short)CustomMessageTypes.InstanceSlaveStartInstanceResponse, x =>
{
InstanceResponseData resp = x.ReadMessage <InstanceResponseData>();
print(resp);
});
}
/// <summary>
/// Unity's Start method.
/// </summary>
protected override void Start()
{
base.Start();
webGLServer.SetNetworkConnectionClass <MasterServerWebGLCustomNetworkConnection>();
webGLServer.useWebSockets = true;
webGLServer.RegisterHandler(MsgType.Connect, OnWebGLConnected);
webGLServer.RegisterHandler(MsgType.Disconnect, OnWebGLDisconnected);
webGLServer.Listen(ip, port);
webGLHostId = webGLServer.serverHostId;
var config = new ConnectionConfig();
config.AddChannel(QosType.ReliableSequenced);
config.AddChannel(QosType.Unreliable);
NetworkServer.Configure(config, maxPlayers > 0 ? maxPlayers : 1024);
NetworkServer.useWebSockets = false;
NetworkServer.Listen(ip, port);
}
public void MyStartBroadcast()
{
if (isClient)
{
StopBroadcast();
}
if (!didInit)
{
didInit = Initialize();
}
if (!passListening)
{
passListening = passServer.Listen(NATNetworkManager_PHP.singleton.passPort);
}
if (!passServer.handlers.ContainsKey(PassCheckId))
{
passServer.RegisterHandler(PassCheckId, PasswordCheckServer);
}
UpdateBroadcastData();
if (!isServer)
{
isServer = StartAsServer();
}
}
public void StartServer()
{
server.Listen(serverListenPort);
PrintUI("Server: Starting on port " + serverListenPort);
}
private void Start()
{
//setup:
broadcastPort = broadcastingPort;
broadcastData = ServerPort.ToString();
//set device id:
if (string.IsNullOrEmpty(customDeviceId))
{
GenerateID();
DeviceId = PlayerPrefs.GetString(_randomIdKey);
broadcastData += "_" + DeviceId;
}
else
{
broadcastData += "_" + customDeviceId;
}
//HACK: this is a fix for the broadcastData bug where Unity will combine different
//data if the length is different because they internally reuse this object
broadcastData += "~!~";
Init();
//configurations:
ConnectionConfig config = new ConnectionConfig();
PrimaryChannel = config.AddChannel(primaryQualityOfService);
SecondaryChannel = config.AddChannel(secondaryQualityOfService);
config.InitialBandwidth = initialBandwidth;
HostTopology topology = new HostTopology(config, maxConnections);
_server.Listen(ServerPort, topology);
//event hooks:
_server.RegisterHandler(MsgType.Connect, HandleConnect);
_server.RegisterHandler(MsgType.Disconnect, HandleDisconnect);
_server.RegisterHandler((short)NetworkMsg.FloatMsg, HandleFloat);
_server.RegisterHandler((short)NetworkMsg.FloatArrayMsg, HandleFloatArray);
_server.RegisterHandler((short)NetworkMsg.IntMsg, HandleInt);
_server.RegisterHandler((short)NetworkMsg.IntArrayMsg, HandleIntArray);
_server.RegisterHandler((short)NetworkMsg.Vector2Msg, HandleVector2);
_server.RegisterHandler((short)NetworkMsg.Vector2ArrayMsg, HandleVector2Array);
_server.RegisterHandler((short)NetworkMsg.Vector3Msg, HandleVector3);
_server.RegisterHandler((short)NetworkMsg.Vector3ArrayMsg, HandleVector3Array);
_server.RegisterHandler((short)NetworkMsg.QuaternionMsg, HandleQuaternion);
_server.RegisterHandler((short)NetworkMsg.QuaternionArrayMsg, HandleQuaternionArray);
_server.RegisterHandler((short)NetworkMsg.Vector4Msg, HandleVector4);
_server.RegisterHandler((short)NetworkMsg.Vector4ArrayMsg, HandleVector4Array);
_server.RegisterHandler((short)NetworkMsg.RectMsg, HandleRect);
_server.RegisterHandler((short)NetworkMsg.RectArrayMsg, HandleRectArray);
_server.RegisterHandler((short)NetworkMsg.StringMsg, HandleString);
_server.RegisterHandler((short)NetworkMsg.StringArrayMsg, HandleStringArray);
_server.RegisterHandler((short)NetworkMsg.ByteMsg, HandleByte);
_server.RegisterHandler((short)NetworkMsg.ByteArrayMsg, HandleByteArray);
_server.RegisterHandler((short)NetworkMsg.ColorMsg, HandleColor);
_server.RegisterHandler((short)NetworkMsg.ColorArrayMsg, HandleColorArray);
_server.RegisterHandler((short)NetworkMsg.Color32Msg, HandleColor32);
_server.RegisterHandler((short)NetworkMsg.Color32ArrayMsg, HandleColor32Array);
_server.RegisterHandler((short)NetworkMsg.RectByteArrayMsg, HandleRectByteArray);
_server.RegisterHandler((short)NetworkMsg.BoolMsg, HandleBool);
_server.RegisterHandler((short)NetworkMsg.BoolArrayMsg, HandleBoolArray);
//dont destroy:
transform.parent = null;
DontDestroyOnLoad(gameObject);
}
