/// <summary>
/// Deserializes an IMapManager and ITileDefinitionManager from a properly formatted NetMessage.
/// </summary>
/// <param name="message">The message containing a serialized map and tileDefines.</param>
private void HandleTileMap(MsgMap message)
{
Debug.Assert(_netManager.IsClient, "Why is the server calling this?");
var mapIndex = message.MapIndex;
_defManager.RegisterServerTileMapping(message);
var chunkSize = message.ChunkSize;
var chunkCount = message.ChunkDefs.Length;
if (!_mapManager.TryGetGrid(mapIndex, out IMapGrid grid))
{
grid = _mapManager.CreateGrid(mapIndex, chunkSize);
}
for (var i = 0; i < chunkCount; ++i)
{
var chunkPos = new MapGrid.Indices(message.ChunkDefs[i].X, message.ChunkDefs[i].Y);
var chunk = grid.GetChunk(chunkPos);
var counter = 0;
for (ushort x = 0; x < chunk.ChunkSize; x++)
{
for (ushort y = 0; y < chunk.ChunkSize; y++)
{
chunk.SetTile(x, y, (Tile)message.ChunkDefs[i].Tiles[counter]);
counter++;
}
}
}
}
private void HandleNetworkMessage(MsgMap message)
{
switch (message.MessageType)
{
case MapMessage.TurfClick:
HandleTurfClick(message);
break;
case MapMessage.TurfUpdate:
HandleTileUpdate(message);
break;
case MapMessage.SendTileMap:
HandleTileMap(message);
break;
case MapMessage.SendMapInfo:
CollectMapInfo(message);
break;
case MapMessage.CreateMap:
CreateMap(message.MapIndex);
break;
case MapMessage.DeleteMap:
DeleteMap(message.MapIndex);
break;
default:
throw new ArgumentOutOfRangeException(nameof(message));
}
}
private void HandleTurfClick(MsgMap message)
{
/*
* // Who clicked and on what tile.
* Atom.Atom clicker = SS13Server.Singleton.playerManager.GetSessionByConnection(message.SenderConnection).attachedAtom;
* short x = message.ReadInt16();
* short y = message.ReadInt16();
* if (Vector2.Distance(clicker.position, new Vector2(x * tileSpacing + (tileSpacing / 2), y * tileSpacing + (tileSpacing / 2))) > 96)
* {
* return; // They were too far away to click us!
* }
* bool Update = false;
* if (IsSaneArrayPosition(x, y))
* {
* Update = tileArray[x, y].ClickedBy(clicker);
* if (Update)
* {
* if (tileArray[x, y].tileState == TileState.Dead)
* {
* Tiles.Atmos.GasCell g = tileArray[x, y].gasCell;
* Tiles.Tile t = GenerateNewTile(x, y, tileArray[x, y].tileType);
* tileArray[x, y] = t;
* tileArray[x, y].gasCell = g;
* }
* NetworkUpdateTile(x, y);
* }
* }
*/
}
/// <summary>
/// Deserializes an IMapManager and ITileDefinitionManager from a properly formatted NetMessage.
/// </summary>
/// <param name="message">The message containing a serialized map and tileDefines.</param>
private void HandleTileMap(MsgMap message)
{
Debug.Assert(_netManager.IsClient, "Why is the server calling this?");
_gridsReceived++;
var mapIndex = message.MapIndex;
var gridIndex = message.GridIndex;
var chunkSize = message.ChunkSize;
var chunkCount = message.ChunkDefs.Length;
if (!TryGetMap(mapIndex, out var map))
{
map = CreateMap(mapIndex);
}
if (!map.GridExists(gridIndex))
{
GetMap(mapIndex).CreateGrid(gridIndex, chunkSize);
}
var grid = GetMap(mapIndex).GetGrid(gridIndex);
SuppressOnTileChanged = true;
var modified = new List <(int x, int y, Tile tile)>();
for (var i = 0; i < chunkCount; ++i)
{
var chunkPos = new MapGrid.Indices(message.ChunkDefs[i].X, message.ChunkDefs[i].Y);
var chunk = grid.GetChunk(chunkPos);
var counter = 0;
for (ushort x = 0; x < chunk.ChunkSize; x++)
{
for (ushort y = 0; y < chunk.ChunkSize; y++)
{
var tile = (Tile)message.ChunkDefs[i].Tiles[counter];
if (chunk.GetTile(x, y).Tile != tile)
{
chunk.SetTile(x, y, tile);
modified.Add((x + chunk.X * chunk.ChunkSize, y + chunk.Y * chunk.ChunkSize, tile));
}
counter++;
}
}
}
SuppressOnTileChanged = false;
if (modified.Count != 0)
{
GridChanged?.Invoke(this, new GridChangedEventArgs(grid, modified));
}
if (_gridsReceived == _gridsToReceive)
{
IoCManager.Resolve <IEntityManager>().MapsInitialized = true;
}
}
private void CollectMapInfo(MsgMap message)
{
Debug.Assert(_netManager.IsClient, "Why is the server calling this?");
_gridsToReceive = message.MapGridsToSend;
if (_gridsReceived == _gridsToReceive)
{
IoCManager.Resolve <IEntityManager>().MapsInitialized = true;
}
}
/// <summary>
/// Updates a single tile from the network message.
/// </summary>
/// <param name="message">The message containing the info.</param>
private void HandleTileUpdate(MsgMap message)
{
Debug.Assert(_netManager.IsClient, "Why is the server calling this?");
var x = message.SingleTurf.X;
var y = message.SingleTurf.Y;
var tile = (Tile)message.SingleTurf.Tile;
var pos = new LocalCoordinates(x, y, message.GridIndex, message.MapIndex);
pos.Grid.SetTile(pos, tile);
}
public void HandleNetworkMessage(MsgMap message)
{
switch (message.MessageType)
{
case MapMessage.TurfClick:
//HandleTurfClick(message);
break;
default:
break;
}
}
/// <summary>
/// Deserializes an IMapManager and ITileDefinitionManager from a properly formatted NetMessage.
/// </summary>
/// <param name="message">The message containing a serialized map and tileDefines.</param>
private void HandleTileMap(MsgMap message)
{
Debug.Assert(_netManager.IsClient, "Why is the server calling this?");
_gridsReceived++;
var mapIndex = message.MapIndex;
var gridIndex = message.GridIndex;
_defManager.RegisterServerTileMapping(message);
var chunkSize = message.ChunkSize;
var chunkCount = message.ChunkDefs.Length;
if (!TryGetMap(mapIndex, out var map))
{
map = CreateMap(mapIndex);
}
if (!map.GridExists(gridIndex))
{
GetMap(mapIndex).CreateGrid(gridIndex, chunkSize);
}
var grid = GetMap(mapIndex).GetGrid(gridIndex);
SuppressOnTileChanged = true;
for (var i = 0; i < chunkCount; ++i)
{
var chunkPos = new MapGrid.Indices(message.ChunkDefs[i].X, message.ChunkDefs[i].Y);
var chunk = grid.GetChunk(chunkPos);
var counter = 0;
for (ushort x = 0; x < chunk.ChunkSize; x++)
{
for (ushort y = 0; y < chunk.ChunkSize; y++)
{
chunk.SetTile(x, y, (Tile)message.ChunkDefs[i].Tiles[counter]);
counter++;
}
}
}
SuppressOnTileChanged = false;
GridChanged?.Invoke(this, new GridChangedEventArgs(grid));
if (_gridsReceived == _gridsToReceive)
{
IoCManager.Resolve <IEntityManager>().MapsInitialized = true;
}
}
/// <summary>
/// Updates a single tile from the network message.
/// </summary>
/// <param name="message">The message containing the info.</param>
private void HandleTileUpdate(MsgMap message)
{
Debug.Assert(_netManager.IsClient, "Why is the server calling this?");
var x = message.SingleTurf.X;
var y = message.SingleTurf.Y;
var tile = (Tile)message.SingleTurf.Tile;
//TODO: This should be a part of the network message, so that multiple maps(z-levels) are possible.
const int MAP_INDEX = 0;
_mapManager.GetGrid(MAP_INDEX).SetTile(x, y, tile);
}
public void RegisterServerTileMapping(MsgMap message)
{
foreach (var tileDef in _tileDefs)
{
tileDef.InvalidateTileId();
}
_tileDefs.Clear();
_tileIds.Clear();
for (var i = 0; i < message.TileDefs.Length; ++i)
{
var tileName = message.TileDefs[i].Name;
var tileDef = this[tileName];
_tileDefs.Add(tileDef);
_tileIds[tileDef] = (ushort)i;
}
}
/// <inheritdoc />
public void HandleNetworkMessage(MsgMap message)
{
switch (message.MessageType)
{
case MapMessage.TurfClick:
HandleTurfClick(message);
break;
case MapMessage.TurfUpdate:
HandleTileUpdate(message);
break;
case MapMessage.SendTileMap:
HandleTileMap(message);
break;
default:
throw new ArgumentOutOfRangeException(nameof(message));
}
}
