public void RaiseStepWise(BlockVertical vertical, bool diagonalStep, int increment, bool autoSwitch = false)
{
var split = vertical.IsOnFloor() ? Floor.DiagonalSplit : Ceiling.DiagonalSplit;
if (split != DiagonalSplit.None)
{
var stepIsLimited = increment != 0 && increment > 0 == (vertical.IsOnCeiling() ^ diagonalStep);
if (split == DiagonalSplit.XpZn && GetHeight(vertical, BlockEdge.XnZp) == GetHeight(vertical, BlockEdge.XpZp) && stepIsLimited ||
split == DiagonalSplit.XnZn && GetHeight(vertical, BlockEdge.XpZp) == GetHeight(vertical, BlockEdge.XpZn) && stepIsLimited ||
split == DiagonalSplit.XnZp && GetHeight(vertical, BlockEdge.XpZn) == GetHeight(vertical, BlockEdge.XnZn) && stepIsLimited ||
split == DiagonalSplit.XpZp && GetHeight(vertical, BlockEdge.XnZn) == GetHeight(vertical, BlockEdge.XnZp) && stepIsLimited)
{
if (IsAnyWall && autoSwitch)
{
Raise(vertical, increment, !diagonalStep);
}
else
{
if (autoSwitch)
{
Transform(new RectTransformation {
QuadrantRotation = 2
}, vertical.IsOnFloor());
Raise(vertical, increment, !diagonalStep);
}
return;
}
}
}
Raise(vertical, increment, diagonalStep);
}
public void ChangeHeight(BlockVertical vertical, BlockEdge edge, int increment)
{
if (increment != 0)
{
SetHeight(vertical, edge, (short)(GetHeight(vertical, edge) + increment));
}
}
public Block[,] GetSectors()
{
if (_data == null)
{
return(null);
}
var sectors = new Block[Width, Height];
using (var ms = new MemoryStream(_data))
{
using (var reader = new BinaryReader(ms))
{
for (int x = 0; x < Width; x++)
{
for (int z = 0; z < Height; z++)
{
var b = sectors[x, z] = new Block(0, 12);
for (BlockVertical vertical = 0; vertical < BlockVertical.Count; ++vertical)
{
for (BlockEdge edge = 0; edge < BlockEdge.Count; ++edge)
{
b.SetHeight(vertical, edge, reader.ReadInt16());
}
}
b.Type = (BlockType)reader.ReadInt32();
b.ForceFloorSolid = reader.ReadBoolean();
b.Floor.SplitDirectionToggled = reader.ReadBoolean();
b.Floor.SplitDirectionIsXEqualsZ = reader.ReadBoolean();
b.Floor.DiagonalSplit = (DiagonalSplit)reader.ReadInt32();
b.Ceiling.SplitDirectionToggled = reader.ReadBoolean();
b.Ceiling.SplitDirectionIsXEqualsZ = reader.ReadBoolean();
b.Ceiling.DiagonalSplit = (DiagonalSplit)reader.ReadInt32();
b.Flags = (BlockFlags)reader.ReadInt32();
sectors[x, z] = b;
}
}
}
}
return(sectors);
}
public SectorsClipboardData(Editor editor)
{
var selection = editor.SelectedSectors;
Width = selection.Area.Width + 1;
Height = selection.Area.Height + 1;
using (var ms = new MemoryStream())
{
using (var writer = new BinaryWriter(ms))
{
Block[,] sectors = new Block[selection.Area.Width, selection.Area.Height];
for (int x = 0; x < Width; x++)
{
for (int z = 0; z < Height; z++)
{
var currX = selection.Area.X0 + x;
var currZ = selection.Area.Y0 + z;
var b = editor.SelectedRoom.Blocks[currX, currZ];
for (BlockVertical vertical = 0; vertical < BlockVertical.Count; ++vertical)
{
for (BlockEdge edge = 0; edge < BlockEdge.Count; ++edge)
{
writer.Write((short)b.GetHeight(vertical, edge));
}
}
writer.Write((int)b.Type);
writer.Write(b.ForceFloorSolid);
writer.Write(b.Floor.SplitDirectionToggled);
writer.Write(b.Floor.SplitDirectionIsXEqualsZ);
writer.Write((int)b.Floor.DiagonalSplit);
writer.Write(b.Ceiling.SplitDirectionToggled);
writer.Write(b.Ceiling.SplitDirectionIsXEqualsZ);
writer.Write((int)b.Ceiling.DiagonalSplit);
writer.Write((int)b.Flags);
}
}
}
_data = ms.ToArray();
}
}
public short GetHeight(BlockVertical vertical, BlockEdge edge)
{
switch (vertical)
{
case BlockVertical.Floor:
return(Floor.GetHeight(edge));
case BlockVertical.Ceiling:
return(Ceiling.GetHeight(edge));
case BlockVertical.Ed:
return(_ed[(int)edge]);
case BlockVertical.Rf:
return(_rf[(int)edge]);
default:
throw new ArgumentOutOfRangeException();
}
}
public void Raise(BlockVertical vertical, int increment, bool diagonalStep = false)
{
var split = vertical == BlockVertical.Floor || vertical == BlockVertical.Ed ? Floor.DiagonalSplit : Ceiling.DiagonalSplit;
if (diagonalStep)
{
switch (split)
{
case DiagonalSplit.XpZn:
ChangeHeight(vertical, BlockEdge.XnZp, increment);
break;
case DiagonalSplit.XnZn:
ChangeHeight(vertical, BlockEdge.XpZp, increment);
break;
case DiagonalSplit.XnZp:
ChangeHeight(vertical, BlockEdge.XpZn, increment);
break;
case DiagonalSplit.XpZp:
ChangeHeight(vertical, BlockEdge.XnZn, increment);
break;
}
}
else
{
for (BlockEdge edge = 0; edge < BlockEdge.Count; edge++)
{
if (edge == BlockEdge.XnZp && split == DiagonalSplit.XpZn ||
edge == BlockEdge.XnZn && split == DiagonalSplit.XpZp ||
edge == BlockEdge.XpZn && split == DiagonalSplit.XnZp ||
edge == BlockEdge.XpZp && split == DiagonalSplit.XnZn)
{
continue;
}
ChangeHeight(vertical, edge, increment);
}
}
}
public void SetHeight(BlockVertical vertical, BlockEdge edge, int newValue)
{
switch (vertical)
{
case BlockVertical.Floor:
Floor.SetHeight(edge, newValue);
return;
case BlockVertical.Ceiling:
Ceiling.SetHeight(edge, newValue);
return;
case BlockVertical.Ed:
_ed[(int)edge] = checked ((short)newValue);
return;
case BlockVertical.Rf:
_rf[(int)edge] = checked ((short)newValue);
return;
default:
throw new ArgumentOutOfRangeException();
}
}
public static bool IsOnCeiling(this BlockVertical vertical) => vertical == BlockVertical.Ceiling || vertical == BlockVertical.Rf;
public static bool IsOnFloor(this BlockVertical vertical) => vertical == BlockVertical.Floor || vertical == BlockVertical.Ed;
