// Set functions
/// <summary>Sets the tile at x, y - either a sprite Id or -1 if the tile is empty.</summary>
public void SetTile(int x, int y, int tile)
{
tk2dTileFlags currentFlags = GetTileFlags(x, y);
int rawTileValue = (tile == -1) ? -1 : (tile | (int)currentFlags);
SetRawTileValue(x, y, rawTileValue);
}
public static bool IsRawTileFlagSet(int rawTile, tk2dTileFlags flag)
{
if (rawTile == -1)
{
return(false);
}
return((rawTile & (int)flag) != 0);
}
public static void SetRawTileFlag(ref int rawTile, tk2dTileFlags flag, bool setValue)
{
if (rawTile == -1)
{
return;
}
rawTile = setValue ? (rawTile | (int)flag) : (rawTile & (int)(~flag));
}
/// <summary>Sets the tile flags on a layer at x, y - a combination of tk2dTileFlags</summary>
public void SetTileFlags(int x, int y, int layer, tk2dTileFlags flags)
{
if (layer < 0 || layer >= layers.Length)
{
return;
}
layers[layer].SetTileFlags(x, y, flags);
}
public static void InvertRawTileFlag(ref int rawTile, tk2dTileFlags flag)
{
if (rawTile == -1)
{
return;
}
bool setValue = (rawTile & (int)flag) == 0;
rawTile = setValue ? (rawTile | (int)flag) : (rawTile & (int)(~flag));
}
/// <summary>Sets the tile flags at x, y - a combination of tk2dTileFlags</summary>
public void SetTileFlags(int x, int y, tk2dTileFlags flags)
{
int currentTile = GetTile(x, y);
if (currentTile != -1)
{
int rawTileValue = currentTile | (int)flags;
SetRawTileValue(x, y, rawTileValue);
}
}
public void CreateSpikeAt(Coordinates c, TileDirection d)
{
tk2dTileFlags tileFlags = 0;
map.SetTile(c.x, c.y, (int)TileLayer.Spike, spikeTile);
switch (d)
{
case TileDirection.Down:
tileFlags ^= tk2dTileFlags.FlipY;
break;
}
map.SetTileFlags(c.x, c.y, (int)TileLayer.Spike, tileFlags);
}
public TileInfo GetTileAtPosition(Vector2 pos, TileLayer l)
{
int x, y, tileId = -1;
TileDirection dir = TileDirection.Up;
if (map.GetTileAtPosition(pos, out x, out y))
{
tileId = map.GetTile(x, y, (int)l);
}
tk2dTileFlags flags = map.GetTileFlags(x, y, (int)l);
dir = (TileFlagsToTileDirection(flags));
TileInfo tile = new TileInfo();
tile.worldPos = map.GetTilePosition(x, y);
switch (tileId)
{
case 0:
case 1:
case 2:
case 3:
case 4:
case 32:
case 33:
case 34:
case 35:
case 36:
case 64:
case 65:
case 66:
tile.type = TileType.Wall;
break;
case 8:
tile.type = TileType.Lava;
break;
default:
tile.type = TileType.Empty;
break;
}
if (tileId == spikeTile)
{
tile.type = TileType.Spike;
}
print(tile.type);
tile.direction = dir;
return(tile);
}
public TileDirection TileFlagsToTileDirection(tk2dTileFlags flags)
{
bool flipVertical = (flags & tk2dTileFlags.FlipY) != 0;
bool flipHorizontal = (flags & tk2dTileFlags.FlipX) != 0;
bool flipDiagonal = (flags & tk2dTileFlags.Rot90) != 0;
if (flipDiagonal)
{
if (flipHorizontal)
{
return(TileDirection.Left);
}
return(TileDirection.Right);
}
else
{
if (flipVertical)
{
return(TileDirection.Down);
}
}
return(TileDirection.Up);
}
public static void InvertRawTileFlag(ref int rawTile, tk2dTileFlags flag) {
if (rawTile == -1) return;
bool setValue = (rawTile & (int)flag) == 0;
rawTile = setValue ? (rawTile | (int)flag) : (rawTile & (int)(~flag));
}
public static void SetRawTileFlag(ref int rawTile, tk2dTileFlags flag, bool setValue) {
if (rawTile == -1) return;
rawTile = setValue ? (rawTile | (int)flag) : (rawTile & (int)(~flag));
}
public static bool IsRawTileFlagSet(int rawTile, tk2dTileFlags flag) {
if (rawTile == -1) return false;
return (rawTile & (int)flag) != 0;
}
public static bool IsRawTileFlagSet(int rawTile, tk2dTileFlags flag)
{
if (rawTile == -1)
{
return false;
}
return ((rawTile & flag) != 0);
}
/// <summary>Sets the tile flags on a layer at x, y - a combination of tk2dTileFlags</summary>
public void SetTileFlags(int x, int y, int layer, tk2dTileFlags flags) {
if (layer < 0 || layer >= layers.Length)
return;
layers[layer].SetTileFlags(x, y, flags);
}
public static void SetRawTileFlag(ref int rawTile, tk2dTileFlags flag, bool setValue)
{
if (rawTile != -1)
{
rawTile = !setValue ? (rawTile & ~flag) : (rawTile | flag);
}
}
/// <summary>Sets the tile flags at x, y - a combination of tk2dTileFlags</summary>
public void SetTileFlags(int x, int y, tk2dTileFlags flags)
{
int currentTile = GetTile(x, y);
if (currentTile != -1) {
int rawTileValue = currentTile | (int)flags;
SetRawTileValue(x, y, rawTileValue);
}
}
void PopulateTilemap(tk2dTileMap tileMap)
{
int extraWidth = staggered ? 1 : 0;
tk2dEditor.TileMap.TileMapUtility.ResizeTileMap(tileMap, width + extraWidth, height, tileMap.partitionSizeX, tileMap.partitionSizeY);
if (staggered)
{
tileMap.data.sortMethod = tk2dTileMapData.SortMethod.TopLeft;
tileMap.data.tileType = tk2dTileMapData.TileType.Isometric;
}
foreach (var layer in layers)
{
int index = tk2dEditor.TileMap.TileMapUtility.FindOrCreateLayer(tileMap, layer.name);
var target = tileMap.Layers[index];
int ww = width + extraWidth;
for (int y = 0; y < height; ++y)
{
for (int x = 0; x < ww; ++x)
{
target.SetTile(x, y, -1);
}
}
for (int y = 0; y < height; ++y)
{
for (int x = 0; x < width; ++x)
{
uint rawTmxTile = layer.tiles[y * width + x];
// Set tile
int tile = (int)(rawTmxTile & ~(0xE0000000)) - 1; // ignore flipping and rotating
int offset = (!staggered || (staggered && ((y % 2) == 0))) ? 0 : 1;
target.SetTile(x + offset, height - 1 - y, tile);
// Set tile flags
bool flipHorizontal = (rawTmxTile & 0x80000000) != 0;
bool flipVertical = (rawTmxTile & 0x40000000) != 0;
bool flipDiagonal = (rawTmxTile & 0x20000000) != 0;
tk2dTileFlags tileFlags = 0;
if (flipDiagonal)
{
tileFlags |= (tk2dTileFlags.Rot90 | tk2dTileFlags.FlipX);
}
if (flipHorizontal)
{
tileFlags ^= tk2dTileFlags.FlipX;
}
if (flipVertical)
{
tileFlags ^= tk2dTileFlags.FlipY;
}
target.SetTileFlags(x + offset, height - 1 - y, tileFlags);
}
}
target.Optimize();
}
}
public static void InvertRawTileFlag(ref int rawTile, tk2dTileFlags flag)
{
if (rawTile != -1)
{
bool flag2 = (rawTile & flag) == 0;
rawTile = !flag2 ? (rawTile & ~flag) : (rawTile | flag);
}
}
public void SetTileFlags(int x, int y, int layer, tk2dTileFlags flags)
{
if ((layer >= 0) && (layer < this.layers.Length))
{
this.layers[layer].SetTileFlags(x, y, flags);
}
}
public void CreateVaultInRoom(Vault v, Room r)
{
uint[,] tileInts = v.tileInts;
uint[,] spikeInts = v.spikeInts;
for (int x = 0; x < tileInts.GetLength(0); x++)
{
for (int y = 0; y < tileInts.GetLength(1); y++)
{
uint rawTile = tileInts [x, y];
int tile = (int)(rawTile & ~(0xE0000000)); // ignore flipping and rotating
// Tiled add's a 1 to the tile so that 0 can be blank
tile--;
Coordinates newCoords = new Coordinates(x, tileInts.GetLength(0) - 1 - y);
newCoords.x += r.pos.x;
newCoords.y += r.pos.y;
newCoords.x -= r.size.x / 2;
// newCoords.y -= r.size.y;
newCoords.y -= r.size.y / 2;
if (tile != -1)
{
map.SetTile(newCoords.x, newCoords.y, wallLayer, tile);
}
}
}
for (int x = 0; x < spikeInts.GetLength(0); x++)
{
for (int y = 0; y < spikeInts.GetLength(1); y++)
{
uint rawTile = spikeInts [x, y];
int tile = (int)(rawTile & ~(0xE0000000)); // ignore flipping and rotating
// Tiled add's a 1 to the tile so that 0 can be blank
tile--;
Coordinates newCoords = new Coordinates(x, tileInts.GetLength(0) - 1 - y);
newCoords.x += r.pos.x;
newCoords.y += r.pos.y;
newCoords.x -= r.size.x / 2;
// newCoords.y -= r.size.y;
newCoords.y -= r.size.y / 2;
if (tile == spikeTile)
{
map.SetTile(newCoords.x, newCoords.y, (int)TileLayer.Spike, tile);
}
// Set tile flags
bool flipHorizontal = (rawTile & 0x80000000) != 0;
bool flipVertical = (rawTile & 0x40000000) != 0;
bool flipDiagonal = (rawTile & 0x20000000) != 0;
tk2dTileFlags tileFlags = 0;
if (flipDiagonal)
{
tileFlags |= (tk2dTileFlags.Rot90 | tk2dTileFlags.FlipX);
}
if (flipHorizontal)
{
tileFlags ^= tk2dTileFlags.FlipX;
}
if (flipVertical)
{
tileFlags ^= tk2dTileFlags.FlipY;
}
map.SetTileFlags(newCoords.x, newCoords.y, (int)TileLayer.Spike, tileFlags);
}
}
}
public void SetTileFlags(int x, int y, tk2dTileFlags flags)
{
int tile = this.GetTile(x, y);
if (tile != -1)
{
int num2 = tile | flags;
this.SetRawTileValue(x, y, num2);
}
}
