public void Erase(Tilemap tilemap, Vector2 localPos)
        {
            int minGridX = m_brushTilemap.MinGridX;
            int minGridY = m_brushTilemap.MinGridY;
            int maxGridX = m_brushTilemap.MaxGridX;
            int maxGridY = m_brushTilemap.MaxGridY;

            if (IsUndoEnabled)
            {
#if UNITY_EDITOR
                Undo.RecordObject(tilemap, Tilemap.k_UndoOpName + tilemap.name);
                Undo.RecordObjects(tilemap.GetComponentsInChildren <TilemapChunk>(), Tilemap.k_UndoOpName + tilemap.name);
#endif
            }
            tilemap.IsUndoEnabled = IsUndoEnabled;
            int dstGy = BrushUtil.GetGridY(localPos, tilemap.CellSize);
            for (int gridY = minGridY; gridY <= maxGridY; ++gridY, ++dstGy)
            {
                int dstGx = BrushUtil.GetGridX(localPos, tilemap.CellSize);
                for (int gridX = minGridX; gridX <= maxGridX; ++gridX, ++dstGx)
                {
                    tilemap.SetTileData(dstGx, dstGy, Tileset.k_TileData_Empty);
                }
            }
            tilemap.UpdateMesh();
            tilemap.IsUndoEnabled = false;
        }
Exemple #2
0
        public void Paint(Tilemap tilemap, Vector2 localPos)
        {
            int minGridX = m_brushTilemap.MinGridX;
            int minGridY = m_brushTilemap.MinGridY;
            int maxGridX = m_brushTilemap.MaxGridX;
            int maxGridY = m_brushTilemap.MaxGridY;

            if (IsUndoEnabled)
            {
#if UNITY_EDITOR
                Undo.RecordObject(tilemap, Tilemap.k_UndoOpName + tilemap.name);
                Undo.RecordObjects(tilemap.GetComponentsInChildren <TilemapChunk>(), Tilemap.k_UndoOpName + tilemap.name);
#endif
            }
            tilemap.IsUndoEnabled = IsUndoEnabled;
            int dstGy = BrushUtil.GetGridY(localPos, tilemap.CellSize);
            for (int gridY = minGridY; gridY <= maxGridY; ++gridY, ++dstGy)
            {
                int dstGx = BrushUtil.GetGridX(localPos, tilemap.CellSize);
                for (int gridX = minGridX; gridX <= maxGridX; ++gridX, ++dstGx)
                {
                    uint tileData = m_brushTilemap.GetTileData(gridX, gridY);
                    if (
                        tileData != Tileset.k_TileData_Empty || // don't copy empty tiles
                        m_brushTilemap.GridWidth == 1 && m_brushTilemap.GridHeight == 1    // unless the brush size is one
                        )
                    {
                        tilemap.SetTileData(dstGx, dstGy, tileData);
                    }
                }
            }
            tilemap.UpdateMesh();
            tilemap.IsUndoEnabled = false;
        }
Exemple #3
0
        static bool s_isOnValidate = false; // fix issue when destroying unused resources from the invalidate call
        void OnValidate()
        {
            Event e = Event.current;

            if (e != null && e.type == EventType.ExecuteCommand && (e.commandName == "Duplicate" || e.commandName == "Paste"))
            {
                _DoDuplicate();
            }
#if UNITY_EDITOR
            // fix prefab preview
            if (UnityEditor.PrefabUtility.GetPrefabType(gameObject) == UnityEditor.PrefabType.Prefab)
            {
                m_needsRebuildMesh = true;
                UpdateMesh();
            }
            else
#endif
            {
                m_needsRebuildMesh      = true;
                m_needsRebuildColliders = true;
                if (ParentTilemap) //NOTE: this is null sometimes in Unity 2017.2.0b4. It happens when the brush is changed, so maybe it's related with the brush but transform.parent is null.
                {
                    ParentTilemap.UpdateMesh();
                }
            }
        }
        public void FloodFill(Tilemap tilemap, Vector2 localPos, uint tileData)
        {
            if (IsUndoEnabled)
            {
#if UNITY_EDITOR
                Undo.RecordObject(tilemap, Tilemap.k_UndoOpName + tilemap.name);
                Undo.RecordObjects(tilemap.GetComponentsInChildren <TilemapChunk>(), Tilemap.k_UndoOpName + tilemap.name);
#endif
            }
            tilemap.IsUndoEnabled = IsUndoEnabled;

            TilemapDrawingUtils.FloodFill(tilemap, localPos, tileData);
            tilemap.UpdateMesh();

            tilemap.IsUndoEnabled = false;
        }
Exemple #5
0
        static bool s_isOnValidate = false; // fix issue when destroying unused resources from the invalidate call
        void OnValidate()
        {
            Event e = Event.current;

            if (e != null && e.type == EventType.ExecuteCommand && (e.commandName == "Duplicate" || e.commandName == "Paste"))
            {
                _DoDuplicate();
            }
#if UNITY_EDITOR
            // fix prefab preview
            if (UnityEditor.PrefabUtility.GetPrefabType(gameObject) == UnityEditor.PrefabType.Prefab)
            {
                m_needsRebuildMesh = true;
                UpdateMesh();
            }
            else
#endif
            {
                m_needsRebuildMesh      = true;
                m_needsRebuildColliders = true;
                ParentTilemap.UpdateMesh();
            }
        }
        public void CutRect(Tilemap tilemap, int startGridX, int startGridY, int endGridX, int endGridY)
        {
            if (IsUndoEnabled)
            {
#if UNITY_EDITOR
                Undo.RecordObject(tilemap, Tilemap.k_UndoOpName + tilemap.name);
                Undo.RecordObjects(tilemap.GetComponentsInChildren <TilemapChunk>(), Tilemap.k_UndoOpName + tilemap.name);
#endif
            }
            tilemap.IsUndoEnabled = IsUndoEnabled;

            for (int gridY = startGridY; gridY <= endGridY; ++gridY)
            {
                for (int gridX = startGridX; gridX <= endGridX; ++gridX)
                {
                    BrushTilemap.SetTileData(gridX - startGridX, gridY - startGridY, tilemap.GetTileData(gridX, gridY));
                    tilemap.SetTileData(gridX, gridY, Tileset.k_TileData_Empty);
                }
            }
            BrushTilemap.UpdateMesh();
            tilemap.UpdateMesh();

            tilemap.IsUndoEnabled = false;
        }
        public void GenerateMap()
        {
            //Ground.ClearMap();
            GroundOverlay.ClearMap();

            float now;

            now = Time.realtimeSinceStartup;
            float fDiv = 25f;
            float xf   = Random.value * 100;
            float yf   = Random.value * 100;

            //*/ Rogue Demo (280ms with 180x180)
            uint tileWater       = (8 << 16);
            uint tileWaterPlants = (24 << 16);
            uint tileDarkGrass   = 66;
            uint tileGrass       = (9 << 16);
            uint tileFlowers     = (22 << 16);
            uint tileMountains   = (23 << 16);

            //*/

            // Oryx Demo

            /*/
             * uint tileWater = (9 << 16);
             * uint tileWaterPlants = (16 << 16);
             * uint tileDarkGrass = 757;
             * uint tileGrass = 756;
             * uint tileFlowers = (17 << 16);
             * uint tileMountains = (18 << 16);
             * //*/

            for (int i = 0; i < Width; i++)
            {
                for (int j = 0; j < Height; j++)
                {
                    float fRand = Random.value;
                    float noise = Mathf.PerlinNoise((i + xf) / fDiv, (j + yf) / fDiv);
                    //Debug.Log( "noise: "+noise+"; i: "+i+"; j: "+j );
                    if (noise < 0.3) //water
                    {
                        Ground.SetTileData(i, j, tileWater);
                    }
                    else if (noise < 0.4) // water plants
                    {
                        Ground.SetTileData(i, j, tileWater);
                        if (fRand < noise / 3)
                        {
                            GroundOverlay.SetTileData(i, j, tileWaterPlants);
                        }
                    }
                    else if (noise < 0.5 && fRand < (1 - noise / 2)) // dark grass
                    {
                        Ground.SetTileData(i, j, tileDarkGrass);
                    }
                    else if (noise < 0.6 && fRand < (1 - 1.2 * noise)) // flowers
                    {
                        Ground.SetTileData(i, j, tileGrass);
                        GroundOverlay.SetTileData(i, j, tileFlowers);
                    }
                    else if (noise < 0.7) // grass
                    {
                        Ground.SetTileData(i, j, tileGrass);
                    }
                    else // mountains
                    {
                        Ground.SetTileData(i, j, tileGrass);
                        GroundOverlay.SetTileData(i, j, tileMountains);
                    }
                }
            }
            Debug.Log("Generation time(ms): " + (Time.realtimeSinceStartup - now) * 1000);

            now = Time.realtimeSinceStartup;
            Ground.UpdateMesh();
            GroundOverlay.UpdateMesh();
            Debug.Log("UpdateMesh time(ms): " + (Time.realtimeSinceStartup - now) * 1000);
        }
 public void FlipH(bool changeFlags = true)
 {
     m_brushTilemap.FlipH(changeFlags);
     m_brushTilemap.UpdateMesh();
 }