public override void ActionPerform()
{
var painterBrushNum = 0;
terrain = Map.Terrain;
painter = Map.Painter;
tile = terrain.Tiles[PosNum.X, PosNum.Y];
texture = tile.Texture;
terrain.Tiles[PosNum.X, PosNum.Y].TriTopLeftIsCliff = false;
terrain.Tiles[PosNum.X, PosNum.Y].TriTopRightIsCliff = false;
terrain.Tiles[PosNum.X, PosNum.Y].TriBottomLeftIsCliff = false;
terrain.Tiles[PosNum.X, PosNum.Y].TriBottomRightIsCliff = false;
terrain.Tiles[PosNum.X, PosNum.Y].DownSide = TileUtil.None;
for (painterBrushNum = 0; painterBrushNum <= painter.CliffBrushCount - 1; painterBrushNum++)
{
var a = 0;
for (a = 0; a <= painter.CliffBrushes[painterBrushNum].Tiles_Straight.TileCount - 1; a++)
{
painterTexture = painter.CliffBrushes[painterBrushNum].Tiles_Straight.Tiles[a];
if (painterTexture.TextureNum == texture.TextureNum)
{
if (tile.Tri)
{
terrain.Tiles[PosNum.X, PosNum.Y].TriTopLeftIsCliff = true;
terrain.Tiles[PosNum.X, PosNum.Y].TriBottomRightIsCliff = true;
}
else
{
terrain.Tiles[PosNum.X, PosNum.Y].TriTopRightIsCliff = true;
terrain.Tiles[PosNum.X, PosNum.Y].TriBottomLeftIsCliff = true;
}
terrain.Tiles[PosNum.X, PosNum.Y].Terrain_IsCliff = true;
TileUtil.RotateDirection(painterTexture.Direction, texture.Orientation, ref resultDirection);
terrain.Tiles[PosNum.X, PosNum.Y].DownSide = resultDirection;
}
}
for (a = 0; a <= painter.CliffBrushes[painterBrushNum].Tiles_Corner_In.TileCount - 1; a++)
{
painterTexture = painter.CliffBrushes[painterBrushNum].Tiles_Corner_In.Tiles[a];
if (painterTexture.TextureNum == texture.TextureNum)
{
TileUtil.RotateDirection(painterTexture.Direction, texture.Orientation, ref resultDirection);
if (tile.Tri)
{
if (TileUtil.IdenticalTileDirections(resultDirection, TileUtil.TopLeft))
{
terrain.Tiles[PosNum.X, PosNum.Y].TriTopLeftIsCliff = true;
terrain.Tiles[PosNum.X, PosNum.Y].Terrain_IsCliff = true;
}
else if (TileUtil.IdenticalTileDirections(resultDirection, TileUtil.BottomRight))
{
terrain.Tiles[PosNum.X, PosNum.Y].TriBottomRightIsCliff = true;
terrain.Tiles[PosNum.X, PosNum.Y].Terrain_IsCliff = true;
}
}
else
{
if (TileUtil.IdenticalTileDirections(resultDirection, TileUtil.TopRight))
{
terrain.Tiles[PosNum.X, PosNum.Y].TriTopRightIsCliff = true;
terrain.Tiles[PosNum.X, PosNum.Y].Terrain_IsCliff = true;
}
else if (TileUtil.IdenticalTileDirections(resultDirection, TileUtil.BottomLeft))
{
terrain.Tiles[PosNum.X, PosNum.Y].TriBottomLeftIsCliff = true;
terrain.Tiles[PosNum.X, PosNum.Y].Terrain_IsCliff = true;
}
}
}
}
for (a = 0; a <= painter.CliffBrushes[painterBrushNum].Tiles_Corner_Out.TileCount - 1; a++)
{
painterTexture = painter.CliffBrushes[painterBrushNum].Tiles_Corner_Out.Tiles[a];
if (painterTexture.TextureNum == texture.TextureNum)
{
oppositeDirection = painterTexture.Direction;
oppositeDirection.FlipX();
oppositeDirection.FlipY();
TileUtil.RotateDirection(oppositeDirection, texture.Orientation, ref resultDirection);
if (tile.Tri)
{
if (TileUtil.IdenticalTileDirections(resultDirection, TileUtil.TopLeft))
{
terrain.Tiles[PosNum.X, PosNum.Y].TriTopLeftIsCliff = true;
terrain.Tiles[PosNum.X, PosNum.Y].Terrain_IsCliff = true;
}
else if (TileUtil.IdenticalTileDirections(resultDirection, TileUtil.BottomRight))
{
terrain.Tiles[PosNum.X, PosNum.Y].TriBottomRightIsCliff = true;
terrain.Tiles[PosNum.X, PosNum.Y].Terrain_IsCliff = true;
}
}
else
{
if (TileUtil.IdenticalTileDirections(resultDirection, TileUtil.TopRight))
{
terrain.Tiles[PosNum.X, PosNum.Y].TriTopRightIsCliff = true;
terrain.Tiles[PosNum.X, PosNum.Y].Terrain_IsCliff = true;
}
else if (TileUtil.IdenticalTileDirections(resultDirection, TileUtil.BottomLeft))
{
terrain.Tiles[PosNum.X, PosNum.Y].TriBottomLeftIsCliff = true;
terrain.Tiles[PosNum.X, PosNum.Y].Terrain_IsCliff = true;
}
}
}
}
}
Map.SectorTerrainUndoChanges.TileChanged(PosNum);
}
public override void ActionPerform()
{
terrain = Map.Terrain;
painter = Map.Painter;
resultTiles = null;
resultDirection = TileUtil.None;
//apply centre brushes
if (!terrain.Tiles[PosNum.X, PosNum.Y].Terrain_IsCliff)
{
for (var brushNum = 0; brushNum <= painter.TerrainCount - 1; brushNum++)
{
terrainInner = painter.Terrains[brushNum];
if (terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner)
{
if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner)
{
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner)
{
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
//i i i i
resultTiles = terrainInner.Tiles;
resultDirection = TileUtil.None;
}
}
}
}
}
}
//apply transition brushes
if (!terrain.Tiles[PosNum.X, PosNum.Y].Terrain_IsCliff)
{
for (var brushNum = 0; brushNum <= painter.TransitionBrushCount - 1; brushNum++)
{
terrainInner = painter.TransitionBrushes[brushNum].TerrainInner;
terrainOuter = painter.TransitionBrushes[brushNum].TerrainOuter;
if (terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner)
{
if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner)
{
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner)
{
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
//i i i i
//nothing to do here
break;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)
{
//i i i o
resultTiles = painter.TransitionBrushes[brushNum].TilesCornerIn;
resultDirection = TileUtil.BottomRight;
break;
}
}
else if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter)
{
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
//i i o i
resultTiles = painter.TransitionBrushes[brushNum].TilesCornerIn;
resultDirection = TileUtil.BottomLeft;
break;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)
{
//i i o o
resultTiles = painter.TransitionBrushes[brushNum].TilesStraight;
resultDirection = TileUtil.Bottom;
break;
}
}
}
else if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter)
{
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner)
{
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
//i o i i
resultTiles = painter.TransitionBrushes[brushNum].TilesCornerIn;
resultDirection = TileUtil.TopRight;
break;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)
{
//i o i o
resultTiles = painter.TransitionBrushes[brushNum].TilesStraight;
resultDirection = TileUtil.Right;
break;
}
}
else if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter)
{
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
//i o o i
resultTiles = null;
resultDirection = TileUtil.None;
break;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)
{
//i o o o
resultTiles = painter.TransitionBrushes[brushNum].TilesCornerOut;
resultDirection = TileUtil.BottomRight;
break;
}
}
}
}
else if (terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainOuter)
{
if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner)
{
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner)
{
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
//o i i i
resultTiles = painter.TransitionBrushes[brushNum].TilesCornerIn;
resultDirection = TileUtil.TopLeft;
break;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)
{
//o i i o
resultTiles = null;
resultDirection = TileUtil.None;
break;
}
}
else if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter)
{
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
//o i o i
resultTiles = painter.TransitionBrushes[brushNum].TilesStraight;
resultDirection = TileUtil.Left;
break;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)
{
//o i o o
resultTiles = painter.TransitionBrushes[brushNum].TilesCornerOut;
resultDirection = TileUtil.BottomLeft;
break;
}
}
}
else if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter)
{
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner)
{
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
//o o i i
resultTiles = painter.TransitionBrushes[brushNum].TilesStraight;
resultDirection = TileUtil.Top;
break;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)
{
//o o i o
resultTiles = painter.TransitionBrushes[brushNum].TilesCornerOut;
resultDirection = TileUtil.TopRight;
break;
}
}
else if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter)
{
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
//o o o i
resultTiles = painter.TransitionBrushes[brushNum].TilesCornerOut;
resultDirection = TileUtil.TopLeft;
break;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)
{
//o o o o
//nothing to do here
break;
}
}
}
}
}
}
//set cliff tiles
if (terrain.Tiles[PosNum.X, PosNum.Y].Tri)
{
if (terrain.Tiles[PosNum.X, PosNum.Y].TriTopLeftIsCliff)
{
if (terrain.Tiles[PosNum.X, PosNum.Y].TriBottomRightIsCliff)
{
var brushNum = 0;
for (brushNum = 0; brushNum <= painter.CliffBrushCount - 1; brushNum++)
{
terrainInner = painter.CliffBrushes[brushNum].Terrain_Inner;
terrainOuter = painter.CliffBrushes[brushNum].Terrain_Outer;
if (terrainInner == terrainOuter)
{
var a = 0;
if (terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner)
{
a++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner)
{
a++;
}
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner)
{
a++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
a++;
}
if (a >= 3)
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Straight;
resultDirection = terrain.Tiles[PosNum.X, PosNum.Y].DownSide;
break;
}
}
if (((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner && terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner) &&
(terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter ||
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)) ||
((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner || terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner) &&
(terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter &&
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)))
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Straight;
resultDirection = TileUtil.Bottom;
break;
}
if (((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainOuter &&
terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter) &&
(terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner ||
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)) ||
((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainOuter ||
terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter) &&
(terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner &&
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)))
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Straight;
resultDirection = TileUtil.Left;
break;
}
if (((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainOuter &&
terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter) &&
(terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner ||
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)) ||
((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainOuter ||
terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter) &&
(terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner &&
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)))
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Straight;
resultDirection = TileUtil.Top;
break;
}
if (((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner &&
terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner) &&
(terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter ||
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)) ||
((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner ||
terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner) &&
(terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter &&
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)))
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Straight;
resultDirection = TileUtil.Right;
break;
}
}
if (brushNum == painter.CliffBrushCount)
{
resultTiles = null;
resultDirection = TileUtil.None;
}
}
else
{
var brushNum = 0;
for (brushNum = 0; brushNum <= painter.CliffBrushCount - 1; brushNum++)
{
terrainInner = painter.CliffBrushes[brushNum].Terrain_Inner;
terrainOuter = painter.CliffBrushes[brushNum].Terrain_Outer;
if (terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainOuter)
{
var a = 0;
if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner)
{
a++;
}
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner)
{
a++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
a++;
}
if (a >= 2)
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Corner_In;
resultDirection = TileUtil.TopLeft;
break;
}
}
else if (terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner)
{
var A = 0;
if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter)
{
A++;
}
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter)
{
A++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)
{
A++;
}
if (A >= 2)
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Corner_Out;
resultDirection = TileUtil.BottomRight;
break;
}
}
}
if (brushNum == painter.CliffBrushCount)
{
resultTiles = null;
resultDirection = TileUtil.None;
}
}
}
else if (terrain.Tiles[PosNum.X, PosNum.Y].TriBottomRightIsCliff)
{
var brushNum = 0;
for (brushNum = 0; brushNum <= painter.CliffBrushCount - 1; brushNum++)
{
terrainInner = painter.CliffBrushes[brushNum].Terrain_Inner;
terrainOuter = painter.CliffBrushes[brushNum].Terrain_Outer;
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)
{
var a = 0;
if (terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner)
{
a++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner)
{
a++;
}
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner)
{
a++;
}
if (a >= 2)
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Corner_In;
resultDirection = TileUtil.BottomRight;
break;
}
}
else if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
var a = 0;
if (terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainOuter)
{
a++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter)
{
a++;
}
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter)
{
a++;
}
if (a >= 2)
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Corner_Out;
resultDirection = TileUtil.TopLeft;
break;
}
}
}
if (brushNum == painter.CliffBrushCount)
{
resultTiles = null;
resultDirection = TileUtil.None;
}
}
}
else
{
//default tri orientation
if (terrain.Tiles[PosNum.X, PosNum.Y].TriTopRightIsCliff)
{
if (terrain.Tiles[PosNum.X, PosNum.Y].TriBottomLeftIsCliff)
{
var brushNum = 0;
for (brushNum = 0; brushNum <= painter.CliffBrushCount - 1; brushNum++)
{
terrainInner = painter.CliffBrushes[brushNum].Terrain_Inner;
terrainOuter = painter.CliffBrushes[brushNum].Terrain_Outer;
if (terrainInner == terrainOuter)
{
var a = 0;
if (terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner)
{
a++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner)
{
a++;
}
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner)
{
a++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
a++;
}
if (a >= 3)
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Straight;
resultDirection = terrain.Tiles[PosNum.X, PosNum.Y].DownSide;
break;
}
}
if (((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner && terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner) &&
(terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter ||
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)) ||
((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner || terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner) &&
(terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter &&
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)))
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Straight;
resultDirection = TileUtil.Bottom;
break;
}
if (((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainOuter &&
terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter) &&
(terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner ||
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)) ||
((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainOuter ||
terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter) &&
(terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner &&
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)))
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Straight;
resultDirection = TileUtil.Left;
break;
}
if (((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainOuter &&
terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter) &&
(terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner ||
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)) ||
((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainOuter ||
terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter) &&
(terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner &&
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)))
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Straight;
resultDirection = TileUtil.Top;
break;
}
if (((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner &&
terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner) &&
(terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter ||
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)) ||
((terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner ||
terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner) &&
(terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter &&
terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)))
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Straight;
resultDirection = TileUtil.Right;
break;
}
}
if (brushNum == painter.CliffBrushCount)
{
resultTiles = null;
resultDirection = TileUtil.None;
}
}
else
{
var brushNum = 0;
for (brushNum = 0; brushNum <= painter.CliffBrushCount - 1; brushNum++)
{
terrainInner = painter.CliffBrushes[brushNum].Terrain_Inner;
terrainOuter = painter.CliffBrushes[brushNum].Terrain_Outer;
if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter)
{
var a = 0;
if (terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner)
{
a++;
}
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner)
{
a++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
a++;
}
if (a >= 2)
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Corner_In;
resultDirection = TileUtil.TopRight;
break;
}
}
else if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner)
{
var a = 0;
if (terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainOuter)
{
a++;
}
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter)
{
a++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)
{
a++;
}
if (a >= 2)
{
resultTiles = painter.CliffBrushes[brushNum].Tiles_Corner_Out;
resultDirection = TileUtil.BottomLeft;
break;
}
}
}
if (brushNum == painter.CliffBrushCount)
{
resultTiles = null;
resultDirection = TileUtil.None;
}
}
}
else if (terrain.Tiles[PosNum.X, PosNum.Y].TriBottomLeftIsCliff)
{
var BrushNum = 0;
for (BrushNum = 0; BrushNum <= painter.CliffBrushCount - 1; BrushNum++)
{
terrainInner = painter.CliffBrushes[BrushNum].Terrain_Inner;
terrainOuter = painter.CliffBrushes[BrushNum].Terrain_Outer;
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter)
{
var A = 0;
if (terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainInner)
{
A++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainInner)
{
A++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainInner)
{
A++;
}
if (A >= 2)
{
resultTiles = painter.CliffBrushes[BrushNum].Tiles_Corner_In;
resultDirection = TileUtil.BottomLeft;
break;
}
}
else if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainInner)
{
var A = 0;
if (terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainOuter)
{
A++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter)
{
A++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)
{
A++;
}
if (A >= 2)
{
resultTiles = painter.CliffBrushes[BrushNum].Tiles_Corner_Out;
resultDirection = TileUtil.TopRight;
break;
}
}
}
if (BrushNum == painter.CliffBrushCount)
{
resultTiles = null;
resultDirection = TileUtil.None;
}
}
}
//apply roads
road = null;
if (terrain.SideH[PosNum.X, PosNum.Y].Road != null)
{
road = terrain.SideH[PosNum.X, PosNum.Y].Road;
}
else if (terrain.SideH[PosNum.X, PosNum.Y + 1].Road != null)
{
road = terrain.SideH[PosNum.X, PosNum.Y + 1].Road;
}
else if (terrain.SideV[PosNum.X + 1, PosNum.Y].Road != null)
{
road = terrain.SideV[PosNum.X + 1, PosNum.Y].Road;
}
else if (terrain.SideV[PosNum.X, PosNum.Y].Road != null)
{
road = terrain.SideV[PosNum.X, PosNum.Y].Road;
}
if (road != null)
{
var BrushNum = 0;
for (BrushNum = 0; BrushNum <= painter.RoadBrushCount - 1; BrushNum++)
{
if (painter.RoadBrushes[BrushNum].Road == road)
{
terrainOuter = painter.RoadBrushes[BrushNum].Terrain;
var A = 0;
if (terrain.Vertices[PosNum.X, PosNum.Y].Terrain == terrainOuter)
{
A++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y].Terrain == terrainOuter)
{
A++;
}
if (terrain.Vertices[PosNum.X, PosNum.Y + 1].Terrain == terrainOuter)
{
A++;
}
if (terrain.Vertices[PosNum.X + 1, PosNum.Y + 1].Terrain == terrainOuter)
{
A++;
}
if (A >= 2)
{
break;
}
}
}
resultTiles = null;
resultDirection = TileUtil.None;
if (BrushNum < painter.RoadBrushCount)
{
roadTop = terrain.SideH[PosNum.X, PosNum.Y].Road == road;
roadLeft = terrain.SideV[PosNum.X, PosNum.Y].Road == road;
roadRight = terrain.SideV[PosNum.X + 1, PosNum.Y].Road == road;
roadBottom = terrain.SideH[PosNum.X, PosNum.Y + 1].Road == road;
//do cross intersection
if (roadTop && roadLeft && roadRight && roadBottom)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_CrossIntersection;
resultDirection = TileUtil.None;
//do T intersection
}
else if (roadTop && roadLeft && roadRight)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_TIntersection;
resultDirection = TileUtil.Top;
}
else if (roadTop && roadLeft && roadBottom)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_TIntersection;
resultDirection = TileUtil.Left;
}
else if (roadTop && roadRight && roadBottom)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_TIntersection;
resultDirection = TileUtil.Right;
}
else if (roadLeft && roadRight && roadBottom)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_TIntersection;
resultDirection = TileUtil.Bottom;
//do straight
}
else if (roadTop && roadBottom)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_Straight;
if (App.Random.Next() >= 0.5F)
{
resultDirection = TileUtil.Top;
}
else
{
resultDirection = TileUtil.Bottom;
}
}
else if (roadLeft && roadRight)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_Straight;
if (App.Random.Next() >= 0.5F)
{
resultDirection = TileUtil.Left;
}
else
{
resultDirection = TileUtil.Right;
}
//do corner
}
else if (roadTop && roadLeft)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_Corner_In;
resultDirection = TileUtil.TopLeft;
}
else if (roadTop && roadRight)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_Corner_In;
resultDirection = TileUtil.TopRight;
}
else if (roadLeft && roadBottom)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_Corner_In;
resultDirection = TileUtil.BottomLeft;
}
else if (roadRight && roadBottom)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_Corner_In;
resultDirection = TileUtil.BottomRight;
//do end
}
else if (roadTop)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_End;
resultDirection = TileUtil.Top;
}
else if (roadLeft)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_End;
resultDirection = TileUtil.Left;
}
else if (roadRight)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_End;
resultDirection = TileUtil.Right;
}
else if (roadBottom)
{
resultTiles = painter.RoadBrushes[BrushNum].Tile_End;
resultDirection = TileUtil.Bottom;
}
}
}
if (resultTiles == null)
{
resultTexture.TextureNum = -1;
resultTexture.Direction = TileUtil.None;
}
else
{
resultTexture = resultTiles.GetRandom();
}
if (resultTexture.TextureNum < 0)
{
if (MakeInvalidTiles)
{
terrain.Tiles[PosNum.X, PosNum.Y].Texture = TileUtil.OrientateTile(ref resultTexture, resultDirection);
}
}
else
{
terrain.Tiles[PosNum.X, PosNum.Y].Texture = TileUtil.OrientateTile(ref resultTexture, resultDirection);
}
Map.SectorGraphicsChanges.TileChanged(PosNum);
Map.SectorTerrainUndoChanges.TileChanged(PosNum);
}
private void ToolPerformTile()
{
var PainterBrushNum = 0;
var A = 0;
for (PainterBrushNum = 0; PainterBrushNum <= Painter.TerrainCount - 1; PainterBrushNum++)
{
PainterTerrainA = Painter.Terrains[PainterBrushNum];
for (A = 0; A <= PainterTerrainA.Tiles.TileCount - 1; A++)
{
PainterTexture = PainterTerrainA.Tiles.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
TerrainCount[PainterTerrainA.Num]++;
}
}
}
for (PainterBrushNum = 0; PainterBrushNum <= Painter.TransitionBrushCount - 1; PainterBrushNum++)
{
PainterTerrainA = Painter.TransitionBrushes[PainterBrushNum].TerrainInner;
PainterTerrainB = Painter.TransitionBrushes[PainterBrushNum].TerrainOuter;
for (A = 0; A <= Painter.TransitionBrushes[PainterBrushNum].TilesStraight.TileCount - 1; A++)
{
PainterTexture = Painter.TransitionBrushes[PainterBrushNum].TilesStraight.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
TileUtil.RotateDirection(PainterTexture.Direction, Texture.Orientation, ref ResultDirection);
if (TileUtil.DirectionsOnSameSide(VertexDirection, ResultDirection))
{
TerrainCount[PainterTerrainB.Num]++;
}
else
{
TerrainCount[PainterTerrainA.Num]++;
}
}
}
for (A = 0; A <= Painter.TransitionBrushes[PainterBrushNum].TilesCornerIn.TileCount - 1; A++)
{
PainterTexture = Painter.TransitionBrushes[PainterBrushNum].TilesCornerIn.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
TileUtil.RotateDirection(PainterTexture.Direction, Texture.Orientation, ref ResultDirection);
if (TileUtil.IdenticalTileDirections(VertexDirection, ResultDirection))
{
TerrainCount[PainterTerrainB.Num]++;
}
else
{
TerrainCount[PainterTerrainA.Num]++;
}
}
}
for (A = 0; A <= Painter.TransitionBrushes[PainterBrushNum].TilesCornerOut.TileCount - 1; A++)
{
PainterTexture = Painter.TransitionBrushes[PainterBrushNum].TilesCornerOut.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
OppositeDirection = PainterTexture.Direction;
OppositeDirection.FlipX();
OppositeDirection.FlipY();
TileUtil.RotateDirection(OppositeDirection, Texture.Orientation, ref ResultDirection);
if (TileUtil.IdenticalTileDirections(VertexDirection, ResultDirection))
{
TerrainCount[PainterTerrainA.Num]++;
}
else
{
TerrainCount[PainterTerrainB.Num]++;
}
}
}
}
for (PainterBrushNum = 0; PainterBrushNum <= Painter.CliffBrushCount - 1; PainterBrushNum++)
{
PainterTerrainA = Painter.CliffBrushes[PainterBrushNum].Terrain_Inner;
PainterTerrainB = Painter.CliffBrushes[PainterBrushNum].Terrain_Outer;
for (A = 0; A <= Painter.CliffBrushes[PainterBrushNum].Tiles_Straight.TileCount - 1; A++)
{
PainterTexture = Painter.CliffBrushes[PainterBrushNum].Tiles_Straight.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
TileUtil.RotateDirection(PainterTexture.Direction, Texture.Orientation, ref ResultDirection);
if (TileUtil.DirectionsOnSameSide(VertexDirection, ResultDirection))
{
TerrainCount[PainterTerrainB.Num]++;
}
else
{
TerrainCount[PainterTerrainA.Num]++;
}
}
}
for (A = 0; A <= Painter.CliffBrushes[PainterBrushNum].Tiles_Corner_In.TileCount - 1; A++)
{
PainterTexture = Painter.CliffBrushes[PainterBrushNum].Tiles_Corner_In.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
TileUtil.RotateDirection(PainterTexture.Direction, Texture.Orientation, ref ResultDirection);
if (TileUtil.IdenticalTileDirections(VertexDirection, ResultDirection))
{
TerrainCount[PainterTerrainA.Num]++;
}
else
{
TerrainCount[PainterTerrainB.Num]++;
}
}
}
for (A = 0; A <= Painter.CliffBrushes[PainterBrushNum].Tiles_Corner_Out.TileCount - 1; A++)
{
PainterTexture = Painter.CliffBrushes[PainterBrushNum].Tiles_Corner_Out.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
OppositeDirection = PainterTexture.Direction;
OppositeDirection.FlipX();
OppositeDirection.FlipY();
TileUtil.RotateDirection(OppositeDirection, Texture.Orientation, ref ResultDirection);
if (TileUtil.IdenticalTileDirections(VertexDirection, ResultDirection))
{
TerrainCount[PainterTerrainA.Num]++;
}
else
{
TerrainCount[PainterTerrainB.Num]++;
}
}
}
}
for (PainterBrushNum = 0; PainterBrushNum <= Painter.RoadBrushCount - 1; PainterBrushNum++)
{
PainterTerrainA = Painter.RoadBrushes[PainterBrushNum].Terrain;
for (A = 0; A <= Painter.RoadBrushes[PainterBrushNum].Tile_Corner_In.TileCount - 1; A++)
{
PainterTexture = Painter.RoadBrushes[PainterBrushNum].Tile_Corner_In.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
TerrainCount[PainterTerrainA.Num]++;
}
}
for (A = 0; A <= Painter.RoadBrushes[PainterBrushNum].Tile_CrossIntersection.TileCount - 1; A++)
{
PainterTexture = Painter.RoadBrushes[PainterBrushNum].Tile_CrossIntersection.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
TerrainCount[PainterTerrainA.Num]++;
}
}
for (A = 0; A <= Painter.RoadBrushes[PainterBrushNum].Tile_End.TileCount - 1; A++)
{
PainterTexture = Painter.RoadBrushes[PainterBrushNum].Tile_End.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
TerrainCount[PainterTerrainA.Num]++;
}
}
for (A = 0; A <= Painter.RoadBrushes[PainterBrushNum].Tile_Straight.TileCount - 1; A++)
{
PainterTexture = Painter.RoadBrushes[PainterBrushNum].Tile_Straight.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
TerrainCount[PainterTerrainA.Num]++;
}
}
for (A = 0; A <= Painter.RoadBrushes[PainterBrushNum].Tile_TIntersection.TileCount - 1; A++)
{
PainterTexture = Painter.RoadBrushes[PainterBrushNum].Tile_TIntersection.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
TerrainCount[PainterTerrainA.Num]++;
}
}
}
}
public static clsTerrain.Tile.sTexture OrientateTile(ref TileOrientationChance tileChance, TileDirection newDirection)
{
var returnResult = new clsTerrain.Tile.sTexture();
//use random for empty tiles
if (tileChance.TextureNum < 0)
{
returnResult.Orientation.ResultXFlip = App.Random.Next() >= 0.5F;
returnResult.Orientation.ResultYFlip = App.Random.Next() >= 0.5F;
returnResult.Orientation.SwitchedAxes = App.Random.Next() >= 0.5F;
returnResult.TextureNum = -1;
return(returnResult);
}
//stop invalid numbers
if (tileChance.Direction.X > 2 | tileChance.Direction.Y > 2 | newDirection.X > 2 | newDirection.Y > 2)
{
Debugger.Break();
return(returnResult);
}
//stop different direction types
if ((newDirection.X == 1 ^ newDirection.Y == 1) ^ (tileChance.Direction.X == 1 ^ tileChance.Direction.Y == 1))
{
Debugger.Break();
return(returnResult);
}
returnResult.TextureNum = tileChance.TextureNum;
//if a direction is neutral then give a random orientation
if ((newDirection.X == 1 & newDirection.Y == 1) || (tileChance.Direction.X == 1 & tileChance.Direction.Y == 1))
{
returnResult.Orientation.SwitchedAxes = App.Random.Next() >= 0.5F;
returnResult.Orientation.ResultXFlip = App.Random.Next() >= 0.5F;
returnResult.Orientation.ResultYFlip = App.Random.Next() >= 0.5F;
return(returnResult);
}
bool isDiagonal = newDirection.X != 1 & newDirection.Y != 1;
if (isDiagonal)
{
returnResult.Orientation.SwitchedAxes = false;
//use flips to match the directions
if (tileChance.Direction.X == 0 ^ newDirection.X == 0)
{
returnResult.Orientation.ResultXFlip = true;
}
else
{
returnResult.Orientation.ResultXFlip = false;
}
if (tileChance.Direction.Y == 0 ^ newDirection.Y == 0)
{
returnResult.Orientation.ResultYFlip = true;
}
else
{
returnResult.Orientation.ResultYFlip = false;
}
//randomly switch to the alternate orientation
if (App.Random.Next() >= 0.5F)
{
returnResult.Orientation.SwitchedAxes = !returnResult.Orientation.SwitchedAxes;
if ((newDirection.X == 0 ^ newDirection.Y == 0) ^ (returnResult.Orientation.ResultXFlip ^ returnResult.Orientation.ResultYFlip))
{
returnResult.Orientation.ResultXFlip = !returnResult.Orientation.ResultXFlip;
returnResult.Orientation.ResultYFlip = !returnResult.Orientation.ResultYFlip;
}
}
}
else
{
//switch axes if the directions are on different axes
returnResult.Orientation.SwitchedAxes = tileChance.Direction.X == 1 ^ newDirection.X == 1;
//use a flip to match the directions
if (returnResult.Orientation.SwitchedAxes)
{
if (tileChance.Direction.Y != newDirection.X)
{
returnResult.Orientation.ResultXFlip = true;
}
else
{
returnResult.Orientation.ResultXFlip = false;
}
if (tileChance.Direction.X != newDirection.Y)
{
returnResult.Orientation.ResultYFlip = true;
}
else
{
returnResult.Orientation.ResultYFlip = false;
}
}
else
{
if (tileChance.Direction.X != newDirection.X)
{
returnResult.Orientation.ResultXFlip = true;
}
else
{
returnResult.Orientation.ResultXFlip = false;
}
if (tileChance.Direction.Y != newDirection.Y)
{
returnResult.Orientation.ResultYFlip = true;
}
else
{
returnResult.Orientation.ResultYFlip = false;
}
}
//randomly switch to the alternate orientation
if (App.Random.Next() >= 0.5F)
{
if (newDirection.X == 1)
{
returnResult.Orientation.ResultXFlip = !returnResult.Orientation.ResultXFlip;
}
else
{
returnResult.Orientation.ResultYFlip = !returnResult.Orientation.ResultYFlip;
}
}
}
return(returnResult);
}
protected void ToolPerformTile()
{
var PainterBrushNum = 0;
var A = 0;
for (PainterBrushNum = 0; PainterBrushNum <= Painter.RoadBrushCount - 1; PainterBrushNum++)
{
PainterRoad = Painter.RoadBrushes[PainterBrushNum].Road;
PainterTerrain = Painter.RoadBrushes[PainterBrushNum].Terrain;
for (A = 0; A <= Painter.RoadBrushes[PainterBrushNum].Tile_Corner_In.TileCount - 1; A++)
{
PainterTexture = Painter.RoadBrushes[PainterBrushNum].Tile_Corner_In.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
TileUtil.RotateDirection(PainterTexture.Direction, Texture.Orientation, ref ResultDirection);
if (TileUtil.DirectionsOnSameSide(SideDirection, ResultDirection))
{
RoadCount[PainterRoad.Num]++;
}
}
}
for (A = 0; A <= Painter.RoadBrushes[PainterBrushNum].Tile_CrossIntersection.TileCount - 1; A++)
{
PainterTexture = Painter.RoadBrushes[PainterBrushNum].Tile_CrossIntersection.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
RoadCount[PainterRoad.Num]++;
}
}
for (A = 0; A <= Painter.RoadBrushes[PainterBrushNum].Tile_End.TileCount - 1; A++)
{
PainterTexture = Painter.RoadBrushes[PainterBrushNum].Tile_End.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
TileUtil.RotateDirection(PainterTexture.Direction, Texture.Orientation, ref ResultDirection);
if (TileUtil.IdenticalTileDirections(SideDirection, ResultDirection))
{
RoadCount[PainterRoad.Num]++;
}
}
}
for (A = 0; A <= Painter.RoadBrushes[PainterBrushNum].Tile_Straight.TileCount - 1; A++)
{
PainterTexture = Painter.RoadBrushes[PainterBrushNum].Tile_Straight.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
TileUtil.RotateDirection(PainterTexture.Direction, Texture.Orientation, ref ResultDirection);
if (TileUtil.DirectionsAreInLine(SideDirection, ResultDirection))
{
RoadCount[PainterRoad.Num]++;
}
}
}
for (A = 0; A <= Painter.RoadBrushes[PainterBrushNum].Tile_TIntersection.TileCount - 1; A++)
{
PainterTexture = Painter.RoadBrushes[PainterBrushNum].Tile_TIntersection.Tiles[A];
if (PainterTexture.TextureNum == Texture.TextureNum)
{
TileUtil.RotateDirection(PainterTexture.Direction, Texture.Orientation, ref ResultDirection);
if (!TileUtil.DirectionsOnSameSide(SideDirection, ResultDirection))
{
RoadCount[PainterRoad.Num]++;
}
}
}
}
}
