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 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();
}
public void Start()
{
server = new NetworkServerSimple();
serverOnClientConnect += ServerOnClientConnect;
serverOnClientDisconnect += ServerOnClientDisconnect;
serverOnData += ServerOnData;
server.RegisterHandler(MsgType.Connect, serverOnClientConnect);
server.RegisterHandler(MsgType.Disconnect, serverOnClientDisconnect);
server.RegisterHandler(TerminalMsgID, serverOnData);
client = new NetworkClient();
clientOnConnect += ClientOnConnect;
clientOnDisconnect += ClientOnDisconnect;
clientOnData += ClientOnData;
client.RegisterHandler(MsgType.Connect, clientOnConnect);
client.RegisterHandler(MsgType.Disconnect, clientOnDisconnect);
client.RegisterHandler(TerminalMsgID, clientOnData);
ConnectionConfig myConfig = new ConnectionConfig();
reliableChannelId = myConfig.AddChannel(QosType.Reliable);
unreliableChannelId = myConfig.AddChannel(QosType.Unreliable);
server.Configure(myConfig, maxConnections);
client.Configure(myConfig, maxConnections);
}
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);
}
}
void StopServer()
{
if (server != null)
{
server.Stop();
server = null;
}
}
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);
}
// 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);
}
void StartServer()
{
server = new NetworkServerSimple();
server.RegisterHandler(k_myMsg, OnMyMessage);
if (server.Listen(8848))
{
Debug.Log("Start listening port 8848");
}
}
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);
}
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);
}
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);
}
}
private void Start()
{
msgServer = new NetworkServerSimple();
msgClient = new NetworkClient();
if (useMsgServer)
{
StartNetServer();
}
if (useMsgClient)
{
StartNetClient();
}
}
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();
}
// Use this for initialization
void Start()
{
cube = GameObject.Find("Cube");
server = new NetworkServerSimple();
if (isServer)
{
SetupServer();
}
Physics.gravity = new Vector3(0, 0, 0);
ball = GameObject.CreatePrimitive(PrimitiveType.Sphere);
ball.transform.localScale = Vector3.one * 0.1f;
ball.transform.SetParent(cube.transform);
ball.transform.localPosition = new Vector3(0, 0, 0.5f);
ball.AddComponent <Rigidbody>();
}
void Awake()
{
if (instance == null)
{
instance = this;
}
else
{
UnityEngine.Debug.LogError("Only one instance of instance manager should exist");
Destroy(this.gameObject);
return;
}
server = new NetworkServerSimple();
slaves = new Dictionary <int, SlaveInfo>();
shuttingDownSlaves = new List <NetworkConnection>();
Initialize(Application.dataPath + "\\..\\config.json");
}
public void StopServer()
{
if (!isStarted)
{
return;
}
startedMutex.WaitOne();
isStarted = false;
server.Stop();
discovery.DoStop();
server = null;
HeadsetId = null;
TabletId = null;
startedMutex.ReleaseMutex();
}
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);
}
public void SetupServerMessages(NetworkServerSimple server)
{
server.RegisterHandler(MsgChatSendFromClient.MsgId, OnServerChatReceive);
server.RegisterHandler(MsgChatLoginRequestFromClient.MsgId, OnServerLoginRequest);
}
