/// <summary>
            /// Transforms global world coordinates to chunk indices relative to grid origin.
            /// </summary>
            /// <param name="localPos">The position in the world.</param>
            /// <returns></returns>
            public MapIndices WorldToChunk(GridLocalCoordinates posWorld)
            {
                var local = posWorld.ConvertToGrid(this);
                var x     = (int)Math.Floor(local.X / (TileSize * ChunkSize));
                var y     = (int)Math.Floor(local.Y / (TileSize * ChunkSize));

                return(new MapIndices(x, y));
            }
        /// <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 GridLocalCoordinates(x, y, message.GridIndex);

            pos.Grid.SetTile(pos, tile);
        }
            public MapIndices SnapGridCellFor(GridLocalCoordinates worldPos, SnapGridOffset offset)
            {
                var local = worldPos.ConvertToGrid(this);

                if (offset == SnapGridOffset.Edge)
                {
                    local = local.Offset(new Vector2(TileSize / 2f, TileSize / 2f));
                }
                var x = (int)Math.Floor(local.X / TileSize);
                var y = (int)Math.Floor(local.Y / TileSize);

                return(new MapIndices(x, y));
            }
            /// <inheritdoc />
            public TileRef GetTile(GridLocalCoordinates worldPos)
            {
                var chunkIndices    = WorldToChunk(worldPos);
                var gridTileIndices = WorldToTile(worldPos);

                Chunk output;

                if (_chunks.TryGetValue(chunkIndices, out output))
                {
                    var chunkTileIndices = output.GridTileToChunkTile(gridTileIndices);
                    return(output.GetTile((ushort)chunkTileIndices.X, (ushort)chunkTileIndices.Y));
                }
                return(new TileRef(MapID, Index, gridTileIndices.X, gridTileIndices.Y, default(Tile)));
            }
            /// <inheritdoc />
            public IMapGrid FindGridAt(GridLocalCoordinates worldPos)
            {
                var pos = worldPos.ToWorld().Position;

                return(FindGridAt(pos));
            }
 /// <inheritdoc />
 public GridLocalCoordinates LocalToWorld(GridLocalCoordinates posLocal)
 {
     return(new GridLocalCoordinates(posLocal.Position + WorldPosition, posLocal.MapID));
 }
 /// <inheritdoc />
 public void SetTile(GridLocalCoordinates worldPos, ushort tileId, ushort tileData = 0)
 {
     SetTile(worldPos, new Tile(tileId, tileData));
 }
            /// <inheritdoc />
            public void SetTile(GridLocalCoordinates worldPos, Tile tile)
            {
                var localTile = WorldToTile(worldPos);

                SetTile(localTile.X, localTile.Y, tile);
            }
 public void RemoveFromSnapGridCell(GridLocalCoordinates worldPos, SnapGridOffset offset, SnapGridComponent snap)
 {
     RemoveFromSnapGridCell(SnapGridCellFor(worldPos, offset), offset, snap);
 }
 public void AddToSnapGridCell(GridLocalCoordinates worldPos, SnapGridOffset offset, SnapGridComponent snap)
 {
     AddToSnapGridCell(SnapGridCellFor(worldPos, offset), offset, snap);
 }
 public IEnumerable <SnapGridComponent> GetSnapGridCell(GridLocalCoordinates worldPos, SnapGridOffset offset)
 {
     return(GetSnapGridCell(SnapGridCellFor(worldPos, offset), offset));
 }