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 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);
}
public override void ActionPerform()
{
var A = 0;
Terrain = Map.Terrain;
Painter = Map.Painter;
TerrainCount = new int[Painter.TerrainCount];
if (PosNum.Y > 0)
{
if (PosNum.X > 0)
{
VertexDirection = TileUtil.BottomRight;
Tile = Terrain.Tiles[PosNum.X - 1, PosNum.Y - 1];
Texture = Tile.Texture;
ToolPerformTile();
}
if (PosNum.X < Terrain.TileSize.X)
{
VertexDirection = TileUtil.BottomLeft;
Tile = Terrain.Tiles[PosNum.X, PosNum.Y - 1];
Texture = Tile.Texture;
ToolPerformTile();
}
}
if (PosNum.Y < Terrain.TileSize.Y)
{
if (PosNum.X > 0)
{
VertexDirection = TileUtil.TopRight;
Tile = Terrain.Tiles[PosNum.X - 1, PosNum.Y];
Texture = Tile.Texture;
ToolPerformTile();
}
if (PosNum.X < Terrain.TileSize.X)
{
VertexDirection = TileUtil.TopLeft;
Tile = Terrain.Tiles[PosNum.X, PosNum.Y];
Texture = Tile.Texture;
ToolPerformTile();
}
}
BestNum = -1;
BestCount = 0;
for (A = 0; A <= Painter.TerrainCount - 1; A++)
{
if (TerrainCount[A] > BestCount)
{
BestNum = A;
BestCount = TerrainCount[A];
}
}
if (BestCount > 0)
{
Terrain.Vertices[PosNum.X, PosNum.Y].Terrain = Painter.Terrains[BestNum];
}
else
{
Terrain.Vertices[PosNum.X, PosNum.Y].Terrain = null;
}
Map.SectorTerrainUndoChanges.VertexChanged(PosNum);
}
public override void ActionPerform()
{
var PainterBrushNum = 0;
var A = 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++ )
{
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()
{
var A = 0;
Terrain = Map.Terrain;
Painter = Map.Painter;
TerrainCount = new int[Painter.TerrainCount];
if ( PosNum.Y > 0 )
{
if ( PosNum.X > 0 )
{
VertexDirection = TileUtil.BottomRight;
Tile = Terrain.Tiles[PosNum.X - 1, PosNum.Y - 1];
Texture = Tile.Texture;
ToolPerformTile();
}
if ( PosNum.X < Terrain.TileSize.X )
{
VertexDirection = TileUtil.BottomLeft;
Tile = Terrain.Tiles[PosNum.X, PosNum.Y - 1];
Texture = Tile.Texture;
ToolPerformTile();
}
}
if ( PosNum.Y < Terrain.TileSize.Y )
{
if ( PosNum.X > 0 )
{
VertexDirection = TileUtil.TopRight;
Tile = Terrain.Tiles[PosNum.X - 1, PosNum.Y];
Texture = Tile.Texture;
ToolPerformTile();
}
if ( PosNum.X < Terrain.TileSize.X )
{
VertexDirection = TileUtil.TopLeft;
Tile = Terrain.Tiles[PosNum.X, PosNum.Y];
Texture = Tile.Texture;
ToolPerformTile();
}
}
BestNum = -1;
BestCount = 0;
for ( A = 0; A <= Painter.TerrainCount - 1; A++ )
{
if ( TerrainCount[A] > BestCount )
{
BestNum = A;
BestCount = TerrainCount[A];
}
}
if ( BestCount > 0 )
{
Terrain.Vertices[PosNum.X, PosNum.Y].Terrain = Painter.Terrains[BestNum];
}
else
{
Terrain.Vertices[PosNum.X, PosNum.Y].Terrain = null;
}
Map.SectorTerrainUndoChanges.VertexChanged(PosNum);
}
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;
}
var IsDiagonal = default(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;
}
