diff --git a/src/main/java/org/dimdev/ddutils/nbt/NBTTest.java b/src/main/java/org/dimdev/ddutils/nbt/NBTTest.java index 1f21ac14..c906f13c 100644 --- a/src/main/java/org/dimdev/ddutils/nbt/NBTTest.java +++ b/src/main/java/org/dimdev/ddutils/nbt/NBTTest.java @@ -5,7 +5,7 @@ import net.minecraft.util.math.Vec3i; import org.dimdev.annotatednbt.NBTSerializable; import org.dimdev.annotatednbt.Saved; import org.dimdev.ddutils.Location; -import org.dimdev.dimdoors.shared.pockets.Pocket; +import org.dimdev.pocketlib.Pocket; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/org/dimdev/dimdoors/DimDoors.java b/src/main/java/org/dimdev/dimdoors/DimDoors.java index 09a76f37..9fbbd0cb 100644 --- a/src/main/java/org/dimdev/dimdoors/DimDoors.java +++ b/src/main/java/org/dimdev/dimdoors/DimDoors.java @@ -27,7 +27,8 @@ public class DimDoors { public static final String MODID = "dimdoors"; public static final String MODNAME = "Dimensional Doors"; public static final String VERSION = "${version}"; - public static final String DEPENDENCIES = "required-after:forge@[14.23.0.2517,)"; //TODO make the forge version here change depending on a field in build.gradle + // TODO: make the forge version here change depending on a field in build.gradle + public static final String DEPENDENCIES = "required-after:forge@[14.23.0.2517,);before:csb_ench_table"; // before:csb_ench_table as a workaround for https://github.com/crazysnailboy/EnchantingTable/issues/7 @Mod.Instance(DimDoors.MODID) public static DimDoors instance; diff --git a/src/main/java/org/dimdev/dimdoors/shared/EventHandler.java b/src/main/java/org/dimdev/dimdoors/shared/EventHandler.java index c3df3a94..5c33eaae 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/EventHandler.java +++ b/src/main/java/org/dimdev/dimdoors/shared/EventHandler.java @@ -9,7 +9,7 @@ import net.minecraftforge.event.entity.living.LivingHurtEvent; import net.minecraftforge.fml.common.eventhandler.EventPriority; import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; import net.minecraftforge.fml.common.gameevent.PlayerEvent; -import org.dimdev.dimdoors.shared.pockets.PocketRegistry; +import org.dimdev.pocketlib.PocketRegistry; import org.dimdev.dimdoors.shared.rifts.registry.RiftRegistry; import org.dimdev.dimdoors.shared.world.ModDimensions; @@ -35,7 +35,7 @@ public final class EventHandler { if (!world.isRemote && !player.isDead && ModDimensions.isDimDoorsPocketDimension(world) - && !PocketRegistry.instance(dim).isPlayerAllowedToBeHere(player, player.getPosition())) { + && !PocketRegistry.instance(dim).isPlayerAllowedToBeAt(player, player.getPosition())) { // TODO: make the world circular } } diff --git a/src/main/java/org/dimdev/dimdoors/shared/commands/CommandPocket.java b/src/main/java/org/dimdev/dimdoors/shared/commands/CommandPocket.java index 97f6862d..23f077b4 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/commands/CommandPocket.java +++ b/src/main/java/org/dimdev/dimdoors/shared/commands/CommandPocket.java @@ -6,6 +6,7 @@ import org.dimdev.dimdoors.shared.rifts.TileEntityRift; import org.dimdev.ddutils.Location; import org.dimdev.ddutils.TeleportUtils; import org.dimdev.ddutils.WorldUtils; +import org.dimdev.dimdoors.shared.rifts.registry.RiftRegistry; import org.dimdev.dimdoors.shared.world.ModDimensions; import net.minecraft.command.CommandBase; import net.minecraft.command.CommandException; @@ -14,6 +15,7 @@ import net.minecraft.entity.player.EntityPlayerMP; import net.minecraft.server.MinecraftServer; import net.minecraft.util.math.BlockPos; import net.minecraft.util.text.TextComponentString; +import org.dimdev.pocketlib.Pocket; import javax.annotation.Nullable; import java.util.ArrayList; @@ -88,12 +90,11 @@ public class CommandPocket extends CommandBase { // Generate the schematic PocketTemplate template = SchematicHandler.INSTANCE.getTemplate(group, name); - Pocket pocket = PocketGenerator.generatePocketFromTemplate(WorldUtils.getDim(player.world), template, null); - if (setup) pocket.setup(); + Pocket pocket = PocketGenerator.generatePocketFromTemplate(WorldUtils.getDim(player.world), template, null, setup); // Teleport the player there - if (pocket.getEntrance() != null) { - TileEntityRift entrance = (TileEntityRift) player.world.getTileEntity(pocket.getEntrance().getPos()); + if (RiftRegistry.instance().getPocketEntrance(pocket) != null) { + TileEntityRift entrance = (TileEntityRift) player.world.getTileEntity(RiftRegistry.instance().getPocketEntrance(pocket).getPos()); entrance.teleportTo(player); } else { int size = (pocket.getSize() + 1) * 16; diff --git a/src/main/java/org/dimdev/dimdoors/shared/commands/CommandSaveSchem.java b/src/main/java/org/dimdev/dimdoors/shared/commands/CommandSaveSchem.java index 43ef4343..27399303 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/commands/CommandSaveSchem.java +++ b/src/main/java/org/dimdev/dimdoors/shared/commands/CommandSaveSchem.java @@ -10,8 +10,8 @@ import net.minecraft.util.math.BlockPos; import net.minecraft.util.text.TextComponentString; import org.dimdev.ddutils.schem.Schematic; import org.dimdev.dimdoors.DimDoors; -import org.dimdev.dimdoors.shared.pockets.Pocket; -import org.dimdev.dimdoors.shared.pockets.PocketRegistry; +import org.dimdev.pocketlib.Pocket; +import org.dimdev.pocketlib.PocketRegistry; import org.dimdev.dimdoors.shared.pockets.SchematicHandler; import org.dimdev.dimdoors.shared.world.pocketdimension.WorldProviderPocket; diff --git a/src/main/java/org/dimdev/dimdoors/shared/pockets/Pocket.java b/src/main/java/org/dimdev/dimdoors/shared/pockets/Pocket.java deleted file mode 100644 index de6d86b9..00000000 --- a/src/main/java/org/dimdev/dimdoors/shared/pockets/Pocket.java +++ /dev/null @@ -1,135 +0,0 @@ -package org.dimdev.dimdoors.shared.pockets; - -import lombok.Getter; -import lombok.Setter; -import net.minecraft.nbt.NBTTagCompound; -import net.minecraft.tileentity.TileEntity; -import net.minecraft.util.math.BlockPos; -import org.dimdev.annotatednbt.NBTSerializable; -import org.dimdev.annotatednbt.Saved; -import org.dimdev.ddutils.Location; -import org.dimdev.ddutils.math.MathUtils; -import org.dimdev.ddutils.nbt.INBTStorable; -import org.dimdev.ddutils.nbt.NBTUtils; -import org.dimdev.dimdoors.DimDoors; -import org.dimdev.dimdoors.shared.VirtualLocation; -import org.dimdev.dimdoors.shared.rifts.RiftDestination; -import org.dimdev.dimdoors.shared.rifts.TileEntityRift; -import org.dimdev.dimdoors.shared.rifts.destinations.PocketEntranceDestination; -import org.dimdev.dimdoors.shared.rifts.destinations.PocketExitDestination; -import org.dimdev.dimdoors.shared.rifts.registry.LinkProperties; -import org.dimdev.dimdoors.shared.tileentities.TileEntityEntranceRift; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; - -@NBTSerializable public class Pocket implements INBTStorable { // TODO: better visibilities - - @Saved @Getter protected int id; - @Saved @Getter protected int x; // Grid x TODO: rename to gridX and gridY, or just convert to non-grid dependant coordinates - @Saved @Getter protected int z; // Grid y - @Saved @Getter @Setter protected int size; // TODO: size = sizeInChunks - 1 ???!!! TODO: non chunk-based size, better bounds such as minX, minZ, maxX, maxZ, etc. - @Saved @Getter @Setter protected VirtualLocation virtualLocation; - @Saved @Getter @Setter protected Location entrance; // TODO: move this to the rift registry (pocketlib) - @Saved @Getter protected List riftLocations; // TODO: convert to a list of all tile entities (for chests, and to make it independant of pocketlib) - - @Getter int dim; // Not saved - - public Pocket() {} - - public Pocket(int id, int dim, int x, int z) { - this.id = id; - this.dim = dim; - this.x = x; - this.z = z; - riftLocations = new ArrayList<>(); - } - - // TODO: make these static? - @Override public void readFromNBT(NBTTagCompound nbt) { NBTUtils.readFromNBT(this, nbt); } - - @Override public NBTTagCompound writeToNBT(NBTTagCompound nbt) { return NBTUtils.writeToNBT(this, nbt); } - - boolean isInBounds(BlockPos pos) { - // pocket bounds - int gridSize = PocketRegistry.instance(dim).getGridSize(); - int minX = x * gridSize; - int minZ = z * gridSize; - int maxX = minX + (size + 1) * 16; - int maxZ = minX + (size + 1) * 16; - return minX <= pos.getX() && minZ <= pos.getZ() && pos.getX() < maxX && pos.getZ() < maxZ; - } - - public List getRifts() { - List rifts = new ArrayList<>(riftLocations.size()); // TODO: make immutable - for (Location riftLocation : riftLocations) { - TileEntity tileEntity = riftLocation.getWorld().getTileEntity(riftLocation.getPos()); - if (tileEntity instanceof TileEntityRift) { - rifts.add((TileEntityRift) tileEntity); - } else { - throw new RuntimeException("The rift locations array was wrong, check the schematic placing function to see why!"); - } - } - return rifts; - } - - public void setup() { // Always call after creating a pocket except when building the pocket - List rifts = getRifts(); - - HashMap entranceWeights = new HashMap<>(); - - for (TileEntityRift rift : rifts) { // Find an entrance - if (rift.getDestination() instanceof PocketEntranceDestination) { - entranceWeights.put(rift, ((PocketEntranceDestination) rift.getDestination()).getWeight()); - } - } - - if (entranceWeights.size() == 0) { - DimDoors.log.warn("Pocket had no possible entrance in schematic!"); - return; - } - TileEntityRift selectedEntrance = MathUtils.weightedRandom(entranceWeights); - - // Replace entrances with appropriate destinations - for (TileEntityRift rift : rifts) { - RiftDestination dest = rift.getDestination(); - if (dest instanceof PocketEntranceDestination) { - if (rift == selectedEntrance) { - entrance = new Location(rift.getWorld(), rift.getPos()); - PocketRegistry.instance(dim).markDirty(); - rift.setDestination(((PocketEntranceDestination) dest).getIfDestination()); - } else { - rift.setDestination(((PocketEntranceDestination) dest).getOtherwiseDestination()); - } - } - } - - // register the rifts - for (TileEntityRift rift : rifts) { - rift.register(); - } - } - - public void linkPocketTo(RiftDestination linkTo, LinkProperties linkProperties) { - List rifts = getRifts(); - - // Link pocket exits back - for (TileEntityRift rift : rifts) { - RiftDestination dest = rift.getDestination(); - if (dest instanceof PocketExitDestination) { - if (linkProperties != null) rift.setProperties(linkProperties); - rift.setDestination(linkTo); - if (rift instanceof TileEntityEntranceRift && !rift.isAlwaysDelete()) { - ((TileEntityEntranceRift) rift).setPlaceRiftOnBreak(true); // We modified the door's state - } - rift.markDirty(); - } - } - } - - public BlockPos getOrigin() { - int gridSize = PocketRegistry.instance(dim).getGridSize(); - return new BlockPos(x * gridSize * 16, 0, z * gridSize * 16); // TODO: configurable yBase? - } -} diff --git a/src/main/java/org/dimdev/dimdoors/shared/pockets/PocketGenerator.java b/src/main/java/org/dimdev/dimdoors/shared/pockets/PocketGenerator.java index 4b56d31b..d51ecf60 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/pockets/PocketGenerator.java +++ b/src/main/java/org/dimdev/dimdoors/shared/pockets/PocketGenerator.java @@ -1,33 +1,40 @@ package org.dimdev.dimdoors.shared.pockets; import org.dimdev.dimdoors.DimDoors; -import org.dimdev.dimdoors.shared.VirtualLocation; import org.dimdev.dimdoors.shared.*; +import org.dimdev.dimdoors.shared.rifts.RiftDestination; +import org.dimdev.dimdoors.shared.rifts.registry.LinkProperties; import org.dimdev.dimdoors.shared.world.ModDimensions; +import org.dimdev.pocketlib.Pocket; +import org.dimdev.pocketlib.PocketRegistry; +import org.dimdev.pocketlib.VirtualLocation; import java.util.Random; public final class PocketGenerator { - public static Pocket generatePocketFromTemplate(int dim, PocketTemplate pocketTemplate, VirtualLocation virtualLocation) { + public static Pocket generatePocketFromTemplate(int dim, PocketTemplate pocketTemplate, VirtualLocation virtualLocation, boolean setup) { DimDoors.log.info("Generating pocket from template " + pocketTemplate.getId() + " at virtual location " + virtualLocation); PocketRegistry registry = PocketRegistry.instance(dim); Pocket pocket = registry.newPocket(); pocketTemplate.place(pocket); pocket.setVirtualLocation(virtualLocation); + if (setup) pocketTemplate.setup(pocket, null, null); return pocket; } public static Pocket generatePrivatePocket(VirtualLocation virtualLocation) { PocketTemplate pocketTemplate = SchematicHandler.INSTANCE.getPersonalPocketTemplate(); - return generatePocketFromTemplate(ModDimensions.getPrivateDim(), pocketTemplate, virtualLocation); + return generatePocketFromTemplate(ModDimensions.getPrivateDim(), pocketTemplate, virtualLocation, true); } // TODO: size of public pocket should increase with depth - public static Pocket generatePublicPocket(VirtualLocation virtualLocation) { + public static Pocket generatePublicPocket(VirtualLocation virtualLocation, RiftDestination linkTo, LinkProperties linkProperties) { PocketTemplate pocketTemplate = SchematicHandler.INSTANCE.getPublicPocketTemplate(); - return generatePocketFromTemplate(ModDimensions.getPublicDim(), pocketTemplate, virtualLocation); + Pocket pocket = generatePocketFromTemplate(ModDimensions.getPublicDim(), pocketTemplate, virtualLocation, false); + pocketTemplate.setup(pocket, linkTo, linkProperties); + return pocket; } /** @@ -36,13 +43,15 @@ public final class PocketGenerator { * @param virtualLocation The virtual location of the pocket * @return The newly-generated dungeon pocket */ - public static Pocket generateDungeonPocket(VirtualLocation virtualLocation) { + public static Pocket generateDungeonPocket(VirtualLocation virtualLocation, RiftDestination linkTo, LinkProperties linkProperties) { int depth = virtualLocation.getDepth(); float netherProbability = virtualLocation.getDim() == -1 ? 1 : (float) depth / 200; // TODO: improve nether probability Random random = new Random(); String group = random.nextFloat() < netherProbability ? "nether" : "ruins"; PocketTemplate pocketTemplate = SchematicHandler.INSTANCE.getRandomTemplate(group, depth, Config.getMaxPocketSize(), false); - return generatePocketFromTemplate(ModDimensions.getDungeonDim(), pocketTemplate, virtualLocation); + Pocket pocket = generatePocketFromTemplate(ModDimensions.getDungeonDim(), pocketTemplate, virtualLocation, false); + pocketTemplate.setup(pocket, linkTo, linkProperties); + return pocket; } } diff --git a/src/main/java/org/dimdev/dimdoors/shared/pockets/PocketTemplate.java b/src/main/java/org/dimdev/dimdoors/shared/pockets/PocketTemplate.java index 2894fe46..3175959a 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/pockets/PocketTemplate.java +++ b/src/main/java/org/dimdev/dimdoors/shared/pockets/PocketTemplate.java @@ -1,13 +1,5 @@ package org.dimdev.dimdoors.shared.pockets; -import org.dimdev.ddutils.WorldUtils; -import org.dimdev.dimdoors.shared.rifts.TileEntityRift; -import org.dimdev.ddutils.Location; -import org.dimdev.ddutils.schem.Schematic; -import org.dimdev.dimdoors.DimDoors; - -import java.util.ArrayList; - import lombok.AllArgsConstructor; import lombok.Getter; import lombok.RequiredArgsConstructor; @@ -25,6 +17,24 @@ import net.minecraft.util.math.BlockPos; import net.minecraft.world.WorldServer; import net.minecraft.world.storage.loot.LootContext; import net.minecraft.world.storage.loot.LootTable; +import org.dimdev.ddutils.Location; +import org.dimdev.ddutils.WorldUtils; +import org.dimdev.ddutils.math.MathUtils; +import org.dimdev.ddutils.schem.Schematic; +import org.dimdev.dimdoors.DimDoors; +import org.dimdev.dimdoors.shared.rifts.RiftDestination; +import org.dimdev.dimdoors.shared.rifts.TileEntityRift; +import org.dimdev.dimdoors.shared.rifts.destinations.PocketEntranceDestination; +import org.dimdev.dimdoors.shared.rifts.destinations.PocketExitDestination; +import org.dimdev.dimdoors.shared.rifts.registry.LinkProperties; +import org.dimdev.dimdoors.shared.rifts.registry.RiftRegistry; +import org.dimdev.dimdoors.shared.tileentities.TileEntityEntranceRift; +import org.dimdev.pocketlib.Pocket; +import org.dimdev.pocketlib.PocketRegistry; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; /** * @author Robijnvogel @@ -38,7 +48,7 @@ public class PocketTemplate { @Getter private final String name; @Getter private final String author; @Getter @Setter private Schematic schematic; - @Getter private final int size; // size in chunks (n*n chunks) + @Getter private final int size; // number of chunks (16 blocks) on each side - 1 @Getter private final int baseWeight; public float getWeight(int depth) { @@ -52,27 +62,38 @@ public class PocketTemplate { public void place(Pocket pocket) { pocket.setSize(size); - int gridSize = PocketRegistry.instance(pocket.dim).getGridSize(); - int dim = pocket.dim; + int gridSize = PocketRegistry.instance(pocket.getDim()).getGridSize(); + int dim = pocket.getDim(); + WorldServer world = WorldUtils.getWorld(dim); int xBase = pocket.getX() * gridSize * 16; int yBase = 0; int zBase = pocket.getZ() * gridSize * 16; + + // Place the schematic DimDoors.log.info("Placing new pocket using schematic " + schematic.name + " at x = " + xBase + ", z = " + zBase); - - WorldServer world = WorldUtils.getWorld(dim); Schematic.place(schematic, world, xBase, yBase, zBase); + } + + public void setup(Pocket pocket, RiftDestination linkTo, LinkProperties linkProperties) { + int gridSize = PocketRegistry.instance(pocket.getDim()).getGridSize(); + int dim = pocket.getDim(); + WorldServer world = WorldUtils.getWorld(dim); + int xBase = pocket.getX() * gridSize * 16; + int yBase = 0; + int zBase = pocket.getZ() * gridSize * 16; + + List rifts = new ArrayList<>(); - // Set pocket riftLocations - pocket.riftLocations = new ArrayList<>(); for (NBTTagCompound tileEntityNBT : schematic.tileEntities) { BlockPos pos = new BlockPos( xBase + tileEntityNBT.getInteger("x"), yBase + tileEntityNBT.getInteger("y"), zBase + tileEntityNBT.getInteger("z")); TileEntity tile = world.getTileEntity(pos); + if (tile instanceof TileEntityRift) { DimDoors.log.info("Rift found in schematic at " + pos); - pocket.riftLocations.add(new Location(world, pos)); + rifts.add((TileEntityRift) tile); } else if (tile instanceof TileEntityChest) { DimDoors.log.info("Now populating chest."); TileEntityChest chest = (TileEntityChest) tile; @@ -101,5 +122,56 @@ public class PocketTemplate { DimDoors.log.info("Dispenser should be populated now. Dispenser is: " + (dispenser.isEmpty() ? "emtpy." : "filled.")); } } + + // Find an entrance + + HashMap entranceWeights = new HashMap<>(); + + for (TileEntityRift rift : rifts) { // Find an entrance + if (rift.getDestination() instanceof PocketEntranceDestination) { + entranceWeights.put(rift, ((PocketEntranceDestination) rift.getDestination()).getWeight()); + } + } + + if (entranceWeights.size() == 0) { + DimDoors.log.warn("Pocket had no possible entrance in schematic!"); + return; + } + TileEntityRift selectedEntrance = MathUtils.weightedRandom(entranceWeights); + + // Replace entrances with appropriate destinations + for (TileEntityRift rift : rifts) { + RiftDestination dest = rift.getDestination(); + if (dest instanceof PocketEntranceDestination) { + if (rift == selectedEntrance) { + PocketRegistry.instance(dim).markDirty(); + rift.setDestination(((PocketEntranceDestination) dest).getIfDestination()); + rift.register(); + RiftRegistry.instance().addPocketEntrance(pocket, new Location(rift.getWorld(), rift.getPos())); + } else { + rift.setDestination(((PocketEntranceDestination) dest).getOtherwiseDestination()); + } + } + } + + // Link the pocket back + + // Link pocket exits back + for (TileEntityRift rift : rifts) { + RiftDestination dest = rift.getDestination(); + if (dest instanceof PocketExitDestination) { + if (linkProperties != null) rift.setProperties(linkProperties); + rift.setDestination(rift.getProperties() == null || !rift.getProperties().oneWay ? linkTo : null); + if (rift instanceof TileEntityEntranceRift && !rift.isAlwaysDelete()) { + ((TileEntityEntranceRift) rift).setPlaceRiftOnBreak(true); // We modified the door's state + } + } + } + + // register the rifts + for (TileEntityRift rift : rifts) { + rift.register(); + rift.markDirty(); + } } } diff --git a/src/main/java/org/dimdev/dimdoors/shared/pockets/SchematicHandler.java b/src/main/java/org/dimdev/dimdoors/shared/pockets/SchematicHandler.java index 5ea09ac5..d86e58d2 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/pockets/SchematicHandler.java +++ b/src/main/java/org/dimdev/dimdoors/shared/pockets/SchematicHandler.java @@ -28,11 +28,12 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.CompressedStreamTools; import org.apache.commons.io.IOUtils; import org.dimdev.dimdoors.shared.world.ModDimensions; +import org.dimdev.pocketlib.PocketRegistry; /** * @author Robijnvogel */ -public class SchematicHandler { +public class SchematicHandler { // TODO: parts of this should be moved to the org.dimdev.ddutils.schem package private static final String SAVED_POCKETS_GROUP_NAME = "saved_pockets"; public static final SchematicHandler INSTANCE = new SchematicHandler(); diff --git a/src/main/java/org/dimdev/dimdoors/shared/rifts/TileEntityRift.java b/src/main/java/org/dimdev/dimdoors/shared/rifts/TileEntityRift.java index bd477036..5f5be3f6 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/rifts/TileEntityRift.java +++ b/src/main/java/org/dimdev/dimdoors/shared/rifts/TileEntityRift.java @@ -18,7 +18,7 @@ import org.dimdev.annotatednbt.Saved; import org.dimdev.ddutils.*; import org.dimdev.ddutils.nbt.NBTUtils; import org.dimdev.dimdoors.DimDoors; -import org.dimdev.dimdoors.shared.VirtualLocation; +import org.dimdev.pocketlib.VirtualLocation; import org.dimdev.dimdoors.shared.blocks.BlockDimensionalDoor; import org.dimdev.dimdoors.shared.blocks.BlockFloatingRift; import org.dimdev.dimdoors.shared.rifts.registry.LinkProperties; diff --git a/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/AvailableLinkDestination.java b/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/AvailableLinkDestination.java index 1e59b81a..471d3e24 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/AvailableLinkDestination.java +++ b/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/AvailableLinkDestination.java @@ -16,9 +16,9 @@ import org.dimdev.ddutils.RotatedLocation; import org.dimdev.ddutils.WorldUtils; import org.dimdev.ddutils.math.MathUtils; import org.dimdev.ddutils.nbt.NBTUtils; -import org.dimdev.dimdoors.shared.VirtualLocation; +import org.dimdev.pocketlib.VirtualLocation; import org.dimdev.dimdoors.shared.blocks.ModBlocks; -import org.dimdev.dimdoors.shared.pockets.Pocket; +import org.dimdev.pocketlib.Pocket; import org.dimdev.dimdoors.shared.pockets.PocketGenerator; import org.dimdev.dimdoors.shared.rifts.*; import org.dimdev.dimdoors.shared.rifts.registry.LinkProperties; @@ -146,18 +146,13 @@ import java.util.Set; riftEntity.teleportTo(entity, thisRift.getYaw(), thisRift.getPitch()); } else { // Make a new dungeon pocket - Pocket pocket = PocketGenerator.generateDungeonPocket(virtualLocation); // TODO make the generated dungeon of the same type, but in the overworld - pocket.setup(); - - // Link the pocket back TileEntityRift thisRift = (TileEntityRift) location.getLocation().getTileEntity(); - TileEntityRift riftEntity = (TileEntityRift) pocket.getEntrance().getTileEntity(); LinkProperties newLink = thisRift.getProperties() != null ? thisRift.getProperties().toBuilder().linksRemaining(0).build() : null; - pocket.linkPocketTo(new GlobalDestination(!noLinkBack && !riftEntity.getProperties().oneWay ? location.getLocation() : null), newLink); // TODO: linkId + Pocket pocket = PocketGenerator.generateDungeonPocket(virtualLocation, new GlobalDestination(!noLinkBack ? location.getLocation() : null), newLink); // TODO make the generated dungeon of the same type, but in the overworld // Link the rift if necessary and teleport the entity - if (!noLink) linkRifts(location.getLocation(), pocket.getEntrance()); - ((TileEntityRift) pocket.getEntrance().getTileEntity()).teleportTo(entity, location.getYaw(), location.getPitch()); + if (!noLink) linkRifts(location.getLocation(), RiftRegistry.instance().getPocketEntrance(pocket)); + ((TileEntityRift) RiftRegistry.instance().getPocketEntrance(pocket).getTileEntity()).teleportTo(entity, location.getYaw(), location.getPitch()); } } else { // An existing rift was selected diff --git a/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PocketEntranceDestination.java b/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PocketEntranceDestination.java index 4bb1a4ca..b3054fc0 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PocketEntranceDestination.java +++ b/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PocketEntranceDestination.java @@ -37,7 +37,7 @@ import org.dimdev.dimdoors.shared.rifts.RiftDestination; @Override public boolean teleport(RotatedLocation loc, Entity entity) { - if (entity instanceof EntityPlayer) DimDoors.chat(entity, "The entrances of this dungeon has not been linked. Either this is a bug or you are in dungeon-building mode."); + if (entity instanceof EntityPlayer) DimDoors.chat(entity, "The entrance of this dungeon has not been converted. If this is a normally generated pocket, please report this bug."); return false; } } diff --git a/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PocketExitDestination.java b/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PocketExitDestination.java index ed78973e..f095b76b 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PocketExitDestination.java +++ b/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PocketExitDestination.java @@ -28,7 +28,7 @@ public class PocketExitDestination extends RiftDestination { // TODO: not exactl @Override public boolean teleport(RotatedLocation loc, Entity entity) { - if (entity instanceof EntityPlayer) DimDoors.chat(entity, "The exit of this dungeon has not been linked. Either this is a bug or you are in dungeon-building mode."); + if (entity instanceof EntityPlayer) DimDoors.chat(entity, "The exit of this dungeon has not been linked. If this is a normally generated pocket, please report this bug."); return false; } } diff --git a/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PrivateDestination.java b/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PrivateDestination.java index 8b9972ef..d8eec850 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PrivateDestination.java +++ b/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PrivateDestination.java @@ -3,14 +3,13 @@ package org.dimdev.dimdoors.shared.rifts.destinations; import org.dimdev.ddutils.RGBA; import org.dimdev.ddutils.RotatedLocation; import org.dimdev.dimdoors.DimDoors; -import org.dimdev.dimdoors.shared.VirtualLocation; -import org.dimdev.dimdoors.shared.pockets.Pocket; +import org.dimdev.pocketlib.PrivatePocketData; +import org.dimdev.pocketlib.VirtualLocation; +import org.dimdev.pocketlib.Pocket; import org.dimdev.dimdoors.shared.pockets.PocketGenerator; -import org.dimdev.dimdoors.shared.pockets.PocketRegistry; import org.dimdev.dimdoors.shared.rifts.RiftDestination; import org.dimdev.dimdoors.shared.rifts.registry.RiftRegistry; import org.dimdev.dimdoors.shared.rifts.TileEntityRift; -import org.dimdev.dimdoors.shared.world.ModDimensions; import org.dimdev.ddutils.EntityUtils; import org.dimdev.ddutils.Location; import lombok.AllArgsConstructor; @@ -34,25 +33,22 @@ public class PrivateDestination extends RiftDestination { UUID uuid = EntityUtils.getEntityOwnerUUID(entity); VirtualLocation virtualLocation = VirtualLocation.fromLocation(loc.getLocation()); if (uuid != null) { - PocketRegistry privatePocketRegistry = PocketRegistry.instance(ModDimensions.getPrivateDim()); - Pocket pocket = privatePocketRegistry.getPocket(privatePocketRegistry.getPrivatePocketID(uuid)); + Pocket pocket = PrivatePocketData.instance().getPrivatePocket(uuid); if (pocket == null) { // generate the private pocket and get its entrances // set to where the pocket was first created pocket = PocketGenerator.generatePrivatePocket(virtualLocation != null ? virtualLocation.toBuilder().depth(-1).build() : null); - pocket.setup(); - privatePocketRegistry.setPrivatePocketID(uuid, pocket.getId()); - ((TileEntityRift) pocket.getEntrance().getTileEntity()).teleportTo(entity, loc.getYaw(), loc.getPitch()); + PrivatePocketData.instance().setPrivatePocketID(uuid, pocket); + ((TileEntityRift) RiftRegistry.instance().getPocketEntrance(pocket).getTileEntity()).teleportTo(entity, loc.getYaw(), loc.getPitch()); RiftRegistry.instance().setLastPrivatePocketExit(uuid, loc.getLocation()); return true; } else { Location destLoc = RiftRegistry.instance().getPrivatePocketEntrance(uuid); // get the last used entrances - if (destLoc == null) destLoc = pocket.getEntrance(); // if there's none, then set the target to the main entrances + if (destLoc == null) destLoc = RiftRegistry.instance().getPocketEntrance(pocket); // if there's none, then set the target to the main entrances if (destLoc == null) { // if the pocket entrances is gone, then create a new private pocket DimDoors.log.info("All entrances are gone, creating a new private pocket!"); pocket = PocketGenerator.generatePrivatePocket(virtualLocation != null ? virtualLocation.toBuilder().depth(-1).build() : null); - pocket.setup(); - privatePocketRegistry.setPrivatePocketID(uuid, pocket.getId()); - destLoc = pocket.getEntrance(); + PrivatePocketData.instance().setPrivatePocketID(uuid, pocket); + destLoc = RiftRegistry.instance().getPocketEntrance(pocket); } ((TileEntityRift) destLoc.getTileEntity()).teleportTo(entity, loc.getYaw(), loc.getPitch()); RiftRegistry.instance().setLastPrivatePocketExit(uuid, loc.getLocation()); diff --git a/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PrivatePocketExitDestination.java b/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PrivatePocketExitDestination.java index d6502289..c301cbb1 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PrivatePocketExitDestination.java +++ b/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PrivatePocketExitDestination.java @@ -8,12 +8,12 @@ import net.minecraft.entity.Entity; import net.minecraft.nbt.NBTTagCompound; import org.dimdev.ddutils.*; import org.dimdev.dimdoors.DimDoors; -import org.dimdev.dimdoors.shared.pockets.Pocket; -import org.dimdev.dimdoors.shared.pockets.PocketRegistry; +import org.dimdev.pocketlib.PrivatePocketData; +import org.dimdev.pocketlib.Pocket; +import org.dimdev.pocketlib.PocketRegistry; import org.dimdev.dimdoors.shared.rifts.RiftDestination; import org.dimdev.dimdoors.shared.rifts.TileEntityRift; import org.dimdev.dimdoors.shared.rifts.registry.RiftRegistry; -import org.dimdev.dimdoors.shared.world.ModDimensions; import org.dimdev.dimdoors.shared.world.limbo.WorldProviderLimbo; import org.dimdev.dimdoors.shared.world.pocketdimension.WorldProviderPersonalPocket; @@ -39,9 +39,9 @@ public class PrivatePocketExitDestination extends RiftDestination { Location destLoc; UUID uuid = EntityUtils.getEntityOwnerUUID(entity); if (uuid != null) { - PocketRegistry privatePocketRegistry = PocketRegistry.instance(ModDimensions.getPrivateDim()); destLoc = RiftRegistry.instance().getPrivatePocketExit(uuid); - if (loc.getLocation().getWorld().provider instanceof WorldProviderPersonalPocket && privatePocketRegistry.getPrivatePocketID(uuid) == privatePocketRegistry.posToID(loc.getLocation().getPos())) { + Pocket pocket = PrivatePocketData.instance().getPrivatePocket(uuid); + if (loc.getLocation().getWorld().provider instanceof WorldProviderPersonalPocket && pocket != null && PocketRegistry.instance(pocket.getDim()).getPocketAt(loc.getLocation().getPos()).equals(pocket)) { RiftRegistry.instance().setLastPrivatePocketEntrance(uuid, loc.getLocation()); // Remember which exit was used for next time the pocket is entered } if (destLoc == null || !(destLoc.getTileEntity() instanceof TileEntityRift)) { diff --git a/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PublicPocketDestination.java b/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PublicPocketDestination.java index 10acf1ef..2118253b 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PublicPocketDestination.java +++ b/src/main/java/org/dimdev/dimdoors/shared/rifts/destinations/PublicPocketDestination.java @@ -5,8 +5,9 @@ import net.minecraft.entity.Entity; import net.minecraft.nbt.NBTTagCompound; import org.dimdev.ddutils.Location; import org.dimdev.ddutils.RotatedLocation; -import org.dimdev.dimdoors.shared.VirtualLocation; -import org.dimdev.dimdoors.shared.pockets.Pocket; +import org.dimdev.dimdoors.shared.rifts.registry.RiftRegistry; +import org.dimdev.pocketlib.VirtualLocation; +import org.dimdev.pocketlib.Pocket; import org.dimdev.dimdoors.shared.pockets.PocketGenerator; @Getter @AllArgsConstructor @Builder(toBuilder = true) @ToString @@ -24,10 +25,8 @@ public class PublicPocketDestination extends RestoringDestination { int depth = Math.max(riftVirtualLocation.getDepth(), 1); newVirtualLocation = riftVirtualLocation.toBuilder().depth(depth).build(); } - Pocket pocket = PocketGenerator.generatePublicPocket(newVirtualLocation); - pocket.setup(); - pocket.linkPocketTo(new GlobalDestination(loc.getLocation()), null); + Pocket pocket = PocketGenerator.generatePublicPocket(newVirtualLocation, new GlobalDestination(loc.getLocation()), null); - return pocket.getEntrance(); + return RiftRegistry.instance().getPocketEntrance(pocket); } } diff --git a/src/main/java/org/dimdev/dimdoors/shared/rifts/registry/RiftPlaceholder.java b/src/main/java/org/dimdev/dimdoors/shared/rifts/registry/RiftPlaceholder.java index a96aab92..e7510491 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/rifts/registry/RiftPlaceholder.java +++ b/src/main/java/org/dimdev/dimdoors/shared/rifts/registry/RiftPlaceholder.java @@ -3,9 +3,7 @@ package org.dimdev.dimdoors.shared.rifts.registry; import lombok.ToString; import net.minecraft.nbt.NBTTagCompound; import org.dimdev.annotatednbt.NBTSerializable; -import org.dimdev.ddutils.Location; import org.dimdev.dimdoors.DimDoors; -import org.dimdev.dimdoors.shared.rifts.TileEntityRift; @ToString @NBTSerializable public class RiftPlaceholder extends Rift { // TODO: don't extend rift diff --git a/src/main/java/org/dimdev/dimdoors/shared/rifts/registry/RiftRegistry.java b/src/main/java/org/dimdev/dimdoors/shared/rifts/registry/RiftRegistry.java index 20508948..e1c558fc 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/rifts/registry/RiftRegistry.java +++ b/src/main/java/org/dimdev/dimdoors/shared/rifts/registry/RiftRegistry.java @@ -10,9 +10,9 @@ import org.dimdev.ddutils.Location; import org.dimdev.ddutils.WorldUtils; import org.dimdev.dimdoors.DimDoors; import org.dimdev.ddutils.GraphUtils; -import org.dimdev.dimdoors.shared.pockets.Pocket; -import org.dimdev.dimdoors.shared.pockets.PocketRegistry; -import org.dimdev.dimdoors.shared.world.ModDimensions; +import org.dimdev.pocketlib.PrivatePocketData; +import org.dimdev.pocketlib.Pocket; +import org.dimdev.pocketlib.PocketRegistry; import org.jgrapht.graph.DefaultDirectedGraph; import org.jgrapht.graph.DefaultEdge; @@ -374,6 +374,10 @@ public class RiftRegistry extends WorldSavedData { } } + public Location getPocketEntrance(Pocket pocket) { + return getPocketEntrances(pocket).stream().findFirst().orElse(null); + } + public void addPocketEntrance(Pocket pocket, Location location) { DimDoors.log.info("Adding pocket entrance for pocket " + pocket.getId() + " in dimension " + pocket.getDim() + " at " + location); PocketEntrancePointer pointer = pocketEntranceMap.get(pocket); @@ -394,10 +398,8 @@ public class RiftRegistry extends WorldSavedData { Rift entrance = (Rift) GraphUtils.followPointer(graph, entrancePointer); if (entrance != null) return entrance.location; - // If there was no last used private entrance, get one of the player's private pocket entrances - PocketRegistry privatePocketRegistry = PocketRegistry.instance(ModDimensions.getPrivateDim()); - Pocket pocket = privatePocketRegistry.getPocket(privatePocketRegistry.getPrivatePocketID(playerUUID)); - return getPocketEntrances(pocket).stream().findFirst().orElse(null); + // If there was no last used private entrance, get the first player's private pocket entrance + return getPocketEntrance(PrivatePocketData.instance().getPrivatePocket(playerUUID)); } private void setPlayerRiftPointer(UUID playerUUID, Location rift, Map map) { diff --git a/src/main/java/org/dimdev/pocketlib/Pocket.java b/src/main/java/org/dimdev/pocketlib/Pocket.java new file mode 100644 index 00000000..37a0bb73 --- /dev/null +++ b/src/main/java/org/dimdev/pocketlib/Pocket.java @@ -0,0 +1,50 @@ +package org.dimdev.pocketlib; + +import lombok.Getter; +import lombok.Setter; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.math.BlockPos; +import org.dimdev.annotatednbt.NBTSerializable; +import org.dimdev.annotatednbt.Saved; +import org.dimdev.ddutils.nbt.INBTStorable; +import org.dimdev.ddutils.nbt.NBTUtils; + +@NBTSerializable public class Pocket implements INBTStorable { + + @Saved @Getter protected int id; + @Saved @Getter protected int x; // Grid x TODO: rename to gridX and gridY, or just convert to non-grid dependant coordinates + @Saved @Getter protected int z; // Grid y + @Saved @Getter @Setter protected int size; // TODO: size = sizeInChunks - 1 ???!!! TODO: non chunk-based size, better bounds such as minX, minZ, maxX, maxZ, etc. + @Saved @Getter @Setter protected VirtualLocation virtualLocation; + + @Getter int dim; // Not saved + + public Pocket() {} + + public Pocket(int id, int dim, int x, int z) { + this.id = id; + this.dim = dim; + this.x = x; + this.z = z; + } + + @Override public void readFromNBT(NBTTagCompound nbt) { NBTUtils.readFromNBT(this, nbt); } + @Override public NBTTagCompound writeToNBT(NBTTagCompound nbt) { return NBTUtils.writeToNBT(this, nbt); } + + boolean isInBounds(BlockPos pos) { + // pocket bounds + int gridSize = PocketRegistry.instance(dim).getGridSize(); + int minX = x * gridSize; + int minZ = z * gridSize; + int maxX = minX + (size + 1) * 16; + int maxZ = minX + (size + 1) * 16; + return minX <= pos.getX() && minZ <= pos.getZ() && pos.getX() < maxX && pos.getZ() < maxZ; + } + + public BlockPos getOrigin() { + int gridSize = PocketRegistry.instance(dim).getGridSize(); + return new BlockPos(x * gridSize * 16, 0, z * gridSize * 16); + } + + // TODO: more pocket methods +} diff --git a/src/main/java/org/dimdev/dimdoors/shared/pockets/PocketRegistry.java b/src/main/java/org/dimdev/pocketlib/PocketRegistry.java similarity index 60% rename from src/main/java/org/dimdev/dimdoors/shared/pockets/PocketRegistry.java rename to src/main/java/org/dimdev/pocketlib/PocketRegistry.java index a7e8a634..272b1ad0 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/pockets/PocketRegistry.java +++ b/src/main/java/org/dimdev/pocketlib/PocketRegistry.java @@ -1,19 +1,15 @@ -package org.dimdev.dimdoors.shared.pockets; +package org.dimdev.pocketlib; -import com.google.common.collect.BiMap; -import com.google.common.collect.HashBiMap; import net.minecraft.world.World; import org.dimdev.annotatednbt.Saved; import org.dimdev.annotatednbt.NBTSerializable; import org.dimdev.dimdoors.shared.Config; import org.dimdev.ddutils.math.GridUtils; -import org.dimdev.dimdoors.DimDoors; import org.dimdev.ddutils.nbt.NBTUtils; import org.dimdev.ddutils.WorldUtils; import java.util.HashMap; import java.util.Map; -import java.util.UUID; import lombok.Getter; import net.minecraft.entity.player.EntityPlayerMP; @@ -23,18 +19,14 @@ import net.minecraft.world.storage.MapStorage; import net.minecraft.world.storage.WorldSavedData; import org.dimdev.dimdoors.shared.world.pocketdimension.WorldProviderPocket; -@NBTSerializable public class -PocketRegistry extends WorldSavedData { // TODO: unregister pocket entrances, private pocket entrances/exits +@NBTSerializable public class PocketRegistry extends WorldSavedData { - private static final String DATA_NAME = DimDoors.MODID + "_pockets"; - @Getter private static final int DATA_VERSION = 0; // IMPORTANT: Update this and upgradeRegistry when making changes. + private static final String DATA_NAME = "pocketlib_pockets"; @Saved @Getter /*package-private*/ int gridSize; // Determines how much pockets in their dimension are spaced - @Saved @Getter /*package-private*/ int maxPocketSize; @Saved @Getter /*package-private*/ int privatePocketSize; @Saved @Getter /*package-private*/ int publicPocketSize; - @Saved /*package-private*/ BiMap privatePocketMap; // Player UUID -> Pocket ID, in pocket dim only TODO: move this out of pocketlib - @Saved @Getter /*package-private*/ Map pockets; // TODO: remove getter? + @Saved @Getter /*package-private*/ Map pockets; @Saved @Getter /*package-private*/ int nextID; @Getter private int dim; @@ -73,51 +65,15 @@ PocketRegistry extends WorldSavedData { // TODO: unregister pocket entrances, pr public void initNewRegistry() { gridSize = Config.getPocketGridSize(); - maxPocketSize = Config.getMaxPocketSize(); privatePocketSize = Config.getPrivatePocketSize(); publicPocketSize = Config.getPublicPocketSize(); nextID = 0; pockets = new HashMap<>(); - privatePocketMap = HashBiMap.create(); } - @Override - public void readFromNBT(NBTTagCompound nbt) { - Integer version = nbt.getInteger("version"); - if (version == null || version != DATA_VERSION) { - if (upgradeRegistry(nbt, version == null ? -1 : version)) { - markDirty(); - } else { - DimDoors.log.fatal("Failed to upgrade the pocket registry, you'll have to recreate your world!"); - throw new RuntimeException("Couldn't upgrade registry"); // TODO: better exceptions - } - } - NBTUtils.readFromNBT(this, nbt); - } - - @SuppressWarnings("unused") - private static boolean upgradeRegistry(NBTTagCompound nbt, int oldVersion) { - if (oldVersion > DATA_VERSION) throw new RuntimeException("Upgrade the mod!"); // TODO: better exceptions - switch (oldVersion) { - case -1: // No version tag - return false; - case 0: - // Upgrade to 1 or return false - case 1: - // Upgrade to 2 or return false - case 2: - // Upgrade to 3 or return false - // ... - } - return true; - } - - @Override - public NBTTagCompound writeToNBT(NBTTagCompound nbt) { - nbt.setInteger("version", DATA_VERSION); - return NBTUtils.writeToNBT(this, nbt); - } + @Override public void readFromNBT(NBTTagCompound nbt) { NBTUtils.readFromNBT(this, nbt); } + @Override public NBTTagCompound writeToNBT(NBTTagCompound nbt) { return NBTUtils.writeToNBT(this, nbt); } /** * Create a new blank pocket. @@ -126,7 +82,7 @@ PocketRegistry extends WorldSavedData { // TODO: unregister pocket entrances, pr */ public Pocket newPocket() { Pocket pocket = null; - while(pocket == null) pocket = newPocket(nextID++); // TODO: config option to reuse IDs (start at 0 rather than nextFreePocket) + while(pocket == null) pocket = newPocket(nextID++); return pocket; } @@ -150,8 +106,6 @@ PocketRegistry extends WorldSavedData { // TODO: unregister pocket entrances, pr markDirty(); } - // TODO: Lookup functions such as getPocketByType/Depth/etc. - /** * Gets the pocket with a certain ID, or null if there is no pocket with that ID. * @@ -161,22 +115,6 @@ PocketRegistry extends WorldSavedData { // TODO: unregister pocket entrances, pr return pockets.get(id); } - // TODO: these should be per-map rather than per-world - public int getPrivatePocketID(UUID playerUUID) { - Integer id = privatePocketMap.get(playerUUID.toString()); - if (id == null) return -1; - return id; - } - - public UUID getPrivatePocketOwner(int id) { - return UUID.fromString(privatePocketMap.inverse().get(id)); - } - - public void setPrivatePocketID(UUID playerUUID, int id) { - privatePocketMap.put(playerUUID.toString(), id); - markDirty(); - } - public GridUtils.GridPos idToGridPos(int id) { return GridUtils.numToPos(id); } @@ -211,7 +149,7 @@ PocketRegistry extends WorldSavedData { // TODO: unregister pocket entrances, pr return getPocket(posToID(pos)); } - public boolean isPlayerAllowedToBeHere(EntityPlayerMP player, BlockPos pos) { + public boolean isPlayerAllowedToBeAt(EntityPlayerMP player, BlockPos pos) { Pocket pocket = getPocketAt(pos); return pocket != null && pocket.isInBounds(pos); } diff --git a/src/main/java/org/dimdev/pocketlib/PrivatePocketData.java b/src/main/java/org/dimdev/pocketlib/PrivatePocketData.java new file mode 100644 index 00000000..85cff853 --- /dev/null +++ b/src/main/java/org/dimdev/pocketlib/PrivatePocketData.java @@ -0,0 +1,72 @@ +package org.dimdev.pocketlib; + +import com.google.common.collect.BiMap; +import com.google.common.collect.HashBiMap; +import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; +import lombok.ToString; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.world.storage.MapStorage; +import net.minecraft.world.storage.WorldSavedData; +import org.dimdev.annotatednbt.NBTSerializable; +import org.dimdev.annotatednbt.Saved; +import org.dimdev.ddutils.WorldUtils; +import org.dimdev.ddutils.nbt.INBTStorable; +import org.dimdev.ddutils.nbt.NBTUtils; +import org.dimdev.dimdoors.DimDoors; + +import java.util.UUID; + +@NBTSerializable public class PrivatePocketData extends WorldSavedData { + + @AllArgsConstructor @NoArgsConstructor @EqualsAndHashCode @ToString + @NBTSerializable protected static class PocketInfo implements INBTStorable { + @Saved protected int dim; + @Saved protected int id; + + @Override public void readFromNBT(NBTTagCompound nbt) { NBTUtils.readFromNBT(this, nbt); } + @Override public NBTTagCompound writeToNBT(NBTTagCompound nbt) { return NBTUtils.writeToNBT(this, nbt); } + } + + private static final String DATA_NAME = DimDoors.MODID + "_private_pockets"; + @Saved protected BiMap privatePocketMap = HashBiMap.create(); // Player UUID -> Pocket Info TODO: fix AnnotatedNBT and use UUID rather than String + + public PrivatePocketData(String name) { + super(name); + } + + public PrivatePocketData() { + super(DATA_NAME); + } + + public static PrivatePocketData instance() { + MapStorage storage = WorldUtils.getWorld(0).getMapStorage(); + PrivatePocketData instance = (PrivatePocketData) storage.getOrLoadData(PrivatePocketData.class, DATA_NAME); + + if (instance == null) { + instance = new PrivatePocketData(); + storage.setData(DATA_NAME, instance); + } + + return instance; + } + + @Override public void readFromNBT(NBTTagCompound nbt) { NBTUtils.readFromNBT(this, nbt); } + @Override public NBTTagCompound writeToNBT(NBTTagCompound nbt) { return NBTUtils.writeToNBT(this, nbt); } + + public Pocket getPrivatePocket(UUID playerUUID) { + PocketInfo pocket = privatePocketMap.get(playerUUID.toString()); + if (pocket == null) return null; + return PocketRegistry.instance(pocket.dim).getPocket(pocket.id); + } + + public void setPrivatePocketID(UUID playerUUID, Pocket pocket) { + privatePocketMap.put(playerUUID.toString(), new PocketInfo(pocket.getDim(), pocket.getId())); + markDirty(); + } + + public UUID getPrivatePocketOwner(Pocket pocket) { + return UUID.fromString(privatePocketMap.inverse().get(new PocketInfo(pocket.getDim(), pocket.getId()))); + } +} diff --git a/src/main/java/org/dimdev/dimdoors/shared/VirtualLocation.java b/src/main/java/org/dimdev/pocketlib/VirtualLocation.java similarity index 55% rename from src/main/java/org/dimdev/dimdoors/shared/VirtualLocation.java rename to src/main/java/org/dimdev/pocketlib/VirtualLocation.java index c9130ca8..11bbaedb 100644 --- a/src/main/java/org/dimdev/dimdoors/shared/VirtualLocation.java +++ b/src/main/java/org/dimdev/pocketlib/VirtualLocation.java @@ -1,56 +1,42 @@ -package org.dimdev.dimdoors.shared; +package org.dimdev.pocketlib; import lombok.*; import net.minecraft.nbt.NBTTagCompound; import org.dimdev.annotatednbt.NBTSerializable; import org.dimdev.annotatednbt.Saved; +import org.dimdev.ddutils.Location; import org.dimdev.ddutils.nbt.INBTStorable; import org.dimdev.ddutils.nbt.NBTUtils; -import org.dimdev.dimdoors.DimDoors; -import org.dimdev.dimdoors.shared.pockets.Pocket; -import org.dimdev.dimdoors.shared.pockets.PocketRegistry; -import org.dimdev.ddutils.Location; -import org.dimdev.dimdoors.shared.world.ModDimensions; +import org.dimdev.dimdoors.shared.Config; import org.dimdev.dimdoors.shared.world.limbo.WorldProviderLimbo; +import org.dimdev.dimdoors.shared.world.pocketdimension.WorldProviderPocket; /*@Value*/ @ToString @AllArgsConstructor @NoArgsConstructor @Builder(toBuilder = true) -@NBTSerializable public class VirtualLocation implements INBTStorable { // TODO: fix AnnotatedNBT and rename this class back to VirtualLocation +@NBTSerializable public class VirtualLocation implements INBTStorable { @Saved @Getter protected int dim; @Saved @Getter protected int x; @Saved @Getter protected int z; @Saved @Getter protected int depth; // TODO: convert to doubles @Override public void readFromNBT(NBTTagCompound nbt) { NBTUtils.readFromNBT(this, nbt); } + @Override public NBTTagCompound writeToNBT(NBTTagCompound nbt) { return NBTUtils.writeToNBT(this, nbt); } public static VirtualLocation fromLocation(Location location) { VirtualLocation virtualLocation = null; - if (ModDimensions.isDimDoorsPocketDimension(location.getDim())) { + if (location.getWorld().provider instanceof WorldProviderPocket) { Pocket pocket = PocketRegistry.instance(location.getDim()).getPocketAt(location.getPos()); if (pocket != null) { virtualLocation = pocket.getVirtualLocation(); // TODO: pocket-relative coordinates } else { - DimDoors.log.warn("Tried to get VirtualLocation at " + location + " which is inside a pocket dimension but outside of a pocket"); virtualLocation = null; // TODO: door was placed in a pocket dim but outside of a pocket... } - } else if (location.getWorld().provider instanceof WorldProviderLimbo) { + } else if (location.getWorld().provider instanceof WorldProviderLimbo) { // TODO: convert to interface on worldprovider virtualLocation = new VirtualLocation(location.getDim(), location.getX(), location.getZ(), Config.getMaxDungeonDepth()); - } + } // TODO: nether coordinate transform if (virtualLocation == null) { virtualLocation = new VirtualLocation(0, location.getX(), location.getZ(), 5); // TODO - DimDoors.log.warn("VirtualLocation was null at " + location); } return virtualLocation; } - - /*// TODO: world-seed based transformations and pocket selections - public VirtualLocation transformDepth(int depth) { // TODO: Config option for block ratio between depths (see video of removed features) - Random random = new Random(); - int depthDiff = Math.abs(this.depth - depth); - int base = Config.getOwCoordinateOffsetBase(); - double power = Config.getOwCoordinateOffsetPower(); - int xOffset = random.nextInt((int) Math.pow(base * (depthDiff + 1), power)) * (random.nextBoolean() ? 1 : -1); - int zOffset = random.nextInt((int) Math.pow(base * (depthDiff + 1), power)) * (random.nextBoolean() ? 1 : -1); - return new VirtualLocation(getDim(), getPos().offset(EnumFacing.EAST, xOffset).offset(EnumFacing.SOUTH, zOffset), depth); - }*/ }