From fc65f22febd6cd75fa7b9cd236685ffcfeb7772a Mon Sep 17 00:00:00 2001 From: rycbar0 Date: Mon, 3 Oct 2022 19:59:07 +0200 Subject: [PATCH] clean up and adding javadoc --- .../java/baritone/process/BuilderProcess.java | 14 ++-- .../format/defaults/LitematicaSchematic.java | 67 +++++++++++----- .../litematica/LitematicaHelper.java | 79 +++++++++++++++++-- .../placement/SchematicPlacementManager.java | 2 +- 4 files changed, 129 insertions(+), 33 deletions(-) diff --git a/src/main/java/baritone/process/BuilderProcess.java b/src/main/java/baritone/process/BuilderProcess.java index 110df3de..124547ee 100644 --- a/src/main/java/baritone/process/BuilderProcess.java +++ b/src/main/java/baritone/process/BuilderProcess.java @@ -181,6 +181,10 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil } } + /** + * Builds the with index 'i' given schematic placement. + * @param i index reference to the schematic placement list. + */ @Override public void buildOpenLitematic(int i) { if (LitematicaHelper.isLitematicaPresent()) { @@ -190,14 +194,10 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil try { LitematicaSchematic schematic1 = new LitematicaSchematic(CompressedStreamTools.readCompressed(Files.newInputStream(LitematicaHelper.getSchematicFile(i).toPath())),false); Vec3i correctedOrigin = LitematicaHelper.getCorrectedOrigin(schematic1, i); - try { - LitematicaSchematic schematic2 = LitematicaHelper.blackMagicFuckery(schematic1, i); - build(name, schematic2, correctedOrigin); - } catch (IndexOutOfBoundsException e) { - logDirect("BlackMagicFuckery summoned a Balrog. This foe is beyond any of you. "); - } + LitematicaSchematic schematic2 = LitematicaHelper.blackMagicFuckery(schematic1, i); + build(name, schematic2, correctedOrigin); } catch (IOException e) { - logDirect("Schematic File could not be loaded"); + logDirect("Schematic File could not be loaded."); } } else { logDirect("No schematic currently loaded"); diff --git a/src/main/java/baritone/utils/schematic/format/defaults/LitematicaSchematic.java b/src/main/java/baritone/utils/schematic/format/defaults/LitematicaSchematic.java index fb2f36eb..f55f9212 100644 --- a/src/main/java/baritone/utils/schematic/format/defaults/LitematicaSchematic.java +++ b/src/main/java/baritone/utils/schematic/format/defaults/LitematicaSchematic.java @@ -38,16 +38,16 @@ import java.util.Optional; * @since 22.09.2022 */ public final class LitematicaSchematic extends StaticSchematic { - private final int minX; - private final int minY; - private final int minZ; + private final Vec3i offsetMinCorner; private final NBTTagCompound nbt; + /** + * @param nbtTagCompound a decompressed file stream aka nbt data. + * @param rotated if the schematic is rotated by 90° aka x and z size are switched. + */ public LitematicaSchematic(NBTTagCompound nbtTagCompound, boolean rotated) { this.nbt = nbtTagCompound; - this.minX = getMinOfSchematic("x"); - this.minY = getMinOfSchematic("y"); - this.minZ = getMinOfSchematic("z"); + this.offsetMinCorner = new Vec3i(getMinOfSchematic("x"),getMinOfSchematic("y"),getMinOfSchematic("z")); this.y = Math.abs(nbt.getCompoundTag("Metadata").getCompoundTag("EnclosingSize").getInteger("y")); if (rotated) { @@ -61,6 +61,10 @@ public final class LitematicaSchematic extends StaticSchematic { fillInSchematic(); } + /** + * @param s axis. + * @return the lowest coordinate of that axis of the schematic. + */ private int getMinOfSchematic(String s) { int n = Integer.MAX_VALUE; for (String subReg : getRegions(nbt)) { @@ -69,6 +73,9 @@ public final class LitematicaSchematic extends StaticSchematic { return n; } + /** + * reads the file data. + */ private void fillInSchematic() { for (String subReg : getRegions(nbt)) { NBTTagList usedBlockTypes = nbt.getCompoundTag("Regions").getCompoundTag(subReg).getTagList("BlockStatePalette", 10); @@ -92,7 +99,7 @@ public final class LitematicaSchematic extends StaticSchematic { } /** - * Gets both ends from schematic box for a given axis and returns the lower one. + * Gets both ends from a region box for a given axis and returns the lower one. * * @param s axis that should be read. * @return the lower coord of the requested axis. @@ -197,22 +204,19 @@ public final class LitematicaSchematic extends StaticSchematic { } /** - * @param blockList list with the different block types used in the schematic - * @param bitArray bit array that holds the placement pattern + * Writes the file data in to the IBlockstate array. + * + * @param blockList list with the different block types used in the schematic. + * @param bitArray bit array that holds the placement pattern. */ - //x,y,z are the releative positons to the minimum corner of the enclosing box - //minX,minY,minZ are correction terms if the schematic origin isn't the minimum corner - //posX,posY,posZ are the subregions offset relative to the minimum corner private void writeSubregionIntoSchematic(NBTTagCompound nbt, String subReg, IBlockState[] blockList, LitematicaBitArray bitArray) { - int posX = getMinOfSubregion(nbt, subReg, "x"); - int posY = getMinOfSubregion(nbt, subReg, "y"); - int posZ = getMinOfSubregion(nbt, subReg, "z"); + Vec3i offsetSubregion = new Vec3i(getMinOfSubregion(nbt, subReg, "x"), getMinOfSubregion(nbt, subReg, "y"), getMinOfSubregion(nbt, subReg, "z")); int index = 0; for (int y = 0; y < this.y; y++) { for (int z = 0; z < this.z; z++) { for (int x = 0; x < this.x; x++) { if (inSubregion(nbt, subReg, x, y, z)) { - this.states[x - (minX - posX)][z - (minZ - posZ)][y - (minY - posY)] = blockList[bitArray.getAt(index)]; + this.states[x - (offsetMinCorner.getX() - offsetSubregion.getX())][z - (offsetMinCorner.getZ() - offsetSubregion.getZ())][y - (offsetMinCorner.getY() - offsetSubregion.getY())] = blockList[bitArray.getAt(index)]; index++; } } @@ -220,21 +224,48 @@ public final class LitematicaSchematic extends StaticSchematic { } } - public Vec3i getMinimumCorner() { - return new Vec3i(this.minX, this.minY, this.minZ); + /** + * @return offset from the schematic origin to the minimum Corner as a Vec3i. + */ + public Vec3i getOffsetMinCorner() { + return offsetMinCorner; } + + /** + * @return x size of the schematic. + */ public int getX() { return this.x; } + + /** + * @return y size of the schematic. + */ public int getY() { return this.y; } + + /** + * @return z size of the schematic. + */ public int getZ() { return this.z; } + + /** + * @param x position relative to the minimum corner of the schematic. + * @param y position relative to the minimum corner of the schematic. + * @param z position relative to the minimum corner of the schematic. + * @param blockState new blockstate of the block at this position. + */ public void setDirect(int x,int y,int z,IBlockState blockState) { this.states[x][z][y] = blockState; } + + /** + * @param rotated if the schematic is rotated by 90°. + * @return a copy of the schematic. + */ public LitematicaSchematic getCopy(boolean rotated) { return new LitematicaSchematic(nbt, rotated); } diff --git a/src/main/java/baritone/utils/schematic/litematica/LitematicaHelper.java b/src/main/java/baritone/utils/schematic/litematica/LitematicaHelper.java index f63c8eb3..be437624 100644 --- a/src/main/java/baritone/utils/schematic/litematica/LitematicaHelper.java +++ b/src/main/java/baritone/utils/schematic/litematica/LitematicaHelper.java @@ -27,7 +27,17 @@ import net.minecraft.util.math.Vec3i; import java.io.File; +/** + * Helper class that provides access or processes data related to Litmatica schematics. + * + * @author rycbar + * @since 28.09.2022 + */ public final class LitematicaHelper { + + /** + * @return if Litmatica is installed. + */ public static boolean isLitematicaPresent() { try { Class.forName(Litematica.class.getName()); @@ -36,12 +46,26 @@ public final class LitematicaHelper { return false; } } + + /** + * @return if there are loaded schematics. + */ public static boolean hasLoadedSchematic() { return DataManager.getSchematicPlacementManager().getAllSchematicsPlacements().size()>0; } + + /** + * @param i index of the Schematic in the schematic placement list. + * @return the name of the requested schematic. + */ public static String getName(int i) { return DataManager.getSchematicPlacementManager().getAllSchematicsPlacements().get(i).getName(); } + + /** + * @param i index of the Schematic in the schematic placement list. + * @return the world coordinates of the schematic origin. This can but does not have to be the minimum corner. + */ public static Vec3i getOrigin(int i) { int x,y,z; x=DataManager.getSchematicPlacementManager().getAllSchematicsPlacements().get(i).getOrigin().getX(); @@ -49,22 +73,43 @@ public final class LitematicaHelper { z=DataManager.getSchematicPlacementManager().getAllSchematicsPlacements().get(i).getOrigin().getZ(); return new Vec3i(x,y,z); } + + /** + * @param i index of the Schematic in the schematic placement list. + * @return Filepath of the schematic file. + */ public static File getSchematicFile(int i) { return DataManager.getSchematicPlacementManager().getAllSchematicsPlacements().get(i).getSchematicFile(); } + + /** + * @param i index of the Schematic in the schematic placement list. + * @return rotation of the schematic placement. + */ public static Rotation getRotation(int i) { return DataManager.getSchematicPlacementManager().getAllSchematicsPlacements().get(i).getRotation(); } + + /** + * @param i index of the Schematic in the schematic placement list. + * @return the mirroring of the schematic placement. + */ public static Mirror getMirror(int i) { return DataManager.getSchematicPlacementManager().getAllSchematicsPlacements().get(i).getMirror(); } + + /** + * @param schematic original schematic. + * @param i index of the Schematic in the schematic placement list. + * @return the minimum corner coordinates of the schematic, after the original schematic got rotated and mirrored. + */ public static Vec3i getCorrectedOrigin(LitematicaSchematic schematic, int i) { int x = LitematicaHelper.getOrigin(i).getX(); int y = LitematicaHelper.getOrigin(i).getY(); int z = LitematicaHelper.getOrigin(i).getZ(); - int mx = schematic.getMinimumCorner().getX(); - int my = schematic.getMinimumCorner().getY(); - int mz = schematic.getMinimumCorner().getZ(); + int mx = schematic.getOffsetMinCorner().getX(); + int my = schematic.getOffsetMinCorner().getY(); + int mz = schematic.getOffsetMinCorner().getZ(); int sx = (schematic.getX() - 1) * -1; int sz = (schematic.getZ() - 1) * -1; @@ -109,6 +154,14 @@ public final class LitematicaHelper { } return correctedOrigin; } + + /** + * @param in the xyz offsets of the block relative to the schematic minimum corner. + * @param sizeX size of the schematic in the x-axis direction. + * @param sizeZ size of the schematic in the z-axis direction. + * @param mirror the mirroring of the schematic placement. + * @return the corresponding xyz coordinates after mirroring them according to the given mirroring. + */ public static Vec3i doMirroring(Vec3i in, int sizeX, int sizeZ, Mirror mirror) { int xOut = in.getX(); int zOut = in.getZ(); @@ -119,31 +172,43 @@ public final class LitematicaHelper { } return new Vec3i(xOut, in.getY(), zOut); } + + /** + * @param in the xyz offsets of the block relative to the schematic minimum corner. + * @param sizeX size of the schematic in the x-axis direction. + * @param sizeZ size of the schematic in the z-axis direction. + * @return the corresponding xyz coordinates after rotation them 90° clockwise. + */ public static Vec3i rotate(Vec3i in, int sizeX, int sizeZ) { return new Vec3i(sizeX - (sizeX - sizeZ) - in.getZ(), in.getY(), in.getX()); } + + /** + * IDFK this just grew and it somehow works. If you understand how, pls tell me. + * + * @param schemIn give in the original schematic. + * @param i index of the Schematic in the schematic placement list. + * @return get it out rotated and mirrored. + */ public static LitematicaSchematic blackMagicFuckery(LitematicaSchematic schemIn, int i) { LitematicaSchematic tempSchem = schemIn.getCopy(LitematicaHelper.getRotation(i).ordinal()%2==1); for (int yCounter=0; yCounter schematicPlacements = new ArrayList<>(); //in case of a java.lang.NoSuchMethodError try change the name of this method to getAllSchematicPlacements() - // there are inconsistencies in the litematica mod about the naming of this method + //there are inconsistencies in the litematica mod about the naming of this method public List getAllSchematicsPlacements() { return schematicPlacements; }