public void SendMap(INetChannel channel)
{
if (_netManager.IsClient)
{
return;
}
Debug.Assert(_netManager.IsServer, "Why is the client calling this?");
Logger.Info(channel.RemoteAddress + ": Sending map");
var quantityGridsSent = 0;
foreach (var map in GetAllMaps())
{
foreach (var grid in map.GetAllGrids())
{
quantityGridsSent++;
var message = _netManager.CreateNetMessage <MsgMap>();
message.MessageType = MapMessage.SendTileMap;
message.MapIndex = map.Index;
message.GridIndex = grid.Index;
// Map chunks
var gridSize = grid.ChunkSize;
message.ChunkSize = gridSize;
message.ChunkDefs = new MsgMap.ChunkDef[grid.ChunkCount];
var defCounter = 0;
foreach (var chunk in grid.GetMapChunks())
{
var newChunk = new MsgMap.ChunkDef
{
X = chunk.X,
Y = chunk.Y
};
newChunk.Tiles = new uint[gridSize * gridSize];
var counter = 0;
foreach (var tile in chunk)
{
newChunk.Tiles[counter] = (uint)tile.Tile;
counter++;
}
message.ChunkDefs[defCounter++] = newChunk;
}
_netManager.ServerSendMessage(message, channel);
}
}
var msg = _netManager.CreateNetMessage <MsgMap>();
msg.MessageType = MapMessage.SendMapInfo;
msg.MapGridsToSend = quantityGridsSent;
_netManager.ServerSendMessage(msg, channel);
}
/// <inheritdoc />
public void SendMap(INetChannel channel)
{
Debug.Assert(_netManager.IsServer, "Why is the client calling this?");
//TODO: This should be a part of the network message, so that multiple maps(z-levels) are possible.
const int MAP_INDEX = 0;
Logger.Log(channel.RemoteAddress + ": Sending map");
var message = _netManager.CreateNetMessage <MsgMap>();
message.MessageType = MapMessage.SendTileMap;
message.MapIndex = MAP_INDEX;
// Tile definition mapping
message.TileDefs = new MsgMap.TileDef[_defManager.Count];
for (var i = 0; i < _defManager.Count; i++)
{
message.TileDefs[i] = new MsgMap.TileDef()
{
Name = _defManager[i].Name
};
}
// Map chunks
var grid = _mapManager.GetGrid(MAP_INDEX);
var gridSize = grid.ChunkSize;
message.ChunkSize = gridSize;
message.ChunkDefs = new MsgMap.ChunkDef[grid.ChunkCount];
var defCounter = 0;
foreach (var chunk in grid.GetMapChunks())
{
var newChunk = new MsgMap.ChunkDef()
{
X = chunk.X,
Y = chunk.Y
};
newChunk.Tiles = new uint[gridSize * gridSize];
var counter = 0;
foreach (var tile in chunk)
{
newChunk.Tiles[counter] = (uint)tile.Tile;
counter++;
}
message.ChunkDefs[defCounter++] = newChunk;
}
_netManager.ServerSendMessage(message, channel);
}
private void BroadcastTableUpdate(int id, string str)
{
if (_network.IsClient)
{
return;
}
var message = _network.CreateNetMessage <MsgStringTableEntry>();
message.EntryId = id;
message.EntryString = str;
_network.ServerSendToAll(message);
}
private void _msgReqData(MsgViewVariablesReqData message)
{
if (!_sessions.TryGetValue(message.SessionId, out var session) ||
session.PlayerUser != message.MsgChannel.UserId)
{
// TODO: logging?
return;
}
var blob = session.DataRequest(message.RequestMeta);
var dataMsg = _netManager.CreateNetMessage <MsgViewVariablesRemoteData>();
dataMsg.RequestId = message.RequestId;
dataMsg.Blob = blob;
_netManager.ServerSendMessage(dataMsg, message.MsgChannel);
}
/// <summary>
/// Update a single clients group data.
/// </summary>
/// <param name="session">The client session to update.</param>
private void UpdateClientData(IPlayerSession session)
{
var group = _sessions.GetSessionGroup(session);
var groupData = _groups.Groups[group];
var msg = _netManager.CreateNetMessage <MsgConGroupUpdate>();
msg.ClientConGroup = groupData;
_netManager.ServerSendMessage(msg, session.ConnectedClient);
}
/// <summary>
/// Starts the handshake from the server end of the given channel,
/// sending a <see cref="MsgMapStrServerHandshake"/>.
/// </summary>
/// <param name="channel">The network channel to perform the handshake over.</param>
/// <remarks>
/// Locks the string mapping if this is the first time the server is
/// performing the handshake.
/// </remarks>
/// <seealso cref="MsgMapStrClientHandshake"/>
/// <seealso cref="MsgMapStrStrings"/>
public async Task Handshake(INetChannel channel)
{
DebugTools.Assert(_net.IsServer);
DebugTools.Assert(_dict.Locked);
_incompleteHandshakes.Add(channel);
var message = _net.CreateNetMessage <MsgMapStrServerHandshake>();
message.Hash = _stringMapHash;
_net.ServerSendMessage(message, channel);
while (_incompleteHandshakes.Contains(channel))
{
await Task.Delay(1);
}
LogSzr.Debug($"Completed handshake with {channel.RemoteEndPoint.Address}.");
}
private void BroadcastTableUpdate(int id, string str)
{
if (_network.IsClient)
{
return;
}
if (!_network.IsRunning)
{
return;
}
var message = _network.CreateNetMessage <MsgStringTableEntries>();
message.Entries = new MsgStringTableEntries.Entry[1];
message.Entries[0].Id = id;
message.Entries[0].String = str;
_network.ServerSendToAll(message);
}
/// <summary>
/// Inform the server that the client has a complete copy of the
/// mapping, and alert other code that the handshake is over.
/// </summary>
/// <seealso cref="ClientHandshakeComplete"/>
/// <seealso cref="NetworkInitialize"/>
private void OnClientCompleteHandshake(INetManager net, INetChannel channel)
{
LogSzr.Debug("Letting server know we're good to go.");
var handshake = net.CreateNetMessage <MsgMapStrClientHandshake>();
handshake.NeedsStrings = false;
channel.SendMessage(handshake);
if (ClientHandshakeComplete == null)
{
LogSzr.Warning("There's no handler attached to ClientHandshakeComplete.");
}
ClientHandshakeComplete?.Invoke();
}
/// <summary>
/// Interpret a server's handshake, either requesting a package
/// of strings or completing the handshake.
///
/// Uncached flow: <code>
/// Client | Server
/// | <-------------- Hash | <- you are here on client
/// | Need Strings ------> |
/// | <----------- Strings |
/// | Dont Need Strings -> |
/// </code>
///
/// Cached flow: <code>
/// Client | Server
/// | <-------------- Hash | <- you are here on client
/// | Dont Need Strings -> |
/// </code>
///
/// Verification failure flow: <code>
/// Client | Server
/// | <-------------- Hash | <- you are here on client
/// | Need Strings ------> |
/// | <----------- Strings |
/// + Hash Failed |
/// | Need Strings ------> |
/// | <----------- Strings |
/// | Dont Need Strings -> |
/// </code>
///
/// NOTE: Verification failure flow is currently not implemented.
/// </summary>
/// <exception cref="InvalidOperationException">Mapped strings are locked.</exception>
/// <seealso cref="NetworkInitialize"/>
private void HandleServerHandshake(INetManager net, MsgRobustMappedStringsSerializerServerHandshake msgRobustMappedStringsSerializer)
{
if (net.IsServer)
{
LogSzr.Error("Received server handshake on server.");
return;
}
ServerHash = msgRobustMappedStringsSerializer.Hash;
LockMappedStrings = false;
if (LockMappedStrings)
{
throw new InvalidOperationException("Mapped strings are locked.");
}
ClearStrings();
var hashStr = ConvertToBase64Url(Convert.ToBase64String(msgRobustMappedStringsSerializer.Hash !));
LogSzr.Debug($"Received server handshake with hash {hashStr}.");
var fileName = CacheForHash(hashStr);
if (!File.Exists(fileName))
{
LogSzr.Debug($"No string cache for {hashStr}.");
var handshake = net.CreateNetMessage <MsgRobustMappedStringsSerializerClientHandshake>();
LogSzr.Debug("Asking server to send mapped strings.");
handshake.NeedsStrings = true;
msgRobustMappedStringsSerializer.MsgChannel.SendMessage(handshake);
}
else
{
LogSzr.Debug($"We had a cached string map that matches {hashStr}.");
using var file = File.OpenRead(fileName);
var added = LoadStrings(file);
_stringMapHash = msgRobustMappedStringsSerializer.Hash !;
LogSzr.Debug($"Read {added} strings from cache {hashStr}.");
LockMappedStrings = true;
LogSzr.Debug($"Locked in at {_mappedStrings.Count} mapped strings.");
// ok we're good now
var channel = msgRobustMappedStringsSerializer.MsgChannel;
OnClientCompleteHandshake(net, channel);
}
}
private async void OnConnected(object?sender, NetChannelArgs e)
{
if (IPAddress.IsLoopback(e.Channel.RemoteEndPoint.Address))
{
return;
}
var lastRead = await _dbManager.GetLastReadRules(e.Channel.UserId);
if (lastRead > LastValidReadTime)
{
return;
}
var message = _netManager.CreateNetMessage <ShouldShowRulesPopupMessage>();
_netManager.ServerSendMessage(message, e.Channel);
}
private void RequestPlayerList()
{
var message = _netManager.CreateNetMessage <AdminMenuPlayerListRequest>();
_netManager.ClientSendMessage(message);
}
private void OnAcceptPressed()
{
var message = _netManager.CreateNetMessage <RulesAcceptedMessage>();
_netManager.ClientSendMessage(message);
}
/// <inheritdoc />
public void SendMap(INetChannel channel)
{
Debug.Assert(_netManager.IsServer, "Why is the client calling this?");
Logger.Log(channel.RemoteAddress + ": Sending map");
int QuantityGridsSent = 0;
foreach (Map Map in GetAllMaps())
{
foreach (IMapGrid Grid in Map.GetAllGrids())
{
QuantityGridsSent++;
var message = _netManager.CreateNetMessage <MsgMap>();
message.MessageType = MapMessage.SendTileMap;
message.MapIndex = Map.Index;
message.GridIndex = Grid.Index;
// Tile definition mapping
message.TileDefs = new MsgMap.TileDef[_defManager.Count];
for (var i = 0; i < _defManager.Count; i++)
{
message.TileDefs[i] = new MsgMap.TileDef()
{
Name = _defManager[i].Name
};
}
// Map chunks
var grid = _mapManager.GetMap(Map.Index).GetGrid(Grid.Index);
var gridSize = grid.ChunkSize;
message.ChunkSize = gridSize;
message.ChunkDefs = new MsgMap.ChunkDef[grid.ChunkCount];
var defCounter = 0;
foreach (var chunk in grid.GetMapChunks())
{
var newChunk = new MsgMap.ChunkDef()
{
X = chunk.X,
Y = chunk.Y
};
newChunk.Tiles = new uint[gridSize * gridSize];
var counter = 0;
foreach (var tile in chunk)
{
newChunk.Tiles[counter] = (uint)tile.Tile;
counter++;
}
message.ChunkDefs[defCounter++] = newChunk;
}
_netManager.ServerSendMessage(message, channel);
}
}
var mapmessage = _netManager.CreateNetMessage <MsgMap>();
mapmessage.MessageType = MapMessage.SendMapInfo;
mapmessage.MapGridsToSend = QuantityGridsSent;
_netManager.ServerSendMessage(mapmessage, channel);
}
