public List <Entity> GetRange(VectorRangeI range, Vector3I top)
{
var output = new List <Entity>();
var cube = new VectorCubeI(range.Start, top);
for (var y = cube.Y.Start - 1; y <= cube.Y.End; y++)
{
for (var x = cube.X.Start; x <= cube.X.End; x++)
{
for (var z = cube.Z.Start; z <= cube.Z.End; z++)
{
var render = z == cube.Z.Start || z == cube.Z.End ||
x == cube.X.Start || x == cube.X.Start - 1 || x == cube.X.End || x == cube.X.End - 1;
if (render)
{
var entity = new Entity(CoreHook.Universe.AllocateNewEntityId(), false, ParticleHostEntityBuilder.KindCode, true);
entity.Physics.ForcedPosition(new Vector3D(x, y, z));
((ParticleHostEntityLogic)entity.Logic).SetParticleCode(range.ParticleCode);
((ParticleHostEntityLogic)entity.Logic).SetLocation(new Vector3D(x, y, z));
output.Add(entity);
}
}
}
}
return(output);
}
internal static bool Wall(Entity entity, int width, int height, out long tileCount, string tile = "staxel.tile.dirt.dirt")
{
var parseWidth = width <= 0 ? 0 : width;
var parseHeight = height <= 0 ? 0 : height;
tileCount = 0;
if (!TileShortCodes.IsValidTile(tile))
{
return(false);
}
var newTile = TileShortCodes.GetTile(tile);
var facing = entity.PlayerEntityLogic.Heading().GetDirection();
Vector3I center;
Vector3I start;
Vector3I end;
var position = entity.Physics.BottomPosition().From3Dto3I();
if (facing == Compass.NORTH || facing == Compass.SOUTH)
{
center = facing == Compass.NORTH ? new Vector3I(position.X, position.Y, position.Z - 1) : new Vector3I(position.X, position.Y, position.Z + 1);
}
else
{
center = facing == Compass.EAST ? new Vector3I(position.X + 1, position.Y, position.Z) : new Vector3I(position.X - 1, position.Y, position.Z);
}
var div = (float)parseWidth / 2;
var side1 = (int)Math.Floor(div);
var side2 = (int)Math.Floor(div);
if (facing == Compass.NORTH || facing == Compass.SOUTH)
{
start = new Vector3I(center.X - side1, center.Y, center.Z);
end = new Vector3I(center.X + side2, center.Y + parseHeight, center.Z);
}
else
{
start = new Vector3I(center.X, center.Y, center.Z - side1);
end = new Vector3I(center.X, center.Y + parseHeight, center.Z + side2);
}
var vc = new VectorCubeI(start, end);
SaveUndo(entity, vc.Start, vc.End, true, tile);
var count = 0;
var list = new List <RenderItem>();
tileCount = count;
return(true);
}
internal static void Replace(Entity entity, string newKindCode, string oldKindCode, out long replacedTiles, out ReplaceResult result)
{
replacedTiles = 0;
result = ReplaceResult.Success;
EntityCheck(entity);
var target = PositionClone()[entity];
if (target.Pos1 == default(Vector3D) || target.Pos2 == default(Vector3D))
{
result = ReplaceResult.InvalidPositions;
return;
}
var newTileConfig = GameContext.TileDatabase.AllMaterials().FirstOrDefault(x =>
string.Equals(x.Code, newKindCode, StringComparison.CurrentCultureIgnoreCase));
if (newTileConfig == null)
{
result = ReplaceResult.InvalidTile;
return;
}
var newTile = newTileConfig.MakeTile();
var vc = new VectorCubeI(target.Pos1.From3Dto3I(), target.Pos2.From3Dto3I());
SaveUndo(entity, vc.Start, vc.End, true, newKindCode);
var count = 0;
replacedTiles = count;
}
internal static long Copy(Entity entity)
{
EntityCheck(entity);
var target = PositionClone()[entity];
if (target.Pos1 == default(Vector3D) || target.Pos2 == default(Vector3D))
{
return(0);
}
var region = new VectorCubeI(target.Pos1.From3Dto3I(), target.Pos2.From3Dto3I());
target.ClipBoard.Clear();
Helpers.VectorLoop(target.Pos1.From3Dto3I(), target.Pos2.From3Dto3I(), (x, y, z) => {
Tile tile;
if (FoxCore.WorldManager.Universe.World.ReadTile(new Vector3I(x, y, z), TileAccessFlags.SynchronousWait,
out tile))
{
target.ClipBoard.Add(new Vector3I(x - region.Start.X, y - region.Start.Y, z - region.Start.Z), tile);
}
});
target.ClipBoardOffset = new Vector3D(region.Start.X - entity.Physics.Position.X,
region.Start.Y - entity.Physics.Position.Y, region.Start.Z - entity.Physics.Position.Z);
return(region.GetTileCount());
}
public void SetRegion(VectorCubeI region)
{
Region = region;
if (Entity.Physics.Position != region.Start.ToVector3D())
{
SetDestination(region.Start);
}
}
public static void VectorLoop(VectorCubeI region, Action <int, int, int> coordFunction)
{
for (var y = region.Start.Y; y <= region.End.Y; y++)
{
for (var z = region.Start.Z; z <= region.End.Z; z++)
{
for (var x = region.Start.X; x <= region.End.X; x++)
{
coordFunction(x, y, z);
}
}
}
}
internal static void Export(Entity entity, string schematic)
{
EntityCheck(entity);
var target = PositionClone()[entity];
var cube = new VectorCubeI(target.Pos1.From3Dto3I(), target.Pos2.From3Dto3I());
var cube0 = Vector3I.Min(new Vector3I(cube.Start.X, cube.Start.Y, cube.Start.Z), new Vector3I(cube.End.X, cube.End.Y, cube.End.Z));
var cube1 = Vector3I.Max(new Vector3I(cube.Start.X, cube.Start.Y, cube.Start.Z),
new Vector3I(cube.End.X, cube.End.Y, cube.End.Z)) - cube0 + Vector3I.One;
FoxCore.SaveDirectory.FetchDirectory("Exports").ExportCube(cube1, cube0, schematic);
}
internal static bool Platform(Entity entity, int size, out long tileCount, string tile = "staxel.tile.dirt.dirt")
{
var parseSize = size <= 0 ? 0 : size;
tileCount = 0;
if (!TileShortCodes.IsValidTile(tile))
{
return(false);
}
var newTile = TileShortCodes.GetTile(tile);
var current = entity.Physics.BottomPosition().From3Dto3I();
var start = new Vector3I(current.X - parseSize, current.Y - 1, current.Z - parseSize);
var end = new Vector3I(current.X + parseSize, current.Y - 1, current.Z + parseSize);
var count = 0;
var vc = new VectorCubeI(start, end);
SaveUndo(entity, vc.Start, vc.End, true, tile);
Helpers.VectorLoop(start, end, (x, y, z) => {
Tile currentTile;
if (FoxCore.WorldManager.World.ReadTile(new Vector3I(x, y, z), TileAccessFlags.SynchronousWait,
out currentTile))
{
if (string.Equals(currentTile.Configuration.Code, "staxel.tile.Sky",
StringComparison.CurrentCultureIgnoreCase))
{
if (FoxCore.WorldManager.World.PlaceTile(new Vector3I(x, y, z), newTile,
TileAccessFlags.SynchronousWait))
{
count++;
}
}
}
});
tileCount = count;
return(true);
}
internal static long Paste(Entity entity, bool vectorOverride = false, Vector3I vectorO = default(Vector3I))
{
EntityCheck(entity);
var target = PositionClone()[entity];
if (target.ClipBoard.Any())
{
var entityVector = entity.Physics.BottomPosition().From3Dto3I();
if (vectorOverride)
{
entityVector = vectorO;
}
var clipboardVector = target.ClipBoardOffset.From3Dto3I();
var first = target.ClipBoard.First();
var last = target.ClipBoard.Last();
var min = new Vector3I(first.Key.X + clipboardVector.X + entityVector.X,
first.Key.Y + clipboardVector.Y + entityVector.Y,
first.Key.Z + clipboardVector.Z + entityVector.Z);
var max = new Vector3I(last.Key.X + clipboardVector.X + entityVector.X,
last.Key.Y + clipboardVector.Y + entityVector.Y,
last.Key.Z + clipboardVector.Z + entityVector.Z);
var vc = new VectorCubeI(min, max);
SaveUndo(entity, vc.Start, vc.End);
return(target.ClipBoard.Count);
}
return(0);
}
internal static void Stack(Entity entity, int repeat, string direction = "forwards")
{
EntityCheck(entity);
var target = PositionClone()[entity];
if (target.Pos1 == default(Vector3D) || target.Pos2 == default(Vector3D))
{
return;
}
var targetcube = new VectorCubeI(target.Pos1.From3Dto3I(), target.Pos2.From3Dto3I());
var facing = entity.Logic.Heading().GetDirection();
switch (direction.ToLower())
{
case "forwards":
break;
case "left":
if (facing == Compass.EAST)
{
facing = Compass.NORTH;
}
else if (facing == Compass.NORTH)
{
facing = Compass.WEST;
}
else if (facing == Compass.WEST)
{
facing = Compass.SOUTH;
}
else if (facing == Compass.SOUTH)
{
facing = Compass.EAST;
}
break;
case "right":
if (facing == Compass.EAST)
{
facing = Compass.SOUTH;
}
else if (facing == Compass.SOUTH)
{
facing = Compass.WEST;
}
else if (facing == Compass.WEST)
{
facing = Compass.NORTH;
}
else if (facing == Compass.NORTH)
{
facing = Compass.EAST;
}
break;
case "backwards":
if (facing == Compass.EAST)
{
facing = Compass.WEST;
}
else if (facing == Compass.WEST)
{
facing = Compass.EAST;
}
else if (facing == Compass.NORTH)
{
facing = Compass.SOUTH;
}
else if (facing == Compass.SOUTH)
{
facing = Compass.NORTH;
}
break;
case "up":
facing = Compass.UP;
break;
case "down":
facing = Compass.DOWN;
break;
default:
return;
}
var oldClipboard = target.ClipBoard;
Copy(entity);
var cube = new VectorCubeI(target.ClipBoard.Keys.First(), target.ClipBoard.Keys.Last());
var oldOffset = target.ClipBoardOffset;
var x = cube.End.X - cube.Start.X;
var y = cube.End.Y - cube.Start.Y;
var z = cube.End.Z - cube.Start.Z;
for (var i = 1; i <= repeat; i++)
{
if (facing == Compass.NORTH)
{
target.ClipBoardOffset = new Vector3D(0, 0, -z * i);
}
else if (facing == Compass.EAST)
{
target.ClipBoardOffset = new Vector3D(x * i, 0, 0);
}
else if (facing == Compass.SOUTH)
{
target.ClipBoardOffset = new Vector3D(0, 0, z * i);
}
else if (facing == Compass.WEST)
{
target.ClipBoardOffset = new Vector3D(-x * i, 0, 0);
}
else if (facing == Compass.UP)
{
target.ClipBoardOffset = new Vector3D(0, y * i, 0);
}
else if (facing == Compass.DOWN)
{
target.ClipBoardOffset = new Vector3D(0, -y * i, 0);
}
Paste(entity, true, targetcube.Start);
}
target.ClipBoardOffset = oldOffset;
target.ClipBoard = oldClipboard;
}
//internal void RenderRegions() {
// foreach (var toRender in CloneRegions().Where(x => !x.Value.Rendered || x.Value.Remove)) {
// foreach (var item in toRender.Value.Info.Where(x => !x.Rendered || (toRender.Value.Remove && !x.Removed)).Take(25)) {
// if (!item.Rendered) {
// toRender.Value.Rendered =
// WorldEditManager.FoxCore.WorldManager.World.PlaceTile(item.Location, item.Tile,
// TileAccessFlags.None);
// } else {
// if (toRender.Value.Remove) {
// if (WorldEditManager.FoxCore.WorldManager.World.PlaceTile(item.Location,
// TileShortCodes.GetTile("staxel.tile.Sky"), TileAccessFlags.SynchronousWait)) {
// item.Removed = true;
// }
// }
// }
// }
// if (!toRender.Value.Info.Any(x => !x.Rendered)) {
// toRender.Value.Rendered = true;
// }
// if (!toRender.Value.Info.Any(x => !x.Removed)) {
// Regions.Remove(toRender.Key);
// }
// }
//}
internal Guid AddCube(Vector3I start, Vector3I end, FrameTiles tiles)
{
var guid = Guid.NewGuid();
var cube = new VectorCubeI(start, end).GetOuterRegions();
Helpers.VectorLoop(cube.Start, cube.End, (x, y, z) => {
var renderCount = 0;
renderCount += y == cube.Start.Y || y == cube.End.Y ? 1 : 0;
renderCount += z == cube.Start.Z || z == cube.End.Z ? 1 : 0;
renderCount += x == cube.Start.X || x == cube.End.X ? 1 : 0;
if (renderCount > 1)
{
Tile tile;
var current = new Vector3I(x, y, z);
loop:
if (WorldEditManager.FoxCore.WorldManager.Universe.ReadTile(current, TileAccessFlags.SynchronousWait, out tile))
{
if (tile.Configuration.Code.ToLower() == "staxel.tile.sky")
{
Tile?cT = null;
if ((x == cube.Start.X || x == cube.End.X) && (z == cube.Start.Z || z == cube.End.Z))
{
cT = tiles.Line.Y;
}
if (z == cube.Start.Z || z == cube.End.Z)
{
if (cT == null)
{
cT = tiles.Line.Z;
}
else
{
if (z == cube.Start.Z)
{
if (y == cube.Start.Y)
{
cT = tiles.L.Up.Z;
}
else if (y == cube.End.Y)
{
cT = tiles.L.Down.Z;
}
}
else if (z == cube.End.Z)
{
if (y == cube.Start.Y)
{
cT = tiles.L.Up.NZ;
}
else if (y == cube.End.Y)
{
cT = tiles.L.Down.NZ;
}
}
}
}
if (x == cube.Start.X || x == cube.End.X)
{
if (cT == null)
{
cT = tiles.Line.X;
}
else
{
if (x == cube.Start.X)
{
if (cT == tiles.Line.Y)
{
if (y == cube.Start.Y)
{
cT = tiles.L.Up.X;
}
else if (y == cube.End.Y)
{
cT = tiles.L.Down.X;
}
}
else if (cT == tiles.Line.Z)
{
if (z == cube.Start.Z)
{
cT = tiles.L.Side.NE;
}
else if (z == cube.End.Z)
{
cT = tiles.L.Side.SW;
}
}
else if (cT == tiles.L.Up.Z)
{
cT = tiles.Corner.Up.NE;
}
else if (cT == tiles.L.Down.Z)
{
cT = tiles.Corner.Down.NE;
}
else if (cT == tiles.L.Up.NZ)
{
cT = tiles.Corner.Up.WN;
}
else if (cT == tiles.L.Down.NZ)
{
cT = tiles.Corner.Down.WN;
}
}
else if (x == cube.End.X)
{
if (cT == tiles.Line.Y)
{
if (y == cube.Start.Y)
{
cT = tiles.L.Up.NX;
}
else if (y == cube.End.Y)
{
cT = tiles.L.Down.NX;
}
}
else if (cT == tiles.Line.Z)
{
if (z == cube.Start.Z)
{
cT = tiles.L.Side.ES;
}
else if (z == cube.End.Z)
{
cT = tiles.L.Side.WN;
}
}
else if (cT == tiles.L.Up.Z)
{
cT = tiles.Corner.Up.ES;
}
else if (cT == tiles.L.Down.Z)
{
cT = tiles.Corner.Down.ES;
}
else if (cT == tiles.L.Up.NZ)
{
cT = tiles.Corner.Up.SW;
}
else if (cT == tiles.L.Down.NZ)
{
cT = tiles.Corner.Down.SW;
}
}
}
}
if (cT != null)
{
Add(guid, new FrameRegion.FrameRegionInfo {
Tile = cT.Value,
Location = current
});
}
}
}
else
{
goto loop;
}
}
});
return(guid);
}
