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 MessageHandler RegisterNetwork(string guid, MessageHandler send, PlatformerCharacterConfig config, DemoSettingsServer settings)
{
var trustSquared = settings.trustDistance * settings.trustDistance;
var broadcastInputMsg = new PlayerInputMessage();
broadcastInputMsg.playerGuid = guid;
this.platformerConfig = config;
this.networkSend = send;
StartCoroutine(ServerUpdate(send, settings.tickRate, guid));
return((opCode, message) => {
if (opCode == OpCode.PLAYER_INPUT)
{
var updatedState = (PlayerInputMessage)message;
updatedState.state.CopyTo(platformerInputState);
var actualPosition = transform.position;
var clientPosition = updatedState.position.toVector();
var deltaPosition = actualPosition - clientPosition;
if (deltaPosition.sqrMagnitude < trustSquared)
{
transform.position = clientPosition;
}
else
{
transform.position = (deltaPosition.normalized * settings.trustDistance) + actualPosition;
}
updatedState.state.CopyTo(broadcastInputMsg.state);
broadcastInputMsg.position.FromVector(transform.position);
send(OpCode.PLAYER_INPUT, broadcastInputMsg);
}
return 1;
});
}
public void Simulate(uint tickIndex)
{
if (_client.IsConnected)
{
bool up = Input.GetKey(KeyCode.W);
bool right = Input.GetKey(KeyCode.D);
bool down = Input.GetKey(KeyCode.S);
bool left = Input.GetKey(KeyCode.A);
bool space = Input.GetKeyDown(KeyCode.Space);
if (up || right || down || left || space)
{
Vector3 input = GetMovement(up, right, down, left);
HandleInputHistory(input);
var inputMessage = new PlayerInputMessage(_client.LocalPlayerId, input, space);
_client.SendMessage(inputMessage);
if (_localPlayer == null)
{
_localPlayer = _playerRegistry.GetControlledPlayerById(_client.LocalPlayerId);
}
_localPlayer.BufferInput(new InputData(input, tickIndex));
}
else
{
HandleInputHistory(Vector3.zero);
}
}
}
public void Handle(MessageWrapper messageWrapper, IPEndPoint sender)
{
PlayerInputMessage message =
ZeroFormatterSerializer.Deserialize <PlayerInputMessage>(messageWrapper.SerializedMessage);
int matchId = message.MatchId;
inputEntitiesCreator.TryAddMovementMessage(matchId, message.TemporaryId, message.GetVector2());
inputEntitiesCreator.TryAddAttackMessage(matchId, message.TemporaryId, message.Angle);
inputEntitiesCreator.TryAddAbilityMessage(matchId, message.TemporaryId, message.UseAbility);
}
public void SendInputMessage(float movementX, float movementY, float attackAngle, bool useAbility)
{
ushort myId = PlayerIdStorage.TmpPlayerIdForMatch;
// Debug.LogWarning($"{nameof(myId)} {myId}");
var message = new PlayerInputMessage(myId, matchId, movementX, movementY,
attackAngle, useAbility);
byte[] data = MessageFactory.GetSerializedMessage(message, false, out uint messageId);
udpClientWrapper.Send(data);
}
// Update is called once per frame
void Update()
{
time += Time.deltaTime;
acumTime += Time.deltaTime;
if (Input.GetKey(KeyCode.W))
{
frameActions.Add(PlayerAction.MoveForward);
}
if (Input.GetKey(KeyCode.A))
{
frameActions.Add(PlayerAction.MoveLeft);
}
if (Input.GetKey(KeyCode.S))
{
frameActions.Add(PlayerAction.MoveBack);
}
if (Input.GetKey(KeyCode.D))
{
frameActions.Add(PlayerAction.MoveRight);
}
if (Input.GetMouseButtonDown(0))
{
Shoot();
toSend.Add(new PlayerInputMessage(PlayerAction.Shoot, time, true));
}
if (acumTime >= (1.0f / GlobalSettings.Fps))
{
acumTime -= (1.0f / GlobalSettings.Fps);
foreach (var action in frameActions)
{
PlayerInputMessage msg = new PlayerInputMessage(action, time, true);
toSend.Add(msg);
if (SnapshotHandler.GetInstance().prediction)
{
actions.Enqueue(msg);
applyAction(action);
}
}
toSend.Add(new RotationMessage(this.gameObject.transform.eulerAngles));
frameActions.Clear();
}
camera.transform.position = this.gameObject.transform.position;
camera.transform.rotation = this.gameObject.transform.rotation;
}
private void UpdatePlayer(int id, float time)
{
List <PlayerInputMessage> playerActions = actions[id];
PlayerSnapshot ps = players[id];
ps._TimeStamp = this.time;
while (playerActions.Count > 0)
{
PlayerInputMessage mssg = playerActions[0];
playerActions.RemoveAt(0);
Mover.GetInstance().ApplyAction(ps, mssg.Action, time);
ps.lastId = mssg._MessageId;
}
}
void AvatarMoved(Vector3 _pos, Quaternion _rot)
{
PlayerInputMessage msg = new PlayerInputMessage();
Vect3 pos = new Vect3();
pos.x = _pos.x;
pos.y = _pos.y;
pos.z = _pos.z;
Quat rot = new Quat();
rot.x = _rot.x;
rot.y = _rot.y;
rot.z = _rot.z;
rot.w = _rot.w;
msg.position = pos;
msg.rotation = rot;
room.Send("input", msg);
}
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);
}
private void ProcessPacket(Packet packet)
{
bool reliableFlag = false;
foreach (GameMessage gm in packet.Messages)
{
if (gm.isReliable())
{
if (gm.type() == MessageType.PlayerInput)
{
PlayerInputMessage rm = (PlayerInputMessage)gm;
}
reliableFlag = true;
int id = ((ReliableMessage)gm)._MessageId;
if (gm.type() == MessageType.ClientConnect)
{
processConnect((ClientConnectMessage)gm, packet.connection);
}
else if (lastAcks[connections[packet.connection]] == id - 1)
{
MessageHandler.ProcessMessage(gm, packet.connection);
lastAcks[connections[packet.connection]] = ((ReliableMessage)gm)._MessageId;
processBufferedMessages(packet.connection);
}
else if (lastAcks[connections[packet.connection]] < id)
{
bufferMessage((ReliableMessage)gm, packet.connection);
}
}
else
{
MessageHandler.ProcessMessage(gm, packet.connection);
}
}
if (reliableFlag)
{
SendAck(packet.connection, lastAcks[connections[packet.connection]]);
}
}
void ProcessPlayerInput(PlayerInputMessage playerInputMessage)
{
Input = playerInputMessage.Input;
}
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);
}
}
private void processInput(PlayerInputMessage inputMessage, Connection connection)
{
int id = server.connections[connection];
server.actions[id].Add(inputMessage);
}
