public LayerTile RemoveTile(Vector3Int cellPosition, LayerType layerType, bool removeAll = true)
    {
        var layerTile = metaTileMap.GetTile(cellPosition, layerType);

        if (metaTileMap.HasTile(cellPosition, layerType))
        {
            InternalRemoveTile(cellPosition, layerType, removeAll);

            RemoveTileMessage.Send(networkIdentity.netId, cellPosition, layerType, false);

            AddToChangeList(cellPosition, layerType);

            if (layerType == LayerType.Floors || layerType == LayerType.Base)
            {
                OnFloorOrPlatingRemoved.Invoke(cellPosition);
            }
            else if (layerType == LayerType.Windows)
            {
                RemoveTile(cellPosition, LayerType.Effects);
            }

            return(layerTile);
        }

        return(layerTile);
    }
Esempio n. 2
0
    public void RemoveAllOverlays(Vector3Int cellPosition, LayerType layerType, bool onlyIfCleanable = false)
    {
        cellPosition.z = 0;

        var overlayPos = metaTileMap.GetAllOverlayPos(cellPosition, layerType);

        if (overlayPos == null || overlayPos.Count == 0)
        {
            return;
        }

        foreach (var overlay in overlayPos)
        {
            cellPosition = overlay;

            if (onlyIfCleanable)
            {
                //only remove it if it's a cleanable tile
                var tile = metaTileMap.GetTile(cellPosition, layerType) as OverlayTile;
                //it's not an overlay tile or it's not cleanable so don't remove it
                if (tile == null || !tile.IsCleanable)
                {
                    continue;
                }
            }

            InternalRemoveTile(cellPosition, layerType, false);

            RemoveTileMessage.Send(networkIdentity.netId, cellPosition, layerType, false);

            AddToChangeList(cellPosition, layerType);
        }
    }
Esempio n. 3
0
    public void RemoveOverlaysOfName(Vector3Int cellPosition, LayerType layerType,
                                     string overlayName, bool onlyIfCleanable = false, TileType tileType = TileType.Effects)
    {
        cellPosition.z = 0;

        var overlayPos = metaTileMap.GetOverlayPos(cellPosition, layerType, overlayName);

        if (overlayPos == null)
        {
            return;
        }

        cellPosition = overlayPos.Value;

        if (onlyIfCleanable)
        {
            //only remove it if it's a cleanable tile
            var tile = metaTileMap.GetTile(cellPosition, layerType) as OverlayTile;
            //it's not an overlay tile or it's not cleanable so don't remove it
            if (tile == null || !tile.IsCleanable)
            {
                return;
            }
        }

        InternalRemoveTile(cellPosition, layerType, false);

        RemoveTileMessage.Send(networkIdentity.netId, cellPosition, layerType, false);

        AddToChangeList(cellPosition, layerType);
    }
Esempio n. 4
0
    public static RemoveTileMessage Send(uint tileChangeManagerNetID, Vector3 position, LayerType layerType, bool removeAll)
    {
        RemoveTileMessage msg = new RemoveTileMessage
        {
            Position          = position,
            LayerType         = layerType,
            RemoveAll         = removeAll,
            TileChangeManager = tileChangeManagerNetID
        };

        msg.SendToAll();
        return(msg);
    }
Esempio n. 5
0
    public static void Process()
    {
        if (!prefabsToSpawn.IsEmpty)
        {
            SpawnSafeThreadData data;
            while (prefabsToSpawn.TryDequeue(out data))
            {
                var result = Spawn.ServerPrefab(data.Prefab, data.WorldPosition,
                                                data.ParentTransform == null
                                                ? MatrixManager.GetDefaultParent(data.WorldPosition, true)
                                                : data.ParentTransform,
                                                count: data.Amount);

                //Greater than one as most items start stacked at 1
                if (result.Successful && data.AmountIfStackable > 1 &&
                    result.GameObject.TryGetComponent <Stackable>(out var stackable))
                {
                    // -1 as we are adding, eg if we want 10 in stack, item already starts at 1 so we add 9
                    stackable.ServerIncrease(data.AmountIfStackable - 1);
                }
            }
        }

        if (!tilesToUpdate.IsEmpty)
        {
            Tuple <uint, Vector3Int, TileType, string, Matrix4x4, Color, LayerType> tuple;
            while (tilesToUpdate.TryDequeue(out tuple))
            {
                UpdateTileMessage.Send(tuple.Item1, tuple.Item2, tuple.Item3, tuple.Item4, tuple.Item5, tuple.Item6,
                                       tuple.Item7);
            }
        }

        if (!tilesToRemove.IsEmpty)
        {
            Tuple <uint, Vector3Int, LayerType> tuple;
            while (tilesToRemove.TryDequeue(out tuple))
            {
                RemoveTileMessage.Send(tuple.Item1, tuple.Item2, tuple.Item3);
            }
        }
    }
    public void RemoveOverlay(Vector3Int cellPosition, LayerType layerType, bool onlyIfCleanable = false)
    {
        cellPosition.z = -1;

        if (metaTileMap.HasTile(cellPosition, layerType))
        {
            if (onlyIfCleanable)
            {
                //only remove it if it's a cleanable tile
                var tile = metaTileMap.GetTile(cellPosition, layerType) as OverlayTile;
                //it's not an overlay tile or it's not cleanable so don't remove it
                if (tile == null || !tile.IsCleanable)
                {
                    return;
                }
            }

            InternalRemoveTile(cellPosition, layerType, false);

            RemoveTileMessage.Send(networkIdentity.netId, cellPosition, layerType, false);

            AddToChangeList(cellPosition, layerType, removeAll: true);
        }
    }