public void SortTiles(bool leftToRight, bool bottomToTop)
    {
        int n = tiles.Length;

        for (int i = 0; i < n; ++i)
        {
            for (int j = i + 1; j < n; ++j)
            {
                bool swap = false;
                if (tiles[i].y != tiles[j].y)
                {
                    swap = ((tiles[i].y < tiles[j].y) != bottomToTop);
                }
                else
                {
                    swap = ((tiles[i].x < tiles[j].x) != leftToRight);
                }
                if (swap)
                {
                    tk2dSparseTile tmp = tiles[i];
                    tiles[i] = tiles[j];
                    tiles[j] = tmp;
                }
            }
        }
    }
Exemple #2
0
 public tk2dSparseTile(tk2dSparseTile source)
 {
     this.x           = source.x;
     this.y           = source.y;
     this.layer       = source.layer;
     this.spriteId    = source.spriteId;
     this.blendAmount = source.blendAmount;
 }
 public tk2dSparseTile(tk2dSparseTile source)
 {
     this.x = source.x;
     this.y = source.y;
     this.layer = source.layer;
     this.spriteId = source.spriteId;
     this.blendAmount = source.blendAmount;
 }
Exemple #4
0
    public tk2dTileMapEditorBrush(tk2dTileMapEditorBrush source)
    {
        this.name      = source.name;
        this.type      = source.type;
        this.paintMode = source.paintMode;

        tiles = new tk2dSparseTile[source.tiles.Length];
        for (int i = 0; i < source.tiles.Length; ++i)
        {
            tiles[i] = new tk2dSparseTile(source.tiles[i]);
        }

        multiSelectTiles = new int[source.multiSelectTiles.Length];
        for (int i = 0; i < source.multiSelectTiles.Length; ++i)
        {
            multiSelectTiles[i] = source.multiSelectTiles[i];
        }

        edgeMode   = source.edgeMode;
        multiLayer = source.multiLayer;
        overrideWithSpriteBounds = source.overrideWithSpriteBounds;
    }
	public void UpdateWorkingBrush()
	{
		tk2dTileMapEditorBrush workBrush = WorkingBrush;
		tk2dTileMapEditorBrush activeBrush = editorData.activeBrush;

		int rectX1 = Mathf.Min(cursorX, cursorX0);
		int rectX2 = Mathf.Max(cursorX, cursorX0);
		int rectY1 = Mathf.Min(cursorY, cursorY0);
		int rectY2 = Mathf.Max(cursorY, cursorY0);

		int xoffset = 0;
		if (tileMap.data.tileType == tk2dTileMapData.TileType.Isometric && (cursorY & 1) == 1) 
			xoffset = 1;

		workBrush.tiles = new tk2dSparseTile[0]; 

		tk2dSparseTile[] srcTiles;
		if (activeBrush.type != tk2dTileMapEditorBrush.Type.MultiSelect) {
			srcTiles = activeBrush.tiles;
		} else {
			int n = activeBrush.multiSelectTiles.Length;
			srcTiles = new tk2dSparseTile[n];
			for (int i = 0; i < n; ++i) {
				srcTiles[i] = new tk2dSparseTile(i, 0, editorData.layer, activeBrush.multiSelectTiles[i]);
			}
		}

		if (srcTiles.Length == 0) {
			workBrush.UpdateBrushHash();
			return;
		}

		bool flipH = tk2dTileMapToolbar.workBrushFlipX;
		bool flipV = tk2dTileMapToolbar.workBrushFlipY;

		if (tk2dTileMapToolbar.mainMode == tk2dTileMapToolbar.MainMode.Brush) {
			if (rectX1 == rectX2 && rectY1 == rectY2) {
				int nTiles = srcTiles.Length;
				workBrush.tiles = new tk2dSparseTile[nTiles];
				
				for (int i = 0; i < nTiles; ++i) {
					int spriteId = srcTiles[i].spriteId;
					int tx = srcTiles[i].x;
					int ty = srcTiles[i].y;

					if (flipH) {
						tx = -tx;
						tk2dRuntime.TileMap.BuilderUtil.InvertRawTileFlag(ref spriteId, tk2dTileFlags.FlipX);
					}
					if (flipV) {
						ty = -ty;
						tk2dRuntime.TileMap.BuilderUtil.InvertRawTileFlag(ref spriteId, tk2dTileFlags.FlipY);
					}
					
					int thisRowXOffset = ((ty & 1) == 1) ? xoffset : 0;
					
					workBrush.tiles[i] = new tk2dSparseTile(
						cursorX + tx + thisRowXOffset,
						cursorY + ty,
						editorData.layer,
						spriteId	);
				}
			} else {
				int gridWidth = 1 + rectX2 - rectX1;
				int gridHeight = 1 + rectY2 - rectY1;
				workBrush.tiles = new tk2dSparseTile[gridWidth * gridHeight];

				// fill with tiles repeated pattern...
				int patternX1 = 0;
				int patternY1 = 0;
				int patternX2 = 0;
				int patternY2 = 0;
				foreach (var tile in srcTiles) {
					patternX1 = Mathf.Min (patternX1, tile.x);
					patternY1 = Mathf.Min (patternY1, tile.y);
					patternX2 = Mathf.Max (patternX2, tile.x);
					patternY2 = Mathf.Max (patternY2, tile.y);
				}
				int patternW = 1 + patternX2 - patternX1;
				int patternH = 1 + patternY2 - patternY1;

				int idx = 0;
				for (int y = 0; y < gridHeight; ++y) {
					int thisRowXOffset = ((y & 1) == 1) ? xoffset : 0;
					for (int x = 0; x < gridWidth; ++x) {
						int spriteId = srcTiles[0].spriteId;
						foreach (var tile in srcTiles) {
							if ((x % patternW) == (tile.x - patternX1) &&
							    (y % patternH) == (tile.y - patternY1))
							{
								spriteId = tile.spriteId;
								break;
							}
						}
						if (flipH)
							tk2dRuntime.TileMap.BuilderUtil.InvertRawTileFlag(ref spriteId, tk2dTileFlags.FlipX);
						if (flipV)
							tk2dRuntime.TileMap.BuilderUtil.InvertRawTileFlag(ref spriteId, tk2dTileFlags.FlipY);
						workBrush.tiles[idx++] = new tk2dSparseTile(
							rectX1 + x + thisRowXOffset, rectY1 + y, editorData.layer, spriteId);
					}
				}
			}
		}
		if (tk2dTileMapToolbar.mainMode == tk2dTileMapToolbar.MainMode.BrushRandom) {
			int gridWidth = 1 + rectX2 - rectX1;
			int gridHeight = 1 + rectY2 - rectY1;
			workBrush.tiles = new tk2dSparseTile[gridWidth * gridHeight];

			var rng = new System.Random(randomSeed + cursorY * tileMap.width + cursorX);

			int idx = 0;
			for (int y = 0; y < gridHeight; ++y) {
				int thisRowXOffset = ((y & 1) == 1) ? xoffset : 0;
				for (int x = 0; x < gridWidth; ++x) {
					int spriteId = srcTiles[rng.Next(srcTiles.Length)].spriteId;
					workBrush.tiles[idx++] = new tk2dSparseTile(
						rectX1 + x + thisRowXOffset, rectY1 + y, editorData.layer, spriteId);
				}
			}
		}

		if (scratchpadGUI.workingHere) {
			int scratchW, scratchH;
			scratchpadGUI.GetScratchpadSize(out scratchW, out scratchH);
			workBrush.ClipTiles(0, 0, scratchW - 1, scratchH - 1);
		} else {
			workBrush.ClipTiles(0, 0, tileMap.width - 1, tileMap.height - 1);
		}

		workBrush.SortTiles(tileMapData.sortMethod == tk2dTileMapData.SortMethod.BottomLeft || tileMapData.sortMethod == tk2dTileMapData.SortMethod.TopLeft,
			tileMapData.sortMethod == tk2dTileMapData.SortMethod.BottomLeft || tileMapData.sortMethod == tk2dTileMapData.SortMethod.BottomRight);

		workBrush.UpdateBrushHash();
	}
    public tk2dTileMapEditorBrush(tk2dTileMapEditorBrush source)
    {
        this.name = source.name;
        this.type = source.type;
        this.paintMode = source.paintMode;

        tiles = new tk2dSparseTile[source.tiles.Length];
        for (int i = 0; i < source.tiles.Length; ++i)
            tiles[i] = new tk2dSparseTile(source.tiles[i]);

        multiSelectTiles = new int[source.multiSelectTiles.Length];
        for (int i = 0; i < source.multiSelectTiles.Length; ++i)
            multiSelectTiles[i] = source.multiSelectTiles[i];

        edgeMode = source.edgeMode;
        multiLayer = source.multiLayer;
        overrideWithSpriteBounds = source.overrideWithSpriteBounds;
    }
    public void UpdateWorkingBrush()
    {
        tk2dTileMapEditorBrush workBrush   = WorkingBrush;
        tk2dTileMapEditorBrush activeBrush = editorData.activeBrush;

        int rectX1 = Mathf.Min(cursorX, cursorX0);
        int rectX2 = Mathf.Max(cursorX, cursorX0);
        int rectY1 = Mathf.Min(cursorY, cursorY0);
        int rectY2 = Mathf.Max(cursorY, cursorY0);

        int xoffset = 0;

        if (tileMap.data.tileType == tk2dTileMapData.TileType.Isometric && (cursorY & 1) == 1)
        {
            xoffset = 1;
        }

        workBrush.tiles = new tk2dSparseTile[0];

        tk2dSparseTile[] srcTiles;
        if (activeBrush.type != tk2dTileMapEditorBrush.Type.MultiSelect)
        {
            srcTiles = activeBrush.tiles;
        }
        else
        {
            int n = activeBrush.multiSelectTiles.Length;
            srcTiles = new tk2dSparseTile[n];
            for (int i = 0; i < n; ++i)
            {
                srcTiles[i] = new tk2dSparseTile(i, 0, editorData.layer, activeBrush.multiSelectTiles[i]);
            }
        }

        if (srcTiles.Length == 0)
        {
            workBrush.UpdateBrushHash();
            return;
        }

        bool flipH = tk2dTileMapToolbar.workBrushFlipX;
        bool flipV = tk2dTileMapToolbar.workBrushFlipY;

        if (tk2dTileMapToolbar.mainMode == tk2dTileMapToolbar.MainMode.Brush)
        {
            if (rectX1 == rectX2 && rectY1 == rectY2)
            {
                int nTiles = srcTiles.Length;
                workBrush.tiles = new tk2dSparseTile[nTiles];

                for (int i = 0; i < nTiles; ++i)
                {
                    int spriteId = srcTiles[i].spriteId;
                    int tx       = srcTiles[i].x;
                    int ty       = srcTiles[i].y;

                    if (flipH)
                    {
                        tx = -tx;
                        tk2dRuntime.TileMap.BuilderUtil.InvertRawTileFlag(ref spriteId, tk2dTileFlags.FlipX);
                    }
                    if (flipV)
                    {
                        ty = -ty;
                        tk2dRuntime.TileMap.BuilderUtil.InvertRawTileFlag(ref spriteId, tk2dTileFlags.FlipY);
                    }

                    int thisRowXOffset = ((ty & 1) == 1) ? xoffset : 0;

                    workBrush.tiles[i] = new tk2dSparseTile(
                        cursorX + tx + thisRowXOffset,
                        cursorY + ty,
                        editorData.layer,
                        spriteId);
                }
            }
            else
            {
                int gridWidth  = 1 + rectX2 - rectX1;
                int gridHeight = 1 + rectY2 - rectY1;
                workBrush.tiles = new tk2dSparseTile[gridWidth * gridHeight];

                // fill with tiles repeated pattern...
                int patternX1 = 0;
                int patternY1 = 0;
                int patternX2 = 0;
                int patternY2 = 0;
                foreach (var tile in srcTiles)
                {
                    patternX1 = Mathf.Min(patternX1, tile.x);
                    patternY1 = Mathf.Min(patternY1, tile.y);
                    patternX2 = Mathf.Max(patternX2, tile.x);
                    patternY2 = Mathf.Max(patternY2, tile.y);
                }
                int patternW = 1 + patternX2 - patternX1;
                int patternH = 1 + patternY2 - patternY1;

                int idx = 0;
                for (int y = 0; y < gridHeight; ++y)
                {
                    int thisRowXOffset = ((y & 1) == 1) ? xoffset : 0;
                    for (int x = 0; x < gridWidth; ++x)
                    {
                        int spriteId = srcTiles[0].spriteId;
                        foreach (var tile in srcTiles)
                        {
                            if ((x % patternW) == (tile.x - patternX1) &&
                                (y % patternH) == (tile.y - patternY1))
                            {
                                spriteId = tile.spriteId;
                                break;
                            }
                        }
                        if (flipH)
                        {
                            tk2dRuntime.TileMap.BuilderUtil.InvertRawTileFlag(ref spriteId, tk2dTileFlags.FlipX);
                        }
                        if (flipV)
                        {
                            tk2dRuntime.TileMap.BuilderUtil.InvertRawTileFlag(ref spriteId, tk2dTileFlags.FlipY);
                        }
                        workBrush.tiles[idx++] = new tk2dSparseTile(
                            rectX1 + x + thisRowXOffset, rectY1 + y, editorData.layer, spriteId);
                    }
                }
            }
        }
        if (tk2dTileMapToolbar.mainMode == tk2dTileMapToolbar.MainMode.BrushRandom)
        {
            int gridWidth  = 1 + rectX2 - rectX1;
            int gridHeight = 1 + rectY2 - rectY1;
            workBrush.tiles = new tk2dSparseTile[gridWidth * gridHeight];

            var rng = new System.Random(randomSeed + cursorY * tileMap.width + cursorX);

            int idx = 0;
            for (int y = 0; y < gridHeight; ++y)
            {
                int thisRowXOffset = ((y & 1) == 1) ? xoffset : 0;
                for (int x = 0; x < gridWidth; ++x)
                {
                    int spriteId = srcTiles[rng.Next(srcTiles.Length)].spriteId;
                    workBrush.tiles[idx++] = new tk2dSparseTile(
                        rectX1 + x + thisRowXOffset, rectY1 + y, editorData.layer, spriteId);
                }
            }
        }

        if (scratchpadGUI.workingHere)
        {
            int scratchW, scratchH;
            scratchpadGUI.GetScratchpadSize(out scratchW, out scratchH);
            workBrush.ClipTiles(0, 0, scratchW - 1, scratchH - 1);
        }
        else
        {
            workBrush.ClipTiles(0, 0, tileMap.width - 1, tileMap.height - 1);
        }

        workBrush.SortTiles(tileMapData.sortMethod == tk2dTileMapData.SortMethod.BottomLeft || tileMapData.sortMethod == tk2dTileMapData.SortMethod.TopLeft,
                            tileMapData.sortMethod == tk2dTileMapData.SortMethod.BottomLeft || tileMapData.sortMethod == tk2dTileMapData.SortMethod.BottomRight);

        workBrush.UpdateBrushHash();
    }