public void Core()
{
if (this.isClientBroadcasting)
{
NetworkEventType dataEvent = NetworkEventType.DataEvent;
while (this.isClientBroadcasting && (dataEvent != NetworkEventType.Nothing))
{
dataEvent = NetworkTransport.ReceiveFromHost(this._clientHostID, out this._recvConnID, out this._recvChannelID, this._recvBuffer, this._recvBuffer.Length, out this._recvDataSize, out this._recvErr);
if (dataEvent == NetworkEventType.BroadcastEvent)
{
string str;
int num;
string str2;
int num2;
NetworkTransport.GetBroadcastConnectionMessage(this._clientHostID, this._recvBuffer, this._recvBuffer.Length, out this._recvDataSize, out this._recvErr);
this.CheckNetError(this._recvErr, NetworkEventType.Nothing);
NetworkTransport.GetBroadcastConnectionInfo(this._clientHostID, out str, out num, out this._recvErr);
this.CheckNetError(this._recvErr, NetworkEventType.Nothing);
this.ParseServerTuple(this._recvBuffer, this._recvDataSize, out str2, out num2);
if (str2 == "<ANY>")
{
str2 = str;
}
if (this.onClientDiscoveredServer != null)
{
this.onClientDiscoveredServer(str2, num2);
}
}
}
}
}
void Update()
{
if (hostId == -1)
{
return;
}
if (m_IsServer)
{
return;
}
int connectionId;
int channelId;
int receivedSize;
byte error;
NetworkEventType networkEvent = NetworkEventType.DataEvent;
do
{
networkEvent = NetworkTransport.ReceiveFromHost(hostId, out connectionId, out channelId, msgInBuffer, kMaxBroadcastMsgSize, out receivedSize, out error);
if (networkEvent == NetworkEventType.BroadcastEvent)
{
NetworkTransport.GetBroadcastConnectionMessage(hostId, msgInBuffer, kMaxBroadcastMsgSize, out receivedSize, out error);
string senderAddr;
int senderPort;
NetworkTransport.GetBroadcastConnectionInfo(hostId, out senderAddr, out senderPort, out error);
OnReceivedBroadcast(senderAddr, BytesToString(msgInBuffer));
}
} while (networkEvent != NetworkEventType.Nothing);
}
void PollBroadCastEvent()
{
int connectionId;
int channelId;
int receivedSize;
byte error;
byte[] buffer = new byte[1024];
NetworkEventType networkEvent = NetworkEventType.DataEvent;
do
{
networkEvent = NetworkTransport.ReceiveFromHost(broadcastHostId, out connectionId, out channelId, msgInBuffer, maxBroadcastMsgSize, out receivedSize, out error);
if (networkEvent == NetworkEventType.BroadcastEvent)
{
NetworkTransport.GetBroadcastConnectionMessage(broadcastHostId, msgInBuffer, maxBroadcastMsgSize, out receivedSize, out error);
string senderAddr;
int senderPort;
NetworkTransport.GetBroadcastConnectionInfo(broadcastHostId, out senderAddr, out senderPort, out error);
OnReceivedBroadcast(senderAddr, senderPort, BytesToString(msgInBuffer));
}
}while (networkEvent != NetworkEventType.Nothing);
}
void Process()
{
//int HostID = 0;
//int ClientID;
//int rec_hostID = 0;
int rec_connectionID;
int rec_channelID;
byte[] buffer = new byte[1024];
int buffer_length;
byte error;
NetworkEventType networkEvent = NetworkEventType.DataEvent;
do
{
networkEvent = NetworkTransport.ReceiveFromHost(HostID, out rec_connectionID, out rec_channelID, buffer, 1024, out buffer_length, out error);
switch (networkEvent)
{
case NetworkEventType.ConnectEvent: // Server received connect event
Connected = true;
Debug.Log("Connected.");
break;
case NetworkEventType.DataEvent: // Server received data
try { //Try catch is super expensive, a data server will replace it later
Decipher d = Serializer.UnSeal(HostID, buffer);
SendMessage(d.protocol, d);
} catch {
AppendBuffer(buffer, buffer_length);
}
break;
case NetworkEventType.DisconnectEvent: // Client received disconnect event
Connected = false;
if (error == 6) //Server down
{
StartCoroutine(Scene.LoadThenExecute(ID.StartMenu, PopUpNotification.Push, "Disconnected from server.", PopUpNotification.Type.Confirm));
}
Debug.Log("Disconnected.");
ClientID = -1;
break;
case NetworkEventType.BroadcastEvent: //This block should be removed for network version
if (Connected || ip != String.Empty)
{
return;
}
NetworkTransport.GetBroadcastConnectionMessage(HostID, buffer, 1024, out buffer_length, out error);
ip = Serializer.DeSerialize <string>(buffer);
RootButtons.cg.interactable = true;
break;
}
} while (networkEvent != NetworkEventType.Nothing);
}
internal override void ProcessIncomingEvent(NetworkEventType netEvent, int connectionId, int channelId, byte[] buffer, int dataSize)
{
if (netEvent != NetworkEventType.BroadcastEvent)
{
return;
}
byte error;
NetworkTransport.GetBroadcastConnectionMessage(Socket, buffer, buffer.Length, out dataSize, out error);
if (error > 0)
{
Error = error;
return;
}
string host;
int port;
NetworkTransport.GetBroadcastConnectionInfo(Socket, out host, out port, out error);
if (error > 0)
{
Error = error;
return;
}
var data = new byte[dataSize];
Buffer.BlockCopy(buffer, 0, data, 0, dataSize);
WakeNet.Log(Encoding.UTF8.GetString(data));
var gameResult = JsonUtility.FromJson <GameResult>(Encoding.UTF8.GetString(data));
if (!_foundGames.ContainsKey(gameResult.DeviceId))
{
_foundGames.Add(gameResult.DeviceId, new Result {
Host = host, Port = gameResult.Port, GameResult = gameResult
});
_foundGames[gameResult.DeviceId].Routine = WakeNet.InvokeAt(() => { _foundGames.Remove(gameResult.DeviceId); }, Time.unscaledTime + _interval * 2);
}
else
{
_foundGames[gameResult.DeviceId].Host = host;
_foundGames[gameResult.DeviceId].Port = gameResult.Port;
_foundGames[gameResult.DeviceId].GameResult.Message = gameResult.Message;
WakeNet.StopRoutine(_foundGames[gameResult.DeviceId].Routine);
_foundGames[gameResult.DeviceId].Routine = WakeNet.InvokeAt(() => { _foundGames.Remove(gameResult.DeviceId); }, Time.unscaledTime + _interval * 2);
}
}
private void CheckForDevices()
{
int num;
int num2;
int num3;
byte num4;
this.msgInBuffer = new byte[0x400];
if (NetworkTransport.ReceiveFromHost(this.hostId, out num, out num2, this.msgInBuffer, 0x400, out num3, out num4) == NetworkEventType.BroadcastEvent)
{
string str;
int num5;
NetworkTransport.GetBroadcastConnectionMessage(this.hostId, this.msgInBuffer, 0x400, out num3, out num4);
NetworkTransport.GetBroadcastConnectionInfo(this.hostId, out str, out num5, out num4);
this.OnReceivedBroadcast(str, GetString(this.msgInBuffer));
}
}
private NetworkEventType ProcessNetworkEvent()
{
NetworkEventType networkEvent;
int connectionId;
int channelId;
int receivedSize;
byte error;
networkEvent = NetworkTransport.ReceiveFromHost(m_HostId, out connectionId, out channelId, m_MsgInBuffer, k_MaxBroadcastMsgSize, out receivedSize, out error);
if (networkEvent == NetworkEventType.BroadcastEvent)
{
NetworkTransport.GetBroadcastConnectionMessage(m_HostId, m_MsgInBuffer, k_MaxBroadcastMsgSize, out receivedSize, out error);
string senderAddr;
int senderPort;
NetworkTransport.GetBroadcastConnectionInfo(m_HostId, out senderAddr, out senderPort, out error);
string senderAddrIPv4 = senderAddr.Substring(senderAddr.LastIndexOf(':') + 1);
var byteData = new byte[receivedSize];
Buffer.BlockCopy(m_MsgInBuffer, 0, byteData, 0, receivedSize);
string data = BytesToString(byteData);
var recv = new ExpiringBroadcastResult
{
serverAddress = senderAddrIPv4,
broadcastData = data,
expiration = DateTime.Now.AddSeconds(m_receivedBroadCastLifetime)
};
m_BroadcastsReceived[senderAddrIPv4] = recv;
OnReceivedBroadcast(senderAddrIPv4, BytesToString(m_MsgInBuffer));
}
return(networkEvent);
}
private void ReadBroadcast()
{
if (isConnected)
{
return;
}
byte[] buffer = new byte[BYTE_SIZE];
NetworkTransport.GetBroadcastConnectionMessage(
hostId,
buffer,
BYTE_SIZE,
out int recievedSize,
out byte broadcastError);
if ((NetworkError)broadcastError != NetworkError.Ok)
{
Debug.LogError($"Network Error: {(NetworkError)broadcastError}");
}
NetworkTransport.GetBroadcastConnectionInfo(
hostId,
out string senderAddr,
out int port,
out byte infoError);
if ((NetworkError)infoError != NetworkError.Ok)
{
Debug.LogError($"Network Error: {(NetworkError)infoError}");
}
// Do things
Debug.Log($"Got broadcast from {senderAddr}");
// Deserialize server name
var chars = new char[recievedSize * sizeof(char)];
System.Buffer.BlockCopy(buffer, 0, chars, 0, recievedSize);
string data = new string(chars);
LANConnectionInfo info = new LANConnectionInfo(senderAddr, data);
GameObject.Find("/Canvases").GetComponent <LANMenu>().AddToList(info);
}
/// <summary>
/// handles broadcast messages
/// </summary>
private void HandleBroadcast()
{
string ip;
int port;
byte error;
byte[] buffer = new byte[1024];
int size;
NetworkTransport.GetBroadcastConnectionInfo(m_hostId, out ip, out port, out error);
NetworkTransport.GetBroadcastConnectionMessage(m_hostId, buffer, 1024, out size, out error);
NetUtilGameAdvert advert = ConstructType <NetUtilGameAdvert>(buffer, 1, size - 1);
NetUtilGameInfo gameInfo = new NetUtilGameInfo();
gameInfo.name = advert.name;
gameInfo.playerCount = advert.playerCount;
gameInfo.playerLimit = advert.playerLimit;
gameInfo.ip = ip;
gameInfo.port = port;
gameInfo.time = Time.time;
m_remoteGames[gameInfo.ip + ":" + port] = gameInfo;
}
// Update is called once per frame
void Update()
{
int connectionId;
int channelId;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
int recPort;
string addr;
NetworkEventType recData = NetworkTransport.ReceiveFromHost(hostId, out connectionId, out channelId, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.Nothing: //1
break;
case NetworkEventType.ConnectEvent: //2
NetworkID network;
NodeID dstNode;
NetworkTransport.GetConnectionInfo(hostId, connectionId, out addr, out recPort, out network, out dstNode, out error);
Debug.Log("Connect request: " + (NetworkError)error + " on conId " + connectionId + " addr " + addr + " port " + recPort + " net " + network + " dstNode " + dstNode);
if (!otherPlayerConnections.ContainsValue(addr))
{
otherPlayerConnections[connectionId] = addr;
}
break;
case NetworkEventType.DataEvent: //3
string data = Encoding.ASCII.GetString(recBuffer);
Debug.Log("Got data: " + data + " on conId " + connectionId);
if (recieve)
{
micMan.HandleSpeech(data);
}
break;
case NetworkEventType.DisconnectEvent: //4
Debug.Log("Disconnect: " + (NetworkError)error + " on conId " + connectionId);
otherPlayerConnections.Remove(connectionId);
break;
case NetworkEventType.BroadcastEvent:
addr = NetworkTransport.GetBroadcastConnectionInfo(hostId, out recPort, out error);
int recSize;
NetworkTransport.GetBroadcastConnectionMessage(hostId, recBuffer, bufferSize, out recSize, out error);
string message = Encoding.ASCII.GetString(recBuffer, 0, recSize);
//Debug.Log("saw broadcast from " + addr + " with message of len " + message.Length + ":" + message + "|");
if (message != deviceId || !ignoreSelf)
{
if (!otherPlayerConnections.ContainsValue(addr))
{
int conId = NetworkTransport.Connect(hostId, addr, port, 0, out error);
Debug.Log("Connect attempt to " + addr + " result: " + (NetworkError)error + " conid:" + conId);
otherPlayerConnections[conId] = addr;
}
}
break;
}
}
private void CheckMessages()
{
if (clientSocket < 0)
{
return;
}
int recConnectionID; // rec stands for received
int recChannelID;
int bsize = 1024;
byte[] buffer = new byte[bsize];
int dataSize;
byte error;
// continuously loop until there are no more messages
while (true)
{
NetworkEventType recEvent = NetworkTransport.ReceiveFromHost(
clientSocket, out recConnectionID, out recChannelID, buffer, bsize, out dataSize, out error);
switch (recEvent)
{
case NetworkEventType.Nothing:
return;
case NetworkEventType.DataEvent:
ReceivePacket(new Packet(buffer));
break;
case NetworkEventType.BroadcastEvent:
if (serverSocket >= 0) // already connected to a server
{
break;
}
Debug.Log("CLIENT: found server broadcast!");
// get broadcast message (not doing anything with it currently)
NetworkTransport.GetBroadcastConnectionMessage(clientSocket, buffer, bsize, out dataSize, out error);
Packet msg = new Packet(buffer);
msg.ReadByte();
Debug.Log("CLIENT: message received: " + msg.ReadString());
// connect to broadcaster by port and address
int broadcastPort;
string broadcastAddress;
NetworkTransport.GetBroadcastConnectionInfo(clientSocket, out broadcastAddress, out broadcastPort, out error);
//// close client socket on port 8887 so new clients on this comp can connect to broadcast port
//NetworkTransport.RemoveHost(clientSocket);
//clientSocket = -1;
//// reconnect in one second since RemoveHost kind of times out the network momentarily
//StartCoroutine(waitThenReconnect(0.5f, broadcastAddress, broadcastPort));
// just connect directly for now (prob wont need this testing stuff above)
Debug.Log("CLIENT: connected on port: " + port);
serverSocket = NetworkTransport.Connect(clientSocket, broadcastAddress, broadcastPort, 0, out error);
return;
case NetworkEventType.ConnectEvent:
Debug.Log("CLIENT: connected to server");
break;
case NetworkEventType.DisconnectEvent:
Debug.Log("CLIENT: disconnected from server");
break;
default:
break;
}
}
}
public void GetBroadcastConnectionMessage(int hostId, byte[] buffer, int bufferSize, out int receivedSize, out byte error)
{
NetworkTransport.GetBroadcastConnectionMessage(hostId, buffer, bufferSize, out receivedSize, out error);
}
private void checkMessages()
{
if (clientSocket < 0)
{
return;
}
int recConnectionID; // rec stands for received
int recChannelID;
int bsize = 1024;
byte[] buffer = new byte[bsize];
int dataSize;
byte error;
// continuously loop until there are no more messages
while (true)
{
if (waitToCheckMessages)
{
return;
}
NetworkEventType recEvent = NetworkTransport.ReceiveFromHost(
clientSocket, out recConnectionID, out recChannelID, buffer, bsize, out dataSize, out error);
switch (recEvent)
{
case NetworkEventType.Nothing:
return;
case NetworkEventType.DataEvent:
receivePacket(new Packet(buffer));
break;
case NetworkEventType.BroadcastEvent:
if (serverSocket >= 0) // already connected to a server
{
break;
}
menuUI.stopStatusTextAnim();
Debug.Log("CLIENT: found server broadcast!");
string statusText = !enabledServer ? "Found Server!" : "Created Server!";
menuUI.setStatusText(statusText, Color.yellow, true);
// get broadcast message (not doing anything with it currently)
NetworkTransport.GetBroadcastConnectionMessage(clientSocket, buffer, bsize, out dataSize, out error);
// connect to broadcaster by port and address
int broadcastPort;
string broadcastAddress;
NetworkTransport.GetBroadcastConnectionInfo(clientSocket, out broadcastAddress, out broadcastPort, out error);
// close client socket on port 8887 so new clients on this comp can connect to broadcast port
NetworkTransport.RemoveHost(clientSocket);
clientSocket = -1;
// reconnect in one second since RemoveHost kind of times out the network momentarily
StartCoroutine(waitThenReconnect(0.5f, broadcastAddress, broadcastPort));
return;
case NetworkEventType.ConnectEvent:
Debug.Log("CLIENT: connected to server");
break;
case NetworkEventType.DisconnectEvent:
Debug.Log("CLIENT: disconnected from server");
ResetToMenu.Reset();
break;
default:
break;
}
}
}
private void Update()
{
if (_closing)
{
bool openedConnections = false;
for (int i = 0; i <= _maxConnections; i++)
{
if (_connections[i] == null)
{
continue;
}
openedConnections = true;
break;
}
if (!openedConnections)
{
Destroy(gameObject);
}
}
if (!EventsReady)
{
return;
}
EventsReady = false;
NetworkEventType networkEvent;
do
{
networkEvent = NetworkTransport.ReceiveFromHost(
Id,
out int connectionId,
out int channelId,
_packet,
_packetSize,
out int dataSize,
out byte error
);
ParseError("Failed to poll event", error);
switch (networkEvent)
{
case NetworkEventType.ConnectEvent:
{
var connectionObject = Instantiate(_connectionPrefab, transform);
_connections[connectionId] = connectionObject.GetComponent <Connection>();
_connections[connectionId].ImmediateStart(Id, connectionId);
var wrapper = new ReceiveWrapper
{
message = new Connect(),
connection = connectionId,
ip = _connections[connectionId].Ip,
port = _connections[connectionId].Port,
};
_messages.Enqueue(wrapper);
break;
}
case NetworkEventType.DataEvent:
{
var wrapper = new ReceiveWrapper
{
message = _formatter.Deserialize(_packet),
connection = connectionId,
ip = _connections[connectionId].Ip,
port = _connections[connectionId].Port,
};
wrapper.ping = NetworkTransport.GetRemoteDelayTimeMS(Id, connectionId, wrapper.message.timeStamp, out error);
ParseError("Failed to get ping", error);
_messages.Enqueue(wrapper);
break;
}
case NetworkEventType.BroadcastEvent:
{
NetworkTransport.GetBroadcastConnectionMessage(Id, _broadcastPacket, _packetSize, out int size, out error);
ParseError("Failed to get broadcast message", error);
var wrapper = new ReceiveWrapper
{
message = _formatter.Deserialize(_broadcastPacket),
};
NetworkTransport.GetBroadcastConnectionInfo(Id, out wrapper.ip, out wrapper.port, out error);
ParseError("Failed to get broadcast connection info", error);
_messages.Enqueue(wrapper);
break;
}
case NetworkEventType.DisconnectEvent:
{
DisconnectError = (NetworkError)error;
var wrapper = new ReceiveWrapper
{
message = new Disconnect(),
connection = connectionId,
};
if (_connections[connectionId] != null)
{
wrapper.ip = _connections[connectionId].Ip;
wrapper.port = _connections[connectionId].Port;
Destroy(_connections[connectionId].gameObject);
}
_messages.Enqueue(wrapper);
break;
}
}
}while (networkEvent != NetworkEventType.Nothing);
}
// Update is called once per frame
void Update()
{
if (isClient && !conectou)
{
int connectionId;
int channelId;
byte error;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
NetworkEventType networkEvent;
do
{
networkEvent = NetworkTransport.ReceiveFromHost(hostId, out connectionId,
out channelId, recBuffer, bufferSize, out dataSize, out error);
Debug.Log(networkEvent + " teste Broadcast");
if (networkEvent == NetworkEventType.BroadcastEvent)
{
string hostIP;
int hostPort;
NetworkTransport.GetBroadcastConnectionInfo(hostId, out hostIP, out hostPort, out error);
NetworkTransport.GetBroadcastConnectionMessage(hostId, recBuffer, bufferSize,
out dataSize, out error);
OnReceivedBroadcast(hostIP, GetString(recBuffer));
}
} while (networkEvent != NetworkEventType.Nothing);
}
if (conectou)
{
NetworkEventType recData;
do
{
int recHostId;
int connectionId;
int channelId;
byte[] recBuffer = new byte[1024];
int bufferSize = 1024;
int dataSize;
byte error;
recData = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, recBuffer, bufferSize, out dataSize, out error);
switch (recData)
{
case NetworkEventType.ConnectEvent:
if (meuID == 2)
{
EnviarPlayer("Conectou|" + connectionId + "|" + GlobalClass.HostArena + "|" + GlobalClass.pSkin, connectionId, reliableChannel);
Debug.Log("Conexao com : " + connectionId);
NetworkTransport.StopBroadcastDiscovery();
p1text.color = Color.green;
preparados = true;
}
else
{
Debug.Log("me conectei com id: " + connectionId);
p2text.color = Color.green;
preparados = true;
clienteSkin.sprite = materials[GlobalClass.pSkin].sprite;
clienteSkin.enabled = true;
Enviar("SkinCliente|" + GlobalClass.pSkin, reliableChannel);
}
goto case NetworkEventType.Nothing;
case NetworkEventType.DataEvent:
string msg = Encoding.Unicode.GetString(recBuffer, 0, dataSize);
//Debug.Log(msg);
string[] sepEnvio = msg.Split('|');
switch (sepEnvio[0])
{
/*case "Preparados":
* preparados = true;
* //p1text.color = Color.green;
* //p2text.color = Color.green;
* break;*/
case "Conectou":
meuID = int.Parse(sepEnvio[1]);
GlobalClass.HostArena = int.Parse(sepEnvio[2]);
mapB.NewLayer();
numP.text = "Player " + meuID.ToString();
if (meuID == 1)
{
player1.GetComponent <Character>().nPlayer = 1;
player1.GetComponent <Character>().setMaterials(meuID, materials[GlobalClass.pSkin]);
player2.GetComponent <Character>().nPlayer = 2;
player2.GetComponent <Character>().setMaterials(meuID, materials[int.Parse(sepEnvio[3])]);
hostSkin.sprite = materials[int.Parse(sepEnvio[3])].sprite;
hostSkin.enabled = true;
SetArena();
//player2.GetComponent<Character>().setMaterial(2);
//player1.GetComponent<Character>().setMaterial(1);
p1text.text = "Eu";
p1text.color = Color.green;
p2text.text = "Inimigo";
}
break;
case "SkinCliente":
if (meuID == 2) //só o host recebe
{
Debug.Log("recebi_Skin_do_Cliente " + sepEnvio[1]);
player1.GetComponent <Character>().setMaterials(meuID, materials[int.Parse(sepEnvio[1])]);
clienteSkin.sprite = materials[int.Parse(sepEnvio[1])].sprite;
clienteSkin.enabled = true;
}
break;
case "Direcao":
float x, y, z;
x = float.Parse(sepEnvio[2]);
y = float.Parse(sepEnvio[3]);
z = float.Parse(sepEnvio[4]);
JsonSerial dFoice = JsonUtility.FromJson <JsonSerial>(sepEnvio[5]);
Vector3 dir = new Vector3(x, y, z);
if (meuID == 2)
{
player1.GetComponent <Character>().ChangeDirection(dir);
player1.GetComponent <Character>().SetFoiceT(dFoice.pp, dFoice.rr);
}
else
{
player2.GetComponent <Character>().ChangeDirection(dir);
player2.GetComponent <Character>().SetFoiceT(dFoice.pp, dFoice.rr);
}
break;
case "Pronto":
if (meuID == 1)
{
player2Ready = true;
check2.enabled = true;
p2text.color = Color.green;
}
else
{
p1text.color = Color.green;
player1Ready = true;
check1.enabled = true;
//EnviarPlayer("Preparados|", 1, reliableChannel);
//preparados = true;
}
break;
case "Comecar":
ComecarPartida();
break;
case "Posicao":
float xp, yp, zp;
xp = float.Parse(sepEnvio[2]);
yp = float.Parse(sepEnvio[3]);
zp = float.Parse(sepEnvio[4]);
JsonSerial pFoice = JsonUtility.FromJson <JsonSerial>(sepEnvio[5]);
if (meuID == 2)
{
//player1
player1.GetComponent <Character>().SetPosition(xp, yp, zp);
player1.GetComponent <Character>().SetFoiceT(pFoice.pp, pFoice.rr);
}
else
{
//player2
player2.GetComponent <Character>().SetPosition(xp, yp, zp);
player2.GetComponent <Character>().SetFoiceT(pFoice.pp, pFoice.rr);
}
break;
case "Egiro":
if (meuID == 2)
{
//player1 entrou girospot
player1.GetComponent <Character>().GirospotEnter(girospots[int.Parse(sepEnvio[2])], bool.Parse(sepEnvio[3]));
}
else
{
//player2 entrou girospot
player2.GetComponent <Character>().GirospotEnter(girospots[int.Parse(sepEnvio[2])], bool.Parse(sepEnvio[3]));
}
break;
case "Sgiro":
if (meuID == 2)
{
//player1 saiu girospot
player1.GetComponent <Character>().GirospotExit();
}
else
{
//player2 saiu girospot
player2.GetComponent <Character>().GirospotExit();
}
break;
case "InvDir":
Debug.Log("Inverter");
if (meuID == 1)
{
player1.GetComponent <Character>().InverterDirecao();
player1.GetComponent <Character>().PlayPonP();
}
break;
case "TomouDano":
player1.GetComponent <Character>().GiroGhostOn();
player1.GetComponent <Character>().instSangue(float.Parse(sepEnvio[1]), float.Parse(sepEnvio[2]), float.Parse(sepEnvio[3]));
player1.GetComponent <Character>().PlaySom();
break;
case "FoiceCol":
if (meuID == 1)
{
//Debug.Log("Recebi FoiceCol");
player1.GetComponent <Character>().InverterDirecao();
player1.GetComponent <Character>().InverterDirFaisca(float.Parse(sepEnvio[1]), float.Parse(sepEnvio[2]), float.Parse(sepEnvio[3]));
}
break;
case "CausouDano":
player2.GetComponent <Character>().GiroGhostOn();
player1.GetComponent <Character>().instSangue(float.Parse(sepEnvio[1]), float.Parse(sepEnvio[2]), float.Parse(sepEnvio[3]));
player1.GetComponent <Character>().PlaySom();
break;
case "Terminou":
terminarPartida(int.Parse(sepEnvio[1]));
player1.GetComponent <Character>().GiroFast();
break;
case "Revanche":
if (meuID == 1)
{
rematchB.interactable = true;
winner.text = "Revanche?";
}
else if (meuID == 2)
{
//recomecar partida;
resetGame();
}
break;
}
goto case NetworkEventType.Nothing;
case NetworkEventType.DisconnectEvent:
//Debug.Log("DisconnectEvent");
goto case NetworkEventType.Nothing;
case NetworkEventType.BroadcastEvent:
//Debug.Log("BroadcastEvent");
goto case NetworkEventType.Nothing;
case NetworkEventType.Nothing:
//Debug.Log("Nothing");
continue;
}
} while (recData != NetworkEventType.Nothing);
}
if (jogando)
{
if (slow)
{
if (meuID == 2)
{
cam.GetComponent <CameraController>().setPosition(player2.transform.position);
}
else
{
cam.GetComponent <CameraController>().setPosition(player1.transform.position);
}
}
dist = Vector3.Distance(player1.transform.position, player2.transform.position);
if (dist < 4 && !slow)
{
//Debug.Log("Distancia: " + dist);
if (!player2.GetComponent <Character>().ghost&& !player1.GetComponent <Character>().ghost)
{
if (!player2.GetComponent <Character>().onGirospot&& !player1.GetComponent <Character>().onGirospot)
{
if (meuID == 2)//host
{
player2.GetComponent <Character>().GiroSlow();
cam.GetComponent <CameraController>().setPosition(player2.transform.position);
}
else if (meuID == 1)//cliente
{
player1.GetComponent <Character>().GiroSlow();
cam.GetComponent <CameraController>().setPosition(player1.transform.position);
}
slow = true;
}
}
}
else if (dist > 4 && slow)
{
if (meuID == 2)//host
{
player2.GetComponent <Character>().GiroFast();
cam.GetComponent <CameraController>().resetPosition();
}
else//cliente
{
player1.GetComponent <Character>().GiroFast();
cam.GetComponent <CameraController>().resetPosition();
}
slow = false;
}
}
if (player1Ready && player2Ready && rede && !jogando)
{
ComecarPartida();
}
if (player1Ready && player2Ready && !jogando && !rede)
{
comecou = true;
startPanel.SetActive(false);
Debug.Log("todos prontos");
}
if (comecou && !rede)
{
jogando = true;
player1.GetComponent <Character>().EntrarGirospot(girospots[0]);
player2.GetComponent <Character>().EntrarGirospot(girospots[girospots.Length - 1]);
comecou = false;
Debug.Log("comecou");
}
if (jogando)
{
time += Time.deltaTime;
minutos = ((int)time / 60).ToString();
segundos = (time % 60).ToString("f0");
tempo.text = minutos + ":" + segundos;
}
}
void Update()
{
int recHostId;
int connectionId;
int recChannelId;
int dataSize;
// enable play mode if needed
if (manager && manager.IsInitialized() && !manager.IsPlayModeEnabled())
{
manager.EnablePlayMode(true);
}
// connect after broadcast discovery, if needed
if (clientConnId < 0 && serverHost != string.Empty && serverHost != "0.0.0.0" && serverPort != 0)
{
Start();
}
try
{
byte error = 0;
// disconnect if no data received for the last 10 seconds
if (connected && (Time.time - dataReceivedAt) >= 10f)
{
NetworkTransport.Disconnect(clientHostId, clientConnId, out error);
dataReceivedAt = Time.time;
if (error != (byte)NetworkError.Ok)
{
throw new UnityException("Disconnect: " + (NetworkError)error);
}
}
if (connected && keepAliveIndex < keepAliveCount)
{
if (sendKeepAlive[keepAliveIndex] && !string.IsNullOrEmpty(keepAliveData[keepAliveIndex]))
{
// send keep-alive to the server
sendKeepAlive[keepAliveIndex] = false;
byte[] btSendMessage = System.Text.Encoding.UTF8.GetBytes(keepAliveData[keepAliveIndex]);
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;
}
NetworkTransport.Send(clientHostId, clientConnId, clientChannelId, compressBuffer, compSize, out error);
//Debug.Log(clientConnId + "-keep: " + keepAliveData[keepAliveIndex]);
if (error != (byte)NetworkError.Ok)
{
throw new UnityException("Keep-alive: " + (NetworkError)error);
}
// make sure sr-message is sent just once
if (keepAliveIndex == 0 && keepAliveData[0].IndexOf(",sr") >= 0)
{
RemoveResponseMsg(",sr");
}
}
keepAliveIndex++;
if (keepAliveIndex >= keepAliveCount)
{
keepAliveIndex = 0;
}
}
// get next receive event
NetworkEventType recData;
if (serverHost != string.Empty && serverHost != "0.0.0.0" && serverPort != 0)
{
recData = NetworkTransport.ReceiveFromHost(clientHostId, out connectionId, out recChannelId, recBuffer, bufferSize, out dataSize, out error);
}
else
{
recData = NetworkTransport.Receive(out recHostId, out connectionId, out recChannelId, recBuffer, bufferSize, out dataSize, out error); // wait for broadcast
}
switch (recData)
{
case NetworkEventType.Nothing:
break;
case NetworkEventType.ConnectEvent:
if (connectionId == clientConnId)
{
connected = true;
//connectedOnce = true;
disconnectedAt = 0f;
dataReceivedAt = Time.time;
//sendKeepAlive = false;
Debug.Log("Connected.");
if (statusText)
{
statusText.text = "Connected.";
}
}
break;
case NetworkEventType.DataEvent:
if (connectionId == clientConnId)
{
if (error != (byte)NetworkError.Ok)
{
Debug.Log("Receive error on connection " + connectionId + ": " + (NetworkError)error);
}
else
{
dataReceivedAt = Time.time;
//sendKeepAlive = true;
//string sRecvMessage = System.Text.Encoding.UTF8.GetString(recBuffer, 0, dataSize);
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("pv"))
// {
// //Debug.Log("Got part face verts - " + sRecvMessage.Substring(0, 3));
//
// // part of face-vertices msg
// sRecvMessage = ProcessPvMessage(sRecvMessage);
//
// if(sRecvMessage.Length == 0)
// EnableNextKeepAlive(2);
// }
// else if(sRecvMessage.StartsWith("pt"))
// {
// //Debug.Log("Got part face tris - " + sRecvMessage.Substring(0, 3));
//
// // part of face-triangles msg
// sRecvMessage = ProcessPtMessage(sRecvMessage);
//
// if(sRecvMessage.Length == 0)
// EnableNextKeepAlive(3);
// }
if (!string.IsNullOrEmpty(sRecvMessage))
{
char[] msgDelim = { '|' };
string[] asMessages = sRecvMessage.Split(msgDelim);
char[] partDelim = { ',' };
for (int i = 0; i < asMessages.Length; i++)
{
if (manager && asMessages[i].Length > 3)
{
if (asMessages[i].StartsWith("kb,"))
{
//Debug.Log("Got body data");
manager.SetBodyFrameData(asMessages[i]);
EnableNextKeepAlive(0);
}
else if (asMessages[i].StartsWith("kh,"))
{
manager.SetBodyHandData(asMessages[i]);
}
else if (asMessages[i].StartsWith("km,"))
{
manager.SetWorldMatrixData(asMessages[i]);
}
else if (asMessages[i].StartsWith("vg,") && gestureManager != null)
{
gestureManager.SetGestureDataFromCsv(asMessages[i], partDelim);
}
else if (asMessages[i].StartsWith("sr,") && speechManager != null)
{
speechManager.SetSpeechDataFromCsv(asMessages[i], partDelim);
}
// else if(asMessages[i].StartsWith("fp,") && faceManager != null)
// {
// //Debug.Log("Got face params");
// faceManager.SetFaceParamsFromCsv(asMessages[i]);
// EnableNextKeepAlive(1);
// }
// else if(asMessages[i].StartsWith("fv,") && faceManager != null)
// {
// //Debug.Log("Got face vertices");
// faceManager.SetFaceVerticesFromCsv(asMessages[i]);
// EnableNextKeepAlive(2);
// }
// else if(asMessages[i].StartsWith("fu,") && faceManager != null)
// {
// //Debug.Log("Got face uvs");
// faceManager.SetFaceUvsFromCsv(asMessages[i]);
// EnableNextKeepAlive(2);
// }
// else if(asMessages[i].StartsWith("ft,") && faceManager != null)
// {
// //Debug.Log("Got face triangles");
// faceManager.SetFaceTrianglesFromCsv(asMessages[i]);
//
// keepAliveData[3] = null; // clear index 3 - one set of tris is enough
// EnableNextKeepAlive(3);
// }
}
}
}
}
}
break;
case NetworkEventType.DisconnectEvent:
if (connectionId == clientConnId)
{
connected = false;
//connectedOnce = true; // anyway, try to reconnect
disconnectedAt = Time.time;
dataReceivedAt = 0f;
//sendKeepAlive = false;
Debug.Log("Disconnected: " + (NetworkError)error);
if (error != (byte)NetworkError.Ok)
{
throw new UnityException("Disconnected: " + (NetworkError)error);
}
}
break;
case NetworkEventType.BroadcastEvent:
int receivedSize;
NetworkTransport.GetBroadcastConnectionMessage(bcastHostId, bcastBuffer, bcastBuffer.Length, out receivedSize, out error);
string senderAddr;
int senderPort;
NetworkTransport.GetBroadcastConnectionInfo(bcastHostId, out senderAddr, out senderPort, out error);
if (serverHost == string.Empty || serverHost == "0.0.0.0" || serverPort == 0)
{
string sData = System.Text.Encoding.UTF8.GetString(bcastBuffer, 0, bcastBuffer.Length).Trim();
OnReceivedBroadcast(senderAddr, sData);
}
break;
}
// try to reconnect, if disconnected
if (!connected && /**connectedOnce &&*/ disconnectedAt > 0f && (Time.time - disconnectedAt) >= reconnectAfter)
{
disconnectedAt = 0f;
error = 0;
clientConnId = NetworkTransport.Connect(clientHostId, serverHost, serverPort, 0, out error);
if (error == (byte)NetworkError.Ok)
{
Debug.Log("Reconnecting to the server - " + serverHost + ":" + serverPort);
if (statusText)
{
statusText.text = "Reconnecting to the server...";
}
}
else
{
throw new UnityException("Error while reconnecting: " + (NetworkError)error);
}
}
}
catch (System.Exception ex)
{
Debug.LogError(ex.Message + "\n" + ex.StackTrace);
if (statusText)
{
statusText.text = ex.Message;
}
}
}
public void ProcessBroadcasts()
{
int connectionId;
int channelId;
int receivedSize;
byte error;
while (m_BroadcastHostId > -1)
{
UnityEngine.Networking.NetworkEventType ne = NetworkTransport.ReceiveFromHost(m_BroadcastHostId, out connectionId, out channelId, m_Buffer, m_Buffer.Length, out receivedSize, out error);
if (ne == UnityEngine.Networking.NetworkEventType.Nothing)
{
break;
}
switch (ne)
{
case UnityEngine.Networking.NetworkEventType.BroadcastEvent:
{
int _port;
string address;
NetworkTransport.GetBroadcastConnectionInfo(m_BroadcastHostId, out address, out _port, out error);
NetworkTransport.GetBroadcastConnectionMessage(m_BroadcastHostId, m_Buffer, m_Buffer.Length, out receivedSize, out error);
var reader = new NetworkReader(m_Buffer, null);
int port = reader.ReadInt32();
uint token = reader.ReadUInt32();
string servername = reader.ReadString();
string levelname = reader.ReadString();
string gamemode = reader.ReadString();
int connectedPlayers = reader.ReadInt32();
int maxPlayers = reader.ReadInt32();
if (address.StartsWith("::ffff:"))
{
address = address.AfterFirst("::ffff:");
}
var key = address + ":" + port;
ServerInfo si = null;
for (var i = 0; i < m_KnownServers.Count; i++)
{
if (m_KnownServers[i].Address == key)
{
si = m_KnownServers[i];
break;
}
}
if (si == null)
{
si = new ServerInfo();
m_KnownServers.Add(si);
GameDebug.Log("New server: " + servername + " " + address + ":" + port + " _port: " + _port);
}
si.Token = token;
si.Name = servername;
si.LevelName = levelname;
si.GameMode = gamemode;
si.Players = connectedPlayers;
si.MaxPlayers = maxPlayers;
si.Address = key;
si.LastSeenTime = Time.time;
}
break;
}
}
for (var i = m_KnownServers.Count - 1; i >= 0; --i)
{
if (m_KnownServers[i].LastSeenTime < Time.time - 5.0f)
{
m_KnownServers.RemoveAt(i);
}
}
}
/// <summary>
/// Process network events on this host.
/// This will send and receive packets as well as handle connections and disconnects.
/// </summary>
public void ProcessEvents()
{
//
if (!IsOpen)
{
throw new InvalidOperationException("Unable to process network events, local host not open.");
}
while (true)
{
byte error;
int connectionId, channelId, dataSize;
var type = NetworkTransport.ReceiveFromHost(Id, out connectionId, out channelId, Buffer, Buffer.Length, out dataSize, out error);
// Danny: In rare instances, this will be encountered instead of NetworkEventType.Disconnect.
if ((NetworkError)error == NetworkError.Timeout)
{
Debug.LogError("NetworkHost.ProcessEvents() : Detected Timeout.");
type = NetworkEventType.DisconnectEvent;
}
else if (error > 0)
{
throw new NetworkException(string.Format("Receive - Host {0}", Id), error);
}
if (type == NetworkEventType.Nothing)
{
return; // Exit function
}
// if( error > 0 )
// Debug.LogFormat( "{4} Event: Host {0} Connection {1} Channel {2} Size {3}", Id, connectionId, channelId, dataSize, type );
var channel = _Channels.Values.FirstOrDefault(c => c.Id == channelId);
var connection = _Connections.Find(c => c.Id == connectionId);
switch (type)
{
case NetworkEventType.BroadcastEvent:
// Get remote info
string remoteAddress;
int messageSize, remotePort;
NetworkTransport.GetBroadcastConnectionInfo(Id, out remoteAddress, out remotePort, out error);
if (error > 0)
{
throw new NetworkException(string.Format("Broadcast - Get Info {0}", Id), error);
}
// Avoid messages from the local host
if (!IsLocalAddress(remoteAddress))
{
// Get remote message
NetworkTransport.GetBroadcastConnectionMessage(Id, Buffer, Buffer.Length, out messageSize, out error);
if (error > 0)
{
throw new NetworkException(string.Format("Broadcast - Get Message {0}", Id), error);
}
// Extract message
var message = new byte[messageSize];
Array.Copy(Buffer, message, messageSize);
// Create packet object
var bPacket = new BroadcastPacket(remoteAddress, remotePort, message);
_BroadcastPackets.Enqueue(bPacket);
// Too many packets, start clearing them...!
if (_BroadcastPackets.Count > MAX_PACKET_QUEUE_SIZE)
{
Debug.LogWarningFormat("Too many broadcast packets in queue. Discarding oldest packet.");
_BroadcastPackets.Dequeue();
}
}
break;
case NetworkEventType.ConnectEvent:
// Create new remote
// Will be null if a remote is connecting to the local host
// Won't be null if the local host is connecting to a remote host
if (connection == null)
{
connection = new NetworkConnection(this, connectionId);
_Connections.Add(connection);
}
//
if (!connection.IsConnected)
{
connection.OnConnected();
}
// Trigger Connection Event
OnConnect(connection);
break;
case NetworkEventType.DisconnectEvent:
Debug.Log("Got disconnect event.");
// Remove remote connection
if (connection != null)
{
_Connections.Remove(connection);
}
else
{
Debug.LogWarningFormat("Disconnect: {0} wasn't in connections?", connectionId);
}
// Trigger Disconnection Event
OnDisconnect(connection);
break;
case NetworkEventType.DataEvent:
// Copy packet from buffer
var data = new byte[dataSize];
Array.Copy(Buffer, data, dataSize);
// Debug.LogFormat( "-- Received a packet ( {0} bytes )", data.Length );
// Create packet object
var dPacket = new Packet(connection, channel, data);
_Packets.Enqueue(dPacket);
// Too many packets, start clearing them...!
if (_Packets.Count > MAX_PACKET_QUEUE_SIZE)
{
Debug.LogWarningFormat("Too many packets in queue. Discarding oldest packet.");
_Packets.Dequeue();
}
break;
}
}
}
public void FindHosts()
{
//Debug.Log("Finding Hosts");
if (!findingHosts)
{
findingHosts = true;
//lobbySearchCanvas.transform.Find("FindHostBtn").gameObject.SetActive(false);
//lobbySearchCanvas.transform.Find("StopSearchBtn").gameObject.SetActive(true);
}
// Does player have name?
/*string pName = GameObject.Find("NameInput").GetComponent<InputField>().text;
* pName = "LOLS";
* if (pName == "")
* {
* Debug.Log("You must enter a name");
* return;
* }*/
//playerName = pName;
// Does player know who the host is?
if (hostId == -1)
{
//Debug.Log("Haven't received port");
ConnectionConfig cc = new ConnectionConfig();
reliableChannel = cc.AddChannel(QosType.Reliable);
unreliableChannel = cc.AddChannel(QosType.Unreliable);
HostTopology topo = new HostTopology(cc, MAX_CONNECTION);
hostId = NetworkTransport.AddHost(topo, broadcastPort);
//Debug.Log(hostId);
if (hostId == -1)
{
NetworkTransport.RemoveHost(hostId);
Debug.LogError("NetworkDiscovery StartAsClient - addHost failed");
return;
}
}
NetworkTransport.SetBroadcastCredentials(hostId, broadcastKey, broadcastVersion, broadcastSubVersion, out error);
//int counter = 0;
NetworkEventType recData = NetworkEventType.Nothing;
//do
// {
//Debug.Log("Listening...");
recData = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, recBuffer, bufferSize, out dataSize, out error);
//Debug.Log(recData);
if (recData == NetworkEventType.BroadcastEvent)
{
//Debug.Log("YE");
int rcvSize;
NetworkTransport.GetBroadcastConnectionMessage(hostId, buffer, buffer.Length, out rcvSize, out error);
string senderAddr;
int senderPort;
NetworkTransport.GetBroadcastConnectionInfo(hostId, out senderAddr, out senderPort, out error);
//Debug.Log(rcvSize);
OnReceivedBroadcast(senderAddr, senderPort, Encoding.Unicode.GetString(buffer));
}
/*counter++;
* //Waits roughly 10seconds before timeout
* if (counter > 1 << 24 - 1)
* {
* Debug.Log("WAITED TOO LONG");
* NetworkTransport.RemoveHost(hostId);
* hostId = -1;
* return;
* }*/
// } while (recData != NetworkEventType.BroadcastEvent);
}
