void Update()
{
if (Input.GetKeyDown(KeyCode.Space) && !isConnected)
{
communicationManager.SendMessage(ConnectPlayerMessage.CreateConnectPlayerMessageToSend(playerId));
}
else if (Input.GetKeyDown(KeyCode.Escape) && isConnected)
{
communicationManager.SendMessage(new DisconnectPlayerMessage(Random.Range(0, int.MaxValue), playerId));
Clean();
}
ReadMessages();
if (simIniTime != 0)
{
if (!Input.GetKey(KeyCode.K))
{
Interpolate();
}
}
if (ownPlayer != null)
{
communicationManager.SendMessage(new PlayerInputMessage(playerId, ownPlayer.playerInput));
}
Packet outPacket = communicationManager.BuildPacket();
if (outPacket != null)
{
channel.Send(outPacket);
}
}
public void ProcessConnectPlayer(ConnectPlayerMessage connectPlayerMessage)
{
int playerId = connectPlayerMessage.PlayerId;
Player player = GetPlayerWithId(playerId);
if (player != null)
{
DisconnectPlayer(player);
}
GameObject playerGO = Instantiate(playerPrefab) as GameObject;
playerGO.name = "Player " + playerId;
player = playerGO.GetComponent <Player> ();
player.endPoint = connectPlayerMessage.EndPoint;
player.Id = playerId;
players.Add(player);
//send all players that a new player has connected
for (int i = 0; i < players.Count; i++)
{
Player playerToSendTo = players [i];
PlayerConnectedMessage playerConnectedMessage = PlayerConnectedMessage.CreatePlayerConnectedMessageToSend(playerToSendTo, playerId);
playerToSendTo.CommunicationManager.SendMessage(playerConnectedMessage);
}
}
Message ReadClientMessage(BitBuffer bitBuffer, IPEndPoint clientEndPoint)
{
MessageType messageType = bitBuffer.GetEnum <MessageType> ((int)MessageType.TOTAL);
Message clientMessage = null;
switch (messageType)
{
case MessageType.CONNECT_PLAYER:
clientMessage = ConnectPlayerMessage.CreateConnectPlayerMessageToReceive(clientEndPoint); break;
case MessageType.DISCONNECT_PLAYER:
clientMessage = new DisconnectPlayerMessage(); break;
case MessageType.PLAYER_INPUT:
clientMessage = new PlayerInputMessage(); break;
case MessageType.ACK_RELIABLE_MAX_WAIT_TIME:
clientMessage = AckReliableMessage.CreateAckReliableMessageToReceive(); break;
case MessageType.ACK_RELIABLE_SEND_EVERY_PACKET:
clientMessage = AckReliableSendEveryFrameMessage.CreateAckReliableSEFMToReceive(); break;
default:
Debug.LogError("Unknown client message received.");
return(null);
}
clientMessage.From = clientEndPoint;
clientMessage.Load(bitBuffer);
return(clientMessage);
}
public void Update()
{
if (!_connected && Input.GetKeyDown(KeyCode.Space))
{
_communicationManager.SendMessage(ConnectPlayerMessage.CreateConnectPlayerMessageToSend(PlayerId));
CleanClient();
}
else if (_connected && Input.GetKeyDown(KeyCode.Escape))
{
var id = Random.Range(0, int.MaxValue);
_communicationManager.SendMessage(new DisconnectPlayerMessage(id, PlayerId));
}
ReadMessages(); // Read messages from server
Interpolate(); // Perform interpolation of snapshots
SendInput(); // Send own data
}
void Update()
{
Packet s;
if ((s = channel.GetPacket()) != null)
{
int messages = s.buffer.GetInt();
for (int i = 0; i < messages; i++)
{
Message m = readServerMessage(s.buffer);
if (m != null)
{
ProcessMessage(m);
}
else
{
Debug.Log("m is null");
}
}
Debug.Log("Recibi algo");
}
if (!snapshotManager.alreadyAdded)
{
snapshotManager.AddInterpolated();
}
if (Input.GetKeyDown(KeyCode.Space))
{
//send player connect message
ConnectPlayerMessage connectPlayerMessage = ConnectPlayerMessage.CreateConnectPlayerMessageToSend(playerId);
cm.SendMessage(connectPlayerMessage);
}
processSnapshot();
Packet packet = Packet.Obtain();
PlayerInputMessage pim = new PlayerInputMessage(playerId, playerController.playerInput);
cm.SendMessage(pim);
Packet p = cm.BuildPacket();
channel.Send(p);
}
public void ProcessConnectPlayer(ConnectPlayerMessage connectPlayerMessage)
{
int playerId = connectPlayerMessage.PlayerId;
ServerPlayerController player = GetPlayerWithId(playerId);
if (player != null)
{
DisconnectPlayer(player);
}
GameObject playerGO = Instantiate(playerPrefab) as GameObject;
playerGO.name = PLAYER + " " + playerId;
player = playerGO.GetComponent <ServerPlayerController>();
player.endPoint = connectPlayerMessage.EndPoint;
player.Id = playerId;
players.Add(player);
BroadcastConnection(playerId);
}
void Update()
{
if (Input.GetKeyDown(KeyCode.C))
{
//send player connect message
outMessages.Add(ConnectPlayerMessage.CreateConnectPlayerMessageToSend(playerId));
}
if (Input.GetKeyDown(KeyCode.V))
{
//send player disconnect message
Packet p = new Packet();
DisconnectPlayerMessage disconnectPlayerMessage = new DisconnectPlayerMessage(GetNewReliableMessageId(), playerId);
p.buffer.PutInt(1);
disconnectPlayerMessage.Save(p.buffer);
p.buffer.Flush();
channel.Send(p);
}
Packet inPacket = channel.GetPacket();
if (inPacket != null)
{
//read it!
BitBuffer bitBuffer = inPacket.buffer;
int messageCount = bitBuffer.GetInt();
List <Message> serverMessages = new List <Message> ();
for (int i = 0; i < messageCount; i++)
{
//parse message
Message serverMessage = ReadServerMessage(bitBuffer);
if (serverMessage != null)
{
serverMessages.Add(serverMessage);
}
}
for (int i = 0; i < serverMessages.Count; i++)
{
ProcessServerMessage(serverMessages[i]);
}
}
if (localPlayerController != null)
{
PlayerInputMessage playerInputMessage = new PlayerInputMessage(-1, localPlayerController.Input);
outMessages.Add(playerInputMessage);
outMessages.Add(AckReliableSendEveryFrameMessage.CreateAckReliableSendEveryFrameMessageMessageToSend(lastReceivedSendInEveryFramePacketMessageId));
}
int messagesReadyToSend = 0;
for (int i = 0; i < outMessages.Count; i++)
{
Message clientMessage = outMessages [i];
clientMessage.Update(Time.deltaTime);
if (clientMessage.NeedsToBeSent)
{
messagesReadyToSend++;
}
}
if (messagesReadyToSend > 0)
{
Packet outPacket = new Packet();
outPacket.buffer.PutInt(outMessages.Count);
for (int i = 0; i < outMessages.Count; i++)
{
Message clientMessage = outMessages [i];
clientMessage.Save(outPacket.buffer);
if (clientMessage.Reliability == ReliabilityType.UNRELIABLE)
{
outMessages.RemoveAt(i);
i--;
}
else if (clientMessage.Reliability == ReliabilityType.RELIABLE_SEND_EVERY_PACKET)
{
clientMessage.TimeToSend = 0;
}
else
{
clientMessage.TimeToSend = clientMessage.ReliableMaxTime;
}
}
outPacket.buffer.Flush();
channel.Send(outPacket);
}
}