/// <summary>
/// Reads network events and delegates how they are used
/// </summary>
public static void PollEvents()
{
// If nothing is running, why bother
if (mServers.Count < 1 && mClients.Count < 1)
{
return;
}
int recHostId;
int connectionId;
int channelId;
int dataSize;
byte[] buffer = new byte[1024];
byte error;
NetworkEventType networkEvent = NetworkEventType.DataEvent;
// Process network events for n clients and n servers
while (mIsInitialized && networkEvent != NetworkEventType.Nothing)
{
int i = -1; // Index for netserver in mservers
networkEvent = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, buffer, 1024, out dataSize, out error);
// Route message to our server delegate
i = mServers.FindIndex(x => x.mSocket == recHostId);
if (i != -1)
{
if (mServers[i].OnMessage != null)
{
mServers[i].OnMessage(networkEvent, connectionId, channelId, buffer, dataSize);
}
}
// Route message to our client delegate
// Client Connect Event
i = mClients.FindIndex(c => c.mSocket.Equals(recHostId));
if (i != -1)
{
if (mClients[i].OnMessage != null)
{
mClients[i].OnMessage(networkEvent, connectionId, channelId, buffer, dataSize);
}
}
switch (networkEvent)
{
// Nothing
case NetworkEventType.Nothing:
break;
// Connect
case NetworkEventType.ConnectEvent:
// Server Connect Event
i = mServers.FindIndex(s => s.mSocket.Equals(recHostId));
if (i != -1)
{
mServers[i].AddClient(connectionId);
if (mServers[i].OnConnection != null)
{
mServers[i].OnConnection(connectionId, channelId, buffer, dataSize);
}
}
// Client Connect Event
i = mClients.FindIndex(c => c.mSocket.Equals(recHostId));
if (i != -1)
{
mClients[i].mIsConnected = true; // Set client connected to true
if (mClients[i].OnConnection != null)
{
mClients[i].OnConnection(connectionId, channelId, buffer, dataSize);
}
}
break;
// Data
case NetworkEventType.DataEvent:
// Server received data
i = mServers.FindIndex(x => x.mSocket == recHostId);
if (i != -1)
{
if (mServers[i].OnData != null)
{
mServers[i].OnData(connectionId, channelId, buffer, dataSize);
}
}
// Client Received Data
i = mClients.FindIndex(c => c.mSocket.Equals(recHostId));
if (i != -1)
{
if (mClients[i].OnData != null)
{
mClients[i].OnData(connectionId, channelId, buffer, dataSize);
}
}
break;
// Disconnect
case NetworkEventType.DisconnectEvent:
// Server Disconnect Event
i = mServers.FindIndex(x => x.mSocket == recHostId);
if (i != -1)
{
mServers[i].RemoveClient(connectionId);
if (mServers[i].OnDisconnection != null)
{
mServers[i].OnDisconnection(connectionId, channelId, buffer, dataSize);
}
}
// Client Disconnect Event
i = mClients.FindIndex(c => c.mSocket.Equals(recHostId));
if (i != -1)
{
mClients[i].mIsConnected = false; // Set client connected to true
if (mClients[i].OnDisconnection != null)
{
mClients[i].OnDisconnection(connectionId, channelId, buffer, dataSize);
}
}
break;
}
}
}
void Destroy()
{
NetworkTransport.Shutdown();
}
public void Stop()
{
ServerStarted = false;
NetworkTransport.RemoveHost(m_hostID);
}
// Update is called once per frame
void Update()
{
// Incoming Connection IDs
int incomingSocketID = -1;
int incomingConnectionID = -1;
int incomingChannelID = -1;
byte[] incomingMessageBuffer = new byte[_incomingBufferSize];
int dataSize = 0;
byte error;
NetworkEventType incomingNetworkEvent = NetworkTransport.Receive(out incomingSocketID, out incomingConnectionID,
out incomingChannelID, incomingMessageBuffer, _incomingBufferSize, out dataSize, out error);
switch (incomingNetworkEvent)
{
case NetworkEventType.Nothing:
break;
case NetworkEventType.ConnectEvent:
Debug.Log("Master Server: new client connected");
++_numberOfConnections;
break;
case NetworkEventType.DataEvent:
string message = Encoding.UTF8.GetString(incomingMessageBuffer);
int prefix = 0;
int index;
string newMessage = "";
// New parser now allows client commands to be > 1 digit
for (index = 0; index < message.Length; ++index)
{
if (message[index] == '{')
{
break;
}
}
prefix = Convert.ToInt32(message.Substring(0, index));
newMessage = message.Substring(index);
// Have game servers register themselves.
if (prefix == (int)MasterServerCommands.RegisterGameServer)
{
Debug.Log("register a server");
foreach (KeyValuePair <string, GameInstanceStats> instance in _gameInstances)
{
if (instance.Value.serverID == 0)
{
instance.Value.serverID = JsonUtility.FromJson <PortID>(newMessage).portID;
instance.Value.socketID = incomingSocketID;
instance.Value.connectionID = incomingConnectionID;
instance.Value.channelID = incomingChannelID;
break;
}
}
}
else if (prefix == (int)MasterServerCommands.RegisterClient)
{
if (!_clients.ContainsKey(incomingConnectionID))
{
ClientInfo clientInfo = new ClientInfo(incomingSocketID, incomingConnectionID, incomingChannelID);
_clients.Add(incomingConnectionID, clientInfo);
Debug.Log(incomingConnectionID + " added to _clients");
}
}
//process login info
else if (prefix == (int)MasterServerCommands.C_VerifyLogin)
{
LoginInfo info = JsonUtility.FromJson <LoginInfo>(newMessage);
StartCoroutine(verifyLogin(info.username, info.password, incomingSocketID, incomingConnectionID, incomingChannelID));
}
//process create account info
else if (prefix == (int)MasterServerCommands.C_CreateAccount)
{
LoginInfo info = JsonUtility.FromJson <LoginInfo>(newMessage);
StartCoroutine(CreateUser(info.username, info.password, incomingSocketID, incomingConnectionID, incomingChannelID));
}
// Process game connection requests
else if (prefix == (int)MasterServerCommands.C_SelectGameInstance)
{
string serverName = JsonUtility.FromJson <ServerInfo>(newMessage).servername;
if (_gameInstances.ContainsKey(serverName.ToLower()))
{
// Connect client to an already existing game server.
if (_gameInstances[serverName].inGamePlayers < 4 && _gameInstances[serverName].openToConnections == true)
{
// Tells client that game is being created
string jsonToBeSent = "13";
jsonToBeSent += JsonUtility.ToJson("");
byte[] messageBuffer = Encoding.UTF8.GetBytes(jsonToBeSent);
NetworkTransport.Send(incomingSocketID, incomingConnectionID, incomingChannelID, messageBuffer, messageBuffer.Length, out error);
Debug.Log("Forwarding player to already established game: " + serverName);
StartCoroutine(ForwardPlayerToGame(serverName.ToLower(), _clients[incomingConnectionID]));
}
else
{
Debug.Log("In Game Players: " + _gameInstances[serverName].inGamePlayers);
Debug.Log("Open to new connections? " + _gameInstances[serverName].openToConnections);
string jsonToBeSent = "12";
jsonToBeSent += JsonUtility.ToJson("");
byte[] messageBuffer = Encoding.UTF8.GetBytes(jsonToBeSent);
NetworkTransport.Send(incomingSocketID, incomingConnectionID, incomingChannelID, messageBuffer, messageBuffer.Length, out error);
}
}
else
{
if (_numberOfGameInstances == _maxGameInstances)
{
Debug.Log("Maximum game instances reached.");
MaximumInstancesReached(_gameInstances, _clients[incomingConnectionID]);
}
else
{
// Create an instance of a game and have the client connect.
_numberOfGameInstances++;
_gameInstances.Add(serverName.ToLower(), new GameInstanceStats(serverName.ToLower()));
if (_enableAutomaticServerInstanceExecute)
{
System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
startInfo.FileName = _GameInstancePath;
System.Diagnostics.Process.Start(startInfo);
}
// Tells client that game is being created
string jsonToBeSent = "13";
jsonToBeSent += JsonUtility.ToJson("");
byte[] messageBuffer = Encoding.UTF8.GetBytes(jsonToBeSent);
NetworkTransport.Send(incomingSocketID, incomingConnectionID, incomingChannelID, messageBuffer, messageBuffer.Length, out error);
// Forwards player to game
StartCoroutine(ForwardPlayerToGameWithDelay(serverName.ToLower(), _clients[incomingConnectionID]));
}
}
}
else if (prefix == (int)MasterServerCommands.VerifyOccupancy)
{
int inGamePlayers = JsonUtility.FromJson <GameServerInfo>(newMessage).inGamePlayers;
string serverName = JsonUtility.FromJson <GameServerInfo>(newMessage).serverName;
Debug.Log("Verify Occupancy: " + serverName);
_gameInstances[serverName.ToLower()].inGamePlayers = inGamePlayers;
}
else if (prefix == (int)MasterServerCommands.GS_openToConnections)
{
GameInstanceStats gs = JsonUtility.FromJson <GameInstanceStats>(newMessage);
Debug.Log("OpenToConnections message received | " + gs.serverName);
_gameInstances[gs.serverName.ToLower()].openToConnections = true;
}
else if (prefix == (int)MasterServerCommands.GS_closedToConnections)
{
GameInstanceStats gs = JsonUtility.FromJson <GameInstanceStats>(newMessage);
Debug.Log("closedToConnections message received | " + gs.serverName);
_gameInstances[gs.serverName.ToLower()].openToConnections = false;
}
break;
case NetworkEventType.DisconnectEvent:
_numberOfConnections = --_numberOfConnections < 0 ? 0 : _numberOfConnections;
if (_activeusernames.Contains(_clients[incomingConnectionID].username))
{
_activeusernames.Remove(_clients[incomingConnectionID].username);
}
break;
}
}
void Awake()
{
try
{
NetworkTransport.Init();
serverConfig = new ConnectionConfig();
serverChannelId = serverConfig.AddChannel(QosType.StateUpdate); // QosType.UnreliableFragmented
serverConfig.MaxSentMessageQueueSize = 2048; // 128 by default
// start data server
serverTopology = new HostTopology(serverConfig, maxConnections);
serverHostId = NetworkTransport.AddHost(serverTopology, listenOnPort);
if (serverHostId < 0)
{
throw new UnityException("AddHost failed for port " + listenOnPort);
}
// add broadcast host
if (broadcastPort > 0)
{
broadcastHostId = NetworkTransport.AddHost(serverTopology, 0);
if (broadcastHostId < 0)
{
throw new UnityException("AddHost failed for broadcast discovery");
}
}
// set broadcast data
string sBroadcastData = string.Empty;
#if !UNITY_WSA
try
{
string strHostName = System.Net.Dns.GetHostName();
IPHostEntry ipEntry = Dns.GetHostEntry(strHostName);
IPAddress[] addr = ipEntry.AddressList;
string sHostInfo = "Host: " + strHostName;
for (int i = 0; i < addr.Length; i++)
{
if (addr[i].AddressFamily == AddressFamily.InterNetwork)
{
sHostInfo += ", IP: " + addr[i].ToString();
sBroadcastData = "KinectDataServer:" + addr[i].ToString() + ":" + listenOnPort;
break;
}
}
sHostInfo += ", Port: " + listenOnPort;
Debug.Log(sHostInfo);
if (serverStatusText)
{
serverStatusText.text = sHostInfo;
}
}
catch (System.Exception ex)
{
Debug.LogError(ex.Message + "\n\n" + ex.StackTrace);
if (serverStatusText)
{
serverStatusText.text = "Use 'ipconfig' to see the host IP; Port: " + listenOnPort;
}
}
#else
sBroadcastData = "KinectDataServer:" + "127.0.0.1" + ":" + listenOnPort;
#endif
// start broadcast discovery
if (broadcastPort > 0)
{
broadcastOutBuffer = System.Text.Encoding.UTF8.GetBytes(sBroadcastData);
byte error = 0;
if (!NetworkTransport.StartBroadcastDiscovery(broadcastHostId, broadcastPort, 8888, 1, 0, broadcastOutBuffer, broadcastOutBuffer.Length, 2000, out error))
{
throw new UnityException("Start broadcast discovery failed: " + (NetworkError)error);
}
}
liRelTime = 0;
fCurrentTime = Time.time;
System.DateTime dtNow = System.DateTime.UtcNow;
Debug.Log("Kinect data server started at " + dtNow.ToString() + " - " + dtNow.Ticks);
if (connStatusText)
{
connStatusText.text = "Server running: 0 connection(s)";
}
}
catch (System.Exception ex)
{
Debug.LogError(ex.Message + "\n" + ex.StackTrace);
if (connStatusText)
{
connStatusText.text = ex.Message;
}
}
}
public void Shutdown()
{
isStarted = false;
NetworkTransport.Shutdown();
}
public void InitNetworkTransport()
{
NetworkTransport.Init();
}
// Use this for initialization
void Start()
{
NetworkTransport.Init();
}
public void Disconnect()
{
NetworkTransport.Disconnect(hostID, connectionID, out error);
}
public void ServerStop()
{
NetworkTransport.RemoveHost(serverHostId);
serverHostId = -1;
Debug.Log("LLAPITransport.ServerStop");
}
private void Update()
{
if (!is_started)
{
return;
}
int recHostId;
int connectionId;
int channelId;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
NetworkEventType recData = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.ConnectEvent:
Debug.Log("Player:" + connectionId + " has connected!");
Onconnection(connectionId);
break;
case NetworkEventType.DataEvent:
string msg = Encoding.Unicode.GetString(recBuffer, 0, dataSize);
//Debug.Log("Receiving from" + connectionId + " : " + msg);
//Debug.Log("length is: " + msg.Length);
string[] splitData = msg.Split('|');
switch (splitData[0])
{
case "NAMEIS":
OnNameIs(connectionId, splitData[1]);
break;
case "MYROT":
OnMyRot(connectionId, splitData[1]);
break;
case "CALIS":
OnCALIS(connectionId, splitData[1]);
break;
default:
Debug.Log("Invalid Message : " + msg);
break;
}
break;
break;
case NetworkEventType.DisconnectEvent:
OnDisconnection(connectionId);
Debug.Log("Player:" + connectionId + " has disconnected");
break;
case NetworkEventType.BroadcastEvent:
break;
}
//Ask for rotation update
if (BoradCasting)
{
if (Time.time - lastRotationUpdate > UpdateRate)
{
if (BoradCasting_Changed)
{
Send("ONBC|", ReliableChannel, clients);
BoradCasting_Changed = false;
}
lastRotationUpdate = Time.time;
string m = "ROT|";
GameObject datamanager = GameObject.Find("DataManager");
Quaternion data = datamanager.GetComponent <DataManager>().RealSense_Rotation;
m += data.x.ToString() + '%' + data.y.ToString() + '%' + data.z.ToString() + '%' + data.w.ToString() + '%';
data = datamanager.GetComponent <DataManager>().Inertia_Rotation;
m += data.x.ToString() + '%' + data.y.ToString() + '%' + data.z.ToString() + '%' + data.w.ToString() + '%';
m += '|';
Send(m, UnreliableChannel, clients);
}
}
if (!BoradCasting)
{
if (BoradCasting_Changed)
{
Send("OFFBC|", ReliableChannel, clients);
BoradCasting_Changed = false;
}
}
}
public float ClientGetRTT()
{
return(NetworkTransport.GetCurrentRTT(clientId, clientConnectionId, out error));
}
private void Update()
{
if (!isConnected)
{
return;
}
int recHostId;
int connectionId;
int channelId;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
NetworkEventType recData = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.DataEvent:
string msg = Encoding.Unicode.GetString(recBuffer, 0, dataSize);
//Debug.Log ("Receiving : " + msg);
string[] splitData = msg.Split('|');
//Filter out asking for coordinate updates, cluttering up debug log
if (splitData[0] != "ASKPOSITION" && splitData[0] != "ASKROTATION")
{
Debug.Log("Receiving from server: " + msg);
}
switch (splitData[0])
{
case "ASKNAME":
OnAskName(splitData);
break;
case "CNN":
SpawnPlayer(splitData [1], int.Parse(splitData [2]));
break;
case "DC":
PlayerDisconnected(int.Parse(splitData[1]));
break;
case "ASKPOSITION":
OnAskPosition(splitData);
break;
case "ASKROTATION":
OnAskRotation(splitData);
break;
case "ASKANIMATION":
OnAskAnimation(splitData);
break;
case "ASKCURRENTHEALTH":
OnAskCurrentHealth(splitData);
break;
case "PROJECTILESPAWNED":
OnProjectileWasSpawned(splitData);
break;
default:
Debug.Log("Invalid message : " + msg);
break;
}
break;
}
}
/// <summary>
/// Initialize our low level network APIs.
/// </summary>
public static void Init()
{
NetworkTransport.Init(mGlobalConfig);
mIsInitialized = true;
}
public override bool ServerDisconnect(int connectionId)
{
return(NetworkTransport.Disconnect(serverHostId, connectionId, out error));
}
public void sendMessage(string message)
{
byte[] buffer = Encoding.Unicode.GetBytes(message);
NetworkTransport.Send(hostID, connectionID, reliableChannelID, buffer, message.Length * sizeof(char), out error);
}
void Awake()
{
NetworkTransport.Init(globalConfig);
Debug.Log("LLAPITransport initialized!");
}
void fresh()
{
int outHostId;
int outConnectionId;
int outChannelId;
string outConnIp;
int outPort;
NetworkID outID;
NodeID outNode;
int receivedSize;
byte error;
int quesize;
NetworkEventType evt;
int dog = 0;
do
{
dog++;
evt =
NetworkTransport.Receive(out outHostId, out outConnectionId, out outChannelId, buffer, buffer.Length, out receivedSize, out error);
quesize = NetworkTransport.GetIncomingMessageQueueSize(outHostId, out error);
if (error != 0)
{
Debug.LogError("Receive error=" + error + "quesize=" + quesize);
}
switch (evt)
{
case NetworkEventType.ConnectEvent:
{
NetworkTransport.GetConnectionInfo(outHostId, outConnectionId, out outConnIp, out outPort, out outID, out outNode, out error);
connectionClient.Add(outConnectionId, new StrTxt(Instantiate(text), outConnIp, true));
OnConnect(outHostId, outConnectionId, (NetworkError)error);
break;
}
case NetworkEventType.DisconnectEvent:
{
OnDisconnect(outHostId, outConnectionId, (NetworkError)error);
break;
}
case NetworkEventType.DataEvent:
{
OnData(outHostId, outConnectionId, outChannelId, ref buffer, receivedSize, (NetworkError)error);
break;
}
case NetworkEventType.BroadcastEvent:
{
OnBroadcast(outHostId, buffer, receivedSize, (NetworkError)error);
break;
}
case NetworkEventType.Nothing:
break;
default:
Debug.LogError("Unknown network message type received: " + evt);
break;
}
}while (dog < 30 && quesize != 0);
}
private static NetworkEventType BaseReceive(NetworkEventType @event, int hostId, ref int connectionId, ref int channelId, byte[] buffer, int bufferSize, ref int receivedSize, ref byte error)
{
switch (@event)
{
case NetworkEventType.DataEvent:
MessageType messageType = (MessageType)buffer[receivedSize - 1];
switch (messageType)
{
case MessageType.ConnectToServer: // Connection approved
{
if (!isClient)
{
connectionId = (ushort)(buffer[receivedSize - 3] | (buffer[receivedSize - 2] << 8)); // Parse connection id
}
return(NetworkEventType.ConnectEvent);
}
case MessageType.Data:
{
// Implicitly remove header
if (isClient)
{
--receivedSize;
}
else
{
connectionId = buffer.FromBytes(receivedSize -= 3);
}
return(NetworkEventType.DataEvent);
}
case MessageType.ClientDisconnect:
{
connectionId = (ushort)(buffer[0] | (buffer[1] << 8)); // Parse connection id
return(NetworkEventType.DisconnectEvent);
}
}
break;
case NetworkEventType.ConnectEvent:
{
if (isClient)
{
//Connect via relay
string s = new StringBuilder(address).Append(':').Append(port).ToString();
buffer[s.Length] = (byte)MessageType.ConnectToServer;
// Address data length is implied
for (int i = 0; i < s.Length; i++)
{
buffer[i] = (byte)s[i]; // Get ASCII characters
}
NetworkTransport.Send(hostId, connectionId, GetReliableChannel(), buffer, s.Length + 1, out error);
}
else
{
//Register us as a server
buffer[0] = (byte)MessageType.StartServer;
NetworkTransport.Send(hostId, connectionId, GetReliableChannel(), buffer, 1, out error);
}
return(NetworkEventType.Nothing); // Connect event is ignored
}
case NetworkEventType.DisconnectEvent:
{
if ((NetworkError)error == NetworkError.CRCMismatch)
{
Debug.LogError("[MLAPI.Relay] The MLAPI Relay detected a CRC mismatch. This could be due to the maxClients or other connectionConfig settings not being the same");
}
return(NetworkEventType.DisconnectEvent);
}
}
return(@event);
}
private void Update()
{
if (!isStarted)
{
return;
}
int recHostId;
int connectionId;
int channelId;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
NetworkEventType recData = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.ConnectEvent: //2
Debug.Log("Player " + connectionId + " has connected");
OnConnection(connectionId);
break;
case NetworkEventType.DataEvent: //3
string msg = Encoding.Unicode.GetString(recBuffer, 0, dataSize);
Debug.Log("Receiving from " + connectionId + " : " + msg);
string[] splitData = msg.Split('|');
switch (splitData[0])
{
case "NAMEIS":
OnNameIs(connectionId, splitData[1]);
break;
case "MYPOSITION":
OnMyPosition(connectionId, float.Parse(splitData[1]), float.Parse(splitData[2]), float.Parse(splitData[3]));
break;
case "CHATMSG":
OnChatMessage(connectionId, splitData[2], splitData[3]);
break;
default:
Debug.Log("Invalid message : " + msg);
break;
}
break;
case NetworkEventType.DisconnectEvent: //4
Debug.Log("Player " + connectionId + " has disconnected");
OnDisconnection(connectionId);
break;
}
//ask player for position
if (Time.time - lastMovementUpdate > movementUpdateRate)
{
lastMovementUpdate = Time.time;
string m = "ASKPOSITION|";
foreach (ServerClient sc in clients)
{
m += sc.connectionId.ToString() + '%' + sc.position.x.ToString() + '%' + sc.position.y.ToString() + '%' + sc.position.z.ToString() + '|';
}
m = m.Trim('|');
Send(m, unreliableChannel, clients);
}
}
public void ShutdownNetworkTransport()
{
NetworkTransport.Shutdown();
}
public void ShutDown()
{
NetworkTransport.Shutdown();
isStarted = false;
Debug.Log("network shutdown");
}
void Update()
{
int recHostId;
int connectionId;
int recChannelId;
int dataSize;
bool connListUpdated = false;
if (backgroundImage && backgroundImage.texture == null)
{
backgroundImage.texture = manager ? manager.GetUsersLblTex() : null;
}
// if(faceManager == null)
// {
// faceManager = FacetrackingManager.Instance;
// }
if (gestureManager == null)
{
gestureManager = VisualGestureManager.Instance;
}
if (speechManager == null)
{
speechManager = SpeechManager.Instance;
}
try
{
byte error = 0;
NetworkEventType recData = NetworkTransport.Receive(out recHostId, out connectionId, out recChannelId, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.Nothing: //1
break;
case NetworkEventType.ConnectEvent: //2
if (recHostId == serverHostId && recChannelId == serverChannelId &&
!dictConnection.ContainsKey(connectionId))
{
HostConnection conn = new HostConnection();
conn.hostId = recHostId;
conn.connectionId = connectionId;
conn.channelId = recChannelId;
conn.keepAlive = true;
conn.reqDataType = "ka,kb,km,kh";
//conn.matrixSent = false;
dictConnection[connectionId] = conn;
connListUpdated = true;
//Debug.Log(connectionId + "-conn: " + conn.reqDataType);
}
// // reset chunked face messages
// sendFvMsg = string.Empty;
// sendFvNextOfs = 0;
//
// sendFtMsg = string.Empty;
// sendFtNextOfs = 0;
break;
case NetworkEventType.DataEvent: //3
if (recHostId == serverHostId && recChannelId == serverChannelId &&
dictConnection.ContainsKey(connectionId))
{
HostConnection conn = dictConnection[connectionId];
int decompSize = 0;
if (decompressor != null && (recBuffer[0] > 127 || recBuffer[0] < 32))
{
decompSize = decompressor.Decompress(recBuffer, 0, compressBuffer, 0, dataSize);
}
else
{
System.Buffer.BlockCopy(recBuffer, 0, compressBuffer, 0, dataSize);
decompSize = dataSize;
}
string sRecvMessage = System.Text.Encoding.UTF8.GetString(compressBuffer, 0, decompSize);
if (sRecvMessage.StartsWith("ka"))
{
if (sRecvMessage == "ka") // vr-examples v1.0 keep-alive message
{
sRecvMessage = "ka,kb,km,kh";
}
conn.keepAlive = true;
conn.reqDataType = sRecvMessage;
dictConnection[connectionId] = conn;
//Debug.Log(connectionId + "-recv: " + conn.reqDataType);
// check for SR phrase-reset
int iIndexSR = sRecvMessage.IndexOf(",sr");
if (iIndexSR >= 0 && speechManager)
{
speechManager.ClearPhraseRecognized();
//Debug.Log("phrase cleared");
}
}
}
break;
case NetworkEventType.DisconnectEvent: //4
if (dictConnection.ContainsKey(connectionId))
{
dictConnection.Remove(connectionId);
connListUpdated = true;
}
break;
}
if (connListUpdated)
{
// get all connection IDs
alConnectionId.Clear();
alConnectionId.AddRange(dictConnection.Keys);
// display the number of connections
StringBuilder sbConnStatus = new StringBuilder();
sbConnStatus.AppendFormat("Server running: {0} connection(s)", dictConnection.Count);
foreach (int connId in dictConnection.Keys)
{
HostConnection conn = dictConnection[connId];
int iPort = 0; string sAddress = string.Empty; NetworkID network; NodeID destNode;
NetworkTransport.GetConnectionInfo(conn.hostId, conn.connectionId, out sAddress, out iPort, out network, out destNode, out error);
if (error == (int)NetworkError.Ok)
{
sbConnStatus.AppendLine().Append(" ").Append(sAddress).Append(":").Append(iPort);
}
}
Debug.Log(sbConnStatus);
if (connStatusText)
{
connStatusText.text = sbConnStatus.ToString();
}
}
// send body frame to available connections
const char delimiter = ',';
string sBodyFrame = manager ? manager.GetBodyFrameData(ref liRelTime, ref fCurrentTime, delimiter) : string.Empty;
if (sBodyFrame.Length > 0 && dictConnection.Count > 0)
{
StringBuilder sbSendMessage = new StringBuilder();
sbSendMessage.Append(manager.GetWorldMatrixData(delimiter)).Append('|');
sbSendMessage.Append(sBodyFrame).Append('|');
sbSendMessage.Append(manager.GetBodyHandData(ref liRelTime, delimiter)).Append('|');
if (gestureManager && gestureManager.IsVisualGestureInitialized())
{
sbSendMessage.Append(gestureManager.GetGestureDataAsCsv(delimiter)).Append('|');
}
if (speechManager && speechManager.IsSapiInitialized())
{
sbSendMessage.Append(speechManager.GetSpeechDataAsCsv(delimiter)).Append('|');
}
if (sbSendMessage.Length > 0 && sbSendMessage[sbSendMessage.Length - 1] == '|')
{
sbSendMessage.Remove(sbSendMessage.Length - 1, 1);
}
byte[] btSendMessage = System.Text.Encoding.UTF8.GetBytes(sbSendMessage.ToString());
int compSize = 0;
if (compressor != null && btSendMessage.Length > 100)
{
compSize = compressor.Compress(btSendMessage, 0, btSendMessage.Length, compressBuffer, 0);
}
else
{
System.Buffer.BlockCopy(btSendMessage, 0, compressBuffer, 0, btSendMessage.Length);
compSize = btSendMessage.Length;
}
// // check face-tracking requests
// bool bFaceParams = false, bFaceVertices = false, bFaceUvs = false, bFaceTriangles = false;
// if(faceManager && faceManager.IsFaceTrackingInitialized())
// CheckFacetrackRequests(out bFaceParams, out bFaceVertices, out bFaceUvs, out bFaceTriangles);
//
// byte[] btFaceParams = null;
// if(bFaceParams)
// {
// string sFaceParams = faceManager.GetFaceParamsAsCsv();
// if(!string.IsNullOrEmpty(sFaceParams))
// btFaceParams = System.Text.Encoding.UTF8.GetBytes(sFaceParams);
// }
//
// // next chunk of data for face vertices
// byte[] btFaceVertices = null;
// string sFvMsgHead = string.Empty;
// GetNextFaceVertsChunk(bFaceVertices, bFaceUvs, ref btFaceVertices, out sFvMsgHead);
//
// // next chunk of data for face triangles
// byte[] btFaceTriangles = null;
// string sFtMsgHead = string.Empty;
// GetNextFaceTrisChunk(bFaceTriangles, ref btFaceTriangles, out sFtMsgHead);
foreach (int connId in alConnectionId)
{
HostConnection conn = dictConnection[connId];
if (conn.keepAlive)
{
conn.keepAlive = false;
dictConnection[connId] = conn;
if (conn.reqDataType != null && conn.reqDataType.Contains("kb,"))
{
//Debug.Log(conn.connectionId + "-sendkb: " + conn.reqDataType);
error = 0;
//if(!NetworkTransport.Send(conn.hostId, conn.connectionId, conn.channelId, btSendMessage, btSendMessage.Length, out error))
if (!NetworkTransport.Send(conn.hostId, conn.connectionId, conn.channelId, compressBuffer, compSize, out error))
{
string sMessage = "Error sending body data via conn " + conn.connectionId + ": " + (NetworkError)error;
Debug.LogError(sMessage);
if (serverStatusText)
{
serverStatusText.text = sMessage;
}
}
}
// if(bFaceParams && btFaceParams != null &&
// conn.reqDataType != null && conn.reqDataType.Contains("fp,"))
// {
// //Debug.Log(conn.connectionId + "-sendfp: " + conn.reqDataType);
//
// error = 0;
// if(!NetworkTransport.Send(conn.hostId, conn.connectionId, conn.channelId, btFaceParams, btFaceParams.Length, out error))
// {
// string sMessage = "Error sending face params via conn " + conn.connectionId + ": " + (NetworkError)error;
// Debug.LogError(sMessage);
//
// if(serverStatusText)
// {
// serverStatusText.text = sMessage;
// }
// }
// }
//
// if(bFaceVertices && btFaceVertices != null &&
// conn.reqDataType != null && conn.reqDataType.Contains("fv,"))
// {
// //Debug.Log(conn.connectionId + "-sendfv: " + conn.reqDataType + " - " + sFvMsgHead);
//
// error = 0;
// if(!NetworkTransport.Send(conn.hostId, conn.connectionId, conn.channelId, btFaceVertices, btFaceVertices.Length, out error))
// {
// string sMessage = "Error sending face verts via conn " + conn.connectionId + ": " + (NetworkError)error;
// Debug.LogError(sMessage);
//
// if(serverStatusText)
// {
// serverStatusText.text = sMessage;
// }
// }
// }
//
// if(bFaceTriangles && btFaceTriangles != null &&
// conn.reqDataType != null && conn.reqDataType.Contains("ft,"))
// {
// //Debug.Log(conn.connectionId + "-sendft: " + conn.reqDataType + " - " + sFtMsgHead);
//
// error = 0;
// if(!NetworkTransport.Send(conn.hostId, conn.connectionId, conn.channelId, btFaceTriangles, btFaceTriangles.Length, out error))
// {
// string sMessage = "Error sending face tris via conn " + conn.connectionId + ": " + (NetworkError)error;
// Debug.LogError(sMessage);
//
// if(serverStatusText)
// {
// serverStatusText.text = sMessage;
// }
// }
// }
}
}
}
}
catch (System.Exception ex)
{
Debug.LogError(ex.Message + "\n" + ex.StackTrace);
if (serverStatusText)
{
serverStatusText.text = ex.Message;
}
}
}
public override bool ClientSend(int channelId, byte[] data)
{
return(NetworkTransport.Send(clientId, clientConnectionId, channelId, data, data.Length, out error));
}
public static void SendSocketMessage(int socketID, int connectionId, int channel, byte[] buffer)
{
byte error;
NetworkTransport.Send(socketID, connectionId, channel, buffer, buffer.Length, out error);
}
public string ClientGetAddress()
{
NetworkTransport.GetConnectionInfo(serverHostId, clientId, out string address, out int port, out NetworkID networkId, out NodeID node, out error);
return(address);
}
protected void init(int port, int maxConnections)
{
var topology = getTopology(maxConnections);
_hostId = NetworkTransport.AddHost(topology, port);
}
public override bool ServerSend(int connectionId, int channelId, byte[] data)
{
return(NetworkTransport.Send(serverHostId, connectionId, channelId, data, data.Length, out error));
}
private IEnumerator Receiver()
{
int recSocketId, recConnectionId, recChannelId, recDataSize;
byte error = 0;
byte[] recBuffer = new byte[_bufferSize];
while (true)
{
NetworkEventType netEventType = NetworkTransport.Receive
(
out recSocketId,
out recConnectionId,
out recChannelId,
recBuffer,
_bufferSize,
out recDataSize,
out error
);
if (error != 0)
{
Debug.Log($"Error ID -> {error}");
}
else
{
switch (netEventType)
{
case NetworkEventType.Nothing:
{
yield return(null);
break;
}
case NetworkEventType.DataEvent:
{
OnDataReceived(recConnectionId, recChannelId, recBuffer, recDataSize);
break;
}
case NetworkEventType.ConnectEvent:
{
OnConnectedToServer(recConnectionId);
break;
}
case NetworkEventType.DisconnectEvent:
{
OnDisconnected(recSocketId, recConnectionId);
break;
}
default:
{
Debug.LogWarning($"Receiver -> Unrecognized Message Type [{netEventType.ToString()}]");
break;
}
}
if (error != 0)
{
Debug.Log($"Error ID -> {error}");
}
}
}
}
void FixedUpdate()
{
while (true)
{
int host;
int connection;
int channel;
int dataSize;
byte error;
NetworkEventType eventType = NetworkTransport.Receive(out host, out connection, out channel, buffer, BUFFER_SIZE, out dataSize, out error);
if (error != 0)
{
Debug.Log((NetworkError)error);
}
if (eventType == NetworkEventType.Nothing)
{
break;
}
switch (eventType)
{
case NetworkEventType.ConnectEvent:
Debug.Log("NEW CLIENT CONNECTED!");
clients.Add(new Client(connection));
break;
case NetworkEventType.DataEvent:
//Debug.Log ("Data recieved: " + buffer [0]);
//For a standing phone -beta, -gamma, alpha
alpha = ((buffer [0] << 8) | buffer [1]) / 10f;
beta = ((buffer [2] << 8) | buffer [3]) / 10f;
gamma = ((buffer [4] << 8) | buffer [5]) / 10f;
if (beta > 180)
{
beta -= 360;
}
if (gamma > 180)
{
gamma -= 360;
}
bool shouldCalibrate = buffer [6] == 1;
bool swipeLeft = buffer [7] == 1;
bool swipeRight = buffer [7] == 2;
bool swipeUp = buffer [7] == 3;
//Debug.Log (alpha + ", " + beta + ", " + gamma + ", shouldCalibrate=" + shouldCalibrate);
Client c = getClient(connection);
if (shouldCalibrate)
{
c.calibrate(alpha, beta, gamma);
Debug.Log("Calibrating.");
}
if (swipeLeft)
{
Debug.Log("left is detected");
materialIndex--;
if (materialIndex < 0)
{
materialIndex = materials.Length - 1;
}
}
if (swipeRight)
{
Debug.Log("RIGHT is detected");
materialIndex++;
if (materialIndex >= materials.Length)
{
materialIndex = 0;
}
}
if (swipeUp)
{
Debug.Log("UP is detected");
anim.SetInteger(intHash, 1);
}
for (int i = 0; i < leatherRenderers.Length; i++)
{
leatherRenderers [i].material = materials [materialIndex];
}
AnimatorStateInfo stateInfo = anim.GetCurrentAnimatorStateInfo(0);
if (stateInfo.nameHash == removeHash)
{
target = c.correct(alpha, beta, gamma);
}
break;
case NetworkEventType.DisconnectEvent:
Debug.Log("Client disconnected");
clients.Remove(getClient(connection));
break;
}
}
if (!Input.GetKey(KeyCode.Space))
{
float angle = Quaternion.Angle(currentRotation, target);
float sensitivity = 0.01f;
float v = angle * sensitivity;
currentRotation = Quaternion.Slerp(currentRotation, target, 0.5f * v / (v + 1.0f));
}
else
{
currentRotation = target;
}
if (Input.GetKey(KeyCode.K))
{
Debug.Log("Kicking " + clients.Count + " connected clients.");
for (int i = 0; i < clients.Count; i++)
{
byte error;
NetworkTransport.Disconnect(hostID, clients[i].getConnectionID(), out error);
}
clients.Clear();
}
if (clients.Count == 0)
{
anim.SetInteger(intHash, 0);
target = buildQuaternion(90, 0, 0);
}
gameObject.transform.SetPositionAndRotation(new Vector3(0, 0, 0), currentRotation);
}
