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);
}
/// <summary>
/// Sends the full table to a channel.
/// </summary>
/// <param name="channel">The channel that will receive the table.</param>
public void SendFullTable(INetChannel channel)
{
if (_network.IsClient)
{
return;
}
var message = _network.CreateNetMessage <MsgStringTableEntries>();
var count = _strings.Count;
message.Entries = new MsgStringTableEntries.Entry[count];
var i = 0;
foreach (var kvEntries in _strings)
{
message.Entries[i].Id = kvEntries.Key;
message.Entries[i].String = kvEntries.Value;
i++;
}
Logger.InfoS("net", $"Sending message name string table to {channel.RemoteEndPoint.Address}.");
_network.ServerSendMessage(message, channel);
}
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}.");
}
/// <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);
}
/// <summary>
/// Sends the full table to a channel.
/// </summary>
/// <param name="channel">The channel that will receive the table.</param>
public void SendFullTable(INetChannel channel)
{
if (_network.IsClient)
{
return;
}
var message = _network.CreateNetMessage <MsgStringTableEntry>();
foreach (var kvEntries in _strings)
{
message.EntryId = kvEntries.Key;
message.EntryString = kvEntries.Value;
_network.ServerSendMessage(message, channel);
}
}
private async void OnConnected(object?sender, NetChannelArgs e)
{
if (IPAddress.IsLoopback(e.Channel.RemoteEndPoint.Address) && _cfg.GetCVar(CCVars.RulesExemptLocal))
{
return;
}
var lastRead = await _dbManager.GetLastReadRules(e.Channel.UserId);
if (lastRead > LastValidReadTime)
{
return;
}
var message = new ShouldShowRulesPopupMessage();
_netManager.ServerSendMessage(message, e.Channel);
}
/// <summary>
/// Sends the full table to a channel.
/// </summary>
/// <param name="channel">The channel that will receive the table.</param>
public void SendFullTable(INetChannel channel)
{
if (_network.IsClient)
{
return;
}
var message = _network.CreateNetMessage <MsgStringTableEntries>();
var count = _strings.Count;
message.Entries = new MsgStringTableEntries.Entry[count];
var i = 0;
foreach (var kvEntries in _strings)
{
message.Entries[i].Id = kvEntries.Key;
message.Entries[i].String = kvEntries.Value;
i++;
}
_network.ServerSendMessage(message, channel);
}
/// <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);
}
