public async Task <PlayerUpdateResponse> UpdatePlayerLocation(double latitude, double longitude, double altitude)
{
//SetCoordinates(latitude, longitude, altitude);
// This needs to me removed from here
Client.CurrentLatitude = latitude;
Client.CurrentLongitude = longitude;
Client.CurrentAltitude = altitude;
string latlngalt = latitude.ToString(CultureInfo.InvariantCulture) + ":" + longitude.ToString(CultureInfo.InvariantCulture) + ":" + altitude.ToString(CultureInfo.InvariantCulture);
File.WriteAllText(Directory.GetCurrentDirectory() + "\\Configs\\LastCoords.txt", latlngalt);
//
var message = new PlayerUpdateMessage
{
Latitude = Client.CurrentLatitude,
Longitude = Client.CurrentLongitude
};
Logger.Debug($"Calling Request UpdatePlayerLocation -> {latitude} / {longitude} / {altitude}");
var updatePlayerLocationRequestEnvelope = await GetRequestBuilder().GetRequestEnvelope(new Request[] {
new Request
{
RequestType = RequestType.PlayerUpdate,
RequestMessage = message.ToByteString()
}
}).ConfigureAwait(false);
return(await PostProtoPayload <Request, PlayerUpdateResponse>(updatePlayerLocationRequestEnvelope).ConfigureAwait(false));
}
//NOTE: CURRENTLY NO TESTING FOR ANY SECURITY, ONE PLAYER COULD SEND FAKE PACKETS IF THEY WERE SMART ENOUGH AND RIG THE GAME
public override void Update()
{
if (m_Server != null && m_Status != null)
{
m_Server.DispatchCallback(m_Status); //check for new or changed connections
foreach (var c in m_Connections)
{
netMessageCount = m_Server.ReceiveMessagesOnConnection(c.Key, netMessages, maxMessages);
m_NetworkMessageConnectionSource = c.Key;
readNetworkMessages();
}
HandleNewConnection(); //simple add to m_Connections if necessary
if (GameManager.Instance.HasGameStarted)
{
ClientPlayer cPlayer = GameManager.Instance.ClientPlayer;
if (cPlayer != null)
{
PlayerUpdateMessage cPlayerUpdateMsg = new PlayerUpdateMessage(FindObjectOfType <ClientPlayer>().m_PlayerInfo, GameManager.Instance.m_PlayerUsername);
SendMessageToAllPlayers(cPlayerUpdateMsg);
}
}
if (GameManager.Instance.HasGameStarted && !GameManager.Instance.HasGameEnded)
{
CheckForBoundsLoss(); //check if any player fallen behind
}
}
}
override public void parseMessage(string message)
{
Debug.Log(whoAmI() + "parsing message");
NetworkMessage networkMessage = NetworkMessage.decodeMessage(message);
string messageType = networkMessage.thisMessageType();
if (messageType == typeof(PlayerUpdateMessage).FullName)
{
PlayerUpdateMessage joinMsg = (PlayerUpdateMessage)networkMessage;
if (joinMsg.action == "join")
{
this.connectedPlayers.Add(new NetworkNode(joinMsg.ipAddress, Config.clientListenPort));
}
Debug.Log("[SERVER] client " + joinMsg.ipAddress + " " + joinMsg.action + "-ed ");
// update everyone on who is online
broadcastMessage(new JoinBroadcastMessage(connectedPlayerIps()));
}
else if (messageType == typeof(PingMessage).FullName)
{
Debug.Log("[SERVER] ping!");
}
else
{
broadcastMessage(networkMessage);
}
}
public async Task <PlayerUpdateResponse> UpdatePlayerLocation(double latitude, double longitude, double altitude)
{
SetCoordinates(latitude, longitude, altitude);
var message = new PlayerUpdateMessage
{
Latitude = _client.CurrentLatitude,
Longitude = _client.CurrentLongitude
};
var updatePlayerLocationRequestEnvelope = RequestBuilder.GetRequestEnvelope(
new Request
{
RequestType = RequestType.PlayerUpdate,
RequestMessage = message.ToByteString()
});
var updateResponse =
await PostProtoPayload <Request, PlayerUpdateResponse>(updatePlayerLocationRequestEnvelope);
lock (Client._lock)
{
_client._map.Invoke(new MethodInvoker(delegate {
var userOverlay = _client._map.Overlays[4];
userOverlay.Markers[0].Position = new GMap.NET.PointLatLng(_client.CurrentLatitude, _client.CurrentLongitude);
}));
}
return(updateResponse);
}
internal void SendClientInputPredictionsToServer(SimulationTickNumber currentSimTickNumber, NetworkMessageWriter networkMessageWriter)
{
for (int playerIdx = 0; playerIdx < _localPlayers.Count; playerIdx++)
{
ref var player = ref _localPlayers.Items[playerIdx];
var inputSnapshotsComp = player.InputSnapshotsComponent;
PlayerUpdateMessage playerUpdateMsg = default;
var pendingInputs = inputSnapshotsComp.PendingInputs;
// Need to limit the number of input, eg. if there's a large delay in server ack response,
// then most likely it has lost some of our older input. Probably should be a config setting?
const int MaxPendingPlayerInputs = GameConfig.PhysicsSimulationRate * 20; // 20s worth of input
const int MaxSendPlayerInputs = 10; // We will only send 10 inputs max in a single packet, and accept the fact that older inputs may be lost
if (pendingInputs.Count >= MaxPendingPlayerInputs)
{
pendingInputs.RemoveRange(0, pendingInputs.Count - MaxPendingPlayerInputs + 1);
}
// Append the latest input
var findSnapshotResult = inputSnapshotsComp.SnapshotStore.TryFindSnapshot(currentSimTickNumber);
Debug.Assert(findSnapshotResult.IsFound);
pendingInputs.Add(findSnapshotResult.Result);
int sendInputCount = Math.Min(pendingInputs.Count, MaxSendPlayerInputs);
// At most, only send the last 10 inputs (ie. the current inputs) to not blow out the packet size.
int inputIndexOffset = pendingInputs.Count - sendInputCount;
for (int i = 0; i < sendInputCount; i++)
{
int inputIndex = i + inputIndexOffset;
if (pendingInputs[inputIndex].PlayerInputSequenceNumber > inputSnapshotsComp.ServerLastAcknowledgedPlayerInputSequenceNumber)
{
inputIndexOffset += i;
sendInputCount -= i;
break;
}
}
networkMessageWriter.Reset();
playerUpdateMsg.AcknowledgedServerSimulationTickNumber = player.NetworkEntityComponent.LastAcknowledgedServerSimulationTickNumber;
playerUpdateMsg.WriteTo(networkMessageWriter);
PlayerUpdateInputMessage playerUpdateInputsMsg = default;
playerUpdateInputsMsg.WriteHeader(networkMessageWriter, (ushort)sendInputCount);
for (int i = 0; i < sendInputCount; i++)
{
int inputIndex = i + inputIndexOffset;
ref var curInputData = ref pendingInputs.Items[inputIndex];
playerUpdateInputsMsg.PlayerInputSequenceNumber = curInputData.PlayerInputSequenceNumber;
playerUpdateInputsMsg.MoveInput = curInputData.MoveInput;
playerUpdateInputsMsg.JumpRequestedInput = curInputData.IsJumpButtonDown;
playerUpdateInputsMsg.WriteNextArrayItem(networkMessageWriter);
#if DEBUG
//if (curInputData.MoveInput.LengthSquared() > 0)
//{
// _networkEntityProcessor.DebugWriteLine($"Cln SendInput Move: {curInputData.MoveInput} - PISeqNo: {curInputData.PlayerInputSequenceNumber}");
//}
#endif
}
private void ClientReceiveUpdate(NetworkMessage message) //lo que recibe al conectarse
{
PlayerUpdateMessage msg = message.ReadMessage <PlayerUpdateMessage>();
player.transform.position = msg.position;
mov.speed = msg.speed;
mov.lives = msg.lives;
}
public static Message decipherMessage(byte[] msgBytes)
{
if (BitConverter.IsLittleEndian)
{
//Array.Reverse(msgBytes);
}
Message msg;
byte[] eventTypeBytes = new byte[2];
Buffer.BlockCopy(msgBytes, 0, eventTypeBytes, 0, 2);
ushort sho = BitConverter.ToUInt16(eventTypeBytes, 0);
NetworkEvent eventType = (NetworkEvent)sho;
switch (eventType)
{
case NetworkEvent.StartGame:
msg = new GameStartMessage(msgBytes);
break;
case NetworkEvent.PlayerUpdateInfo:
msg = new PlayerUpdateMessage(msgBytes);
break;
case NetworkEvent.PlayerConnected:
msg = new PlayerConnectedMessage(msgBytes);
break;
case NetworkEvent.PlayerDisconnected:
msg = new PlayerDisconnectedMessage(msgBytes);
break;
case NetworkEvent.ObstacleGenerated:
msg = new ObstacleGeneratedMessage(msgBytes);
break;
case NetworkEvent.PlayerFellBehind:
msg = new PlayerFellBehindMessage(msgBytes);
break;
case NetworkEvent.ObstacleModified:
msg = new ObstacleModifiedMessage(msgBytes);
break;
case NetworkEvent.PlayerWonRace:
msg = new PlayerWonMessage(msgBytes);
break;
case NetworkEvent.PlayerAttackPlayer:
msg = new PlayerAttackedPlayerMessage(msgBytes);
break;
default:
throw new Exception("oops " + eventType);
}
return(msg);
}
public override void HandleNetworkMessage(Message msg)
{
base.HandleNetworkMessage(msg);
if (msg is PlayerConnectedMessage) //player sends this once connected to send name
{
PlayerConnectedMessage nMsg = msg as PlayerConnectedMessage;
if (GameManager.Instance.GetPlayer(nMsg.playerID) != null) //player name already used, prepare to kick
{
m_ConnectionToAdd = new KeyValuePair <uint, string>(m_NetworkMessageConnectionSource, "");
}
else
{
m_ConnectionToAdd = new KeyValuePair <uint, string>(m_NetworkMessageConnectionSource, nMsg.playerID);
//Send the player connected info to everyone
ClientPlayer cP = GameManager.Instance.ClientPlayer;
if (cP != null)
{
SendMessageToAllExceptPlayer(nMsg.playerID, new PlayerConnectedMessage(nMsg.playerID), SendType.Reliable);
}
//send current players to the connected player
List <Player> players = GameManager.Instance.m_Players;
for (int i = 0; i < players.Count; i++)
{
if (players[i] is ClientPlayer)
{
m_Server.SendMessageToConnection(m_NetworkMessageConnectionSource, new PlayerConnectedMessage(GameManager.Instance.m_PlayerUsername).toBuffer(), SendType.Reliable);
}
else
{
m_Server.SendMessageToConnection(m_NetworkMessageConnectionSource, new PlayerConnectedMessage((players[i] as NetworkedPlayer).playerID).toBuffer(), SendType.Reliable);
}
}
GameManager.Instance.AddPlayer(nMsg.playerID);
Invoke("RealignPlayersAndSend", 0.1f); //need a delay for them to add the player
}
}
if (msg is PlayerUpdateMessage)
{
PlayerUpdateMessage nMsg = msg as PlayerUpdateMessage;
GameManager.Instance.UpdatePlayerInformation(ref nMsg.info, nMsg.playerID);
SendMessageToAllExceptPlayer(nMsg.playerID, nMsg);
}
if (msg is ObstacleModifiedMessage)
{
Debug.Log("Obstacle Modified Message");
ObstacleModifiedMessage nMsg = msg as ObstacleModifiedMessage;
SendMessageToAllExceptPlayer(nMsg.playerID, nMsg, SendType.Reliable);
(GameManager.Instance.m_AllObstacles[(int)nMsg.obstacleID] as IObstacle).InteractedWith(GameManager.Instance.GetPlayer(nMsg.playerID));
}
if (msg is PlayerAttackedPlayerMessage)
{
PlayerAttackedPlayerMessage nMsg = msg as PlayerAttackedPlayerMessage;
SendMessageToAllExceptPlayer(nMsg.attackeePlayerID, nMsg, SendType.Reliable);
GameManager.Instance.PlayerAttacked(nMsg.attackedPlayerID);
}
}
/// <summary>
///
/// </summary>
/// <param name="latitude"></param>
/// <param name="longitude"></param>
/// <param name="accuracy"></param>
/// <returns></returns>
public bool QueueUpdatePlayerLocationRequest(double latitude, double longitude, double accuracy)
{
SetCoordinates(latitude, longitude, accuracy);
var message = new PlayerUpdateMessage
{
Latitude = Client.CurrentPosition.Latitude,
Longitude = Client.CurrentPosition.Longitude,
};
return(Client.QueueRequest(RequestType.PlayerUpdate, message));
}
public async Task <PlayerUpdateResponse> UpdatePlayerLocation(double lat, double lng, double alt)
{
SetCoordinates(lat, lng, alt);
PlayerUpdateMessage playerUpdateMessage = new PlayerUpdateMessage()
{
Latitude = CurrentLat,
Longitude = CurrentLng
};
return(await AwaitableOnResponseFor <PlayerUpdateMessage, PlayerUpdateResponse>(playerUpdateMessage, RequestType.PlayerUpdate));
}
public override void HandleNetworkMessage(Message msg)
{
base.HandleNetworkMessage(msg);
if (msg is GameStartMessage)
{
GameStartMessage nMsg = msg as GameStartMessage;
ConnectionStatus cStat = new ConnectionStatus();
m_Server.GetQuickConnectionStatus(m_Connection, cStat);
uniformTimeOffset = ((nMsg.uniformTime.Ticks / TimeSpan.TicksPerSecond) + (((float)cStat.ping) * 0.01f)) - (DateTime.UtcNow.Ticks / TimeSpan.TicksPerSecond);
GameManager.Instance.StartGameInSeconds(nMsg.timeAfterToSpawn + uniformTimeOffset);
}
if (msg is PlayerConnectedMessage)
{
PlayerConnectedMessage nMsg = msg as PlayerConnectedMessage;
NetworkedPlayer p = GameManager.Instance.AddPlayer(nMsg.playerID);
p.playerID = nMsg.playerID;
}
else if (msg is PlayerDisconnectedMessage)
{
PlayerDisconnectedMessage nMsg = msg as PlayerDisconnectedMessage;
GameManager.Instance.RemovePlayer(nMsg.playerID);
}
else if (msg is PlayerUpdateMessage)
{
PlayerUpdateMessage nMsg = msg as PlayerUpdateMessage;
GameManager.Instance.UpdatePlayerInformation(ref nMsg.info, nMsg.playerID);
}
else if (msg is ObstacleGeneratedMessage)
{
ObstacleGeneratedMessage nMsg = msg as ObstacleGeneratedMessage;
TileManager.Instance.SpawnObstacle(nMsg.itemID, nMsg.itemPos, nMsg.itemType);
}
else if (msg is ObstacleModifiedMessage)
{
ObstacleModifiedMessage nMsg = msg as ObstacleModifiedMessage;
(GameManager.Instance.m_AllObstacles[(int)nMsg.obstacleID] as IObstacle).InteractedWith(GameManager.Instance.GetPlayer(nMsg.playerID));
}
else if (msg is PlayerFellBehindMessage)
{
PlayerFellBehindMessage nMsg = msg as PlayerFellBehindMessage;
GameManager.Instance.PlayerFellBehind(nMsg.playerID);
}
else if (msg is PlayerWonMessage)
{
PlayerWonMessage nMsg = msg as PlayerWonMessage;
GameManager.Instance.PlayerHasWonGame(GameManager.Instance.GetPlayer(nMsg.playerID));
}
else if (msg is PlayerAttackedPlayerMessage)
{
PlayerAttackedPlayerMessage nMsg = msg as PlayerAttackedPlayerMessage;
GameManager.Instance.PlayerAttacked(nMsg.attackedPlayerID);
}
}
private void ServerReceiveUpdate(NetworkMessage message) //cuando se conecta algun jugador
{
//PlayerTypeMessage msg = message.ReadMessage<PlayerTypeMessage>();
PlayerUpdateMessage msg = new PlayerUpdateMessage();
msg.position = playerpos;
msg.speed = speed;
msg.lives = lives;
//NetworkServer.SendToAll(MsgType.Connect, msg);
}
public async Task <PlayerUpdateResponse> UpdatePlayerLocation(double latitude, double longitude, double altitude)
{
SetCoordinates(latitude, longitude, altitude);
var message = new PlayerUpdateMessage
{
Latitude = Client.CurrentLatitude,
Longitude = Client.CurrentLongitude
};
var updatePlayerLocationRequestEnvelope = RequestBuilder.GetRequestEnvelope(
new Request
{
RequestType = RequestType.PlayerUpdate,
RequestMessage = message.ToByteString()
});
return(await PostProtoPayload <Request, PlayerUpdateResponse>(updatePlayerLocationRequestEnvelope));
}
public async Task<PlayerUpdateResponse> UpdatePlayerLocation(double latitude, double longitude, double altitude)
{
SetCoordinates(latitude, longitude, altitude);
var message = new PlayerUpdateMessage
{
Latitude = _client.CurrentLatitude,
Longitude = _client.CurrentLongitude
};
var updatePlayerLocationRequestEnvelope = RequestBuilder.GetRequestEnvelope(
new Request
{
RequestType = RequestType.PlayerUpdate,
RequestMessage = message.ToByteString()
});
return await PostProtoPayload<Request, PlayerUpdateResponse>(updatePlayerLocationRequestEnvelope);
}
private Task OnPlayerUpdate(PlayerUpdateMessage message)
{
var plr = _playerManager[message.AccountId];
if (plr == null)
{
_logger.Warning("<OnPlayerUpdate> Cant find player={Id}", message.AccountId);
return(Task.CompletedTask);
}
plr.TotalExperience = message.TotalExperience;
plr.RoomId = message.RoomId;
plr.TeamId = message.TeamId;
var channel = plr.Channel;
channel.Broadcast(new SUserDataAckMessage(plr.Map <Player, UserDataDto>()));
return(Task.CompletedTask);
}
void parseConnectionSearchMessage(string message)
{
try {
NetworkMessage networkMessage = NetworkMessage.decodeMessage(message);
string messageType = networkMessage.thisMessageType();
Debug.Log("[CLIENT] got connection ping from server. " + message);
if (messageType == typeof(DiscoveryPingMessage).FullName)
{
DiscoveryPingMessage dpm = (DiscoveryPingMessage)networkMessage;
this.node = new NetworkNode(dpm.sourceIp.ToString(), Config.serverListenPort);
this.serverNode = new NetworkNode(dpm.sourceIp.ToString(), Config.clientListenPort);
startListening(this.serverNode);
// send initial connection message
ipAddress = NetworkService.GetSelfIP();
PlayerUpdateMessage joinMsg = new PlayerUpdateMessage(ipAddress, "join");
this.sendMessageToServer(joinMsg);
serverDiscoveryClient.Close();
}
} catch (Exception e) {
Debug.Log(whoAmI() + e);
}
}
private void HandlePlayerUpdate(PlayerUpdateMessage playerUpdate)
{
Player = playerUpdate.Player;
}
