From dac15d5e3be853c96a2e7073fe16a103965a0e4f Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 10 Apr 2021 00:55:51 -0400 Subject: [PATCH 01/36] Basic unit tests, delete machine data file if it exists --- build.gradle | 40 ++++++++++++++ .../tests/minecraft/ExampleTest.java | 55 +++++++++++++++++++ 2 files changed, 95 insertions(+) create mode 100644 src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java diff --git a/build.gradle b/build.gradle index b9f269e3..817602a6 100644 --- a/build.gradle +++ b/build.gradle @@ -94,6 +94,26 @@ minecraft { } } } + + unitTests { + parent runs.server // This run config inherits settings from the server config + workingDirectory project.file('run/test') + main 'com.alcatrazescapee.mcjunitlib.DedicatedTestServerLauncher' // The main class which launches a customized server which then runs JUnit tests + ideaModule "${project.name}.test" // Tell IDEA to use the classpath of the test module + property 'forge.logging.console.level', 'unittest' // This logging level prevents any other server information messages and leaves only the unit test output + environment 'MOD_CLASSES', String.join(File.pathSeparator, + "${mod_id}%%${sourceSets.main.output.resourcesDir}", + "${mod_id}%%${sourceSets.main.output.classesDirs[0]}", + "${mod_id}%%${sourceSets.test.output.resourcesDir}", + "${mod_id}%%${sourceSets.test.output.classesDirs[0]}", + ) // Forge will ignore all test sources unless we explicitly tell it to include them as mod sources + environment 'target', 'fmltestserver' // This is a custom service used to launch with ModLauncher's transforming class loader + mods { + compactmachines { // The mod that is being tested - Replace this with your mod ID! + sources sourceSets.main + } + } + } } } @@ -129,6 +149,9 @@ def getModVersion(filename) { def dev_mods_dir = "mods" +task("dev") { + println(sourceSets.main.output.classesDirs[0]); +} repositories { // Built mods flatDir { @@ -146,6 +169,12 @@ repositories { name 'tterrag maven' url "http://maven.tterrag.com/" } + + // Unit Tests + maven { + name 'MCUnitTests' + url 'https://jitpack.io' + } } def dev_mods = fileTree(dev_mods_dir).filter { it -> it.isFile() }.files.name.collect({ getModVersion(it) }) @@ -156,12 +185,14 @@ dependencies { // The userdev artifact is a special name and will get all sorts of transformations applied to it. minecraft "net.minecraftforge:forge:${minecraft_version}-${forge_version}" + // Deobfuscate each dev mod for runtime dev_mods.each { compileOnly fg.deobf(it) runtimeOnly fg.deobf(it) } + // JEI compileOnly fg.deobf("mezz.jei:jei-${jei_mc_version}:${jei_version}:api") runtimeOnly fg.deobf("mezz.jei:jei-${jei_mc_version}:${jei_version}") @@ -170,6 +201,8 @@ dependencies { compileOnly fg.deobf("mcjty.theoneprobe:TheOneProbe-1.16:${top_version}:api") runtimeOnly fg.deobf("mcjty.theoneprobe:TheOneProbe-1.16:${top_version}") + testImplementation(fg.deobf("com.github.alcatrazEscapee:mcjunitlib:1.3.3-${minecraft_version}")) + } // Example for how to get properties into the manifest for reading by the runtime.. @@ -227,3 +260,10 @@ publishing { } } } + +test { + useJUnitPlatform() + filter { + exclude "com/robotgryphon/compactmachines/tests/minecraft/**" + } +} diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java b/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java new file mode 100644 index 00000000..fbea9e53 --- /dev/null +++ b/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java @@ -0,0 +1,55 @@ +package com.robotgryphon.compactmachines.tests.minecraft; + +import com.robotgryphon.compactmachines.core.Registration; +import com.robotgryphon.compactmachines.data.SavedMachineData; +import net.minecraft.block.Block; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.ResourceLocation; +import net.minecraft.world.storage.DimensionSavedDataManager; +import net.minecraft.world.storage.WorldSavedData; +import net.minecraftforge.fml.common.ObfuscationReflectionHelper; +import net.minecraftforge.fml.network.FMLNetworkConstants; +import net.minecraftforge.fml.server.ServerLifecycleHooks; +import net.minecraftforge.registries.ForgeRegistries; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +public class ExampleTest { + + @Test + void CanDoBasicTest() { + MinecraftServer serv = ServerLifecycleHooks.getCurrentServer(); + // SavedMachineData sd = SavedMachineData.getInstance(serv); + + DimensionSavedDataManager ds = serv + .getLevel(Registration.COMPACT_DIMENSION) + .getDataStorage(); + + SavedMachineData found = ds.get(SavedMachineData::new, SavedMachineData.DATA_NAME); + if(found != null) { + // Assertions.assertNotNull(sd); + Method getDataFile = ObfuscationReflectionHelper.findMethod( + DimensionSavedDataManager.class, + "func_215754_a", + String.class); + + try { + File i = (File) getDataFile.invoke(ds, found.getId()); + System.out.println(i.getAbsolutePath()); + + i.delete(); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } catch (InvocationTargetException e) { + e.printStackTrace(); + } + } else { + // File not found + Assertions.assertTrue(true); + } + } +} From 4dd7f3f797cd7aa97ccf3a7a53ae153ebc4fc693 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sun, 11 Apr 2021 07:00:16 -0400 Subject: [PATCH 02/36] Working changes, start to support nested machine theory --- src/generated/resources/.cache/cache | 4 +- .../personal_shrinking_device.json | 4 +- .../recipes/compactmachines/wall.json | 4 +- .../compactmachines/CompactMachines.java | 37 ++-- .../block/BlockCompactMachine.java | 28 +-- .../block/tiles/CompactMachineTile.java | 41 +++-- .../block/tiles/TunnelWallTile.java | 2 +- .../providers/CompactMachineProvider.java | 2 +- .../compactmachines/core/EventHandler.java | 9 - .../core/ServerEventHandler.java | 18 ++ .../compactmachines/data/NbtDataUtil.java | 22 --- .../data/codec/CodecExtensions.java | 26 +++ .../data/{ => codec}/NbtListCollector.java | 4 +- .../CompactMachineBaseData.java | 3 +- .../CompactMachineCommonData.java | 39 +--- .../CompactMachineRegistrationData.java | 5 +- .../CompactMachineServerData.java | 22 ++- .../data/{ => legacy}/SavedMachineData.java | 3 +- .../data/legacy/SavedMachineDataMigrator.java | 93 ++++++++++ .../machine/CompactMachineInternalData.java | 57 ++++++ .../CompactMachinePlayerData.java | 145 ++++++++------- .../compactmachines/data/player/theory.txt | 56 ++++++ .../data/world/ExternalMachineData.java | 167 ++++++++++++++++++ .../data/world/InternalMachineData.java | 84 +++++++++ .../datagen/RecipeGenerator.java | 18 +- .../network/MachinePlayersChangedPacket.java | 6 +- .../teleportation/DimensionalPosition.java | 48 +++-- .../compactmachines/tunnels/TunnelHelper.java | 8 +- .../RedstoneInTunnelDefinition.java | 8 - .../util/CompactMachinePlayerUtil.java | 57 ++++-- .../util/CompactMachineUtil.java | 7 +- .../compactmachines/util/PlayerUtil.java | 98 ++++++---- .../tests/minecraft/ExampleTest.java | 42 +---- 33 files changed, 822 insertions(+), 345 deletions(-) delete mode 100644 src/main/java/com/robotgryphon/compactmachines/core/EventHandler.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/core/ServerEventHandler.java delete mode 100644 src/main/java/com/robotgryphon/compactmachines/data/NbtDataUtil.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java rename src/main/java/com/robotgryphon/compactmachines/data/{ => codec}/NbtListCollector.java (93%) rename src/main/java/com/robotgryphon/compactmachines/data/{machines => legacy}/CompactMachineBaseData.java (94%) rename src/main/java/com/robotgryphon/compactmachines/data/{ => legacy}/CompactMachineCommonData.java (53%) rename src/main/java/com/robotgryphon/compactmachines/data/{machines => legacy}/CompactMachineRegistrationData.java (97%) rename src/main/java/com/robotgryphon/compactmachines/data/{ => legacy}/CompactMachineServerData.java (87%) rename src/main/java/com/robotgryphon/compactmachines/data/{ => legacy}/SavedMachineData.java (96%) create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineDataMigrator.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java rename src/main/java/com/robotgryphon/compactmachines/data/{machines => player}/CompactMachinePlayerData.java (51%) create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/player/theory.txt create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/world/InternalMachineData.java diff --git a/src/generated/resources/.cache/cache b/src/generated/resources/.cache/cache index 25bb6ef4..17226955 100644 --- a/src/generated/resources/.cache/cache +++ b/src/generated/resources/.cache/cache @@ -13,8 +13,8 @@ bb446af024870e7a07d31a3c78cab75797392cd5 assets/compactmachines/models/tunnels/n 2781d8f8d22db668495872f1bb39e2dd1290ab66 assets/compactmachines/models/tunnels/south.json 955410e7497ca2252d75eac53d02fb96992d94c7 assets/compactmachines/models/tunnels/up.json f8748baf2b48a44db2cf8d3872bd09b54a822560 assets/compactmachines/models/tunnels/west.json -95bb11d93b0dee59240d959bc881caea0115970f data/compactmachines/advancements/recipes/compactmachines/personal_shrinking_device.json -b86297267feb2e7d28cb68a830a0d7ffd6b6539a data/compactmachines/advancements/recipes/compactmachines/wall.json +e012e4b65799a56d195a6324c82e2cdf7a5a91be data/compactmachines/advancements/recipes/compactmachines/personal_shrinking_device.json +fd7ccf69e4445ba0a2d7b2cd405ebe2ae85be240 data/compactmachines/advancements/recipes/compactmachines/wall.json fb5c7560898ae604661d0655c2a39e923eb1d4b4 data/compactmachines/loot_tables/blocks/machine_giant.json 056d363f46ab1cc37c16f08428a3d2a9e0dd66d2 data/compactmachines/loot_tables/blocks/machine_large.json 38a7648eb331daf18f5076126f31f31b6021ac51 data/compactmachines/loot_tables/blocks/machine_maximum.json diff --git a/src/generated/resources/data/compactmachines/advancements/recipes/compactmachines/personal_shrinking_device.json b/src/generated/resources/data/compactmachines/advancements/recipes/compactmachines/personal_shrinking_device.json index 9944fb53..44a41e91 100644 --- a/src/generated/resources/data/compactmachines/advancements/recipes/compactmachines/personal_shrinking_device.json +++ b/src/generated/resources/data/compactmachines/advancements/recipes/compactmachines/personal_shrinking_device.json @@ -6,7 +6,7 @@ ] }, "criteria": { - "has_recipe": { + "picked_up_ender_eye": { "trigger": "minecraft:inventory_changed", "conditions": { "items": [ @@ -25,7 +25,7 @@ }, "requirements": [ [ - "has_recipe", + "picked_up_ender_eye", "has_the_recipe" ] ] diff --git a/src/generated/resources/data/compactmachines/advancements/recipes/compactmachines/wall.json b/src/generated/resources/data/compactmachines/advancements/recipes/compactmachines/wall.json index 41f67f75..e2047b76 100644 --- a/src/generated/resources/data/compactmachines/advancements/recipes/compactmachines/wall.json +++ b/src/generated/resources/data/compactmachines/advancements/recipes/compactmachines/wall.json @@ -6,7 +6,7 @@ ] }, "criteria": { - "has_recipe": { + "picked_up_iron": { "trigger": "minecraft:inventory_changed", "conditions": { "items": [ @@ -25,7 +25,7 @@ }, "requirements": [ [ - "has_recipe", + "picked_up_iron", "has_the_recipe" ] ] diff --git a/src/main/java/com/robotgryphon/compactmachines/CompactMachines.java b/src/main/java/com/robotgryphon/compactmachines/CompactMachines.java index a85403ba..6f50077e 100644 --- a/src/main/java/com/robotgryphon/compactmachines/CompactMachines.java +++ b/src/main/java/com/robotgryphon/compactmachines/CompactMachines.java @@ -6,15 +6,18 @@ import com.robotgryphon.compactmachines.config.ServerConfig; import com.robotgryphon.compactmachines.core.Registration; import com.robotgryphon.compactmachines.network.NetworkHandler; +import net.minecraft.client.Minecraft; import net.minecraft.item.ItemGroup; import net.minecraft.item.ItemStack; import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.common.crafting.CraftingHelper; +import net.minecraftforge.event.TickEvent; import net.minecraftforge.eventbus.api.IEventBus; import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.fml.ModList; import net.minecraftforge.fml.ModLoadingContext; import net.minecraftforge.fml.common.Mod; +import net.minecraftforge.fml.common.ObfuscationReflectionHelper; import net.minecraftforge.fml.config.ModConfig; import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent; import net.minecraftforge.fml.event.lifecycle.InterModEnqueueEvent; @@ -24,8 +27,8 @@ import org.apache.logging.log4j.Logger; @Mod(CompactMachines.MOD_ID) -public class CompactMachines -{ +@Mod.EventBusSubscriber(modid = CompactMachines.MOD_ID) +public class CompactMachines { public static final String MOD_ID = "compactmachines"; public static final Logger LOGGER = LogManager.getLogger(); @@ -43,15 +46,6 @@ public CompactMachines() { // Register blocks and items Registration.init(); - // Register the setup method for modloading - modBus.addListener(this::setup); - - // Register the enqueueIMC method for modloading - modBus.addListener(this::enqueueIMC); - - // Register ourselves for server and other game events we are interested in - MinecraftForge.EVENT_BUS.register(this); - ModLoadingContext mlCtx = ModLoadingContext.get(); mlCtx.registerConfig(ModConfig.Type.COMMON, CommonConfig.CONFIG); mlCtx.registerConfig(ModConfig.Type.SERVER, ServerConfig.CONFIG); @@ -59,14 +53,25 @@ public CompactMachines() { CraftingHelper.register(EnableVanillaRecipesConfigCondition.Serializer.INSTANCE); } - private void setup(final FMLCommonSetupEvent event) - { + @SubscribeEvent + public static void setup(final FMLCommonSetupEvent event) { NetworkHandler.initialize(); } - private void enqueueIMC(final InterModEnqueueEvent event) - { - if(ModList.get().isLoaded("theoneprobe")) + @SubscribeEvent + public static void enqueueIMC(final InterModEnqueueEvent event) { + if (ModList.get().isLoaded("theoneprobe")) TheOneProbeCompat.sendIMC(); } + + @SubscribeEvent + public static void onTick(TickEvent.RenderTickEvent e) { + // lol frames r good +// ObfuscationReflectionHelper.setPrivateValue( +// Minecraft.class, +// Minecraft.getInstance(), +// -100, +// "field_71420_M" +// ); + } } diff --git a/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java b/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java index db86f52a..07dd2c47 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java @@ -94,7 +94,7 @@ public boolean canConnectRedstone(BlockState state, IBlockReader world, BlockPos @Override public int getSignal(BlockState blockState, IBlockReader blockAccess, BlockPos pos, Direction side) { -// TODO Tile Entity +// TODO Redstone out tunnels // if(!(blockAccess.getTileEntity(pos) instanceof TileEntityMachine)) { // return 0; // } @@ -257,32 +257,6 @@ public void setPlacedBy(World worldIn, BlockPos pos, BlockState state, @Nullable tile.setChanged(); } -// // TODO: Allow storing of schemas in machines -// if(stack.hasTag()) { -// if(stack.getTag().contains("coords")) { -// int coords = stack.getTag().getInt("coords"); -// if (coords != -1) { -// tileEntityMachine.coords = coords; -// if(!world.isRemote) { -// WorldSavedDataMachines.INSTANCE.addMachinePosition(tileEntityMachine.coords, pos, world.provider.getDimension(), tileEntityMachine.getSize()); -// StructureTools.setBiomeForCoords(coords, world.getBiome(pos)); -// } -// } -// } -// -// if(stack.getTag().contains("schema")) { -// tileEntityMachine.setSchema(stack.getTag().getString("schema")); -// } -// - -// } -// - -// -// tileEntityMachine.markDirty(); -// } - - @Override public ActionResultType use(BlockState state, World worldIn, BlockPos pos, PlayerEntity player, Hand handIn, BlockRayTraceResult hit) { if (worldIn.isClientSide()) diff --git a/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java b/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java index 1e65a369..e9523a44 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java @@ -2,10 +2,11 @@ import com.robotgryphon.compactmachines.config.ServerConfig; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.CompactMachineCommonData; -import com.robotgryphon.compactmachines.data.SavedMachineData; -import com.robotgryphon.compactmachines.data.machines.CompactMachinePlayerData; -import com.robotgryphon.compactmachines.data.machines.CompactMachineRegistrationData; +import com.robotgryphon.compactmachines.data.legacy.CompactMachineCommonData; +import com.robotgryphon.compactmachines.data.legacy.SavedMachineData; +import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; +import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData; +import com.robotgryphon.compactmachines.data.world.ExternalMachineData; import com.robotgryphon.compactmachines.reference.Reference; import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; import com.robotgryphon.compactmachines.tunnels.TunnelHelper; @@ -189,8 +190,8 @@ public CompoundNBT getUpdateTag() { if (level instanceof ServerWorld) { Optional playerData = Optional.empty(); try { - SavedMachineData machineData = SavedMachineData.getInstance(level.getServer()); - playerData = machineData.getData().getPlayerData(machineId); + CompactMachinePlayerData psd = CompactMachinePlayerData.get(level.getServer()); + // psd = psd.getPlayersInside(this.machineId); } catch (Exception e) { e.printStackTrace(); } @@ -207,6 +208,15 @@ public CompoundNBT getUpdateTag() { return base; } + public Optional getInternalChunkPos() { + if(level instanceof ServerWorld) { + ExternalMachineData emd = ExternalMachineData.get(level.getServer()); + return emd.getChunkLocation(this.machineId); + } + + return Optional.empty(); + } + @Override public void handleUpdateTag(BlockState state, CompoundNBT tag) { super.handleUpdateTag(state, tag); @@ -214,7 +224,7 @@ public void handleUpdateTag(BlockState state, CompoundNBT tag) { this.machineId = tag.getInt("machine"); if (tag.contains("players")) { CompoundNBT players = tag.getCompound("players"); - playerData = CompactMachinePlayerData.fromNBT(players); + // playerData = CompactMachinePlayerData.fromNBT(players); } @@ -265,11 +275,13 @@ public Optional getMachineData() { } public boolean hasPlayersInside() { - return CompactMachineCommonData - .getInstance() - .getPlayerData(machineId) - .map(CompactMachinePlayerData::hasPlayers) - .orElse(false); + return false; + // TODO +// return CompactMachineCommonData +// .getInstance() +// .getPlayerData(machineId) +// .map(CompactMachinePlayerData::hasPlayers) +// .orElse(false); } protected void doChunkload(boolean force) { @@ -294,8 +306,9 @@ public void handlePlayerLeft(UUID playerID) { } public void handlePlayerEntered(UUID playerID) { - if(this.playerData != null) - this.playerData.addPlayer(playerID); + // TODO +// if(this.playerData != null) +// this.playerData.addPlayer(playerID); } /* diff --git a/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java b/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java index dbb44072..8b6f410e 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java @@ -2,7 +2,7 @@ import com.robotgryphon.compactmachines.block.walls.TunnelWallBlock; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.machines.CompactMachineRegistrationData; +import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData; import com.robotgryphon.compactmachines.network.NetworkHandler; import com.robotgryphon.compactmachines.network.TunnelAddedPacket; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; diff --git a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java b/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java index 1143358b..f2e1cf57 100644 --- a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java +++ b/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java @@ -6,7 +6,7 @@ import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; import com.robotgryphon.compactmachines.compat.theoneprobe.IProbeData; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.machines.CompactMachineRegistrationData; +import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData; import com.robotgryphon.compactmachines.tunnels.TunnelHelper; import mcjty.theoneprobe.api.IProbeHitData; import mcjty.theoneprobe.api.IProbeInfo; diff --git a/src/main/java/com/robotgryphon/compactmachines/core/EventHandler.java b/src/main/java/com/robotgryphon/compactmachines/core/EventHandler.java deleted file mode 100644 index 9dceff29..00000000 --- a/src/main/java/com/robotgryphon/compactmachines/core/EventHandler.java +++ /dev/null @@ -1,9 +0,0 @@ -package com.robotgryphon.compactmachines.core; - -import com.robotgryphon.compactmachines.CompactMachines; -import net.minecraftforge.fml.common.Mod; - -@Mod.EventBusSubscriber(modid = CompactMachines.MOD_ID) -public class EventHandler { - -} diff --git a/src/main/java/com/robotgryphon/compactmachines/core/ServerEventHandler.java b/src/main/java/com/robotgryphon/compactmachines/core/ServerEventHandler.java new file mode 100644 index 00000000..ab314a24 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/core/ServerEventHandler.java @@ -0,0 +1,18 @@ +package com.robotgryphon.compactmachines.core; + +import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.data.legacy.SavedMachineDataMigrator; +import net.minecraft.server.MinecraftServer; +import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.fml.common.Mod; +import net.minecraftforge.fml.event.server.FMLServerStartingEvent; + +@Mod.EventBusSubscriber(modid = CompactMachines.MOD_ID) +public class ServerEventHandler { + + @SubscribeEvent + public static void onServerStarting(final FMLServerStartingEvent evt) { + MinecraftServer server = evt.getServer(); + SavedMachineDataMigrator.migrate(server); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/NbtDataUtil.java b/src/main/java/com/robotgryphon/compactmachines/data/NbtDataUtil.java deleted file mode 100644 index 9c4b1ede..00000000 --- a/src/main/java/com/robotgryphon/compactmachines/data/NbtDataUtil.java +++ /dev/null @@ -1,22 +0,0 @@ -package com.robotgryphon.compactmachines.data; - -import net.minecraft.nbt.CompoundNBT; -import net.minecraft.util.math.vector.Vector3d; - -public abstract class NbtDataUtil { - - public static CompoundNBT writeVectorCompound(Vector3d vector) { - CompoundNBT nbt = new CompoundNBT(); - nbt.putDouble("x", vector.x); - nbt.putDouble("y", vector.y); - nbt.putDouble("z", vector.z); - return nbt; - } - - public static Vector3d readVectorCompound(CompoundNBT nbt) { - double x = nbt.getDouble("x"); - double y = nbt.getDouble("y"); - double z = nbt.getDouble("z"); - return new Vector3d(x, y, z); - } -} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java b/src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java new file mode 100644 index 00000000..a97e9ec2 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java @@ -0,0 +1,26 @@ +package com.robotgryphon.compactmachines.data.codec; + +import com.mojang.serialization.Codec; +import com.mojang.serialization.codecs.RecordCodecBuilder; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.util.math.vector.Vector3d; + +import java.util.UUID; + +public abstract class CodecExtensions { + + public static Codec UUID_CODEC = RecordCodecBuilder.create(i -> i.group( + Codec.STRING.fieldOf("uuid").forGetter(UUID::toString) + ).apply(i, UUID::fromString)); + + public static Codec VECTOR3D_CODEC = RecordCodecBuilder.create(i -> i.group( + Codec.DOUBLE.fieldOf("x").forGetter(Vector3d::x), + Codec.DOUBLE.fieldOf("y").forGetter(Vector3d::y), + Codec.DOUBLE.fieldOf("z").forGetter(Vector3d::z) + ).apply(i, Vector3d::new)); + + public static Codec CHUNKPOS_CODEC = RecordCodecBuilder.create(i -> i.group( + Codec.INT.fieldOf("chunkX").forGetter((c) -> c.x), + Codec.INT.fieldOf("chunkZ").forGetter((c) -> c.z) + ).apply(i, ChunkPos::new)); +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/NbtListCollector.java b/src/main/java/com/robotgryphon/compactmachines/data/codec/NbtListCollector.java similarity index 93% rename from src/main/java/com/robotgryphon/compactmachines/data/NbtListCollector.java rename to src/main/java/com/robotgryphon/compactmachines/data/codec/NbtListCollector.java index c34181f2..170d3369 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/NbtListCollector.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/codec/NbtListCollector.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.data; +package com.robotgryphon.compactmachines.data.codec; import com.google.common.collect.ImmutableSet; import net.minecraft.nbt.INBT; @@ -13,8 +13,6 @@ import java.util.function.Supplier; import java.util.stream.Collector; -import java.util.stream.Collector.Characteristics; - public class NbtListCollector implements Collector, ListNBT> { @Override diff --git a/src/main/java/com/robotgryphon/compactmachines/data/machines/CompactMachineBaseData.java b/src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineBaseData.java similarity index 94% rename from src/main/java/com/robotgryphon/compactmachines/data/machines/CompactMachineBaseData.java rename to src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineBaseData.java index a09addaa..53fcdd30 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/machines/CompactMachineBaseData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineBaseData.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.data.machines; +package com.robotgryphon.compactmachines.data.legacy; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.INBT; @@ -9,6 +9,7 @@ /** * Holds basic information about a compact machine. */ +@Deprecated public abstract class CompactMachineBaseData implements INBTSerializable { private int id; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/CompactMachineCommonData.java b/src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineCommonData.java similarity index 53% rename from src/main/java/com/robotgryphon/compactmachines/data/CompactMachineCommonData.java rename to src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineCommonData.java index 664f7999..aa91d369 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/CompactMachineCommonData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineCommonData.java @@ -1,6 +1,7 @@ -package com.robotgryphon.compactmachines.data; +package com.robotgryphon.compactmachines.data.legacy; -import com.robotgryphon.compactmachines.data.machines.CompactMachinePlayerData; +import com.robotgryphon.compactmachines.data.codec.NbtListCollector; +import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.ListNBT; import net.minecraftforge.common.util.Constants; @@ -9,6 +10,7 @@ import java.util.Map; import java.util.Optional; +@Deprecated public class CompactMachineCommonData { protected Map playerData; @@ -18,6 +20,7 @@ protected CompactMachineCommonData() { this.playerData = new HashMap<>(); } + @Deprecated public static CompactMachineCommonData getInstance() { if (INSTANCE == null) { INSTANCE = new CompactMachineCommonData(); @@ -45,39 +48,7 @@ public CompoundNBT serializeNBT(CompoundNBT compound) { } public void deserializeNBT(CompoundNBT nbt) { - deserializePlayerData(nbt); - } - - public void deserializePlayerData(CompoundNBT nbt) { - if (nbt.contains("players")) { - ListNBT players = nbt.getList("players", Constants.NBT.TAG_COMPOUND); - players.forEach(data -> { - CompactMachinePlayerData pmd = CompactMachinePlayerData.fromNBT(data); - playerData.put(pmd.getId(), pmd); - }); - } - } - - - - public void updatePlayerData(CompactMachinePlayerData pd) { - int id = pd.getId(); - - // Do we have an existing player data entry? If not, just add and return - if (!playerData.containsKey(id)) { - playerData.put(id, pd); - return; - } - - // If we have an existing entry, update and mark dirty - playerData.replace(id, pd); } - public Optional getPlayerData(int id) { - if (!playerData.containsKey(id)) - playerData.put(id, new CompactMachinePlayerData(id)); - - return Optional.ofNullable(playerData.get(id)); - } } diff --git a/src/main/java/com/robotgryphon/compactmachines/data/machines/CompactMachineRegistrationData.java b/src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineRegistrationData.java similarity index 97% rename from src/main/java/com/robotgryphon/compactmachines/data/machines/CompactMachineRegistrationData.java rename to src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineRegistrationData.java index 2a754385..36516d0b 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/machines/CompactMachineRegistrationData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineRegistrationData.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.data.machines; +package com.robotgryphon.compactmachines.data.legacy; import com.robotgryphon.compactmachines.reference.EnumMachineSize; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; @@ -14,13 +14,14 @@ import net.minecraft.world.World; import net.minecraft.world.server.ServerWorld; -import java.util.List; import java.util.Optional; import java.util.UUID; /** * Holds information that can be used to uniquely identify a compact machine. + * @deprecated Prefer InternalMachineData and CompactMachineInternalData instead. */ +@Deprecated public class CompactMachineRegistrationData extends CompactMachineBaseData { private BlockPos center; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/CompactMachineServerData.java b/src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineServerData.java similarity index 87% rename from src/main/java/com/robotgryphon/compactmachines/data/CompactMachineServerData.java rename to src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineServerData.java index 73097b23..9e3c586a 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/CompactMachineServerData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineServerData.java @@ -1,22 +1,21 @@ -package com.robotgryphon.compactmachines.data; +package com.robotgryphon.compactmachines.data.legacy; -import com.robotgryphon.compactmachines.data.machines.CompactMachinePlayerData; -import com.robotgryphon.compactmachines.data.machines.CompactMachineRegistrationData; +import com.robotgryphon.compactmachines.data.codec.NbtListCollector; +import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; import com.robotgryphon.compactmachines.reference.EnumMachineSize; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.ListNBT; -import net.minecraft.server.MinecraftServer; import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.common.util.Constants; -import javax.annotation.Nullable; import java.util.HashMap; import java.util.Map; import java.util.Optional; import java.util.stream.Stream; +@Deprecated public class CompactMachineServerData extends CompactMachineCommonData { private Map machineData; @@ -69,7 +68,7 @@ public boolean registerMachine(int newID, CompactMachineRegistrationData compact return false; this.machineData.put(newID, compactMachineData); - this.playerData.put(newID, new CompactMachinePlayerData(newID)); + // TODO this.playerData.put(newID, new CompactMachinePlayerData(newID)); return true; } @@ -122,4 +121,15 @@ public Optional getMachineData(int machineId) { return Optional.ofNullable(machineData.get(machineId)); } + + public void removeMachine(int machineId) { + if(!machineData.containsKey(machineId)) + return; + + machineData.remove(machineId); + } + + public void removeMachine(CompactMachineRegistrationData mach) { + removeMachine(mach.getId()); + } } diff --git a/src/main/java/com/robotgryphon/compactmachines/data/SavedMachineData.java b/src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineData.java similarity index 96% rename from src/main/java/com/robotgryphon/compactmachines/data/SavedMachineData.java rename to src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineData.java index e663b419..1cc76eae 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/SavedMachineData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineData.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.data; +package com.robotgryphon.compactmachines.data.legacy; import com.robotgryphon.compactmachines.CompactMachines; import com.robotgryphon.compactmachines.core.Registration; @@ -14,6 +14,7 @@ /** * Basically a wrapper around CompactMachineServerData. Allows read/write to disk. */ +@Deprecated public class SavedMachineData extends WorldSavedData { public final static String DATA_NAME = CompactMachines.MOD_ID + "_machines"; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineDataMigrator.java b/src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineDataMigrator.java new file mode 100644 index 00000000..b747efb6 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineDataMigrator.java @@ -0,0 +1,93 @@ +package com.robotgryphon.compactmachines.data.legacy; + +import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.core.Registration; +import com.robotgryphon.compactmachines.data.legacy.CompactMachineServerData; +import com.robotgryphon.compactmachines.data.legacy.SavedMachineData; +import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; +import com.robotgryphon.compactmachines.data.world.ExternalMachineData; +import com.robotgryphon.compactmachines.data.world.InternalMachineData; +import com.robotgryphon.compactmachines.reference.EnumMachineSize; +import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.world.storage.DimensionSavedDataManager; +import net.minecraftforge.fml.common.ObfuscationReflectionHelper; + +import java.io.File; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.UUID; + +public class SavedMachineDataMigrator { + + public static void migrate(MinecraftServer server) { + DimensionSavedDataManager ds = server + .getLevel(Registration.COMPACT_DIMENSION) + .getDataStorage(); + + SavedMachineData found = ds.get(SavedMachineData::new, SavedMachineData.DATA_NAME); + if (found == null) { + CompactMachines.LOGGER.debug("Migration complete; nothing available to migrate."); + return; + } + + ExternalMachineData emd = ExternalMachineData.get(server); + if (emd == null) { + CompactMachines.LOGGER.error("Could not perform migration; couldn't create the external machine file."); + return; + } + + InternalMachineData imd = InternalMachineData.get(server); + if(imd == null) { + CompactMachines.LOGGER.error("Could not perform migration; couldn't create the internal machine file."); + return; + } + + CompactMachineServerData data = found.getData(); + data.getMachines().forEach(mach -> { + DimensionalPosition outside = mach.getOutsidePosition(server); + BlockPos internalCenter = mach.getCenter(); + ChunkPos machineChunk = new ChunkPos(internalCenter); + + UUID owner = mach.getOwner(); + EnumMachineSize size = mach.getSize(); + BlockPos center = mach.getCenter(); + BlockPos spawn = mach.getSpawnPoint().orElse(center); + + int id = mach.getId(); + if (!emd.machineLocations.containsKey(id)) + emd.machineLocations.put(id, outside); + + if (!emd.machineMapping.containsKey(id)) + emd.machineMapping.put(id, machineChunk); + + if(!imd.machineData.containsKey(machineChunk)) { + CompactMachineInternalData d = new CompactMachineInternalData(owner, center, spawn, size); + imd.machineData.put(machineChunk, d); + } + }); + + imd.setDirty(); + emd.setDirty(); + } + + private static boolean doFileDelete(DimensionSavedDataManager ds, SavedMachineData found) { + Method getDataFile = ObfuscationReflectionHelper.findMethod( + DimensionSavedDataManager.class, + "func_215754_a", + String.class); + + try { + File i = (File) getDataFile.invoke(ds, found.getId()); + System.out.println(i.getAbsolutePath()); + + return i.delete(); + } catch (IllegalAccessException | InvocationTargetException e) { + e.printStackTrace(); + } + + return false; + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java b/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java new file mode 100644 index 00000000..24899443 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java @@ -0,0 +1,57 @@ +package com.robotgryphon.compactmachines.data.machine; + +import com.mojang.serialization.Codec; +import com.mojang.serialization.codecs.RecordCodecBuilder; +import com.robotgryphon.compactmachines.reference.EnumMachineSize; +import net.minecraft.util.math.BlockPos; + +import java.util.UUID; + +public class CompactMachineInternalData { + + public static Codec CODEC = RecordCodecBuilder.create(i -> i.group( + Codec.STRING.fieldOf("owner").forGetter(CompactMachineInternalData::getOwnerString), + BlockPos.CODEC.fieldOf("center").forGetter(CompactMachineInternalData::getCenter), + BlockPos.CODEC.fieldOf("spawn").forGetter(CompactMachineInternalData::getSpawn), + Codec.STRING.fieldOf("size").forGetter(CompactMachineInternalData::getSizeString) + ).apply(i, CompactMachineInternalData::new)); + + private final UUID owner; + private final BlockPos center; + private BlockPos spawn; + private final EnumMachineSize size; + + protected CompactMachineInternalData(String owner, BlockPos center, BlockPos spawn, String sizeString) { + this.owner = UUID.fromString(owner); + this.center = center; + this.spawn = spawn; + this.size = EnumMachineSize.getFromSize(sizeString); + } + + public CompactMachineInternalData(UUID owner, BlockPos center, BlockPos spawn, EnumMachineSize size) { + this.owner = owner; + this.center = center; + this.spawn = spawn; + this.size = size; + } + + private String getSizeString() { + return this.size.name(); + } + + private String getOwnerString() { + return owner.toString(); + } + + public BlockPos getSpawn() { + return this.spawn; + } + + public BlockPos getCenter() { + return this.center; + } + + public void setSpawn(BlockPos newSpawn) { + this.spawn = newSpawn; + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/machines/CompactMachinePlayerData.java b/src/main/java/com/robotgryphon/compactmachines/data/player/CompactMachinePlayerData.java similarity index 51% rename from src/main/java/com/robotgryphon/compactmachines/data/machines/CompactMachinePlayerData.java rename to src/main/java/com/robotgryphon/compactmachines/data/player/CompactMachinePlayerData.java index f873414c..da5d5c97 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/machines/CompactMachinePlayerData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/player/CompactMachinePlayerData.java @@ -1,23 +1,32 @@ -package com.robotgryphon.compactmachines.data.machines; +package com.robotgryphon.compactmachines.data.player; -import com.robotgryphon.compactmachines.data.NbtListCollector; +import com.mojang.serialization.DataResult; +import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.core.Registration; +import com.robotgryphon.compactmachines.data.codec.CodecExtensions; +import com.robotgryphon.compactmachines.data.codec.NbtListCollector; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; import com.robotgryphon.compactmachines.util.PlayerUtil; import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.nbt.*; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.world.server.ServerWorld; +import net.minecraft.world.storage.DimensionSavedDataManager; +import net.minecraft.world.storage.WorldSavedData; import net.minecraftforge.common.util.Constants; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Optional; -import java.util.UUID; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.util.*; /** * Holds basic information about players inside a compact machine. */ -public class CompactMachinePlayerData extends CompactMachineBaseData { +public class CompactMachinePlayerData extends WorldSavedData { - private HashSet internalPlayers; + public static final String DATA_NAME = "players"; + private HashMap internalPlayerLocations; /** * Holds a mapping of where players entered a machine. @@ -25,40 +34,68 @@ public class CompactMachinePlayerData extends CompactMachineBaseData { private HashMap externalSpawns; protected CompactMachinePlayerData() { - super(); - this.internalPlayers = new HashSet<>(0); + super(DATA_NAME); + this.internalPlayerLocations = new HashMap<>(0); this.externalSpawns = new HashMap<>(0); } - public CompactMachinePlayerData(int id) { - super(id); - this.internalPlayers = new HashSet<>(0); - this.externalSpawns = new HashMap<>(0); + @Nullable + public static CompactMachinePlayerData get(MinecraftServer server) { + ServerWorld compactWorld = server.getLevel(Registration.COMPACT_DIMENSION); + if (compactWorld == null) { + CompactMachines.LOGGER.error("No compact dimension found. Report this."); + return null; + } + + DimensionSavedDataManager sd = compactWorld.getDataStorage(); + return sd.computeIfAbsent(CompactMachinePlayerData::new, DATA_NAME); } - public static CompactMachinePlayerData fromNBT(INBT nbt) { - if (nbt instanceof CompoundNBT) { - Optional id = getIdFromNbt(nbt); + @Override + public void load(CompoundNBT nbt) { + if (nbt.contains("players")) { + ListNBT players = nbt.getList("players", Constants.NBT.TAG_COMPOUND); + players.forEach(playerData -> { + CompoundNBT pd = (CompoundNBT) playerData; + UUID id = pd.getUUID("id"); + + Optional chunk = CodecExtensions.CHUNKPOS_CODEC + .parse(NBTDynamicOps.INSTANCE, pd.get("chunk")) + .resultOrPartial(CompactMachines.LOGGER::error); - // If we have an ID from nbt, create an instance, otherwise invalid - return id.map(i -> { - CompactMachinePlayerData d = new CompactMachinePlayerData(i); - d.deserializeNBT((CompoundNBT) nbt); - return d; - }).orElse(null); + // If the chunk position was found, load it into the map + chunk.ifPresent(c -> { + this.internalPlayerLocations.put(id, c); + }); + }); } - return null; + if (nbt.contains("spawns")) { + ListNBT spawns = nbt.getList("spawns", Constants.NBT.TAG_COMPOUND); + spawns.forEach(spawnData -> { + + CompoundNBT spawn = (CompoundNBT) spawnData; + UUID playerId = spawn.getUUID("id"); + DimensionalPosition pos = DimensionalPosition.fromNBT(spawn.getCompound("spawn")); + + externalSpawns.put(playerId, pos); + }); + } } @Override - public CompoundNBT serializeNBT() { - CompoundNBT nbt = super.serializeNBT(); - ListNBT ids = internalPlayers.stream() + @Nonnull + public CompoundNBT save(CompoundNBT nbt) { + ListNBT ids = internalPlayerLocations.entrySet() + .stream() .map(u -> { - IntArrayNBT intNBTS = NBTUtil.createUUID(u); + IntArrayNBT intNBTS = NBTUtil.createUUID(u.getKey()); CompoundNBT pnbt = new CompoundNBT(); pnbt.put("id", intNBTS); + + DataResult r = CodecExtensions.CHUNKPOS_CODEC.encodeStart(NBTDynamicOps.INSTANCE, u.getValue()); + r.result().ifPresent(a -> pnbt.put("chunk", a)); + return pnbt; }) .collect(NbtListCollector.toNbtList()); @@ -84,56 +121,30 @@ public CompoundNBT serializeNBT() { return nbt; } - @Override - public void deserializeNBT(CompoundNBT nbt) { - super.deserializeNBT(nbt); - - if (nbt.contains("players")) { - ListNBT players = nbt.getList("players", Constants.NBT.TAG_COMPOUND); - players.forEach(playerData -> { - CompoundNBT pd = (CompoundNBT) playerData; - UUID id = pd.getUUID("id"); - this.internalPlayers.add(id); - }); - } - - if (nbt.contains("spawns")) { - ListNBT spawns = nbt.getList("spawns", Constants.NBT.TAG_COMPOUND); - spawns.forEach(spawnData -> { - - CompoundNBT spawn = (CompoundNBT) spawnData; - UUID playerId = spawn.getUUID("id"); - DimensionalPosition pos = DimensionalPosition.fromNBT(spawn.getCompound("spawn")); - - externalSpawns.put(playerId, pos); - }); - } - } - public boolean hasPlayers() { - return !internalPlayers.isEmpty(); + return !internalPlayerLocations.isEmpty(); } - public void addPlayer(UUID playerID) { - if(!internalPlayers.contains(playerID)) { - internalPlayers.add(playerID); + public void addPlayer(UUID playerID, ChunkPos innerChunk) { + if (!internalPlayerLocations.containsKey(playerID)) { + internalPlayerLocations.put(playerID, innerChunk); } } - public void addPlayer(ServerPlayerEntity serverPlayer) { + public void addPlayer(ServerPlayerEntity serverPlayer, ChunkPos innerChunk) { UUID playerUUID = serverPlayer.getGameProfile().getId(); - addPlayer(playerUUID); + addPlayer(playerUUID, innerChunk); // server support - add spawn to data - if(!externalSpawns.containsKey(playerUUID)) { + if (!externalSpawns.containsKey(playerUUID)) { DimensionalPosition pos = PlayerUtil.getPlayerDimensionalPosition(serverPlayer); externalSpawns.put(playerUUID, pos); } } public void removePlayer(UUID playerID) { - if (internalPlayers.contains(playerID)) { - internalPlayers.remove(playerID); + if (internalPlayerLocations.containsKey(playerID)) { + internalPlayerLocations.remove(playerID); externalSpawns.remove(playerID); } } @@ -145,12 +156,16 @@ public void removePlayer(ServerPlayerEntity serverPlayer) { public Optional getExternalSpawn(ServerPlayerEntity serverPlayer) { UUID playerUUID = serverPlayer.getGameProfile().getId(); - if(!internalPlayers.contains(playerUUID)) + if (!internalPlayerLocations.containsKey(playerUUID)) return Optional.empty(); - if(!externalSpawns.containsKey(playerUUID)) + if (!externalSpawns.containsKey(playerUUID)) return Optional.empty(); return Optional.of(externalSpawns.get(playerUUID)); } + + public Set getPlayersInside(ChunkPos machinePos) { + return Collections.emptySet(); + } } diff --git a/src/main/java/com/robotgryphon/compactmachines/data/player/theory.txt b/src/main/java/com/robotgryphon/compactmachines/data/player/theory.txt new file mode 100644 index 00000000..21061312 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/player/theory.txt @@ -0,0 +1,56 @@ +Player P +Machines A,B,C,D + +====================================================================== +machine locations (external) +====================================================================== +A (01): 00, 00, 00 @ overworld +A (05): 76, 40, 76 @ compact_world +A (06): 51, 40, 51 @ compact_world +B (02): 26, 40, 26 @ compact_world +C (03): 51, 40, 51 @ compact_world +D (04): 10, 10, 10 @ overworld + +====================================================================== +Tree View of machine nesting +====================================================================== +A from 01 (entangled - at 0,0,0 in overworld) + B from 02 (entered at 01, 40, 01) + C from 03 (entered at 26, 40, 26) + A from 06 (entangled - entered at 51, 40, 51) + +D from 04 (non-entangled, at 10, 10, 10 in overworld) + A from 05 (entangled, at 76, 40, 76 in compact_world) + +====================================================================== +Facts +====================================================================== +B is not entangled and inside A. +C is not entangled and inside B. +A is entangled, and inside C and D. +====================================================================== + +- P enters A from {0,0,0} (entry-1) +- P enters B from A. +- P enters C from B. +- P reenters A from C. + +====================================================================== +Deque status at end of entering A (06) - player_entry_history +====================================================================== +tail DimPos { 51, 40, 51 @ compact_world } (entered A from C) +- DimPos { 26, 40, 26 @ compact_world } (entered C from B) +- DimPos { 01, 40, 01 @ compact_world } (entered B from A) +head DimPos { 00, 00, 00 @ overworld } (entered A) + +Player P is represented as "inside" A, B, and C. +Re-entering machine A does not add a second entry to the list. + +====================================================================== +Deque status at end of entering A (05) - player_entry_history +====================================================================== +tail DimPos { 79, 40, 76 @ compact_world } (entered A from D) +head DimPos { 10, 00, 10 @ overworld } (entered D) + +Player P is represented as "inside" A, B, C, and D. + B and C are included because A is inside C, and the tree was traversed upwards. \ No newline at end of file diff --git a/src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java b/src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java new file mode 100644 index 00000000..55a4a3f2 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java @@ -0,0 +1,167 @@ +package com.robotgryphon.compactmachines.data.world; + +import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.core.Registration; +import com.robotgryphon.compactmachines.data.codec.NbtListCollector; +import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import net.minecraft.nbt.CompoundNBT; +import net.minecraft.nbt.ListNBT; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.world.server.ServerWorld; +import net.minecraft.world.storage.DimensionSavedDataManager; +import net.minecraft.world.storage.WorldSavedData; +import net.minecraftforge.common.util.Constants; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.util.*; +import java.util.stream.Collectors; + +/** + * Holds information on the external points of a machine, ie the actual machine blocks. + */ +public class ExternalMachineData extends WorldSavedData { + + /** + * File storage name. + */ + public final static String DATA_NAME = "machines_external"; + + /** + * Used for performing reverse lookups on which machine internals are mapped + * to their external points. Effectively a cache for machineMapping. + */ + public Map> reverseMappingCache; + + /** + * Maps an external machine point to an internal machine chunk position. + * The inside of a machine may have multiple points accessing it in the future, + * due to advanced tunnels and fancier integrations. + */ + public Map machineMapping; + + /** + * Specifies locations of machines in-world, outside of the compact world. + * This is used for things like spawn lookups, tunnel handling, and forced ejections. + */ + public Map machineLocations; + + public ExternalMachineData() { + super(DATA_NAME); + machineMapping = new HashMap<>(); + machineLocations = new HashMap<>(); + reverseMappingCache = new HashMap<>(); + } + + @Nullable + public static ExternalMachineData get(MinecraftServer server) { + ServerWorld compactWorld = server.getLevel(Registration.COMPACT_DIMENSION); + if (compactWorld == null) { + CompactMachines.LOGGER.error("No compact dimension found. Report this."); + return null; + } + + DimensionSavedDataManager sd = compactWorld.getDataStorage(); + return sd.computeIfAbsent(ExternalMachineData::new, DATA_NAME); + } + + @Override + public void load(CompoundNBT nbt) { + if(nbt.contains("mapping")) { + ListNBT mapping = nbt.getList("mapping", Constants.NBT.TAG_COMPOUND); + mapping.forEach(map -> { + CompoundNBT mapEntry = (CompoundNBT) map; + ChunkPos cp = new ChunkPos( + mapEntry.getInt("chunkX"), + mapEntry.getInt("chunkZ") + ); + + int id = mapEntry.getInt("id"); + + // add to reverse lookup mapping + machineMapping.put(id, cp); + reverseMappingCache.putIfAbsent(cp, new HashSet<>()); + reverseMappingCache.get(cp).add(id); + }); + } + + if(nbt.contains("locations")) { + ListNBT nbtLocations = nbt.getList("locations", Constants.NBT.TAG_COMPOUND); + nbtLocations.forEach(nbtLoc -> { + CompoundNBT loc = (CompoundNBT) nbtLoc; + int machine = loc.getInt("machine"); + CompoundNBT locationNbt = loc.getCompound("location"); + DimensionalPosition dimLoc = DimensionalPosition.fromNBT(locationNbt); + + machineLocations.put(machine, dimLoc); + }); + } + } + + @Override + @Nonnull + public CompoundNBT save(@Nonnull CompoundNBT nbt) { + if(!machineMapping.isEmpty()) { + ListNBT list = machineMapping.entrySet() + .stream() + .map((i) -> { + ChunkPos cPos = i.getValue(); + CompoundNBT entry = new CompoundNBT(); + { + entry.putInt("id", i.getKey()); + entry.putInt("chunkX", cPos.x); + entry.putInt("chunkZ", cPos.z); + } + + return entry; + }).collect(NbtListCollector.toNbtList()); + + nbt.put("mapping", list); + } + + if(!machineLocations.isEmpty()) { + ListNBT nbtLocations = machineLocations.entrySet().stream() + .map(l -> { + int machine = l.getKey(); + DimensionalPosition location = l.getValue(); + + CompoundNBT entry = new CompoundNBT(); + { + entry.putInt("machine", machine); + entry.put("location", location.serializeNBT()); + } + + return entry; + }).collect(NbtListCollector.toNbtList()); + + nbt.put("locations", nbtLocations); + } + + return nbt; + } + + public Set getExternalMachineIDs(ChunkPos internal) { + if(!reverseMappingCache.containsKey(internal)) { + // If we hit this, we have an internal position that somehow didn't map to the external points + rebuildReverseMapCache(internal); + } + + return reverseMappingCache.get(internal); + } + + private void rebuildReverseMapCache(ChunkPos internal) { + // Rebuild the cache here + Set remapped = machineMapping + .entrySet().stream() + .filter(e -> e.getValue().equals(internal)) + .map(Map.Entry::getKey) + .collect(Collectors.toSet()); + + reverseMappingCache.put(internal, remapped); + } + + public Optional getChunkLocation(int machineId) { + return Optional.ofNullable(machineMapping.get(machineId)); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/world/InternalMachineData.java b/src/main/java/com/robotgryphon/compactmachines/data/world/InternalMachineData.java new file mode 100644 index 00000000..c9fca378 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/world/InternalMachineData.java @@ -0,0 +1,84 @@ +package com.robotgryphon.compactmachines.data.world; + +import com.mojang.serialization.DataResult; +import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.core.Registration; +import com.robotgryphon.compactmachines.data.codec.NbtListCollector; +import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; +import net.minecraft.nbt.CompoundNBT; +import net.minecraft.nbt.INBT; +import net.minecraft.nbt.ListNBT; +import net.minecraft.nbt.NBTDynamicOps; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.world.server.ServerWorld; +import net.minecraft.world.storage.DimensionSavedDataManager; +import net.minecraft.world.storage.WorldSavedData; +import net.minecraftforge.common.util.Constants; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +public class InternalMachineData extends WorldSavedData { + public static final String DATA_NAME = "machines_internal"; + + public Map machineData; + + public InternalMachineData() { + super(DATA_NAME); + machineData = new HashMap<>(); + } + + @Nullable + public static InternalMachineData get(MinecraftServer server) { + ServerWorld compactWorld = server.getLevel(Registration.COMPACT_DIMENSION); + if (compactWorld == null) { + CompactMachines.LOGGER.error("No compact dimension found. Report this."); + return null; + } + + DimensionSavedDataManager sd = compactWorld.getDataStorage(); + return sd.computeIfAbsent(InternalMachineData::new, DATA_NAME); + } + + @Override + public void load(CompoundNBT nbt) { + if (nbt.contains("machines")) { + ListNBT machines = nbt.getList("machines", Constants.NBT.TAG_COMPOUND); + machines.forEach(machNbt -> { + DataResult result = + CompactMachineInternalData.CODEC.parse(NBTDynamicOps.INSTANCE, machNbt); + + result + .resultOrPartial((err) -> CompactMachines.LOGGER.error("Error loading machine data from file: {}", err)) + .ifPresent(imd -> { + ChunkPos chunk = new ChunkPos(imd.getCenter()); + this.machineData.put(chunk, imd); + }); + }); + } + } + + @Override + @Nonnull + public CompoundNBT save(@Nonnull CompoundNBT nbt) { + if (!machineData.isEmpty()) { + ListNBT collect = machineData.values() + .stream() + .map(data -> { + DataResult n = CompactMachineInternalData.CODEC.encodeStart(NBTDynamicOps.INSTANCE, data); + return n.result(); + }) + .filter(Optional::isPresent) + .map(Optional::get) + .collect(NbtListCollector.toNbtList()); + + nbt.put("machines", collect); + } + + return nbt; + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java b/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java index 7a026f25..23c891fa 100644 --- a/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java +++ b/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java @@ -2,10 +2,7 @@ import com.robotgryphon.compactmachines.config.EnableVanillaRecipesConfigCondition; import com.robotgryphon.compactmachines.core.Registration; -import net.minecraft.data.DataGenerator; -import net.minecraft.data.IFinishedRecipe; -import net.minecraft.data.RecipeProvider; -import net.minecraft.data.ShapedRecipeBuilder; +import net.minecraft.data.*; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.item.Items; @@ -30,7 +27,7 @@ protected void buildShapelessRecipes(Consumer consumer) { .pattern(" I ") .define('R', Tags.Items.DUSTS_REDSTONE) .define('I', Tags.Items.STORAGE_BLOCKS_IRON) - .unlockedBy("has_recipe", has(Tags.Items.STORAGE_BLOCKS_IRON)) + .unlockedBy("picked_up_iron", has(Tags.Items.STORAGE_BLOCKS_IRON)) .save(consumer); ShapedRecipeBuilder.shaped(Registration.PERSONAL_SHRINKING_DEVICE.get()) @@ -41,9 +38,18 @@ protected void buildShapelessRecipes(Consumer consumer) { .define('E', Items.ENDER_EYE) .define('B', Items.BOOK) .define('I', Tags.Items.INGOTS_IRON) - .unlockedBy("has_recipe", has(Items.ENDER_EYE)) + .unlockedBy("picked_up_ender_eye", has(Items.ENDER_EYE)) .save(consumer); + addTunnelRecipes(consumer); + addMachineRecipes(consumer); + } + + private void addTunnelRecipes(Consumer consumer) { + // todo + } + + private void addMachineRecipes(Consumer consumer) { registerMachineRecipe(consumer, Registration.MACHINE_BLOCK_ITEM_TINY.get(), ItemTags.PLANKS); registerMachineRecipe(consumer, Registration.MACHINE_BLOCK_ITEM_SMALL.get(), Tags.Items.STORAGE_BLOCKS_IRON); registerMachineRecipe(consumer, Registration.MACHINE_BLOCK_ITEM_NORMAL.get(), Tags.Items.STORAGE_BLOCKS_GOLD); diff --git a/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java b/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java index 05b43542..c2d22960 100644 --- a/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java +++ b/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java @@ -3,9 +3,9 @@ import com.google.common.collect.ImmutableSet; import com.robotgryphon.compactmachines.CompactMachines; import com.robotgryphon.compactmachines.client.machine.MachinePlayerEventHandler; -import com.robotgryphon.compactmachines.data.CompactMachineServerData; -import com.robotgryphon.compactmachines.data.SavedMachineData; -import com.robotgryphon.compactmachines.data.machines.CompactMachineRegistrationData; +import com.robotgryphon.compactmachines.data.legacy.CompactMachineServerData; +import com.robotgryphon.compactmachines.data.legacy.SavedMachineData; +import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; import net.minecraft.network.PacketBuffer; import net.minecraft.server.MinecraftServer; diff --git a/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java b/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java index e91ddecc..31c089f0 100644 --- a/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java +++ b/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java @@ -1,7 +1,13 @@ package com.robotgryphon.compactmachines.teleportation; -import com.robotgryphon.compactmachines.data.NbtDataUtil; +import com.mojang.serialization.Codec; +import com.mojang.serialization.DataResult; +import com.mojang.serialization.codecs.RecordCodecBuilder; +import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.data.codec.CodecExtensions; import net.minecraft.nbt.CompoundNBT; +import net.minecraft.nbt.INBT; +import net.minecraft.nbt.NBTDynamicOps; import net.minecraft.server.MinecraftServer; import net.minecraft.util.RegistryKey; import net.minecraft.util.ResourceLocation; @@ -20,8 +26,18 @@ public class DimensionalPosition implements INBTSerializable { private RegistryKey dimension; private Vector3d position; + public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( + Codec.STRING.fieldOf("dim").forGetter(DimensionalPosition::getDimensionString), + CodecExtensions.VECTOR3D_CODEC.fieldOf("pos").forGetter(DimensionalPosition::getPosition) + ).apply(i, DimensionalPosition::new)); + private DimensionalPosition() { } + private DimensionalPosition(String dimKey, Vector3d pos) { + this.dimension = RegistryKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation(dimKey)); + this.position = pos; + } + public DimensionalPosition(RegistryKey dim, Vector3d pos) { this.dimension = dim; this.position = pos; @@ -45,32 +61,30 @@ public static DimensionalPosition fromNBT(CompoundNBT nbt) { @Override public CompoundNBT serializeNBT() { - CompoundNBT nbt = new CompoundNBT(); - nbt.putString("dim", dimension.location().toString()); - CompoundNBT posNbt = NbtDataUtil.writeVectorCompound(position); - nbt.put("pos", posNbt); - return nbt; + DataResult nbt = CODEC.encodeStart(NBTDynamicOps.INSTANCE, this); + return (CompoundNBT) nbt.result().orElse(null); } @Override public void deserializeNBT(CompoundNBT nbt) { - if(nbt.contains("dim")) - { - ResourceLocation dim = new ResourceLocation(nbt.getString("dim")); - this.dimension = RegistryKey.create(Registry.DIMENSION_REGISTRY, dim); - } - - if(nbt.contains("pos")) { - CompoundNBT bPosNbt = nbt.getCompound("pos"); - Vector3d bPos = NbtDataUtil.readVectorCompound(bPosNbt); - this.position = bPos; - } + Optional dimensionalPosition = CODEC + .parse(NBTDynamicOps.INSTANCE, nbt) + .resultOrPartial(CompactMachines.LOGGER::error); + + dimensionalPosition.ifPresent(dp -> { + this.dimension = dp.dimension; + this.position = dp.position; + }); } public RegistryKey getDimension() { return this.dimension; } + private String getDimensionString() { + return this.dimension.location().toString(); + } + public Vector3d getPosition() { return this.position; } diff --git a/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelHelper.java b/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelHelper.java index 10375035..70b0485f 100644 --- a/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelHelper.java +++ b/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelHelper.java @@ -6,19 +6,17 @@ import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; import com.robotgryphon.compactmachines.block.walls.TunnelWallBlock; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.CompactMachineServerData; -import com.robotgryphon.compactmachines.data.SavedMachineData; -import com.robotgryphon.compactmachines.data.machines.CompactMachineRegistrationData; +import com.robotgryphon.compactmachines.data.legacy.CompactMachineServerData; +import com.robotgryphon.compactmachines.data.legacy.SavedMachineData; +import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; import net.minecraft.block.BlockState; -import net.minecraft.server.MinecraftServer; import net.minecraft.util.Direction; import net.minecraft.util.RegistryKey; import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; import net.minecraft.world.IBlockReader; -import net.minecraft.world.IWorldReader; import net.minecraft.world.World; import net.minecraft.world.server.ServerWorld; import net.minecraftforge.fml.RegistryObject; diff --git a/src/main/java/com/robotgryphon/compactmachines/tunnels/definitions/RedstoneInTunnelDefinition.java b/src/main/java/com/robotgryphon/compactmachines/tunnels/definitions/RedstoneInTunnelDefinition.java index 57f9b67e..dd87c9a2 100644 --- a/src/main/java/com/robotgryphon/compactmachines/tunnels/definitions/RedstoneInTunnelDefinition.java +++ b/src/main/java/com/robotgryphon/compactmachines/tunnels/definitions/RedstoneInTunnelDefinition.java @@ -1,19 +1,11 @@ package com.robotgryphon.compactmachines.tunnels.definitions; -import com.robotgryphon.compactmachines.CompactMachines; import com.robotgryphon.compactmachines.api.tunnels.EnumTunnelSide; import com.robotgryphon.compactmachines.api.tunnels.ITunnelConnectionInfo; import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; -import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; -import com.robotgryphon.compactmachines.data.machines.CompactMachineRegistrationData; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; import com.robotgryphon.compactmachines.api.tunnels.redstone.IRedstoneReaderTunnel; import net.minecraft.block.BlockState; -import net.minecraft.server.MinecraftServer; -import net.minecraft.tileentity.TileEntity; -import net.minecraft.util.Direction; -import net.minecraft.util.math.BlockPos; -import net.minecraft.world.IBlockReader; import net.minecraft.world.IWorldReader; import net.minecraft.world.server.ServerWorld; diff --git a/src/main/java/com/robotgryphon/compactmachines/util/CompactMachinePlayerUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/CompactMachinePlayerUtil.java index 6013a47b..ca4d8f15 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/CompactMachinePlayerUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/CompactMachinePlayerUtil.java @@ -1,46 +1,65 @@ package com.robotgryphon.compactmachines.util; -import com.robotgryphon.compactmachines.data.CompactMachineServerData; -import com.robotgryphon.compactmachines.data.SavedMachineData; -import com.robotgryphon.compactmachines.data.machines.CompactMachinePlayerData; +import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; +import com.robotgryphon.compactmachines.data.legacy.CompactMachineServerData; +import com.robotgryphon.compactmachines.data.legacy.SavedMachineData; +import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; import com.robotgryphon.compactmachines.network.MachinePlayersChangedPacket; import com.robotgryphon.compactmachines.network.NetworkHandler; import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.server.MinecraftServer; import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.ChunkPos; import net.minecraftforge.fml.network.PacketDistributor; import java.util.Optional; public class CompactMachinePlayerUtil { - public static void addPlayerToMachine(ServerPlayerEntity serverPlayer, BlockPos machinePos, int machineId) { + public static void addPlayerToMachine(ServerPlayerEntity serverPlayer, BlockPos machinePos) { MinecraftServer serv = serverPlayer.getServer(); - SavedMachineData machineData = SavedMachineData.getInstance(serv); - CompactMachineServerData serverData = machineData.getData(); - Optional playerData = serverData.getPlayerData(machineId); + if (serv == null) + return; - playerData.ifPresent(d -> { - d.addPlayer(serverPlayer); - machineData.setDirty(); + CompactMachinePlayerData playerData = CompactMachinePlayerData.get(serv); + if (playerData == null) + return; - MachinePlayersChangedPacket p = new MachinePlayersChangedPacket(serv, machineId, serverPlayer.getUUID(), MachinePlayersChangedPacket.EnumPlayerChangeType.ENTERED); + CompactMachineTile tile = (CompactMachineTile) serverPlayer.getLevel().getBlockEntity(machinePos); + if(tile == null) + return; + + tile.getInternalChunkPos().ifPresent(mChunk -> { + + playerData.addPlayer(serverPlayer, mChunk); + playerData.setDirty(); + + MachinePlayersChangedPacket p = new MachinePlayersChangedPacket(serv, tile.machineId, serverPlayer.getUUID(), MachinePlayersChangedPacket.EnumPlayerChangeType.ENTERED); NetworkHandler.MAIN_CHANNEL.send( PacketDistributor.TRACKING_CHUNK.with(() -> serverPlayer.getLevel().getChunkAt(machinePos)), p); }); } - public static void removePlayerFromMachine(ServerPlayerEntity serverPlayer, BlockPos machinePos, int machineId) { + public static void removePlayerFromMachine(ServerPlayerEntity serverPlayer, BlockPos machinePos) { MinecraftServer serv = serverPlayer.getServer(); - SavedMachineData machineData = SavedMachineData.getInstance(serv); - CompactMachineServerData serverData = machineData.getData(); - Optional playerData = serverData.getPlayerData(machineId); - playerData.ifPresent(d -> { - d.removePlayer(serverPlayer); - machineData.setDirty(); + CompactMachinePlayerData playerData = CompactMachinePlayerData.get(serv); + if (playerData == null) + return; + + playerData.removePlayer(serverPlayer); + + CompactMachineTile tile = (CompactMachineTile) serverPlayer.getLevel().getBlockEntity(machinePos); + if(tile == null) + return; + + tile.getInternalChunkPos().ifPresent(mChunk -> { + + playerData.removePlayer(serverPlayer); + playerData.setDirty(); - MachinePlayersChangedPacket p = new MachinePlayersChangedPacket(serv, machineId, serverPlayer.getUUID(), MachinePlayersChangedPacket.EnumPlayerChangeType.EXITED); + MachinePlayersChangedPacket p = new MachinePlayersChangedPacket(serv, tile.machineId, serverPlayer.getUUID(), MachinePlayersChangedPacket.EnumPlayerChangeType.EXITED); NetworkHandler.MAIN_CHANNEL.send( PacketDistributor.TRACKING_CHUNK.with(() -> serverPlayer.getLevel().getChunkAt(machinePos)), p); diff --git a/src/main/java/com/robotgryphon/compactmachines/util/CompactMachineUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/CompactMachineUtil.java index 2332b05f..27c8efcc 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/CompactMachineUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/CompactMachineUtil.java @@ -4,16 +4,15 @@ import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; import com.robotgryphon.compactmachines.config.ServerConfig; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.CompactMachineServerData; -import com.robotgryphon.compactmachines.data.SavedMachineData; -import com.robotgryphon.compactmachines.data.machines.CompactMachineRegistrationData; +import com.robotgryphon.compactmachines.data.legacy.CompactMachineServerData; +import com.robotgryphon.compactmachines.data.legacy.SavedMachineData; +import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData; import com.robotgryphon.compactmachines.reference.EnumMachineSize; import net.minecraft.block.Block; import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.item.Item; import net.minecraft.nbt.CompoundNBT; import net.minecraft.server.MinecraftServer; -import net.minecraft.util.Direction; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.vector.Vector3d; import net.minecraft.util.math.vector.Vector3i; diff --git a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java index 5e4bc5fd..66d85111 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java @@ -2,15 +2,22 @@ import com.mojang.authlib.GameProfile; import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.data.CompactMachineServerData; -import com.robotgryphon.compactmachines.data.SavedMachineData; -import com.robotgryphon.compactmachines.data.machines.CompactMachinePlayerData; -import com.robotgryphon.compactmachines.data.machines.CompactMachineRegistrationData; +import com.robotgryphon.compactmachines.data.legacy.CompactMachineServerData; +import com.robotgryphon.compactmachines.data.legacy.SavedMachineData; +import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; +import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData; +import com.robotgryphon.compactmachines.data.world.ExternalMachineData; +import com.robotgryphon.compactmachines.data.world.InternalMachineData; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import net.minecraft.client.Minecraft; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.entity.player.ServerPlayerEntity; +import net.minecraft.server.MinecraftServer; import net.minecraft.util.RegistryKey; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.ChunkPos; import net.minecraft.util.math.vector.Vector3d; +import net.minecraft.util.text.ChatType; import net.minecraft.util.text.TranslationTextComponent; import net.minecraft.world.IWorld; import net.minecraft.world.World; @@ -38,46 +45,65 @@ public static DimensionalPosition getPlayerDimensionalPosition(PlayerEntity play public static void teleportPlayerOutOfMachine(ServerWorld world, ServerPlayerEntity serverPlayer) { - SavedMachineData machineData = SavedMachineData.getInstance(world.getServer()); - CompactMachineServerData serverData = machineData.getData(); - - Optional machine = serverData.getMachineContainingPosition(serverPlayer.position()); + MinecraftServer serv = world.getServer(); + CompactMachinePlayerData playerData = CompactMachinePlayerData.get(serv); + if (playerData == null) + return; - if (!machine.isPresent()) { + Optional externalSpawn = playerData.getExternalSpawn(serverPlayer); + if (!externalSpawn.isPresent()) { serverPlayer.displayClientMessage( - new TranslationTextComponent("not_inside_machine"), - true); + new TranslationTextComponent("messages.%s.how_did_you_get_here", CompactMachines.MOD_ID), + true + ); return; } - CompactMachineRegistrationData machineInfo = machine.get(); + ChunkPos currentMachine = new ChunkPos(serverPlayer.blockPosition()); - Optional machinePlayers = serverData.getPlayerData(machineInfo.getId()); - if (!machinePlayers.isPresent()) { - // No player data for machine, wut - CompactMachines.LOGGER.warn("Warning: Machine player data not set but machine registered, and player is inside. Machine ID: {}", machineInfo.getId()); - serverPlayer.displayClientMessage(new TranslationTextComponent("ah_crap"), true); - return; - } + DimensionalPosition spawnPoint = externalSpawn.get(); - Optional lastPos = machinePlayers.get().getExternalSpawn(serverPlayer); - if (!lastPos.isPresent()) { - // PANIC + Optional outsideWorld = spawnPoint.getWorld(world.getServer()); + outsideWorld.ifPresent(w -> { + Vector3d worldPos = spawnPoint.getPosition(); + serverPlayer.teleportTo(w, worldPos.x(), worldPos.y(), worldPos.z(), serverPlayer.yRot, serverPlayer.xRot); - return; - } else { - DimensionalPosition p = lastPos.get(); - Vector3d bp = p.getPosition(); - Optional outsideWorld = p.getWorld(world.getServer()); - outsideWorld.ifPresent(w -> { - machine.ifPresent(m -> { - serverPlayer.teleportTo(w, bp.x(), bp.y(), bp.z(), serverPlayer.yRot, serverPlayer.xRot); - CompactMachinePlayerUtil.removePlayerFromMachine(serverPlayer, - machineInfo.getOutsidePosition(serverPlayer.getServer()).getBlockPosition(), - m.getId()); - }); - }); - } + // CompactMachinePlayerUtil.removePlayerFromMachine(serverPlayer, MACHINE_POS); + // TODO - Networking for player leaving machine +// machine.ifPresent(m -> { +// CompactMachinePlayerUtil.removePlayerFromMachine(serverPlayer, +// machineInfo.getOutsidePosition(serverPlayer.getServer()).getBlockPosition(), +// m.getId()); +// }); + }); + + // TODO +// Optional machinePlayers = serverData.getPlayerData(machineInfo.getId()); +// if (!machinePlayers.isPresent()) { +// // No player data for machine, wut +// CompactMachines.LOGGER.warn("Warning: Machine player data not set but machine registered, and player is inside. Machine ID: {}", machineInfo.getId()); +// serverPlayer.displayClientMessage(new TranslationTextComponent("ah_crap"), true); +// return; +// } +// +// Optional lastPos = machinePlayers.get().getExternalSpawn(serverPlayer); +// if (!lastPos.isPresent()) { +// // PANIC +// +// return; +// } else { +// DimensionalPosition p = lastPos.get(); +// Vector3d bp = p.getPosition(); +// Optional outsideWorld = p.getWorld(world.getServer()); +// outsideWorld.ifPresent(w -> { +// machine.ifPresent(m -> { +// serverPlayer.teleportTo(w, bp.x(), bp.y(), bp.z(), serverPlayer.yRot, serverPlayer.xRot); +// CompactMachinePlayerUtil.removePlayerFromMachine(serverPlayer, +// machineInfo.getOutsidePosition(serverPlayer.getServer()).getBlockPosition(), +// m.getId()); +// }); +// }); +// } } } diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java b/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java index fbea9e53..631c8a17 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java +++ b/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java @@ -1,23 +1,10 @@ package com.robotgryphon.compactmachines.tests.minecraft; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.SavedMachineData; -import net.minecraft.block.Block; +import com.robotgryphon.compactmachines.data.legacy.SavedMachineDataMigrator; import net.minecraft.server.MinecraftServer; -import net.minecraft.util.ResourceLocation; -import net.minecraft.world.storage.DimensionSavedDataManager; -import net.minecraft.world.storage.WorldSavedData; -import net.minecraftforge.fml.common.ObfuscationReflectionHelper; -import net.minecraftforge.fml.network.FMLNetworkConstants; import net.minecraftforge.fml.server.ServerLifecycleHooks; -import net.minecraftforge.registries.ForgeRegistries; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; -import java.io.File; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; - public class ExampleTest { @Test @@ -25,31 +12,8 @@ void CanDoBasicTest() { MinecraftServer serv = ServerLifecycleHooks.getCurrentServer(); // SavedMachineData sd = SavedMachineData.getInstance(serv); - DimensionSavedDataManager ds = serv - .getLevel(Registration.COMPACT_DIMENSION) - .getDataStorage(); - - SavedMachineData found = ds.get(SavedMachineData::new, SavedMachineData.DATA_NAME); - if(found != null) { - // Assertions.assertNotNull(sd); - Method getDataFile = ObfuscationReflectionHelper.findMethod( - DimensionSavedDataManager.class, - "func_215754_a", - String.class); + SavedMachineDataMigrator.migrate(serv); + } - try { - File i = (File) getDataFile.invoke(ds, found.getId()); - System.out.println(i.getAbsolutePath()); - i.delete(); - } catch (IllegalAccessException e) { - e.printStackTrace(); - } catch (InvocationTargetException e) { - e.printStackTrace(); - } - } else { - // File not found - Assertions.assertTrue(true); - } - } } From 04088f498cb74f6e568fa8834def19618d16de73 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Thu, 22 Apr 2021 19:21:36 -0400 Subject: [PATCH 03/36] More work on machine graph --- build.gradle | 5 +- .../data/graph/CompactMachineInsideNode.java | 45 ++++ .../data/graph/CompactMachineNode.java | 58 +++++ .../data/graph/IMachineGraphNode.java | 6 + .../data/graph/MachineExternalLocation.java | 6 + .../compactmachines/data/player/theory.txt | 14 +- .../datagen/RecipeGenerator.java | 3 + .../util/CompactMachineUtil.java | 2 +- .../compactmachines/tests/GraphTests.java | 216 ++++++++++++++++++ .../tests/minecraft/ExampleTest.java | 2 + 10 files changed, 348 insertions(+), 9 deletions(-) create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineInsideNode.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineNode.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/graph/IMachineGraphNode.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/graph/MachineExternalLocation.java create mode 100644 src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java diff --git a/build.gradle b/build.gradle index 817602a6..412d712b 100644 --- a/build.gradle +++ b/build.gradle @@ -262,8 +262,7 @@ publishing { } test { - useJUnitPlatform() - filter { - exclude "com/robotgryphon/compactmachines/tests/minecraft/**" + useJUnitPlatform { + excludeTags "minecraft" } } diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineInsideNode.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineInsideNode.java new file mode 100644 index 00000000..5143af93 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineInsideNode.java @@ -0,0 +1,45 @@ +package com.robotgryphon.compactmachines.data.graph; + +import net.minecraft.util.math.ChunkPos; + +import java.util.Objects; + +/** + * Represents the inside of a Compact Machine. + */ +public class CompactMachineInsideNode implements IMachineGraphNode { + + private final ChunkPos pos; + + public CompactMachineInsideNode(ChunkPos pos) { + this.pos = pos; + } + + @Override + public String getId() { + return getIdFor(this.pos); + } + + @Override + public String label() { + return String.format("Compact Machine {%s,%s}", pos.x, pos.z); + } + + public static String getIdFor(ChunkPos pos) { + long v = pos.toLong(); + return "internal_" + (v < 0 ? "N" : "") + Math.abs(v); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + CompactMachineInsideNode that = (CompactMachineInsideNode) o; + return pos.equals(that.pos); + } + + @Override + public int hashCode() { + return Objects.hash(pos); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineNode.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineNode.java new file mode 100644 index 00000000..02880d67 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineNode.java @@ -0,0 +1,58 @@ +package com.robotgryphon.compactmachines.data.graph; + +import com.google.common.graph.MutableGraph; +import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; + +import java.util.Objects; + +/** + * Represents a machine's external point. This can be either inside a machine or in a dimension somewhere. + */ +public class CompactMachineNode implements IMachineGraphNode { + public boolean isConnected; + private int machineId; + private IMachineGraphNode linkedTo; + public MachineExternalLocation location; + public DimensionalPosition position; + private MutableGraph graph; + + public CompactMachineNode(MutableGraph graph, int machine) { + this.graph = graph; + this.machineId = machine; + this.isConnected = false; + } + + public void connectTo(IMachineGraphNode newInside) { + if (this.linkedTo != null) { + graph.removeEdge(this, linkedTo); + this.isConnected = false; + } + + this.linkedTo = newInside; + this.isConnected = true; + graph.putEdge(this, linkedTo); + } + + @Override + public String label() { + return "Compact Machine #" + machineId; + } + + @Override + public String getId() { + return "machine" + machineId; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + CompactMachineNode that = (CompactMachineNode) o; + return machineId == that.machineId; + } + + @Override + public int hashCode() { + return Objects.hash(machineId); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/IMachineGraphNode.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/IMachineGraphNode.java new file mode 100644 index 00000000..fbfc2dee --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/graph/IMachineGraphNode.java @@ -0,0 +1,6 @@ +package com.robotgryphon.compactmachines.data.graph; + +public interface IMachineGraphNode { + String label(); + String getId(); +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/MachineExternalLocation.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/MachineExternalLocation.java new file mode 100644 index 00000000..7b6b1f5e --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/graph/MachineExternalLocation.java @@ -0,0 +1,6 @@ +package com.robotgryphon.compactmachines.data.graph; + +public enum MachineExternalLocation { + INSIDE_MACHINE, + EXTERNAL_DIMENSION +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/player/theory.txt b/src/main/java/com/robotgryphon/compactmachines/data/player/theory.txt index 21061312..3c9fd54e 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/player/theory.txt +++ b/src/main/java/com/robotgryphon/compactmachines/data/player/theory.txt @@ -5,11 +5,11 @@ Machines A,B,C,D machine locations (external) ====================================================================== A (01): 00, 00, 00 @ overworld -A (05): 76, 40, 76 @ compact_world -A (06): 51, 40, 51 @ compact_world -B (02): 26, 40, 26 @ compact_world -C (03): 51, 40, 51 @ compact_world +B (02): 26, 40, 26 @ compact_world (inside A) +C (03): 51, 40, 51 @ compact_world (inside B) D (04): 10, 10, 10 @ overworld +A (05): 76, 40, 76 @ compact_world (inside D) +A (06): 51, 40, 51 @ compact_world (inside C) ====================================================================== Tree View of machine nesting @@ -53,4 +53,8 @@ tail DimPos { 79, 40, 76 @ compact_world } (entered A from D) head DimPos { 10, 00, 10 @ overworld } (entered D) Player P is represented as "inside" A, B, C, and D. - B and C are included because A is inside C, and the tree was traversed upwards. \ No newline at end of file + B and C are included because A is inside C, and the tree was traversed upwards. + + + + diff --git a/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java b/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java index 23c891fa..44b3eda2 100644 --- a/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java +++ b/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java @@ -47,6 +47,9 @@ protected void buildShapelessRecipes(Consumer consumer) { private void addTunnelRecipes(Consumer consumer) { // todo + + ShapelessRecipeBuilder.shapeless() + } private void addMachineRecipes(Consumer consumer) { diff --git a/src/main/java/com/robotgryphon/compactmachines/util/CompactMachineUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/CompactMachineUtil.java index 27c8efcc..3eb737d3 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/CompactMachineUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/CompactMachineUtil.java @@ -94,7 +94,7 @@ public static void teleportInto(ServerPlayerEntity serverPlayer, BlockPos machin try { // Mark the player as inside the machine, set external spawn, and yeet - CompactMachinePlayerUtil.addPlayerToMachine(serverPlayer, machinePos, tile.machineId); + CompactMachinePlayerUtil.addPlayerToMachine(serverPlayer, machinePos); } catch (Exception ex) { CompactMachines.LOGGER.error(ex); } diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java b/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java new file mode 100644 index 00000000..00f72364 --- /dev/null +++ b/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java @@ -0,0 +1,216 @@ +package com.robotgryphon.compactmachines.tests; + +import com.google.common.graph.*; +import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.data.graph.CompactMachineInsideNode; +import com.robotgryphon.compactmachines.data.graph.CompactMachineNode; +import com.robotgryphon.compactmachines.data.graph.IMachineGraphNode; +import com.robotgryphon.compactmachines.data.graph.MachineExternalLocation; +import com.robotgryphon.compactmachines.util.MathUtil; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.util.math.vector.Vector3i; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.io.FileNotFoundException; +import java.io.PrintWriter; +import java.util.*; +import java.util.stream.Collectors; + +@SuppressWarnings("UnstableApiUsage") +public class GraphTests { + + @Test + void canCreateBasicGraph() { + MutableGraph g = GraphBuilder + .directed() + .nodeOrder(ElementOrder.sorted(Comparator.comparing(IMachineGraphNode::getId))) + .build(); + + HashMap lookup = new HashMap<>(); + + generateData(g, lookup); + + String w = write(g); + + try (PrintWriter pw = new PrintWriter("graph.dot")) { + pw.println(w); + } catch (FileNotFoundException e) { + e.printStackTrace(); + } + + Assertions.assertTrue(true); + } + + private void generateData(MutableGraph g, HashMap lookup) { + Random r = new Random(); + MachineExternalLocation[] values = MachineExternalLocation.values(); + int numInsides = 0; + int numOutsides = 0; + + Set disconnected = new HashSet<>(); + List externals = new ArrayList<>(); + List internals = new ArrayList<>(); + + // Seed a couple of machines and insides so they're always there + for(int i = 0; i < 10; i++) { + ChunkPos machineChunk = getMachineChunkPos(numInsides + 1); + CompactMachineNode extern = createMachineExternalNode(g, lookup, i); + CompactMachineInsideNode intern = createMachineInternalNode(g, lookup, machineChunk); + + externals.add(extern); + internals.add(intern); + + extern.connectTo(intern); + numOutsides++; + numInsides++; + } + + for(int i = 0; i < 50; i++) { + + if(r.nextBoolean()) { + // Creating the outside of a machine + MachineExternalLocation loc = values[r.nextInt(values.length)]; + + CompactMachineNode machine = createMachineExternalNode(g, lookup, numOutsides + 1); + externals.add(machine); + + switch (loc) { + case EXTERNAL_DIMENSION: + int randomMachineInsideE = r.nextInt(internals.size()); + CompactMachineInsideNode miE = internals.get(randomMachineInsideE); + machine.connectTo(miE); + + // try to remove from disconnected if it exists there + disconnected.remove(miE); + break; + + case INSIDE_MACHINE: + int randomMachineInsideI = r.nextInt(internals.size()); + CompactMachineInsideNode miI = internals.get(randomMachineInsideI); + + // Put the machine inside a randomly chosen existing machine + g.putEdge(miI, machine); + + boolean connectToAnother = r.nextBoolean(); + if(connectToAnother) { + System.out.println("connect"); + int randomMachine = r.nextInt(internals.size()); + CompactMachineInsideNode in = internals.get(randomMachine); + machine.connectTo(in); + } + break; + } + + numOutsides++; + } else { + // Creating the inside of a machine + ChunkPos machineChunk= getMachineChunkPos(numInsides + 1); + CompactMachineInsideNode mi = createMachineInternalNode(g, lookup, machineChunk); + disconnected.add(mi); + numInsides++; + } + } + + if(!disconnected.isEmpty()) { + for (IMachineGraphNode di : disconnected) { + CompactMachineNode machine = createMachineExternalNode(g, lookup, numOutsides + 1); + machine.connectTo(di); + numOutsides++; + } + } + + disconnected.clear(); + } + + private ChunkPos getMachineChunkPos(int i) { + Vector3i pos = MathUtil.getRegionPositionByIndex(i); + ChunkPos machineChunk = new ChunkPos(pos.getX(), pos.getZ()); + return machineChunk; + } + + private CompactMachineInsideNode createMachineInternalNode(MutableGraph g, HashMap lookup, ChunkPos id) { + CompactMachineInsideNode intern = new CompactMachineInsideNode(id); + g.addNode(intern); + lookup.put(intern.getId(), intern); + return intern; + } + + private CompactMachineNode createMachineExternalNode(MutableGraph g, HashMap lookup, int id) { + CompactMachineNode extern = new CompactMachineNode(g, id); + g.addNode(extern); + lookup.put(extern.getId(), extern); + return extern; + } + + public static String write(final Graph graph) { + StringBuilder sb = new StringBuilder(); + sb + .append("strict digraph G {") + .append(System.lineSeparator()) + .append("\tlayout = fdp;").append(System.lineSeparator()) + .append("\tnode [shape=square,style=filled,color=lightgray];").append(System.lineSeparator()); + + Set topLevelMachines = graph.nodes().stream() + .filter(n -> n instanceof CompactMachineNode) + .map(n -> (CompactMachineNode) n) + .filter(n -> graph.inDegree(n) == 0) + .collect(Collectors.toSet()); + + for (CompactMachineNode n : topLevelMachines) + outputExternalNode(sb, n); + + graph.nodes().stream() + .filter(n -> n instanceof CompactMachineInsideNode) + .map(n -> (CompactMachineInsideNode) n) + .forEach(n -> { + outputMachineInside(graph, sb, n); + }); + + sb.append("}"); + return sb.toString(); + } + + private static void outputMachineInside(Graph graph, StringBuilder sb, IMachineGraphNode inside) { + if (inside instanceof CompactMachineInsideNode) { + CompactMachineInsideNode min = (CompactMachineInsideNode) inside; + + String insideClusterName = "cluster_" + min.getId(); + graph.predecessors(min).forEach(incoming -> { + sb.append("\t") + .append(incoming.getId()) + .append("->") + .append(insideClusterName) + .append(System.lineSeparator()); + }); + + sb.append("\t") + .append("subgraph ").append(insideClusterName) + .append(" {") + .append(System.lineSeparator()); + + sb.append("\t\t") + .append(String.format("graph [label=\"%s\",style=filled,color=cadetblue]", min.label())) + .append(System.lineSeparator()); + + graph.successors(min).forEach(insideNode -> { + if(insideNode instanceof CompactMachineNode) { + CompactMachineNode men = (CompactMachineNode) insideNode; + outputExternalNode(sb, men); + } + }); + + sb.append("\t") + .append("}").append(System.lineSeparator()) + .append(System.lineSeparator()); + } + } + + private static void outputExternalNode(StringBuilder sb, CompactMachineNode men) { + boolean connected = men.isConnected; + sb.append("\t") + .append(men.getId()) + .append(String.format(" [label=\"%s\",style=filled,color=%s]", men.label(), men.isConnected ? "lightgray" : "palevioletred1")) + .append(System.lineSeparator()); + } +} diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java b/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java index 631c8a17..be0bb9f1 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java +++ b/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java @@ -3,11 +3,13 @@ import com.robotgryphon.compactmachines.data.legacy.SavedMachineDataMigrator; import net.minecraft.server.MinecraftServer; import net.minecraftforge.fml.server.ServerLifecycleHooks; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; public class ExampleTest { @Test + @Tag("minecraft") void CanDoBasicTest() { MinecraftServer serv = ServerLifecycleHooks.getCurrentServer(); // SavedMachineData sd = SavedMachineData.getInstance(serv); From 3fd630b628561f8691813dfb24eb289039e0cd0b Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Thu, 22 Apr 2021 20:33:30 -0400 Subject: [PATCH 04/36] Remove WIP tunnel generation (in another branch) --- .../compactmachines/datagen/RecipeGenerator.java | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java b/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java index 44b3eda2..0c36937f 100644 --- a/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java +++ b/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java @@ -40,18 +40,10 @@ protected void buildShapelessRecipes(Consumer consumer) { .define('I', Tags.Items.INGOTS_IRON) .unlockedBy("picked_up_ender_eye", has(Items.ENDER_EYE)) .save(consumer); - - addTunnelRecipes(consumer); + addMachineRecipes(consumer); } - private void addTunnelRecipes(Consumer consumer) { - // todo - - ShapelessRecipeBuilder.shapeless() - - } - private void addMachineRecipes(Consumer consumer) { registerMachineRecipe(consumer, Registration.MACHINE_BLOCK_ITEM_TINY.get(), ItemTags.PLANKS); registerMachineRecipe(consumer, Registration.MACHINE_BLOCK_ITEM_SMALL.get(), Tags.Items.STORAGE_BLOCKS_IRON); From 348283650f628c3401e50f4927260dbaf4afdf13 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 24 Apr 2021 02:23:41 -0400 Subject: [PATCH 05/36] so many changes --- graph.dot | 257 ++++++++++++++++++ .../compactmachines/CompactMachines.java | 13 - .../compactmachines/api/core/Constants.java | 5 + .../compactmachines/api/core/Messages.java | 10 + .../compactmachines/api/core/Tooltips.java | 25 ++ .../block/BlockCompactMachine.java | 89 +++++- .../block/tiles/CompactMachineTile.java | 51 +++- .../block/tiles/TunnelWallTile.java | 128 +++++---- .../providers/CompactMachineProvider.java | 28 +- .../compactmachines/core/ModBusEvents.java | 27 ++ .../data/legacy/SavedMachineDataMigrator.java | 13 +- .../machine/CompactMachineInternalData.java | 14 + .../data/world/ExternalMachineData.java | 15 + .../data/world/InternalMachineData.java | 23 +- .../datagen/RecipeGenerator.java | 2 +- .../item/ItemBlockMachine.java | 98 ++++--- .../compactmachines/item/ItemBlockWall.java | 18 +- .../item/ItemPersonalShrinkingDevice.java | 47 ++-- .../compactmachines/item/TunnelItem.java | 6 + .../reference/EnumMachineSize.java | 7 + .../TeleportationEventHandler.java | 86 ++++-- .../tunnels/TunnelConnectionInfo.java | 6 +- .../util/CompactMachinePlayerUtil.java | 68 ----- .../util/CompactMachineUtil.java | 232 ---------------- .../compactmachines/util/PlayerUtil.java | 170 +++++++++++- .../compactmachines/util/TranslationUtil.java | 32 +++ .../assets/compactmachines/lang/en_us.json | 22 +- 27 files changed, 987 insertions(+), 505 deletions(-) create mode 100644 graph.dot create mode 100644 src/main/java/com/robotgryphon/compactmachines/api/core/Constants.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/api/core/Messages.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/api/core/Tooltips.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/core/ModBusEvents.java delete mode 100644 src/main/java/com/robotgryphon/compactmachines/util/CompactMachinePlayerUtil.java delete mode 100644 src/main/java/com/robotgryphon/compactmachines/util/CompactMachineUtil.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/util/TranslationUtil.java diff --git a/graph.dot b/graph.dot new file mode 100644 index 00000000..d2dd2659 --- /dev/null +++ b/graph.dot @@ -0,0 +1,257 @@ +strict digraph G { + layout = fdp; + node [shape=square,style=filled,color=lightgray]; + machine0 [label="Compact Machine #0",style=filled,color=lightgray] + machine1 [label="Compact Machine #1",style=filled,color=lightgray] + machine2 [label="Compact Machine #2",style=filled,color=lightgray] + machine3 [label="Compact Machine #3",style=filled,color=lightgray] + machine4 [label="Compact Machine #4",style=filled,color=lightgray] + machine5 [label="Compact Machine #5",style=filled,color=lightgray] + machine6 [label="Compact Machine #6",style=filled,color=lightgray] + machine7 [label="Compact Machine #7",style=filled,color=lightgray] + machine8 [label="Compact Machine #8",style=filled,color=lightgray] + machine9 [label="Compact Machine #9",style=filled,color=lightgray] + machine12 [label="Compact Machine #12",style=filled,color=lightgray] + machine13 [label="Compact Machine #13",style=filled,color=lightgray] + machine14 [label="Compact Machine #14",style=filled,color=lightgray] + machine15 [label="Compact Machine #15",style=filled,color=lightgray] + machine18 [label="Compact Machine #18",style=filled,color=lightgray] + machine20 [label="Compact Machine #20",style=filled,color=lightgray] + machine26 [label="Compact Machine #26",style=filled,color=lightgray] + machine27 [label="Compact Machine #27",style=filled,color=lightgray] + machine28 [label="Compact Machine #28",style=filled,color=lightgray] + machine29 [label="Compact Machine #29",style=filled,color=lightgray] + machine30 [label="Compact Machine #30",style=filled,color=lightgray] + machine31 [label="Compact Machine #31",style=filled,color=lightgray] + machine32 [label="Compact Machine #32",style=filled,color=lightgray] + machine33 [label="Compact Machine #33",style=filled,color=lightgray] + machine36 [label="Compact Machine #36",style=filled,color=lightgray] + machine37 [label="Compact Machine #37",style=filled,color=lightgray] + machine38 [label="Compact Machine #38",style=filled,color=lightgray] + machine39 [label="Compact Machine #39",style=filled,color=lightgray] + machine40 [label="Compact Machine #40",style=filled,color=lightgray] + machine41 [label="Compact Machine #41",style=filled,color=lightgray] + machine42 [label="Compact Machine #42",style=filled,color=lightgray] + machine43 [label="Compact Machine #43",style=filled,color=lightgray] + machine44 [label="Compact Machine #44",style=filled,color=lightgray] + machine45 [label="Compact Machine #45",style=filled,color=lightgray] + machine46 [label="Compact Machine #46",style=filled,color=lightgray] + machine47 [label="Compact Machine #47",style=filled,color=lightgray] + machine48 [label="Compact Machine #48",style=filled,color=lightgray] + machine49 [label="Compact Machine #49",style=filled,color=lightgray] + machine50 [label="Compact Machine #50",style=filled,color=lightgray] + machine51 [label="Compact Machine #51",style=filled,color=lightgray] + machine52 [label="Compact Machine #52",style=filled,color=lightgray] + machine53 [label="Compact Machine #53",style=filled,color=lightgray] + machine54 [label="Compact Machine #54",style=filled,color=lightgray] + machine55 [label="Compact Machine #55",style=filled,color=lightgray] + machine56 [label="Compact Machine #56",style=filled,color=lightgray] + machine57 [label="Compact Machine #57",style=filled,color=lightgray] + machine58 [label="Compact Machine #58",style=filled,color=lightgray] + machine59 [label="Compact Machine #59",style=filled,color=lightgray] + machine60 [label="Compact Machine #60",style=filled,color=lightgray] + machine13->cluster_internal_1 + machine2->cluster_internal_1 + machine20->cluster_internal_1 + subgraph cluster_internal_1 { + graph [label="Compact Machine {1,0}",style=filled,color=cadetblue] + } + + machine38->cluster_internal_12884901886 + subgraph cluster_internal_12884901886 { + graph [label="Compact Machine {-2,2}",style=filled,color=cadetblue] + } + + machine57->cluster_internal_12884901887 + subgraph cluster_internal_12884901887 { + graph [label="Compact Machine {-1,2}",style=filled,color=cadetblue] + } + + machine60->cluster_internal_12884901890 + subgraph cluster_internal_12884901890 { + graph [label="Compact Machine {2,3}",style=filled,color=cadetblue] + } + + machine47->cluster_internal_12884901891 + subgraph cluster_internal_12884901891 { + graph [label="Compact Machine {3,3}",style=filled,color=cadetblue] + } + + machine41->cluster_internal_2 + subgraph cluster_internal_2 { + graph [label="Compact Machine {2,0}",style=filled,color=cadetblue] + } + + machine56->cluster_internal_3 + subgraph cluster_internal_3 { + graph [label="Compact Machine {3,0}",style=filled,color=cadetblue] + } + + machine55->cluster_internal_4294967294 + subgraph cluster_internal_4294967294 { + graph [label="Compact Machine {-2,0}",style=filled,color=cadetblue] + } + + machine12->cluster_internal_4294967295 + machine6->cluster_internal_4294967295 + subgraph cluster_internal_4294967295 { + graph [label="Compact Machine {-1,0}",style=filled,color=cadetblue] + machine11 [label="Compact Machine #11",style=filled,color=lightgray] + machine21 [label="Compact Machine #21",style=filled,color=lightgray] + machine16 [label="Compact Machine #16",style=filled,color=palevioletred1] + } + + machine4->cluster_internal_4294967296 + subgraph cluster_internal_4294967296 { + graph [label="Compact Machine {0,1}",style=filled,color=cadetblue] + } + + machine33->cluster_internal_4294967297 + machine18->cluster_internal_4294967297 + machine3->cluster_internal_4294967297 + machine28->cluster_internal_4294967297 + machine29->cluster_internal_4294967297 + subgraph cluster_internal_4294967297 { + graph [label="Compact Machine {1,1}",style=filled,color=cadetblue] + machine35 [label="Compact Machine #35",style=filled,color=palevioletred1] + } + + machine46->cluster_internal_4294967298 + subgraph cluster_internal_4294967298 { + graph [label="Compact Machine {2,1}",style=filled,color=cadetblue] + } + + machine59->cluster_internal_4294967299 + subgraph cluster_internal_4294967299 { + graph [label="Compact Machine {3,1}",style=filled,color=cadetblue] + } + + machine49->cluster_internal_8589934590 + subgraph cluster_internal_8589934590 { + graph [label="Compact Machine {-2,1}",style=filled,color=cadetblue] + } + + machine5->cluster_internal_8589934591 + machine32->cluster_internal_8589934591 + subgraph cluster_internal_8589934591 { + graph [label="Compact Machine {-1,1}",style=filled,color=cadetblue] + machine25 [label="Compact Machine #25",style=filled,color=lightgray] + machine22 [label="Compact Machine #22",style=filled,color=palevioletred1] + } + + machine36->cluster_internal_8589934592 + subgraph cluster_internal_8589934592 { + graph [label="Compact Machine {0,2}",style=filled,color=cadetblue] + } + + machine44->cluster_internal_8589934593 + subgraph cluster_internal_8589934593 { + graph [label="Compact Machine {1,2}",style=filled,color=cadetblue] + } + + machine51->cluster_internal_8589934594 + subgraph cluster_internal_8589934594 { + graph [label="Compact Machine {2,2}",style=filled,color=cadetblue] + } + + machine40->cluster_internal_8589934595 + subgraph cluster_internal_8589934595 { + graph [label="Compact Machine {3,2}",style=filled,color=cadetblue] + } + + machine25->cluster_internal_N1 + machine30->cluster_internal_N1 + machine7->cluster_internal_N1 + subgraph cluster_internal_N1 { + graph [label="Compact Machine {-1,-1}",style=filled,color=cadetblue] + machine34 [label="Compact Machine #34",style=filled,color=palevioletred1] + } + + machine48->cluster_internal_N12884901885 + subgraph cluster_internal_N12884901885 { + graph [label="Compact Machine {3,-3}",style=filled,color=cadetblue] + } + + machine50->cluster_internal_N12884901886 + subgraph cluster_internal_N12884901886 { + graph [label="Compact Machine {2,-3}",style=filled,color=cadetblue] + } + + machine37->cluster_internal_N12884901887 + subgraph cluster_internal_N12884901887 { + graph [label="Compact Machine {1,-3}",style=filled,color=cadetblue] + } + + machine42->cluster_internal_N12884901888 + subgraph cluster_internal_N12884901888 { + graph [label="Compact Machine {0,-3}",style=filled,color=cadetblue] + } + + machine54->cluster_internal_N2 + subgraph cluster_internal_N2 { + graph [label="Compact Machine {-2,-1}",style=filled,color=cadetblue] + } + + machine53->cluster_internal_N4294967293 + subgraph cluster_internal_N4294967293 { + graph [label="Compact Machine {3,-1}",style=filled,color=cadetblue] + } + + machine39->cluster_internal_N4294967294 + subgraph cluster_internal_N4294967294 { + graph [label="Compact Machine {2,-1}",style=filled,color=cadetblue] + } + + machine1->cluster_internal_N4294967295 + machine27->cluster_internal_N4294967295 + machine14->cluster_internal_N4294967295 + machine23->cluster_internal_N4294967295 + subgraph cluster_internal_N4294967295 { + graph [label="Compact Machine {1,-1}",style=filled,color=cadetblue] + machine17 [label="Compact Machine #17",style=filled,color=palevioletred1] + } + + machine26->cluster_internal_N4294967296 + machine0->cluster_internal_N4294967296 + subgraph cluster_internal_N4294967296 { + graph [label="Compact Machine {0,-1}",style=filled,color=cadetblue] + machine19 [label="Compact Machine #19",style=filled,color=palevioletred1] + } + + machine52->cluster_internal_N4294967297 + subgraph cluster_internal_N4294967297 { + graph [label="Compact Machine {-1,-2}",style=filled,color=cadetblue] + } + + machine45->cluster_internal_N4294967298 + subgraph cluster_internal_N4294967298 { + graph [label="Compact Machine {-2,-2}",style=filled,color=cadetblue] + } + + machine43->cluster_internal_N8589934589 + subgraph cluster_internal_N8589934589 { + graph [label="Compact Machine {3,-2}",style=filled,color=cadetblue] + } + + machine58->cluster_internal_N8589934590 + subgraph cluster_internal_N8589934590 { + graph [label="Compact Machine {2,-2}",style=filled,color=cadetblue] + } + + machine9->cluster_internal_N8589934591 + machine15->cluster_internal_N8589934591 + subgraph cluster_internal_N8589934591 { + graph [label="Compact Machine {1,-2}",style=filled,color=cadetblue] + machine24 [label="Compact Machine #24",style=filled,color=palevioletred1] + } + + machine11->cluster_internal_N8589934592 + machine21->cluster_internal_N8589934592 + machine31->cluster_internal_N8589934592 + machine8->cluster_internal_N8589934592 + subgraph cluster_internal_N8589934592 { + graph [label="Compact Machine {0,-2}",style=filled,color=cadetblue] + machine23 [label="Compact Machine #23",style=filled,color=lightgray] + } + +} diff --git a/src/main/java/com/robotgryphon/compactmachines/CompactMachines.java b/src/main/java/com/robotgryphon/compactmachines/CompactMachines.java index 6f50077e..d3ddcc3d 100644 --- a/src/main/java/com/robotgryphon/compactmachines/CompactMachines.java +++ b/src/main/java/com/robotgryphon/compactmachines/CompactMachines.java @@ -41,8 +41,6 @@ public ItemStack makeIcon() { }; public CompactMachines() { - IEventBus modBus = FMLJavaModLoadingContext.get().getModEventBus(); - // Register blocks and items Registration.init(); @@ -53,17 +51,6 @@ public CompactMachines() { CraftingHelper.register(EnableVanillaRecipesConfigCondition.Serializer.INSTANCE); } - @SubscribeEvent - public static void setup(final FMLCommonSetupEvent event) { - NetworkHandler.initialize(); - } - - @SubscribeEvent - public static void enqueueIMC(final InterModEnqueueEvent event) { - if (ModList.get().isLoaded("theoneprobe")) - TheOneProbeCompat.sendIMC(); - } - @SubscribeEvent public static void onTick(TickEvent.RenderTickEvent e) { // lol frames r good diff --git a/src/main/java/com/robotgryphon/compactmachines/api/core/Constants.java b/src/main/java/com/robotgryphon/compactmachines/api/core/Constants.java new file mode 100644 index 00000000..4dd30313 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/api/core/Constants.java @@ -0,0 +1,5 @@ +package com.robotgryphon.compactmachines.api.core; + +public abstract class Constants { + public static final String MOD_ID = "compactmachines"; +} diff --git a/src/main/java/com/robotgryphon/compactmachines/api/core/Messages.java b/src/main/java/com/robotgryphon/compactmachines/api/core/Messages.java new file mode 100644 index 00000000..63e3802c --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/api/core/Messages.java @@ -0,0 +1,10 @@ +package com.robotgryphon.compactmachines.api.core; + +import net.minecraft.util.ResourceLocation; + +public abstract class Messages { + public static final ResourceLocation CANNOT_ENTER_MACHINE = new ResourceLocation(Constants.MOD_ID, "cannot_enter"); + public static final ResourceLocation NO_MACHINE_DATA = new ResourceLocation(Constants.MOD_ID, "no_machine_data"); + public static final ResourceLocation MACHINE_SPAWNPOINT_SET = new ResourceLocation(Constants.MOD_ID, "spawnpoint_set"); + public static final ResourceLocation TELEPORT_OUT_OF_BOUNDS = new ResourceLocation(Constants.MOD_ID, "teleport_oob"); +} diff --git a/src/main/java/com/robotgryphon/compactmachines/api/core/Tooltips.java b/src/main/java/com/robotgryphon/compactmachines/api/core/Tooltips.java new file mode 100644 index 00000000..fd0284ba --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/api/core/Tooltips.java @@ -0,0 +1,25 @@ +package com.robotgryphon.compactmachines.api.core; + +import net.minecraft.util.ResourceLocation; + +import static com.robotgryphon.compactmachines.api.core.Constants.MOD_ID; + +public abstract class Tooltips { + + public static final ResourceLocation UNKNOWN_PLAYER_NAME = new ResourceLocation(MOD_ID, "unknown_player"); + + public static abstract class Machines { + public static final ResourceLocation ID = new ResourceLocation(MOD_ID, "machine.id"); + public static final ResourceLocation OWNER = new ResourceLocation(MOD_ID, "machine.owner"); + public static final ResourceLocation SIZE = new ResourceLocation(MOD_ID, "machine.size"); + } + + //#region Hints and Details + public static final ResourceLocation HINT_HOLD_SHIFT = new ResourceLocation(MOD_ID, "hint.hold_shift"); + + public static abstract class Details { + public static final ResourceLocation PERSONAL_SHRINKING_DEVICE = new ResourceLocation(MOD_ID, "details.psd"); + public static final ResourceLocation SOLID_WALL = new ResourceLocation(MOD_ID, "details.solid_wall"); + } + //#endregion +} diff --git a/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java b/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java index 07dd2c47..afbca6dd 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java @@ -3,25 +3,25 @@ import com.robotgryphon.compactmachines.CompactMachines; import com.robotgryphon.compactmachines.api.tunnels.ITunnelConnectionInfo; import com.robotgryphon.compactmachines.api.tunnels.redstone.IRedstoneReaderTunnel; -import com.robotgryphon.compactmachines.api.tunnels.redstone.IRedstoneTunnel; import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; -import com.robotgryphon.compactmachines.compat.theoneprobe.providers.CompactMachineProvider; import com.robotgryphon.compactmachines.compat.theoneprobe.IProbeData; import com.robotgryphon.compactmachines.compat.theoneprobe.IProbeDataProvider; -import com.robotgryphon.compactmachines.config.CommonConfig; +import com.robotgryphon.compactmachines.compat.theoneprobe.providers.CompactMachineProvider; import com.robotgryphon.compactmachines.config.ServerConfig; import com.robotgryphon.compactmachines.core.EnumMachinePlayersBreakHandling; import com.robotgryphon.compactmachines.core.Registration; import com.robotgryphon.compactmachines.reference.EnumMachineSize; import com.robotgryphon.compactmachines.reference.Reference; import com.robotgryphon.compactmachines.tunnels.TunnelHelper; -import com.robotgryphon.compactmachines.util.CompactMachineUtil; +import com.robotgryphon.compactmachines.util.PlayerUtil; +import net.minecraft.block.AbstractBlock; import net.minecraft.block.Block; import net.minecraft.block.BlockState; import net.minecraft.entity.LivingEntity; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.entity.player.ServerPlayerEntity; +import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.nbt.CompoundNBT; import net.minecraft.tileentity.TileEntity; @@ -33,7 +33,6 @@ import net.minecraft.util.math.RayTraceResult; import net.minecraft.world.IBlockReader; import net.minecraft.world.IWorld; -import net.minecraft.world.IWorldReader; import net.minecraft.world.World; import net.minecraft.world.server.ServerWorld; @@ -43,8 +42,6 @@ import java.util.Set; import java.util.UUID; -import net.minecraft.block.AbstractBlock; - public class BlockCompactMachine extends Block implements IProbeDataProvider { private final EnumMachineSize size; @@ -156,9 +153,73 @@ public void neighborChanged(BlockState state, World world, BlockPos pos, Block c }); } + + public static EnumMachineSize getMachineSizeFromNBT(@Nullable CompoundNBT tag) { + try { + if (tag == null) + return EnumMachineSize.TINY; + + if (!tag.contains("size")) + return EnumMachineSize.TINY; + + String sizeFromTag = tag.getString("size"); + return EnumMachineSize.getFromSize(sizeFromTag); + } catch (Exception ex) { + return EnumMachineSize.TINY; + } + } + + public static Block getBySize(EnumMachineSize size) { + switch (size) { + case TINY: + return Registration.MACHINE_BLOCK_TINY.get(); + + case SMALL: + return Registration.MACHINE_BLOCK_SMALL.get(); + + case NORMAL: + return Registration.MACHINE_BLOCK_NORMAL.get(); + + case LARGE: + return Registration.MACHINE_BLOCK_LARGE.get(); + + case GIANT: + return Registration.MACHINE_BLOCK_GIANT.get(); + + case MAXIMUM: + return Registration.MACHINE_BLOCK_MAXIMUM.get(); + } + + return Registration.MACHINE_BLOCK_NORMAL.get(); + } + + public static Item getItemBySize(EnumMachineSize size) { + switch (size) { + case TINY: + return Registration.MACHINE_BLOCK_ITEM_TINY.get(); + + case SMALL: + return Registration.MACHINE_BLOCK_ITEM_SMALL.get(); + + case NORMAL: + return Registration.MACHINE_BLOCK_ITEM_NORMAL.get(); + + case LARGE: + return Registration.MACHINE_BLOCK_ITEM_LARGE.get(); + + case GIANT: + return Registration.MACHINE_BLOCK_ITEM_GIANT.get(); + + case MAXIMUM: + return Registration.MACHINE_BLOCK_ITEM_MAXIMUM.get(); + } + + return Registration.MACHINE_BLOCK_ITEM_NORMAL.get(); + } + @Override public ItemStack getPickBlock(BlockState state, RayTraceResult target, IBlockReader world, BlockPos pos, PlayerEntity player) { - Block given = CompactMachineUtil.getMachineBlockBySize(this.size); + Block given = getBySize(this.size); ItemStack stack = new ItemStack(given, 1); CompoundNBT nbt = stack.getOrCreateTagElement("cm"); @@ -233,7 +294,12 @@ public void setPlacedBy(World worldIn, BlockPos pos, BlockState state, @Nullable // tile.setCustomName(stack.getDisplayName()); // } - CompoundNBT nbt = stack.getOrCreateTag(); + if(!stack.hasTag()) + return; + + CompoundNBT nbt = stack.getTag(); + if(nbt == null) + return; if (nbt.contains(Reference.CompactMachines.OWNER_NBT)) { tile.setOwner(nbt.getUUID(Reference.CompactMachines.OWNER_NBT)); @@ -248,8 +314,6 @@ public void setPlacedBy(World worldIn, BlockPos pos, BlockState state, @Nullable if (machineData.contains("coords")) { int machineID = machineData.getInt("coords"); tile.setMachineId(machineID); - - CompactMachineUtil.updateMachineInWorldPosition(serverWorld, machineID, pos); } } @@ -274,9 +338,10 @@ public ActionResultType use(BlockState state, World worldIn, BlockPos pos, Playe if (mainItem.isEmpty()) return ActionResultType.PASS; + // TODO - Item tags instead of direct item reference here if (mainItem.getItem() == Registration.PERSONAL_SHRINKING_DEVICE.get()) { // Try teleport to compact machine dimension - CompactMachineUtil.teleportInto(serverPlayer, pos, size); + PlayerUtil.teleportPlayerIntoMachine(serverPlayer, pos, size); } } diff --git a/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java b/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java index e9523a44..bece8fef 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java @@ -2,13 +2,13 @@ import com.robotgryphon.compactmachines.config.ServerConfig; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.legacy.CompactMachineCommonData; -import com.robotgryphon.compactmachines.data.legacy.SavedMachineData; +import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; -import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData; import com.robotgryphon.compactmachines.data.world.ExternalMachineData; +import com.robotgryphon.compactmachines.data.world.InternalMachineData; import com.robotgryphon.compactmachines.reference.Reference; import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; +import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; import com.robotgryphon.compactmachines.tunnels.TunnelHelper; import com.robotgryphon.compactmachines.api.tunnels.ICapableTunnel; import net.minecraft.block.BlockState; @@ -17,6 +17,7 @@ import net.minecraft.nbt.StringNBT; import net.minecraft.network.NetworkManager; import net.minecraft.network.play.server.SUpdateTileEntityPacket; +import net.minecraft.server.MinecraftServer; import net.minecraft.tileentity.ITickableTileEntity; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.Direction; @@ -260,15 +261,26 @@ public void setMachineId(int id) { this.setChanged(); } - public Optional getMachineData() { - if (this.machineId == 0) + public Optional getInternalData() { + if(this.machineId == 0) return Optional.empty(); if (level instanceof ServerWorld) { - return Optional.ofNullable(level.getServer()) - .map(SavedMachineData::getInstance) - .map(SavedMachineData::getData) - .flatMap(d -> d.getMachineData(this.machineId)); + MinecraftServer serv = level.getServer(); + if(serv == null) + return Optional.empty(); + + // Get external machine info (which, this should have some if it has a machine ID + ExternalMachineData extern = ExternalMachineData.get(serv); + if(extern == null) + return Optional.empty(); + + Optional chunkLocation = extern.getChunkLocation(machineId); + if(!chunkLocation.isPresent()) + return Optional.empty(); + + InternalMachineData intern = InternalMachineData.get(serv); + return intern.forChunk(chunkLocation.get()); } else { return Optional.empty(); } @@ -288,7 +300,7 @@ protected void doChunkload(boolean force) { if (level == null || level.isClientSide) return; - getMachineData().ifPresent(data -> { + getInternalData().ifPresent(data -> { ServerWorld compact = this.level.getServer().getLevel(Registration.COMPACT_DIMENSION); IChunk machineChunk = compact.getChunk(data.getCenter()); ChunkPos chunkPos = machineChunk.getPos(); @@ -297,6 +309,21 @@ protected void doChunkload(boolean force) { } public void doPostPlaced() { + if(this.level == null || this.level.isClientSide) + return; + + MinecraftServer serv = this.level.getServer(); + if(serv == null) + return; + + DimensionalPosition dp = new DimensionalPosition( + this.level.dimension(), + this.worldPosition + ); + + ExternalMachineData extern = ExternalMachineData.get(serv); + extern.setMachineLocation(this.machineId, dp); + doChunkload(true); } @@ -311,6 +338,10 @@ public void handlePlayerEntered(UUID playerID) { // this.playerData.addPlayer(playerID); } + public boolean mapped() { + return getInternalData().isPresent(); + } + /* * Chunk-Loading triggers */ diff --git a/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java b/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java index 8b6f410e..f4bf35ea 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java @@ -1,22 +1,25 @@ package com.robotgryphon.compactmachines.block.tiles; +import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.api.tunnels.ICapableTunnel; +import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; import com.robotgryphon.compactmachines.block.walls.TunnelWallBlock; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData; +import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; +import com.robotgryphon.compactmachines.data.world.ExternalMachineData; +import com.robotgryphon.compactmachines.data.world.InternalMachineData; import com.robotgryphon.compactmachines.network.NetworkHandler; import com.robotgryphon.compactmachines.network.TunnelAddedPacket; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; -import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; -import com.robotgryphon.compactmachines.api.tunnels.ICapableTunnel; -import com.robotgryphon.compactmachines.util.CompactMachineUtil; import net.minecraft.block.BlockState; import net.minecraft.nbt.CompoundNBT; +import net.minecraft.server.MinecraftServer; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.Direction; import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.ChunkPos; import net.minecraft.util.math.vector.Vector3d; -import net.minecraft.world.IWorldReader; import net.minecraft.world.chunk.Chunk; import net.minecraft.world.server.ServerWorld; import net.minecraftforge.common.capabilities.Capability; @@ -27,19 +30,27 @@ import javax.annotation.Nonnull; import javax.annotation.Nullable; import java.util.Optional; +import java.util.Set; public class TunnelWallTile extends TileEntity { + private int connectedMachine; private ResourceLocation tunnelType; public TunnelWallTile() { super(Registration.TUNNEL_WALL_TILE.get()); } - public Optional getMachineInfo() { + public Optional getMachineInfo() { if (this.level instanceof ServerWorld) { ServerWorld serverWorld = (ServerWorld) this.level; - return CompactMachineUtil.getMachineInfoByInternalPosition(serverWorld, this.worldPosition); + ChunkPos p = new ChunkPos(worldPosition); + + InternalMachineData intern = InternalMachineData.get(serverWorld.getServer()); + if (intern == null) + return Optional.empty(); + + return intern.forChunk(p); } return Optional.empty(); @@ -49,16 +60,21 @@ public Optional getMachineInfo() { public void load(BlockState state, CompoundNBT nbt) { super.load(state, nbt); - if(nbt.contains("tunnel_type")) { + if (nbt.contains("tunnel_type")) { ResourceLocation type = new ResourceLocation(nbt.getString("tunnel_type")); this.tunnelType = type; } + + if(nbt.contains("machine")) { + this.connectedMachine = nbt.getInt("machine"); + } } @Override public CompoundNBT save(CompoundNBT compound) { compound = super.save(compound); compound.putString("tunnel_type", tunnelType.toString()); + compound.putInt("machine", connectedMachine); return compound; } @@ -66,7 +82,7 @@ public CompoundNBT save(CompoundNBT compound) { public CompoundNBT getUpdateTag() { CompoundNBT nbt = super.getUpdateTag(); nbt.putString("tunnel_type", tunnelType.toString()); - + nbt.putInt("machine", connectedMachine); return nbt; } @@ -74,77 +90,74 @@ public CompoundNBT getUpdateTag() { public void handleUpdateTag(BlockState state, CompoundNBT tag) { super.handleUpdateTag(state, tag); - if(tag.contains("tunnel_type")) { + if (tag.contains("tunnel_type")) { this.tunnelType = new ResourceLocation(tag.getString("tunnel_type")); } - } - - public Optional getConnectedWorld() { - if (level == null || level.isClientSide()) - return Optional.empty(); - - ServerWorld serverWorld = (ServerWorld) level; - - Optional machineInfo = getMachineInfo(); - if (!machineInfo.isPresent()) - return Optional.empty(); - - Direction outsideDir = getConnectedSide(); - CompactMachineRegistrationData regData = machineInfo.get(); - - // Is the machine placed in world? If not, do not return an outside position - if (!regData.isPlacedInWorld()) - return Optional.empty(); - - DimensionalPosition machinePosition = regData.getOutsidePosition(serverWorld.getServer()); - if (machinePosition != null) { - return machinePosition.getWorld(serverWorld.getServer()); + if(tag.contains("machine")) { + this.connectedMachine = tag.getInt("machine"); } - - return Optional.empty(); } - /** - * Gets the position outside the machine where this tunnel is connected to. - * - * @return - */ public Optional getConnectedPosition() { if (level == null || level.isClientSide()) return Optional.empty(); ServerWorld serverWorld = (ServerWorld) level; + MinecraftServer serv = serverWorld.getServer(); - Optional machineInfo = getMachineInfo(); - if (!machineInfo.isPresent()) + ExternalMachineData extern = ExternalMachineData.get(serv); + if(extern == null) return Optional.empty(); - Direction outsideDir = getConnectedSide(); + if (this.connectedMachine <= 0) { + Optional mid = tryFindExternalMachineByChunkPos(extern); - CompactMachineRegistrationData regData = machineInfo.get(); + // Map the results - either it found an ID and we can map, or it found nothing + return mid.map(i -> { + this.connectedMachine = i; + DimensionalPosition pos = extern.getMachineLocation(i); + if(pos == null) + return null; - // Is the machine placed in world? If not, do not return an outside position - if (!regData.isPlacedInWorld()) + BlockPos bumped = pos.getBlockPosition().relative(getConnectedSide(), 1); + return new DimensionalPosition(pos.getDimension(), bumped); + }); + } + + DimensionalPosition pos = extern.getMachineLocation(this.connectedMachine); + if(pos == null) return Optional.empty(); - DimensionalPosition machinePosition = regData.getOutsidePosition(serverWorld.getServer()); - if (machinePosition != null) { - Vector3d o = machinePosition.getPosition(); - BlockPos machineOutPos = new BlockPos(o.x, o.y, o.z); + BlockPos bumped = pos.getBlockPosition().relative(getConnectedSide(), 1); + DimensionalPosition bdp = new DimensionalPosition(pos.getDimension(), bumped); + return Optional.of(bdp); + } - BlockPos connectedBlock = machineOutPos.relative(outsideDir); - Vector3d connectedBlockVec = new Vector3d(connectedBlock.getX(), connectedBlock.getY(), connectedBlock.getZ()); + private Optional tryFindExternalMachineByChunkPos(ExternalMachineData extern) { + ChunkPos thisMachineChunk = new ChunkPos(worldPosition); + Set externalMachineIDs = extern.getExternalMachineIDs(thisMachineChunk); - DimensionalPosition connectedPosition = new DimensionalPosition(machinePosition.getDimension(), connectedBlockVec); - return Optional.of(connectedPosition); + // This shouldn't happen - there should always be at least one machine attached externally + // If this DOES happen, it's probably a migration failure or the block was destroyed without notification + if (externalMachineIDs.isEmpty()) { + CompactMachines.LOGGER.warn("Warning: Tunnel applied to a machine but no external machine data found."); + CompactMachines.LOGGER.warn("Please validate the tunnel at: " + worldPosition.toShortString()); + return Optional.empty(); } - return Optional.empty(); + int first = externalMachineIDs.stream().findFirst().orElse(-1); + // sanity - makes compiler happier, we already did a check above for empty state + if (first == -1) return Optional.empty(); + + // In theory, we can re-attach the tunnel to the first found external machine, if the saved data + // does not actually contain an attached external id + return Optional.of(first); } /** * Gets the side the tunnel is placed on (the wall inside the machine) + * * @return */ public Direction getTunnelSide() { @@ -154,6 +167,7 @@ public Direction getTunnelSide() { /** * Gets the side the tunnel connects to externally (the machine side) + * * @return */ public Direction getConnectedSide() { @@ -166,7 +180,7 @@ public Optional getTunnelDefinitionId() { } public Optional getTunnelDefinition() { - if(tunnelType == null) + if (tunnelType == null) return Optional.empty(); TunnelDefinition definition = GameRegistry @@ -196,7 +210,7 @@ public LazyOptional getCapability(@Nonnull Capability cap, @Nullable D // loop through tunnel definition for capabilities TunnelDefinition definition = tunnelDef.get(); if (definition instanceof ICapableTunnel) { - if(!level.isClientSide()) { + if (!level.isClientSide()) { ServerWorld sw = (ServerWorld) level; return ((ICapableTunnel) definition).getExternalCapability(sw, worldPosition, cap, side); } @@ -208,7 +222,7 @@ public LazyOptional getCapability(@Nonnull Capability cap, @Nullable D public void setTunnelType(ResourceLocation registryName) { this.tunnelType = registryName; - if(level != null && !level.isClientSide()) { + if (level != null && !level.isClientSide()) { setChanged(); TunnelAddedPacket pkt = new TunnelAddedPacket(worldPosition, registryName); diff --git a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java b/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java index f2e1cf57..6970633f 100644 --- a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java +++ b/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java @@ -1,13 +1,14 @@ package com.robotgryphon.compactmachines.compat.theoneprobe.providers; import com.mojang.authlib.GameProfile; -import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.api.core.Tooltips; import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; import com.robotgryphon.compactmachines.compat.theoneprobe.IProbeData; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData; +import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; import com.robotgryphon.compactmachines.tunnels.TunnelHelper; +import com.robotgryphon.compactmachines.util.TranslationUtil; import mcjty.theoneprobe.api.IProbeHitData; import mcjty.theoneprobe.api.IProbeInfo; import mcjty.theoneprobe.api.ProbeMode; @@ -18,7 +19,6 @@ import net.minecraft.util.text.IFormattableTextComponent; import net.minecraft.util.text.StringTextComponent; import net.minecraft.util.text.TextFormatting; -import net.minecraft.util.text.TranslationTextComponent; import net.minecraft.world.World; import net.minecraft.world.server.ServerWorld; @@ -40,33 +40,35 @@ private static void addProbeInfo(ProbeMode mode, IProbeInfo info, PlayerEntity p if (te instanceof CompactMachineTile) { CompactMachineTile machine = (CompactMachineTile) te; - Optional machineData = machine.getMachineData(); + Optional machineData = machine.getInternalData(); machineData.ifPresent(md -> { - IFormattableTextComponent id = new TranslationTextComponent( - String.format("tooltip.%s.machine_id", CompactMachines.MOD_ID), - md.getId() - ).withStyle(TextFormatting.GREEN); + IFormattableTextComponent id = TranslationUtil + .tooltip(Tooltips.Machines.ID, machine.machineId) + .withStyle(TextFormatting.GREEN); + info.text(id); // Owner Name PlayerEntity owner = world.getPlayerByUUID(md.getOwner()); if (owner != null) { GameProfile ownerProfile = owner.getGameProfile(); - IFormattableTextComponent ownerText = new TranslationTextComponent( - String.format("tooltip.%s.owner", CompactMachines.MOD_ID), ownerProfile.getName() - ).withStyle(TextFormatting.GRAY); + IFormattableTextComponent ownerText = TranslationUtil + .tooltip(Tooltips.Machines.OWNER, ownerProfile.getName()) + .withStyle(TextFormatting.GRAY); info.text(ownerText); } - Set tunnelsForMachineSide = TunnelHelper.getTunnelsForMachineSide(md.getId(), (ServerWorld) world, hitData.getSideHit()); + Set tunnelsForMachineSide = TunnelHelper.getTunnelsForMachineSide(machine.machineId, + (ServerWorld) world, hitData.getSideHit()); + IProbeInfo vertical = info.vertical(info.defaultLayoutStyle().spacing(0)); ServerWorld cm = world.getServer().getLevel(Registration.COMPACT_DIMENSION); tunnelsForMachineSide.forEach(pos -> { TunnelWallTile tile = (TunnelWallTile) cm.getBlockEntity(pos); - if(tile == null) + if (tile == null) return; tile.getTunnelDefinition().ifPresent(tunnelDef -> { diff --git a/src/main/java/com/robotgryphon/compactmachines/core/ModBusEvents.java b/src/main/java/com/robotgryphon/compactmachines/core/ModBusEvents.java new file mode 100644 index 00000000..ab698a10 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/core/ModBusEvents.java @@ -0,0 +1,27 @@ +package com.robotgryphon.compactmachines.core; + +import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.compat.theoneprobe.TheOneProbeCompat; +import com.robotgryphon.compactmachines.network.NetworkHandler; +import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.fml.ModList; +import net.minecraftforge.fml.common.Mod; +import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent; +import net.minecraftforge.fml.event.lifecycle.InterModEnqueueEvent; + +@Mod.EventBusSubscriber(modid = CompactMachines.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD) +public class ModBusEvents { + + @SubscribeEvent + public static void setup(final FMLCommonSetupEvent event) { + CompactMachines.LOGGER.trace("Initializing network handler."); + NetworkHandler.initialize(); + } + + @SubscribeEvent + public static void enqueueIMC(final InterModEnqueueEvent event) { + CompactMachines.LOGGER.trace("Sending IMC setup to TOP and other mods."); + if (ModList.get().isLoaded("theoneprobe")) + TheOneProbeCompat.sendIMC(); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineDataMigrator.java b/src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineDataMigrator.java index b747efb6..b48db8b7 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineDataMigrator.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineDataMigrator.java @@ -15,6 +15,7 @@ import net.minecraft.world.storage.DimensionSavedDataManager; import net.minecraftforge.fml.common.ObfuscationReflectionHelper; +import javax.naming.OperationNotSupportedException; import java.io.File; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; @@ -40,7 +41,7 @@ public static void migrate(MinecraftServer server) { } InternalMachineData imd = InternalMachineData.get(server); - if(imd == null) { + if (imd == null) { CompactMachines.LOGGER.error("Could not perform migration; couldn't create the internal machine file."); return; } @@ -63,9 +64,13 @@ public static void migrate(MinecraftServer server) { if (!emd.machineMapping.containsKey(id)) emd.machineMapping.put(id, machineChunk); - if(!imd.machineData.containsKey(machineChunk)) { - CompactMachineInternalData d = new CompactMachineInternalData(owner, center, spawn, size); - imd.machineData.put(machineChunk, d); + if (!imd.isRegistered(machineChunk)) { + try { + CompactMachineInternalData d = new CompactMachineInternalData(owner, center, spawn, size); + imd.register(machineChunk, d); + } catch (OperationNotSupportedException e) { + e.printStackTrace(); + } } }); diff --git a/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java b/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java index 24899443..5f75aa77 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java @@ -3,6 +3,7 @@ import com.mojang.serialization.Codec; import com.mojang.serialization.codecs.RecordCodecBuilder; import com.robotgryphon.compactmachines.reference.EnumMachineSize; +import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; import java.util.UUID; @@ -39,11 +40,20 @@ private String getSizeString() { return this.size.name(); } + public UUID getOwner() { return this.owner; } + private String getOwnerString() { return owner.toString(); } public BlockPos getSpawn() { + if(this.spawn != null) + return this.spawn; + + BlockPos.Mutable newSpawn = center.mutable(); + newSpawn.setY(newSpawn.getY() - (size.getInternalSize() / 2)); + + this.spawn = newSpawn; return this.spawn; } @@ -54,4 +64,8 @@ public BlockPos getCenter() { public void setSpawn(BlockPos newSpawn) { this.spawn = newSpawn; } + + public AxisAlignedBB getMachineBounds() { + return size.getBounds(this.center); + } } diff --git a/src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java b/src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java index 55a4a3f2..3ed9ec1d 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java @@ -164,4 +164,19 @@ private void rebuildReverseMapCache(ChunkPos internal) { public Optional getChunkLocation(int machineId) { return Optional.ofNullable(machineMapping.get(machineId)); } + + public boolean isPlaced(Integer machineId) { + return machineLocations.containsKey(machineId); + } + + public void setMachineLocation(int machineId, DimensionalPosition position) { + // TODO - Packet/Event for machine changing external location (tunnels) + machineLocations.put(machineId, position); + this.setDirty(); + } + + @Nullable + public DimensionalPosition getMachineLocation(int machineId) { + return machineLocations.get(machineId); + } } diff --git a/src/main/java/com/robotgryphon/compactmachines/data/world/InternalMachineData.java b/src/main/java/com/robotgryphon/compactmachines/data/world/InternalMachineData.java index c9fca378..9ffb1470 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/world/InternalMachineData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/world/InternalMachineData.java @@ -18,6 +18,7 @@ import javax.annotation.Nonnull; import javax.annotation.Nullable; +import javax.naming.OperationNotSupportedException; import java.util.HashMap; import java.util.Map; import java.util.Optional; @@ -25,7 +26,7 @@ public class InternalMachineData extends WorldSavedData { public static final String DATA_NAME = "machines_internal"; - public Map machineData; + private Map machineData; public InternalMachineData() { super(DATA_NAME); @@ -81,4 +82,24 @@ public CompoundNBT save(@Nonnull CompoundNBT nbt) { return nbt; } + + public boolean isRegistered(ChunkPos chunkPos) { + return machineData.containsKey(chunkPos); + } + + public void register(ChunkPos pos, CompactMachineInternalData data) throws OperationNotSupportedException { + if(isRegistered(pos)) + throw new OperationNotSupportedException("Machine already registered."); + + machineData.put(pos, data); + setDirty(); + } + + public Optional forChunk(ChunkPos chunkPos) { + return Optional.ofNullable(machineData.get(chunkPos)); + } + + public int getNextId() { + return this.machineData.size() + 1; + } } diff --git a/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java b/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java index 0c36937f..571be1a3 100644 --- a/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java +++ b/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java @@ -40,7 +40,7 @@ protected void buildShapelessRecipes(Consumer consumer) { .define('I', Tags.Items.INGOTS_IRON) .unlockedBy("picked_up_ender_eye", has(Items.ENDER_EYE)) .save(consumer); - + addMachineRecipes(consumer); } diff --git a/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java b/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java index ff2f32db..e6d3c173 100644 --- a/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java +++ b/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java @@ -1,18 +1,23 @@ package com.robotgryphon.compactmachines.item; import com.mojang.authlib.GameProfile; -import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.api.core.Tooltips; import com.robotgryphon.compactmachines.block.BlockCompactMachine; +import com.robotgryphon.compactmachines.data.world.ExternalMachineData; import com.robotgryphon.compactmachines.reference.EnumMachineSize; import com.robotgryphon.compactmachines.reference.Reference; import com.robotgryphon.compactmachines.util.PlayerUtil; +import com.robotgryphon.compactmachines.util.TranslationUtil; import net.minecraft.block.Block; +import net.minecraft.block.BlockState; import net.minecraft.client.gui.screen.Screen; import net.minecraft.client.util.ITooltipFlag; import net.minecraft.item.BlockItem; +import net.minecraft.item.BlockItemUseContext; import net.minecraft.item.ItemGroup; import net.minecraft.item.ItemStack; import net.minecraft.nbt.CompoundNBT; +import net.minecraft.server.MinecraftServer; import net.minecraft.util.NonNullList; import net.minecraft.util.text.*; import net.minecraft.world.World; @@ -22,8 +27,6 @@ import java.util.Optional; import java.util.UUID; -import net.minecraft.item.Item.Properties; - public class ItemBlockMachine extends BlockItem { public ItemBlockMachine(Block blockIn, EnumMachineSize size, Properties builder) { @@ -35,56 +38,89 @@ public void fillItemCategory(ItemGroup group, NonNullList items) { super.fillItemCategory(group, items); } + public static Optional getMachineId(ItemStack stack) { + if (!stack.hasTag()) + return Optional.empty(); + + CompoundNBT machineData = stack.getTagElement("cm"); + if (machineData == null) + return Optional.empty(); + + if (machineData.contains("coords")) { + int c = machineData.getInt("coords"); + return c > -1 ? Optional.of(c) : Optional.empty(); + } + + return Optional.empty(); + } + + @Override + protected boolean canPlace(BlockItemUseContext ctx, BlockState state) { + boolean s = super.canPlace(ctx, state); + if (!s) return false; + + ItemStack stack = ctx.getItemInHand(); + World level = ctx.getLevel(); + + if(level.isClientSide) + return true; + + MinecraftServer serv = level.getServer(); + return getMachineId(stack) + .map(id -> { + // Need to determine if another machine with this ID already on server + ExternalMachineData extern = ExternalMachineData.get(serv); + return extern.isPlaced(id); + }) + .orElse(true); + } + @Override public void appendHoverText(ItemStack stack, @Nullable World worldIn, List tooltip, ITooltipFlag flagIn) { super.appendHoverText(stack, worldIn, tooltip, flagIn); + + // We need NBT data for the rest of this - if (!stack.hasTag()) - return; - - CompoundNBT nbt = stack.getTag(); - if (nbt.contains("cm")) { - CompoundNBT machineData = nbt.getCompound("cm"); - if (machineData.contains("coords")) { - int coords = machineData.getInt("coords"); - if (coords > -1) { - IFormattableTextComponent coordsTC = new TranslationTextComponent("tooltip.compactmachines.machine_id", coords); - tooltip.add(coordsTC); - } - } - } + if (stack.hasTag()) { - if (nbt.contains(Reference.CompactMachines.OWNER_NBT)) { - UUID owner = nbt.getUUID(Reference.CompactMachines.OWNER_NBT); - Optional playerProfile = PlayerUtil.getProfileByUUID(worldIn, owner); + CompoundNBT nbt = stack.getTag(); - IFormattableTextComponent player = playerProfile - .map(p -> (IFormattableTextComponent) new StringTextComponent(p.getName())) - .orElseGet(() -> new TranslationTextComponent("tooltip." + CompactMachines.MOD_ID + ".unknown_player")); + getMachineId(stack).ifPresent(id -> { + tooltip.add(TranslationUtil.tooltip(Tooltips.Machines.ID, id)); + }); - IFormattableTextComponent ownerText = new TranslationTextComponent("tooltip." + CompactMachines.MOD_ID + ".owner") - .append(player); + if (nbt.contains(Reference.CompactMachines.OWNER_NBT)) { + UUID owner = nbt.getUUID(Reference.CompactMachines.OWNER_NBT); + Optional playerProfile = PlayerUtil.getProfileByUUID(worldIn, owner); + + IFormattableTextComponent player = playerProfile + .map(p -> (IFormattableTextComponent) new StringTextComponent(p.getName())) + .orElse(TranslationUtil.tooltip(Tooltips.UNKNOWN_PLAYER_NAME)); + + IFormattableTextComponent ownerText = TranslationUtil.tooltip(Tooltips.Machines.OWNER) + .append(player); + + tooltip.add(ownerText); + } - tooltip.add(ownerText); } if (Screen.hasShiftDown()) { - // TODO Show size information when sneaking - Block b = Block.byItem(stack.getItem()); if (b instanceof BlockCompactMachine) { EnumMachineSize size = ((BlockCompactMachine) b).getSize(); int internalSize = size.getInternalSize(); - IFormattableTextComponent text = new TranslationTextComponent("tooltip." + CompactMachines.MOD_ID + ".machine.size", internalSize) + IFormattableTextComponent text = TranslationUtil.tooltip(Tooltips.Machines.SIZE, internalSize) .withStyle(TextFormatting.YELLOW); tooltip.add(text); } } else { - IFormattableTextComponent text = new TranslationTextComponent("tooltip." + CompactMachines.MOD_ID + ".hold_shift.hint") - .withStyle(TextFormatting.GRAY); + IFormattableTextComponent text = TranslationUtil.tooltip(Tooltips.HINT_HOLD_SHIFT) + .withStyle(TextFormatting.DARK_GRAY) + .withStyle(TextFormatting.ITALIC); tooltip.add(text); } diff --git a/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockWall.java b/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockWall.java index decaf84f..37fc2f02 100644 --- a/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockWall.java +++ b/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockWall.java @@ -1,7 +1,10 @@ package com.robotgryphon.compactmachines.item; +import com.robotgryphon.compactmachines.api.core.Tooltips; import com.robotgryphon.compactmachines.core.Registration; +import com.robotgryphon.compactmachines.util.TranslationUtil; import net.minecraft.block.Block; +import net.minecraft.client.gui.screen.Screen; import net.minecraft.client.util.ITooltipFlag; import net.minecraft.item.BlockItem; import net.minecraft.item.ItemStack; @@ -11,8 +14,6 @@ import javax.annotation.Nullable; import java.util.List; -import net.minecraft.item.Item.Properties; - public class ItemBlockWall extends BlockItem { public ItemBlockWall(Block blockIn, Properties builder) { @@ -24,9 +25,16 @@ public void appendHoverText(ItemStack stack, @Nullable World worldIn, List use(World world, PlayerEntity player, Hand hand) // If we aren't in the compact dimension, allow PSD guide usage // Prevents misfiring if a player is trying to leave a machine or set their spawn - if(world.isClientSide && world.dimension() != Registration.COMPACT_DIMENSION) { + if (world.isClientSide && world.dimension() != Registration.COMPACT_DIMENSION) { PersonalShrinkingDeviceScreen.show(); return ActionResult.success(stack); } @@ -77,14 +71,23 @@ public ActionResult use(World world, PlayerEntity player, Hand hand) ServerPlayerEntity serverPlayer = (ServerPlayerEntity) player; if (serverPlayer.level.dimension() == Registration.COMPACT_DIMENSION) { - ServerWorld serverWorld = serverPlayer.getLevel(); + ServerWorld serverWorld = serverPlayer.getLevel(); if (player.isShiftKeyDown()) { - CompactMachineUtil.setMachineSpawn(serverWorld.getServer(), player.blockPosition()); + ChunkPos machineChunk = new ChunkPos(player.blockPosition()); + + InternalMachineData intern = InternalMachineData.get(serverWorld.getServer()); + if (intern != null) { + // Use internal data to set new spawn point + intern.forChunk(machineChunk).ifPresent(data -> { + data.setSpawn(player.blockPosition()); + intern.setDirty(); - IFormattableTextComponent tc = new TranslationTextComponent("messages.compactmachines.psd.spawnpoint_set") - .withStyle(TextFormatting.GREEN); + IFormattableTextComponent tc = TranslationUtil.message(Messages.MACHINE_SPAWNPOINT_SET) + .withStyle(TextFormatting.GREEN); - player.displayClientMessage(tc, true); + player.displayClientMessage(tc, true); + }); + } } else { PlayerUtil.teleportPlayerOutOfMachine(serverWorld, serverPlayer); } diff --git a/src/main/java/com/robotgryphon/compactmachines/item/TunnelItem.java b/src/main/java/com/robotgryphon/compactmachines/item/TunnelItem.java index ea28c2d4..06312e1e 100644 --- a/src/main/java/com/robotgryphon/compactmachines/item/TunnelItem.java +++ b/src/main/java/com/robotgryphon/compactmachines/item/TunnelItem.java @@ -1,11 +1,13 @@ package com.robotgryphon.compactmachines.item; import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.api.core.Tooltips; import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; import com.robotgryphon.compactmachines.block.walls.TunnelWallBlock; import com.robotgryphon.compactmachines.core.Registration; import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; import com.robotgryphon.compactmachines.api.tunnels.redstone.IRedstoneReaderTunnel; +import com.robotgryphon.compactmachines.util.TranslationUtil; import net.minecraft.block.BlockState; import net.minecraft.client.gui.screen.Screen; import net.minecraft.client.util.ITooltipFlag; @@ -59,6 +61,10 @@ public void appendHoverText(@Nonnull ItemStack stack, @Nullable World worldIn, L .withStyle(TextFormatting.ITALIC); tooltip.add(type); + } else { + tooltip.add(TranslationUtil.tooltip(Tooltips.HINT_HOLD_SHIFT) + .withStyle(TextFormatting.DARK_GRAY) + .withStyle(TextFormatting.ITALIC)); } }); } diff --git a/src/main/java/com/robotgryphon/compactmachines/reference/EnumMachineSize.java b/src/main/java/com/robotgryphon/compactmachines/reference/EnumMachineSize.java index 6e9ec66b..c964fac8 100644 --- a/src/main/java/com/robotgryphon/compactmachines/reference/EnumMachineSize.java +++ b/src/main/java/com/robotgryphon/compactmachines/reference/EnumMachineSize.java @@ -1,6 +1,8 @@ package com.robotgryphon.compactmachines.reference; import net.minecraft.util.IStringSerializable; +import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.math.BlockPos; public enum EnumMachineSize implements IStringSerializable { TINY ("tiny", 3), @@ -26,6 +28,11 @@ public String getName() { return this.name; } + public AxisAlignedBB getBounds(BlockPos center) { + AxisAlignedBB bounds = new AxisAlignedBB(center); + return bounds.inflate(Math.floorDiv(internalSize, 2)); + } + public int getInternalSize() { return this.internalSize; } diff --git a/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java b/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java index a3722420..85e397c4 100644 --- a/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java +++ b/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java @@ -1,12 +1,24 @@ package com.robotgryphon.compactmachines.teleportation; import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.api.core.Messages; import com.robotgryphon.compactmachines.core.Registration; +import com.robotgryphon.compactmachines.data.world.InternalMachineData; +import com.robotgryphon.compactmachines.util.TranslationUtil; import net.minecraft.entity.Entity; +import net.minecraft.entity.LivingEntity; import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.NBTUtil; +import net.minecraft.server.MinecraftServer; +import net.minecraft.tileentity.EnderChestTileEntity; +import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.math.ChunkPos; import net.minecraft.util.math.vector.Vector3d; +import net.minecraft.util.text.TextFormatting; +import net.minecraft.util.text.TranslationTextComponent; +import net.minecraftforge.event.entity.EntityEvent; +import net.minecraftforge.event.entity.living.EnderTeleportEvent; import net.minecraftforge.event.entity.living.EntityTeleportEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.fml.common.Mod; @@ -14,32 +26,68 @@ @Mod.EventBusSubscriber(modid = CompactMachines.MOD_ID) public class TeleportationEventHandler { + @SubscribeEvent + public static void onEnderTeleport(final EnderTeleportEvent evt) { + Vector3d target = new Vector3d( + evt.getTargetX(), + evt.getTargetY(), + evt.getTargetZ() + ); + + Entity ent = evt.getEntity(); + doEntityTeleportHandle(evt, target, ent); + } + @SubscribeEvent public static void onEntityTeleport(final EntityTeleportEvent evt) { // Allow teleport commands, we don't want to trap people anywhere - if(evt instanceof EntityTeleportEvent.TeleportCommand) + if (evt instanceof EntityTeleportEvent.TeleportCommand) return; - // Allow ender pearls as well, since players can teleport around inside machines - if(evt instanceof EntityTeleportEvent.EnderPearl) - return; + Entity ent = evt.getEntity(); + doEntityTeleportHandle(evt, evt.getTarget(), ent); + } + + + /** + * Helper to determine if an event should be canceled, by determining if a target is outside + * a machine's bounds. + * + * @param entity Entity trying to teleport. + * @param target Teleportation target location. + * @return True if teleportation should be cancelled; false otherwise. + */ + private static boolean cancelOutOfBoxTeleport(Entity entity, Vector3d target) { + MinecraftServer serv = entity.getServer(); + if (serv == null) + return false; + + ChunkPos machineChunk = new ChunkPos(entity.xChunk, entity.zChunk); + + InternalMachineData intern = InternalMachineData.get(serv); + if (intern == null) + return false; + + return intern.forChunk(machineChunk).map(md -> { + AxisAlignedBB bounds = md.getMachineBounds(); + boolean targetInBounds = bounds.contains(target); + + return !targetInBounds; + }).orElse(false); + } - // Make sure we only target player entities on a server - Entity entity = evt.getEntity(); - if (entity instanceof ServerPlayerEntity) { - ServerPlayerEntity sp = (ServerPlayerEntity) entity; - if(sp.level.dimension() == Registration.COMPACT_DIMENSION) { - if(evt.isCancelable()) { - evt.setCanceled(true); - return; + private static void doEntityTeleportHandle(EntityEvent evt, Vector3d target, Entity ent) { + if (ent.level.dimension() == Registration.COMPACT_DIMENSION) { + if (cancelOutOfBoxTeleport(ent, target) && evt.isCancelable()) { + if (ent instanceof ServerPlayerEntity) { + ((ServerPlayerEntity) ent).displayClientMessage( + TranslationUtil.message(Messages.TELEPORT_OUT_OF_BOUNDS, ent.getName()) + .withStyle(TextFormatting.RED) + .withStyle(TextFormatting.ITALIC), + true + ); } - - // If the event isn't cancelable, force the position to - // be the same as the starting point - Vector3d prev = evt.getPrev(); - evt.setTargetX(prev.x); - evt.setTargetY(prev.y); - evt.setTargetZ(prev.z); + evt.setCanceled(true); } } } diff --git a/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelConnectionInfo.java b/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelConnectionInfo.java index f4706b68..265b0573 100644 --- a/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelConnectionInfo.java +++ b/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelConnectionInfo.java @@ -5,6 +5,7 @@ import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; import net.minecraft.block.BlockState; +import net.minecraft.server.MinecraftServer; import net.minecraft.util.Direction; import net.minecraft.world.IWorldReader; @@ -37,7 +38,10 @@ public Optional getConnectedWorld(EnumTunnelSide side) { return Optional.ofNullable(tunnel.getLevel()); case OUTSIDE: - return tunnel.getConnectedWorld(); + return tunnel.getConnectedPosition().map(p -> { + MinecraftServer serv = tunnel.getLevel().getServer(); + return p.getWorld(serv).orElse(null); + }); } return Optional.empty(); diff --git a/src/main/java/com/robotgryphon/compactmachines/util/CompactMachinePlayerUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/CompactMachinePlayerUtil.java deleted file mode 100644 index ca4d8f15..00000000 --- a/src/main/java/com/robotgryphon/compactmachines/util/CompactMachinePlayerUtil.java +++ /dev/null @@ -1,68 +0,0 @@ -package com.robotgryphon.compactmachines.util; - -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; -import com.robotgryphon.compactmachines.data.legacy.CompactMachineServerData; -import com.robotgryphon.compactmachines.data.legacy.SavedMachineData; -import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; -import com.robotgryphon.compactmachines.network.MachinePlayersChangedPacket; -import com.robotgryphon.compactmachines.network.NetworkHandler; -import net.minecraft.entity.player.ServerPlayerEntity; -import net.minecraft.server.MinecraftServer; -import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.ChunkPos; -import net.minecraftforge.fml.network.PacketDistributor; - -import java.util.Optional; - -public class CompactMachinePlayerUtil { - public static void addPlayerToMachine(ServerPlayerEntity serverPlayer, BlockPos machinePos) { - MinecraftServer serv = serverPlayer.getServer(); - if (serv == null) - return; - - CompactMachinePlayerData playerData = CompactMachinePlayerData.get(serv); - if (playerData == null) - return; - - CompactMachineTile tile = (CompactMachineTile) serverPlayer.getLevel().getBlockEntity(machinePos); - if(tile == null) - return; - - tile.getInternalChunkPos().ifPresent(mChunk -> { - - playerData.addPlayer(serverPlayer, mChunk); - playerData.setDirty(); - - MachinePlayersChangedPacket p = new MachinePlayersChangedPacket(serv, tile.machineId, serverPlayer.getUUID(), MachinePlayersChangedPacket.EnumPlayerChangeType.ENTERED); - NetworkHandler.MAIN_CHANNEL.send( - PacketDistributor.TRACKING_CHUNK.with(() -> serverPlayer.getLevel().getChunkAt(machinePos)), - p); - }); - } - - public static void removePlayerFromMachine(ServerPlayerEntity serverPlayer, BlockPos machinePos) { - MinecraftServer serv = serverPlayer.getServer(); - - CompactMachinePlayerData playerData = CompactMachinePlayerData.get(serv); - if (playerData == null) - return; - - playerData.removePlayer(serverPlayer); - - CompactMachineTile tile = (CompactMachineTile) serverPlayer.getLevel().getBlockEntity(machinePos); - if(tile == null) - return; - - tile.getInternalChunkPos().ifPresent(mChunk -> { - - playerData.removePlayer(serverPlayer); - playerData.setDirty(); - - MachinePlayersChangedPacket p = new MachinePlayersChangedPacket(serv, tile.machineId, serverPlayer.getUUID(), MachinePlayersChangedPacket.EnumPlayerChangeType.EXITED); - NetworkHandler.MAIN_CHANNEL.send( - PacketDistributor.TRACKING_CHUNK.with(() -> serverPlayer.getLevel().getChunkAt(machinePos)), - p); - }); - } -} diff --git a/src/main/java/com/robotgryphon/compactmachines/util/CompactMachineUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/CompactMachineUtil.java deleted file mode 100644 index 3eb737d3..00000000 --- a/src/main/java/com/robotgryphon/compactmachines/util/CompactMachineUtil.java +++ /dev/null @@ -1,232 +0,0 @@ -package com.robotgryphon.compactmachines.util; - -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; -import com.robotgryphon.compactmachines.config.ServerConfig; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.legacy.CompactMachineServerData; -import com.robotgryphon.compactmachines.data.legacy.SavedMachineData; -import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData; -import com.robotgryphon.compactmachines.reference.EnumMachineSize; -import net.minecraft.block.Block; -import net.minecraft.entity.player.ServerPlayerEntity; -import net.minecraft.item.Item; -import net.minecraft.nbt.CompoundNBT; -import net.minecraft.server.MinecraftServer; -import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.vector.Vector3d; -import net.minecraft.util.math.vector.Vector3i; -import net.minecraft.util.text.IFormattableTextComponent; -import net.minecraft.util.text.TextFormatting; -import net.minecraft.util.text.TranslationTextComponent; -import net.minecraft.world.server.ServerWorld; - -import javax.annotation.Nullable; -import java.util.Optional; - -public abstract class CompactMachineUtil { - - public static void teleportInto(ServerPlayerEntity serverPlayer, BlockPos machinePos, EnumMachineSize size) { - ServerWorld serverWorld = serverPlayer.getLevel(); - - MinecraftServer serv = serverWorld.getServer(); - if (serverWorld.dimension() == Registration.COMPACT_DIMENSION) { - IFormattableTextComponent msg = new TranslationTextComponent(CompactMachines.MOD_ID + ".cannot_enter") - .withStyle(TextFormatting.RED); - - serverPlayer.displayClientMessage(msg, true); - return; - } - - ServerWorld compactWorld = serv.getLevel(Registration.COMPACT_DIMENSION); - if (compactWorld == null) { - CompactMachines.LOGGER.warn("Compact dimension not found; player attempted to enter machine."); - return; - } - - CompactMachineTile tile = (CompactMachineTile) serverWorld.getBlockEntity(machinePos); - if (tile == null) - return; - - serv.submitAsync(() -> { - BlockPos spawnPoint; - - SavedMachineData machineData = SavedMachineData.getInstance(serv); - CompactMachineServerData serverData = machineData.getData(); - - if (tile.machineId == -1) { - int nextID = serverData.getNextMachineId(); - - BlockPos center = getCenterForNewMachine(nextID, size); - - CompactStructureGenerator.generateCompactStructure(compactWorld, size, center); - - tile.setMachineId(nextID); - CompactMachineRegistrationData regData = new CompactMachineRegistrationData(nextID, center, serverPlayer.getUUID(), size); - regData.setWorldPosition(serverWorld, machinePos); - - serverData.registerMachine(nextID, regData); - machineData.setDirty(); - - BlockPos.Mutable spawn = center.mutable(); - spawn.setY(ServerConfig.MACHINE_FLOOR_Y.get()); - - spawnPoint = spawn.immutable(); - } else { - Optional info = serverData.getMachineData(tile.machineId); - - // We have no machine info here? - if (!info.isPresent()) { - IFormattableTextComponent text = new TranslationTextComponent("messages.compactmachines.no_machine_data") - .withStyle(TextFormatting.RED) - .withStyle(TextFormatting.BOLD); - - serverPlayer.displayClientMessage(text, true); - return; - } - - CompactMachineRegistrationData data = info.get(); - BlockPos.Mutable spawn = data.getCenter().mutable(); - spawn.setY(spawn.getY() - (size.getInternalSize() / 2)); - - spawnPoint = data.getSpawnPoint().orElse(spawn); - } - - try { - // Mark the player as inside the machine, set external spawn, and yeet - CompactMachinePlayerUtil.addPlayerToMachine(serverPlayer, machinePos); - } catch (Exception ex) { - CompactMachines.LOGGER.error(ex); - } - - serverPlayer.teleportTo(compactWorld, spawnPoint.getX() + 0.5, spawnPoint.getY(), spawnPoint.getZ() + 0.5, serverPlayer.yRot, serverPlayer.xRot); - }); - } - - - public static EnumMachineSize getMachineSizeFromNBT(@Nullable CompoundNBT tag) { - try { - if (tag == null) - return EnumMachineSize.TINY; - - if (!tag.contains("size")) - return EnumMachineSize.TINY; - - String sizeFromTag = tag.getString("size"); - return EnumMachineSize.getFromSize(sizeFromTag); - } catch (Exception ex) { - return EnumMachineSize.TINY; - } - } - - public static Block getMachineBlockBySize(EnumMachineSize size) { - switch (size) { - case TINY: - return Registration.MACHINE_BLOCK_TINY.get(); - - case SMALL: - return Registration.MACHINE_BLOCK_SMALL.get(); - - case NORMAL: - return Registration.MACHINE_BLOCK_NORMAL.get(); - - case LARGE: - return Registration.MACHINE_BLOCK_LARGE.get(); - - case GIANT: - return Registration.MACHINE_BLOCK_GIANT.get(); - - case MAXIMUM: - return Registration.MACHINE_BLOCK_MAXIMUM.get(); - } - - return Registration.MACHINE_BLOCK_NORMAL.get(); - } - - public static Item getMachineBlockItemBySize(EnumMachineSize size) { - switch (size) { - case TINY: - return Registration.MACHINE_BLOCK_ITEM_TINY.get(); - - case SMALL: - return Registration.MACHINE_BLOCK_ITEM_SMALL.get(); - - case NORMAL: - return Registration.MACHINE_BLOCK_ITEM_NORMAL.get(); - - case LARGE: - return Registration.MACHINE_BLOCK_ITEM_LARGE.get(); - - case GIANT: - return Registration.MACHINE_BLOCK_ITEM_GIANT.get(); - - case MAXIMUM: - return Registration.MACHINE_BLOCK_ITEM_MAXIMUM.get(); - } - - return Registration.MACHINE_BLOCK_ITEM_NORMAL.get(); - } - - public static BlockPos getCenterForNewMachine(int id, EnumMachineSize size) { - Vector3i location = MathUtil.getRegionPositionByIndex(id); - int centerY = ServerConfig.MACHINE_FLOOR_Y.get() + (size.getInternalSize() / 2); - return new BlockPos((location.getX() * 1024) + 8, centerY, (location.getZ() * 1024) + 8); - } - - public static void setMachineSpawn(MinecraftServer server, BlockPos position) { - SavedMachineData machineData = SavedMachineData.getInstance(server); - CompactMachineServerData serverData = machineData.getData(); - - Optional compactMachineData = serverData.getMachineContainingPosition(position); - compactMachineData.ifPresent(d -> { - d.setSpawnPoint(position); - serverData.updateMachineData(d); - machineData.setDirty(); - }); - } - - public static Optional getMachineData(ServerWorld world) { - if (world == null) - return Optional.empty(); - - SavedMachineData md = SavedMachineData.getInstance(world.getServer()); - return Optional.of(md); - } - - public static Optional getMachineInfoByInternalPosition(ServerWorld world, Vector3d pos) { - SavedMachineData machineData = SavedMachineData.getInstance(world.getServer()); - CompactMachineServerData serverData = machineData.getData(); - - return serverData.getMachineContainingPosition(pos); - } - - public static Optional getMachineInfoByInternalPosition(ServerWorld world, BlockPos pos) { - SavedMachineData machineData = SavedMachineData.getInstance(world.getServer()); - CompactMachineServerData serverData = machineData.getData(); - - return serverData.getMachineContainingPosition(pos); - } - - /** - * Server only; updates the machine data to reflect where the "outside" of the machine is, - * in-world. - * - * @param world - * @param machineID - * @param pos - */ - public static void updateMachineInWorldPosition(ServerWorld world, int machineID, BlockPos pos) { - SavedMachineData machineData = SavedMachineData.getInstance(world.getServer()); - CompactMachineServerData serverData = machineData.getData(); - - Optional machineById = serverData.getMachineData(machineID); - machineById.ifPresent(data -> { - data.setWorldPosition(world, pos); - data.removeFromPlayerInventory(); - - // Write changes to disk - serverData.updateMachineData(data); - machineData.setDirty(); - }); - } -} diff --git a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java index 66d85111..b3307000 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java @@ -2,14 +2,18 @@ import com.mojang.authlib.GameProfile; import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.data.legacy.CompactMachineServerData; -import com.robotgryphon.compactmachines.data.legacy.SavedMachineData; +import com.robotgryphon.compactmachines.api.core.Messages; +import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; +import com.robotgryphon.compactmachines.config.ServerConfig; +import com.robotgryphon.compactmachines.core.Registration; +import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; -import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData; import com.robotgryphon.compactmachines.data.world.ExternalMachineData; import com.robotgryphon.compactmachines.data.world.InternalMachineData; +import com.robotgryphon.compactmachines.network.MachinePlayersChangedPacket; +import com.robotgryphon.compactmachines.network.NetworkHandler; +import com.robotgryphon.compactmachines.reference.EnumMachineSize; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; -import net.minecraft.client.Minecraft; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.server.MinecraftServer; @@ -17,12 +21,17 @@ import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.ChunkPos; import net.minecraft.util.math.vector.Vector3d; -import net.minecraft.util.text.ChatType; +import net.minecraft.util.math.vector.Vector3i; +import net.minecraft.util.text.IFormattableTextComponent; +import net.minecraft.util.text.TextFormatting; import net.minecraft.util.text.TranslationTextComponent; import net.minecraft.world.IWorld; import net.minecraft.world.World; +import net.minecraft.world.chunk.Chunk; import net.minecraft.world.server.ServerWorld; +import net.minecraftforge.fml.network.PacketDistributor; +import javax.naming.OperationNotSupportedException; import java.util.Optional; import java.util.UUID; @@ -43,6 +52,106 @@ public static DimensionalPosition getPlayerDimensionalPosition(PlayerEntity play return new DimensionalPosition(dim, pos); } + public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, BlockPos machinePos, EnumMachineSize size) { + ServerWorld serverWorld = serverPlayer.getLevel(); + + MinecraftServer serv = serverWorld.getServer(); + if (serverWorld.dimension() == Registration.COMPACT_DIMENSION) { + IFormattableTextComponent msg = TranslationUtil + .message(Messages.CANNOT_ENTER_MACHINE) + .withStyle(TextFormatting.RED); + + serverPlayer.displayClientMessage(msg, true); + return; + } + + ServerWorld compactWorld = serv.getLevel(Registration.COMPACT_DIMENSION); + if (compactWorld == null) { + CompactMachines.LOGGER.warn("Compact dimension not found; player attempted to enter machine."); + return; + } + + CompactMachineTile tile = (CompactMachineTile) serverWorld.getBlockEntity(machinePos); + if (tile == null) + return; + + if (!tile.mapped()) { + ExternalMachineData extern = ExternalMachineData.get(serv); + InternalMachineData intern = InternalMachineData.get(serv); + + int nextId = intern.getNextId(); + Vector3i location = MathUtil.getRegionPositionByIndex(nextId); + + int centerY = ServerConfig.MACHINE_FLOOR_Y.get() + (size.getInternalSize() / 2); + BlockPos newCenter = new BlockPos( + (location.getX() * 1024) + 8, + centerY, + (location.getZ() * 1024) + 8); + + // Generate a new machine inside and update the tile + CompactStructureGenerator.generateCompactStructure(compactWorld, size, newCenter); + ChunkPos machineChunk = new ChunkPos(newCenter); + tile.setMachineId(nextId); + extern.machineMapping.put(nextId, machineChunk); + extern.machineLocations.put(nextId, new DimensionalPosition(serverWorld.dimension(), machinePos)); + extern.setDirty(); + + BlockPos.Mutable newSpawn = newCenter.mutable(); + newSpawn.setY(newSpawn.getY() - (size.getInternalSize() / 2)); + + try { + intern.register(machineChunk, new CompactMachineInternalData( + serverPlayer.getUUID(), + newCenter, + newSpawn, + size + )); + } catch (OperationNotSupportedException e) { + CompactMachines.LOGGER.warn(e); + } + } + + serv.submitAsync(() -> { + tile.getInternalData().ifPresent(mach -> { + BlockPos spawn = mach.getSpawn(); + InternalMachineData.get(serv).setDirty(); + try { + // Mark the player as inside the machine, set external spawn, and yeet + addPlayerToMachine(serverPlayer, machinePos); + } catch (Exception ex) { + CompactMachines.LOGGER.error(ex); + } + + serverPlayer.teleportTo( + compactWorld, + spawn.getX() + 0.5, + spawn.getY(), + spawn.getZ() + 0.5, + serverPlayer.yRot, + serverPlayer.xRot); + }); + + // TODO - Move machine generation to new method +// int nextID = serverData.getNextMachineId(); +// +// BlockPos center = getCenterForNewMachine(nextID, size); +// +// CompactStructureGenerator.generateCompactStructure(compactWorld, size, center); +// +// tile.setMachineId(nextID); +// CompactMachineRegistrationData regData = new CompactMachineRegistrationData(nextID, center, serverPlayer.getUUID(), size); +// regData.setWorldPosition(serverWorld, machinePos); +// +// serverData.registerMachine(nextID, regData); +// machineData.setDirty(); +// +// BlockPos.Mutable spawn = center.mutable(); +// spawn.setY(ServerConfig.MACHINE_FLOOR_Y.get()); +// +// spawnPoint = spawn.immutable(); + }); + } + public static void teleportPlayerOutOfMachine(ServerWorld world, ServerPlayerEntity serverPlayer) { MinecraftServer serv = world.getServer(); @@ -105,5 +214,56 @@ public static void teleportPlayerOutOfMachine(ServerWorld world, ServerPlayerEnt // }); // }); // } + + } + + public static void addPlayerToMachine(ServerPlayerEntity serverPlayer, BlockPos machinePos) { + MinecraftServer serv = serverPlayer.getServer(); + if (serv == null) + return; + + CompactMachinePlayerData playerData = CompactMachinePlayerData.get(serv); + if (playerData == null) + return; + + CompactMachineTile tile = (CompactMachineTile) serverPlayer.getLevel().getBlockEntity(machinePos); + if (tile == null) + return; + + tile.getInternalChunkPos().ifPresent(mChunk -> { + + playerData.addPlayer(serverPlayer, mChunk); + playerData.setDirty(); + + MachinePlayersChangedPacket p = new MachinePlayersChangedPacket(serv, tile.machineId, serverPlayer.getUUID(), MachinePlayersChangedPacket.EnumPlayerChangeType.ENTERED); + NetworkHandler.MAIN_CHANNEL.send( + PacketDistributor.TRACKING_CHUNK.with(() -> serverPlayer.getLevel().getChunkAt(machinePos)), + p); + }); + } + + public static void removePlayerFromMachine(ServerPlayerEntity serverPlayer, BlockPos machinePos) { + MinecraftServer serv = serverPlayer.getServer(); + + CompactMachinePlayerData playerData = CompactMachinePlayerData.get(serv); + if (playerData == null) + return; + + playerData.removePlayer(serverPlayer); + + CompactMachineTile tile = (CompactMachineTile) serverPlayer.getLevel().getBlockEntity(machinePos); + if (tile == null) + return; + + tile.getInternalChunkPos().ifPresent(mChunk -> { + + playerData.removePlayer(serverPlayer); + playerData.setDirty(); + + MachinePlayersChangedPacket p = new MachinePlayersChangedPacket(serv, tile.machineId, serverPlayer.getUUID(), MachinePlayersChangedPacket.EnumPlayerChangeType.EXITED); + NetworkHandler.MAIN_CHANNEL.send( + PacketDistributor.TRACKING_CHUNK.with(() -> serverPlayer.getLevel().getChunkAt(machinePos)), + p); + }); } } diff --git a/src/main/java/com/robotgryphon/compactmachines/util/TranslationUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/TranslationUtil.java new file mode 100644 index 00000000..71e34bf6 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/util/TranslationUtil.java @@ -0,0 +1,32 @@ +package com.robotgryphon.compactmachines.util; + +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.Util; +import net.minecraft.util.text.TranslationTextComponent; + +public abstract class TranslationUtil { + + public static String messageId(ResourceLocation message) { + return Util.makeDescriptionId("message", message); + } + + public static TranslationTextComponent message(ResourceLocation message) { + return new TranslationTextComponent(messageId(message)); + } + + public static TranslationTextComponent message(ResourceLocation message, Object... params) { + return new TranslationTextComponent(messageId(message), params); + } + + public static String tooltipId(ResourceLocation tooltip) { + return Util.makeDescriptionId("tooltip", tooltip); + } + + public static TranslationTextComponent tooltip(ResourceLocation tooltip) { + return new TranslationTextComponent(tooltipId(tooltip)); + } + + public static TranslationTextComponent tooltip(ResourceLocation tooltip, Object... params) { + return new TranslationTextComponent(tooltipId(tooltip), params); + } +} diff --git a/src/main/resources/assets/compactmachines/lang/en_us.json b/src/main/resources/assets/compactmachines/lang/en_us.json index 44855a15..e3f80e17 100644 --- a/src/main/resources/assets/compactmachines/lang/en_us.json +++ b/src/main/resources/assets/compactmachines/lang/en_us.json @@ -1,18 +1,20 @@ { "itemGroup.compactmachines": "Compact Machines", - "tooltip.compactmachines.machine_id": "Machine ID: %s", - "tooltip.compactmachines.owner": "Owner: %s", + "tooltip.compactmachines.machine.id": "Machine ID: %s", + "tooltip.compactmachines.machine.owner": "Owner: %s", + "tooltip.compactmachines.machine.size": "Internal Size: %1$sx%1$sx%1$s", "tooltip.compactmachines.unknown_player": "Unknown Player", - "tooltip.compactmachines.machine.size": "Size: %1$sx%1$sx%1$s", - "tooltip.compactmachines.hold_shift.hint": "Hold shift for details.", - "tooltip.compactmachines.psd.hint": "Used as in-game documentation and to enter Compact Machines.", - "tooltip.compactmachines.solid_wall.hint": "Warning! Unbreakable for non-creative players!", - "tooltip.compactmachines.machine.hint": "A %1$s provides a %2$s room.", "tooltip.compactmachines.tunnel_type": "Type ID: %1$s", - "messages.compactmachines.psd.spawnpoint_set": "New spawn point set.", - "messages.compactmachines.no_machine_data": "No machine data loaded; report this.", + "tooltip.compactmachines.hint.hold_shift": "Hold shift for details.", + "tooltip.compactmachines.details.psd": "Used as in-game documentation and to enter Compact Machines.", + "tooltip.compactmachines.details.solid_wall": "Warning! Unbreakable for non-creative players!", + + "message.compactmachines.cannot_enter": "You fumble with the shrinking device, to no avail. It refuses to work.", + "message.compactmachines.spawnpoint_set": "New spawn point set.", + "message.compactmachines.no_machine_data": "No machine data loaded; report this.", + "message.compactmachines.teleport_oob": "An otherworldly force prevents your teleportation.", "block.compactmachines.machine": "Compact Machine", "block.compactmachines.machine_tiny": "Compact Machine (Tiny)", @@ -39,8 +41,6 @@ "item.compactmachines.tunnels.redstone_in": "Redstone Tunnel (In)", "item.compactmachines.tunnels.redstone_out": "Redstone Tunnel (Out)", - "compactmachines.cannot_enter": "You fumble with the shrinking device, to no avail. It refuses to work.", - "compactmachines.connected_block": "Connected: %s", "compactmachines.direction.side": "Side: %s", "compactmachines.direction.up": "Up", From 7a2604c2c2cd5af56a6421a44939b027c9051f9a Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Tue, 27 Apr 2021 03:36:14 -0400 Subject: [PATCH 06/36] Packet rewrites for multiple entrypoints --- .../block/tiles/TunnelWallTile.java | 19 +-- .../machine/MachinePlayerEventHandler.java | 5 + .../data/world/ExternalMachineData.java | 10 ++ .../network/MachinePlayersChangedPacket.java | 143 +++++++++++++----- .../network/NetworkHandler.java | 16 +- .../network/TunnelAddedPacket.java | 20 +-- .../compactmachines/util/PlayerUtil.java | 16 +- 7 files changed, 149 insertions(+), 80 deletions(-) diff --git a/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java b/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java index f4bf35ea..c5f4c4a9 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java @@ -41,21 +41,6 @@ public TunnelWallTile() { super(Registration.TUNNEL_WALL_TILE.get()); } - public Optional getMachineInfo() { - if (this.level instanceof ServerWorld) { - ServerWorld serverWorld = (ServerWorld) this.level; - ChunkPos p = new ChunkPos(worldPosition); - - InternalMachineData intern = InternalMachineData.get(serverWorld.getServer()); - if (intern == null) - return Optional.empty(); - - return intern.forChunk(p); - } - - return Optional.empty(); - } - @Override public void load(BlockState state, CompoundNBT nbt) { super.load(state, nbt); @@ -199,8 +184,6 @@ public LazyOptional getCapability(@Nonnull Capability cap) { @Nonnull @Override public LazyOptional getCapability(@Nonnull Capability cap, @Nullable Direction side) { - Direction tunnelInDir = getConnectedSide(); - Optional tunnelDef = getTunnelDefinition(); // If we don't have a definition for the tunnel, skip @@ -210,7 +193,7 @@ public LazyOptional getCapability(@Nonnull Capability cap, @Nullable D // loop through tunnel definition for capabilities TunnelDefinition definition = tunnelDef.get(); if (definition instanceof ICapableTunnel) { - if (!level.isClientSide()) { + if (!level.isClientSide) { ServerWorld sw = (ServerWorld) level; return ((ICapableTunnel) definition).getExternalCapability(sw, worldPosition, cap, side); } diff --git a/src/main/java/com/robotgryphon/compactmachines/client/machine/MachinePlayerEventHandler.java b/src/main/java/com/robotgryphon/compactmachines/client/machine/MachinePlayerEventHandler.java index 912302ff..2cee69f1 100644 --- a/src/main/java/com/robotgryphon/compactmachines/client/machine/MachinePlayerEventHandler.java +++ b/src/main/java/com/robotgryphon/compactmachines/client/machine/MachinePlayerEventHandler.java @@ -14,10 +14,15 @@ public static void handlePlayerMachineChanged(UUID playerID, MachinePlayersChangedPacket.EnumPlayerChangeType changeType, DimensionalPosition pos) { ClientWorld w = Minecraft.getInstance().level; + if(w == null) + return; if (w.dimension() != pos.getDimension()) return; + if(!w.isLoaded(pos.getBlockPosition())) + return; + CompactMachineTile tile = (CompactMachineTile) w.getBlockEntity(pos.getBlockPosition()); if (tile == null) return; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java b/src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java index 3ed9ec1d..c9d8c890 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java @@ -179,4 +179,14 @@ public void setMachineLocation(int machineId, DimensionalPosition position) { public DimensionalPosition getMachineLocation(int machineId) { return machineLocations.get(machineId); } + + public Set getExternalMachineLocations(ChunkPos inside) { + Set externIDs = getExternalMachineIDs(inside); + + return machineLocations.entrySet() + .stream() + .filter(in -> externIDs.contains(in.getKey())) + .map(Map.Entry::getValue) + .collect(Collectors.toSet()); + } } diff --git a/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java b/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java index c2d22960..58ec8955 100644 --- a/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java +++ b/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java @@ -1,42 +1,63 @@ package com.robotgryphon.compactmachines.network; import com.google.common.collect.ImmutableSet; +import com.mojang.serialization.Codec; +import com.mojang.serialization.codecs.RecordCodecBuilder; import com.robotgryphon.compactmachines.CompactMachines; import com.robotgryphon.compactmachines.client.machine.MachinePlayerEventHandler; -import com.robotgryphon.compactmachines.data.legacy.CompactMachineServerData; -import com.robotgryphon.compactmachines.data.legacy.SavedMachineData; -import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData; +import com.robotgryphon.compactmachines.data.codec.CodecExtensions; +import com.robotgryphon.compactmachines.data.world.ExternalMachineData; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.network.PacketBuffer; import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.ChunkPos; import net.minecraftforge.fml.network.NetworkEvent; import javax.annotation.Nullable; -import java.util.Optional; -import java.util.UUID; +import java.io.IOException; +import java.util.*; import java.util.function.Supplier; public class MachinePlayersChangedPacket { - private MinecraftServer server; - public int machineID; + public ChunkPos machine; + public UUID playerID; public ImmutableSet machinePositions; public EnumPlayerChangeType type; - public UUID playerID; - public MachinePlayersChangedPacket(@Nullable MinecraftServer server, int machineID, UUID id, EnumPlayerChangeType type) { - this.server = server; - this.machineID = machineID; - this.machinePositions = ImmutableSet.of(); - this.playerID = id; - this.type = type; + public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( + CodecExtensions.CHUNKPOS_CODEC.fieldOf("machine").forGetter(MachinePlayersChangedPacket::getChunkPos), + CodecExtensions.UUID_CODEC.fieldOf("player").forGetter(MachinePlayersChangedPacket::getPlayer), + Codec.STRING.fieldOf("type").forGetter((p) -> p.type.name()), + DimensionalPosition.CODEC.listOf().fieldOf("positions").forGetter(p -> p.machinePositions.asList()) + ).apply(i, MachinePlayersChangedPacket::new)); + + public MachinePlayersChangedPacket(PacketBuffer buf) { + try { + MachinePlayersChangedPacket pkt = buf.readWithCodec(MachinePlayersChangedPacket.CODEC); + + machine = pkt.machine; + playerID = pkt.playerID; + machinePositions = pkt.machinePositions; + type = pkt.type; + } catch (IOException e) { + CompactMachines.LOGGER.error(e); + } + } + + private MachinePlayersChangedPacket(ChunkPos chunkPos, UUID player, String type, Collection positions) { + this.machine = chunkPos; + this.playerID = player; + this.type = EnumPlayerChangeType.valueOf(type); + this.machinePositions = ImmutableSet.copyOf(positions); } public static void handle(MachinePlayersChangedPacket message, Supplier context) { NetworkEvent.Context ctx = context.get(); message.machinePositions.forEach(machinePos -> { - CompactMachines.LOGGER.debug("Player changed machine {}; outer position {}", message.machineID, machinePos); + CompactMachines.LOGGER.debug("Player changed inside {}; outer position {}", message.machine, machinePos); MachinePlayerEventHandler.handlePlayerMachineChanged(message.playerID, message.type, machinePos); }); @@ -44,37 +65,81 @@ public static void handle(MachinePlayersChangedPacket message, Supplier machineData = data.getMachineData(pkt.machineID); - buf.writeBoolean(machineData.isPresent()); - machineData.ifPresent(mData -> { - DimensionalPosition out = mData.getOutsidePosition(pkt.server); - buf.writeNbt(out.serializeNBT()); - }); + try { + buf.writeWithCodec(CODEC, pkt); + } catch (IOException e) { + CompactMachines.LOGGER.error(e); + } } - public static MachinePlayersChangedPacket decode(PacketBuffer buf) { - int machine = buf.readInt(); - UUID id = buf.readUUID(); - EnumPlayerChangeType changeType = EnumPlayerChangeType.valueOf(buf.readUtf()); - - MachinePlayersChangedPacket pkt = new MachinePlayersChangedPacket(null, machine, id, changeType); - if(buf.readBoolean()) { - DimensionalPosition tilePos = DimensionalPosition.fromNBT(buf.readNbt()); - pkt.machinePositions = ImmutableSet.of(tilePos); - } + private UUID getPlayer() { + return playerID; + } - return pkt; + private ChunkPos getChunkPos() { + return machine; } public enum EnumPlayerChangeType { ENTERED, EXITED } + + public static class Builder { + + private final MinecraftServer server; + private EnumPlayerChangeType change; + private ChunkPos chunk; + private UUID player; + private int entryPoint; + + private Builder(MinecraftServer server) { + this.server = server; + this.change = EnumPlayerChangeType.EXITED; + } + + public static Builder create(MinecraftServer server) { + return new Builder(server); + } + + @Nullable + public MachinePlayersChangedPacket build() { + ExternalMachineData extern = ExternalMachineData.get(server); + if(extern == null) + { + CompactMachines.LOGGER.fatal("Could not load external machine data from server."); + return null; + } + + Set externalMachineIDs = extern.getExternalMachineLocations(chunk); + + return new MachinePlayersChangedPacket(chunk, player, change.name(), externalMachineIDs); + } + + public Builder forMachine(ChunkPos insideChunk) { + this.chunk = insideChunk; + return this; + } + + public Builder forPlayer(ServerPlayerEntity player) { + this.player = player.getUUID(); + return this; + } + + public Builder forPlayer(UUID player) { + this.player = player; + return this; + } + + public Builder enteredFrom(int machineId) { + this.entryPoint = machineId; + this.change = EnumPlayerChangeType.ENTERED; + return this; + } + + public Builder exited() { + this.change = EnumPlayerChangeType.EXITED; + return this; + } + } } diff --git a/src/main/java/com/robotgryphon/compactmachines/network/NetworkHandler.java b/src/main/java/com/robotgryphon/compactmachines/network/NetworkHandler.java index 018a728b..f50d8e08 100644 --- a/src/main/java/com/robotgryphon/compactmachines/network/NetworkHandler.java +++ b/src/main/java/com/robotgryphon/compactmachines/network/NetworkHandler.java @@ -19,12 +19,16 @@ public class NetworkHandler { ); public static void initialize() { - MAIN_CHANNEL.registerMessage(index++, MachinePlayersChangedPacket.class, - MachinePlayersChangedPacket::encode, MachinePlayersChangedPacket::decode, - MachinePlayersChangedPacket::handle, Optional.of(NetworkDirection.PLAY_TO_CLIENT)); + MAIN_CHANNEL.messageBuilder(MachinePlayersChangedPacket.class, index++, NetworkDirection.PLAY_TO_CLIENT) + .encoder(MachinePlayersChangedPacket::encode) + .decoder(MachinePlayersChangedPacket::new) + .consumer(MachinePlayersChangedPacket::handle) + .add(); - MAIN_CHANNEL.registerMessage(index++, TunnelAddedPacket.class, - TunnelAddedPacket::encode, TunnelAddedPacket::decode, - TunnelAddedPacket::handle, Optional.of(NetworkDirection.PLAY_TO_CLIENT)); + MAIN_CHANNEL.messageBuilder(TunnelAddedPacket.class, index++, NetworkDirection.PLAY_TO_CLIENT) + .encoder(TunnelAddedPacket::encode) + .decoder(TunnelAddedPacket::new) + .consumer(TunnelAddedPacket::handle) + .add(); } } diff --git a/src/main/java/com/robotgryphon/compactmachines/network/TunnelAddedPacket.java b/src/main/java/com/robotgryphon/compactmachines/network/TunnelAddedPacket.java index cd0c19bd..228af494 100644 --- a/src/main/java/com/robotgryphon/compactmachines/network/TunnelAddedPacket.java +++ b/src/main/java/com/robotgryphon/compactmachines/network/TunnelAddedPacket.java @@ -12,17 +12,19 @@ public class TunnelAddedPacket { - private BlockPos position; - private ResourceLocation type; - - private TunnelAddedPacket() { - } + private final BlockPos position; + private final ResourceLocation type; public TunnelAddedPacket(BlockPos tunnelPos, ResourceLocation tunnelType) { this.position = tunnelPos; this.type = tunnelType; } + public TunnelAddedPacket(PacketBuffer buf) { + position = buf.readBlockPos(); + type = buf.readResourceLocation(); + } + public static void handle(TunnelAddedPacket message, Supplier context) { NetworkEvent.Context ctx = context.get(); @@ -40,12 +42,4 @@ public static void encode(TunnelAddedPacket pkt, PacketBuffer buf) { buf.writeBlockPos(pkt.position); buf.writeResourceLocation(pkt.type); } - - public static TunnelAddedPacket decode(PacketBuffer buf) { - TunnelAddedPacket pkt = new TunnelAddedPacket(); - pkt.position = buf.readBlockPos(); - pkt.type = buf.readResourceLocation(); - - return pkt; - } } diff --git a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java index b3307000..cbfd0c9e 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java @@ -27,7 +27,6 @@ import net.minecraft.util.text.TranslationTextComponent; import net.minecraft.world.IWorld; import net.minecraft.world.World; -import net.minecraft.world.chunk.Chunk; import net.minecraft.world.server.ServerWorld; import net.minecraftforge.fml.network.PacketDistributor; @@ -105,7 +104,7 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl newCenter, newSpawn, size - )); + )); } catch (OperationNotSupportedException e) { CompactMachines.LOGGER.warn(e); } @@ -235,7 +234,12 @@ public static void addPlayerToMachine(ServerPlayerEntity serverPlayer, BlockPos playerData.addPlayer(serverPlayer, mChunk); playerData.setDirty(); - MachinePlayersChangedPacket p = new MachinePlayersChangedPacket(serv, tile.machineId, serverPlayer.getUUID(), MachinePlayersChangedPacket.EnumPlayerChangeType.ENTERED); + MachinePlayersChangedPacket p = MachinePlayersChangedPacket.Builder.create(serv) + .forMachine(mChunk) + .forPlayer(serverPlayer) + .enteredFrom(tile.machineId) + .build(); + NetworkHandler.MAIN_CHANNEL.send( PacketDistributor.TRACKING_CHUNK.with(() -> serverPlayer.getLevel().getChunkAt(machinePos)), p); @@ -260,7 +264,11 @@ public static void removePlayerFromMachine(ServerPlayerEntity serverPlayer, Bloc playerData.removePlayer(serverPlayer); playerData.setDirty(); - MachinePlayersChangedPacket p = new MachinePlayersChangedPacket(serv, tile.machineId, serverPlayer.getUUID(), MachinePlayersChangedPacket.EnumPlayerChangeType.EXITED); + MachinePlayersChangedPacket p = MachinePlayersChangedPacket.Builder.create(serv) + .forMachine(mChunk) + .forPlayer(serverPlayer) + .build(); + NetworkHandler.MAIN_CHANNEL.send( PacketDistributor.TRACKING_CHUNK.with(() -> serverPlayer.getLevel().getChunkAt(machinePos)), p); From a61d749b2afdcfc8071a0531f3b9bfeada820b57 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Thu, 29 Apr 2021 20:18:08 -0400 Subject: [PATCH 07/36] Add spiral algorithm test cases --- .../compactmachines/util/MathUtil.java | 8 ++++ .../compactmachines/util/PlayerUtil.java | 5 +-- .../compactmachines/tests/MathTests.java | 44 +++++++++++++++++++ 3 files changed, 53 insertions(+), 4 deletions(-) create mode 100644 src/test/java/com/robotgryphon/compactmachines/tests/MathTests.java diff --git a/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java index 1aeb8fe2..76ecacad 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java @@ -1,5 +1,6 @@ package com.robotgryphon.compactmachines.util; +import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.vector.Vector3i; public class MathUtil { @@ -40,4 +41,11 @@ public static Vector3i getRegionPositionByIndex(int i) { return new Vector3i(x, 0, y); } + + public static BlockPos getCenterWithY(Vector3i regionIndex, int y) { + return new BlockPos( + (regionIndex.getX() * 1024) + 8, + y, + (regionIndex.getZ() * 1024) + 8); + } } diff --git a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java index cbfd0c9e..482462ef 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java @@ -82,10 +82,7 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl Vector3i location = MathUtil.getRegionPositionByIndex(nextId); int centerY = ServerConfig.MACHINE_FLOOR_Y.get() + (size.getInternalSize() / 2); - BlockPos newCenter = new BlockPos( - (location.getX() * 1024) + 8, - centerY, - (location.getZ() * 1024) + 8); + BlockPos newCenter = MathUtil.getCenterWithY(location, centerY); // Generate a new machine inside and update the tile CompactStructureGenerator.generateCompactStructure(compactWorld, size, newCenter); diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/MathTests.java b/src/test/java/com/robotgryphon/compactmachines/tests/MathTests.java new file mode 100644 index 00000000..e880a4d8 --- /dev/null +++ b/src/test/java/com/robotgryphon/compactmachines/tests/MathTests.java @@ -0,0 +1,44 @@ +package com.robotgryphon.compactmachines.tests; + +import com.robotgryphon.compactmachines.util.MathUtil; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.util.math.vector.Vector3i; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; + +public class MathTests { + + @Test + void positionGeneratorWorksCorrectly() { + // Our generation works in a counter-clockwise spiral, starting at 0,0 + /* + * 6 5 4 + * 7 0 3 + * 8 1 2 + */ + + HashMap tests = new HashMap<>(); + tests.put(0, new ChunkPos(0, 0)); + tests.put(1, new ChunkPos(0, -64)); + tests.put(2, new ChunkPos(64, -64)); + tests.put(3, new ChunkPos(64, 0)); + tests.put(4, new ChunkPos(64, 64)); + tests.put(5, new ChunkPos(0, 64)); + tests.put(6, new ChunkPos(-64, 64)); + tests.put(7, new ChunkPos(-64, 0)); + tests.put(8, new ChunkPos(-64, -64)); + + tests.forEach((id, expectedChunk) -> { + Vector3i byIndex = MathUtil.getRegionPositionByIndex(id); + BlockPos finalPos = MathUtil.getCenterWithY(byIndex, 0); + + ChunkPos calculatedChunk = new ChunkPos(finalPos); + + String error = String.format("Generation did not match for %s.", id); + Assertions.assertEquals(expectedChunk, calculatedChunk, error); + }); + } +} From 2439d86a3939a986359f7059f94ed14f4b8ae883 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Thu, 29 Apr 2021 20:22:41 -0400 Subject: [PATCH 08/36] Add dimensional position equality, test FileHelper class --- .../teleportation/DimensionalPosition.java | 14 ++++++ .../tests/util/FileHelper.java | 45 +++++++++++++++++++ 2 files changed, 59 insertions(+) create mode 100644 src/test/java/com/robotgryphon/compactmachines/tests/util/FileHelper.java diff --git a/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java b/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java index 31c089f0..0994080a 100644 --- a/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java +++ b/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java @@ -19,6 +19,7 @@ import net.minecraftforge.common.util.INBTSerializable; import javax.annotation.Nonnull; +import java.util.Objects; import java.util.Optional; public class DimensionalPosition implements INBTSerializable { @@ -93,6 +94,19 @@ public BlockPos getBlockPosition() { return new BlockPos(position.x, position.y, position.z); } + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + DimensionalPosition that = (DimensionalPosition) o; + return Objects.equals(dimension, that.dimension) && Objects.equals(position, that.position); + } + + @Override + public int hashCode() { + return Objects.hash(dimension, position); + } + @Override public String toString() { return "DimensionalPosition{" + diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/util/FileHelper.java b/src/test/java/com/robotgryphon/compactmachines/tests/util/FileHelper.java new file mode 100644 index 00000000..5f898710 --- /dev/null +++ b/src/test/java/com/robotgryphon/compactmachines/tests/util/FileHelper.java @@ -0,0 +1,45 @@ +package com.robotgryphon.compactmachines.tests.util; + +import com.google.gson.Gson; +import com.google.gson.JsonElement; +import net.minecraft.nbt.CompoundNBT; +import net.minecraft.nbt.CompressedStreamTools; + +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.net.URL; + +public class FileHelper { + public static final FileHelper INSTANCE = new FileHelper(); + + private FileHelper() { + } + + public InputStream getFileStream(String filename) { + return getClass().getClassLoader().getResourceAsStream(filename); + } + + public InputStreamReader openFile(String filename) { + URL res = getClass().getClassLoader().getResource(filename); + try { + InputStream inputStream = res.openStream(); + return new InputStreamReader(inputStream); + } catch (IOException e) { + e.printStackTrace(); + } + + return null; + } + + public JsonElement getJsonFromFile(String filename) { + Gson g = new Gson(); + InputStreamReader isr = openFile(filename); + return g.fromJson(isr, JsonElement.class); + } + + public CompoundNBT getNbtFromFile(String filename) throws IOException { + InputStream isr = getFileStream(filename); + return CompressedStreamTools.readCompressed(isr); + } +} From 2af5bb26e139eea171a80897ad3f23d8ddadd595 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 1 May 2021 13:15:14 -0400 Subject: [PATCH 09/36] Working on graph structure and unit tests --- .gitignore | 2 + graph.dot | 257 --------------- .../legacy/CompactMachineBaseData.java | 0 .../legacy/CompactMachineCommonData.java | 0 .../CompactMachineRegistrationData.java | 0 .../legacy/CompactMachineServerData.java | 0 .../data => }/legacy/SavedMachineData.java | 0 .../legacy/SavedMachineDataMigrator.java | 0 .../block/tiles/CompactMachineTile.java | 4 +- .../block/tiles/TunnelWallTile.java | 5 +- .../core/ServerEventHandler.java | 3 +- .../graph/CompactMachineConnectionGraph.java | 150 +++++++++ .../data/graph/CompactMachineNode.java | 27 +- ...eNode.java => CompactMachineRoomNode.java} | 10 +- .../data/graph/MachineExternalLocation.java | 6 - .../data/machine/CompactMachineExternal.java | 37 +++ .../ExternalMachineData.java | 2 +- .../InternalMachineData.java | 2 +- .../data/persistent/MachineConnections.java | 42 +++ .../item/ItemBlockMachine.java | 2 +- .../item/ItemPersonalShrinkingDevice.java | 2 +- .../network/MachinePlayersChangedPacket.java | 2 +- .../TeleportationEventHandler.java | 7 +- .../compactmachines/tunnels/TunnelHelper.java | 74 ++--- .../compactmachines/util/PlayerUtil.java | 4 +- .../compactmachines/tests/GraphTests.java | 312 ++++++++++-------- .../compactmachines/tests/MathTests.java | 5 +- .../tests/minecraft/ExampleTest.java | 4 +- .../tests/nbt/MachineExternalDataTests.java | 62 ++++ .../machines_external.dat | Bin 0 -> 154 bytes .../machines_internal.dat | Bin 0 -> 159 bytes .../single-machine-player-inside/players.dat | Bin 0 -> 191 bytes 32 files changed, 532 insertions(+), 489 deletions(-) delete mode 100644 graph.dot rename src/{main/java/com/robotgryphon/compactmachines/data => }/legacy/CompactMachineBaseData.java (100%) rename src/{main/java/com/robotgryphon/compactmachines/data => }/legacy/CompactMachineCommonData.java (100%) rename src/{main/java/com/robotgryphon/compactmachines/data => }/legacy/CompactMachineRegistrationData.java (100%) rename src/{main/java/com/robotgryphon/compactmachines/data => }/legacy/CompactMachineServerData.java (100%) rename src/{main/java/com/robotgryphon/compactmachines/data => }/legacy/SavedMachineData.java (100%) rename src/{main/java/com/robotgryphon/compactmachines/data => }/legacy/SavedMachineDataMigrator.java (100%) create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java rename src/main/java/com/robotgryphon/compactmachines/data/graph/{CompactMachineInsideNode.java => CompactMachineRoomNode.java} (78%) delete mode 100644 src/main/java/com/robotgryphon/compactmachines/data/graph/MachineExternalLocation.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineExternal.java rename src/main/java/com/robotgryphon/compactmachines/data/{world => persistent}/ExternalMachineData.java (99%) rename src/main/java/com/robotgryphon/compactmachines/data/{world => persistent}/InternalMachineData.java (98%) create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java create mode 100644 src/test/java/com/robotgryphon/compactmachines/tests/nbt/MachineExternalDataTests.java create mode 100644 src/test/resources/scenario/single-machine-player-inside/machines_external.dat create mode 100644 src/test/resources/scenario/single-machine-player-inside/machines_internal.dat create mode 100644 src/test/resources/scenario/single-machine-player-inside/players.dat diff --git a/.gitignore b/.gitignore index 7c73c0ce..e51a7c00 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,5 @@ forge*changelog.txt logs/ /mods/ /build-out/ + +*.dot diff --git a/graph.dot b/graph.dot deleted file mode 100644 index d2dd2659..00000000 --- a/graph.dot +++ /dev/null @@ -1,257 +0,0 @@ -strict digraph G { - layout = fdp; - node [shape=square,style=filled,color=lightgray]; - machine0 [label="Compact Machine #0",style=filled,color=lightgray] - machine1 [label="Compact Machine #1",style=filled,color=lightgray] - machine2 [label="Compact Machine #2",style=filled,color=lightgray] - machine3 [label="Compact Machine #3",style=filled,color=lightgray] - machine4 [label="Compact Machine #4",style=filled,color=lightgray] - machine5 [label="Compact Machine #5",style=filled,color=lightgray] - machine6 [label="Compact Machine #6",style=filled,color=lightgray] - machine7 [label="Compact Machine #7",style=filled,color=lightgray] - machine8 [label="Compact Machine #8",style=filled,color=lightgray] - machine9 [label="Compact Machine #9",style=filled,color=lightgray] - machine12 [label="Compact Machine #12",style=filled,color=lightgray] - machine13 [label="Compact Machine #13",style=filled,color=lightgray] - machine14 [label="Compact Machine #14",style=filled,color=lightgray] - machine15 [label="Compact Machine #15",style=filled,color=lightgray] - machine18 [label="Compact Machine #18",style=filled,color=lightgray] - machine20 [label="Compact Machine #20",style=filled,color=lightgray] - machine26 [label="Compact Machine #26",style=filled,color=lightgray] - machine27 [label="Compact Machine #27",style=filled,color=lightgray] - machine28 [label="Compact Machine #28",style=filled,color=lightgray] - machine29 [label="Compact Machine #29",style=filled,color=lightgray] - machine30 [label="Compact Machine #30",style=filled,color=lightgray] - machine31 [label="Compact Machine #31",style=filled,color=lightgray] - machine32 [label="Compact Machine #32",style=filled,color=lightgray] - machine33 [label="Compact Machine #33",style=filled,color=lightgray] - machine36 [label="Compact Machine #36",style=filled,color=lightgray] - machine37 [label="Compact Machine #37",style=filled,color=lightgray] - machine38 [label="Compact Machine #38",style=filled,color=lightgray] - machine39 [label="Compact Machine #39",style=filled,color=lightgray] - machine40 [label="Compact Machine #40",style=filled,color=lightgray] - machine41 [label="Compact Machine #41",style=filled,color=lightgray] - machine42 [label="Compact Machine #42",style=filled,color=lightgray] - machine43 [label="Compact Machine #43",style=filled,color=lightgray] - machine44 [label="Compact Machine #44",style=filled,color=lightgray] - machine45 [label="Compact Machine #45",style=filled,color=lightgray] - machine46 [label="Compact Machine #46",style=filled,color=lightgray] - machine47 [label="Compact Machine #47",style=filled,color=lightgray] - machine48 [label="Compact Machine #48",style=filled,color=lightgray] - machine49 [label="Compact Machine #49",style=filled,color=lightgray] - machine50 [label="Compact Machine #50",style=filled,color=lightgray] - machine51 [label="Compact Machine #51",style=filled,color=lightgray] - machine52 [label="Compact Machine #52",style=filled,color=lightgray] - machine53 [label="Compact Machine #53",style=filled,color=lightgray] - machine54 [label="Compact Machine #54",style=filled,color=lightgray] - machine55 [label="Compact Machine #55",style=filled,color=lightgray] - machine56 [label="Compact Machine #56",style=filled,color=lightgray] - machine57 [label="Compact Machine #57",style=filled,color=lightgray] - machine58 [label="Compact Machine #58",style=filled,color=lightgray] - machine59 [label="Compact Machine #59",style=filled,color=lightgray] - machine60 [label="Compact Machine #60",style=filled,color=lightgray] - machine13->cluster_internal_1 - machine2->cluster_internal_1 - machine20->cluster_internal_1 - subgraph cluster_internal_1 { - graph [label="Compact Machine {1,0}",style=filled,color=cadetblue] - } - - machine38->cluster_internal_12884901886 - subgraph cluster_internal_12884901886 { - graph [label="Compact Machine {-2,2}",style=filled,color=cadetblue] - } - - machine57->cluster_internal_12884901887 - subgraph cluster_internal_12884901887 { - graph [label="Compact Machine {-1,2}",style=filled,color=cadetblue] - } - - machine60->cluster_internal_12884901890 - subgraph cluster_internal_12884901890 { - graph [label="Compact Machine {2,3}",style=filled,color=cadetblue] - } - - machine47->cluster_internal_12884901891 - subgraph cluster_internal_12884901891 { - graph [label="Compact Machine {3,3}",style=filled,color=cadetblue] - } - - machine41->cluster_internal_2 - subgraph cluster_internal_2 { - graph [label="Compact Machine {2,0}",style=filled,color=cadetblue] - } - - machine56->cluster_internal_3 - subgraph cluster_internal_3 { - graph [label="Compact Machine {3,0}",style=filled,color=cadetblue] - } - - machine55->cluster_internal_4294967294 - subgraph cluster_internal_4294967294 { - graph [label="Compact Machine {-2,0}",style=filled,color=cadetblue] - } - - machine12->cluster_internal_4294967295 - machine6->cluster_internal_4294967295 - subgraph cluster_internal_4294967295 { - graph [label="Compact Machine {-1,0}",style=filled,color=cadetblue] - machine11 [label="Compact Machine #11",style=filled,color=lightgray] - machine21 [label="Compact Machine #21",style=filled,color=lightgray] - machine16 [label="Compact Machine #16",style=filled,color=palevioletred1] - } - - machine4->cluster_internal_4294967296 - subgraph cluster_internal_4294967296 { - graph [label="Compact Machine {0,1}",style=filled,color=cadetblue] - } - - machine33->cluster_internal_4294967297 - machine18->cluster_internal_4294967297 - machine3->cluster_internal_4294967297 - machine28->cluster_internal_4294967297 - machine29->cluster_internal_4294967297 - subgraph cluster_internal_4294967297 { - graph [label="Compact Machine {1,1}",style=filled,color=cadetblue] - machine35 [label="Compact Machine #35",style=filled,color=palevioletred1] - } - - machine46->cluster_internal_4294967298 - subgraph cluster_internal_4294967298 { - graph [label="Compact Machine {2,1}",style=filled,color=cadetblue] - } - - machine59->cluster_internal_4294967299 - subgraph cluster_internal_4294967299 { - graph [label="Compact Machine {3,1}",style=filled,color=cadetblue] - } - - machine49->cluster_internal_8589934590 - subgraph cluster_internal_8589934590 { - graph [label="Compact Machine {-2,1}",style=filled,color=cadetblue] - } - - machine5->cluster_internal_8589934591 - machine32->cluster_internal_8589934591 - subgraph cluster_internal_8589934591 { - graph [label="Compact Machine {-1,1}",style=filled,color=cadetblue] - machine25 [label="Compact Machine #25",style=filled,color=lightgray] - machine22 [label="Compact Machine #22",style=filled,color=palevioletred1] - } - - machine36->cluster_internal_8589934592 - subgraph cluster_internal_8589934592 { - graph [label="Compact Machine {0,2}",style=filled,color=cadetblue] - } - - machine44->cluster_internal_8589934593 - subgraph cluster_internal_8589934593 { - graph [label="Compact Machine {1,2}",style=filled,color=cadetblue] - } - - machine51->cluster_internal_8589934594 - subgraph cluster_internal_8589934594 { - graph [label="Compact Machine {2,2}",style=filled,color=cadetblue] - } - - machine40->cluster_internal_8589934595 - subgraph cluster_internal_8589934595 { - graph [label="Compact Machine {3,2}",style=filled,color=cadetblue] - } - - machine25->cluster_internal_N1 - machine30->cluster_internal_N1 - machine7->cluster_internal_N1 - subgraph cluster_internal_N1 { - graph [label="Compact Machine {-1,-1}",style=filled,color=cadetblue] - machine34 [label="Compact Machine #34",style=filled,color=palevioletred1] - } - - machine48->cluster_internal_N12884901885 - subgraph cluster_internal_N12884901885 { - graph [label="Compact Machine {3,-3}",style=filled,color=cadetblue] - } - - machine50->cluster_internal_N12884901886 - subgraph cluster_internal_N12884901886 { - graph [label="Compact Machine {2,-3}",style=filled,color=cadetblue] - } - - machine37->cluster_internal_N12884901887 - subgraph cluster_internal_N12884901887 { - graph [label="Compact Machine {1,-3}",style=filled,color=cadetblue] - } - - machine42->cluster_internal_N12884901888 - subgraph cluster_internal_N12884901888 { - graph [label="Compact Machine {0,-3}",style=filled,color=cadetblue] - } - - machine54->cluster_internal_N2 - subgraph cluster_internal_N2 { - graph [label="Compact Machine {-2,-1}",style=filled,color=cadetblue] - } - - machine53->cluster_internal_N4294967293 - subgraph cluster_internal_N4294967293 { - graph [label="Compact Machine {3,-1}",style=filled,color=cadetblue] - } - - machine39->cluster_internal_N4294967294 - subgraph cluster_internal_N4294967294 { - graph [label="Compact Machine {2,-1}",style=filled,color=cadetblue] - } - - machine1->cluster_internal_N4294967295 - machine27->cluster_internal_N4294967295 - machine14->cluster_internal_N4294967295 - machine23->cluster_internal_N4294967295 - subgraph cluster_internal_N4294967295 { - graph [label="Compact Machine {1,-1}",style=filled,color=cadetblue] - machine17 [label="Compact Machine #17",style=filled,color=palevioletred1] - } - - machine26->cluster_internal_N4294967296 - machine0->cluster_internal_N4294967296 - subgraph cluster_internal_N4294967296 { - graph [label="Compact Machine {0,-1}",style=filled,color=cadetblue] - machine19 [label="Compact Machine #19",style=filled,color=palevioletred1] - } - - machine52->cluster_internal_N4294967297 - subgraph cluster_internal_N4294967297 { - graph [label="Compact Machine {-1,-2}",style=filled,color=cadetblue] - } - - machine45->cluster_internal_N4294967298 - subgraph cluster_internal_N4294967298 { - graph [label="Compact Machine {-2,-2}",style=filled,color=cadetblue] - } - - machine43->cluster_internal_N8589934589 - subgraph cluster_internal_N8589934589 { - graph [label="Compact Machine {3,-2}",style=filled,color=cadetblue] - } - - machine58->cluster_internal_N8589934590 - subgraph cluster_internal_N8589934590 { - graph [label="Compact Machine {2,-2}",style=filled,color=cadetblue] - } - - machine9->cluster_internal_N8589934591 - machine15->cluster_internal_N8589934591 - subgraph cluster_internal_N8589934591 { - graph [label="Compact Machine {1,-2}",style=filled,color=cadetblue] - machine24 [label="Compact Machine #24",style=filled,color=palevioletred1] - } - - machine11->cluster_internal_N8589934592 - machine21->cluster_internal_N8589934592 - machine31->cluster_internal_N8589934592 - machine8->cluster_internal_N8589934592 - subgraph cluster_internal_N8589934592 { - graph [label="Compact Machine {0,-2}",style=filled,color=cadetblue] - machine23 [label="Compact Machine #23",style=filled,color=lightgray] - } - -} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineBaseData.java b/src/legacy/CompactMachineBaseData.java similarity index 100% rename from src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineBaseData.java rename to src/legacy/CompactMachineBaseData.java diff --git a/src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineCommonData.java b/src/legacy/CompactMachineCommonData.java similarity index 100% rename from src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineCommonData.java rename to src/legacy/CompactMachineCommonData.java diff --git a/src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineRegistrationData.java b/src/legacy/CompactMachineRegistrationData.java similarity index 100% rename from src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineRegistrationData.java rename to src/legacy/CompactMachineRegistrationData.java diff --git a/src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineServerData.java b/src/legacy/CompactMachineServerData.java similarity index 100% rename from src/main/java/com/robotgryphon/compactmachines/data/legacy/CompactMachineServerData.java rename to src/legacy/CompactMachineServerData.java diff --git a/src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineData.java b/src/legacy/SavedMachineData.java similarity index 100% rename from src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineData.java rename to src/legacy/SavedMachineData.java diff --git a/src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineDataMigrator.java b/src/legacy/SavedMachineDataMigrator.java similarity index 100% rename from src/main/java/com/robotgryphon/compactmachines/data/legacy/SavedMachineDataMigrator.java rename to src/legacy/SavedMachineDataMigrator.java diff --git a/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java b/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java index bece8fef..79dcfda1 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java @@ -4,8 +4,8 @@ import com.robotgryphon.compactmachines.core.Registration; import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; -import com.robotgryphon.compactmachines.data.world.ExternalMachineData; -import com.robotgryphon.compactmachines.data.world.InternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.ExternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.InternalMachineData; import com.robotgryphon.compactmachines.reference.Reference; import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; diff --git a/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java b/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java index c5f4c4a9..c0405042 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java @@ -5,9 +5,7 @@ import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; import com.robotgryphon.compactmachines.block.walls.TunnelWallBlock; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; -import com.robotgryphon.compactmachines.data.world.ExternalMachineData; -import com.robotgryphon.compactmachines.data.world.InternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.ExternalMachineData; import com.robotgryphon.compactmachines.network.NetworkHandler; import com.robotgryphon.compactmachines.network.TunnelAddedPacket; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; @@ -19,7 +17,6 @@ import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.ChunkPos; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.chunk.Chunk; import net.minecraft.world.server.ServerWorld; import net.minecraftforge.common.capabilities.Capability; diff --git a/src/main/java/com/robotgryphon/compactmachines/core/ServerEventHandler.java b/src/main/java/com/robotgryphon/compactmachines/core/ServerEventHandler.java index ab314a24..24d28660 100644 --- a/src/main/java/com/robotgryphon/compactmachines/core/ServerEventHandler.java +++ b/src/main/java/com/robotgryphon/compactmachines/core/ServerEventHandler.java @@ -1,7 +1,6 @@ package com.robotgryphon.compactmachines.core; import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.data.legacy.SavedMachineDataMigrator; import net.minecraft.server.MinecraftServer; import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.fml.common.Mod; @@ -13,6 +12,6 @@ public class ServerEventHandler { @SubscribeEvent public static void onServerStarting(final FMLServerStartingEvent evt) { MinecraftServer server = evt.getServer(); - SavedMachineDataMigrator.migrate(server); + // SavedMachineDataMigrator.migrate(server); } } diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java new file mode 100644 index 00000000..62675d33 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java @@ -0,0 +1,150 @@ +package com.robotgryphon.compactmachines.data.graph; + +import com.google.common.graph.ElementOrder; +import com.google.common.graph.GraphBuilder; +import com.google.common.graph.MutableGraph; +import com.mojang.serialization.Codec; +import com.mojang.serialization.codecs.RecordCodecBuilder; +import com.robotgryphon.compactmachines.data.codec.CodecExtensions; +import net.minecraft.util.math.ChunkPos; + +import java.util.*; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * Stores information on how external machines connect to the rooms in the compact machine + * dimension. + */ +public class CompactMachineConnectionGraph { + + private final MutableGraph graph; + private final Map machines; + private final Map rooms; + + private static final Codec CONNECTION_INFO_CODEC = RecordCodecBuilder.create(i -> i.group( + CodecExtensions.CHUNKPOS_CODEC + .fieldOf("machine") + .forGetter(CompactMachineConnectionInfo::room), + + Codec.INT.listOf() + .fieldOf("connections") + .forGetter(CompactMachineConnectionInfo::machines) + ).apply(i, CompactMachineConnectionInfo::new)); + + public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( + CONNECTION_INFO_CODEC.listOf() + .fieldOf("connections") + .forGetter(CompactMachineConnectionGraph::buildConnections) + ).apply(i, CompactMachineConnectionGraph::new)); + + + + public CompactMachineConnectionGraph() { + graph = GraphBuilder + .directed() + .nodeOrder(ElementOrder.sorted(Comparator.comparing(IMachineGraphNode::getId))) + .build(); + + machines = new HashMap<>(); + rooms = new HashMap<>(); + } + + private CompactMachineConnectionGraph(List connections) { + this(); + + for(CompactMachineConnectionInfo i : connections) { + addRoom(i.roomChunk); + for(int connectedMachine : i.machines()) { + addMachine(connectedMachine); + connectMachineToRoom(connectedMachine, i.roomChunk); + } + } + } + + private List buildConnections() { + return Collections.emptyList(); + } + + public void addMachine(int machine) { + if(this.machines.containsKey(machine)) + return; + + CompactMachineNode node = new CompactMachineNode(machine); + graph.addNode(node); + machines.put(machine, node); + } + + public void addRoom(ChunkPos roomChunk) { + if(this.rooms.containsKey(roomChunk)) + return; + + CompactMachineRoomNode node = new CompactMachineRoomNode(roomChunk); + graph.addNode(node); + rooms.put(roomChunk, node); + } + + public void connectMachineToRoom(int machine, ChunkPos room) { + if(!machines.containsKey(machine)) + return; + + if(!rooms.containsKey(room)) + return; + + CompactMachineNode machineNode = machines.get(machine); + CompactMachineRoomNode roomNode = rooms.get(room); + + graph.putEdge(machineNode, roomNode); + } + + public Collection getMachinesFor(ChunkPos machineChunk) { + CompactMachineRoomNode node = this.rooms.get(machineChunk); + if(node == null) + return Collections.emptySet(); + + Set inbound = graph.predecessors(node); + return inbound.stream() + .filter(ibn -> ibn instanceof CompactMachineNode) + .map(ibn -> (CompactMachineNode) ibn) + .map(CompactMachineNode::getMachineId) + .collect(Collectors.toSet()); + } + + public Optional getConnectedRoom(int machine) { + if(!this.machines.containsKey(machine)) + return Optional.empty(); + + CompactMachineNode node = this.machines.get(machine); + Set connected = this.graph.successors(node); + return connected.stream() + .filter(n -> n instanceof CompactMachineRoomNode) + .map(n -> (CompactMachineRoomNode) n) + .map(CompactMachineRoomNode::getChunk) + .findFirst(); + } + + public Stream getMachines() { + return this.machines.values().stream(); + } + + /** + * Data structure for serialization. Do not use directly. + */ + private static class CompactMachineConnectionInfo { + private final ChunkPos roomChunk; + private final List connectedMachines; + + public CompactMachineConnectionInfo(ChunkPos roomChunk, List connections) { + this.roomChunk = roomChunk; + this.connectedMachines = connections; + } + + public ChunkPos room() { + return this.roomChunk; + } + + public List machines() { + return this.connectedMachines; + } + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineNode.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineNode.java index 02880d67..3f012767 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineNode.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineNode.java @@ -1,7 +1,6 @@ package com.robotgryphon.compactmachines.data.graph; import com.google.common.graph.MutableGraph; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; import java.util.Objects; @@ -9,28 +8,10 @@ * Represents a machine's external point. This can be either inside a machine or in a dimension somewhere. */ public class CompactMachineNode implements IMachineGraphNode { - public boolean isConnected; - private int machineId; - private IMachineGraphNode linkedTo; - public MachineExternalLocation location; - public DimensionalPosition position; - private MutableGraph graph; - - public CompactMachineNode(MutableGraph graph, int machine) { - this.graph = graph; - this.machineId = machine; - this.isConnected = false; - } - - public void connectTo(IMachineGraphNode newInside) { - if (this.linkedTo != null) { - graph.removeEdge(this, linkedTo); - this.isConnected = false; - } + private final int machineId; - this.linkedTo = newInside; - this.isConnected = true; - graph.putEdge(this, linkedTo); + public CompactMachineNode(int machine) { + this.machineId = machine; } @Override @@ -43,6 +24,8 @@ public String getId() { return "machine" + machineId; } + public int getMachineId() { return machineId; } + @Override public boolean equals(Object o) { if (this == o) return true; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineInsideNode.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineRoomNode.java similarity index 78% rename from src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineInsideNode.java rename to src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineRoomNode.java index 5143af93..7781f438 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineInsideNode.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineRoomNode.java @@ -7,11 +7,11 @@ /** * Represents the inside of a Compact Machine. */ -public class CompactMachineInsideNode implements IMachineGraphNode { +public class CompactMachineRoomNode implements IMachineGraphNode { private final ChunkPos pos; - public CompactMachineInsideNode(ChunkPos pos) { + public CompactMachineRoomNode(ChunkPos pos) { this.pos = pos; } @@ -34,7 +34,7 @@ public static String getIdFor(ChunkPos pos) { public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; - CompactMachineInsideNode that = (CompactMachineInsideNode) o; + CompactMachineRoomNode that = (CompactMachineRoomNode) o; return pos.equals(that.pos); } @@ -42,4 +42,8 @@ public boolean equals(Object o) { public int hashCode() { return Objects.hash(pos); } + + public ChunkPos getChunk() { + return pos; + } } diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/MachineExternalLocation.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/MachineExternalLocation.java deleted file mode 100644 index 7b6b1f5e..00000000 --- a/src/main/java/com/robotgryphon/compactmachines/data/graph/MachineExternalLocation.java +++ /dev/null @@ -1,6 +0,0 @@ -package com.robotgryphon.compactmachines.data.graph; - -public enum MachineExternalLocation { - INSIDE_MACHINE, - EXTERNAL_DIMENSION -} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineExternal.java b/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineExternal.java new file mode 100644 index 00000000..96869540 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineExternal.java @@ -0,0 +1,37 @@ +package com.robotgryphon.compactmachines.data.machine; + +import com.mojang.serialization.Codec; +import com.mojang.serialization.codecs.RecordCodecBuilder; +import com.robotgryphon.compactmachines.data.codec.CodecExtensions; +import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import net.minecraft.util.math.ChunkPos; + +public class CompactMachineExternal { + private final int machineId; + public DimensionalPosition location; + private ChunkPos chunk; + + public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( + Codec.INT.fieldOf("machine").forGetter(CompactMachineExternal::getMachineId), + DimensionalPosition.CODEC.fieldOf("location").forGetter(CompactMachineExternal::getLocation), + CodecExtensions.CHUNKPOS_CODEC.fieldOf("chunk").forGetter(CompactMachineExternal::getMappedChunk) + ).apply(i, CompactMachineExternal::new)); + + public CompactMachineExternal(int machineId, DimensionalPosition location, ChunkPos inside) { + this.machineId = machineId; + this.location = location; + this.chunk = inside; + } + + public int getMachineId() { + return this.machineId; + } + + public DimensionalPosition getLocation() { + return this.location; + } + + public ChunkPos getMappedChunk() { + return this.chunk; + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java b/src/main/java/com/robotgryphon/compactmachines/data/persistent/ExternalMachineData.java similarity index 99% rename from src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java rename to src/main/java/com/robotgryphon/compactmachines/data/persistent/ExternalMachineData.java index c9d8c890..243dd41a 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/persistent/ExternalMachineData.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.data.world; +package com.robotgryphon.compactmachines.data.persistent; import com.robotgryphon.compactmachines.CompactMachines; import com.robotgryphon.compactmachines.core.Registration; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/world/InternalMachineData.java b/src/main/java/com/robotgryphon/compactmachines/data/persistent/InternalMachineData.java similarity index 98% rename from src/main/java/com/robotgryphon/compactmachines/data/world/InternalMachineData.java rename to src/main/java/com/robotgryphon/compactmachines/data/persistent/InternalMachineData.java index 9ffb1470..b20ddc5c 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/world/InternalMachineData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/persistent/InternalMachineData.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.data.world; +package com.robotgryphon.compactmachines.data.persistent; import com.mojang.serialization.DataResult; import com.robotgryphon.compactmachines.CompactMachines; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java b/src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java new file mode 100644 index 00000000..e7c2b6f3 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java @@ -0,0 +1,42 @@ +package com.robotgryphon.compactmachines.data.persistent; + +import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.core.Registration; +import com.robotgryphon.compactmachines.data.graph.CompactMachineConnectionGraph; +import net.minecraft.nbt.CompoundNBT; +import net.minecraft.server.MinecraftServer; +import net.minecraft.world.server.ServerWorld; +import net.minecraft.world.storage.DimensionSavedDataManager; +import net.minecraft.world.storage.WorldSavedData; + +public class MachineConnections extends WorldSavedData { + public static final String DATA_NAME = CompactMachines.MOD_ID + "_connections"; + + private CompactMachineConnectionGraph graph; + + public MachineConnections() { + super(DATA_NAME); + graph = new CompactMachineConnectionGraph(); + } + + public static MachineConnections instance(MinecraftServer server) { + ServerWorld compactWorld = server.getLevel(Registration.COMPACT_DIMENSION); + if (compactWorld == null) { + CompactMachines.LOGGER.error("No compact dimension found. Report this."); + return null; + } + + DimensionSavedDataManager sd = compactWorld.getDataStorage(); + return sd.computeIfAbsent(MachineConnections::new, DATA_NAME); + } + + @Override + public void load(CompoundNBT nbt) { + + } + + @Override + public CompoundNBT save(CompoundNBT nbt) { + return nbt; + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java b/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java index e6d3c173..d8e60992 100644 --- a/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java +++ b/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java @@ -3,7 +3,7 @@ import com.mojang.authlib.GameProfile; import com.robotgryphon.compactmachines.api.core.Tooltips; import com.robotgryphon.compactmachines.block.BlockCompactMachine; -import com.robotgryphon.compactmachines.data.world.ExternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.ExternalMachineData; import com.robotgryphon.compactmachines.reference.EnumMachineSize; import com.robotgryphon.compactmachines.reference.Reference; import com.robotgryphon.compactmachines.util.PlayerUtil; diff --git a/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java b/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java index 44ca3d46..3e79a21d 100644 --- a/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java +++ b/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java @@ -4,7 +4,7 @@ import com.robotgryphon.compactmachines.api.core.Tooltips; import com.robotgryphon.compactmachines.client.gui.PersonalShrinkingDeviceScreen; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.world.InternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.InternalMachineData; import com.robotgryphon.compactmachines.util.PlayerUtil; import com.robotgryphon.compactmachines.util.TranslationUtil; import net.minecraft.client.gui.screen.Screen; diff --git a/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java b/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java index 58ec8955..a2098329 100644 --- a/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java +++ b/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java @@ -6,7 +6,7 @@ import com.robotgryphon.compactmachines.CompactMachines; import com.robotgryphon.compactmachines.client.machine.MachinePlayerEventHandler; import com.robotgryphon.compactmachines.data.codec.CodecExtensions; -import com.robotgryphon.compactmachines.data.world.ExternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.ExternalMachineData; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.network.PacketBuffer; diff --git a/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java b/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java index 85e397c4..fab277a8 100644 --- a/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java +++ b/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java @@ -3,20 +3,15 @@ import com.robotgryphon.compactmachines.CompactMachines; import com.robotgryphon.compactmachines.api.core.Messages; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.world.InternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.InternalMachineData; import com.robotgryphon.compactmachines.util.TranslationUtil; import net.minecraft.entity.Entity; -import net.minecraft.entity.LivingEntity; import net.minecraft.entity.player.ServerPlayerEntity; -import net.minecraft.nbt.CompoundNBT; -import net.minecraft.nbt.NBTUtil; import net.minecraft.server.MinecraftServer; -import net.minecraft.tileentity.EnderChestTileEntity; import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.ChunkPos; import net.minecraft.util.math.vector.Vector3d; import net.minecraft.util.text.TextFormatting; -import net.minecraft.util.text.TranslationTextComponent; import net.minecraftforge.event.entity.EntityEvent; import net.minecraftforge.event.entity.living.EnderTeleportEvent; import net.minecraftforge.event.entity.living.EntityTeleportEvent; diff --git a/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelHelper.java b/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelHelper.java index 70b0485f..4836bcd4 100644 --- a/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelHelper.java +++ b/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelHelper.java @@ -6,9 +6,6 @@ import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; import com.robotgryphon.compactmachines.block.walls.TunnelWallBlock; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.legacy.CompactMachineServerData; -import com.robotgryphon.compactmachines.data.legacy.SavedMachineData; -import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; import net.minecraft.block.BlockState; import net.minecraft.util.Direction; @@ -80,41 +77,42 @@ public static Set getTunnelsForMachineSide(int machine, ServerWorld wo Set tunnelPositions = new HashSet<>(); - CompactMachineServerData data = SavedMachineData.getInstance(world.getServer()).getData(); - - Optional mData = data.getMachineData(machine); - mData.ifPresent(machineData -> { - BlockPos machineCenter = machineData.getCenter(); - int internalSize = machineData.getSize().getInternalSize(); - - AxisAlignedBB allBlocksInMachine = new AxisAlignedBB(machineCenter, machineCenter) - .inflate(internalSize); - - Set tunnelPositionsUnfiltered = BlockPos.betweenClosedStream(allBlocksInMachine) - .filter(pos -> !compactWorld.isEmptyBlock(pos)) - // .filter(pos -> world.getBlockState(pos).getBlock() instanceof TunnelWallBlock) - .map(BlockPos::immutable) - .collect(Collectors.toSet()); - - if(!tunnelPositionsUnfiltered.isEmpty()) { - Set tunnelPositionsFiltered = tunnelPositionsUnfiltered - .stream() - .filter(pos -> { - BlockState state = compactWorld.getBlockState(pos); - - boolean tunnel = state.getBlock() instanceof TunnelWallBlock; - if(!tunnel) - return false; - - Direction externalSide = state.getValue(TunnelWallBlock.CONNECTED_SIDE); - return externalSide == machineSide; - }) - .map(BlockPos::immutable) - .collect(Collectors.toSet()); - - tunnelPositions.addAll(tunnelPositionsFiltered); - } - }); + // TODO - Reimplement with capability +// CompactMachineServerData data = SavedMachineData.getInstance(world.getServer()).getData(); +// +// Optional mData = data.getMachineData(machine); +// mData.ifPresent(machineData -> { +// BlockPos machineCenter = machineData.getCenter(); +// int internalSize = machineData.getSize().getInternalSize(); +// +// AxisAlignedBB allBlocksInMachine = new AxisAlignedBB(machineCenter, machineCenter) +// .inflate(internalSize); +// +// Set tunnelPositionsUnfiltered = BlockPos.betweenClosedStream(allBlocksInMachine) +// .filter(pos -> !compactWorld.isEmptyBlock(pos)) +// // .filter(pos -> world.getBlockState(pos).getBlock() instanceof TunnelWallBlock) +// .map(BlockPos::immutable) +// .collect(Collectors.toSet()); +// +// if(!tunnelPositionsUnfiltered.isEmpty()) { +// Set tunnelPositionsFiltered = tunnelPositionsUnfiltered +// .stream() +// .filter(pos -> { +// BlockState state = compactWorld.getBlockState(pos); +// +// boolean tunnel = state.getBlock() instanceof TunnelWallBlock; +// if(!tunnel) +// return false; +// +// Direction externalSide = state.getValue(TunnelWallBlock.CONNECTED_SIDE); +// return externalSide == machineSide; +// }) +// .map(BlockPos::immutable) +// .collect(Collectors.toSet()); +// +// tunnelPositions.addAll(tunnelPositionsFiltered); +// } +// }); return tunnelPositions; } diff --git a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java index 482462ef..2080cb56 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java @@ -8,8 +8,8 @@ import com.robotgryphon.compactmachines.core.Registration; import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; -import com.robotgryphon.compactmachines.data.world.ExternalMachineData; -import com.robotgryphon.compactmachines.data.world.InternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.ExternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.InternalMachineData; import com.robotgryphon.compactmachines.network.MachinePlayersChangedPacket; import com.robotgryphon.compactmachines.network.NetworkHandler; import com.robotgryphon.compactmachines.reference.EnumMachineSize; diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java b/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java index 00f72364..ebd59fa9 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java +++ b/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java @@ -1,149 +1,189 @@ package com.robotgryphon.compactmachines.tests; -import com.google.common.graph.*; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.data.graph.CompactMachineInsideNode; +import com.google.common.graph.Graph; +import com.robotgryphon.compactmachines.data.graph.CompactMachineConnectionGraph; import com.robotgryphon.compactmachines.data.graph.CompactMachineNode; +import com.robotgryphon.compactmachines.data.graph.CompactMachineRoomNode; import com.robotgryphon.compactmachines.data.graph.IMachineGraphNode; -import com.robotgryphon.compactmachines.data.graph.MachineExternalLocation; -import com.robotgryphon.compactmachines.util.MathUtil; import net.minecraft.util.math.ChunkPos; -import net.minecraft.util.math.vector.Vector3i; import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; -import java.io.FileNotFoundException; -import java.io.PrintWriter; -import java.util.*; -import java.util.stream.Collectors; +import java.util.Collection; +import java.util.Optional; -@SuppressWarnings("UnstableApiUsage") +@DisplayName("Machine Graph Tests") public class GraphTests { @Test - void canCreateBasicGraph() { - MutableGraph g = GraphBuilder - .directed() - .nodeOrder(ElementOrder.sorted(Comparator.comparing(IMachineGraphNode::getId))) - .build(); + @DisplayName("Can Create Basic Graph") + void basicGraph() { - HashMap lookup = new HashMap<>(); + CompactMachineConnectionGraph g = new CompactMachineConnectionGraph(); - generateData(g, lookup); + Assertions.assertEquals(0, g.getMachines().count()); - String w = write(g); + // At construction, no machines or rooms are registered + // The method itself should just return an empty collection in this scenario + Assertions.assertDoesNotThrow(() -> g.getMachinesFor(new ChunkPos(0, 0))); - try (PrintWriter pw = new PrintWriter("graph.dot")) { - pw.println(w); - } catch (FileNotFoundException e) { - e.printStackTrace(); - } + // Make sure that there's no linked machines here + Collection linkedMachines = g.getMachinesFor(new ChunkPos(0, 0)); + Assertions.assertNotNull(linkedMachines); + Assertions.assertEquals(0, linkedMachines.size()); - Assertions.assertTrue(true); + // Make sure there's no linked rooms + Optional connectedRoom = g.getConnectedRoom(0); + Assertions.assertNotNull(connectedRoom); + Assertions.assertFalse(connectedRoom.isPresent()); } - private void generateData(MutableGraph g, HashMap lookup) { - Random r = new Random(); - MachineExternalLocation[] values = MachineExternalLocation.values(); - int numInsides = 0; - int numOutsides = 0; - - Set disconnected = new HashSet<>(); - List externals = new ArrayList<>(); - List internals = new ArrayList<>(); - - // Seed a couple of machines and insides so they're always there - for(int i = 0; i < 10; i++) { - ChunkPos machineChunk = getMachineChunkPos(numInsides + 1); - CompactMachineNode extern = createMachineExternalNode(g, lookup, i); - CompactMachineInsideNode intern = createMachineInternalNode(g, lookup, machineChunk); - - externals.add(extern); - internals.add(intern); - - extern.connectTo(intern); - numOutsides++; - numInsides++; - } - - for(int i = 0; i < 50; i++) { - - if(r.nextBoolean()) { - // Creating the outside of a machine - MachineExternalLocation loc = values[r.nextInt(values.length)]; - - CompactMachineNode machine = createMachineExternalNode(g, lookup, numOutsides + 1); - externals.add(machine); - - switch (loc) { - case EXTERNAL_DIMENSION: - int randomMachineInsideE = r.nextInt(internals.size()); - CompactMachineInsideNode miE = internals.get(randomMachineInsideE); - machine.connectTo(miE); - - // try to remove from disconnected if it exists there - disconnected.remove(miE); - break; - - case INSIDE_MACHINE: - int randomMachineInsideI = r.nextInt(internals.size()); - CompactMachineInsideNode miI = internals.get(randomMachineInsideI); + @Test + @DisplayName("Create Single Linked Machine (1:1)") + void canCreateGraphWithLinkedMachine() { + int machine = 0; + ChunkPos room = new ChunkPos(0, 0); - // Put the machine inside a randomly chosen existing machine - g.putEdge(miI, machine); + CompactMachineConnectionGraph g = new CompactMachineConnectionGraph(); - boolean connectToAnother = r.nextBoolean(); - if(connectToAnother) { - System.out.println("connect"); - int randomMachine = r.nextInt(internals.size()); - CompactMachineInsideNode in = internals.get(randomMachine); - machine.connectTo(in); - } - break; - } + g.addMachine(0); + g.addRoom(new ChunkPos(0, 0)); - numOutsides++; - } else { - // Creating the inside of a machine - ChunkPos machineChunk= getMachineChunkPos(numInsides + 1); - CompactMachineInsideNode mi = createMachineInternalNode(g, lookup, machineChunk); - disconnected.add(mi); - numInsides++; - } - } + g.connectMachineToRoom(0, new ChunkPos(0, 0)); - if(!disconnected.isEmpty()) { - for (IMachineGraphNode di : disconnected) { - CompactMachineNode machine = createMachineExternalNode(g, lookup, numOutsides + 1); - machine.connectTo(di); - numOutsides++; - } - } + Optional connectedRoom = g.getConnectedRoom(machine); + Assertions.assertTrue(connectedRoom.isPresent()); - disconnected.clear(); - } + connectedRoom.ifPresent(cRoom -> { + Assertions.assertEquals(room, cRoom); + }); - private ChunkPos getMachineChunkPos(int i) { - Vector3i pos = MathUtil.getRegionPositionByIndex(i); - ChunkPos machineChunk = new ChunkPos(pos.getX(), pos.getZ()); - return machineChunk; + Collection linkedMachines = g.getMachinesFor(room); + Assertions.assertEquals(1, linkedMachines.size()); + Assertions.assertTrue(linkedMachines.contains(machine)); } - private CompactMachineInsideNode createMachineInternalNode(MutableGraph g, HashMap lookup, ChunkPos id) { - CompactMachineInsideNode intern = new CompactMachineInsideNode(id); - g.addNode(intern); - lookup.put(intern.getId(), intern); - return intern; - } - - private CompactMachineNode createMachineExternalNode(MutableGraph g, HashMap lookup, int id) { - CompactMachineNode extern = new CompactMachineNode(g, id); - g.addNode(extern); - lookup.put(extern.getId(), extern); - return extern; + @Test + @DisplayName("Create Multiple Linked Machines (M:1)") + void canCreateRoomWithMultipleLinkedMachines() { + int MACHINE_1 = 0; + int MACHINE_2 = 1; + ChunkPos EXPECTED_ROOM = new ChunkPos(0, 0); + + CompactMachineConnectionGraph g = new CompactMachineConnectionGraph(); + + + g.addMachine(0); + g.addMachine(1); + + ChunkPos roomChunk = new ChunkPos(0, 0); + g.addRoom(roomChunk); + g.connectMachineToRoom(0, roomChunk); + g.connectMachineToRoom(1, roomChunk); + + Optional connectedRoom = g.getConnectedRoom(0); + Assertions.assertTrue(connectedRoom.isPresent()); + connectedRoom.ifPresent(cRoom -> { + Assertions.assertEquals(EXPECTED_ROOM, cRoom); + }); + + Optional connectedRoom2 = g.getConnectedRoom(1); + Assertions.assertTrue(connectedRoom2.isPresent()); + connectedRoom2.ifPresent(cRoom2 -> { + Assertions.assertEquals(EXPECTED_ROOM, cRoom2); + }); + + Collection linkedMachines = g.getMachinesFor(EXPECTED_ROOM); + Assertions.assertEquals(2, linkedMachines.size()); + Assertions.assertTrue(linkedMachines.contains(MACHINE_1)); + Assertions.assertTrue(linkedMachines.contains(MACHINE_2)); } - public static String write(final Graph graph) { +// private void generateData(MutableGraph g, HashMap lookup) { +// Random r = new Random(); +// MachineExternalLocation[] values = MachineExternalLocation.values(); +// int numInsides = 0; +// int numOutsides = 0; +// +// Set disconnected = new HashSet<>(); +// List externals = new ArrayList<>(); +// List internals = new ArrayList<>(); +// +// // Seed a couple of machines and insides so they're always there +// for(int i = 0; i < 10; i++) { +// ChunkPos machineChunk = getMachineChunkPos(numInsides + 1); +// CompactMachineExternalNode extern = createMachineExternalNode(g, lookup, i); +// CompactMachineInsideNode intern = createMachineInternalNode(g, lookup, machineChunk); +// +// externals.add(extern); +// internals.add(intern); +// +// extern.connectTo(intern); +// numOutsides++; +// numInsides++; +// } +// +// for(int i = 0; i < 50; i++) { +// +// if(r.nextBoolean()) { +// // Creating the outside of a machine +// MachineExternalLocation loc = values[r.nextInt(values.length)]; +// +// CompactMachineExternalNode machine = createMachineExternalNode(g, lookup, numOutsides + 1); +// externals.add(machine); +// +// switch (loc) { +// case EXTERNAL_DIMENSION: +// int randomMachineInsideE = r.nextInt(internals.size()); +// CompactMachineInsideNode miE = internals.get(randomMachineInsideE); +// machine.connectTo(miE); +// +// // try to remove from disconnected if it exists there +// disconnected.remove(miE); +// break; +// +// case INSIDE_MACHINE: +// int randomMachineInsideI = r.nextInt(internals.size()); +// CompactMachineInsideNode miI = internals.get(randomMachineInsideI); +// +// // Put the machine inside a randomly chosen existing machine +// g.putEdge(miI, machine); +// +// boolean connectToAnother = r.nextBoolean(); +// if(connectToAnother) { +// System.out.println("connect"); +// int randomMachine = r.nextInt(internals.size()); +// CompactMachineInsideNode in = internals.get(randomMachine); +// machine.connectTo(in); +// +// g.successors(machine); // All the connections internally +// } +// break; +// } +// +// numOutsides++; +// } else { +// // Creating the inside of a machine +// ChunkPos machineChunk= getMachineChunkPos(numInsides + 1); +// CompactMachineInsideNode mi = createMachineInternalNode(g, lookup, machineChunk); +// disconnected.add(mi); +// numInsides++; +// } +// } +// +// if(!disconnected.isEmpty()) { +// for (IMachineGraphNode di : disconnected) { +// CompactMachineExternalNode machine = createMachineExternalNode(g, lookup, numOutsides + 1); +// machine.connectTo(di); +// numOutsides++; +// } +// } +// +// disconnected.clear(); +// } + + public static String write(final CompactMachineConnectionGraph graph) { StringBuilder sb = new StringBuilder(); sb .append("strict digraph G {") @@ -151,29 +191,27 @@ public static String write(final Graph graph) { .append("\tlayout = fdp;").append(System.lineSeparator()) .append("\tnode [shape=square,style=filled,color=lightgray];").append(System.lineSeparator()); - Set topLevelMachines = graph.nodes().stream() - .filter(n -> n instanceof CompactMachineNode) - .map(n -> (CompactMachineNode) n) - .filter(n -> graph.inDegree(n) == 0) - .collect(Collectors.toSet()); - - for (CompactMachineNode n : topLevelMachines) - outputExternalNode(sb, n); - - graph.nodes().stream() - .filter(n -> n instanceof CompactMachineInsideNode) - .map(n -> (CompactMachineInsideNode) n) - .forEach(n -> { - outputMachineInside(graph, sb, n); - }); +// Set topLevelMachines = graph.getMachines() +// .filter(n -> graph.getConnectedRoom(n.getMachineId()).isPresent()) +// .collect(Collectors.toSet()); +// +// for (CompactMachineNode n : topLevelMachines) +// outputExternalNode(sb, n); +// +// graph.nodes().stream() +// .filter(n -> n instanceof CompactMachineRoomNode) +// .map(n -> (CompactMachineRoomNode) n) +// .forEach(n -> { +// outputMachineInside(graph, sb, n); +// }); sb.append("}"); return sb.toString(); } private static void outputMachineInside(Graph graph, StringBuilder sb, IMachineGraphNode inside) { - if (inside instanceof CompactMachineInsideNode) { - CompactMachineInsideNode min = (CompactMachineInsideNode) inside; + if (inside instanceof CompactMachineRoomNode) { + CompactMachineRoomNode min = (CompactMachineRoomNode) inside; String insideClusterName = "cluster_" + min.getId(); graph.predecessors(min).forEach(incoming -> { @@ -194,7 +232,7 @@ private static void outputMachineInside(Graph graph, StringBu .append(System.lineSeparator()); graph.successors(min).forEach(insideNode -> { - if(insideNode instanceof CompactMachineNode) { + if (insideNode instanceof CompactMachineNode) { CompactMachineNode men = (CompactMachineNode) insideNode; outputExternalNode(sb, men); } @@ -207,10 +245,10 @@ private static void outputMachineInside(Graph graph, StringBu } private static void outputExternalNode(StringBuilder sb, CompactMachineNode men) { - boolean connected = men.isConnected; + boolean connected = true; sb.append("\t") .append(men.getId()) - .append(String.format(" [label=\"%s\",style=filled,color=%s]", men.label(), men.isConnected ? "lightgray" : "palevioletred1")) + .append(String.format(" [label=\"%s\",style=filled,color=%s]", men.label(), connected ? "lightgray" : "palevioletred1")) .append(System.lineSeparator()); } } diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/MathTests.java b/src/test/java/com/robotgryphon/compactmachines/tests/MathTests.java index e880a4d8..39a09eb5 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/MathTests.java +++ b/src/test/java/com/robotgryphon/compactmachines/tests/MathTests.java @@ -4,14 +4,15 @@ import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.ChunkPos; import net.minecraft.util.math.vector.Vector3i; -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.*; import java.util.HashMap; +@DisplayName("Math") public class MathTests { @Test + @DisplayName("Position Generator Works Correctly") void positionGeneratorWorksCorrectly() { // Our generation works in a counter-clockwise spiral, starting at 0,0 /* diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java b/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java index be0bb9f1..b10b9645 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java +++ b/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java @@ -1,6 +1,5 @@ package com.robotgryphon.compactmachines.tests.minecraft; -import com.robotgryphon.compactmachines.data.legacy.SavedMachineDataMigrator; import net.minecraft.server.MinecraftServer; import net.minecraftforge.fml.server.ServerLifecycleHooks; import org.junit.jupiter.api.Tag; @@ -13,8 +12,7 @@ public class ExampleTest { void CanDoBasicTest() { MinecraftServer serv = ServerLifecycleHooks.getCurrentServer(); // SavedMachineData sd = SavedMachineData.getInstance(serv); - - SavedMachineDataMigrator.migrate(serv); + // SavedMachineDataMigrator.migrate(serv); } diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/nbt/MachineExternalDataTests.java b/src/test/java/com/robotgryphon/compactmachines/tests/nbt/MachineExternalDataTests.java new file mode 100644 index 00000000..e814a899 --- /dev/null +++ b/src/test/java/com/robotgryphon/compactmachines/tests/nbt/MachineExternalDataTests.java @@ -0,0 +1,62 @@ +package com.robotgryphon.compactmachines.tests.nbt; + +import com.mojang.serialization.Codec; +import com.mojang.serialization.DataResult; +import com.robotgryphon.compactmachines.data.machine.CompactMachineExternal; +import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import com.robotgryphon.compactmachines.tests.util.FileHelper; +import net.minecraft.nbt.CompoundNBT; +import net.minecraft.nbt.NBTDynamicOps; +import net.minecraft.util.RegistryKey; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.util.registry.Registry; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.List; +import java.util.Optional; + +@DisplayName("External Machine Data") +public class MachineExternalDataTests { + private final Path EXTERNAL = Paths.get("scenario", "single-machine-player-inside", "machines_external.dat"); + + Codec> c = CompactMachineExternal.CODEC.listOf() + .fieldOf("locations") + .stable() + .codec(); + + @Test + @DisplayName("Loads Single Machine Data") + void canLoadSingleMachineData() throws IOException { + // The external point is overworld @8x4x8 (it was made in a default void superflat) + DimensionalPosition OUTSIDE = new DimensionalPosition( + RegistryKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation("overworld")), + new BlockPos(8,4,8) + ); + + ChunkPos INSIDE = new ChunkPos(0, -64); + + CompoundNBT nbt = FileHelper.INSTANCE.getNbtFromFile(EXTERNAL.toString()); + CompoundNBT data = nbt.getCompound("data"); + DataResult> result = c.parse(NBTDynamicOps.INSTANCE, data); + + Assertions.assertFalse(data.isEmpty()); + + Optional> res = result.result(); + Assertions.assertTrue(res.isPresent()); + + res.ifPresent(list -> { + Assertions.assertEquals(1, list.size()); + + CompactMachineExternal extern = list.get(0); + Assertions.assertEquals(OUTSIDE, extern.location); + Assertions.assertEquals(INSIDE, extern.getMappedChunk()); + }); + } +} diff --git a/src/test/resources/scenario/single-machine-player-inside/machines_external.dat b/src/test/resources/scenario/single-machine-player-inside/machines_external.dat new file mode 100644 index 0000000000000000000000000000000000000000..9a77ec7cfe4e6b19fd07343902c35961ad09592b GIT binary patch literal 154 zcmV;L0A>FliwFP)4U1p^|Knm{;9_7&Ni0d^WZ=xnPfje!%+D+4VqjokWM*K`O-#Ubv&P>JUHR&bMC|$Z{24}2?+^L5)#hppZC^H3NSP^*yQ8u z?Rm-6*wgQtsh^SeHD4be!|Pj3{0t3^HyRlD85=%LOVHKx&^gciDupeHPvP2+|Nr^f z*_piy(?YeFcdt)wS)RW_-<&zRC@YThLPU#`?F1)*>9<*5^liAZ=+T*)1&%R6JPhKK Ko=lqubQb^tWIj&- literal 0 HcmV?d00001 diff --git a/src/test/resources/scenario/single-machine-player-inside/players.dat b/src/test/resources/scenario/single-machine-player-inside/players.dat new file mode 100644 index 0000000000000000000000000000000000000000..1a485dda7ae91d0532ebd32a3d6524fbe44985d9 GIT binary patch literal 191 zcmV;w06_mAiwFP!000000OMj{;9_7&Ni0d^WMD7INvupQD&}HfU|{58U`@^_&C6zH zU<1<;KtTo=C+h$I{|6Yj8JIFtfTAn`n(uF?oUzVXb$#-clm>fO22KXH;)2BTJh)L{ z9v1_1L4GkC17n4Qg!)}AzrubXyV5~`0StibDhKK1uC}`tEnwhaU{1-*Wf0EI%u7u! tN=z%U$}dYTD$g&9004kdP*wl{ literal 0 HcmV?d00001 From 6167c0c26f125a92dbe51d0f9c66129e29c0bf2c Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 1 May 2021 13:24:09 -0400 Subject: [PATCH 10/36] Bump FG version for maven fix, update minimum required Forge in META --- build.gradle | 2 +- src/main/resources/META-INF/mods.toml | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/build.gradle b/build.gradle index 412d712b..605ea735 100644 --- a/build.gradle +++ b/build.gradle @@ -6,7 +6,7 @@ buildscript { } dependencies { - classpath "net.minecraftforge.gradle:ForgeGradle:4.0.23" + classpath "net.minecraftforge.gradle:ForgeGradle:4.1.9" } } diff --git a/src/main/resources/META-INF/mods.toml b/src/main/resources/META-INF/mods.toml index 9e258970..ef5bd5e3 100644 --- a/src/main/resources/META-INF/mods.toml +++ b/src/main/resources/META-INF/mods.toml @@ -6,7 +6,7 @@ # The name of the mod loader type to load - for regular FML @Mod mods it should be javafml modLoader="javafml" #mandatory # A version range to match for said mod loader - for regular FML @Mod it will be the forge version -loaderVersion="[35,)" #mandatory This is typically bumped every Minecraft version by Forge. See our download page for lists of versions. +loaderVersion="[36,)" #mandatory This is typically bumped every Minecraft version by Forge. See our download page for lists of versions. # The license for you mod. This is mandatory metadata and allows for easier comprehension of your redistributive properties. # Review your options at https://choosealicense.com/. All rights reserved is the default copyright stance, and is thus the default here. license="All rights reserved" @@ -40,7 +40,7 @@ license="All rights reserved" # Does this dependency have to exist - if not, ordering below must be specified mandatory=true #mandatory # The version range of the dependency - versionRange="[35,)" #mandatory + versionRange="[36.1.4,)" #mandatory # An ordering relationship for the dependency - BEFORE or AFTER required if the relationship is not mandatory ordering="NONE" # Side this dependency is applied on - BOTH, CLIENT or SERVER @@ -50,6 +50,6 @@ license="All rights reserved" [[dependencies.compactmachines]] modId="minecraft" mandatory=true - versionRange="[1.16.4,1.17)" + versionRange="[1.16.5,1.17)" ordering="NONE" side="BOTH" From 1bb1df5ac0bfa53f3d4f28645c14a5bf7e039663 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 1 May 2021 13:49:31 -0400 Subject: [PATCH 11/36] Update CI tests to force gradle removal and to remove vars fetch --- .github/workflows/ci-tests.yml | 34 ++++++++-------------------------- 1 file changed, 8 insertions(+), 26 deletions(-) diff --git a/.github/workflows/ci-tests.yml b/.github/workflows/ci-tests.yml index 56d5ac19..8b6a1ca2 100644 --- a/.github/workflows/ci-tests.yml +++ b/.github/workflows/ci-tests.yml @@ -3,34 +3,9 @@ name: Gradle Tests (CI) on: push jobs: - vars: - name: Get Variables - runs-on: ubuntu-20.04 - outputs: - release_type: ${{steps.cf_release_type.outputs.value }} - mod_version: ${{steps.mod_version.outputs.value }} - steps: - - name: Checkout - uses: actions/checkout@v2 - - - name: Release Type - id: cf_release_type - uses: christian-draeger/read-properties@1.0.1 - with: - path: './gradle.properties' - property: 'cf_release_type' - - - name: Mod Version - id: mod_version - uses: christian-draeger/read-properties@1.0.1 - with: - path: './gradle.properties' - property: 'mod_version' - jar: - name: Publish JAR + name: Test with Gradle runs-on: ubuntu-20.04 - needs: [vars] steps: - name: Checkout uses: actions/checkout@v2 @@ -40,8 +15,15 @@ jobs: with: java-version: "8.0.282" + - name: Ensure fresh gradle install + # Remove some files from the Gradle cache, so they aren't cached by GitHub Actions. + # Restoring these files from a GitHub Actions cache might cause problems for future builds. + run: | + rm -rf ~/.gradle + - name: Test JAR with Gradle run: ./gradlew test env: GITHUB_ACTOR: ${{ secrets.GITHUB_ACTOR }} GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + From bce98772aadc8eabe586e2b92c47e71a6f5602b5 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 1 May 2021 14:03:35 -0400 Subject: [PATCH 12/36] Attempt build fix per FG toolchain comment (max-workers) https://github.com/MinecraftForge/ForgeGradle/issues/697#issuecomment-665597454 --- .github/workflows/ci-tests.yml | 2 +- .github/workflows/manual-build.yml | 5 +---- .github/workflows/manual-gh-packages.yml | 2 +- .github/workflows/tagged-release.yml | 6 ++---- 4 files changed, 5 insertions(+), 10 deletions(-) diff --git a/.github/workflows/ci-tests.yml b/.github/workflows/ci-tests.yml index 8b6a1ca2..362bf96d 100644 --- a/.github/workflows/ci-tests.yml +++ b/.github/workflows/ci-tests.yml @@ -22,7 +22,7 @@ jobs: rm -rf ~/.gradle - name: Test JAR with Gradle - run: ./gradlew test + run: ./gradlew test --max-workers 1 env: GITHUB_ACTOR: ${{ secrets.GITHUB_ACTOR }} GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/manual-build.yml b/.github/workflows/manual-build.yml index b5d19174..b01cb696 100644 --- a/.github/workflows/manual-build.yml +++ b/.github/workflows/manual-build.yml @@ -115,11 +115,8 @@ jobs: - name: Grant execute permission for gradlew run: chmod +x gradlew - - name: Gradle Dependencies - run: ./gradlew --refresh-dependencies - - name: Build JAR with Gradle - run: ./gradlew build + run: ./gradlew build --max-workers 1 env: GITHUB_ACTOR: ${{ secrets.GITHUB_ACTOR }} GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/manual-gh-packages.yml b/.github/workflows/manual-gh-packages.yml index 784c1ad9..c04a3c33 100644 --- a/.github/workflows/manual-gh-packages.yml +++ b/.github/workflows/manual-gh-packages.yml @@ -117,7 +117,7 @@ jobs: run: chmod +x gradlew - name: Publish JAR with Gradle - run: ./gradlew publish + run: ./gradlew publish --max-workers 1 env: GITHUB_ACTOR: ${{ secrets.GITHUB_ACTOR }} GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/tagged-release.yml b/.github/workflows/tagged-release.yml index eb56a41a..a39b19eb 100644 --- a/.github/workflows/tagged-release.yml +++ b/.github/workflows/tagged-release.yml @@ -119,7 +119,7 @@ jobs: run: chmod +x gradlew - name: Publish package - run: ./gradlew publish + run: ./gradlew publish --max-workers 1 env: GITHUB_ACTOR: ${{ secrets.GITHUB_ACTOR }} GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} @@ -205,9 +205,7 @@ jobs: java-version: "8.0.282" - name: Build JAR with Gradle - uses: eskatos/gradle-command-action@v1 - with: - arguments: build + run: ./gradlew build --max-workers 1 env: GITHUB_ACTOR: ${{ secrets.GITHUB_ACTOR }} GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} \ No newline at end of file From 9bc31d45b0ec144f9b1cb619ed633c237b1d95d8 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 1 May 2021 15:42:57 -0400 Subject: [PATCH 13/36] Connection graph serialization tests. --- .../graph/CompactMachineConnectionGraph.java | 36 ++++++---- .../data/persistent/MachineConnections.java | 19 +++++ .../compactmachines/tests/GraphTests.java | 70 +++++++++++++++++-- .../tests/util/FileHelper.java | 4 ++ 4 files changed, 109 insertions(+), 20 deletions(-) diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java index 62675d33..e51208d1 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java @@ -1,5 +1,6 @@ package com.robotgryphon.compactmachines.data.graph; +import com.google.common.collect.ImmutableList; import com.google.common.graph.ElementOrder; import com.google.common.graph.GraphBuilder; import com.google.common.graph.MutableGraph; @@ -22,18 +23,8 @@ public class CompactMachineConnectionGraph { private final Map machines; private final Map rooms; - private static final Codec CONNECTION_INFO_CODEC = RecordCodecBuilder.create(i -> i.group( - CodecExtensions.CHUNKPOS_CODEC - .fieldOf("machine") - .forGetter(CompactMachineConnectionInfo::room), - - Codec.INT.listOf() - .fieldOf("connections") - .forGetter(CompactMachineConnectionInfo::machines) - ).apply(i, CompactMachineConnectionInfo::new)); - public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( - CONNECTION_INFO_CODEC.listOf() + CompactMachineConnectionInfo.CODEC.listOf() .fieldOf("connections") .forGetter(CompactMachineConnectionGraph::buildConnections) ).apply(i, CompactMachineConnectionGraph::new)); @@ -63,7 +54,14 @@ private CompactMachineConnectionGraph(List connect } private List buildConnections() { - return Collections.emptyList(); + List result = new ArrayList<>(); + this.rooms.forEach((chunk, node) -> { + Collection machines = this.getMachinesFor(chunk); + CompactMachineConnectionInfo roomInfo = new CompactMachineConnectionInfo(chunk, machines); + result.add(roomInfo); + }); + + return result; } public void addMachine(int machine) { @@ -134,9 +132,19 @@ private static class CompactMachineConnectionInfo { private final ChunkPos roomChunk; private final List connectedMachines; - public CompactMachineConnectionInfo(ChunkPos roomChunk, List connections) { + public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( + CodecExtensions.CHUNKPOS_CODEC + .fieldOf("machine") + .forGetter(CompactMachineConnectionInfo::room), + + Codec.INT.listOf() + .fieldOf("connections") + .forGetter(CompactMachineConnectionInfo::machines) + ).apply(i, CompactMachineConnectionInfo::new)); + + public CompactMachineConnectionInfo(ChunkPos roomChunk, Collection connections) { this.roomChunk = roomChunk; - this.connectedMachines = connections; + this.connectedMachines = ImmutableList.copyOf(connections); } public ChunkPos room() { diff --git a/src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java b/src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java index e7c2b6f3..f81b22b4 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java @@ -1,9 +1,12 @@ package com.robotgryphon.compactmachines.data.persistent; +import com.mojang.serialization.DataResult; import com.robotgryphon.compactmachines.CompactMachines; import com.robotgryphon.compactmachines.core.Registration; import com.robotgryphon.compactmachines.data.graph.CompactMachineConnectionGraph; import net.minecraft.nbt.CompoundNBT; +import net.minecraft.nbt.INBT; +import net.minecraft.nbt.NBTDynamicOps; import net.minecraft.server.MinecraftServer; import net.minecraft.world.server.ServerWorld; import net.minecraft.world.storage.DimensionSavedDataManager; @@ -32,11 +35,27 @@ public static MachineConnections instance(MinecraftServer server) { @Override public void load(CompoundNBT nbt) { + if (nbt.contains("graph")) { + CompoundNBT graphNbt = nbt.getCompound("graph"); + DataResult graphParseResult = CompactMachineConnectionGraph.CODEC.parse(NBTDynamicOps.INSTANCE, graphNbt); + graphParseResult + .resultOrPartial(CompactMachines.LOGGER::error) + .ifPresent(g -> this.graph = g); + } } @Override public CompoundNBT save(CompoundNBT nbt) { + if(graph != null) { + DataResult dataResult = CompactMachineConnectionGraph.CODEC.encodeStart(NBTDynamicOps.INSTANCE, graph); + dataResult + .resultOrPartial(CompactMachines.LOGGER::error) + .ifPresent(gNbt -> { + nbt.put("graph", gNbt); + }); + } + return nbt; } } diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java b/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java index ebd59fa9..de63e8b2 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java +++ b/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java @@ -1,21 +1,38 @@ package com.robotgryphon.compactmachines.tests; import com.google.common.graph.Graph; +import com.mojang.serialization.DataResult; +import com.robotgryphon.compactmachines.data.codec.CodecExtensions; import com.robotgryphon.compactmachines.data.graph.CompactMachineConnectionGraph; import com.robotgryphon.compactmachines.data.graph.CompactMachineNode; import com.robotgryphon.compactmachines.data.graph.CompactMachineRoomNode; import com.robotgryphon.compactmachines.data.graph.IMachineGraphNode; +import com.robotgryphon.compactmachines.tests.util.FileHelper; +import net.minecraft.nbt.*; import net.minecraft.util.math.ChunkPos; +import net.minecraftforge.common.util.Constants; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import java.io.File; +import java.io.IOException; import java.util.Collection; import java.util.Optional; @DisplayName("Machine Graph Tests") public class GraphTests { + private CompactMachineConnectionGraph generateGraphWithSingleRoom() { + CompactMachineConnectionGraph g = new CompactMachineConnectionGraph(); + + g.addMachine(0); + g.addRoom(new ChunkPos(0, 0)); + + g.connectMachineToRoom(0, new ChunkPos(0, 0)); + return g; + } + @Test @DisplayName("Can Create Basic Graph") void basicGraph() { @@ -45,12 +62,7 @@ void canCreateGraphWithLinkedMachine() { int machine = 0; ChunkPos room = new ChunkPos(0, 0); - CompactMachineConnectionGraph g = new CompactMachineConnectionGraph(); - - g.addMachine(0); - g.addRoom(new ChunkPos(0, 0)); - - g.connectMachineToRoom(0, new ChunkPos(0, 0)); + CompactMachineConnectionGraph g = generateGraphWithSingleRoom(); Optional connectedRoom = g.getConnectedRoom(machine); Assertions.assertTrue(connectedRoom.isPresent()); @@ -100,6 +112,52 @@ void canCreateRoomWithMultipleLinkedMachines() { Assertions.assertTrue(linkedMachines.contains(MACHINE_2)); } + @Test + @DisplayName("Correctly serializes to NBT") + void canSerialize() { + CompactMachineConnectionGraph graph = generateGraphWithSingleRoom(); + + DataResult nbtResult = CompactMachineConnectionGraph.CODEC.encodeStart(NBTDynamicOps.INSTANCE, graph); + + nbtResult.resultOrPartial(Assertions::fail) + .ifPresent(nbt -> { + Assertions.assertTrue(nbt instanceof CompoundNBT); + +// try { +// File file = FileHelper.RESOURCES_DIR.resolve("graph.dat").toFile(); +// file.delete(); +// CompressedStreamTools.writeCompressed((CompoundNBT) nbt, file); +// } catch (IOException e) { +// e.printStackTrace(); +// } + + CompoundNBT c = (CompoundNBT) nbt; + Assertions.assertFalse(c.isEmpty()); + + Assertions.assertTrue(c.contains("connections")); + + ListNBT connections = c.getList("connections", Constants.NBT.TAG_COMPOUND); + Assertions.assertEquals(1, connections.size(), "Expected one connection from a machine to a single room."); + + CompoundNBT conn1 = connections.getCompound(0); + Assertions.assertNotNull(conn1); + + Assertions.assertTrue(conn1.contains("machine")); + Assertions.assertTrue(conn1.contains("connections")); + + CompoundNBT machineChunk = conn1.getCompound("machine"); + DataResult chunkRes = CodecExtensions.CHUNKPOS_CODEC.parse(NBTDynamicOps.INSTANCE, machineChunk); + chunkRes.resultOrPartial(Assertions::fail) + .ifPresent(chunk -> { + Assertions.assertEquals(new ChunkPos(0, 0), chunk); + }); + + ListNBT connList = conn1.getList("connections", Constants.NBT.TAG_INT); + Assertions.assertNotNull(connList); + Assertions.assertEquals(1, connList.size()); + Assertions.assertEquals(0, connList.getInt(0)); + }); + } // private void generateData(MutableGraph g, HashMap lookup) { // Random r = new Random(); // MachineExternalLocation[] values = MachineExternalLocation.values(); diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/util/FileHelper.java b/src/test/java/com/robotgryphon/compactmachines/tests/util/FileHelper.java index 5f898710..d42caeb8 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/util/FileHelper.java +++ b/src/test/java/com/robotgryphon/compactmachines/tests/util/FileHelper.java @@ -5,13 +5,17 @@ import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.CompressedStreamTools; +import javax.annotation.Nullable; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.net.URL; +import java.nio.file.Path; +import java.nio.file.Paths; public class FileHelper { public static final FileHelper INSTANCE = new FileHelper(); + public static Path RESOURCES_DIR = Paths.get("src","test","resources"); private FileHelper() { } From 922ddb4211647381c1b4a404d0559c6a5092f8ca Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sun, 2 May 2021 19:06:25 -0400 Subject: [PATCH 14/36] More codec migrations, tests, API improvements --- .../block/BlockCompactMachine.java | 2 +- .../block/tiles/CompactMachineTile.java | 223 ++++-------------- .../block/tiles/TunnelWallTile.java | 44 ++-- .../providers/CompactMachineProvider.java | 57 ++--- .../data/codec/CodecExtensions.java | 38 ++- .../data/codec/DoubleStreamExtensions.java | 50 ++++ .../data/machine/CompactMachineExternal.java | 37 --- .../machine/CompactMachineInternalData.java | 22 +- .../data/persistent/CompactMachineData.java | 144 +++++++++++ ...lMachineData.java => CompactRoomData.java} | 10 +- .../data/persistent/ExternalMachineData.java | 192 --------------- .../data/persistent/MachineConnections.java | 4 +- .../item/ItemBlockMachine.java | 4 +- .../item/ItemPersonalShrinkingDevice.java | 4 +- .../network/MachinePlayersChangedPacket.java | 17 +- .../reference/EnumMachineSize.java | 4 + .../TeleportationEventHandler.java | 4 +- .../compactmachines/util/MathUtil.java | 7 + .../compactmachines/util/PlayerUtil.java | 88 ++++--- .../compactmachines/tests/GraphTests.java | 63 +++-- .../tests/codec/CodecTests.java | 44 ++++ .../tests/nbt/MachineExternalDataTests.java | 15 +- .../machines_external.dat | Bin 154 -> 134 bytes 23 files changed, 482 insertions(+), 591 deletions(-) create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/codec/DoubleStreamExtensions.java delete mode 100644 src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineExternal.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactMachineData.java rename src/main/java/com/robotgryphon/compactmachines/data/persistent/{InternalMachineData.java => CompactRoomData.java} (92%) delete mode 100644 src/main/java/com/robotgryphon/compactmachines/data/persistent/ExternalMachineData.java create mode 100644 src/test/java/com/robotgryphon/compactmachines/tests/codec/CodecTests.java diff --git a/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java b/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java index afbca6dd..0d733b58 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java @@ -354,7 +354,7 @@ public EnumMachineSize getSize() { @Override public void addProbeData(IProbeData data, PlayerEntity player, World world, BlockState state) { - CompactMachineProvider.exec(data, player, world, state); + CompactMachineProvider.exec(data, world); } // 1.12.1 code diff --git a/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java b/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java index 79dcfda1..c7c7c474 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java @@ -3,9 +3,10 @@ import com.robotgryphon.compactmachines.config.ServerConfig; import com.robotgryphon.compactmachines.core.Registration; import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; +import com.robotgryphon.compactmachines.data.persistent.CompactRoomData; +import com.robotgryphon.compactmachines.data.persistent.MachineConnections; import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; -import com.robotgryphon.compactmachines.data.persistent.ExternalMachineData; -import com.robotgryphon.compactmachines.data.persistent.InternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; import com.robotgryphon.compactmachines.reference.Reference; import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; @@ -23,7 +24,6 @@ import net.minecraft.util.Direction; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.ChunkPos; -import net.minecraft.world.chunk.IChunk; import net.minecraft.world.server.ServerWorld; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.common.capabilities.ICapabilityProvider; @@ -211,8 +211,15 @@ public CompoundNBT getUpdateTag() { public Optional getInternalChunkPos() { if(level instanceof ServerWorld) { - ExternalMachineData emd = ExternalMachineData.get(level.getServer()); - return emd.getChunkLocation(this.machineId); + MinecraftServer serv = level.getServer(); + if(serv == null) + return Optional.empty(); + + MachineConnections connections = MachineConnections.get(serv); + if(connections == null) + return Optional.empty(); + + return connections.graph.getConnectedRoom(this.machineId); } return Optional.empty(); @@ -261,31 +268,6 @@ public void setMachineId(int id) { this.setChanged(); } - public Optional getInternalData() { - if(this.machineId == 0) - return Optional.empty(); - - if (level instanceof ServerWorld) { - MinecraftServer serv = level.getServer(); - if(serv == null) - return Optional.empty(); - - // Get external machine info (which, this should have some if it has a machine ID - ExternalMachineData extern = ExternalMachineData.get(serv); - if(extern == null) - return Optional.empty(); - - Optional chunkLocation = extern.getChunkLocation(machineId); - if(!chunkLocation.isPresent()) - return Optional.empty(); - - InternalMachineData intern = InternalMachineData.get(serv); - return intern.forChunk(chunkLocation.get()); - } else { - return Optional.empty(); - } - } - public boolean hasPlayersInside() { return false; // TODO @@ -300,11 +282,10 @@ protected void doChunkload(boolean force) { if (level == null || level.isClientSide) return; - getInternalData().ifPresent(data -> { + getInternalChunkPos().ifPresent(chunk -> { ServerWorld compact = this.level.getServer().getLevel(Registration.COMPACT_DIMENSION); - IChunk machineChunk = compact.getChunk(data.getCenter()); - ChunkPos chunkPos = machineChunk.getPos(); - compact.setChunkForced(chunkPos.x, chunkPos.z, force); + compact.setChunkForced(chunk.x, chunk.z, force); + }); } @@ -321,7 +302,7 @@ public void doPostPlaced() { this.worldPosition ); - ExternalMachineData extern = ExternalMachineData.get(serv); + CompactMachineData extern = CompactMachineData.get(serv); extern.setMachineLocation(this.machineId, dp); doChunkload(true); @@ -339,23 +320,34 @@ public void handlePlayerEntered(UUID playerID) { } public boolean mapped() { - return getInternalData().isPresent(); + return getInternalChunkPos().isPresent(); } - /* - * Chunk-Loading triggers - */ + public Optional getSpawn() { + if(level instanceof ServerWorld) { + ServerWorld serverWorld = (ServerWorld) level; + MinecraftServer serv = serverWorld.getServer(); -// private void initialize() { -// if (this.getWorld().isRemote) { -// return; -// } -// -// if (!ChunkLoadingMachines.isMachineChunkLoaded(this.coords)) { -// ChunkLoadingMachines.forceChunk(this.coords); -// } -// -// } + MachineConnections connections = MachineConnections.get(serv); + if(connections == null) + return Optional.empty(); + + Optional connectedRoom = connections.graph.getConnectedRoom(machineId); + + if(!connectedRoom.isPresent()) + return Optional.empty(); + + CompactRoomData roomData = CompactRoomData.get(serv); + if(roomData == null) + return Optional.empty(); + + ChunkPos chunk = connectedRoom.get(); + return roomData.forChunk(chunk) + .map(CompactMachineInternalData::getSpawn); + } + + return Optional.empty(); + } // @Override // public void update() { @@ -419,137 +411,4 @@ public boolean mapped() { // // return StructureTools.getCoordsForPos(this.getPos()) == this.coords; // } -// -// public ItemStack getConnectedPickBlock(EnumFacing facing) { -// BlockPos insetPos = getMachineWorldInsetPos(facing); -// if (insetPos == null) { -// return ItemStack.EMPTY; -// } -// -// WorldServer machineWorld = DimensionTools.getServerMachineWorld(); -// IBlockState state = machineWorld.getBlockState(insetPos); -// return state.getBlock().getItem(machineWorld, insetPos, state); -// } -// -// public int getRedstonePowerOutput(EnumFacing facing) { -// if (this.coords == -1) { -// return 0; -// } -// -// // We don't know the actual power on the client-side, which does not have the worldsaveddatamachines instance -// if (WorldSavedDataMachines.INSTANCE == null || WorldSavedDataMachines.INSTANCE.redstoneTunnels == null) { -// return 0; -// } -// -// HashMap tunnelMapping = WorldSavedDataMachines.INSTANCE.redstoneTunnels.get(this.coords); -// if (tunnelMapping == null) { -// return 0; -// } -// -// RedstoneTunnelData tunnelData = tunnelMapping.get(facing); -// if (tunnelData == null) { -// return 0; -// } -// -// -// if (!tunnelData.isOutput) { -// return 0; -// } -// -// WorldServer machineWorld = DimensionTools.getServerMachineWorld(); -// if (!(machineWorld.getTileEntity(tunnelData.pos) instanceof TileEntityRedstoneTunnel)) { -// return 0; -// } -// -// EnumFacing insetDirection = StructureTools.getInsetWallFacing(tunnelData.pos, this.getSize().getDimension()); -// BlockPos insetPos = tunnelData.pos.offset(insetDirection); -// IBlockState insetBlockState = machineWorld.getBlockState(insetPos); -// -// int power = 0; -// if (insetBlockState.getBlock() instanceof BlockRedstoneWire) { -// power = insetBlockState.getValue(BlockRedstoneWire.POWER); -// } else { -// power = machineWorld.getRedstonePower(insetPos, insetDirection); -// } -// -// return power; -// } -// -// @Override -// public boolean hasCapability(Capability capability, EnumFacing facing) { -// if (isInsideItself()) { -// return false; -// } -// -// if (world.isRemote || facing == null) { -// if (CapabilityNullHandlerRegistry.hasNullHandler(capability)) { -// return true; -// } -// -// return super.hasCapability(capability, facing); -// } -// -// BlockPos tunnelPos = this.getConnectedBlockPosition(facing); -// if (tunnelPos == null) { -// return false; -// } -// -// World machineWorld = DimensionTools.getServerMachineWorld(); -// if (!(machineWorld.getTileEntity(tunnelPos) instanceof TileEntityTunnel)) { -// return false; -// } -// -// EnumFacing insetDirection = StructureTools.getInsetWallFacing(tunnelPos, this.getSize().getDimension()); -// BlockPos insetPos = tunnelPos.offset(insetDirection); -// -// TileEntity te = machineWorld.getTileEntity(insetPos); -// if (te != null && te instanceof ICapabilityProvider && te.hasCapability(capability, insetDirection.getOpposite())) { -// return true; -// } -// -// if (CapabilityNullHandlerRegistry.hasNullHandler(capability)) { -// return true; -// } -// -// return false; -// } -// -// @Override -// public T getCapability(Capability capability, EnumFacing facing) { -// if (isInsideItself()) { -// return null; -// } -// -// if (this.getWorld().isRemote || facing == null) { -// if (CapabilityNullHandlerRegistry.hasNullHandler(capability)) { -// return CapabilityNullHandlerRegistry.getNullHandler(capability); -// } -// -// return super.getCapability(capability, facing); -// } -// -// BlockPos tunnelPos = this.getConnectedBlockPosition(facing); -// if (tunnelPos == null) { -// return null; -// } -// -// WorldServer machineWorld = DimensionTools.getServerMachineWorld(); -// if (!(machineWorld.getTileEntity(tunnelPos) instanceof TileEntityTunnel)) { -// return null; -// } -// -// EnumFacing insetDirection = StructureTools.getInsetWallFacing(tunnelPos, this.getSize().getDimension()); -// BlockPos insetPos = tunnelPos.offset(insetDirection); -// -// TileEntity te = machineWorld.getTileEntity(insetPos); -// if (te instanceof ICapabilityProvider && te.hasCapability(capability, insetDirection.getOpposite())) { -// return machineWorld.getTileEntity(insetPos).getCapability(capability, insetDirection.getOpposite()); -// } -// -// if (CapabilityNullHandlerRegistry.hasNullHandler(capability)) { -// return CapabilityNullHandlerRegistry.getNullHandler(capability); -// } -// -// return null; -// } } diff --git a/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java b/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java index c0405042..22f950fc 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java @@ -5,7 +5,8 @@ import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; import com.robotgryphon.compactmachines.block.walls.TunnelWallBlock; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.persistent.ExternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; +import com.robotgryphon.compactmachines.data.persistent.MachineConnections; import com.robotgryphon.compactmachines.network.NetworkHandler; import com.robotgryphon.compactmachines.network.TunnelAddedPacket; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; @@ -26,8 +27,8 @@ import javax.annotation.Nonnull; import javax.annotation.Nullable; +import java.util.Collection; import java.util.Optional; -import java.util.Set; public class TunnelWallTile extends TileEntity { @@ -47,7 +48,7 @@ public void load(BlockState state, CompoundNBT nbt) { this.tunnelType = type; } - if(nbt.contains("machine")) { + if (nbt.contains("machine")) { this.connectedMachine = nbt.getInt("machine"); } } @@ -76,7 +77,7 @@ public void handleUpdateTag(BlockState state, CompoundNBT tag) { this.tunnelType = new ResourceLocation(tag.getString("tunnel_type")); } - if(tag.contains("machine")) { + if (tag.contains("machine")) { this.connectedMachine = tag.getInt("machine"); } } @@ -88,37 +89,36 @@ public Optional getConnectedPosition() { ServerWorld serverWorld = (ServerWorld) level; MinecraftServer serv = serverWorld.getServer(); - ExternalMachineData extern = ExternalMachineData.get(serv); - if(extern == null) + MachineConnections connections = MachineConnections.get(serv); + CompactMachineData extern = CompactMachineData.get(serv); + if (connections == null || extern == null) return Optional.empty(); if (this.connectedMachine <= 0) { - Optional mid = tryFindExternalMachineByChunkPos(extern); + Optional mid = tryFindExternalMachineByChunkPos(connections); // Map the results - either it found an ID and we can map, or it found nothing return mid.map(i -> { this.connectedMachine = i; - DimensionalPosition pos = extern.getMachineLocation(i); - if(pos == null) - return null; - - BlockPos bumped = pos.getBlockPosition().relative(getConnectedSide(), 1); - return new DimensionalPosition(pos.getDimension(), bumped); + Optional pos = extern.getMachineLocation(i); + return pos.map(p -> { + BlockPos bumped = p.getBlockPosition().relative(getConnectedSide(), 1); + return new DimensionalPosition(p.getDimension(), bumped); + }).orElse(null); }); } - DimensionalPosition pos = extern.getMachineLocation(this.connectedMachine); - if(pos == null) - return Optional.empty(); - - BlockPos bumped = pos.getBlockPosition().relative(getConnectedSide(), 1); - DimensionalPosition bdp = new DimensionalPosition(pos.getDimension(), bumped); - return Optional.of(bdp); + Optional pos = extern.getMachineLocation(this.connectedMachine); + return pos.map(p -> { + BlockPos bumped = p.getBlockPosition().relative(getConnectedSide(), 1); + DimensionalPosition bdp = new DimensionalPosition(p.getDimension(), bumped); + return bdp; + }); } - private Optional tryFindExternalMachineByChunkPos(ExternalMachineData extern) { + private Optional tryFindExternalMachineByChunkPos(MachineConnections connections) { ChunkPos thisMachineChunk = new ChunkPos(worldPosition); - Set externalMachineIDs = extern.getExternalMachineIDs(thisMachineChunk); + Collection externalMachineIDs = connections.graph.getMachinesFor(thisMachineChunk); // This shouldn't happen - there should always be at least one machine attached externally // If this DOES happen, it's probably a migration failure or the block was destroyed without notification diff --git a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java b/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java index 6970633f..8e776070 100644 --- a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java +++ b/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java @@ -6,13 +6,11 @@ import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; import com.robotgryphon.compactmachines.compat.theoneprobe.IProbeData; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; import com.robotgryphon.compactmachines.tunnels.TunnelHelper; import com.robotgryphon.compactmachines.util.TranslationUtil; import mcjty.theoneprobe.api.IProbeHitData; import mcjty.theoneprobe.api.IProbeInfo; import mcjty.theoneprobe.api.ProbeMode; -import net.minecraft.block.BlockState; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.math.BlockPos; @@ -22,64 +20,57 @@ import net.minecraft.world.World; import net.minecraft.world.server.ServerWorld; -import java.util.Optional; import java.util.Set; public class CompactMachineProvider { - public static void exec(IProbeData data, PlayerEntity player, World world, BlockState state) { - ProbeMode mode = data.getMode(); + public static void exec(IProbeData data, World world) { IProbeInfo info = data.getInfo(); IProbeHitData hitData = data.getHitData(); - addProbeInfo(mode, info, player, world, state, hitData); + addProbeInfo(info, world, hitData); } - private static void addProbeInfo(ProbeMode mode, IProbeInfo info, PlayerEntity player, World world, BlockState state, IProbeHitData hitData) { + private static void addProbeInfo(IProbeInfo info, World world, IProbeHitData hitData) { TileEntity te = world.getBlockEntity(hitData.getPos()); if (te instanceof CompactMachineTile) { CompactMachineTile machine = (CompactMachineTile) te; - Optional machineData = machine.getInternalData(); - machineData.ifPresent(md -> { + IFormattableTextComponent id = TranslationUtil + .tooltip(Tooltips.Machines.ID, machine.machineId) + .withStyle(TextFormatting.GREEN); - IFormattableTextComponent id = TranslationUtil - .tooltip(Tooltips.Machines.ID, machine.machineId) - .withStyle(TextFormatting.GREEN); - - info.text(id); + info.text(id); + machine.getOwnerUUID().ifPresent(ownerID -> { // Owner Name - PlayerEntity owner = world.getPlayerByUUID(md.getOwner()); + PlayerEntity owner = world.getPlayerByUUID(ownerID); if (owner != null) { GameProfile ownerProfile = owner.getGameProfile(); IFormattableTextComponent ownerText = TranslationUtil - .tooltip(Tooltips.Machines.OWNER, ownerProfile.getName()) - .withStyle(TextFormatting.GRAY); + .tooltip(Tooltips.Machines.OWNER, ownerProfile.getName()) + .withStyle(TextFormatting.GRAY); info.text(ownerText); } + }); - Set tunnelsForMachineSide = TunnelHelper.getTunnelsForMachineSide(machine.machineId, - (ServerWorld) world, hitData.getSideHit()); + Set tunnelsForMachineSide = TunnelHelper.getTunnelsForMachineSide(machine.machineId, + (ServerWorld) world, hitData.getSideHit()); - IProbeInfo vertical = info.vertical(info.defaultLayoutStyle().spacing(0)); + IProbeInfo vertical = info.vertical(info.defaultLayoutStyle().spacing(0)); - ServerWorld cm = world.getServer().getLevel(Registration.COMPACT_DIMENSION); - tunnelsForMachineSide.forEach(pos -> { - TunnelWallTile tile = (TunnelWallTile) cm.getBlockEntity(pos); - if (tile == null) - return; + ServerWorld cm = world.getServer().getLevel(Registration.COMPACT_DIMENSION); + tunnelsForMachineSide.forEach(pos -> { + TunnelWallTile tile = (TunnelWallTile) cm.getBlockEntity(pos); + if (tile == null) + return; - tile.getTunnelDefinition().ifPresent(tunnelDef -> { - vertical.text( - new StringTextComponent(pos.toString() + ": " + tunnelDef.getRegistryName().toString()) - ); - }); + tile.getTunnelDefinition().ifPresent(tunnelDef -> { + vertical.text( + new StringTextComponent(pos.toString() + ": " + tunnelDef.getRegistryName().toString()) + ); }); - - // TODO: Connected block info (inside) - // TunnelHelper.getConnectedState(world, te, EnumTunnelSide.INSIDE); }); } } diff --git a/src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java b/src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java index a97e9ec2..fe884960 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java @@ -1,26 +1,38 @@ package com.robotgryphon.compactmachines.data.codec; import com.mojang.serialization.Codec; +import com.mojang.serialization.DataResult; +import com.mojang.serialization.DynamicOps; +import com.mojang.serialization.codecs.PrimitiveCodec; import com.mojang.serialization.codecs.RecordCodecBuilder; +import net.minecraft.util.Util; import net.minecraft.util.math.ChunkPos; import net.minecraft.util.math.vector.Vector3d; +import org.lwjgl.system.CallbackI; +import java.util.Arrays; +import java.util.List; import java.util.UUID; +import java.util.stream.BaseStream; +import java.util.stream.Collectors; +import java.util.stream.DoubleStream; +import java.util.stream.IntStream; public abstract class CodecExtensions { + public static Codec UUID_CODEC = Codec.STRING + .comapFlatMap((s) -> { + try { + return DataResult.success(UUID.fromString(s)); + } catch (Exception ex) { + return DataResult.error("Not a valid UUID: " + s + " (" + ex.getMessage() + ")"); + } + }, UUID::toString).stable(); - public static Codec UUID_CODEC = RecordCodecBuilder.create(i -> i.group( - Codec.STRING.fieldOf("uuid").forGetter(UUID::toString) - ).apply(i, UUID::fromString)); + public static Codec VECTOR3D_CODEC = DoubleStreamExtensions.CODEC + .comapFlatMap(i -> DoubleStreamExtensions.fixedDoubleSize(i, 3) + .map(out -> new Vector3d(out[0], out[1], out[2])), vec -> DoubleStream.of(vec.x, vec.y, vec.z)); - public static Codec VECTOR3D_CODEC = RecordCodecBuilder.create(i -> i.group( - Codec.DOUBLE.fieldOf("x").forGetter(Vector3d::x), - Codec.DOUBLE.fieldOf("y").forGetter(Vector3d::y), - Codec.DOUBLE.fieldOf("z").forGetter(Vector3d::z) - ).apply(i, Vector3d::new)); - - public static Codec CHUNKPOS_CODEC = RecordCodecBuilder.create(i -> i.group( - Codec.INT.fieldOf("chunkX").forGetter((c) -> c.x), - Codec.INT.fieldOf("chunkZ").forGetter((c) -> c.z) - ).apply(i, ChunkPos::new)); + public static Codec CHUNKPOS_CODEC = Codec.INT_STREAM + .comapFlatMap(i -> Util.fixedSize(i, 2) + .map(arr -> new ChunkPos(arr[0], arr[1])), pos -> IntStream.of(pos.x, pos.z)); } diff --git a/src/main/java/com/robotgryphon/compactmachines/data/codec/DoubleStreamExtensions.java b/src/main/java/com/robotgryphon/compactmachines/data/codec/DoubleStreamExtensions.java new file mode 100644 index 00000000..dd0f9849 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/codec/DoubleStreamExtensions.java @@ -0,0 +1,50 @@ +package com.robotgryphon.compactmachines.data.codec; + +import com.mojang.serialization.DataResult; +import com.mojang.serialization.DynamicOps; +import com.mojang.serialization.codecs.PrimitiveCodec; + +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.DoubleStream; + +public class DoubleStreamExtensions { + + public static final PrimitiveCodec CODEC = new PrimitiveCodec() { + @Override + public DataResult read(final DynamicOps ops, final T input) { + return getDoubleStream(ops, input); + } + + @Override + public T write(final DynamicOps ops, final DoubleStream value) { + return ops.createList(value.mapToObj(ops::createDouble)); + } + + @Override + public String toString() { + return "DoubleStream"; + } + }; + + public static DataResult fixedDoubleSize(DoubleStream stream, int limit) { + double[] limited = stream.limit(limit + 1).toArray(); + if (limited.length != limit) { + String s = "Input is not a list of " + limit + " doubles"; + return limited.length >= limit ? DataResult.error(s, Arrays.copyOf(limited, limit)) : DataResult.error(s); + } else { + return DataResult.success(limited); + } + } + + public static DataResult getDoubleStream(final DynamicOps ops, final T input) { + return ops.getStream(input).flatMap(stream -> { + final List list = stream.collect(Collectors.toList()); + if (list.stream().allMatch(element -> ops.getNumberValue(element).result().isPresent())) { + return DataResult.success(list.stream().mapToDouble(element -> ops.getNumberValue(element).result().get().doubleValue())); + } + return DataResult.error("Some elements are not doubles: " + input); + }); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineExternal.java b/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineExternal.java deleted file mode 100644 index 96869540..00000000 --- a/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineExternal.java +++ /dev/null @@ -1,37 +0,0 @@ -package com.robotgryphon.compactmachines.data.machine; - -import com.mojang.serialization.Codec; -import com.mojang.serialization.codecs.RecordCodecBuilder; -import com.robotgryphon.compactmachines.data.codec.CodecExtensions; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; -import net.minecraft.util.math.ChunkPos; - -public class CompactMachineExternal { - private final int machineId; - public DimensionalPosition location; - private ChunkPos chunk; - - public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( - Codec.INT.fieldOf("machine").forGetter(CompactMachineExternal::getMachineId), - DimensionalPosition.CODEC.fieldOf("location").forGetter(CompactMachineExternal::getLocation), - CodecExtensions.CHUNKPOS_CODEC.fieldOf("chunk").forGetter(CompactMachineExternal::getMappedChunk) - ).apply(i, CompactMachineExternal::new)); - - public CompactMachineExternal(int machineId, DimensionalPosition location, ChunkPos inside) { - this.machineId = machineId; - this.location = location; - this.chunk = inside; - } - - public int getMachineId() { - return this.machineId; - } - - public DimensionalPosition getLocation() { - return this.location; - } - - public ChunkPos getMappedChunk() { - return this.chunk; - } -} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java b/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java index 5f75aa77..022529cf 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java @@ -2,6 +2,7 @@ import com.mojang.serialization.Codec; import com.mojang.serialization.codecs.RecordCodecBuilder; +import com.robotgryphon.compactmachines.data.codec.CodecExtensions; import com.robotgryphon.compactmachines.reference.EnumMachineSize; import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; @@ -10,11 +11,11 @@ public class CompactMachineInternalData { - public static Codec CODEC = RecordCodecBuilder.create(i -> i.group( - Codec.STRING.fieldOf("owner").forGetter(CompactMachineInternalData::getOwnerString), + public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( + CodecExtensions.UUID_CODEC.fieldOf("owner").forGetter(CompactMachineInternalData::getOwner), BlockPos.CODEC.fieldOf("center").forGetter(CompactMachineInternalData::getCenter), BlockPos.CODEC.fieldOf("spawn").forGetter(CompactMachineInternalData::getSpawn), - Codec.STRING.fieldOf("size").forGetter(CompactMachineInternalData::getSizeString) + EnumMachineSize.CODEC.fieldOf("size").forGetter(CompactMachineInternalData::getSize) ).apply(i, CompactMachineInternalData::new)); private final UUID owner; @@ -22,13 +23,6 @@ public class CompactMachineInternalData { private BlockPos spawn; private final EnumMachineSize size; - protected CompactMachineInternalData(String owner, BlockPos center, BlockPos spawn, String sizeString) { - this.owner = UUID.fromString(owner); - this.center = center; - this.spawn = spawn; - this.size = EnumMachineSize.getFromSize(sizeString); - } - public CompactMachineInternalData(UUID owner, BlockPos center, BlockPos spawn, EnumMachineSize size) { this.owner = owner; this.center = center; @@ -36,16 +30,12 @@ public CompactMachineInternalData(UUID owner, BlockPos center, BlockPos spawn, E this.size = size; } - private String getSizeString() { - return this.size.name(); + private EnumMachineSize getSize() { + return this.size; } public UUID getOwner() { return this.owner; } - private String getOwnerString() { - return owner.toString(); - } - public BlockPos getSpawn() { if(this.spawn != null) return this.spawn; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactMachineData.java b/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactMachineData.java new file mode 100644 index 00000000..9bc41b1d --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactMachineData.java @@ -0,0 +1,144 @@ +package com.robotgryphon.compactmachines.data.persistent; + +import com.mojang.serialization.Codec; +import com.mojang.serialization.DataResult; +import com.mojang.serialization.codecs.RecordCodecBuilder; +import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.core.Registration; +import com.robotgryphon.compactmachines.data.codec.CodecExtensions; +import com.robotgryphon.compactmachines.data.codec.NbtListCollector; +import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import net.minecraft.nbt.CompoundNBT; +import net.minecraft.nbt.INBT; +import net.minecraft.nbt.ListNBT; +import net.minecraft.nbt.NBTDynamicOps; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.world.server.ServerWorld; +import net.minecraft.world.storage.DimensionSavedDataManager; +import net.minecraft.world.storage.WorldSavedData; +import net.minecraftforge.common.util.Constants; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.util.*; + +/** + * Holds information on the external points of a machine, ie the actual machine blocks. + */ +public class CompactMachineData extends WorldSavedData { + + /** + * File storage name. + */ + public final static String DATA_NAME = CompactMachines.MOD_ID + "_machines"; + + /** + * Specifies locations of machines in-world, outside of the compact world. + * This is used for things like spawn lookups, tunnel handling, and forced ejections. + */ + public Map data; + + public CompactMachineData() { + super(DATA_NAME); + data = new HashMap<>(); + } + + @Nullable + public static CompactMachineData get(MinecraftServer server) { + ServerWorld compactWorld = server.getLevel(Registration.COMPACT_DIMENSION); + if (compactWorld == null) { + CompactMachines.LOGGER.error("No compact dimension found. Report this."); + return null; + } + + DimensionSavedDataManager sd = compactWorld.getDataStorage(); + return sd.computeIfAbsent(CompactMachineData::new, DATA_NAME); + } + + @Override + public void load(CompoundNBT nbt) { + if(nbt.contains("locations")) { + ListNBT nbtLocations = nbt.getList("locations", Constants.NBT.TAG_COMPOUND); + nbtLocations.forEach(nbtLoc -> { + DataResult res = MachineData.CODEC.parse(NBTDynamicOps.INSTANCE, nbtLoc); + res.resultOrPartial(err -> { + CompactMachines.LOGGER.error("Error while processing machine data: " + err); + }).ifPresent(machineInfo -> this.data.put(machineInfo.machineId, machineInfo)); + }); + } + } + + @Override + @Nonnull + public CompoundNBT save(@Nonnull CompoundNBT nbt) { + if(!data.isEmpty()) { + ListNBT nbtLocations = data.values() + .stream() + .map(entry -> { + DataResult nbtRes = MachineData.CODEC.encodeStart(NBTDynamicOps.INSTANCE, entry); + return nbtRes + .resultOrPartial(err -> CompactMachines.LOGGER.error("Error serializing machine data: " + err)); + + }) + .filter(Optional::isPresent) + .map(Optional::get) + .collect(NbtListCollector.toNbtList()); + + nbt.put("locations", nbtLocations); + } + + return nbt; + } + + public boolean isPlaced(Integer machineId) { + return data.containsKey(machineId); + } + + public void setMachineLocation(int machineId, DimensionalPosition position) { + // TODO - Packet/Event for machine changing external location (tunnels) + if(data.containsKey(machineId)) { + data.get(machineId).setLocation(position); + } else { + data.put(machineId, new MachineData(machineId, position)); + } + + this.setDirty(); + } + + public Optional getMachineLocation(int machineId) { + if(!data.containsKey(machineId)) + return Optional.empty(); + + MachineData machineData = this.data.get(machineId); + return Optional.ofNullable(machineData.location); + } + + public static class MachineData { + private final int machineId; + public DimensionalPosition location; + + public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( + Codec.INT.fieldOf("machine").forGetter(MachineData::getMachineId), + DimensionalPosition.CODEC.fieldOf("location").forGetter(MachineData::getLocation) + ).apply(i, MachineData::new)); + + public MachineData(int machineId, DimensionalPosition location) { + this.machineId = machineId; + this.location = location; + } + + public int getMachineId() { + return this.machineId; + } + + public DimensionalPosition getLocation() { + return this.location; + } + + public MachineData setLocation(DimensionalPosition position) { + this.location = position; + return this; + } + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/persistent/InternalMachineData.java b/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactRoomData.java similarity index 92% rename from src/main/java/com/robotgryphon/compactmachines/data/persistent/InternalMachineData.java rename to src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactRoomData.java index b20ddc5c..002592d6 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/persistent/InternalMachineData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactRoomData.java @@ -23,18 +23,18 @@ import java.util.Map; import java.util.Optional; -public class InternalMachineData extends WorldSavedData { - public static final String DATA_NAME = "machines_internal"; +public class CompactRoomData extends WorldSavedData { + public static final String DATA_NAME = CompactMachines.MOD_ID + "_rooms"; private Map machineData; - public InternalMachineData() { + public CompactRoomData() { super(DATA_NAME); machineData = new HashMap<>(); } @Nullable - public static InternalMachineData get(MinecraftServer server) { + public static CompactRoomData get(MinecraftServer server) { ServerWorld compactWorld = server.getLevel(Registration.COMPACT_DIMENSION); if (compactWorld == null) { CompactMachines.LOGGER.error("No compact dimension found. Report this."); @@ -42,7 +42,7 @@ public static InternalMachineData get(MinecraftServer server) { } DimensionSavedDataManager sd = compactWorld.getDataStorage(); - return sd.computeIfAbsent(InternalMachineData::new, DATA_NAME); + return sd.computeIfAbsent(CompactRoomData::new, DATA_NAME); } @Override diff --git a/src/main/java/com/robotgryphon/compactmachines/data/persistent/ExternalMachineData.java b/src/main/java/com/robotgryphon/compactmachines/data/persistent/ExternalMachineData.java deleted file mode 100644 index 243dd41a..00000000 --- a/src/main/java/com/robotgryphon/compactmachines/data/persistent/ExternalMachineData.java +++ /dev/null @@ -1,192 +0,0 @@ -package com.robotgryphon.compactmachines.data.persistent; - -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.codec.NbtListCollector; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; -import net.minecraft.nbt.CompoundNBT; -import net.minecraft.nbt.ListNBT; -import net.minecraft.server.MinecraftServer; -import net.minecraft.util.math.ChunkPos; -import net.minecraft.world.server.ServerWorld; -import net.minecraft.world.storage.DimensionSavedDataManager; -import net.minecraft.world.storage.WorldSavedData; -import net.minecraftforge.common.util.Constants; - -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import java.util.*; -import java.util.stream.Collectors; - -/** - * Holds information on the external points of a machine, ie the actual machine blocks. - */ -public class ExternalMachineData extends WorldSavedData { - - /** - * File storage name. - */ - public final static String DATA_NAME = "machines_external"; - - /** - * Used for performing reverse lookups on which machine internals are mapped - * to their external points. Effectively a cache for machineMapping. - */ - public Map> reverseMappingCache; - - /** - * Maps an external machine point to an internal machine chunk position. - * The inside of a machine may have multiple points accessing it in the future, - * due to advanced tunnels and fancier integrations. - */ - public Map machineMapping; - - /** - * Specifies locations of machines in-world, outside of the compact world. - * This is used for things like spawn lookups, tunnel handling, and forced ejections. - */ - public Map machineLocations; - - public ExternalMachineData() { - super(DATA_NAME); - machineMapping = new HashMap<>(); - machineLocations = new HashMap<>(); - reverseMappingCache = new HashMap<>(); - } - - @Nullable - public static ExternalMachineData get(MinecraftServer server) { - ServerWorld compactWorld = server.getLevel(Registration.COMPACT_DIMENSION); - if (compactWorld == null) { - CompactMachines.LOGGER.error("No compact dimension found. Report this."); - return null; - } - - DimensionSavedDataManager sd = compactWorld.getDataStorage(); - return sd.computeIfAbsent(ExternalMachineData::new, DATA_NAME); - } - - @Override - public void load(CompoundNBT nbt) { - if(nbt.contains("mapping")) { - ListNBT mapping = nbt.getList("mapping", Constants.NBT.TAG_COMPOUND); - mapping.forEach(map -> { - CompoundNBT mapEntry = (CompoundNBT) map; - ChunkPos cp = new ChunkPos( - mapEntry.getInt("chunkX"), - mapEntry.getInt("chunkZ") - ); - - int id = mapEntry.getInt("id"); - - // add to reverse lookup mapping - machineMapping.put(id, cp); - reverseMappingCache.putIfAbsent(cp, new HashSet<>()); - reverseMappingCache.get(cp).add(id); - }); - } - - if(nbt.contains("locations")) { - ListNBT nbtLocations = nbt.getList("locations", Constants.NBT.TAG_COMPOUND); - nbtLocations.forEach(nbtLoc -> { - CompoundNBT loc = (CompoundNBT) nbtLoc; - int machine = loc.getInt("machine"); - CompoundNBT locationNbt = loc.getCompound("location"); - DimensionalPosition dimLoc = DimensionalPosition.fromNBT(locationNbt); - - machineLocations.put(machine, dimLoc); - }); - } - } - - @Override - @Nonnull - public CompoundNBT save(@Nonnull CompoundNBT nbt) { - if(!machineMapping.isEmpty()) { - ListNBT list = machineMapping.entrySet() - .stream() - .map((i) -> { - ChunkPos cPos = i.getValue(); - CompoundNBT entry = new CompoundNBT(); - { - entry.putInt("id", i.getKey()); - entry.putInt("chunkX", cPos.x); - entry.putInt("chunkZ", cPos.z); - } - - return entry; - }).collect(NbtListCollector.toNbtList()); - - nbt.put("mapping", list); - } - - if(!machineLocations.isEmpty()) { - ListNBT nbtLocations = machineLocations.entrySet().stream() - .map(l -> { - int machine = l.getKey(); - DimensionalPosition location = l.getValue(); - - CompoundNBT entry = new CompoundNBT(); - { - entry.putInt("machine", machine); - entry.put("location", location.serializeNBT()); - } - - return entry; - }).collect(NbtListCollector.toNbtList()); - - nbt.put("locations", nbtLocations); - } - - return nbt; - } - - public Set getExternalMachineIDs(ChunkPos internal) { - if(!reverseMappingCache.containsKey(internal)) { - // If we hit this, we have an internal position that somehow didn't map to the external points - rebuildReverseMapCache(internal); - } - - return reverseMappingCache.get(internal); - } - - private void rebuildReverseMapCache(ChunkPos internal) { - // Rebuild the cache here - Set remapped = machineMapping - .entrySet().stream() - .filter(e -> e.getValue().equals(internal)) - .map(Map.Entry::getKey) - .collect(Collectors.toSet()); - - reverseMappingCache.put(internal, remapped); - } - - public Optional getChunkLocation(int machineId) { - return Optional.ofNullable(machineMapping.get(machineId)); - } - - public boolean isPlaced(Integer machineId) { - return machineLocations.containsKey(machineId); - } - - public void setMachineLocation(int machineId, DimensionalPosition position) { - // TODO - Packet/Event for machine changing external location (tunnels) - machineLocations.put(machineId, position); - this.setDirty(); - } - - @Nullable - public DimensionalPosition getMachineLocation(int machineId) { - return machineLocations.get(machineId); - } - - public Set getExternalMachineLocations(ChunkPos inside) { - Set externIDs = getExternalMachineIDs(inside); - - return machineLocations.entrySet() - .stream() - .filter(in -> externIDs.contains(in.getKey())) - .map(Map.Entry::getValue) - .collect(Collectors.toSet()); - } -} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java b/src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java index f81b22b4..2d29a388 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java @@ -15,14 +15,14 @@ public class MachineConnections extends WorldSavedData { public static final String DATA_NAME = CompactMachines.MOD_ID + "_connections"; - private CompactMachineConnectionGraph graph; + public CompactMachineConnectionGraph graph; public MachineConnections() { super(DATA_NAME); graph = new CompactMachineConnectionGraph(); } - public static MachineConnections instance(MinecraftServer server) { + public static MachineConnections get(MinecraftServer server) { ServerWorld compactWorld = server.getLevel(Registration.COMPACT_DIMENSION); if (compactWorld == null) { CompactMachines.LOGGER.error("No compact dimension found. Report this."); diff --git a/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java b/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java index d8e60992..e0a539d7 100644 --- a/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java +++ b/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java @@ -3,7 +3,7 @@ import com.mojang.authlib.GameProfile; import com.robotgryphon.compactmachines.api.core.Tooltips; import com.robotgryphon.compactmachines.block.BlockCompactMachine; -import com.robotgryphon.compactmachines.data.persistent.ExternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; import com.robotgryphon.compactmachines.reference.EnumMachineSize; import com.robotgryphon.compactmachines.reference.Reference; import com.robotgryphon.compactmachines.util.PlayerUtil; @@ -69,7 +69,7 @@ protected boolean canPlace(BlockItemUseContext ctx, BlockState state) { return getMachineId(stack) .map(id -> { // Need to determine if another machine with this ID already on server - ExternalMachineData extern = ExternalMachineData.get(serv); + CompactMachineData extern = CompactMachineData.get(serv); return extern.isPlaced(id); }) .orElse(true); diff --git a/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java b/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java index 3e79a21d..2016a3ac 100644 --- a/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java +++ b/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java @@ -4,7 +4,7 @@ import com.robotgryphon.compactmachines.api.core.Tooltips; import com.robotgryphon.compactmachines.client.gui.PersonalShrinkingDeviceScreen; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.persistent.InternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.CompactRoomData; import com.robotgryphon.compactmachines.util.PlayerUtil; import com.robotgryphon.compactmachines.util.TranslationUtil; import net.minecraft.client.gui.screen.Screen; @@ -75,7 +75,7 @@ public ActionResult use(World world, PlayerEntity player, Hand hand) if (player.isShiftKeyDown()) { ChunkPos machineChunk = new ChunkPos(player.blockPosition()); - InternalMachineData intern = InternalMachineData.get(serverWorld.getServer()); + CompactRoomData intern = CompactRoomData.get(serverWorld.getServer()); if (intern != null) { // Use internal data to set new spawn point intern.forChunk(machineChunk).ifPresent(data -> { diff --git a/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java b/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java index a2098329..a213383b 100644 --- a/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java +++ b/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java @@ -6,7 +6,8 @@ import com.robotgryphon.compactmachines.CompactMachines; import com.robotgryphon.compactmachines.client.machine.MachinePlayerEventHandler; import com.robotgryphon.compactmachines.data.codec.CodecExtensions; -import com.robotgryphon.compactmachines.data.persistent.ExternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; +import com.robotgryphon.compactmachines.data.persistent.MachineConnections; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.network.PacketBuffer; @@ -104,16 +105,22 @@ public static Builder create(MinecraftServer server) { @Nullable public MachinePlayersChangedPacket build() { - ExternalMachineData extern = ExternalMachineData.get(server); - if(extern == null) + MachineConnections connections = MachineConnections.get(server); + CompactMachineData extern = CompactMachineData.get(server); + if(connections == null || extern == null) { CompactMachines.LOGGER.fatal("Could not load external machine data from server."); return null; } - Set externalMachineIDs = extern.getExternalMachineLocations(chunk); + Collection externalMachineIDs = connections.graph.getMachinesFor(chunk); + HashSet externalLocations = new HashSet<>(); + for(int eid : externalMachineIDs) { + final Optional loc = extern.getMachineLocation(eid); + loc.ifPresent(externalLocations::add); + } - return new MachinePlayersChangedPacket(chunk, player, change.name(), externalMachineIDs); + return new MachinePlayersChangedPacket(chunk, player, change.name(), externalLocations); } public Builder forMachine(ChunkPos insideChunk) { diff --git a/src/main/java/com/robotgryphon/compactmachines/reference/EnumMachineSize.java b/src/main/java/com/robotgryphon/compactmachines/reference/EnumMachineSize.java index c964fac8..29679709 100644 --- a/src/main/java/com/robotgryphon/compactmachines/reference/EnumMachineSize.java +++ b/src/main/java/com/robotgryphon/compactmachines/reference/EnumMachineSize.java @@ -1,5 +1,6 @@ package com.robotgryphon.compactmachines.reference; +import com.mojang.serialization.Codec; import net.minecraft.util.IStringSerializable; import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; @@ -15,6 +16,9 @@ public enum EnumMachineSize implements IStringSerializable { private String name; private int internalSize; + public static final Codec CODEC = IStringSerializable.fromEnum( + EnumMachineSize::values, EnumMachineSize::getFromSize); + EnumMachineSize(String name, int internalSize) { this.name = name; this.internalSize = internalSize; diff --git a/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java b/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java index fab277a8..5a18c824 100644 --- a/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java +++ b/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java @@ -3,7 +3,7 @@ import com.robotgryphon.compactmachines.CompactMachines; import com.robotgryphon.compactmachines.api.core.Messages; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.persistent.InternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.CompactRoomData; import com.robotgryphon.compactmachines.util.TranslationUtil; import net.minecraft.entity.Entity; import net.minecraft.entity.player.ServerPlayerEntity; @@ -59,7 +59,7 @@ private static boolean cancelOutOfBoxTeleport(Entity entity, Vector3d target) { ChunkPos machineChunk = new ChunkPos(entity.xChunk, entity.zChunk); - InternalMachineData intern = InternalMachineData.get(serv); + CompactRoomData intern = CompactRoomData.get(serv); if (intern == null) return false; diff --git a/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java index 76ecacad..1405397a 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java @@ -1,6 +1,7 @@ package com.robotgryphon.compactmachines.util; import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.ChunkPos; import net.minecraft.util.math.vector.Vector3i; public class MathUtil { @@ -48,4 +49,10 @@ public static BlockPos getCenterWithY(Vector3i regionIndex, int y) { y, (regionIndex.getZ() * 1024) + 8); } + + public static ChunkPos getChunkForRoomIndex(int roomIndex) { + Vector3i region = getRegionPositionByIndex(roomIndex); + BlockPos roomCenter = getCenterWithY(region, 0); + return new ChunkPos(roomCenter); + } } diff --git a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java index 2080cb56..77355dc4 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java @@ -7,9 +7,10 @@ import com.robotgryphon.compactmachines.config.ServerConfig; import com.robotgryphon.compactmachines.core.Registration; import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; +import com.robotgryphon.compactmachines.data.persistent.MachineConnections; import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; -import com.robotgryphon.compactmachines.data.persistent.ExternalMachineData; -import com.robotgryphon.compactmachines.data.persistent.InternalMachineData; +import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; +import com.robotgryphon.compactmachines.data.persistent.CompactRoomData; import com.robotgryphon.compactmachines.network.MachinePlayersChangedPacket; import com.robotgryphon.compactmachines.network.NetworkHandler; import com.robotgryphon.compactmachines.reference.EnumMachineSize; @@ -75,10 +76,16 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl return; if (!tile.mapped()) { - ExternalMachineData extern = ExternalMachineData.get(serv); - InternalMachineData intern = InternalMachineData.get(serv); + CompactMachineData machines = CompactMachineData.get(serv); + CompactRoomData rooms = CompactRoomData.get(serv); + MachineConnections connections = MachineConnections.get(serv); - int nextId = intern.getNextId(); + if (machines == null || rooms == null || connections == null) { + CompactMachines.LOGGER.error("Could not load world saved data while creating new machine and room."); + return; + } + + int nextId = rooms.getNextId(); Vector3i location = MathUtil.getRegionPositionByIndex(nextId); int centerY = ServerConfig.MACHINE_FLOOR_Y.get() + (size.getInternalSize() / 2); @@ -88,15 +95,19 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl CompactStructureGenerator.generateCompactStructure(compactWorld, size, newCenter); ChunkPos machineChunk = new ChunkPos(newCenter); tile.setMachineId(nextId); - extern.machineMapping.put(nextId, machineChunk); - extern.machineLocations.put(nextId, new DimensionalPosition(serverWorld.dimension(), machinePos)); - extern.setDirty(); + + connections.graph.addMachine(nextId); + connections.graph.addRoom(machineChunk); + connections.graph.connectMachineToRoom(nextId, machineChunk); + connections.setDirty(); + + machines.setMachineLocation(nextId, new DimensionalPosition(serverWorld.dimension(), machinePos)); BlockPos.Mutable newSpawn = newCenter.mutable(); newSpawn.setY(newSpawn.getY() - (size.getInternalSize() / 2)); try { - intern.register(machineChunk, new CompactMachineInternalData( + rooms.register(machineChunk, new CompactMachineInternalData( serverPlayer.getUUID(), newCenter, newSpawn, @@ -108,44 +119,29 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl } serv.submitAsync(() -> { - tile.getInternalData().ifPresent(mach -> { - BlockPos spawn = mach.getSpawn(); - InternalMachineData.get(serv).setDirty(); - try { - // Mark the player as inside the machine, set external spawn, and yeet - addPlayerToMachine(serverPlayer, machinePos); - } catch (Exception ex) { - CompactMachines.LOGGER.error(ex); - } - - serverPlayer.teleportTo( - compactWorld, - spawn.getX() + 0.5, - spawn.getY(), - spawn.getZ() + 0.5, - serverPlayer.yRot, - serverPlayer.xRot); - }); - - // TODO - Move machine generation to new method -// int nextID = serverData.getNextMachineId(); -// -// BlockPos center = getCenterForNewMachine(nextID, size); -// -// CompactStructureGenerator.generateCompactStructure(compactWorld, size, center); -// -// tile.setMachineId(nextID); -// CompactMachineRegistrationData regData = new CompactMachineRegistrationData(nextID, center, serverPlayer.getUUID(), size); -// regData.setWorldPosition(serverWorld, machinePos); -// -// serverData.registerMachine(nextID, regData); -// machineData.setDirty(); -// -// BlockPos.Mutable spawn = center.mutable(); -// spawn.setY(ServerConfig.MACHINE_FLOOR_Y.get()); -// -// spawnPoint = spawn.immutable(); + BlockPos spawn = tile.getSpawn().orElse(null); + if (spawn == null) { + CompactMachines.LOGGER.error("Machine " + tile.machineId + " could not load spawn info."); + return; + } + + try { + // Mark the player as inside the machine, set external spawn, and yeet + addPlayerToMachine(serverPlayer, machinePos); + } catch (Exception ex) { + CompactMachines.LOGGER.error(ex); + } + + serverPlayer.teleportTo( + compactWorld, + spawn.getX() + 0.5, + spawn.getY(), + spawn.getZ() + 0.5, + serverPlayer.yRot, + serverPlayer.xRot); }); + + // TODO - Move machine generation to new method } public static void teleportPlayerOutOfMachine(ServerWorld world, ServerPlayerEntity serverPlayer) { diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java b/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java index de63e8b2..a860f669 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java +++ b/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java @@ -7,7 +7,7 @@ import com.robotgryphon.compactmachines.data.graph.CompactMachineNode; import com.robotgryphon.compactmachines.data.graph.CompactMachineRoomNode; import com.robotgryphon.compactmachines.data.graph.IMachineGraphNode; -import com.robotgryphon.compactmachines.tests.util.FileHelper; +import com.robotgryphon.compactmachines.util.MathUtil; import net.minecraft.nbt.*; import net.minecraft.util.math.ChunkPos; import net.minecraftforge.common.util.Constants; @@ -15,8 +15,6 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; -import java.io.File; -import java.io.IOException; import java.util.Collection; import java.util.Optional; @@ -33,6 +31,28 @@ private CompactMachineConnectionGraph generateGraphWithSingleRoom() { return g; } + private CompactMachineConnectionGraph generateGraphWithMultipleRooms(int numRooms) { + CompactMachineConnectionGraph g = new CompactMachineConnectionGraph(); + + for(int i = 0; i < numRooms; i++) { + g.addMachine(i); + ChunkPos chunk = MathUtil.getChunkForRoomIndex(i); + g.addRoom(chunk); + g.connectMachineToRoom(i, chunk); + } + + return g; + } + + private void verifySingleRoomValid(CompactMachineConnectionGraph graph, int machine, ChunkPos room) { + Optional connectedRoom = graph.getConnectedRoom(machine); + Assertions.assertTrue(connectedRoom.isPresent()); + + connectedRoom.ifPresent(cRoom -> { + Assertions.assertEquals(room, cRoom); + }); + } + @Test @DisplayName("Can Create Basic Graph") void basicGraph() { @@ -64,18 +84,27 @@ void canCreateGraphWithLinkedMachine() { CompactMachineConnectionGraph g = generateGraphWithSingleRoom(); - Optional connectedRoom = g.getConnectedRoom(machine); - Assertions.assertTrue(connectedRoom.isPresent()); - - connectedRoom.ifPresent(cRoom -> { - Assertions.assertEquals(room, cRoom); - }); + verifySingleRoomValid(g, machine, room); Collection linkedMachines = g.getMachinesFor(room); Assertions.assertEquals(1, linkedMachines.size()); Assertions.assertTrue(linkedMachines.contains(machine)); } + + + @Test + @DisplayName("Create Multiple Rooms (1:1)") + void canCreateMultipleRoomsWithSingleLinkedMachine() { + CompactMachineConnectionGraph graph = generateGraphWithMultipleRooms(10); + + for(int roomIndex = 0; roomIndex < 10; roomIndex++) { + final ChunkPos EXPECTED_CHUNK = MathUtil.getChunkForRoomIndex(roomIndex); + + verifySingleRoomValid(graph, roomIndex, EXPECTED_CHUNK); + } + } + @Test @DisplayName("Create Multiple Linked Machines (M:1)") void canCreateRoomWithMultipleLinkedMachines() { @@ -85,7 +114,6 @@ void canCreateRoomWithMultipleLinkedMachines() { CompactMachineConnectionGraph g = new CompactMachineConnectionGraph(); - g.addMachine(0); g.addMachine(1); @@ -94,17 +122,8 @@ void canCreateRoomWithMultipleLinkedMachines() { g.connectMachineToRoom(0, roomChunk); g.connectMachineToRoom(1, roomChunk); - Optional connectedRoom = g.getConnectedRoom(0); - Assertions.assertTrue(connectedRoom.isPresent()); - connectedRoom.ifPresent(cRoom -> { - Assertions.assertEquals(EXPECTED_ROOM, cRoom); - }); - - Optional connectedRoom2 = g.getConnectedRoom(1); - Assertions.assertTrue(connectedRoom2.isPresent()); - connectedRoom2.ifPresent(cRoom2 -> { - Assertions.assertEquals(EXPECTED_ROOM, cRoom2); - }); + verifySingleRoomValid(g, 0, EXPECTED_ROOM); + verifySingleRoomValid(g, 1, EXPECTED_ROOM); Collection linkedMachines = g.getMachinesFor(EXPECTED_ROOM); Assertions.assertEquals(2, linkedMachines.size()); @@ -145,7 +164,7 @@ void canSerialize() { Assertions.assertTrue(conn1.contains("machine")); Assertions.assertTrue(conn1.contains("connections")); - CompoundNBT machineChunk = conn1.getCompound("machine"); + INBT machineChunk = conn1.get("machine"); DataResult chunkRes = CodecExtensions.CHUNKPOS_CODEC.parse(NBTDynamicOps.INSTANCE, machineChunk); chunkRes.resultOrPartial(Assertions::fail) .ifPresent(chunk -> { diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/codec/CodecTests.java b/src/test/java/com/robotgryphon/compactmachines/tests/codec/CodecTests.java new file mode 100644 index 00000000..c5a36871 --- /dev/null +++ b/src/test/java/com/robotgryphon/compactmachines/tests/codec/CodecTests.java @@ -0,0 +1,44 @@ +package com.robotgryphon.compactmachines.tests.codec; + +import com.mojang.serialization.DataResult; +import com.robotgryphon.compactmachines.data.codec.CodecExtensions; +import com.robotgryphon.compactmachines.reference.EnumMachineSize; +import net.minecraft.nbt.INBT; +import net.minecraft.nbt.ListNBT; +import net.minecraft.nbt.NBTDynamicOps; +import net.minecraft.nbt.StringNBT; +import net.minecraft.util.math.vector.Vector3d; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +public class CodecTests { + + @Test + void canSerializeVector3d() { + Vector3d expected = new Vector3d(1.25d, 2.50d, 3.75d); + + DataResult nbtResult = CodecExtensions.VECTOR3D_CODEC.encodeStart(NBTDynamicOps.INSTANCE, expected); + nbtResult.resultOrPartial(Assertions::fail) + .ifPresent(nbt -> { + ListNBT list = (ListNBT) nbt; + + Assertions.assertEquals(expected.x, list.getDouble(0)); + Assertions.assertEquals(expected.y, list.getDouble(1)); + Assertions.assertEquals(expected.z, list.getDouble(2)); + }); + } + + @Test + void canSerializeMachineSize() { + DataResult result = EnumMachineSize.CODEC.encodeStart(NBTDynamicOps.INSTANCE, EnumMachineSize.LARGE); + + result.resultOrPartial(Assertions::fail) + .ifPresent(nbt -> { + Assertions.assertEquals(StringNBT.TYPE, nbt.getType()); + + StringNBT string = (StringNBT) nbt; + Assertions.assertNotNull(string); + Assertions.assertEquals(EnumMachineSize.LARGE.getSerializedName(), string.getAsString()); + }); + } +} diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/nbt/MachineExternalDataTests.java b/src/test/java/com/robotgryphon/compactmachines/tests/nbt/MachineExternalDataTests.java index e814a899..c9141f67 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/nbt/MachineExternalDataTests.java +++ b/src/test/java/com/robotgryphon/compactmachines/tests/nbt/MachineExternalDataTests.java @@ -2,7 +2,7 @@ import com.mojang.serialization.Codec; import com.mojang.serialization.DataResult; -import com.robotgryphon.compactmachines.data.machine.CompactMachineExternal; +import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; import com.robotgryphon.compactmachines.tests.util.FileHelper; import net.minecraft.nbt.CompoundNBT; @@ -26,7 +26,7 @@ public class MachineExternalDataTests { private final Path EXTERNAL = Paths.get("scenario", "single-machine-player-inside", "machines_external.dat"); - Codec> c = CompactMachineExternal.CODEC.listOf() + Codec> c = CompactMachineData.MachineData.CODEC.listOf() .fieldOf("locations") .stable() .codec(); @@ -34,29 +34,26 @@ public class MachineExternalDataTests { @Test @DisplayName("Loads Single Machine Data") void canLoadSingleMachineData() throws IOException { - // The external point is overworld @8x4x8 (it was made in a default void superflat) + // The external point is overworld @ 8x4x8 (it was made in a default void superflat) DimensionalPosition OUTSIDE = new DimensionalPosition( RegistryKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation("overworld")), new BlockPos(8,4,8) ); - ChunkPos INSIDE = new ChunkPos(0, -64); - CompoundNBT nbt = FileHelper.INSTANCE.getNbtFromFile(EXTERNAL.toString()); CompoundNBT data = nbt.getCompound("data"); - DataResult> result = c.parse(NBTDynamicOps.INSTANCE, data); + DataResult> result = c.parse(NBTDynamicOps.INSTANCE, data); Assertions.assertFalse(data.isEmpty()); - Optional> res = result.result(); + Optional> res = result.result(); Assertions.assertTrue(res.isPresent()); res.ifPresent(list -> { Assertions.assertEquals(1, list.size()); - CompactMachineExternal extern = list.get(0); + CompactMachineData.MachineData extern = list.get(0); Assertions.assertEquals(OUTSIDE, extern.location); - Assertions.assertEquals(INSIDE, extern.getMappedChunk()); }); } } diff --git a/src/test/resources/scenario/single-machine-player-inside/machines_external.dat b/src/test/resources/scenario/single-machine-player-inside/machines_external.dat index 9a77ec7cfe4e6b19fd07343902c35961ad09592b..d217b8520940c34400e2e83956a6964ea451807c 100644 GIT binary patch literal 134 zcmV;10D1o(iwFP(@s3~s|22-m4#FT1L`SKS!qJFliwFP)4U1p^|Knm{;9_7&Ni0d^WZ=xnPfje!%+D+4VqjokWM*K`O-# Date: Sun, 2 May 2021 19:19:48 -0400 Subject: [PATCH 15/36] Add license (MIT) --- LICENSE | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 LICENSE diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..63b4b681 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) [year] [fullname] + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file From cf0c62452aab4bf616932b75db47d3414e19b1ca Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sun, 2 May 2021 19:39:46 -0400 Subject: [PATCH 16/36] Fix bug where pick block on unmapped machines gives ID 0 --- LICENSE | 2 +- .../block/BlockCompactMachine.java | 2 +- .../providers/CompactMachineProvider.java | 20 +++++++++++++++---- .../teleportation/DimensionalPosition.java | 3 +++ 4 files changed, 21 insertions(+), 6 deletions(-) diff --git a/LICENSE b/LICENSE index 63b4b681..4687e625 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) [year] [fullname] +Copyright (c) 2021 Compact Mods Team Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java b/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java index 0d733b58..9a3fdf79 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java @@ -226,7 +226,7 @@ public ItemStack getPickBlock(BlockState state, RayTraceResult target, IBlockRea nbt.putString("size", this.size.getName()); CompactMachineTile tileEntity = (CompactMachineTile) world.getBlockEntity(pos); - if (tileEntity != null) { + if (tileEntity != null && tileEntity.mapped()) { nbt.putInt("coords", tileEntity.machineId); } diff --git a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java b/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java index 8e776070..aeee0e6a 100644 --- a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java +++ b/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java @@ -1,6 +1,7 @@ package com.robotgryphon.compactmachines.compat.theoneprobe.providers; import com.mojang.authlib.GameProfile; +import com.robotgryphon.compactmachines.CompactMachines; import com.robotgryphon.compactmachines.api.core.Tooltips; import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; @@ -10,11 +11,14 @@ import com.robotgryphon.compactmachines.util.TranslationUtil; import mcjty.theoneprobe.api.IProbeHitData; import mcjty.theoneprobe.api.IProbeInfo; +import mcjty.theoneprobe.api.ITextStyle; import mcjty.theoneprobe.api.ProbeMode; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.BlockPos; import net.minecraft.util.text.IFormattableTextComponent; +import net.minecraft.util.text.ITextComponent; import net.minecraft.util.text.StringTextComponent; import net.minecraft.util.text.TextFormatting; import net.minecraft.world.World; @@ -36,11 +40,19 @@ private static void addProbeInfo(IProbeInfo info, World world, IProbeHitData hit if (te instanceof CompactMachineTile) { CompactMachineTile machine = (CompactMachineTile) te; - IFormattableTextComponent id = TranslationUtil - .tooltip(Tooltips.Machines.ID, machine.machineId) - .withStyle(TextFormatting.GREEN); + if(machine.mapped()) { + IFormattableTextComponent id = TranslationUtil + .tooltip(Tooltips.Machines.ID, machine.machineId) + .withStyle(TextFormatting.GREEN); - info.text(id); + info.text(id); + } else { + IFormattableTextComponent newMachine = TranslationUtil + .message(new ResourceLocation(CompactMachines.MOD_ID, "new_machine")) + .withStyle(TextFormatting.GREEN); + + info.text(newMachine); + } machine.getOwnerUUID().ifPresent(ownerID -> { // Owner Name diff --git a/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java b/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java index 0994080a..b27ebd30 100644 --- a/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java +++ b/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java @@ -83,6 +83,9 @@ public RegistryKey getDimension() { } private String getDimensionString() { + if(this.dimension == null) + return ""; + return this.dimension.location().toString(); } From 3631346b9b3d8d7993fad8aec6320f368a4e6fbc Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sun, 2 May 2021 23:55:55 -0400 Subject: [PATCH 17/36] More codec improvements, data updates - Creates copy of World registry key codec for use in DimensionalPos - Swaps machine tile getSpawn to use a DimensionalPos instead of BlockPos - Minor Codec renames - Move CMInternalData into CompactRoomData - RoomData now private, with access limited via CompactRoomData - PSD now calls getSpawn on the room data, instead of fetching entire RD instance and manually setting WSD dirty - Overhaul to DimPos to include a rotation (for spawning) and improve Codec usage (no more string serializing) - TeleEventHandler updated to call CompactRoomData#getInnerBounds - Add extra methods to MathUtil for chunk and BlockPos calculation - New room generation on player first entry improved - Teleportation into rooms now respects spawn rotation - Update unit tests to swap codec references --- .../block/tiles/CompactMachineTile.java | 28 ++- .../data/codec/CodecExtensions.java | 21 +- .../graph/CompactMachineConnectionGraph.java | 2 +- .../machine/CompactMachineInternalData.java | 61 ------ .../data/persistent/CompactRoomData.java | 180 ++++++++++++++++-- .../data/player/CompactMachinePlayerData.java | 4 +- .../item/ItemPersonalShrinkingDevice.java | 11 +- .../network/MachinePlayersChangedPacket.java | 2 +- .../teleportation/DimensionalPosition.java | 54 +++--- .../TeleportationEventHandler.java | 9 +- .../compactmachines/util/MathUtil.java | 14 +- .../compactmachines/util/PlayerUtil.java | 31 ++- .../compactmachines/tests/GraphTests.java | 2 +- .../tests/codec/CodecTests.java | 2 +- 14 files changed, 257 insertions(+), 164 deletions(-) delete mode 100644 src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java diff --git a/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java b/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java index c7c7c474..0cd5562c 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java @@ -2,7 +2,6 @@ import com.robotgryphon.compactmachines.config.ServerConfig; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; import com.robotgryphon.compactmachines.data.persistent.CompactRoomData; import com.robotgryphon.compactmachines.data.persistent.MachineConnections; import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; @@ -210,13 +209,13 @@ public CompoundNBT getUpdateTag() { } public Optional getInternalChunkPos() { - if(level instanceof ServerWorld) { + if (level instanceof ServerWorld) { MinecraftServer serv = level.getServer(); - if(serv == null) + if (serv == null) return Optional.empty(); MachineConnections connections = MachineConnections.get(serv); - if(connections == null) + if (connections == null) return Optional.empty(); return connections.graph.getConnectedRoom(this.machineId); @@ -290,11 +289,11 @@ protected void doChunkload(boolean force) { } public void doPostPlaced() { - if(this.level == null || this.level.isClientSide) + if (this.level == null || this.level.isClientSide) return; MinecraftServer serv = this.level.getServer(); - if(serv == null) + if (serv == null) return; DimensionalPosition dp = new DimensionalPosition( @@ -309,7 +308,7 @@ public void doPostPlaced() { } public void handlePlayerLeft(UUID playerID) { - if(this.playerData != null) + if (this.playerData != null) this.playerData.removePlayer(playerID); } @@ -323,27 +322,26 @@ public boolean mapped() { return getInternalChunkPos().isPresent(); } - public Optional getSpawn() { - if(level instanceof ServerWorld) { + public Optional getSpawn() { + if (level instanceof ServerWorld) { ServerWorld serverWorld = (ServerWorld) level; MinecraftServer serv = serverWorld.getServer(); MachineConnections connections = MachineConnections.get(serv); - if(connections == null) + if (connections == null) return Optional.empty(); Optional connectedRoom = connections.graph.getConnectedRoom(machineId); - if(!connectedRoom.isPresent()) + if (!connectedRoom.isPresent()) return Optional.empty(); CompactRoomData roomData = CompactRoomData.get(serv); - if(roomData == null) - return Optional.empty(); + if (roomData == null) + return Optional.empty(); ChunkPos chunk = connectedRoom.get(); - return roomData.forChunk(chunk) - .map(CompactMachineInternalData::getSpawn); + return Optional.ofNullable(roomData.getSpawn(chunk)); } return Optional.empty(); diff --git a/src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java b/src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java index fe884960..c9f5cbdb 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java @@ -2,24 +2,20 @@ import com.mojang.serialization.Codec; import com.mojang.serialization.DataResult; -import com.mojang.serialization.DynamicOps; -import com.mojang.serialization.codecs.PrimitiveCodec; -import com.mojang.serialization.codecs.RecordCodecBuilder; +import net.minecraft.util.RegistryKey; +import net.minecraft.util.ResourceLocation; import net.minecraft.util.Util; import net.minecraft.util.math.ChunkPos; import net.minecraft.util.math.vector.Vector3d; -import org.lwjgl.system.CallbackI; +import net.minecraft.util.registry.Registry; +import net.minecraft.world.World; -import java.util.Arrays; -import java.util.List; import java.util.UUID; -import java.util.stream.BaseStream; -import java.util.stream.Collectors; import java.util.stream.DoubleStream; import java.util.stream.IntStream; public abstract class CodecExtensions { - public static Codec UUID_CODEC = Codec.STRING + public static final Codec UUID_CODEC = Codec.STRING .comapFlatMap((s) -> { try { return DataResult.success(UUID.fromString(s)); @@ -28,11 +24,14 @@ public abstract class CodecExtensions { } }, UUID::toString).stable(); - public static Codec VECTOR3D_CODEC = DoubleStreamExtensions.CODEC + public static final Codec> WORLD_REGISTRY_KEY = ResourceLocation.CODEC + .xmap(RegistryKey.elementKey(Registry.DIMENSION_REGISTRY), RegistryKey::location); + + public static final Codec VECTOR3D = DoubleStreamExtensions.CODEC .comapFlatMap(i -> DoubleStreamExtensions.fixedDoubleSize(i, 3) .map(out -> new Vector3d(out[0], out[1], out[2])), vec -> DoubleStream.of(vec.x, vec.y, vec.z)); - public static Codec CHUNKPOS_CODEC = Codec.INT_STREAM + public static final Codec CHUNKPOS = Codec.INT_STREAM .comapFlatMap(i -> Util.fixedSize(i, 2) .map(arr -> new ChunkPos(arr[0], arr[1])), pos -> IntStream.of(pos.x, pos.z)); } diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java index e51208d1..8678922c 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java @@ -133,7 +133,7 @@ private static class CompactMachineConnectionInfo { private final List connectedMachines; public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( - CodecExtensions.CHUNKPOS_CODEC + CodecExtensions.CHUNKPOS .fieldOf("machine") .forGetter(CompactMachineConnectionInfo::room), diff --git a/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java b/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java deleted file mode 100644 index 022529cf..00000000 --- a/src/main/java/com/robotgryphon/compactmachines/data/machine/CompactMachineInternalData.java +++ /dev/null @@ -1,61 +0,0 @@ -package com.robotgryphon.compactmachines.data.machine; - -import com.mojang.serialization.Codec; -import com.mojang.serialization.codecs.RecordCodecBuilder; -import com.robotgryphon.compactmachines.data.codec.CodecExtensions; -import com.robotgryphon.compactmachines.reference.EnumMachineSize; -import net.minecraft.util.math.AxisAlignedBB; -import net.minecraft.util.math.BlockPos; - -import java.util.UUID; - -public class CompactMachineInternalData { - - public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( - CodecExtensions.UUID_CODEC.fieldOf("owner").forGetter(CompactMachineInternalData::getOwner), - BlockPos.CODEC.fieldOf("center").forGetter(CompactMachineInternalData::getCenter), - BlockPos.CODEC.fieldOf("spawn").forGetter(CompactMachineInternalData::getSpawn), - EnumMachineSize.CODEC.fieldOf("size").forGetter(CompactMachineInternalData::getSize) - ).apply(i, CompactMachineInternalData::new)); - - private final UUID owner; - private final BlockPos center; - private BlockPos spawn; - private final EnumMachineSize size; - - public CompactMachineInternalData(UUID owner, BlockPos center, BlockPos spawn, EnumMachineSize size) { - this.owner = owner; - this.center = center; - this.spawn = spawn; - this.size = size; - } - - private EnumMachineSize getSize() { - return this.size; - } - - public UUID getOwner() { return this.owner; } - - public BlockPos getSpawn() { - if(this.spawn != null) - return this.spawn; - - BlockPos.Mutable newSpawn = center.mutable(); - newSpawn.setY(newSpawn.getY() - (size.getInternalSize() / 2)); - - this.spawn = newSpawn; - return this.spawn; - } - - public BlockPos getCenter() { - return this.center; - } - - public void setSpawn(BlockPos newSpawn) { - this.spawn = newSpawn; - } - - public AxisAlignedBB getMachineBounds() { - return size.getBounds(this.center); - } -} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactRoomData.java b/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactRoomData.java index 002592d6..c8dec98a 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactRoomData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactRoomData.java @@ -1,16 +1,25 @@ package com.robotgryphon.compactmachines.data.persistent; +import com.mojang.serialization.Codec; import com.mojang.serialization.DataResult; +import com.mojang.serialization.codecs.RecordCodecBuilder; import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.config.ServerConfig; import com.robotgryphon.compactmachines.core.Registration; +import com.robotgryphon.compactmachines.data.codec.CodecExtensions; import com.robotgryphon.compactmachines.data.codec.NbtListCollector; -import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; +import com.robotgryphon.compactmachines.reference.EnumMachineSize; +import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import com.robotgryphon.compactmachines.util.MathUtil; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.INBT; import net.minecraft.nbt.ListNBT; import net.minecraft.nbt.NBTDynamicOps; import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.ChunkPos; +import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.server.ServerWorld; import net.minecraft.world.storage.DimensionSavedDataManager; import net.minecraft.world.storage.WorldSavedData; @@ -22,11 +31,12 @@ import java.util.HashMap; import java.util.Map; import java.util.Optional; +import java.util.UUID; public class CompactRoomData extends WorldSavedData { public static final String DATA_NAME = CompactMachines.MOD_ID + "_rooms"; - private Map machineData; + private Map machineData; public CompactRoomData() { super(DATA_NAME); @@ -50,15 +60,15 @@ public void load(CompoundNBT nbt) { if (nbt.contains("machines")) { ListNBT machines = nbt.getList("machines", Constants.NBT.TAG_COMPOUND); machines.forEach(machNbt -> { - DataResult result = - CompactMachineInternalData.CODEC.parse(NBTDynamicOps.INSTANCE, machNbt); + DataResult result = + RoomData.CODEC.parse(NBTDynamicOps.INSTANCE, machNbt); result - .resultOrPartial((err) -> CompactMachines.LOGGER.error("Error loading machine data from file: {}", err)) - .ifPresent(imd -> { - ChunkPos chunk = new ChunkPos(imd.getCenter()); - this.machineData.put(chunk, imd); - }); + .resultOrPartial((err) -> CompactMachines.LOGGER.error("Error loading machine data from file: {}", err)) + .ifPresent(imd -> { + ChunkPos chunk = new ChunkPos(imd.getCenter()); + this.machineData.put(chunk, imd); + }); }); } } @@ -70,7 +80,7 @@ public CompoundNBT save(@Nonnull CompoundNBT nbt) { ListNBT collect = machineData.values() .stream() .map(data -> { - DataResult n = CompactMachineInternalData.CODEC.encodeStart(NBTDynamicOps.INSTANCE, data); + DataResult n = RoomData.CODEC.encodeStart(NBTDynamicOps.INSTANCE, data); return n.result(); }) .filter(Optional::isPresent) @@ -87,19 +97,161 @@ public boolean isRegistered(ChunkPos chunkPos) { return machineData.containsKey(chunkPos); } - public void register(ChunkPos pos, CompactMachineInternalData data) throws OperationNotSupportedException { - if(isRegistered(pos)) + private void register(ChunkPos pos, RoomData data) throws OperationNotSupportedException { + if (isRegistered(pos)) throw new OperationNotSupportedException("Machine already registered."); machineData.put(pos, data); setDirty(); } - public Optional forChunk(ChunkPos chunkPos) { - return Optional.ofNullable(machineData.get(chunkPos)); + @Nullable + public DimensionalPosition getSpawn(ChunkPos roomChunk) { + RoomData roomData = machineData.get(roomChunk); + if (roomData == null) + return null; + + return new DimensionalPosition( + Registration.COMPACT_DIMENSION, + roomData.getSpawn() + ); } public int getNextId() { return this.machineData.size() + 1; } + + public void setSpawn(ChunkPos roomChunk, Vector3d position) { + if (!machineData.containsKey(roomChunk)) + return; + + RoomData roomData = machineData.get(roomChunk); + roomData.setSpawn(position); + + setDirty(); + } + + public Optional getInnerBounds(ChunkPos roomChunk) { + if (!machineData.containsKey(roomChunk)) + return Optional.empty(); + + AxisAlignedBB bounds = machineData.get(roomChunk).getMachineBounds(); + return Optional.of(bounds); + } + + public NewRoomRegistration createNew() { + return new NewRoomRegistration(this); + } + + public static class NewRoomRegistration { + + private final CompactRoomData storage; + private Vector3d spawn; + private ChunkPos chunk = new ChunkPos(0, 0); + private EnumMachineSize size = EnumMachineSize.TINY; + private BlockPos center = BlockPos.ZERO; + private UUID owner; + + public NewRoomRegistration(CompactRoomData storage) { + this.storage = storage; + } + + private void recalculateSize() { + BlockPos centerAtFloor = MathUtil.getCenterWithY(chunk, ServerConfig.MACHINE_FLOOR_Y.get()); + BlockPos centerSized = centerAtFloor.above(size.getInternalSize() / 2); + + this.spawn = new Vector3d(centerAtFloor.getX(), centerAtFloor.getY(), centerAtFloor.getZ()); + this.center = centerSized; + } + + public NewRoomRegistration owner(UUID owner) { + this.owner = owner; + return this; + } + + public NewRoomRegistration center(BlockPos roomCenter) { + this.center = roomCenter; + return this; + } + + public NewRoomRegistration size(EnumMachineSize size) { + this.size = size; + recalculateSize(); + return this; + } + + public NewRoomRegistration spawn(BlockPos spawn) { + this.spawn = new Vector3d(spawn.getX(), spawn.getY(), spawn.getZ()); + return this; + } + + public NewRoomRegistration chunk(ChunkPos chunk) { + this.chunk = chunk; + recalculateSize(); + return this; + } + + public void register() throws OperationNotSupportedException { + RoomData data = new RoomData(owner, center, spawn, size); + storage.register(chunk, data); + } + } + + private static class RoomData { + + public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( + CodecExtensions.UUID_CODEC.fieldOf("owner").forGetter(RoomData::getOwner), + BlockPos.CODEC.fieldOf("center").forGetter(RoomData::getCenter), + CodecExtensions.VECTOR3D.fieldOf("spawn").forGetter(RoomData::getSpawn), + EnumMachineSize.CODEC.fieldOf("size").forGetter(RoomData::getSize) + ).apply(i, RoomData::new)); + + private final UUID owner; + private final BlockPos center; + private Vector3d spawn; + private final EnumMachineSize size; + + public RoomData(UUID owner, BlockPos center, Vector3d spawn, EnumMachineSize size) { + this.owner = owner; + this.center = center; + this.spawn = spawn; + this.size = size; + } + + private EnumMachineSize getSize() { + return this.size; + } + + public UUID getOwner() { + return this.owner; + } + + public Vector3d getSpawn() { + if (this.spawn != null) + return this.spawn; + + Vector3d newSpawn = new Vector3d( + center.getX(), + center.getY(), + center.getZ() + ); + + double offset = size.getInternalSize() / 2.0d; + + this.spawn = newSpawn.subtract(0, offset, 0); + return this.spawn; + } + + public BlockPos getCenter() { + return this.center; + } + + public void setSpawn(Vector3d newSpawn) { + this.spawn = newSpawn; + } + + public AxisAlignedBB getMachineBounds() { + return size.getBounds(this.center); + } + } } diff --git a/src/main/java/com/robotgryphon/compactmachines/data/player/CompactMachinePlayerData.java b/src/main/java/com/robotgryphon/compactmachines/data/player/CompactMachinePlayerData.java index da5d5c97..2efdf781 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/player/CompactMachinePlayerData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/player/CompactMachinePlayerData.java @@ -59,7 +59,7 @@ public void load(CompoundNBT nbt) { CompoundNBT pd = (CompoundNBT) playerData; UUID id = pd.getUUID("id"); - Optional chunk = CodecExtensions.CHUNKPOS_CODEC + Optional chunk = CodecExtensions.CHUNKPOS .parse(NBTDynamicOps.INSTANCE, pd.get("chunk")) .resultOrPartial(CompactMachines.LOGGER::error); @@ -93,7 +93,7 @@ public CompoundNBT save(CompoundNBT nbt) { CompoundNBT pnbt = new CompoundNBT(); pnbt.put("id", intNBTS); - DataResult r = CodecExtensions.CHUNKPOS_CODEC.encodeStart(NBTDynamicOps.INSTANCE, u.getValue()); + DataResult r = CodecExtensions.CHUNKPOS.encodeStart(NBTDynamicOps.INSTANCE, u.getValue()); r.result().ifPresent(a -> pnbt.put("chunk", a)); return pnbt; diff --git a/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java b/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java index 2016a3ac..b98f89cb 100644 --- a/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java +++ b/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java @@ -78,15 +78,12 @@ public ActionResult use(World world, PlayerEntity player, Hand hand) CompactRoomData intern = CompactRoomData.get(serverWorld.getServer()); if (intern != null) { // Use internal data to set new spawn point - intern.forChunk(machineChunk).ifPresent(data -> { - data.setSpawn(player.blockPosition()); - intern.setDirty(); + intern.setSpawn(machineChunk, player.position()); - IFormattableTextComponent tc = TranslationUtil.message(Messages.MACHINE_SPAWNPOINT_SET) - .withStyle(TextFormatting.GREEN); + IFormattableTextComponent tc = TranslationUtil.message(Messages.MACHINE_SPAWNPOINT_SET) + .withStyle(TextFormatting.GREEN); - player.displayClientMessage(tc, true); - }); + player.displayClientMessage(tc, true); } } else { PlayerUtil.teleportPlayerOutOfMachine(serverWorld, serverPlayer); diff --git a/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java b/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java index a213383b..37d2b88d 100644 --- a/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java +++ b/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java @@ -28,7 +28,7 @@ public class MachinePlayersChangedPacket { public EnumPlayerChangeType type; public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( - CodecExtensions.CHUNKPOS_CODEC.fieldOf("machine").forGetter(MachinePlayersChangedPacket::getChunkPos), + CodecExtensions.CHUNKPOS.fieldOf("machine").forGetter(MachinePlayersChangedPacket::getChunkPos), CodecExtensions.UUID_CODEC.fieldOf("player").forGetter(MachinePlayersChangedPacket::getPlayer), Codec.STRING.fieldOf("type").forGetter((p) -> p.type.name()), DimensionalPosition.CODEC.listOf().fieldOf("positions").forGetter(p -> p.machinePositions.asList()) diff --git a/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java b/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java index b27ebd30..4da58af3 100644 --- a/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java +++ b/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java @@ -10,10 +10,8 @@ import net.minecraft.nbt.NBTDynamicOps; import net.minecraft.server.MinecraftServer; import net.minecraft.util.RegistryKey; -import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.vector.Vector3d; -import net.minecraft.util.registry.Registry; import net.minecraft.world.World; import net.minecraft.world.server.ServerWorld; import net.minecraftforge.common.util.INBTSerializable; @@ -26,27 +24,34 @@ public class DimensionalPosition implements INBTSerializable { private RegistryKey dimension; private Vector3d position; + private Vector3d rotation; + // Note: We'd use the actual world registry key here, but it static loads the world and does a bunch + // of initialization, making it impossible to unit test without booting a whole server up. public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( - Codec.STRING.fieldOf("dim").forGetter(DimensionalPosition::getDimensionString), - CodecExtensions.VECTOR3D_CODEC.fieldOf("pos").forGetter(DimensionalPosition::getPosition) + CodecExtensions.WORLD_REGISTRY_KEY.fieldOf("dim").forGetter(DimensionalPosition::getDimension), + CodecExtensions.VECTOR3D.fieldOf("pos").forGetter(DimensionalPosition::getPosition), + CodecExtensions.VECTOR3D.optionalFieldOf("rot", Vector3d.ZERO).forGetter(DimensionalPosition::getRotation) ).apply(i, DimensionalPosition::new)); private DimensionalPosition() { } - private DimensionalPosition(String dimKey, Vector3d pos) { - this.dimension = RegistryKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation(dimKey)); - this.position = pos; + public DimensionalPosition(RegistryKey world, BlockPos positionBlock) { + this(world, Vector3d.ZERO, Vector3d.ZERO); + this.position = new Vector3d(positionBlock.getX(), positionBlock.getY(), positionBlock.getZ()); } - public DimensionalPosition(RegistryKey dim, Vector3d pos) { - this.dimension = dim; - this.position = pos; + public DimensionalPosition(RegistryKey world, Vector3d positionBlock) { + this(world, positionBlock, Vector3d.ZERO); + this.dimension = world; + + this.rotation = Vector3d.ZERO; } - public DimensionalPosition(RegistryKey world, BlockPos positionBlock) { - this.dimension = world; - this.position = new Vector3d(positionBlock.getX(), positionBlock.getY(), positionBlock.getZ()); + public DimensionalPosition(RegistryKey dim, Vector3d pos, Vector3d rotation) { + this.dimension = dim; + this.position = pos; + this.rotation = rotation; } public Optional getWorld(@Nonnull MinecraftServer server) { @@ -75,6 +80,7 @@ public void deserializeNBT(CompoundNBT nbt) { dimensionalPosition.ifPresent(dp -> { this.dimension = dp.dimension; this.position = dp.position; + this.rotation = dp.rotation; }); } @@ -82,17 +88,14 @@ public RegistryKey getDimension() { return this.dimension; } - private String getDimensionString() { - if(this.dimension == null) - return ""; - - return this.dimension.location().toString(); - } - public Vector3d getPosition() { return this.position; } + public Vector3d getRotation() { + return this.rotation; + } + public BlockPos getBlockPosition() { return new BlockPos(position.x, position.y, position.z); } @@ -102,19 +105,22 @@ public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; DimensionalPosition that = (DimensionalPosition) o; - return Objects.equals(dimension, that.dimension) && Objects.equals(position, that.position); + return Objects.equals(dimension, that.dimension) && + Objects.equals(position, that.position) && + Objects.equals(rotation, rotation); } @Override public int hashCode() { - return Objects.hash(dimension, position); + return Objects.hash(dimension, position, rotation); } @Override public String toString() { return "DimensionalPosition{" + - "dimension=" + dimension + - ", position=" + position + + "d=" + dimension + + ", p=" + position + + ", r=" + rotation + '}'; } } diff --git a/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java b/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java index 5a18c824..d7625129 100644 --- a/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java +++ b/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java @@ -63,12 +63,9 @@ private static boolean cancelOutOfBoxTeleport(Entity entity, Vector3d target) { if (intern == null) return false; - return intern.forChunk(machineChunk).map(md -> { - AxisAlignedBB bounds = md.getMachineBounds(); - boolean targetInBounds = bounds.contains(target); - - return !targetInBounds; - }).orElse(false); + return intern.getInnerBounds(machineChunk) + .map(bounds -> !bounds.contains(target)) + .orElse(false); } private static void doEntityTeleportHandle(EntityEvent evt, Vector3d target, Entity ent) { diff --git a/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java index 1405397a..37f901d1 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java @@ -43,11 +43,17 @@ public static Vector3i getRegionPositionByIndex(int i) { return new Vector3i(x, 0, y); } + public static BlockPos getCenterWithY(ChunkPos chunk, int y) { + return chunk.getWorldPosition() + .offset(new BlockPos(8, y, 8)); + } + public static BlockPos getCenterWithY(Vector3i regionIndex, int y) { - return new BlockPos( - (regionIndex.getX() * 1024) + 8, - y, - (regionIndex.getZ() * 1024) + 8); + ChunkPos chunk = new ChunkPos( + regionIndex.getX() * 64, + regionIndex.getZ() * 64); + + return getCenterWithY(chunk, y); } public static ChunkPos getChunkForRoomIndex(int roomIndex) { diff --git a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java index 77355dc4..3ceb445b 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java @@ -6,7 +6,6 @@ import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; import com.robotgryphon.compactmachines.config.ServerConfig; import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData; import com.robotgryphon.compactmachines.data.persistent.MachineConnections; import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; @@ -103,23 +102,19 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl machines.setMachineLocation(nextId, new DimensionalPosition(serverWorld.dimension(), machinePos)); - BlockPos.Mutable newSpawn = newCenter.mutable(); - newSpawn.setY(newSpawn.getY() - (size.getInternalSize() / 2)); - try { - rooms.register(machineChunk, new CompactMachineInternalData( - serverPlayer.getUUID(), - newCenter, - newSpawn, - size - )); + rooms.createNew() + .owner(serverPlayer.getUUID()) + .size(size) + .center(newCenter) + .register(); } catch (OperationNotSupportedException e) { CompactMachines.LOGGER.warn(e); } } serv.submitAsync(() -> { - BlockPos spawn = tile.getSpawn().orElse(null); + DimensionalPosition spawn = tile.getSpawn().orElse(null); if (spawn == null) { CompactMachines.LOGGER.error("Machine " + tile.machineId + " could not load spawn info."); return; @@ -132,13 +127,17 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl CompactMachines.LOGGER.error(ex); } + Vector3d sp = spawn.getPosition(); + Vector3d sr = spawn.getRotation() != Vector3d.ZERO ? + spawn.getRotation() : new Vector3d(serverPlayer.xRot, serverPlayer.yRot, 0); + serverPlayer.teleportTo( compactWorld, - spawn.getX() + 0.5, - spawn.getY(), - spawn.getZ() + 0.5, - serverPlayer.yRot, - serverPlayer.xRot); + sp.x, + sp.y, + sp.z, + (float) sr.y, + (float) sr.x); }); // TODO - Move machine generation to new method diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java b/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java index a860f669..620db430 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java +++ b/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java @@ -165,7 +165,7 @@ void canSerialize() { Assertions.assertTrue(conn1.contains("connections")); INBT machineChunk = conn1.get("machine"); - DataResult chunkRes = CodecExtensions.CHUNKPOS_CODEC.parse(NBTDynamicOps.INSTANCE, machineChunk); + DataResult chunkRes = CodecExtensions.CHUNKPOS.parse(NBTDynamicOps.INSTANCE, machineChunk); chunkRes.resultOrPartial(Assertions::fail) .ifPresent(chunk -> { Assertions.assertEquals(new ChunkPos(0, 0), chunk); diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/codec/CodecTests.java b/src/test/java/com/robotgryphon/compactmachines/tests/codec/CodecTests.java index c5a36871..f8cec4c5 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/codec/CodecTests.java +++ b/src/test/java/com/robotgryphon/compactmachines/tests/codec/CodecTests.java @@ -17,7 +17,7 @@ public class CodecTests { void canSerializeVector3d() { Vector3d expected = new Vector3d(1.25d, 2.50d, 3.75d); - DataResult nbtResult = CodecExtensions.VECTOR3D_CODEC.encodeStart(NBTDynamicOps.INSTANCE, expected); + DataResult nbtResult = CodecExtensions.VECTOR3D.encodeStart(NBTDynamicOps.INSTANCE, expected); nbtResult.resultOrPartial(Assertions::fail) .ifPresent(nbt -> { ListNBT list = (ListNBT) nbt; From 36bda1d8f2e06ffc74eb542a26c47324370375ac Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Mon, 3 May 2021 01:41:32 -0400 Subject: [PATCH 18/36] WIP code to handle multi-machine packets Mostly operational, needs more refinement to handle data edge cases and multiplayer environments --- .../data/persistent/CompactRoomData.java | 12 +-- .../network/CMPacketTargets.java | 62 +++++++++++++ .../network/MachinePlayersChangedPacket.java | 2 +- .../compactmachines/util/PlayerUtil.java | 86 ++++++------------- 4 files changed, 95 insertions(+), 67 deletions(-) create mode 100644 src/main/java/com/robotgryphon/compactmachines/network/CMPacketTargets.java diff --git a/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactRoomData.java b/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactRoomData.java index c8dec98a..73851da7 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactRoomData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactRoomData.java @@ -169,11 +169,6 @@ public NewRoomRegistration owner(UUID owner) { return this; } - public NewRoomRegistration center(BlockPos roomCenter) { - this.center = roomCenter; - return this; - } - public NewRoomRegistration size(EnumMachineSize size) { this.size = size; recalculateSize(); @@ -181,7 +176,12 @@ public NewRoomRegistration size(EnumMachineSize size) { } public NewRoomRegistration spawn(BlockPos spawn) { - this.spawn = new Vector3d(spawn.getX(), spawn.getY(), spawn.getZ()); + Vector3d spawnTest = new Vector3d(spawn.getX(), spawn.getY(), spawn.getZ()); + + // Make sure the spawn is inside the new room bounds + if(size.getBounds(this.center).contains(spawnTest)) + this.spawn = spawnTest; + return this; } diff --git a/src/main/java/com/robotgryphon/compactmachines/network/CMPacketTargets.java b/src/main/java/com/robotgryphon/compactmachines/network/CMPacketTargets.java new file mode 100644 index 00000000..68e68061 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/network/CMPacketTargets.java @@ -0,0 +1,62 @@ +package com.robotgryphon.compactmachines.network; + +import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; +import com.robotgryphon.compactmachines.data.persistent.MachineConnections; +import net.minecraft.entity.player.ServerPlayerEntity; +import net.minecraft.network.IPacket; +import net.minecraft.network.play.ServerPlayNetHandler; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.world.Dimension; +import net.minecraft.world.World; +import net.minecraft.world.chunk.Chunk; +import net.minecraft.world.server.ChunkManager; +import net.minecraft.world.server.ServerChunkProvider; +import net.minecraft.world.server.ServerWorld; +import net.minecraftforge.fml.network.NetworkDirection; +import net.minecraftforge.fml.network.PacketDistributor; + +import java.util.*; +import java.util.function.Consumer; +import java.util.function.Supplier; + +public class CMPacketTargets { + + public static final PacketDistributor TRACKING_ROOM = new PacketDistributor<>( + CMPacketTargets::trackingRoom, NetworkDirection.PLAY_TO_CLIENT); + + private static Consumer> trackingRoom(PacketDistributor dist, Supplier supplier) { + Chunk roomChunk = supplier.get(); + World level = roomChunk.getLevel(); + + HashMap trackingPlayersGlobal = new HashMap<>(); + + if (level instanceof ServerWorld) { + ServerWorld serverWorld = (ServerWorld) level; + MinecraftServer server = serverWorld.getServer(); + + MachineConnections connections = MachineConnections.get(server); + CompactMachineData machines = CompactMachineData.get(server); + + Collection linked = connections.graph.getMachinesFor(roomChunk.getPos()); + + for (int machine : linked) { + machines.getMachineLocation(machine).ifPresent(loc -> { + Optional machineWorld = loc.getWorld(server); + BlockPos machineWorldLocation = loc.getBlockPosition(); + ChunkPos machineWorldChunk = new ChunkPos(machineWorldLocation); + + machineWorld.ifPresent(mw -> { + mw.getChunkSource().chunkMap.getPlayers(machineWorldChunk, false).forEach(player -> { + if (!trackingPlayersGlobal.containsKey(player.getUUID())) + trackingPlayersGlobal.put(player.getUUID(), player.connection); + }); + }); + }); + } + } + + return pack -> trackingPlayersGlobal.values().forEach(conn -> conn.send(pack)); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java b/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java index 37d2b88d..a56b3bac 100644 --- a/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java +++ b/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java @@ -58,7 +58,7 @@ public static void handle(MachinePlayersChangedPacket message, Supplier { - CompactMachines.LOGGER.debug("Player changed inside {}; outer position {}", message.machine, machinePos); + CompactMachines.LOGGER.debug("Player {} machine {} via {}", message.type, message.machine, machinePos); MachinePlayerEventHandler.handlePlayerMachineChanged(message.playerID, message.type, machinePos); }); diff --git a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java index 3ceb445b..1dcea128 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java @@ -10,6 +10,7 @@ import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; import com.robotgryphon.compactmachines.data.persistent.CompactRoomData; +import com.robotgryphon.compactmachines.network.CMPacketTargets; import com.robotgryphon.compactmachines.network.MachinePlayersChangedPacket; import com.robotgryphon.compactmachines.network.NetworkHandler; import com.robotgryphon.compactmachines.reference.EnumMachineSize; @@ -27,6 +28,7 @@ import net.minecraft.util.text.TranslationTextComponent; import net.minecraft.world.IWorld; import net.minecraft.world.World; +import net.minecraft.world.chunk.Chunk; import net.minecraft.world.server.ServerWorld; import net.minecraftforge.fml.network.PacketDistributor; @@ -106,7 +108,7 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl rooms.createNew() .owner(serverPlayer.getUUID()) .size(size) - .center(newCenter) + .chunk(machineChunk) .register(); } catch (OperationNotSupportedException e) { CompactMachines.LOGGER.warn(e); @@ -143,6 +145,7 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl // TODO - Move machine generation to new method } + // TODO - Overhaul this to handle nested machines public static void teleportPlayerOutOfMachine(ServerWorld world, ServerPlayerEntity serverPlayer) { MinecraftServer serv = world.getServer(); @@ -162,50 +165,20 @@ public static void teleportPlayerOutOfMachine(ServerWorld world, ServerPlayerEnt ChunkPos currentMachine = new ChunkPos(serverPlayer.blockPosition()); + MachineConnections connections = MachineConnections.get(serv); + if (connections == null) + return; + DimensionalPosition spawnPoint = externalSpawn.get(); - Optional outsideWorld = spawnPoint.getWorld(world.getServer()); + Optional outsideWorld = spawnPoint.getWorld(serv); outsideWorld.ifPresent(w -> { Vector3d worldPos = spawnPoint.getPosition(); - serverPlayer.teleportTo(w, worldPos.x(), worldPos.y(), worldPos.z(), serverPlayer.yRot, serverPlayer.xRot); - - // CompactMachinePlayerUtil.removePlayerFromMachine(serverPlayer, MACHINE_POS); - // TODO - Networking for player leaving machine -// machine.ifPresent(m -> { -// CompactMachinePlayerUtil.removePlayerFromMachine(serverPlayer, -// machineInfo.getOutsidePosition(serverPlayer.getServer()).getBlockPosition(), -// m.getId()); -// }); - }); - - // TODO -// Optional machinePlayers = serverData.getPlayerData(machineInfo.getId()); -// if (!machinePlayers.isPresent()) { -// // No player data for machine, wut -// CompactMachines.LOGGER.warn("Warning: Machine player data not set but machine registered, and player is inside. Machine ID: {}", machineInfo.getId()); -// serverPlayer.displayClientMessage(new TranslationTextComponent("ah_crap"), true); -// return; -// } -// -// Optional lastPos = machinePlayers.get().getExternalSpawn(serverPlayer); -// if (!lastPos.isPresent()) { -// // PANIC -// -// return; -// } else { -// DimensionalPosition p = lastPos.get(); -// Vector3d bp = p.getPosition(); -// Optional outsideWorld = p.getWorld(world.getServer()); -// outsideWorld.ifPresent(w -> { -// machine.ifPresent(m -> { -// serverPlayer.teleportTo(w, bp.x(), bp.y(), bp.z(), serverPlayer.yRot, serverPlayer.xRot); -// CompactMachinePlayerUtil.removePlayerFromMachine(serverPlayer, -// machineInfo.getOutsidePosition(serverPlayer.getServer()).getBlockPosition(), -// m.getId()); -// }); -// }); -// } + Vector3d entryRot = spawnPoint.getRotation(); + serverPlayer.teleportTo(w, worldPos.x(), worldPos.y(), worldPos.z(), (float) entryRot.y, (float) entryRot.x); + removePlayerFromMachine(serverPlayer, currentMachine); + }); } public static void addPlayerToMachine(ServerPlayerEntity serverPlayer, BlockPos machinePos) { @@ -221,7 +194,10 @@ public static void addPlayerToMachine(ServerPlayerEntity serverPlayer, BlockPos if (tile == null) return; + tile.getInternalChunkPos().ifPresent(mChunk -> { + final Chunk chunk = serv.getLevel(Registration.COMPACT_DIMENSION) + .getChunk(mChunk.x, mChunk.z); playerData.addPlayer(serverPlayer, mChunk); playerData.setDirty(); @@ -232,13 +208,11 @@ public static void addPlayerToMachine(ServerPlayerEntity serverPlayer, BlockPos .enteredFrom(tile.machineId) .build(); - NetworkHandler.MAIN_CHANNEL.send( - PacketDistributor.TRACKING_CHUNK.with(() -> serverPlayer.getLevel().getChunkAt(machinePos)), - p); + NetworkHandler.MAIN_CHANNEL.send(CMPacketTargets.TRACKING_ROOM.with(() -> chunk), p); }); } - public static void removePlayerFromMachine(ServerPlayerEntity serverPlayer, BlockPos machinePos) { + public static void removePlayerFromMachine(ServerPlayerEntity serverPlayer, ChunkPos roomChunk) { MinecraftServer serv = serverPlayer.getServer(); CompactMachinePlayerData playerData = CompactMachinePlayerData.get(serv); @@ -246,24 +220,16 @@ public static void removePlayerFromMachine(ServerPlayerEntity serverPlayer, Bloc return; playerData.removePlayer(serverPlayer); + playerData.setDirty(); - CompactMachineTile tile = (CompactMachineTile) serverPlayer.getLevel().getBlockEntity(machinePos); - if (tile == null) - return; - - tile.getInternalChunkPos().ifPresent(mChunk -> { + final Chunk chunk = serv.getLevel(Registration.COMPACT_DIMENSION) + .getChunk(roomChunk.x, roomChunk.z); - playerData.removePlayer(serverPlayer); - playerData.setDirty(); + MachinePlayersChangedPacket p = MachinePlayersChangedPacket.Builder.create(serv) + .forMachine(roomChunk) + .forPlayer(serverPlayer) + .build(); - MachinePlayersChangedPacket p = MachinePlayersChangedPacket.Builder.create(serv) - .forMachine(mChunk) - .forPlayer(serverPlayer) - .build(); - - NetworkHandler.MAIN_CHANNEL.send( - PacketDistributor.TRACKING_CHUNK.with(() -> serverPlayer.getLevel().getChunkAt(machinePos)), - p); - }); + NetworkHandler.MAIN_CHANNEL.send(CMPacketTargets.TRACKING_ROOM.with(() -> chunk), p); } } From 98c4b0833e40025aa66cde01ee4e4198ff69410e Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Thu, 12 Aug 2021 04:46:02 -0400 Subject: [PATCH 19/36] Advancements framework, better tele handling, player history start --- build.gradle | 14 +- src/generated/resources/.cache/cache | 2 + .../advancements/how_did_you_get_here.json | 29 ++++ .../compactmachines/advancements/root.json | 28 ++++ .../advancement/AdvancementTriggers.java | 11 ++ .../GenericAdvancementTriggerListener.java | 33 ++++ ...GenericAdvancementTriggerListenerList.java | 39 +++++ .../trigger/HowDidYouGetHereTrigger.java | 60 +++++++ .../api/core/Advancements.java | 8 + .../compactmachines/api/core/Messages.java | 1 + .../block/BlockCompactMachine.java | 18 +-- .../block/tiles/CompactMachineTile.java | 5 +- .../client/ClientEventHandler.java | 3 + .../machine/MachinePlayerEventHandler.java | 2 + .../compactmachines/core/ModBusEvents.java | 5 + .../graph/CompactMachineConnectionGraph.java | 11 +- .../data/graph/DefaultEdges.java | 8 + .../data/graph/IGraphEdge.java | 4 + .../data/graph/MachineLinkEdge.java | 4 + .../data/player/CompactMachinePlayerData.java | 125 ++------------- .../data/player/IPlayerHistoryNode.java | 5 + .../data/player/PlayerMachineHistory.java | 18 +++ .../datagen/AdvancementGenerator.java | 148 ++++++++++++++++++ .../datagen/DataGeneration.java | 2 + .../item/ItemBlockMachine.java | 24 +-- .../item/ItemPersonalShrinkingDevice.java | 15 +- .../rooms/IRoomHistoryItem.java | 10 ++ .../rooms/capability/CMRoomHistory.java | 34 ++++ .../capability/CapabilityRoomHistory.java | 33 ++++ .../rooms/capability/IRoomHistory.java | 14 ++ .../PlayerRoomHistoryCapProvider.java | 31 ++++ .../rooms/capability/RoomCapEventHandler.java | 32 ++++ .../compactmachines/util/LocationUtil.java | 15 ++ .../compactmachines/util/MathUtil.java | 6 + .../compactmachines/util/PlayerUtil.java | 113 +++++++------ .../compactmachines/util/TranslationUtil.java | 16 ++ .../assets/compactmachines/lang/en_us.json | 7 +- .../dimension/compact_world.json | 2 +- .../compactmachines/tests/GraphTests.java | 28 +++- 39 files changed, 738 insertions(+), 225 deletions(-) create mode 100644 src/generated/resources/data/compactmachines/advancements/how_did_you_get_here.json create mode 100644 src/generated/resources/data/compactmachines/advancements/root.json create mode 100644 src/main/java/com/robotgryphon/compactmachines/advancement/AdvancementTriggers.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/advancement/GenericAdvancementTriggerListener.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/advancement/GenericAdvancementTriggerListenerList.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/advancement/trigger/HowDidYouGetHereTrigger.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/api/core/Advancements.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/graph/DefaultEdges.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/graph/IGraphEdge.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/graph/MachineLinkEdge.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/player/IPlayerHistoryNode.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/data/player/PlayerMachineHistory.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/datagen/AdvancementGenerator.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/rooms/IRoomHistoryItem.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/rooms/capability/CMRoomHistory.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/rooms/capability/CapabilityRoomHistory.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/rooms/capability/IRoomHistory.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/rooms/capability/PlayerRoomHistoryCapProvider.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/rooms/capability/RoomCapEventHandler.java create mode 100644 src/main/java/com/robotgryphon/compactmachines/util/LocationUtil.java diff --git a/build.gradle b/build.gradle index 605ea735..7f983699 100644 --- a/build.gradle +++ b/build.gradle @@ -52,6 +52,9 @@ minecraft { // Recommended logging level for the console property 'forge.logging.console.level', 'debug' + property 'mixin.env.remapRefMap', 'true' + property 'mixin.env.refMapRemappingFile', "${buildDir}/createSrgToMcp/output.srg" + args '--username', 'Dev##' mods { @@ -70,6 +73,9 @@ minecraft { // Recommended logging level for the console property 'forge.logging.console.level', 'debug' + property 'mixin.env.remapRefMap', 'true' + property 'mixin.env.refMapRemappingFile', "${buildDir}/createSrgToMcp/output.srg" + mods { compactmachines { source sourceSets.main @@ -86,7 +92,13 @@ minecraft { // Recommended logging level for the console property 'forge.logging.console.level', 'debug' - args '--mod', 'compactmachines', '--existing', file('src/main/resources'), '--all', '--output', file('src/generated/resources/') + property 'mixin.env.remapRefMap', 'true' + property 'mixin.env.refMapRemappingFile', "${buildDir}/createSrgToMcp/output.srg" + + args '--mod', mod_id + args '--existing', file('src/main/resources') + args '--all' + args '--output', file('src/generated/resources/') mods { compactmachines { diff --git a/src/generated/resources/.cache/cache b/src/generated/resources/.cache/cache index 17226955..431f4daa 100644 --- a/src/generated/resources/.cache/cache +++ b/src/generated/resources/.cache/cache @@ -13,8 +13,10 @@ bb446af024870e7a07d31a3c78cab75797392cd5 assets/compactmachines/models/tunnels/n 2781d8f8d22db668495872f1bb39e2dd1290ab66 assets/compactmachines/models/tunnels/south.json 955410e7497ca2252d75eac53d02fb96992d94c7 assets/compactmachines/models/tunnels/up.json f8748baf2b48a44db2cf8d3872bd09b54a822560 assets/compactmachines/models/tunnels/west.json +26f679025def0ce9b0a9ec9d0e5f6ee83ea50bc3 data/compactmachines/advancements/how_did_you_get_here.json e012e4b65799a56d195a6324c82e2cdf7a5a91be data/compactmachines/advancements/recipes/compactmachines/personal_shrinking_device.json fd7ccf69e4445ba0a2d7b2cd405ebe2ae85be240 data/compactmachines/advancements/recipes/compactmachines/wall.json +8533fe67af279b20dda70b20dbcb03a20b6c4f23 data/compactmachines/advancements/root.json fb5c7560898ae604661d0655c2a39e923eb1d4b4 data/compactmachines/loot_tables/blocks/machine_giant.json 056d363f46ab1cc37c16f08428a3d2a9e0dd66d2 data/compactmachines/loot_tables/blocks/machine_large.json 38a7648eb331daf18f5076126f31f31b6021ac51 data/compactmachines/loot_tables/blocks/machine_maximum.json diff --git a/src/generated/resources/data/compactmachines/advancements/how_did_you_get_here.json b/src/generated/resources/data/compactmachines/advancements/how_did_you_get_here.json new file mode 100644 index 00000000..d46cc1ce --- /dev/null +++ b/src/generated/resources/data/compactmachines/advancements/how_did_you_get_here.json @@ -0,0 +1,29 @@ +{ + "parent": "compactmachines:root", + "display": { + "icon": { + "item": "compactmachines:personal_shrinking_device" + }, + "title": { + "translate": "advancement.compactmachines.how_did_you_get_here" + }, + "description": { + "translate": "advancement.compactmachines.how_did_you_get_here.desc" + }, + "frame": "challenge", + "show_toast": false, + "announce_to_chat": true, + "hidden": true + }, + "criteria": { + "got_stuck": { + "trigger": "compactmachines:how_did_you_get_here", + "conditions": {} + } + }, + "requirements": [ + [ + "got_stuck" + ] + ] +} \ No newline at end of file diff --git a/src/generated/resources/data/compactmachines/advancements/root.json b/src/generated/resources/data/compactmachines/advancements/root.json new file mode 100644 index 00000000..ce6906be --- /dev/null +++ b/src/generated/resources/data/compactmachines/advancements/root.json @@ -0,0 +1,28 @@ +{ + "display": { + "icon": { + "item": "compactmachines:machine_normal" + }, + "title": { + "translate": "advancement.compactmachines.root" + }, + "description": { + "translate": "advancement.compactmachines.root.desc" + }, + "frame": "task", + "show_toast": false, + "announce_to_chat": false, + "hidden": true, + "background": "compactmachines:textures/block/wall.png" + }, + "criteria": { + "root": { + "trigger": "minecraft:impossible" + } + }, + "requirements": [ + [ + "root" + ] + ] +} \ No newline at end of file diff --git a/src/main/java/com/robotgryphon/compactmachines/advancement/AdvancementTriggers.java b/src/main/java/com/robotgryphon/compactmachines/advancement/AdvancementTriggers.java new file mode 100644 index 00000000..1bf41ccb --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/advancement/AdvancementTriggers.java @@ -0,0 +1,11 @@ +package com.robotgryphon.compactmachines.advancement; + +import com.robotgryphon.compactmachines.advancement.trigger.HowDidYouGetHereTrigger; +import net.minecraft.advancements.CriteriaTriggers; + +public class AdvancementTriggers { + + public static final HowDidYouGetHereTrigger HOW_DID_YOU_GET_HERE = CriteriaTriggers.register(new HowDidYouGetHereTrigger()); + + public static void init() {} +} diff --git a/src/main/java/com/robotgryphon/compactmachines/advancement/GenericAdvancementTriggerListener.java b/src/main/java/com/robotgryphon/compactmachines/advancement/GenericAdvancementTriggerListener.java new file mode 100644 index 00000000..040b9c0c --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/advancement/GenericAdvancementTriggerListener.java @@ -0,0 +1,33 @@ +package com.robotgryphon.compactmachines.advancement; + +import java.util.Set; +import com.google.common.collect.Sets; +import net.minecraft.advancements.ICriterionInstance; +import net.minecraft.advancements.ICriterionTrigger; +import net.minecraft.advancements.PlayerAdvancements; + +public class GenericAdvancementTriggerListener { + + private final PlayerAdvancements advancements; + private final Set> listeners = Sets.newHashSet(); + + public GenericAdvancementTriggerListener(PlayerAdvancements advancements) { + this.advancements = advancements; + } + + public void add(ICriterionTrigger.Listener listener) { + listeners.add(listener); + } + + public void remove(ICriterionTrigger.Listener listener) { + listeners.remove(listener); + } + + public boolean empty() { + return listeners.isEmpty(); + } + + public void trigger() { + listeners.forEach(a -> a.run(advancements)); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/advancement/GenericAdvancementTriggerListenerList.java b/src/main/java/com/robotgryphon/compactmachines/advancement/GenericAdvancementTriggerListenerList.java new file mode 100644 index 00000000..8e1a2e0d --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/advancement/GenericAdvancementTriggerListenerList.java @@ -0,0 +1,39 @@ +package com.robotgryphon.compactmachines.advancement; + +import javax.annotation.Nullable; +import java.util.Map; +import com.google.common.collect.Maps; +import com.robotgryphon.compactmachines.advancement.trigger.HowDidYouGetHereTrigger; +import net.minecraft.advancements.ICriterionInstance; +import net.minecraft.advancements.ICriterionTrigger; +import net.minecraft.advancements.PlayerAdvancements; +import net.minecraft.entity.player.ServerPlayerEntity; + +public class GenericAdvancementTriggerListenerList { + private final Map> listeners = Maps.newHashMap(); + + + public void addPlayerListener(PlayerAdvancements advancements, ICriterionTrigger.Listener listener) { + GenericAdvancementTriggerListener listeners = this.listeners.computeIfAbsent(advancements, GenericAdvancementTriggerListener::new); + listeners.add(listener); + } + + public void removePlayerListener(PlayerAdvancements advancements, ICriterionTrigger.Listener listener) { + GenericAdvancementTriggerListener listeners = this.listeners.get(advancements); + if (listeners != null) { + listeners.remove(listener); + if (listeners.empty()) { + this.listeners.remove(advancements); + } + } + } + + public void removePlayerListeners(PlayerAdvancements advancements) { + this.listeners.remove(advancements); + } + + @Nullable + public GenericAdvancementTriggerListener getListeners(ServerPlayerEntity player) { + return listeners.get(player.getAdvancements()); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/advancement/trigger/HowDidYouGetHereTrigger.java b/src/main/java/com/robotgryphon/compactmachines/advancement/trigger/HowDidYouGetHereTrigger.java new file mode 100644 index 00000000..c78b5545 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/advancement/trigger/HowDidYouGetHereTrigger.java @@ -0,0 +1,60 @@ +package com.robotgryphon.compactmachines.advancement.trigger; + +import com.google.gson.JsonObject; +import com.robotgryphon.compactmachines.advancement.GenericAdvancementTriggerListener; +import com.robotgryphon.compactmachines.advancement.GenericAdvancementTriggerListenerList; +import com.robotgryphon.compactmachines.api.core.Advancements; +import net.minecraft.advancements.ICriterionTrigger; +import net.minecraft.advancements.PlayerAdvancements; +import net.minecraft.advancements.criterion.CriterionInstance; +import net.minecraft.advancements.criterion.EntityPredicate; +import net.minecraft.entity.player.ServerPlayerEntity; +import net.minecraft.loot.ConditionArrayParser; +import net.minecraft.util.ResourceLocation; + +public class HowDidYouGetHereTrigger implements ICriterionTrigger { + + private final GenericAdvancementTriggerListenerList listeners = new GenericAdvancementTriggerListenerList<>(); + + @Override + public ResourceLocation getId() { + return Advancements.HOW_DID_YOU_GET_HERE; + } + + @Override + public void addPlayerListener(PlayerAdvancements advancements, Listener list) { + listeners.addPlayerListener(advancements, list); + } + + @Override + public void removePlayerListener(PlayerAdvancements advancements, Listener list) { + listeners.removePlayerListener(advancements, list); + } + + @Override + public void removePlayerListeners(PlayerAdvancements advancements) { + listeners.removePlayerListeners(advancements); + } + + @Override + public Instance createInstance(JsonObject json, ConditionArrayParser conditions) { + return new Instance(EntityPredicate.AndPredicate.fromJson(json, "player", conditions)); + } + + public void trigger(ServerPlayerEntity player) { + final GenericAdvancementTriggerListener listeners = this.listeners.getListeners(player); + if(listeners != null) + listeners.trigger(); + } + + public static class Instance extends CriterionInstance { + + public Instance(EntityPredicate.AndPredicate player) { + super(Advancements.HOW_DID_YOU_GET_HERE, player); + } + + public static Instance create() { + return new Instance(EntityPredicate.AndPredicate.ANY); + } + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/api/core/Advancements.java b/src/main/java/com/robotgryphon/compactmachines/api/core/Advancements.java new file mode 100644 index 00000000..343c0854 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/api/core/Advancements.java @@ -0,0 +1,8 @@ +package com.robotgryphon.compactmachines.api.core; + +import net.minecraft.util.ResourceLocation; + +public class Advancements { + public static final ResourceLocation HOW_DID_YOU_GET_HERE = new ResourceLocation(Constants.MOD_ID, "how_did_you_get_here"); + public static final ResourceLocation ROOT = new ResourceLocation(Constants.MOD_ID, "root"); +} diff --git a/src/main/java/com/robotgryphon/compactmachines/api/core/Messages.java b/src/main/java/com/robotgryphon/compactmachines/api/core/Messages.java index 63e3802c..0ed765f7 100644 --- a/src/main/java/com/robotgryphon/compactmachines/api/core/Messages.java +++ b/src/main/java/com/robotgryphon/compactmachines/api/core/Messages.java @@ -7,4 +7,5 @@ public abstract class Messages { public static final ResourceLocation NO_MACHINE_DATA = new ResourceLocation(Constants.MOD_ID, "no_machine_data"); public static final ResourceLocation MACHINE_SPAWNPOINT_SET = new ResourceLocation(Constants.MOD_ID, "spawnpoint_set"); public static final ResourceLocation TELEPORT_OUT_OF_BOUNDS = new ResourceLocation(Constants.MOD_ID, "teleport_oob"); + public static final ResourceLocation HOW_DID_YOU_GET_HERE = new ResourceLocation(Constants.MOD_ID, "how_did_you_get_here"); } diff --git a/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java b/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java index 9a3fdf79..5c824382 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java @@ -12,12 +12,12 @@ import com.robotgryphon.compactmachines.core.EnumMachinePlayersBreakHandling; import com.robotgryphon.compactmachines.core.Registration; import com.robotgryphon.compactmachines.reference.EnumMachineSize; -import com.robotgryphon.compactmachines.reference.Reference; import com.robotgryphon.compactmachines.tunnels.TunnelHelper; import com.robotgryphon.compactmachines.util.PlayerUtil; import net.minecraft.block.AbstractBlock; import net.minecraft.block.Block; import net.minecraft.block.BlockState; +import net.minecraft.entity.Entity; import net.minecraft.entity.LivingEntity; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.entity.player.ServerPlayerEntity; @@ -51,6 +51,11 @@ public BlockCompactMachine(EnumMachineSize size, AbstractBlock.Properties props) this.size = size; } + @Override + public void entityInside(BlockState p_196262_1_, World p_196262_2_, BlockPos p_196262_3_, Entity p_196262_4_) { + super.entityInside(p_196262_1_, p_196262_2_, p_196262_3_, p_196262_4_); + } + @Override public float getDestroyProgress(BlockState state, PlayerEntity player, IBlockReader worldIn, BlockPos pos) { CompactMachineTile tile = (CompactMachineTile) worldIn.getBlockEntity(pos); @@ -301,14 +306,6 @@ public void setPlacedBy(World worldIn, BlockPos pos, BlockState state, @Nullable if(nbt == null) return; - if (nbt.contains(Reference.CompactMachines.OWNER_NBT)) { - tile.setOwner(nbt.getUUID(Reference.CompactMachines.OWNER_NBT)); - } - - if (!tile.getOwnerUUID().isPresent() && placer instanceof PlayerEntity) { - tile.setOwner(placer.getUUID()); - } - if (nbt.contains("cm")) { CompoundNBT machineData = nbt.getCompound("cm"); if (machineData.contains("coords")) { @@ -331,9 +328,6 @@ public ActionResultType use(BlockState state, World worldIn, BlockPos pos, Playe ServerPlayerEntity serverPlayer = (ServerPlayerEntity) player; - TileEntity te = worldIn.getBlockEntity(pos); - CompactMachineTile tile = (CompactMachineTile) te; - ItemStack mainItem = player.getMainHandItem(); if (mainItem.isEmpty()) return ActionResultType.PASS; diff --git a/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java b/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java index 0cd5562c..12610dfb 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java +++ b/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java @@ -308,14 +308,11 @@ public void doPostPlaced() { } public void handlePlayerLeft(UUID playerID) { - if (this.playerData != null) - this.playerData.removePlayer(playerID); + // TODO } public void handlePlayerEntered(UUID playerID) { // TODO -// if(this.playerData != null) -// this.playerData.addPlayer(playerID); } public boolean mapped() { diff --git a/src/main/java/com/robotgryphon/compactmachines/client/ClientEventHandler.java b/src/main/java/com/robotgryphon/compactmachines/client/ClientEventHandler.java index ed5b8bfe..fad3a3ad 100644 --- a/src/main/java/com/robotgryphon/compactmachines/client/ClientEventHandler.java +++ b/src/main/java/com/robotgryphon/compactmachines/client/ClientEventHandler.java @@ -1,5 +1,6 @@ package com.robotgryphon.compactmachines.client; +import java.util.stream.Stream; import com.robotgryphon.compactmachines.CompactMachines; import com.robotgryphon.compactmachines.core.Registration; import net.minecraft.client.renderer.RenderType; @@ -27,5 +28,7 @@ public static void onBlockColors(final ColorHandlerEvent.Block colors) { public static void onClientSetup(final FMLClientSetupEvent client) { RenderType cutout = RenderType.cutoutMipped(); RenderTypeLookup.setRenderLayer(Registration.BLOCK_TUNNEL_WALL.get(), cutout); + + Stream.of(new int[] {}).map(Object::toString).toArray(String[]::new); } } diff --git a/src/main/java/com/robotgryphon/compactmachines/client/machine/MachinePlayerEventHandler.java b/src/main/java/com/robotgryphon/compactmachines/client/machine/MachinePlayerEventHandler.java index 2cee69f1..5457e3c2 100644 --- a/src/main/java/com/robotgryphon/compactmachines/client/machine/MachinePlayerEventHandler.java +++ b/src/main/java/com/robotgryphon/compactmachines/client/machine/MachinePlayerEventHandler.java @@ -17,9 +17,11 @@ public static void handlePlayerMachineChanged(UUID playerID, if(w == null) return; + // Early exit if machine in another dimension if (w.dimension() != pos.getDimension()) return; + // Early exit if machine isn't in range of the player - the block sync will handle those if(!w.isLoaded(pos.getBlockPosition())) return; diff --git a/src/main/java/com/robotgryphon/compactmachines/core/ModBusEvents.java b/src/main/java/com/robotgryphon/compactmachines/core/ModBusEvents.java index ab698a10..a686200b 100644 --- a/src/main/java/com/robotgryphon/compactmachines/core/ModBusEvents.java +++ b/src/main/java/com/robotgryphon/compactmachines/core/ModBusEvents.java @@ -1,6 +1,8 @@ package com.robotgryphon.compactmachines.core; import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.advancement.AdvancementTriggers; +import com.robotgryphon.compactmachines.api.core.Advancements; import com.robotgryphon.compactmachines.compat.theoneprobe.TheOneProbeCompat; import com.robotgryphon.compactmachines.network.NetworkHandler; import net.minecraftforge.eventbus.api.SubscribeEvent; @@ -16,6 +18,9 @@ public class ModBusEvents { public static void setup(final FMLCommonSetupEvent event) { CompactMachines.LOGGER.trace("Initializing network handler."); NetworkHandler.initialize(); + + CompactMachines.LOGGER.trace("Registering advancement triggers."); + AdvancementTriggers.init(); } @SubscribeEvent diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java index 8678922c..c384f1a9 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java @@ -1,12 +1,11 @@ package com.robotgryphon.compactmachines.data.graph; import com.google.common.collect.ImmutableList; -import com.google.common.graph.ElementOrder; -import com.google.common.graph.GraphBuilder; -import com.google.common.graph.MutableGraph; +import com.google.common.graph.*; import com.mojang.serialization.Codec; import com.mojang.serialization.codecs.RecordCodecBuilder; import com.robotgryphon.compactmachines.data.codec.CodecExtensions; +import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; import net.minecraft.util.math.ChunkPos; import java.util.*; @@ -19,7 +18,7 @@ */ public class CompactMachineConnectionGraph { - private final MutableGraph graph; + private final MutableValueGraph graph; private final Map machines; private final Map rooms; @@ -32,7 +31,7 @@ public class CompactMachineConnectionGraph { public CompactMachineConnectionGraph() { - graph = GraphBuilder + graph = ValueGraphBuilder .directed() .nodeOrder(ElementOrder.sorted(Comparator.comparing(IMachineGraphNode::getId))) .build(); @@ -92,7 +91,7 @@ public void connectMachineToRoom(int machine, ChunkPos room) { CompactMachineNode machineNode = machines.get(machine); CompactMachineRoomNode roomNode = rooms.get(room); - graph.putEdge(machineNode, roomNode); + graph.putEdgeValue(machineNode, roomNode, DefaultEdges.MACHINE_LINK); } public Collection getMachinesFor(ChunkPos machineChunk) { diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/DefaultEdges.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/DefaultEdges.java new file mode 100644 index 00000000..6bacf09d --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/graph/DefaultEdges.java @@ -0,0 +1,8 @@ +package com.robotgryphon.compactmachines.data.graph; + +import java.util.HashMap; + +public class DefaultEdges { + + public static final IGraphEdge MACHINE_LINK = new MachineLinkEdge(); +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/IGraphEdge.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/IGraphEdge.java new file mode 100644 index 00000000..f2e60252 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/graph/IGraphEdge.java @@ -0,0 +1,4 @@ +package com.robotgryphon.compactmachines.data.graph; + +public interface IGraphEdge { +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/MachineLinkEdge.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/MachineLinkEdge.java new file mode 100644 index 00000000..e5f7b2b5 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/graph/MachineLinkEdge.java @@ -0,0 +1,4 @@ +package com.robotgryphon.compactmachines.data.graph; + +public class MachineLinkEdge implements IGraphEdge { +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/player/CompactMachinePlayerData.java b/src/main/java/com/robotgryphon/compactmachines/data/player/CompactMachinePlayerData.java index 2efdf781..5919beee 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/player/CompactMachinePlayerData.java +++ b/src/main/java/com/robotgryphon/compactmachines/data/player/CompactMachinePlayerData.java @@ -1,10 +1,14 @@ package com.robotgryphon.compactmachines.data.player; +import com.google.common.graph.ElementOrder; +import com.google.common.graph.GraphBuilder; +import com.google.common.graph.MutableGraph; import com.mojang.serialization.DataResult; import com.robotgryphon.compactmachines.CompactMachines; import com.robotgryphon.compactmachines.core.Registration; import com.robotgryphon.compactmachines.data.codec.CodecExtensions; import com.robotgryphon.compactmachines.data.codec.NbtListCollector; +import com.robotgryphon.compactmachines.data.graph.IMachineGraphNode; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; import com.robotgryphon.compactmachines.util.PlayerUtil; import net.minecraft.entity.player.ServerPlayerEntity; @@ -26,17 +30,17 @@ public class CompactMachinePlayerData extends WorldSavedData { public static final String DATA_NAME = "players"; - private HashMap internalPlayerLocations; - /** - * Holds a mapping of where players entered a machine. - */ - private HashMap externalSpawns; + public MutableGraph history; + private HashMap lookup; protected CompactMachinePlayerData() { super(DATA_NAME); - this.internalPlayerLocations = new HashMap<>(0); - this.externalSpawns = new HashMap<>(0); + this.history = GraphBuilder + .directed() + .build(); + + this.lookup = new HashMap<>(0); } @Nullable @@ -53,119 +57,12 @@ public static CompactMachinePlayerData get(MinecraftServer server) { @Override public void load(CompoundNBT nbt) { - if (nbt.contains("players")) { - ListNBT players = nbt.getList("players", Constants.NBT.TAG_COMPOUND); - players.forEach(playerData -> { - CompoundNBT pd = (CompoundNBT) playerData; - UUID id = pd.getUUID("id"); - - Optional chunk = CodecExtensions.CHUNKPOS - .parse(NBTDynamicOps.INSTANCE, pd.get("chunk")) - .resultOrPartial(CompactMachines.LOGGER::error); - - // If the chunk position was found, load it into the map - chunk.ifPresent(c -> { - this.internalPlayerLocations.put(id, c); - }); - }); - } - - if (nbt.contains("spawns")) { - ListNBT spawns = nbt.getList("spawns", Constants.NBT.TAG_COMPOUND); - spawns.forEach(spawnData -> { - CompoundNBT spawn = (CompoundNBT) spawnData; - UUID playerId = spawn.getUUID("id"); - DimensionalPosition pos = DimensionalPosition.fromNBT(spawn.getCompound("spawn")); - - externalSpawns.put(playerId, pos); - }); - } } @Override @Nonnull public CompoundNBT save(CompoundNBT nbt) { - ListNBT ids = internalPlayerLocations.entrySet() - .stream() - .map(u -> { - IntArrayNBT intNBTS = NBTUtil.createUUID(u.getKey()); - CompoundNBT pnbt = new CompoundNBT(); - pnbt.put("id", intNBTS); - - DataResult r = CodecExtensions.CHUNKPOS.encodeStart(NBTDynamicOps.INSTANCE, u.getValue()); - r.result().ifPresent(a -> pnbt.put("chunk", a)); - - return pnbt; - }) - .collect(NbtListCollector.toNbtList()); - nbt.put("players", ids); - - - ListNBT spawns = externalSpawns.entrySet() - .stream() - .map((pSpawn) -> { - CompoundNBT spawn = new CompoundNBT(); - - UUID playerId = pSpawn.getKey(); - DimensionalPosition pSpawnPos = pSpawn.getValue(); - spawn.put("id", NBTUtil.createUUID(playerId)); - spawn.put("spawn", pSpawnPos.serializeNBT()); - - return spawn; - }) - .collect(NbtListCollector.toNbtList()); - - nbt.put("spawns", spawns); - return nbt; } - - public boolean hasPlayers() { - return !internalPlayerLocations.isEmpty(); - } - - public void addPlayer(UUID playerID, ChunkPos innerChunk) { - if (!internalPlayerLocations.containsKey(playerID)) { - internalPlayerLocations.put(playerID, innerChunk); - } - } - - public void addPlayer(ServerPlayerEntity serverPlayer, ChunkPos innerChunk) { - UUID playerUUID = serverPlayer.getGameProfile().getId(); - addPlayer(playerUUID, innerChunk); - - // server support - add spawn to data - if (!externalSpawns.containsKey(playerUUID)) { - DimensionalPosition pos = PlayerUtil.getPlayerDimensionalPosition(serverPlayer); - externalSpawns.put(playerUUID, pos); - } - } - - public void removePlayer(UUID playerID) { - if (internalPlayerLocations.containsKey(playerID)) { - internalPlayerLocations.remove(playerID); - externalSpawns.remove(playerID); - } - } - - public void removePlayer(ServerPlayerEntity serverPlayer) { - UUID playerUUID = serverPlayer.getGameProfile().getId(); - removePlayer(playerUUID); - } - - public Optional getExternalSpawn(ServerPlayerEntity serverPlayer) { - UUID playerUUID = serverPlayer.getGameProfile().getId(); - if (!internalPlayerLocations.containsKey(playerUUID)) - return Optional.empty(); - - if (!externalSpawns.containsKey(playerUUID)) - return Optional.empty(); - - return Optional.of(externalSpawns.get(playerUUID)); - } - - public Set getPlayersInside(ChunkPos machinePos) { - return Collections.emptySet(); - } } diff --git a/src/main/java/com/robotgryphon/compactmachines/data/player/IPlayerHistoryNode.java b/src/main/java/com/robotgryphon/compactmachines/data/player/IPlayerHistoryNode.java new file mode 100644 index 00000000..721cad33 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/player/IPlayerHistoryNode.java @@ -0,0 +1,5 @@ +package com.robotgryphon.compactmachines.data.player; + +public interface IPlayerHistoryNode { + +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/player/PlayerMachineHistory.java b/src/main/java/com/robotgryphon/compactmachines/data/player/PlayerMachineHistory.java new file mode 100644 index 00000000..7b1ef66f --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/data/player/PlayerMachineHistory.java @@ -0,0 +1,18 @@ +package com.robotgryphon.compactmachines.data.player; + +import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; + +import java.util.Deque; + +public class PlayerMachineHistory { + + protected Deque history; + + public DimensionalPosition getLastEntryPoint() { + return history.getLast(); + } + + public DimensionalPosition getOrigin() { + return history.getFirst(); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/datagen/AdvancementGenerator.java b/src/main/java/com/robotgryphon/compactmachines/datagen/AdvancementGenerator.java new file mode 100644 index 00000000..89f8c745 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/datagen/AdvancementGenerator.java @@ -0,0 +1,148 @@ +package com.robotgryphon.compactmachines.datagen; + +import java.io.IOException; +import java.nio.file.Path; +import java.util.Set; +import java.util.function.Consumer; +import com.google.common.collect.Sets; +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.advancement.trigger.HowDidYouGetHereTrigger; +import com.robotgryphon.compactmachines.api.core.Advancements; +import com.robotgryphon.compactmachines.core.Registration; +import com.robotgryphon.compactmachines.util.TranslationUtil; +import net.minecraft.advancements.*; +import net.minecraft.advancements.criterion.ImpossibleTrigger; +import net.minecraft.data.DataGenerator; +import net.minecraft.data.DirectoryCache; +import net.minecraft.data.IDataProvider; +import net.minecraft.item.ItemStack; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.text.ITextComponent; +import net.minecraft.util.text.TranslationTextComponent; +import org.apache.logging.log4j.core.tools.picocli.CommandLine; + +public class AdvancementGenerator implements IDataProvider { + + private static final Gson GSON = (new GsonBuilder()).setPrettyPrinting().create(); + private final DataGenerator generator; + + public AdvancementGenerator(DataGenerator gen) { + this.generator = gen; + } + + @Override + public void run(DirectoryCache cache) { + Path path = this.generator.getOutputFolder(); + Set set = Sets.newHashSet(); + Consumer consumer = (adv) -> { + if (!set.add(adv.getId())) { + throw new IllegalStateException("Duplicate advancement " + adv.getId()); + } else { + Path path1 = path.resolve("data/" + adv.getId().getNamespace() + "/advancements/" + adv.getId().getPath() + ".json"); + + try { + IDataProvider.save(GSON, cache, adv.deconstruct().serializeToJson(), path1); + } catch (IOException ioexception) { + CompactMachines.LOGGER.error("Couldn't save advancement {}", path1, ioexception); + } + + } + }; + + generateAdvancements(consumer); + } + + private ResourceLocation modLoc(String i) { + return new ResourceLocation(CompactMachines.MOD_ID, i); + } + + private void generateAdvancements(Consumer consumer) { + + final Advancement root = Advancement.Builder.advancement() + .addCriterion("root", new ImpossibleTrigger.Instance()) + .display(new DisplayBuilder() + .frame(FrameType.TASK) + .background(modLoc("textures/block/wall.png")) + .item(new ItemStack(Registration.MACHINE_BLOCK_ITEM_NORMAL.get())) + .id(Advancements.ROOT) + .toast(false).hidden(true).chat(false) + .build()) + .save(consumer, modLoc("root").toString()); + + Advancement.Builder.advancement() + .parent(root) + .addCriterion("got_stuck", HowDidYouGetHereTrigger.Instance.create()) + .display(new DisplayBuilder() + .frame(FrameType.CHALLENGE) + .item(new ItemStack(Registration.PERSONAL_SHRINKING_DEVICE.get())) + .id(Advancements.HOW_DID_YOU_GET_HERE) + .toast(false).hidden(true) + .build()) + .save(consumer, Advancements.HOW_DID_YOU_GET_HERE.toString()); + } + + @Override + public String getName() { + return "CompactMachinesAdvancements"; + } + + private static class DisplayBuilder { + + private ItemStack stack; + private ResourceLocation translationId; + private boolean showToast = true; + private boolean showInChat = true; + private boolean isHidden = false; + private ResourceLocation background = null; + private FrameType frame = FrameType.TASK; + + public DisplayBuilder() { + } + + public DisplayInfo build() { + return new DisplayInfo(stack, + TranslationUtil.advancementTitle(translationId), + TranslationUtil.advancementDesc(translationId), + background, + frame, + showToast, showInChat, isHidden); + } + + public DisplayBuilder item(ItemStack item) { + stack = item; + return this; + } + + public DisplayBuilder id(ResourceLocation transId) { + translationId = transId; + return this; + } + + public DisplayBuilder toast(boolean toast) { + this.showToast = toast; + return this; + } + + public DisplayBuilder chat(boolean chat) { + this.showInChat = chat; + return this; + } + + public DisplayBuilder hidden(boolean hidden) { + this.isHidden = hidden; + return this; + } + + public DisplayBuilder background(ResourceLocation resource) { + this.background = resource; + return this; + } + + public DisplayBuilder frame(FrameType frame) { + this.frame = frame; + return this; + } + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/datagen/DataGeneration.java b/src/main/java/com/robotgryphon/compactmachines/datagen/DataGeneration.java index 7c0250f2..e2dfa5f1 100644 --- a/src/main/java/com/robotgryphon/compactmachines/datagen/DataGeneration.java +++ b/src/main/java/com/robotgryphon/compactmachines/datagen/DataGeneration.java @@ -22,6 +22,8 @@ public static void gatherData(GatherDataEvent event) { private static void registerServerProviders(DataGenerator generator, GatherDataEvent event) { generator.addProvider(new BlockLootGenerator(generator)); generator.addProvider(new RecipeGenerator(generator)); + + generator.addProvider(new AdvancementGenerator(generator)); } private static void registerClientProviders(DataGenerator generator, GatherDataEvent event) { diff --git a/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java b/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java index e0a539d7..29618d7c 100644 --- a/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java +++ b/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java @@ -54,37 +54,15 @@ public static Optional getMachineId(ItemStack stack) { return Optional.empty(); } - @Override - protected boolean canPlace(BlockItemUseContext ctx, BlockState state) { - boolean s = super.canPlace(ctx, state); - if (!s) return false; - - ItemStack stack = ctx.getItemInHand(); - World level = ctx.getLevel(); - - if(level.isClientSide) - return true; - - MinecraftServer serv = level.getServer(); - return getMachineId(stack) - .map(id -> { - // Need to determine if another machine with this ID already on server - CompactMachineData extern = CompactMachineData.get(serv); - return extern.isPlaced(id); - }) - .orElse(true); - } - @Override public void appendHoverText(ItemStack stack, @Nullable World worldIn, List tooltip, ITooltipFlag flagIn) { super.appendHoverText(stack, worldIn, tooltip, flagIn); - - // We need NBT data for the rest of this if (stack.hasTag()) { CompoundNBT nbt = stack.getTag(); + assert nbt != null; getMachineId(stack).ifPresent(id -> { tooltip.add(TranslationUtil.tooltip(Tooltips.Machines.ID, id)); diff --git a/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java b/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java index b98f89cb..d527e524 100644 --- a/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java +++ b/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java @@ -2,19 +2,26 @@ import com.robotgryphon.compactmachines.api.core.Messages; import com.robotgryphon.compactmachines.api.core.Tooltips; +import com.robotgryphon.compactmachines.block.BlockCompactMachine; +import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; import com.robotgryphon.compactmachines.client.gui.PersonalShrinkingDeviceScreen; import com.robotgryphon.compactmachines.core.Registration; import com.robotgryphon.compactmachines.data.persistent.CompactRoomData; import com.robotgryphon.compactmachines.util.PlayerUtil; import com.robotgryphon.compactmachines.util.TranslationUtil; +import net.minecraft.block.BlockState; import net.minecraft.client.gui.screen.Screen; import net.minecraft.client.util.ITooltipFlag; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemUseContext; +import net.minecraft.tileentity.TileEntity; import net.minecraft.util.ActionResult; +import net.minecraft.util.ActionResultType; import net.minecraft.util.Hand; +import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.ChunkPos; import net.minecraft.util.text.IFormattableTextComponent; import net.minecraft.util.text.ITextComponent; @@ -31,13 +38,6 @@ public ItemPersonalShrinkingDevice(Properties props) { super(props); } -// TODO Model locations -// @SideOnly(MixinEnvironment.Side.CLIENT) -// public void initModel() { -// ModelLoader.setCustomModelResourceLocation(this, 0, new ModelResourceLocation(getRegistryName(), "inventory")); -// } - - @Override public void appendHoverText(ItemStack stack, @Nullable World worldIn, List tooltip, ITooltipFlag flagIn) { super.appendHoverText(stack, worldIn, tooltip, flagIn); @@ -93,5 +93,4 @@ public ActionResult use(World world, PlayerEntity player, Hand hand) return ActionResult.success(stack); } - } diff --git a/src/main/java/com/robotgryphon/compactmachines/rooms/IRoomHistoryItem.java b/src/main/java/com/robotgryphon/compactmachines/rooms/IRoomHistoryItem.java new file mode 100644 index 00000000..5499a7e4 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/rooms/IRoomHistoryItem.java @@ -0,0 +1,10 @@ +package com.robotgryphon.compactmachines.rooms; + +import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; + +public interface IRoomHistoryItem { + + DimensionalPosition getEntryLocation(); + + int getMachine(); +} diff --git a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/CMRoomHistory.java b/src/main/java/com/robotgryphon/compactmachines/rooms/capability/CMRoomHistory.java new file mode 100644 index 00000000..894ab1f1 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/rooms/capability/CMRoomHistory.java @@ -0,0 +1,34 @@ +package com.robotgryphon.compactmachines.rooms.capability; + +import java.util.ArrayDeque; +import java.util.Deque; +import com.robotgryphon.compactmachines.rooms.IRoomHistoryItem; + +public class CMRoomHistory implements IRoomHistory{ + + private final Deque history; + + public CMRoomHistory() { + history = new ArrayDeque<>(10); + } + + @Override + public boolean hasHistory() { + return !history.isEmpty(); + } + + @Override + public IRoomHistoryItem peek() { + return history.peek(); + } + + @Override + public IRoomHistoryItem pop() { + return history.pop(); + } + + @Override + public void addHistory(IRoomHistoryItem item) { + history.add(item); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/CapabilityRoomHistory.java b/src/main/java/com/robotgryphon/compactmachines/rooms/capability/CapabilityRoomHistory.java new file mode 100644 index 00000000..0261c678 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/rooms/capability/CapabilityRoomHistory.java @@ -0,0 +1,33 @@ +package com.robotgryphon.compactmachines.rooms.capability; + +import javax.annotation.Nullable; +import com.robotgryphon.compactmachines.rooms.IRoomHistoryItem; +import net.minecraft.nbt.CompoundNBT; +import net.minecraft.nbt.INBT; +import net.minecraft.util.Direction; +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.common.capabilities.CapabilityInject; +import net.minecraftforge.common.capabilities.CapabilityManager; + +public class CapabilityRoomHistory { + + @CapabilityInject(IRoomHistory.class) + public static Capability HISTORY_CAPABILITY = null; + + public static void setup() { + CapabilityManager.INSTANCE.register( + IRoomHistory.class, + new Capability.IStorage() { + @Nullable + @Override + public INBT writeNBT(Capability capability, IRoomHistory instance, Direction side) { + return new CompoundNBT(); + } + + @Override + public void readNBT(Capability capability, IRoomHistory instance, Direction side, INBT nbt) { + + } + }, CMRoomHistory::new); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/IRoomHistory.java b/src/main/java/com/robotgryphon/compactmachines/rooms/capability/IRoomHistory.java new file mode 100644 index 00000000..0de99554 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/rooms/capability/IRoomHistory.java @@ -0,0 +1,14 @@ +package com.robotgryphon.compactmachines.rooms.capability; + +import java.util.Deque; +import com.robotgryphon.compactmachines.rooms.IRoomHistoryItem; + +public interface IRoomHistory { + + boolean hasHistory(); + IRoomHistoryItem peek(); + IRoomHistoryItem pop(); + + void addHistory(IRoomHistoryItem item); + +} diff --git a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/PlayerRoomHistoryCapProvider.java b/src/main/java/com/robotgryphon/compactmachines/rooms/capability/PlayerRoomHistoryCapProvider.java new file mode 100644 index 00000000..3a3ebae3 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/rooms/capability/PlayerRoomHistoryCapProvider.java @@ -0,0 +1,31 @@ +package com.robotgryphon.compactmachines.rooms.capability; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.util.Direction; +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.common.capabilities.ICapabilityProvider; +import net.minecraftforge.common.util.LazyOptional; + +public class PlayerRoomHistoryCapProvider implements ICapabilityProvider { + + private final PlayerEntity player; + private final CMRoomHistory history; + private LazyOptional opt = LazyOptional.empty(); + + public PlayerRoomHistoryCapProvider(PlayerEntity player) { + this.player = player; + this.history = new CMRoomHistory(); + this.opt = LazyOptional.of(() -> this.history); + } + + @Nonnull + @Override + public LazyOptional getCapability(@Nonnull Capability cap, @Nullable Direction side) { + if(cap == CapabilityRoomHistory.HISTORY_CAPABILITY) + return opt.cast(); + + return LazyOptional.empty(); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/RoomCapEventHandler.java b/src/main/java/com/robotgryphon/compactmachines/rooms/capability/RoomCapEventHandler.java new file mode 100644 index 00000000..d7d61177 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/rooms/capability/RoomCapEventHandler.java @@ -0,0 +1,32 @@ +package com.robotgryphon.compactmachines.rooms.capability; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import com.robotgryphon.compactmachines.CompactMachines; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.entity.player.ServerPlayerEntity; +import net.minecraft.util.Direction; +import net.minecraft.util.ResourceLocation; +import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.common.capabilities.ICapabilityProvider; +import net.minecraftforge.common.util.LazyOptional; +import net.minecraftforge.event.AttachCapabilitiesEvent; +import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.fml.common.Mod; + +@Mod.EventBusSubscriber(modid = CompactMachines.MOD_ID, bus = Mod.EventBusSubscriber.Bus.FORGE) +public class RoomCapEventHandler { + + @SubscribeEvent + public static void onCapPlayerAttach(final AttachCapabilitiesEvent event) { + if(!(event.getObject() instanceof ServerPlayerEntity)) + return; + + ServerPlayerEntity player = (ServerPlayerEntity) event.getObject(); + event.addCapability( + new ResourceLocation(CompactMachines.MOD_ID, "room_history"), + new PlayerRoomHistoryCapProvider(player)); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/util/LocationUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/LocationUtil.java new file mode 100644 index 00000000..1acceb20 --- /dev/null +++ b/src/main/java/com/robotgryphon/compactmachines/util/LocationUtil.java @@ -0,0 +1,15 @@ +package com.robotgryphon.compactmachines.util; + +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.vector.Vector3d; + +public class LocationUtil { + + public static Vector3d blockPosToVector(BlockPos pos) { + return new Vector3d( + pos.getX() + 0.5f, + pos.getY(), + pos.getZ() + 0.5f + ); + } +} diff --git a/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java index 37f901d1..92b38ea4 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java @@ -5,7 +5,13 @@ import net.minecraft.util.math.vector.Vector3i; public class MathUtil { + /** + * + * @param i + * @return + */ public static Vector3i getRegionPositionByIndex(int i) { + // From SO, https://stackoverflow.com/a/41141648 int index = i + 1; // wth int s = (int) Math.ceil(Math.sqrt(index)) + (int) ((Math.ceil(Math.sqrt(index)) % 2 + 1) % 2); diff --git a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java index 1dcea128..08781f5b 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java @@ -2,6 +2,7 @@ import com.mojang.authlib.GameProfile; import com.robotgryphon.compactmachines.CompactMachines; +import com.robotgryphon.compactmachines.advancement.AdvancementTriggers; import com.robotgryphon.compactmachines.api.core.Messages; import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; import com.robotgryphon.compactmachines.config.ServerConfig; @@ -14,6 +15,9 @@ import com.robotgryphon.compactmachines.network.MachinePlayersChangedPacket; import com.robotgryphon.compactmachines.network.NetworkHandler; import com.robotgryphon.compactmachines.reference.EnumMachineSize; +import com.robotgryphon.compactmachines.rooms.IRoomHistoryItem; +import com.robotgryphon.compactmachines.rooms.capability.CapabilityRoomHistory; +import com.robotgryphon.compactmachines.rooms.capability.IRoomHistory; import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.entity.player.ServerPlayerEntity; @@ -23,15 +27,13 @@ import net.minecraft.util.math.ChunkPos; import net.minecraft.util.math.vector.Vector3d; import net.minecraft.util.math.vector.Vector3i; -import net.minecraft.util.text.IFormattableTextComponent; -import net.minecraft.util.text.TextFormatting; -import net.minecraft.util.text.TranslationTextComponent; import net.minecraft.world.IWorld; import net.minecraft.world.World; import net.minecraft.world.chunk.Chunk; import net.minecraft.world.server.ServerWorld; -import net.minecraftforge.fml.network.PacketDistributor; +import net.minecraftforge.common.util.LazyOptional; +import javax.annotation.Nonnull; import javax.naming.OperationNotSupportedException; import java.util.Optional; import java.util.UUID; @@ -57,14 +59,6 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl ServerWorld serverWorld = serverPlayer.getLevel(); MinecraftServer serv = serverWorld.getServer(); - if (serverWorld.dimension() == Registration.COMPACT_DIMENSION) { - IFormattableTextComponent msg = TranslationUtil - .message(Messages.CANNOT_ENTER_MACHINE) - .withStyle(TextFormatting.RED); - - serverPlayer.displayClientMessage(msg, true); - return; - } ServerWorld compactWorld = serv.getLevel(Registration.COMPACT_DIMENSION); if (compactWorld == null) { @@ -146,41 +140,76 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl } // TODO - Overhaul this to handle nested machines - public static void teleportPlayerOutOfMachine(ServerWorld world, ServerPlayerEntity serverPlayer) { + public static void teleportPlayerOutOfMachine(ServerWorld world, @Nonnull ServerPlayerEntity serverPlayer) { MinecraftServer serv = world.getServer(); CompactMachinePlayerData playerData = CompactMachinePlayerData.get(serv); if (playerData == null) return; - Optional externalSpawn = playerData.getExternalSpawn(serverPlayer); - if (!externalSpawn.isPresent()) { - serverPlayer.displayClientMessage( - new TranslationTextComponent("messages.%s.how_did_you_get_here", CompactMachines.MOD_ID), - true - ); + final LazyOptional history = serverPlayer.getCapability(CapabilityRoomHistory.HISTORY_CAPABILITY); + if (!history.isPresent()) { + howDidYouGetThere(serverPlayer); return; } - ChunkPos currentMachine = new ChunkPos(serverPlayer.blockPosition()); + history.ifPresent(hist -> { + ChunkPos currentRoomChunk = new ChunkPos(serverPlayer.blockPosition()); - MachineConnections connections = MachineConnections.get(serv); - if (connections == null) - return; + if(hist.hasHistory()) { + final IRoomHistoryItem prevArea = hist.pop(); + + DimensionalPosition spawnPoint = prevArea.getEntryLocation(); - DimensionalPosition spawnPoint = externalSpawn.get(); + ServerWorld w = spawnPoint.getWorld(serv).orElse(serv.overworld()); + Vector3d worldPos, entryRot; - Optional outsideWorld = spawnPoint.getWorld(serv); - outsideWorld.ifPresent(w -> { - Vector3d worldPos = spawnPoint.getPosition(); - Vector3d entryRot = spawnPoint.getRotation(); - serverPlayer.teleportTo(w, worldPos.x(), worldPos.y(), worldPos.z(), (float) entryRot.y, (float) entryRot.x); + if (serv.getLevel(spawnPoint.getDimension()) != null) { + worldPos = spawnPoint.getPosition(); + entryRot = spawnPoint.getRotation(); - removePlayerFromMachine(serverPlayer, currentMachine); + serverPlayer.teleportTo(w, worldPos.x(), worldPos.y(), worldPos.z(), (float) entryRot.y, (float) entryRot.x); + } else { + teleportPlayerToRespawnOrOverworld(serv, serverPlayer); + } + } else { + howDidYouGetThere(serverPlayer); + + teleportPlayerToRespawnOrOverworld(serv, serverPlayer); + } + + final Chunk chunk = serv.getLevel(Registration.COMPACT_DIMENSION) + .getChunk(currentRoomChunk.x, currentRoomChunk.z); + + MachinePlayersChangedPacket p = MachinePlayersChangedPacket.Builder.create(serv) + .forMachine(currentRoomChunk) + .forPlayer(serverPlayer) + .build(); + + NetworkHandler.MAIN_CHANNEL.send(CMPacketTargets.TRACKING_ROOM.with(() -> chunk), p); }); } + private static void howDidYouGetThere(@Nonnull ServerPlayerEntity serverPlayer) { + AdvancementTriggers.HOW_DID_YOU_GET_HERE.trigger(serverPlayer); + + serverPlayer.displayClientMessage( + TranslationUtil.message(Messages.HOW_DID_YOU_GET_HERE), + true + ); + } + + private static void teleportPlayerToRespawnOrOverworld(MinecraftServer serv, @Nonnull ServerPlayerEntity player) { + ServerWorld level = Optional.ofNullable(serv.getLevel(player.getRespawnDimension())).orElse(serv.overworld()); + Vector3d worldPos = LocationUtil.blockPosToVector(level.getSharedSpawnPos()); + + if (player.getRespawnPosition() != null) + worldPos = LocationUtil.blockPosToVector(player.getRespawnPosition()); + + player.teleportTo(level, worldPos.x(), worldPos.y(), worldPos.z(), 0, player.getRespawnAngle()); + } + public static void addPlayerToMachine(ServerPlayerEntity serverPlayer, BlockPos machinePos) { MinecraftServer serv = serverPlayer.getServer(); if (serv == null) @@ -194,12 +223,12 @@ public static void addPlayerToMachine(ServerPlayerEntity serverPlayer, BlockPos if (tile == null) return; - tile.getInternalChunkPos().ifPresent(mChunk -> { final Chunk chunk = serv.getLevel(Registration.COMPACT_DIMENSION) .getChunk(mChunk.x, mChunk.z); - playerData.addPlayer(serverPlayer, mChunk); + // TODO - Add player to machine data + // playerData.addPlayer(serverPlayer, mChunk); playerData.setDirty(); MachinePlayersChangedPacket p = MachinePlayersChangedPacket.Builder.create(serv) @@ -212,24 +241,4 @@ public static void addPlayerToMachine(ServerPlayerEntity serverPlayer, BlockPos }); } - public static void removePlayerFromMachine(ServerPlayerEntity serverPlayer, ChunkPos roomChunk) { - MinecraftServer serv = serverPlayer.getServer(); - - CompactMachinePlayerData playerData = CompactMachinePlayerData.get(serv); - if (playerData == null) - return; - - playerData.removePlayer(serverPlayer); - playerData.setDirty(); - - final Chunk chunk = serv.getLevel(Registration.COMPACT_DIMENSION) - .getChunk(roomChunk.x, roomChunk.z); - - MachinePlayersChangedPacket p = MachinePlayersChangedPacket.Builder.create(serv) - .forMachine(roomChunk) - .forPlayer(serverPlayer) - .build(); - - NetworkHandler.MAIN_CHANNEL.send(CMPacketTargets.TRACKING_ROOM.with(() -> chunk), p); - } } diff --git a/src/main/java/com/robotgryphon/compactmachines/util/TranslationUtil.java b/src/main/java/com/robotgryphon/compactmachines/util/TranslationUtil.java index 71e34bf6..55a949e1 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/TranslationUtil.java +++ b/src/main/java/com/robotgryphon/compactmachines/util/TranslationUtil.java @@ -29,4 +29,20 @@ public static TranslationTextComponent tooltip(ResourceLocation tooltip) { public static TranslationTextComponent tooltip(ResourceLocation tooltip, Object... params) { return new TranslationTextComponent(tooltipId(tooltip), params); } + + public static String advId(ResourceLocation tooltip) { + return Util.makeDescriptionId("advancement", tooltip); + } + + public static TranslationTextComponent advancement(ResourceLocation advancement) { + return new TranslationTextComponent(advId(advancement)); + } + + public static TranslationTextComponent advancementTitle(ResourceLocation advancement) { + return advancement(advancement); + } + + public static TranslationTextComponent advancementDesc(ResourceLocation advancement) { + return new TranslationTextComponent(Util.makeDescriptionId("advancement", advancement) + ".desc"); + } } diff --git a/src/main/resources/assets/compactmachines/lang/en_us.json b/src/main/resources/assets/compactmachines/lang/en_us.json index e3f80e17..e6acd8b2 100644 --- a/src/main/resources/assets/compactmachines/lang/en_us.json +++ b/src/main/resources/assets/compactmachines/lang/en_us.json @@ -53,5 +53,10 @@ "compactmachines.psd.pages.machines.title": "Compact Machines", "compactmachines.psd.pages.machines": "Compact Machines are the core mechanic of this mod. They allow you to build large rooms in a single block space connected to the outside world. They come in various sizes ranging from 3x3x3 to 13x13x13.\n\nYou can use Tunnels to connect the outside block faces with any of the inside walls to transport items, fluids etc.\n\nYou can enter a Compact Machine by right-clicking it with a Personal Shrinking Device. Please use JEI to look up crafting recipes.", - "compactmachines.errors.unknown_tunnel_type": "Unknown Tunnel Type (%s)" + "compactmachines.errors.unknown_tunnel_type": "Unknown Tunnel Type (%s)", + + "advancement.compactmachines.root": "Compact Machines", + "advancement.compactmachines.root.desc": "", + "advancement.compactmachines.how_did_you_get_here": "How Did You Get Here?!", + "advancement.compactmachines.how_did_you_get_here.desc": "Manage to trap yourself inside a machine room." } \ No newline at end of file diff --git a/src/main/resources/data/compactmachines/dimension/compact_world.json b/src/main/resources/data/compactmachines/dimension/compact_world.json index 5070cb65..e1c929b2 100644 --- a/src/main/resources/data/compactmachines/dimension/compact_world.json +++ b/src/main/resources/data/compactmachines/dimension/compact_world.json @@ -17,7 +17,7 @@ "generator": { "type": "minecraft:flat", "settings": { - "biome": "minecraft:the_void", + "biome": "minecraft:plains", "layers": [ { "block": "minecraft:air", diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java b/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java index 620db430..8728713f 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java +++ b/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java @@ -34,7 +34,7 @@ private CompactMachineConnectionGraph generateGraphWithSingleRoom() { private CompactMachineConnectionGraph generateGraphWithMultipleRooms(int numRooms) { CompactMachineConnectionGraph g = new CompactMachineConnectionGraph(); - for(int i = 0; i < numRooms; i++) { + for (int i = 0; i < numRooms; i++) { g.addMachine(i); ChunkPos chunk = MathUtil.getChunkForRoomIndex(i); g.addRoom(chunk); @@ -92,13 +92,12 @@ void canCreateGraphWithLinkedMachine() { } - @Test @DisplayName("Create Multiple Rooms (1:1)") void canCreateMultipleRoomsWithSingleLinkedMachine() { CompactMachineConnectionGraph graph = generateGraphWithMultipleRooms(10); - for(int roomIndex = 0; roomIndex < 10; roomIndex++) { + for (int roomIndex = 0; roomIndex < 10; roomIndex++) { final ChunkPos EXPECTED_CHUNK = MathUtil.getChunkForRoomIndex(roomIndex); verifySingleRoomValid(graph, roomIndex, EXPECTED_CHUNK); @@ -177,6 +176,29 @@ void canSerialize() { Assertions.assertEquals(0, connList.getInt(0)); }); } + + @Test + void simpleNestedMachines() { + /* + Overworld - Contains Machine 0, linked to Room 0 + CompactWorld - Contains Machine 1, linked to Room 1 (Inside Room 0) + */ + + CompactMachineConnectionGraph graph = new CompactMachineConnectionGraph(); + + graph.addMachine(0); + graph.addMachine(1); + + // Add two rooms + ChunkPos room0 = MathUtil.getChunkForRoomIndex(0); + ChunkPos room1 = MathUtil.getChunkForRoomIndex(1); + graph.addRoom(room0); + graph.addRoom(room1); + + graph.connectMachineToRoom(0, room0); + graph.connectMachineToRoom(1, room1); + + } // private void generateData(MutableGraph g, HashMap lookup) { // Random r = new Random(); // MachineExternalLocation[] values = MachineExternalLocation.values(); From 17f7bfd6b1e97434164171ec0f312a4215f9d9f9 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Thu, 12 Aug 2021 04:52:26 -0400 Subject: [PATCH 20/36] Prep for nightly builds and new workflows --- .github/workflows/ci-tests-nightly.yml | 91 ++++++++++++++++++++++++ .github/workflows/ci-tests.yml | 29 -------- .github/workflows/manual-gh-packages.yml | 3 +- .github/workflows/tagged-release.yml | 3 +- build.gradle | 26 +++++-- 5 files changed, 117 insertions(+), 35 deletions(-) create mode 100644 .github/workflows/ci-tests-nightly.yml delete mode 100644 .github/workflows/ci-tests.yml diff --git a/.github/workflows/ci-tests-nightly.yml b/.github/workflows/ci-tests-nightly.yml new file mode 100644 index 00000000..46f47c05 --- /dev/null +++ b/.github/workflows/ci-tests-nightly.yml @@ -0,0 +1,91 @@ +name: Gradle Tests and Nightly (CI) + +on: push + +jobs: + vars: + name: Get Variables + runs-on: ubuntu-20.04 + outputs: + release_type: ${{steps.cf_release_type.outputs.value }} + mod_version: ${{steps.mod_version.outputs.value }} + steps: + - name: Checkout + uses: actions/checkout@v2 + + - name: Release Type + id: cf_release_type + uses: christian-draeger/read-properties@1.0.1 + with: + path: './gradle.properties' + property: 'cf_release_type' + + - name: Mod Version + id: mod_version + uses: christian-draeger/read-properties@1.0.1 + with: + path: './gradle.properties' + property: 'mod_version' + + tests: + name: Gradle Tests + runs-on: ubuntu-20.04 + needs: [ vars ] + steps: + - name: Checkout + uses: actions/checkout@v2 + + - name: Set up JDK 8 + uses: actions/setup-java@v1 + with: + java-version: "8.0.282" + + - name: Cache Gradle packages + uses: actions/cache@v2 + with: + path: | + ~/.gradle/caches + ~/.gradle/wrapper + key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }} + restore-keys: ${{ runner.os }}-gradle- + + - name: Grant execute permission for gradlew + run: chmod +x gradlew + + - name: Test JAR with Gradle + run: ./gradlew test + env: + GITHUB_ACTOR: ${{ secrets.GITHUB_ACTOR }} + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + + nightly: + name: Publish Nightly + runs-on: ubuntu-20.04 + needs: [ vars, tests ] + steps: + - name: Checkout + uses: actions/checkout@v2 + + - name: Set up JDK 8 + uses: actions/setup-java@v1 + with: + java-version: "8.0.282" + + - name: Cache Gradle packages + uses: actions/cache@v2 + with: + path: | + ~/.gradle/caches + ~/.gradle/wrapper + key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }} + restore-keys: ${{ runner.os }}-gradle- + + - name: Grant execute permission for gradlew + run: chmod +x gradlew + + - name: Publish gradle nightly jar + run: ./gradlew publishNightlyMavenPublicationToGitHubPackagesRepository + env: + CM_RELEASE: false + GITHUB_ACTOR: ${{ secrets.GITHUB_ACTOR }} + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} \ No newline at end of file diff --git a/.github/workflows/ci-tests.yml b/.github/workflows/ci-tests.yml deleted file mode 100644 index 362bf96d..00000000 --- a/.github/workflows/ci-tests.yml +++ /dev/null @@ -1,29 +0,0 @@ -name: Gradle Tests (CI) - -on: push - -jobs: - jar: - name: Test with Gradle - runs-on: ubuntu-20.04 - steps: - - name: Checkout - uses: actions/checkout@v2 - - - name: Set up JDK 8 - uses: actions/setup-java@v1 - with: - java-version: "8.0.282" - - - name: Ensure fresh gradle install - # Remove some files from the Gradle cache, so they aren't cached by GitHub Actions. - # Restoring these files from a GitHub Actions cache might cause problems for future builds. - run: | - rm -rf ~/.gradle - - - name: Test JAR with Gradle - run: ./gradlew test --max-workers 1 - env: - GITHUB_ACTOR: ${{ secrets.GITHUB_ACTOR }} - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - diff --git a/.github/workflows/manual-gh-packages.yml b/.github/workflows/manual-gh-packages.yml index c04a3c33..f38fec4e 100644 --- a/.github/workflows/manual-gh-packages.yml +++ b/.github/workflows/manual-gh-packages.yml @@ -117,8 +117,9 @@ jobs: run: chmod +x gradlew - name: Publish JAR with Gradle - run: ./gradlew publish --max-workers 1 + run: ./gradlew publish -x test env: + CM_RELEASE: true GITHUB_ACTOR: ${{ secrets.GITHUB_ACTOR }} GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/tagged-release.yml b/.github/workflows/tagged-release.yml index a39b19eb..e9a35e3a 100644 --- a/.github/workflows/tagged-release.yml +++ b/.github/workflows/tagged-release.yml @@ -119,8 +119,9 @@ jobs: run: chmod +x gradlew - name: Publish package - run: ./gradlew publish --max-workers 1 + run: ./gradlew publish -x test env: + CM_RELEASE: true GITHUB_ACTOR: ${{ secrets.GITHUB_ACTOR }} GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/build.gradle b/build.gradle index 7f983699..f66807f5 100644 --- a/build.gradle +++ b/build.gradle @@ -6,7 +6,7 @@ buildscript { } dependencies { - classpath "net.minecraftforge.gradle:ForgeGradle:4.1.9" + classpath "net.minecraftforge.gradle:ForgeGradle:4.1.12" } } @@ -18,10 +18,16 @@ plugins { apply plugin: "net.minecraftforge.gradle" -version = "${mod_version}" -group = 'com.robotgryphon' // http://maven.apache.org/guides/mini/guide-naming-conventions.html +def gitCommitHash = 'git rev-parse --verify --short HEAD'.execute().text.trim() +def isRelease = (System.getenv("CM_RELEASE") ?: "false").equalsIgnoreCase("true") + +version = isRelease ? mod_version : "nightly-${gitCommitHash}" +group = 'com.robotgryphon' archivesBaseName = mod_id +println("Mod ID: ${mod_id}"); +println("Version: ${version}"); + sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = '1.8' // Need this here so eclipse task generates correctly. sourceSets { @@ -227,7 +233,7 @@ jar { "Specification-Vendor" : "", "Specification-Version" : "1", // We are version 1 of ourselves "Implementation-Title" : project.name, - "Implementation-Version" : "${archiveVersion}", + "Implementation-Version": isRelease ? archiveVersion : "nightly-${gitCommitHash}", "Implementation-Vendor" : "", "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ") ]) @@ -258,6 +264,18 @@ publishing { } } } + + nightlyMaven(MavenPublication) { + artifactId = mod_id + artifacts { + artifact(jar) { + group = "dev.compactmods.nightly" + } + artifact(apiJar) { + classifier = "api" + } + } + } } repositories { From 7d6ee17f17d20fe01d8ffb779c21e81d06872c25 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Thu, 12 Aug 2021 05:01:32 -0400 Subject: [PATCH 21/36] Root advancement should not be hidden, whoops --- .../compactmachines/datagen/AdvancementGenerator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/robotgryphon/compactmachines/datagen/AdvancementGenerator.java b/src/main/java/com/robotgryphon/compactmachines/datagen/AdvancementGenerator.java index 89f8c745..37b0f1f1 100644 --- a/src/main/java/com/robotgryphon/compactmachines/datagen/AdvancementGenerator.java +++ b/src/main/java/com/robotgryphon/compactmachines/datagen/AdvancementGenerator.java @@ -67,7 +67,7 @@ private void generateAdvancements(Consumer consumer) { .background(modLoc("textures/block/wall.png")) .item(new ItemStack(Registration.MACHINE_BLOCK_ITEM_NORMAL.get())) .id(Advancements.ROOT) - .toast(false).hidden(true).chat(false) + .toast(false).hidden(false).chat(false) .build()) .save(consumer, modLoc("root").toString()); From fb0bd93abfc384add91b4d04bcda0254dfc9397a Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Fri, 13 Aug 2021 12:06:31 -0400 Subject: [PATCH 22/36] Package migration to dev.compactmods.machines --- build.gradle | 6 +-- .../api/tunnels/redstone/IRedstoneTunnel.java | 4 -- .../data/graph/IGraphEdge.java | 4 -- .../data/player/IPlayerHistoryNode.java | 5 --- .../rooms/IRoomHistoryItem.java | 10 ----- .../machines}/CompactMachines.java | 21 +++------- .../advancement/AdvancementTriggers.java | 4 +- .../GenericAdvancementTriggerListener.java | 2 +- ...GenericAdvancementTriggerListenerList.java | 3 +- .../trigger/HowDidYouGetHereTrigger.java | 10 ++--- .../machines}/api/core/Advancements.java | 2 +- .../machines}/api/core/Constants.java | 2 +- .../machines}/api/core/Messages.java | 2 +- .../machines}/api/core/Tooltips.java | 4 +- .../machines}/api/tunnels/EnumTunnelSide.java | 2 +- .../machines}/api/tunnels/ICapableTunnel.java | 2 +- .../machines}/api/tunnels/IItemTunnel.java | 2 +- .../api/tunnels/ITunnelConnectionInfo.java | 4 +- .../api/tunnels/TunnelDefinition.java | 2 +- .../redstone/IRedstoneReaderTunnel.java | 9 +---- .../api/tunnels/redstone/IRedstoneTunnel.java | 4 ++ .../redstone/IRedstoneWriterTunnel.java | 8 +--- .../machines}/block/BlockCompactMachine.java | 32 ++++++++-------- .../block/tiles/CompactMachineTile.java | 26 ++++++------- .../block/tiles/MachineWhitelisting.txt | 0 .../machines}/block/tiles/TunnelWallTile.java | 24 ++++++------ .../block/walls/BreakableWallBlock.java | 2 +- .../block/walls/ProtectedWallBlock.java | 2 +- .../machines}/block/walls/SolidWallBlock.java | 6 +-- .../block/walls/TunnelWallBlock.java | 24 ++++++------ .../machines}/client/ClientEventHandler.java | 9 ++--- .../machines}/client/ClientTunnelHandler.java | 4 +- .../machines}/client/TunnelColors.java | 6 +-- .../machines}/client/TunnelItemColor.java | 6 +-- .../gui/PersonalShrinkingDeviceScreen.java | 6 +-- .../machines}/client/gui/guide/GuidePage.java | 9 ++--- .../client/gui/guide/GuideSection.java | 2 +- .../gui/widget/AbstractCMGuiWidget.java | 2 +- .../widget/ScrollableWrappedTextWidget.java | 5 +-- .../machine/MachinePlayerEventHandler.java | 8 ++-- .../compat/jei/CompactMachinesJeiPlugin.java | 6 +-- .../compat/theoneprobe/IProbeData.java | 2 +- .../theoneprobe/IProbeDataProvider.java | 2 +- .../compat/theoneprobe/ProbeData.java | 2 +- .../compat/theoneprobe/TheOneProbeCompat.java | 2 +- .../compat/theoneprobe/TheOneProbeMain.java | 2 +- .../theoneprobe/TheOneProbeProvider.java | 4 +- .../providers/CompactMachineProvider.java | 21 +++++----- .../theoneprobe/providers/TunnelProvider.java | 22 +++++------ .../machines}/config/CommonConfig.java | 10 +---- .../EnableVanillaRecipesConfigCondition.java | 4 +- .../machines}/config/ServerConfig.java | 4 +- .../core/EnumMachinePlayersBreakHandling.java | 2 +- .../machines}/core/ModBusEvents.java | 11 +++--- .../machines}/core/Registration.java | 37 +++++++++--------- .../machines}/core/ServerEventHandler.java | 4 +- .../machines}/data/codec/CodecExtensions.java | 2 +- .../data/codec/DoubleStreamExtensions.java | 2 +- .../data/codec/NbtListCollector.java | 2 +- .../graph/CompactMachineConnectionGraph.java | 5 +-- .../data/graph/CompactMachineNode.java | 4 +- .../data/graph/CompactMachineRoomNode.java | 2 +- .../machines}/data/graph/DefaultEdges.java | 4 +- .../machines/data/graph/IGraphEdge.java | 4 ++ .../data/graph/IMachineGraphNode.java | 2 +- .../machines}/data/graph/MachineLinkEdge.java | 2 +- .../data/persistent/CompactMachineData.java | 12 +++--- .../data/persistent/CompactRoomData.java | 18 ++++----- .../data/persistent/MachineConnections.java | 8 ++-- .../data/player/CompactMachinePlayerData.java | 16 ++------ .../data/player/IPlayerHistoryNode.java | 5 +++ .../data/player/PlayerMachineHistory.java | 4 +- .../machines}/data/player/theory.txt | 0 .../datagen/AdvancementGenerator.java | 15 +++----- .../machines}/datagen/BlockLootGenerator.java | 6 +-- .../machines}/datagen/DataGeneration.java | 4 +- .../machines}/datagen/RecipeGenerator.java | 7 ++-- .../machines}/datagen/StateGenerator.java | 10 ++--- .../datagen/TunnelWallStateGenerator.java | 11 ++---- .../machines}/item/ItemBlockMachine.java | 18 ++++----- .../machines}/item/ItemBlockWall.java | 8 ++-- .../item/ItemPersonalShrinkingDevice.java | 23 ++++------- .../machines}/item/TunnelItem.java | 23 +++++------ .../machines}/network/CMPacketTargets.java | 10 ++--- .../network/MachinePlayersChangedPacket.java | 14 +++---- .../machines}/network/NetworkHandler.java | 6 +-- .../machines}/network/TunnelAddedPacket.java | 4 +- .../machines}/reference/EnumMachineSize.java | 2 +- .../machines}/reference/GuiIds.java | 2 +- .../machines}/reference/Reference.java | 2 +- .../machines}/reference/Resources.java | 4 +- .../machines/rooms/IRoomHistoryItem.java | 10 +++++ .../rooms/capability/CMRoomHistory.java | 4 +- .../capability/CapabilityRoomHistory.java | 3 +- .../rooms/capability/IRoomHistory.java | 5 +-- .../PlayerRoomHistoryCapProvider.java | 2 +- .../rooms/capability/RoomCapEventHandler.java | 12 +----- .../teleportation/DimensionalPosition.java | 6 +-- .../TeleportationEventHandler.java | 13 +++---- .../tunnels/TunnelConnectionInfo.java | 10 ++--- .../machines}/tunnels/TunnelHelper.java | 19 ++++------ .../definitions/ItemTunnelDefinition.java | 16 ++++---- .../RedstoneInTunnelDefinition.java | 12 +++--- .../RedstoneOutTunnelDefinition.java | 8 ++-- .../util/CompactStructureGenerator.java | 6 +-- .../machines}/util/LocationUtil.java | 2 +- .../compactmods/machines}/util/MathUtil.java | 2 +- .../machines}/util/PlayerUtil.java | 38 +++++++++---------- .../machines}/util/TranslationUtil.java | 2 +- .../machines}/tests/GraphTests.java | 14 +++---- .../machines}/tests/MathTests.java | 4 +- .../machines}/tests/codec/CodecTests.java | 6 +-- .../tests/minecraft/ExampleTest.java | 2 +- .../tests/nbt/MachineExternalDataTests.java | 9 ++--- .../machines}/tests/util/FileHelper.java | 3 +- 115 files changed, 390 insertions(+), 499 deletions(-) delete mode 100644 src/main/java/com/robotgryphon/compactmachines/api/tunnels/redstone/IRedstoneTunnel.java delete mode 100644 src/main/java/com/robotgryphon/compactmachines/data/graph/IGraphEdge.java delete mode 100644 src/main/java/com/robotgryphon/compactmachines/data/player/IPlayerHistoryNode.java delete mode 100644 src/main/java/com/robotgryphon/compactmachines/rooms/IRoomHistoryItem.java rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/CompactMachines.java (63%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/advancement/AdvancementTriggers.java (64%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/advancement/GenericAdvancementTriggerListener.java (94%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/advancement/GenericAdvancementTriggerListenerList.java (91%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/advancement/trigger/HowDidYouGetHereTrigger.java (80%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/api/core/Advancements.java (85%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/api/core/Constants.java (65%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/api/core/Messages.java (93%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/api/core/Tooltips.java (88%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/api/tunnels/EnumTunnelSide.java (68%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/api/tunnels/ICapableTunnel.java (92%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/api/tunnels/IItemTunnel.java (51%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/api/tunnels/ITunnelConnectionInfo.java (86%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/api/tunnels/TunnelDefinition.java (90%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/api/tunnels/redstone/IRedstoneReaderTunnel.java (73%) create mode 100644 src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneTunnel.java rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/api/tunnels/redstone/IRedstoneWriterTunnel.java (50%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/block/BlockCompactMachine.java (92%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/block/tiles/CompactMachineTile.java (93%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/block/tiles/MachineWhitelisting.txt (100%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/block/tiles/TunnelWallTile.java (90%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/block/walls/BreakableWallBlock.java (80%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/block/walls/ProtectedWallBlock.java (96%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/block/walls/SolidWallBlock.java (79%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/block/walls/TunnelWallBlock.java (87%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/client/ClientEventHandler.java (80%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/client/ClientTunnelHandler.java (87%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/client/TunnelColors.java (87%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/client/TunnelItemColor.java (77%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/client/gui/PersonalShrinkingDeviceScreen.java (94%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/client/gui/guide/GuidePage.java (87%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/client/gui/guide/GuideSection.java (95%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/client/gui/widget/AbstractCMGuiWidget.java (92%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/client/gui/widget/ScrollableWrappedTextWidget.java (91%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/client/machine/MachinePlayerEventHandler.java (80%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/compat/jei/CompactMachinesJeiPlugin.java (79%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/compat/theoneprobe/IProbeData.java (79%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/compat/theoneprobe/IProbeDataProvider.java (80%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/compat/theoneprobe/ProbeData.java (91%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/compat/theoneprobe/TheOneProbeCompat.java (77%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/compat/theoneprobe/TheOneProbeMain.java (85%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/compat/theoneprobe/TheOneProbeProvider.java (89%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/compat/theoneprobe/providers/CompactMachineProvider.java (81%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/compat/theoneprobe/providers/TunnelProvider.java (87%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/config/CommonConfig.java (76%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/config/EnableVanillaRecipesConfigCondition.java (91%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/config/ServerConfig.java (93%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/core/EnumMachinePlayersBreakHandling.java (93%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/core/ModBusEvents.java (71%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/core/Registration.java (89%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/core/ServerEventHandler.java (83%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/codec/CodecExtensions.java (96%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/codec/DoubleStreamExtensions.java (97%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/codec/NbtListCollector.java (96%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/graph/CompactMachineConnectionGraph.java (96%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/graph/CompactMachineNode.java (90%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/graph/CompactMachineRoomNode.java (95%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/graph/DefaultEdges.java (56%) create mode 100644 src/main/java/dev/compactmods/machines/data/graph/IGraphEdge.java rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/graph/IMachineGraphNode.java (60%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/graph/MachineLinkEdge.java (51%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/persistent/CompactMachineData.java (91%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/persistent/CompactRoomData.java (93%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/persistent/MachineConnections.java (88%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/player/CompactMachinePlayerData.java (67%) create mode 100644 src/main/java/dev/compactmods/machines/data/player/IPlayerHistoryNode.java rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/player/PlayerMachineHistory.java (69%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/data/player/theory.txt (100%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/datagen/AdvancementGenerator.java (89%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/datagen/BlockLootGenerator.java (96%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/datagen/DataGeneration.java (92%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/datagen/RecipeGenerator.java (93%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/datagen/StateGenerator.java (75%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/datagen/TunnelWallStateGenerator.java (88%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/item/ItemBlockMachine.java (84%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/item/ItemBlockWall.java (84%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/item/ItemPersonalShrinkingDevice.java (79%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/item/TunnelItem.java (90%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/network/CMPacketTargets.java (85%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/network/MachinePlayersChangedPacket.java (91%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/network/NetworkHandler.java (90%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/network/TunnelAddedPacket.java (91%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/reference/EnumMachineSize.java (96%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/reference/GuiIds.java (59%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/reference/Reference.java (80%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/reference/Resources.java (73%) create mode 100644 src/main/java/dev/compactmods/machines/rooms/IRoomHistoryItem.java rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/rooms/capability/CMRoomHistory.java (83%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/rooms/capability/CapabilityRoomHistory.java (90%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/rooms/capability/IRoomHistory.java (53%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/rooms/capability/PlayerRoomHistoryCapProvider.java (94%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/rooms/capability/RoomCapEventHandler.java (64%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/teleportation/DimensionalPosition.java (95%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/teleportation/TeleportationEventHandler.java (87%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/tunnels/TunnelConnectionInfo.java (84%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/tunnels/TunnelHelper.java (90%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/tunnels/definitions/ItemTunnelDefinition.java (89%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/tunnels/definitions/RedstoneInTunnelDefinition.java (75%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/tunnels/definitions/RedstoneOutTunnelDefinition.java (60%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/util/CompactStructureGenerator.java (93%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/util/LocationUtil.java (87%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/util/MathUtil.java (97%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/util/PlayerUtil.java (87%) rename src/main/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/util/TranslationUtil.java (97%) rename src/test/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/tests/GraphTests.java (96%) rename src/test/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/tests/MathTests.java (93%) rename src/test/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/tests/codec/CodecTests.java (88%) rename src/test/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/tests/minecraft/ExampleTest.java (88%) rename src/test/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/tests/nbt/MachineExternalDataTests.java (86%) rename src/test/java/{com/robotgryphon/compactmachines => dev/compactmods/machines}/tests/util/FileHelper.java (94%) diff --git a/build.gradle b/build.gradle index f66807f5..638c144d 100644 --- a/build.gradle +++ b/build.gradle @@ -22,7 +22,7 @@ def gitCommitHash = 'git rev-parse --verify --short HEAD'.execute().text.trim() def isRelease = (System.getenv("CM_RELEASE") ?: "false").equalsIgnoreCase("true") version = isRelease ? mod_version : "nightly-${gitCommitHash}" -group = 'com.robotgryphon' +group = "dev.compactmods" archivesBaseName = mod_id println("Mod ID: ${mod_id}"); @@ -32,9 +32,7 @@ sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = co sourceSets { main { - resources { - srcDir 'src/generated/resources' - } + resources.srcDir "src/generated/resources" } test } diff --git a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/redstone/IRedstoneTunnel.java b/src/main/java/com/robotgryphon/compactmachines/api/tunnels/redstone/IRedstoneTunnel.java deleted file mode 100644 index cd7cd380..00000000 --- a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/redstone/IRedstoneTunnel.java +++ /dev/null @@ -1,4 +0,0 @@ -package com.robotgryphon.compactmachines.api.tunnels.redstone; - -public interface IRedstoneTunnel { -} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/IGraphEdge.java b/src/main/java/com/robotgryphon/compactmachines/data/graph/IGraphEdge.java deleted file mode 100644 index f2e60252..00000000 --- a/src/main/java/com/robotgryphon/compactmachines/data/graph/IGraphEdge.java +++ /dev/null @@ -1,4 +0,0 @@ -package com.robotgryphon.compactmachines.data.graph; - -public interface IGraphEdge { -} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/player/IPlayerHistoryNode.java b/src/main/java/com/robotgryphon/compactmachines/data/player/IPlayerHistoryNode.java deleted file mode 100644 index 721cad33..00000000 --- a/src/main/java/com/robotgryphon/compactmachines/data/player/IPlayerHistoryNode.java +++ /dev/null @@ -1,5 +0,0 @@ -package com.robotgryphon.compactmachines.data.player; - -public interface IPlayerHistoryNode { - -} diff --git a/src/main/java/com/robotgryphon/compactmachines/rooms/IRoomHistoryItem.java b/src/main/java/com/robotgryphon/compactmachines/rooms/IRoomHistoryItem.java deleted file mode 100644 index 5499a7e4..00000000 --- a/src/main/java/com/robotgryphon/compactmachines/rooms/IRoomHistoryItem.java +++ /dev/null @@ -1,10 +0,0 @@ -package com.robotgryphon.compactmachines.rooms; - -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; - -public interface IRoomHistoryItem { - - DimensionalPosition getEntryLocation(); - - int getMachine(); -} diff --git a/src/main/java/com/robotgryphon/compactmachines/CompactMachines.java b/src/main/java/dev/compactmods/machines/CompactMachines.java similarity index 63% rename from src/main/java/com/robotgryphon/compactmachines/CompactMachines.java rename to src/main/java/dev/compactmods/machines/CompactMachines.java index d3ddcc3d..9207f457 100644 --- a/src/main/java/com/robotgryphon/compactmachines/CompactMachines.java +++ b/src/main/java/dev/compactmods/machines/CompactMachines.java @@ -1,28 +1,17 @@ -package com.robotgryphon.compactmachines; +package dev.compactmods.machines; -import com.robotgryphon.compactmachines.compat.theoneprobe.TheOneProbeCompat; -import com.robotgryphon.compactmachines.config.CommonConfig; -import com.robotgryphon.compactmachines.config.EnableVanillaRecipesConfigCondition; -import com.robotgryphon.compactmachines.config.ServerConfig; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.network.NetworkHandler; -import net.minecraft.client.Minecraft; +import dev.compactmods.machines.config.CommonConfig; +import dev.compactmods.machines.config.EnableVanillaRecipesConfigCondition; +import dev.compactmods.machines.config.ServerConfig; +import dev.compactmods.machines.core.Registration; import net.minecraft.item.ItemGroup; import net.minecraft.item.ItemStack; -import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.common.crafting.CraftingHelper; import net.minecraftforge.event.TickEvent; -import net.minecraftforge.eventbus.api.IEventBus; import net.minecraftforge.eventbus.api.SubscribeEvent; -import net.minecraftforge.fml.ModList; import net.minecraftforge.fml.ModLoadingContext; import net.minecraftforge.fml.common.Mod; -import net.minecraftforge.fml.common.ObfuscationReflectionHelper; import net.minecraftforge.fml.config.ModConfig; -import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent; -import net.minecraftforge.fml.event.lifecycle.InterModEnqueueEvent; -import net.minecraftforge.fml.event.server.FMLServerStartingEvent; -import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; diff --git a/src/main/java/com/robotgryphon/compactmachines/advancement/AdvancementTriggers.java b/src/main/java/dev/compactmods/machines/advancement/AdvancementTriggers.java similarity index 64% rename from src/main/java/com/robotgryphon/compactmachines/advancement/AdvancementTriggers.java rename to src/main/java/dev/compactmods/machines/advancement/AdvancementTriggers.java index 1bf41ccb..dcb60909 100644 --- a/src/main/java/com/robotgryphon/compactmachines/advancement/AdvancementTriggers.java +++ b/src/main/java/dev/compactmods/machines/advancement/AdvancementTriggers.java @@ -1,6 +1,6 @@ -package com.robotgryphon.compactmachines.advancement; +package dev.compactmods.machines.advancement; -import com.robotgryphon.compactmachines.advancement.trigger.HowDidYouGetHereTrigger; +import dev.compactmods.machines.advancement.trigger.HowDidYouGetHereTrigger; import net.minecraft.advancements.CriteriaTriggers; public class AdvancementTriggers { diff --git a/src/main/java/com/robotgryphon/compactmachines/advancement/GenericAdvancementTriggerListener.java b/src/main/java/dev/compactmods/machines/advancement/GenericAdvancementTriggerListener.java similarity index 94% rename from src/main/java/com/robotgryphon/compactmachines/advancement/GenericAdvancementTriggerListener.java rename to src/main/java/dev/compactmods/machines/advancement/GenericAdvancementTriggerListener.java index 040b9c0c..9680727a 100644 --- a/src/main/java/com/robotgryphon/compactmachines/advancement/GenericAdvancementTriggerListener.java +++ b/src/main/java/dev/compactmods/machines/advancement/GenericAdvancementTriggerListener.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.advancement; +package dev.compactmods.machines.advancement; import java.util.Set; import com.google.common.collect.Sets; diff --git a/src/main/java/com/robotgryphon/compactmachines/advancement/GenericAdvancementTriggerListenerList.java b/src/main/java/dev/compactmods/machines/advancement/GenericAdvancementTriggerListenerList.java similarity index 91% rename from src/main/java/com/robotgryphon/compactmachines/advancement/GenericAdvancementTriggerListenerList.java rename to src/main/java/dev/compactmods/machines/advancement/GenericAdvancementTriggerListenerList.java index 8e1a2e0d..006fd488 100644 --- a/src/main/java/com/robotgryphon/compactmachines/advancement/GenericAdvancementTriggerListenerList.java +++ b/src/main/java/dev/compactmods/machines/advancement/GenericAdvancementTriggerListenerList.java @@ -1,9 +1,8 @@ -package com.robotgryphon.compactmachines.advancement; +package dev.compactmods.machines.advancement; import javax.annotation.Nullable; import java.util.Map; import com.google.common.collect.Maps; -import com.robotgryphon.compactmachines.advancement.trigger.HowDidYouGetHereTrigger; import net.minecraft.advancements.ICriterionInstance; import net.minecraft.advancements.ICriterionTrigger; import net.minecraft.advancements.PlayerAdvancements; diff --git a/src/main/java/com/robotgryphon/compactmachines/advancement/trigger/HowDidYouGetHereTrigger.java b/src/main/java/dev/compactmods/machines/advancement/trigger/HowDidYouGetHereTrigger.java similarity index 80% rename from src/main/java/com/robotgryphon/compactmachines/advancement/trigger/HowDidYouGetHereTrigger.java rename to src/main/java/dev/compactmods/machines/advancement/trigger/HowDidYouGetHereTrigger.java index c78b5545..934de959 100644 --- a/src/main/java/com/robotgryphon/compactmachines/advancement/trigger/HowDidYouGetHereTrigger.java +++ b/src/main/java/dev/compactmods/machines/advancement/trigger/HowDidYouGetHereTrigger.java @@ -1,9 +1,9 @@ -package com.robotgryphon.compactmachines.advancement.trigger; +package dev.compactmods.machines.advancement.trigger; import com.google.gson.JsonObject; -import com.robotgryphon.compactmachines.advancement.GenericAdvancementTriggerListener; -import com.robotgryphon.compactmachines.advancement.GenericAdvancementTriggerListenerList; -import com.robotgryphon.compactmachines.api.core.Advancements; +import dev.compactmods.machines.advancement.GenericAdvancementTriggerListener; +import dev.compactmods.machines.advancement.GenericAdvancementTriggerListenerList; +import dev.compactmods.machines.api.core.Advancements; import net.minecraft.advancements.ICriterionTrigger; import net.minecraft.advancements.PlayerAdvancements; import net.minecraft.advancements.criterion.CriterionInstance; @@ -14,7 +14,7 @@ public class HowDidYouGetHereTrigger implements ICriterionTrigger { - private final GenericAdvancementTriggerListenerList listeners = new GenericAdvancementTriggerListenerList<>(); + private final GenericAdvancementTriggerListenerList listeners = new GenericAdvancementTriggerListenerList<>(); @Override public ResourceLocation getId() { diff --git a/src/main/java/com/robotgryphon/compactmachines/api/core/Advancements.java b/src/main/java/dev/compactmods/machines/api/core/Advancements.java similarity index 85% rename from src/main/java/com/robotgryphon/compactmachines/api/core/Advancements.java rename to src/main/java/dev/compactmods/machines/api/core/Advancements.java index 343c0854..7722b1ad 100644 --- a/src/main/java/com/robotgryphon/compactmachines/api/core/Advancements.java +++ b/src/main/java/dev/compactmods/machines/api/core/Advancements.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.api.core; +package dev.compactmods.machines.api.core; import net.minecraft.util.ResourceLocation; diff --git a/src/main/java/com/robotgryphon/compactmachines/api/core/Constants.java b/src/main/java/dev/compactmods/machines/api/core/Constants.java similarity index 65% rename from src/main/java/com/robotgryphon/compactmachines/api/core/Constants.java rename to src/main/java/dev/compactmods/machines/api/core/Constants.java index 4dd30313..954065b4 100644 --- a/src/main/java/com/robotgryphon/compactmachines/api/core/Constants.java +++ b/src/main/java/dev/compactmods/machines/api/core/Constants.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.api.core; +package dev.compactmods.machines.api.core; public abstract class Constants { public static final String MOD_ID = "compactmachines"; diff --git a/src/main/java/com/robotgryphon/compactmachines/api/core/Messages.java b/src/main/java/dev/compactmods/machines/api/core/Messages.java similarity index 93% rename from src/main/java/com/robotgryphon/compactmachines/api/core/Messages.java rename to src/main/java/dev/compactmods/machines/api/core/Messages.java index 0ed765f7..070b6b37 100644 --- a/src/main/java/com/robotgryphon/compactmachines/api/core/Messages.java +++ b/src/main/java/dev/compactmods/machines/api/core/Messages.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.api.core; +package dev.compactmods.machines.api.core; import net.minecraft.util.ResourceLocation; diff --git a/src/main/java/com/robotgryphon/compactmachines/api/core/Tooltips.java b/src/main/java/dev/compactmods/machines/api/core/Tooltips.java similarity index 88% rename from src/main/java/com/robotgryphon/compactmachines/api/core/Tooltips.java rename to src/main/java/dev/compactmods/machines/api/core/Tooltips.java index fd0284ba..540e0792 100644 --- a/src/main/java/com/robotgryphon/compactmachines/api/core/Tooltips.java +++ b/src/main/java/dev/compactmods/machines/api/core/Tooltips.java @@ -1,8 +1,8 @@ -package com.robotgryphon.compactmachines.api.core; +package dev.compactmods.machines.api.core; import net.minecraft.util.ResourceLocation; -import static com.robotgryphon.compactmachines.api.core.Constants.MOD_ID; +import static dev.compactmods.machines.api.core.Constants.MOD_ID; public abstract class Tooltips { diff --git a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/EnumTunnelSide.java b/src/main/java/dev/compactmods/machines/api/tunnels/EnumTunnelSide.java similarity index 68% rename from src/main/java/com/robotgryphon/compactmachines/api/tunnels/EnumTunnelSide.java rename to src/main/java/dev/compactmods/machines/api/tunnels/EnumTunnelSide.java index 75c552e4..8b9fa288 100644 --- a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/EnumTunnelSide.java +++ b/src/main/java/dev/compactmods/machines/api/tunnels/EnumTunnelSide.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.api.tunnels; +package dev.compactmods.machines.api.tunnels; /** * Represents the side of a tunnel (inside or outside). diff --git a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/ICapableTunnel.java b/src/main/java/dev/compactmods/machines/api/tunnels/ICapableTunnel.java similarity index 92% rename from src/main/java/com/robotgryphon/compactmachines/api/tunnels/ICapableTunnel.java rename to src/main/java/dev/compactmods/machines/api/tunnels/ICapableTunnel.java index 1f4cfba9..cfda3d11 100644 --- a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/ICapableTunnel.java +++ b/src/main/java/dev/compactmods/machines/api/tunnels/ICapableTunnel.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.api.tunnels; +package dev.compactmods.machines.api.tunnels; import net.minecraft.util.Direction; import net.minecraft.util.math.BlockPos; diff --git a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/IItemTunnel.java b/src/main/java/dev/compactmods/machines/api/tunnels/IItemTunnel.java similarity index 51% rename from src/main/java/com/robotgryphon/compactmachines/api/tunnels/IItemTunnel.java rename to src/main/java/dev/compactmods/machines/api/tunnels/IItemTunnel.java index 85de97fc..7473d313 100644 --- a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/IItemTunnel.java +++ b/src/main/java/dev/compactmods/machines/api/tunnels/IItemTunnel.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.api.tunnels; +package dev.compactmods.machines.api.tunnels; public interface IItemTunnel extends ICapableTunnel { diff --git a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/ITunnelConnectionInfo.java b/src/main/java/dev/compactmods/machines/api/tunnels/ITunnelConnectionInfo.java similarity index 86% rename from src/main/java/com/robotgryphon/compactmachines/api/tunnels/ITunnelConnectionInfo.java rename to src/main/java/dev/compactmods/machines/api/tunnels/ITunnelConnectionInfo.java index 69f25787..dde6367c 100644 --- a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/ITunnelConnectionInfo.java +++ b/src/main/java/dev/compactmods/machines/api/tunnels/ITunnelConnectionInfo.java @@ -1,6 +1,6 @@ -package com.robotgryphon.compactmachines.api.tunnels; +package dev.compactmods.machines.api.tunnels; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import dev.compactmods.machines.teleportation.DimensionalPosition; import net.minecraft.block.BlockState; import net.minecraft.util.Direction; import net.minecraft.world.IWorldReader; diff --git a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/TunnelDefinition.java b/src/main/java/dev/compactmods/machines/api/tunnels/TunnelDefinition.java similarity index 90% rename from src/main/java/com/robotgryphon/compactmachines/api/tunnels/TunnelDefinition.java rename to src/main/java/dev/compactmods/machines/api/tunnels/TunnelDefinition.java index f67ec525..ee4729a6 100644 --- a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/TunnelDefinition.java +++ b/src/main/java/dev/compactmods/machines/api/tunnels/TunnelDefinition.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.api.tunnels; +package dev.compactmods.machines.api.tunnels; import net.minecraftforge.registries.ForgeRegistryEntry; diff --git a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/redstone/IRedstoneReaderTunnel.java b/src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneReaderTunnel.java similarity index 73% rename from src/main/java/com/robotgryphon/compactmachines/api/tunnels/redstone/IRedstoneReaderTunnel.java rename to src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneReaderTunnel.java index 3576deaf..2a263c4c 100644 --- a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/redstone/IRedstoneReaderTunnel.java +++ b/src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneReaderTunnel.java @@ -1,11 +1,6 @@ -package com.robotgryphon.compactmachines.api.tunnels.redstone; +package dev.compactmods.machines.api.tunnels.redstone; -import com.robotgryphon.compactmachines.api.tunnels.ITunnelConnectionInfo; -import net.minecraft.block.BlockState; -import net.minecraft.server.MinecraftServer; -import net.minecraft.util.Direction; -import net.minecraft.util.math.BlockPos; -import net.minecraft.world.IBlockReader; +import dev.compactmods.machines.api.tunnels.ITunnelConnectionInfo; /** * A redstone reader reads a redstone value from outside the machine (from a given side). diff --git a/src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneTunnel.java b/src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneTunnel.java new file mode 100644 index 00000000..bfd4a713 --- /dev/null +++ b/src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneTunnel.java @@ -0,0 +1,4 @@ +package dev.compactmods.machines.api.tunnels.redstone; + +public interface IRedstoneTunnel { +} diff --git a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/redstone/IRedstoneWriterTunnel.java b/src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneWriterTunnel.java similarity index 50% rename from src/main/java/com/robotgryphon/compactmachines/api/tunnels/redstone/IRedstoneWriterTunnel.java rename to src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneWriterTunnel.java index fdff30fd..32afc54d 100644 --- a/src/main/java/com/robotgryphon/compactmachines/api/tunnels/redstone/IRedstoneWriterTunnel.java +++ b/src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneWriterTunnel.java @@ -1,10 +1,6 @@ -package com.robotgryphon.compactmachines.api.tunnels.redstone; +package dev.compactmods.machines.api.tunnels.redstone; -import com.robotgryphon.compactmachines.api.tunnels.ITunnelConnectionInfo; -import net.minecraft.block.BlockState; -import net.minecraft.util.Direction; -import net.minecraft.util.math.BlockPos; -import net.minecraft.world.IBlockReader; +import dev.compactmods.machines.api.tunnels.ITunnelConnectionInfo; /** * A redstone writer sends a redstone value from inside the machine (redstone connected to a tunnel). diff --git a/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java b/src/main/java/dev/compactmods/machines/block/BlockCompactMachine.java similarity index 92% rename from src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java rename to src/main/java/dev/compactmods/machines/block/BlockCompactMachine.java index 5c824382..44a821d9 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/BlockCompactMachine.java +++ b/src/main/java/dev/compactmods/machines/block/BlockCompactMachine.java @@ -1,19 +1,19 @@ -package com.robotgryphon.compactmachines.block; - -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.api.tunnels.ITunnelConnectionInfo; -import com.robotgryphon.compactmachines.api.tunnels.redstone.IRedstoneReaderTunnel; -import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; -import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; -import com.robotgryphon.compactmachines.compat.theoneprobe.IProbeData; -import com.robotgryphon.compactmachines.compat.theoneprobe.IProbeDataProvider; -import com.robotgryphon.compactmachines.compat.theoneprobe.providers.CompactMachineProvider; -import com.robotgryphon.compactmachines.config.ServerConfig; -import com.robotgryphon.compactmachines.core.EnumMachinePlayersBreakHandling; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.reference.EnumMachineSize; -import com.robotgryphon.compactmachines.tunnels.TunnelHelper; -import com.robotgryphon.compactmachines.util.PlayerUtil; +package dev.compactmods.machines.block; + +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.api.tunnels.ITunnelConnectionInfo; +import dev.compactmods.machines.api.tunnels.redstone.IRedstoneReaderTunnel; +import dev.compactmods.machines.block.tiles.CompactMachineTile; +import dev.compactmods.machines.block.tiles.TunnelWallTile; +import dev.compactmods.machines.compat.theoneprobe.IProbeData; +import dev.compactmods.machines.compat.theoneprobe.IProbeDataProvider; +import dev.compactmods.machines.compat.theoneprobe.providers.CompactMachineProvider; +import dev.compactmods.machines.config.ServerConfig; +import dev.compactmods.machines.core.EnumMachinePlayersBreakHandling; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.reference.EnumMachineSize; +import dev.compactmods.machines.tunnels.TunnelHelper; +import dev.compactmods.machines.util.PlayerUtil; import net.minecraft.block.AbstractBlock; import net.minecraft.block.Block; import net.minecraft.block.BlockState; diff --git a/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java b/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java similarity index 93% rename from src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java rename to src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java index 12610dfb..269efd0f 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java +++ b/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java @@ -1,16 +1,16 @@ -package com.robotgryphon.compactmachines.block.tiles; - -import com.robotgryphon.compactmachines.config.ServerConfig; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.persistent.CompactRoomData; -import com.robotgryphon.compactmachines.data.persistent.MachineConnections; -import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; -import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; -import com.robotgryphon.compactmachines.reference.Reference; -import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; -import com.robotgryphon.compactmachines.tunnels.TunnelHelper; -import com.robotgryphon.compactmachines.api.tunnels.ICapableTunnel; +package dev.compactmods.machines.block.tiles; + +import dev.compactmods.machines.config.ServerConfig; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.data.persistent.CompactRoomData; +import dev.compactmods.machines.data.persistent.MachineConnections; +import dev.compactmods.machines.data.player.CompactMachinePlayerData; +import dev.compactmods.machines.data.persistent.CompactMachineData; +import dev.compactmods.machines.reference.Reference; +import dev.compactmods.machines.api.tunnels.TunnelDefinition; +import dev.compactmods.machines.teleportation.DimensionalPosition; +import dev.compactmods.machines.tunnels.TunnelHelper; +import dev.compactmods.machines.api.tunnels.ICapableTunnel; import net.minecraft.block.BlockState; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.ListNBT; diff --git a/src/main/java/com/robotgryphon/compactmachines/block/tiles/MachineWhitelisting.txt b/src/main/java/dev/compactmods/machines/block/tiles/MachineWhitelisting.txt similarity index 100% rename from src/main/java/com/robotgryphon/compactmachines/block/tiles/MachineWhitelisting.txt rename to src/main/java/dev/compactmods/machines/block/tiles/MachineWhitelisting.txt diff --git a/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java b/src/main/java/dev/compactmods/machines/block/tiles/TunnelWallTile.java similarity index 90% rename from src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java rename to src/main/java/dev/compactmods/machines/block/tiles/TunnelWallTile.java index 22f950fc..12bd03fc 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java +++ b/src/main/java/dev/compactmods/machines/block/tiles/TunnelWallTile.java @@ -1,15 +1,15 @@ -package com.robotgryphon.compactmachines.block.tiles; - -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.api.tunnels.ICapableTunnel; -import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; -import com.robotgryphon.compactmachines.block.walls.TunnelWallBlock; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; -import com.robotgryphon.compactmachines.data.persistent.MachineConnections; -import com.robotgryphon.compactmachines.network.NetworkHandler; -import com.robotgryphon.compactmachines.network.TunnelAddedPacket; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +package dev.compactmods.machines.block.tiles; + +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.api.tunnels.ICapableTunnel; +import dev.compactmods.machines.api.tunnels.TunnelDefinition; +import dev.compactmods.machines.block.walls.TunnelWallBlock; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.data.persistent.CompactMachineData; +import dev.compactmods.machines.data.persistent.MachineConnections; +import dev.compactmods.machines.network.NetworkHandler; +import dev.compactmods.machines.network.TunnelAddedPacket; +import dev.compactmods.machines.teleportation.DimensionalPosition; import net.minecraft.block.BlockState; import net.minecraft.nbt.CompoundNBT; import net.minecraft.server.MinecraftServer; diff --git a/src/main/java/com/robotgryphon/compactmachines/block/walls/BreakableWallBlock.java b/src/main/java/dev/compactmods/machines/block/walls/BreakableWallBlock.java similarity index 80% rename from src/main/java/com/robotgryphon/compactmachines/block/walls/BreakableWallBlock.java rename to src/main/java/dev/compactmods/machines/block/walls/BreakableWallBlock.java index 3f2564a3..a6789f7a 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/walls/BreakableWallBlock.java +++ b/src/main/java/dev/compactmods/machines/block/walls/BreakableWallBlock.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.block.walls; +package dev.compactmods.machines.block.walls; import net.minecraft.block.Block; diff --git a/src/main/java/com/robotgryphon/compactmachines/block/walls/ProtectedWallBlock.java b/src/main/java/dev/compactmods/machines/block/walls/ProtectedWallBlock.java similarity index 96% rename from src/main/java/com/robotgryphon/compactmachines/block/walls/ProtectedWallBlock.java rename to src/main/java/dev/compactmods/machines/block/walls/ProtectedWallBlock.java index ed252e60..50300d42 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/walls/ProtectedWallBlock.java +++ b/src/main/java/dev/compactmods/machines/block/walls/ProtectedWallBlock.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.block.walls; +package dev.compactmods.machines.block.walls; import net.minecraft.block.Block; import net.minecraft.block.BlockState; diff --git a/src/main/java/com/robotgryphon/compactmachines/block/walls/SolidWallBlock.java b/src/main/java/dev/compactmods/machines/block/walls/SolidWallBlock.java similarity index 79% rename from src/main/java/com/robotgryphon/compactmachines/block/walls/SolidWallBlock.java rename to src/main/java/dev/compactmods/machines/block/walls/SolidWallBlock.java index 5101b500..34206517 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/walls/SolidWallBlock.java +++ b/src/main/java/dev/compactmods/machines/block/walls/SolidWallBlock.java @@ -1,6 +1,6 @@ -package com.robotgryphon.compactmachines.block.walls; +package dev.compactmods.machines.block.walls; -import com.robotgryphon.compactmachines.config.ServerConfig; +import dev.compactmods.machines.config.ServerConfig; import net.minecraft.block.BlockState; import net.minecraft.entity.EntitySpawnPlacementRegistry; import net.minecraft.entity.EntityType; @@ -9,8 +9,6 @@ import javax.annotation.Nullable; -import net.minecraft.block.AbstractBlock.Properties; - public class SolidWallBlock extends ProtectedWallBlock { public SolidWallBlock(Properties props) { super(props); diff --git a/src/main/java/com/robotgryphon/compactmachines/block/walls/TunnelWallBlock.java b/src/main/java/dev/compactmods/machines/block/walls/TunnelWallBlock.java similarity index 87% rename from src/main/java/com/robotgryphon/compactmachines/block/walls/TunnelWallBlock.java rename to src/main/java/dev/compactmods/machines/block/walls/TunnelWallBlock.java index e886adb0..cedd9f2f 100644 --- a/src/main/java/com/robotgryphon/compactmachines/block/walls/TunnelWallBlock.java +++ b/src/main/java/dev/compactmods/machines/block/walls/TunnelWallBlock.java @@ -1,14 +1,14 @@ -package com.robotgryphon.compactmachines.block.walls; - -import com.robotgryphon.compactmachines.api.tunnels.ITunnelConnectionInfo; -import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; -import com.robotgryphon.compactmachines.compat.theoneprobe.IProbeData; -import com.robotgryphon.compactmachines.compat.theoneprobe.IProbeDataProvider; -import com.robotgryphon.compactmachines.compat.theoneprobe.providers.TunnelProvider; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; -import com.robotgryphon.compactmachines.tunnels.TunnelHelper; -import com.robotgryphon.compactmachines.api.tunnels.redstone.IRedstoneReaderTunnel; +package dev.compactmods.machines.block.walls; + +import dev.compactmods.machines.api.tunnels.ITunnelConnectionInfo; +import dev.compactmods.machines.block.tiles.TunnelWallTile; +import dev.compactmods.machines.compat.theoneprobe.IProbeData; +import dev.compactmods.machines.compat.theoneprobe.IProbeDataProvider; +import dev.compactmods.machines.compat.theoneprobe.providers.TunnelProvider; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.api.tunnels.TunnelDefinition; +import dev.compactmods.machines.tunnels.TunnelHelper; +import dev.compactmods.machines.api.tunnels.redstone.IRedstoneReaderTunnel; import net.minecraft.block.Block; import net.minecraft.block.BlockState; import net.minecraft.entity.item.ItemEntity; @@ -30,8 +30,6 @@ import javax.annotation.Nullable; import java.util.Optional; -import net.minecraft.block.AbstractBlock.Properties; - public class TunnelWallBlock extends ProtectedWallBlock implements IProbeDataProvider { public static DirectionProperty TUNNEL_SIDE = DirectionProperty.create("tunnel_side", Direction.values()); public static DirectionProperty CONNECTED_SIDE = DirectionProperty.create("connected_side", Direction.values()); diff --git a/src/main/java/com/robotgryphon/compactmachines/client/ClientEventHandler.java b/src/main/java/dev/compactmods/machines/client/ClientEventHandler.java similarity index 80% rename from src/main/java/com/robotgryphon/compactmachines/client/ClientEventHandler.java rename to src/main/java/dev/compactmods/machines/client/ClientEventHandler.java index fad3a3ad..81a7b054 100644 --- a/src/main/java/com/robotgryphon/compactmachines/client/ClientEventHandler.java +++ b/src/main/java/dev/compactmods/machines/client/ClientEventHandler.java @@ -1,8 +1,7 @@ -package com.robotgryphon.compactmachines.client; +package dev.compactmods.machines.client; -import java.util.stream.Stream; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.core.Registration; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.core.Registration; import net.minecraft.client.renderer.RenderType; import net.minecraft.client.renderer.RenderTypeLookup; import net.minecraftforge.api.distmarker.Dist; @@ -28,7 +27,5 @@ public static void onBlockColors(final ColorHandlerEvent.Block colors) { public static void onClientSetup(final FMLClientSetupEvent client) { RenderType cutout = RenderType.cutoutMipped(); RenderTypeLookup.setRenderLayer(Registration.BLOCK_TUNNEL_WALL.get(), cutout); - - Stream.of(new int[] {}).map(Object::toString).toArray(String[]::new); } } diff --git a/src/main/java/com/robotgryphon/compactmachines/client/ClientTunnelHandler.java b/src/main/java/dev/compactmods/machines/client/ClientTunnelHandler.java similarity index 87% rename from src/main/java/com/robotgryphon/compactmachines/client/ClientTunnelHandler.java rename to src/main/java/dev/compactmods/machines/client/ClientTunnelHandler.java index ae4169f4..c855731b 100644 --- a/src/main/java/com/robotgryphon/compactmachines/client/ClientTunnelHandler.java +++ b/src/main/java/dev/compactmods/machines/client/ClientTunnelHandler.java @@ -1,6 +1,6 @@ -package com.robotgryphon.compactmachines.client; +package dev.compactmods.machines.client; -import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; +import dev.compactmods.machines.block.tiles.TunnelWallTile; import net.minecraft.block.BlockState; import net.minecraft.client.Minecraft; import net.minecraft.client.world.ClientWorld; diff --git a/src/main/java/com/robotgryphon/compactmachines/client/TunnelColors.java b/src/main/java/dev/compactmods/machines/client/TunnelColors.java similarity index 87% rename from src/main/java/com/robotgryphon/compactmachines/client/TunnelColors.java rename to src/main/java/dev/compactmods/machines/client/TunnelColors.java index e339f50b..1042febd 100644 --- a/src/main/java/com/robotgryphon/compactmachines/client/TunnelColors.java +++ b/src/main/java/dev/compactmods/machines/client/TunnelColors.java @@ -1,7 +1,7 @@ -package com.robotgryphon.compactmachines.client; +package dev.compactmods.machines.client; -import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; -import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; +import dev.compactmods.machines.block.tiles.TunnelWallTile; +import dev.compactmods.machines.api.tunnels.TunnelDefinition; import net.minecraft.block.BlockState; import net.minecraft.client.renderer.color.IBlockColor; import net.minecraft.tileentity.TileEntity; diff --git a/src/main/java/com/robotgryphon/compactmachines/client/TunnelItemColor.java b/src/main/java/dev/compactmods/machines/client/TunnelItemColor.java similarity index 77% rename from src/main/java/com/robotgryphon/compactmachines/client/TunnelItemColor.java rename to src/main/java/dev/compactmods/machines/client/TunnelItemColor.java index 84db4885..6239d604 100644 --- a/src/main/java/com/robotgryphon/compactmachines/client/TunnelItemColor.java +++ b/src/main/java/dev/compactmods/machines/client/TunnelItemColor.java @@ -1,7 +1,7 @@ -package com.robotgryphon.compactmachines.client; +package dev.compactmods.machines.client; -import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; -import com.robotgryphon.compactmachines.item.TunnelItem; +import dev.compactmods.machines.api.tunnels.TunnelDefinition; +import dev.compactmods.machines.item.TunnelItem; import net.minecraft.client.renderer.color.IItemColor; import net.minecraft.item.ItemStack; diff --git a/src/main/java/com/robotgryphon/compactmachines/client/gui/PersonalShrinkingDeviceScreen.java b/src/main/java/dev/compactmods/machines/client/gui/PersonalShrinkingDeviceScreen.java similarity index 94% rename from src/main/java/com/robotgryphon/compactmachines/client/gui/PersonalShrinkingDeviceScreen.java rename to src/main/java/dev/compactmods/machines/client/gui/PersonalShrinkingDeviceScreen.java index 3124b660..593c96c2 100644 --- a/src/main/java/com/robotgryphon/compactmachines/client/gui/PersonalShrinkingDeviceScreen.java +++ b/src/main/java/dev/compactmods/machines/client/gui/PersonalShrinkingDeviceScreen.java @@ -1,9 +1,9 @@ -package com.robotgryphon.compactmachines.client.gui; +package dev.compactmods.machines.client.gui; import com.mojang.blaze3d.matrix.MatrixStack; import com.mojang.blaze3d.systems.RenderSystem; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.client.gui.guide.GuideSection; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.client.gui.guide.GuideSection; import net.minecraft.client.Minecraft; import net.minecraft.client.gui.screen.Screen; import net.minecraft.util.ResourceLocation; diff --git a/src/main/java/com/robotgryphon/compactmachines/client/gui/guide/GuidePage.java b/src/main/java/dev/compactmods/machines/client/gui/guide/GuidePage.java similarity index 87% rename from src/main/java/com/robotgryphon/compactmachines/client/gui/guide/GuidePage.java rename to src/main/java/dev/compactmods/machines/client/gui/guide/GuidePage.java index 87cc7ba5..32835a05 100644 --- a/src/main/java/com/robotgryphon/compactmachines/client/gui/guide/GuidePage.java +++ b/src/main/java/dev/compactmods/machines/client/gui/guide/GuidePage.java @@ -1,9 +1,9 @@ -package com.robotgryphon.compactmachines.client.gui.guide; +package dev.compactmods.machines.client.gui.guide; import com.mojang.blaze3d.matrix.MatrixStack; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.client.gui.widget.AbstractCMGuiWidget; -import com.robotgryphon.compactmachines.client.gui.widget.ScrollableWrappedTextWidget; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.client.gui.widget.AbstractCMGuiWidget; +import dev.compactmods.machines.client.gui.widget.ScrollableWrappedTextWidget; import net.minecraft.client.Minecraft; import net.minecraft.client.gui.AbstractGui; import net.minecraft.client.gui.FontRenderer; @@ -11,7 +11,6 @@ import net.minecraft.client.gui.IRenderable; import net.minecraft.util.text.TextFormatting; import net.minecraft.util.text.TranslationTextComponent; -import net.minecraftforge.common.util.Constants; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/com/robotgryphon/compactmachines/client/gui/guide/GuideSection.java b/src/main/java/dev/compactmods/machines/client/gui/guide/GuideSection.java similarity index 95% rename from src/main/java/com/robotgryphon/compactmachines/client/gui/guide/GuideSection.java rename to src/main/java/dev/compactmods/machines/client/gui/guide/GuideSection.java index 489fb100..0fd33062 100644 --- a/src/main/java/com/robotgryphon/compactmachines/client/gui/guide/GuideSection.java +++ b/src/main/java/dev/compactmods/machines/client/gui/guide/GuideSection.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.client.gui.guide; +package dev.compactmods.machines.client.gui.guide; import com.mojang.blaze3d.matrix.MatrixStack; import net.minecraft.client.gui.IGuiEventListener; diff --git a/src/main/java/com/robotgryphon/compactmachines/client/gui/widget/AbstractCMGuiWidget.java b/src/main/java/dev/compactmods/machines/client/gui/widget/AbstractCMGuiWidget.java similarity index 92% rename from src/main/java/com/robotgryphon/compactmachines/client/gui/widget/AbstractCMGuiWidget.java rename to src/main/java/dev/compactmods/machines/client/gui/widget/AbstractCMGuiWidget.java index 644e83a4..d9fc6451 100644 --- a/src/main/java/com/robotgryphon/compactmachines/client/gui/widget/AbstractCMGuiWidget.java +++ b/src/main/java/dev/compactmods/machines/client/gui/widget/AbstractCMGuiWidget.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.client.gui.widget; +package dev.compactmods.machines.client.gui.widget; import com.mojang.blaze3d.matrix.MatrixStack; import net.minecraft.client.gui.IGuiEventListener; diff --git a/src/main/java/com/robotgryphon/compactmachines/client/gui/widget/ScrollableWrappedTextWidget.java b/src/main/java/dev/compactmods/machines/client/gui/widget/ScrollableWrappedTextWidget.java similarity index 91% rename from src/main/java/com/robotgryphon/compactmachines/client/gui/widget/ScrollableWrappedTextWidget.java rename to src/main/java/dev/compactmods/machines/client/gui/widget/ScrollableWrappedTextWidget.java index 6a674868..15979fe3 100644 --- a/src/main/java/com/robotgryphon/compactmachines/client/gui/widget/ScrollableWrappedTextWidget.java +++ b/src/main/java/dev/compactmods/machines/client/gui/widget/ScrollableWrappedTextWidget.java @@ -1,15 +1,12 @@ -package com.robotgryphon.compactmachines.client.gui.widget; +package dev.compactmods.machines.client.gui.widget; import com.mojang.blaze3d.matrix.MatrixStack; import net.minecraft.client.Minecraft; -import net.minecraft.client.gui.AbstractGui; import net.minecraft.client.gui.FontRenderer; import net.minecraft.client.resources.I18n; import net.minecraft.util.IReorderingProcessor; import net.minecraft.util.math.MathHelper; import net.minecraft.util.text.StringTextComponent; -import net.minecraft.util.text.TextFormatting; -import net.minecraft.util.text.TranslationTextComponent; import java.util.List; diff --git a/src/main/java/com/robotgryphon/compactmachines/client/machine/MachinePlayerEventHandler.java b/src/main/java/dev/compactmods/machines/client/machine/MachinePlayerEventHandler.java similarity index 80% rename from src/main/java/com/robotgryphon/compactmachines/client/machine/MachinePlayerEventHandler.java rename to src/main/java/dev/compactmods/machines/client/machine/MachinePlayerEventHandler.java index 5457e3c2..898d8f3a 100644 --- a/src/main/java/com/robotgryphon/compactmachines/client/machine/MachinePlayerEventHandler.java +++ b/src/main/java/dev/compactmods/machines/client/machine/MachinePlayerEventHandler.java @@ -1,8 +1,8 @@ -package com.robotgryphon.compactmachines.client.machine; +package dev.compactmods.machines.client.machine; -import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; -import com.robotgryphon.compactmachines.network.MachinePlayersChangedPacket; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import dev.compactmods.machines.block.tiles.CompactMachineTile; +import dev.compactmods.machines.network.MachinePlayersChangedPacket; +import dev.compactmods.machines.teleportation.DimensionalPosition; import net.minecraft.client.Minecraft; import net.minecraft.client.world.ClientWorld; diff --git a/src/main/java/com/robotgryphon/compactmachines/compat/jei/CompactMachinesJeiPlugin.java b/src/main/java/dev/compactmods/machines/compat/jei/CompactMachinesJeiPlugin.java similarity index 79% rename from src/main/java/com/robotgryphon/compactmachines/compat/jei/CompactMachinesJeiPlugin.java rename to src/main/java/dev/compactmods/machines/compat/jei/CompactMachinesJeiPlugin.java index 03ae50e9..08026432 100644 --- a/src/main/java/com/robotgryphon/compactmachines/compat/jei/CompactMachinesJeiPlugin.java +++ b/src/main/java/dev/compactmods/machines/compat/jei/CompactMachinesJeiPlugin.java @@ -1,7 +1,7 @@ -package com.robotgryphon.compactmachines.compat.jei; +package dev.compactmods.machines.compat.jei; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.core.Registration; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.core.Registration; import mezz.jei.api.IModPlugin; import mezz.jei.api.JeiPlugin; import mezz.jei.api.registration.ISubtypeRegistration; diff --git a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/IProbeData.java b/src/main/java/dev/compactmods/machines/compat/theoneprobe/IProbeData.java similarity index 79% rename from src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/IProbeData.java rename to src/main/java/dev/compactmods/machines/compat/theoneprobe/IProbeData.java index 61ade6b9..f21b3176 100644 --- a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/IProbeData.java +++ b/src/main/java/dev/compactmods/machines/compat/theoneprobe/IProbeData.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.compat.theoneprobe; +package dev.compactmods.machines.compat.theoneprobe; import mcjty.theoneprobe.api.IProbeHitData; import mcjty.theoneprobe.api.IProbeInfo; diff --git a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/IProbeDataProvider.java b/src/main/java/dev/compactmods/machines/compat/theoneprobe/IProbeDataProvider.java similarity index 80% rename from src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/IProbeDataProvider.java rename to src/main/java/dev/compactmods/machines/compat/theoneprobe/IProbeDataProvider.java index 5a6cd563..203e313d 100644 --- a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/IProbeDataProvider.java +++ b/src/main/java/dev/compactmods/machines/compat/theoneprobe/IProbeDataProvider.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.compat.theoneprobe; +package dev.compactmods.machines.compat.theoneprobe; import net.minecraft.block.BlockState; import net.minecraft.entity.player.PlayerEntity; diff --git a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/ProbeData.java b/src/main/java/dev/compactmods/machines/compat/theoneprobe/ProbeData.java similarity index 91% rename from src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/ProbeData.java rename to src/main/java/dev/compactmods/machines/compat/theoneprobe/ProbeData.java index ea8fbacc..74845cd9 100644 --- a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/ProbeData.java +++ b/src/main/java/dev/compactmods/machines/compat/theoneprobe/ProbeData.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.compat.theoneprobe; +package dev.compactmods.machines.compat.theoneprobe; import mcjty.theoneprobe.api.IProbeHitData; import mcjty.theoneprobe.api.IProbeInfo; diff --git a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/TheOneProbeCompat.java b/src/main/java/dev/compactmods/machines/compat/theoneprobe/TheOneProbeCompat.java similarity index 77% rename from src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/TheOneProbeCompat.java rename to src/main/java/dev/compactmods/machines/compat/theoneprobe/TheOneProbeCompat.java index debc078a..841c3ed7 100644 --- a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/TheOneProbeCompat.java +++ b/src/main/java/dev/compactmods/machines/compat/theoneprobe/TheOneProbeCompat.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.compat.theoneprobe; +package dev.compactmods.machines.compat.theoneprobe; import net.minecraftforge.fml.InterModComms; diff --git a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/TheOneProbeMain.java b/src/main/java/dev/compactmods/machines/compat/theoneprobe/TheOneProbeMain.java similarity index 85% rename from src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/TheOneProbeMain.java rename to src/main/java/dev/compactmods/machines/compat/theoneprobe/TheOneProbeMain.java index 960eed4c..14b1774d 100644 --- a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/TheOneProbeMain.java +++ b/src/main/java/dev/compactmods/machines/compat/theoneprobe/TheOneProbeMain.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.compat.theoneprobe; +package dev.compactmods.machines.compat.theoneprobe; import mcjty.theoneprobe.api.ITheOneProbe; diff --git a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/TheOneProbeProvider.java b/src/main/java/dev/compactmods/machines/compat/theoneprobe/TheOneProbeProvider.java similarity index 89% rename from src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/TheOneProbeProvider.java rename to src/main/java/dev/compactmods/machines/compat/theoneprobe/TheOneProbeProvider.java index c65f84ef..abe14905 100644 --- a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/TheOneProbeProvider.java +++ b/src/main/java/dev/compactmods/machines/compat/theoneprobe/TheOneProbeProvider.java @@ -1,6 +1,6 @@ -package com.robotgryphon.compactmachines.compat.theoneprobe; +package dev.compactmods.machines.compat.theoneprobe; -import com.robotgryphon.compactmachines.CompactMachines; +import dev.compactmods.machines.CompactMachines; import mcjty.theoneprobe.api.IProbeHitData; import mcjty.theoneprobe.api.IProbeInfo; import mcjty.theoneprobe.api.IProbeInfoProvider; diff --git a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java b/src/main/java/dev/compactmods/machines/compat/theoneprobe/providers/CompactMachineProvider.java similarity index 81% rename from src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java rename to src/main/java/dev/compactmods/machines/compat/theoneprobe/providers/CompactMachineProvider.java index aeee0e6a..501f5c7e 100644 --- a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/CompactMachineProvider.java +++ b/src/main/java/dev/compactmods/machines/compat/theoneprobe/providers/CompactMachineProvider.java @@ -1,24 +1,21 @@ -package com.robotgryphon.compactmachines.compat.theoneprobe.providers; +package dev.compactmods.machines.compat.theoneprobe.providers; import com.mojang.authlib.GameProfile; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.api.core.Tooltips; -import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; -import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; -import com.robotgryphon.compactmachines.compat.theoneprobe.IProbeData; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.tunnels.TunnelHelper; -import com.robotgryphon.compactmachines.util.TranslationUtil; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.api.core.Tooltips; +import dev.compactmods.machines.block.tiles.CompactMachineTile; +import dev.compactmods.machines.block.tiles.TunnelWallTile; +import dev.compactmods.machines.compat.theoneprobe.IProbeData; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.tunnels.TunnelHelper; +import dev.compactmods.machines.util.TranslationUtil; import mcjty.theoneprobe.api.IProbeHitData; import mcjty.theoneprobe.api.IProbeInfo; -import mcjty.theoneprobe.api.ITextStyle; -import mcjty.theoneprobe.api.ProbeMode; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.BlockPos; import net.minecraft.util.text.IFormattableTextComponent; -import net.minecraft.util.text.ITextComponent; import net.minecraft.util.text.StringTextComponent; import net.minecraft.util.text.TextFormatting; import net.minecraft.world.World; diff --git a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/TunnelProvider.java b/src/main/java/dev/compactmods/machines/compat/theoneprobe/providers/TunnelProvider.java similarity index 87% rename from src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/TunnelProvider.java rename to src/main/java/dev/compactmods/machines/compat/theoneprobe/providers/TunnelProvider.java index ee4034a5..e35e670b 100644 --- a/src/main/java/com/robotgryphon/compactmachines/compat/theoneprobe/providers/TunnelProvider.java +++ b/src/main/java/dev/compactmods/machines/compat/theoneprobe/providers/TunnelProvider.java @@ -1,14 +1,14 @@ -package com.robotgryphon.compactmachines.compat.theoneprobe.providers; - -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; -import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; -import com.robotgryphon.compactmachines.block.walls.TunnelWallBlock; -import com.robotgryphon.compactmachines.compat.theoneprobe.IProbeData; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; -import com.robotgryphon.compactmachines.api.tunnels.EnumTunnelSide; -import com.robotgryphon.compactmachines.tunnels.TunnelHelper; +package dev.compactmods.machines.compat.theoneprobe.providers; + +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.api.tunnels.TunnelDefinition; +import dev.compactmods.machines.block.tiles.TunnelWallTile; +import dev.compactmods.machines.block.walls.TunnelWallBlock; +import dev.compactmods.machines.compat.theoneprobe.IProbeData; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.teleportation.DimensionalPosition; +import dev.compactmods.machines.api.tunnels.EnumTunnelSide; +import dev.compactmods.machines.tunnels.TunnelHelper; import mcjty.theoneprobe.api.*; import net.minecraft.block.BlockState; import net.minecraft.entity.player.PlayerEntity; diff --git a/src/main/java/com/robotgryphon/compactmachines/config/CommonConfig.java b/src/main/java/dev/compactmods/machines/config/CommonConfig.java similarity index 76% rename from src/main/java/com/robotgryphon/compactmachines/config/CommonConfig.java rename to src/main/java/dev/compactmods/machines/config/CommonConfig.java index fe18e28f..eb05ef6b 100644 --- a/src/main/java/com/robotgryphon/compactmachines/config/CommonConfig.java +++ b/src/main/java/dev/compactmods/machines/config/CommonConfig.java @@ -1,17 +1,11 @@ -package com.robotgryphon.compactmachines.config; +package dev.compactmods.machines.config; -import com.electronwill.nightconfig.core.EnumGetMethod; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.core.EnumMachinePlayersBreakHandling; +import dev.compactmods.machines.CompactMachines; import net.minecraftforge.common.ForgeConfigSpec; import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.config.ModConfig; -import java.util.Arrays; -import java.util.List; -import java.util.stream.Collectors; - @Mod.EventBusSubscriber(modid = CompactMachines.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD) public class CommonConfig { diff --git a/src/main/java/com/robotgryphon/compactmachines/config/EnableVanillaRecipesConfigCondition.java b/src/main/java/dev/compactmods/machines/config/EnableVanillaRecipesConfigCondition.java similarity index 91% rename from src/main/java/com/robotgryphon/compactmachines/config/EnableVanillaRecipesConfigCondition.java rename to src/main/java/dev/compactmods/machines/config/EnableVanillaRecipesConfigCondition.java index b5d3da8a..cfdf509d 100644 --- a/src/main/java/com/robotgryphon/compactmachines/config/EnableVanillaRecipesConfigCondition.java +++ b/src/main/java/dev/compactmods/machines/config/EnableVanillaRecipesConfigCondition.java @@ -1,7 +1,7 @@ -package com.robotgryphon.compactmachines.config; +package dev.compactmods.machines.config; import com.google.gson.JsonObject; -import com.robotgryphon.compactmachines.CompactMachines; +import dev.compactmods.machines.CompactMachines; import net.minecraft.util.ResourceLocation; import net.minecraftforge.common.crafting.conditions.ICondition; import net.minecraftforge.common.crafting.conditions.IConditionSerializer; diff --git a/src/main/java/com/robotgryphon/compactmachines/config/ServerConfig.java b/src/main/java/dev/compactmods/machines/config/ServerConfig.java similarity index 93% rename from src/main/java/com/robotgryphon/compactmachines/config/ServerConfig.java rename to src/main/java/dev/compactmods/machines/config/ServerConfig.java index c077eb97..6a1947c1 100644 --- a/src/main/java/com/robotgryphon/compactmachines/config/ServerConfig.java +++ b/src/main/java/dev/compactmods/machines/config/ServerConfig.java @@ -1,7 +1,7 @@ -package com.robotgryphon.compactmachines.config; +package dev.compactmods.machines.config; import com.electronwill.nightconfig.core.EnumGetMethod; -import com.robotgryphon.compactmachines.core.EnumMachinePlayersBreakHandling; +import dev.compactmods.machines.core.EnumMachinePlayersBreakHandling; import net.minecraftforge.common.ForgeConfigSpec; import java.util.Arrays; diff --git a/src/main/java/com/robotgryphon/compactmachines/core/EnumMachinePlayersBreakHandling.java b/src/main/java/dev/compactmods/machines/core/EnumMachinePlayersBreakHandling.java similarity index 93% rename from src/main/java/com/robotgryphon/compactmachines/core/EnumMachinePlayersBreakHandling.java rename to src/main/java/dev/compactmods/machines/core/EnumMachinePlayersBreakHandling.java index d1b89ad1..5fa7bec6 100644 --- a/src/main/java/com/robotgryphon/compactmachines/core/EnumMachinePlayersBreakHandling.java +++ b/src/main/java/dev/compactmods/machines/core/EnumMachinePlayersBreakHandling.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.core; +package dev.compactmods.machines.core; public enum EnumMachinePlayersBreakHandling { UNBREAKABLE("unbreakable", "Nobody can break while players are inside."), diff --git a/src/main/java/com/robotgryphon/compactmachines/core/ModBusEvents.java b/src/main/java/dev/compactmods/machines/core/ModBusEvents.java similarity index 71% rename from src/main/java/com/robotgryphon/compactmachines/core/ModBusEvents.java rename to src/main/java/dev/compactmods/machines/core/ModBusEvents.java index a686200b..94816e2a 100644 --- a/src/main/java/com/robotgryphon/compactmachines/core/ModBusEvents.java +++ b/src/main/java/dev/compactmods/machines/core/ModBusEvents.java @@ -1,10 +1,9 @@ -package com.robotgryphon.compactmachines.core; +package dev.compactmods.machines.core; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.advancement.AdvancementTriggers; -import com.robotgryphon.compactmachines.api.core.Advancements; -import com.robotgryphon.compactmachines.compat.theoneprobe.TheOneProbeCompat; -import com.robotgryphon.compactmachines.network.NetworkHandler; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.advancement.AdvancementTriggers; +import dev.compactmods.machines.compat.theoneprobe.TheOneProbeCompat; +import dev.compactmods.machines.network.NetworkHandler; import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.fml.ModList; import net.minecraftforge.fml.common.Mod; diff --git a/src/main/java/com/robotgryphon/compactmachines/core/Registration.java b/src/main/java/dev/compactmods/machines/core/Registration.java similarity index 89% rename from src/main/java/com/robotgryphon/compactmachines/core/Registration.java rename to src/main/java/dev/compactmods/machines/core/Registration.java index bd7ce05d..e1ca60e5 100644 --- a/src/main/java/com/robotgryphon/compactmachines/core/Registration.java +++ b/src/main/java/dev/compactmods/machines/core/Registration.java @@ -1,21 +1,20 @@ -package com.robotgryphon.compactmachines.core; - -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; -import com.robotgryphon.compactmachines.block.BlockCompactMachine; -import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; -import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; -import com.robotgryphon.compactmachines.block.walls.BreakableWallBlock; -import com.robotgryphon.compactmachines.block.walls.SolidWallBlock; -import com.robotgryphon.compactmachines.block.walls.TunnelWallBlock; -import com.robotgryphon.compactmachines.item.ItemBlockMachine; -import com.robotgryphon.compactmachines.item.ItemBlockWall; -import com.robotgryphon.compactmachines.item.ItemPersonalShrinkingDevice; -import com.robotgryphon.compactmachines.item.TunnelItem; -import com.robotgryphon.compactmachines.reference.EnumMachineSize; -import com.robotgryphon.compactmachines.tunnels.definitions.ItemTunnelDefinition; -import com.robotgryphon.compactmachines.tunnels.definitions.RedstoneInTunnelDefinition; -import com.robotgryphon.compactmachines.tunnels.definitions.RedstoneOutTunnelDefinition; +package dev.compactmods.machines.core; + +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.api.tunnels.TunnelDefinition; +import dev.compactmods.machines.block.BlockCompactMachine; +import dev.compactmods.machines.block.tiles.CompactMachineTile; +import dev.compactmods.machines.block.tiles.TunnelWallTile; +import dev.compactmods.machines.block.walls.BreakableWallBlock; +import dev.compactmods.machines.block.walls.SolidWallBlock; +import dev.compactmods.machines.block.walls.TunnelWallBlock; +import dev.compactmods.machines.item.ItemBlockMachine; +import dev.compactmods.machines.item.ItemBlockWall; +import dev.compactmods.machines.item.ItemPersonalShrinkingDevice; +import dev.compactmods.machines.item.TunnelItem; +import dev.compactmods.machines.reference.EnumMachineSize; +import dev.compactmods.machines.tunnels.definitions.ItemTunnelDefinition; +import dev.compactmods.machines.tunnels.definitions.RedstoneInTunnelDefinition; import net.minecraft.block.AbstractBlock; import net.minecraft.block.Block; import net.minecraft.block.SoundType; @@ -38,7 +37,7 @@ import java.util.function.Supplier; -import static com.robotgryphon.compactmachines.CompactMachines.MOD_ID; +import static dev.compactmods.machines.CompactMachines.MOD_ID; @Mod.EventBusSubscriber(modid = MOD_ID) public class Registration { diff --git a/src/main/java/com/robotgryphon/compactmachines/core/ServerEventHandler.java b/src/main/java/dev/compactmods/machines/core/ServerEventHandler.java similarity index 83% rename from src/main/java/com/robotgryphon/compactmachines/core/ServerEventHandler.java rename to src/main/java/dev/compactmods/machines/core/ServerEventHandler.java index 24d28660..5a722cc4 100644 --- a/src/main/java/com/robotgryphon/compactmachines/core/ServerEventHandler.java +++ b/src/main/java/dev/compactmods/machines/core/ServerEventHandler.java @@ -1,6 +1,6 @@ -package com.robotgryphon.compactmachines.core; +package dev.compactmods.machines.core; -import com.robotgryphon.compactmachines.CompactMachines; +import dev.compactmods.machines.CompactMachines; import net.minecraft.server.MinecraftServer; import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.fml.common.Mod; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java b/src/main/java/dev/compactmods/machines/data/codec/CodecExtensions.java similarity index 96% rename from src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java rename to src/main/java/dev/compactmods/machines/data/codec/CodecExtensions.java index c9f5cbdb..ecf7d0ad 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java +++ b/src/main/java/dev/compactmods/machines/data/codec/CodecExtensions.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.data.codec; +package dev.compactmods.machines.data.codec; import com.mojang.serialization.Codec; import com.mojang.serialization.DataResult; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/codec/DoubleStreamExtensions.java b/src/main/java/dev/compactmods/machines/data/codec/DoubleStreamExtensions.java similarity index 97% rename from src/main/java/com/robotgryphon/compactmachines/data/codec/DoubleStreamExtensions.java rename to src/main/java/dev/compactmods/machines/data/codec/DoubleStreamExtensions.java index dd0f9849..0486762b 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/codec/DoubleStreamExtensions.java +++ b/src/main/java/dev/compactmods/machines/data/codec/DoubleStreamExtensions.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.data.codec; +package dev.compactmods.machines.data.codec; import com.mojang.serialization.DataResult; import com.mojang.serialization.DynamicOps; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/codec/NbtListCollector.java b/src/main/java/dev/compactmods/machines/data/codec/NbtListCollector.java similarity index 96% rename from src/main/java/com/robotgryphon/compactmachines/data/codec/NbtListCollector.java rename to src/main/java/dev/compactmods/machines/data/codec/NbtListCollector.java index 170d3369..d8ee8084 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/codec/NbtListCollector.java +++ b/src/main/java/dev/compactmods/machines/data/codec/NbtListCollector.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.data.codec; +package dev.compactmods.machines.data.codec; import com.google.common.collect.ImmutableSet; import net.minecraft.nbt.INBT; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java b/src/main/java/dev/compactmods/machines/data/graph/CompactMachineConnectionGraph.java similarity index 96% rename from src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java rename to src/main/java/dev/compactmods/machines/data/graph/CompactMachineConnectionGraph.java index c384f1a9..a3fabe47 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java +++ b/src/main/java/dev/compactmods/machines/data/graph/CompactMachineConnectionGraph.java @@ -1,11 +1,10 @@ -package com.robotgryphon.compactmachines.data.graph; +package dev.compactmods.machines.data.graph; import com.google.common.collect.ImmutableList; import com.google.common.graph.*; import com.mojang.serialization.Codec; import com.mojang.serialization.codecs.RecordCodecBuilder; -import com.robotgryphon.compactmachines.data.codec.CodecExtensions; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import dev.compactmods.machines.data.codec.CodecExtensions; import net.minecraft.util.math.ChunkPos; import java.util.*; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineNode.java b/src/main/java/dev/compactmods/machines/data/graph/CompactMachineNode.java similarity index 90% rename from src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineNode.java rename to src/main/java/dev/compactmods/machines/data/graph/CompactMachineNode.java index 3f012767..8215aa64 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineNode.java +++ b/src/main/java/dev/compactmods/machines/data/graph/CompactMachineNode.java @@ -1,6 +1,4 @@ -package com.robotgryphon.compactmachines.data.graph; - -import com.google.common.graph.MutableGraph; +package dev.compactmods.machines.data.graph; import java.util.Objects; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineRoomNode.java b/src/main/java/dev/compactmods/machines/data/graph/CompactMachineRoomNode.java similarity index 95% rename from src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineRoomNode.java rename to src/main/java/dev/compactmods/machines/data/graph/CompactMachineRoomNode.java index 7781f438..07a34c32 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineRoomNode.java +++ b/src/main/java/dev/compactmods/machines/data/graph/CompactMachineRoomNode.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.data.graph; +package dev.compactmods.machines.data.graph; import net.minecraft.util.math.ChunkPos; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/DefaultEdges.java b/src/main/java/dev/compactmods/machines/data/graph/DefaultEdges.java similarity index 56% rename from src/main/java/com/robotgryphon/compactmachines/data/graph/DefaultEdges.java rename to src/main/java/dev/compactmods/machines/data/graph/DefaultEdges.java index 6bacf09d..9821d0ab 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/graph/DefaultEdges.java +++ b/src/main/java/dev/compactmods/machines/data/graph/DefaultEdges.java @@ -1,6 +1,4 @@ -package com.robotgryphon.compactmachines.data.graph; - -import java.util.HashMap; +package dev.compactmods.machines.data.graph; public class DefaultEdges { diff --git a/src/main/java/dev/compactmods/machines/data/graph/IGraphEdge.java b/src/main/java/dev/compactmods/machines/data/graph/IGraphEdge.java new file mode 100644 index 00000000..60ebd373 --- /dev/null +++ b/src/main/java/dev/compactmods/machines/data/graph/IGraphEdge.java @@ -0,0 +1,4 @@ +package dev.compactmods.machines.data.graph; + +public interface IGraphEdge { +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/IMachineGraphNode.java b/src/main/java/dev/compactmods/machines/data/graph/IMachineGraphNode.java similarity index 60% rename from src/main/java/com/robotgryphon/compactmachines/data/graph/IMachineGraphNode.java rename to src/main/java/dev/compactmods/machines/data/graph/IMachineGraphNode.java index fbfc2dee..20b4d749 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/graph/IMachineGraphNode.java +++ b/src/main/java/dev/compactmods/machines/data/graph/IMachineGraphNode.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.data.graph; +package dev.compactmods.machines.data.graph; public interface IMachineGraphNode { String label(); diff --git a/src/main/java/com/robotgryphon/compactmachines/data/graph/MachineLinkEdge.java b/src/main/java/dev/compactmods/machines/data/graph/MachineLinkEdge.java similarity index 51% rename from src/main/java/com/robotgryphon/compactmachines/data/graph/MachineLinkEdge.java rename to src/main/java/dev/compactmods/machines/data/graph/MachineLinkEdge.java index e5f7b2b5..dfba881f 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/graph/MachineLinkEdge.java +++ b/src/main/java/dev/compactmods/machines/data/graph/MachineLinkEdge.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.data.graph; +package dev.compactmods.machines.data.graph; public class MachineLinkEdge implements IGraphEdge { } diff --git a/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactMachineData.java b/src/main/java/dev/compactmods/machines/data/persistent/CompactMachineData.java similarity index 91% rename from src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactMachineData.java rename to src/main/java/dev/compactmods/machines/data/persistent/CompactMachineData.java index 9bc41b1d..97e9f994 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactMachineData.java +++ b/src/main/java/dev/compactmods/machines/data/persistent/CompactMachineData.java @@ -1,19 +1,17 @@ -package com.robotgryphon.compactmachines.data.persistent; +package dev.compactmods.machines.data.persistent; import com.mojang.serialization.Codec; import com.mojang.serialization.DataResult; import com.mojang.serialization.codecs.RecordCodecBuilder; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.codec.CodecExtensions; -import com.robotgryphon.compactmachines.data.codec.NbtListCollector; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.data.codec.NbtListCollector; +import dev.compactmods.machines.teleportation.DimensionalPosition; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.INBT; import net.minecraft.nbt.ListNBT; import net.minecraft.nbt.NBTDynamicOps; import net.minecraft.server.MinecraftServer; -import net.minecraft.util.math.ChunkPos; import net.minecraft.world.server.ServerWorld; import net.minecraft.world.storage.DimensionSavedDataManager; import net.minecraft.world.storage.WorldSavedData; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactRoomData.java b/src/main/java/dev/compactmods/machines/data/persistent/CompactRoomData.java similarity index 93% rename from src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactRoomData.java rename to src/main/java/dev/compactmods/machines/data/persistent/CompactRoomData.java index 73851da7..91bee95d 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/persistent/CompactRoomData.java +++ b/src/main/java/dev/compactmods/machines/data/persistent/CompactRoomData.java @@ -1,16 +1,16 @@ -package com.robotgryphon.compactmachines.data.persistent; +package dev.compactmods.machines.data.persistent; import com.mojang.serialization.Codec; import com.mojang.serialization.DataResult; import com.mojang.serialization.codecs.RecordCodecBuilder; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.config.ServerConfig; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.codec.CodecExtensions; -import com.robotgryphon.compactmachines.data.codec.NbtListCollector; -import com.robotgryphon.compactmachines.reference.EnumMachineSize; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; -import com.robotgryphon.compactmachines.util.MathUtil; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.config.ServerConfig; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.data.codec.CodecExtensions; +import dev.compactmods.machines.data.codec.NbtListCollector; +import dev.compactmods.machines.reference.EnumMachineSize; +import dev.compactmods.machines.teleportation.DimensionalPosition; +import dev.compactmods.machines.util.MathUtil; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.INBT; import net.minecraft.nbt.ListNBT; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java b/src/main/java/dev/compactmods/machines/data/persistent/MachineConnections.java similarity index 88% rename from src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java rename to src/main/java/dev/compactmods/machines/data/persistent/MachineConnections.java index 2d29a388..3a61b120 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/persistent/MachineConnections.java +++ b/src/main/java/dev/compactmods/machines/data/persistent/MachineConnections.java @@ -1,9 +1,9 @@ -package com.robotgryphon.compactmachines.data.persistent; +package dev.compactmods.machines.data.persistent; import com.mojang.serialization.DataResult; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.graph.CompactMachineConnectionGraph; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.data.graph.CompactMachineConnectionGraph; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.INBT; import net.minecraft.nbt.NBTDynamicOps; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/player/CompactMachinePlayerData.java b/src/main/java/dev/compactmods/machines/data/player/CompactMachinePlayerData.java similarity index 67% rename from src/main/java/com/robotgryphon/compactmachines/data/player/CompactMachinePlayerData.java rename to src/main/java/dev/compactmods/machines/data/player/CompactMachinePlayerData.java index 5919beee..ebf20129 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/player/CompactMachinePlayerData.java +++ b/src/main/java/dev/compactmods/machines/data/player/CompactMachinePlayerData.java @@ -1,24 +1,14 @@ -package com.robotgryphon.compactmachines.data.player; +package dev.compactmods.machines.data.player; -import com.google.common.graph.ElementOrder; import com.google.common.graph.GraphBuilder; import com.google.common.graph.MutableGraph; -import com.mojang.serialization.DataResult; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.codec.CodecExtensions; -import com.robotgryphon.compactmachines.data.codec.NbtListCollector; -import com.robotgryphon.compactmachines.data.graph.IMachineGraphNode; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; -import com.robotgryphon.compactmachines.util.PlayerUtil; -import net.minecraft.entity.player.ServerPlayerEntity; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.core.Registration; import net.minecraft.nbt.*; import net.minecraft.server.MinecraftServer; -import net.minecraft.util.math.ChunkPos; import net.minecraft.world.server.ServerWorld; import net.minecraft.world.storage.DimensionSavedDataManager; import net.minecraft.world.storage.WorldSavedData; -import net.minecraftforge.common.util.Constants; import javax.annotation.Nonnull; import javax.annotation.Nullable; diff --git a/src/main/java/dev/compactmods/machines/data/player/IPlayerHistoryNode.java b/src/main/java/dev/compactmods/machines/data/player/IPlayerHistoryNode.java new file mode 100644 index 00000000..2272f031 --- /dev/null +++ b/src/main/java/dev/compactmods/machines/data/player/IPlayerHistoryNode.java @@ -0,0 +1,5 @@ +package dev.compactmods.machines.data.player; + +public interface IPlayerHistoryNode { + +} diff --git a/src/main/java/com/robotgryphon/compactmachines/data/player/PlayerMachineHistory.java b/src/main/java/dev/compactmods/machines/data/player/PlayerMachineHistory.java similarity index 69% rename from src/main/java/com/robotgryphon/compactmachines/data/player/PlayerMachineHistory.java rename to src/main/java/dev/compactmods/machines/data/player/PlayerMachineHistory.java index 7b1ef66f..06c7aae1 100644 --- a/src/main/java/com/robotgryphon/compactmachines/data/player/PlayerMachineHistory.java +++ b/src/main/java/dev/compactmods/machines/data/player/PlayerMachineHistory.java @@ -1,6 +1,6 @@ -package com.robotgryphon.compactmachines.data.player; +package dev.compactmods.machines.data.player; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import dev.compactmods.machines.teleportation.DimensionalPosition; import java.util.Deque; diff --git a/src/main/java/com/robotgryphon/compactmachines/data/player/theory.txt b/src/main/java/dev/compactmods/machines/data/player/theory.txt similarity index 100% rename from src/main/java/com/robotgryphon/compactmachines/data/player/theory.txt rename to src/main/java/dev/compactmods/machines/data/player/theory.txt diff --git a/src/main/java/com/robotgryphon/compactmachines/datagen/AdvancementGenerator.java b/src/main/java/dev/compactmods/machines/datagen/AdvancementGenerator.java similarity index 89% rename from src/main/java/com/robotgryphon/compactmachines/datagen/AdvancementGenerator.java rename to src/main/java/dev/compactmods/machines/datagen/AdvancementGenerator.java index 37b0f1f1..db9e0519 100644 --- a/src/main/java/com/robotgryphon/compactmachines/datagen/AdvancementGenerator.java +++ b/src/main/java/dev/compactmods/machines/datagen/AdvancementGenerator.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.datagen; +package dev.compactmods.machines.datagen; import java.io.IOException; import java.nio.file.Path; @@ -7,11 +7,11 @@ import com.google.common.collect.Sets; import com.google.gson.Gson; import com.google.gson.GsonBuilder; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.advancement.trigger.HowDidYouGetHereTrigger; -import com.robotgryphon.compactmachines.api.core.Advancements; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.util.TranslationUtil; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.advancement.trigger.HowDidYouGetHereTrigger; +import dev.compactmods.machines.api.core.Advancements; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.util.TranslationUtil; import net.minecraft.advancements.*; import net.minecraft.advancements.criterion.ImpossibleTrigger; import net.minecraft.data.DataGenerator; @@ -19,9 +19,6 @@ import net.minecraft.data.IDataProvider; import net.minecraft.item.ItemStack; import net.minecraft.util.ResourceLocation; -import net.minecraft.util.text.ITextComponent; -import net.minecraft.util.text.TranslationTextComponent; -import org.apache.logging.log4j.core.tools.picocli.CommandLine; public class AdvancementGenerator implements IDataProvider { diff --git a/src/main/java/com/robotgryphon/compactmachines/datagen/BlockLootGenerator.java b/src/main/java/dev/compactmods/machines/datagen/BlockLootGenerator.java similarity index 96% rename from src/main/java/com/robotgryphon/compactmachines/datagen/BlockLootGenerator.java rename to src/main/java/dev/compactmods/machines/datagen/BlockLootGenerator.java index 75bc022d..f0e0fb87 100644 --- a/src/main/java/com/robotgryphon/compactmachines/datagen/BlockLootGenerator.java +++ b/src/main/java/dev/compactmods/machines/datagen/BlockLootGenerator.java @@ -1,9 +1,9 @@ -package com.robotgryphon.compactmachines.datagen; +package dev.compactmods.machines.datagen; import com.google.common.collect.ImmutableList; import com.mojang.datafixers.util.Pair; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.reference.Reference; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.reference.Reference; import net.minecraft.block.Block; import net.minecraft.data.DataGenerator; import net.minecraft.data.LootTableProvider; diff --git a/src/main/java/com/robotgryphon/compactmachines/datagen/DataGeneration.java b/src/main/java/dev/compactmods/machines/datagen/DataGeneration.java similarity index 92% rename from src/main/java/com/robotgryphon/compactmachines/datagen/DataGeneration.java rename to src/main/java/dev/compactmods/machines/datagen/DataGeneration.java index e2dfa5f1..a44f6ed5 100644 --- a/src/main/java/com/robotgryphon/compactmachines/datagen/DataGeneration.java +++ b/src/main/java/dev/compactmods/machines/datagen/DataGeneration.java @@ -1,6 +1,6 @@ -package com.robotgryphon.compactmachines.datagen; +package dev.compactmods.machines.datagen; -import com.robotgryphon.compactmachines.CompactMachines; +import dev.compactmods.machines.CompactMachines; import net.minecraft.data.DataGenerator; import net.minecraftforge.common.data.ExistingFileHelper; import net.minecraftforge.eventbus.api.SubscribeEvent; diff --git a/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java b/src/main/java/dev/compactmods/machines/datagen/RecipeGenerator.java similarity index 93% rename from src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java rename to src/main/java/dev/compactmods/machines/datagen/RecipeGenerator.java index 571be1a3..8e568bac 100644 --- a/src/main/java/com/robotgryphon/compactmachines/datagen/RecipeGenerator.java +++ b/src/main/java/dev/compactmods/machines/datagen/RecipeGenerator.java @@ -1,10 +1,9 @@ -package com.robotgryphon.compactmachines.datagen; +package dev.compactmods.machines.datagen; -import com.robotgryphon.compactmachines.config.EnableVanillaRecipesConfigCondition; -import com.robotgryphon.compactmachines.core.Registration; +import dev.compactmods.machines.config.EnableVanillaRecipesConfigCondition; +import dev.compactmods.machines.core.Registration; import net.minecraft.data.*; import net.minecraft.item.Item; -import net.minecraft.item.ItemStack; import net.minecraft.item.Items; import net.minecraft.tags.ITag; import net.minecraft.tags.ItemTags; diff --git a/src/main/java/com/robotgryphon/compactmachines/datagen/StateGenerator.java b/src/main/java/dev/compactmods/machines/datagen/StateGenerator.java similarity index 75% rename from src/main/java/com/robotgryphon/compactmachines/datagen/StateGenerator.java rename to src/main/java/dev/compactmods/machines/datagen/StateGenerator.java index 443b4b79..47834120 100644 --- a/src/main/java/com/robotgryphon/compactmachines/datagen/StateGenerator.java +++ b/src/main/java/dev/compactmods/machines/datagen/StateGenerator.java @@ -1,15 +1,11 @@ -package com.robotgryphon.compactmachines.datagen; +package dev.compactmods.machines.datagen; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.reference.EnumMachineSize; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.reference.EnumMachineSize; import net.minecraft.data.DataGenerator; import net.minecraftforge.client.model.generators.BlockStateProvider; import net.minecraftforge.common.data.ExistingFileHelper; -import java.util.Arrays; -import java.util.List; -import java.util.stream.Collectors; - public class StateGenerator extends BlockStateProvider { public StateGenerator(DataGenerator gen, ExistingFileHelper exFileHelper) { super(gen, CompactMachines.MOD_ID, exFileHelper); diff --git a/src/main/java/com/robotgryphon/compactmachines/datagen/TunnelWallStateGenerator.java b/src/main/java/dev/compactmods/machines/datagen/TunnelWallStateGenerator.java similarity index 88% rename from src/main/java/com/robotgryphon/compactmachines/datagen/TunnelWallStateGenerator.java rename to src/main/java/dev/compactmods/machines/datagen/TunnelWallStateGenerator.java index 2782eae2..70eb49c9 100644 --- a/src/main/java/com/robotgryphon/compactmachines/datagen/TunnelWallStateGenerator.java +++ b/src/main/java/dev/compactmods/machines/datagen/TunnelWallStateGenerator.java @@ -1,9 +1,9 @@ -package com.robotgryphon.compactmachines.datagen; +package dev.compactmods.machines.datagen; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.block.walls.TunnelWallBlock; -import com.robotgryphon.compactmachines.core.Registration; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.block.walls.TunnelWallBlock; +import dev.compactmods.machines.core.Registration; import net.minecraft.block.Block; import net.minecraft.data.DataGenerator; import net.minecraft.util.Direction; @@ -14,9 +14,6 @@ import net.minecraftforge.client.model.generators.ModelBuilder; import net.minecraftforge.common.data.ExistingFileHelper; -import net.minecraftforge.client.model.generators.ModelBuilder.ElementBuilder; -import net.minecraftforge.client.model.generators.ModelBuilder.ElementBuilder.FaceBuilder; - public class TunnelWallStateGenerator extends BlockStateProvider { public TunnelWallStateGenerator(DataGenerator gen, ExistingFileHelper exFileHelper) { super(gen, CompactMachines.MOD_ID, exFileHelper); diff --git a/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java b/src/main/java/dev/compactmods/machines/item/ItemBlockMachine.java similarity index 84% rename from src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java rename to src/main/java/dev/compactmods/machines/item/ItemBlockMachine.java index 29618d7c..349f98fd 100644 --- a/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockMachine.java +++ b/src/main/java/dev/compactmods/machines/item/ItemBlockMachine.java @@ -1,23 +1,19 @@ -package com.robotgryphon.compactmachines.item; +package dev.compactmods.machines.item; import com.mojang.authlib.GameProfile; -import com.robotgryphon.compactmachines.api.core.Tooltips; -import com.robotgryphon.compactmachines.block.BlockCompactMachine; -import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; -import com.robotgryphon.compactmachines.reference.EnumMachineSize; -import com.robotgryphon.compactmachines.reference.Reference; -import com.robotgryphon.compactmachines.util.PlayerUtil; -import com.robotgryphon.compactmachines.util.TranslationUtil; +import dev.compactmods.machines.api.core.Tooltips; +import dev.compactmods.machines.block.BlockCompactMachine; +import dev.compactmods.machines.reference.EnumMachineSize; +import dev.compactmods.machines.reference.Reference; +import dev.compactmods.machines.util.PlayerUtil; +import dev.compactmods.machines.util.TranslationUtil; import net.minecraft.block.Block; -import net.minecraft.block.BlockState; import net.minecraft.client.gui.screen.Screen; import net.minecraft.client.util.ITooltipFlag; import net.minecraft.item.BlockItem; -import net.minecraft.item.BlockItemUseContext; import net.minecraft.item.ItemGroup; import net.minecraft.item.ItemStack; import net.minecraft.nbt.CompoundNBT; -import net.minecraft.server.MinecraftServer; import net.minecraft.util.NonNullList; import net.minecraft.util.text.*; import net.minecraft.world.World; diff --git a/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockWall.java b/src/main/java/dev/compactmods/machines/item/ItemBlockWall.java similarity index 84% rename from src/main/java/com/robotgryphon/compactmachines/item/ItemBlockWall.java rename to src/main/java/dev/compactmods/machines/item/ItemBlockWall.java index 37fc2f02..54ae84a2 100644 --- a/src/main/java/com/robotgryphon/compactmachines/item/ItemBlockWall.java +++ b/src/main/java/dev/compactmods/machines/item/ItemBlockWall.java @@ -1,8 +1,8 @@ -package com.robotgryphon.compactmachines.item; +package dev.compactmods.machines.item; -import com.robotgryphon.compactmachines.api.core.Tooltips; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.util.TranslationUtil; +import dev.compactmods.machines.api.core.Tooltips; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.util.TranslationUtil; import net.minecraft.block.Block; import net.minecraft.client.gui.screen.Screen; import net.minecraft.client.util.ITooltipFlag; diff --git a/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java b/src/main/java/dev/compactmods/machines/item/ItemPersonalShrinkingDevice.java similarity index 79% rename from src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java rename to src/main/java/dev/compactmods/machines/item/ItemPersonalShrinkingDevice.java index d527e524..e5d535cf 100644 --- a/src/main/java/com/robotgryphon/compactmachines/item/ItemPersonalShrinkingDevice.java +++ b/src/main/java/dev/compactmods/machines/item/ItemPersonalShrinkingDevice.java @@ -1,27 +1,20 @@ -package com.robotgryphon.compactmachines.item; +package dev.compactmods.machines.item; -import com.robotgryphon.compactmachines.api.core.Messages; -import com.robotgryphon.compactmachines.api.core.Tooltips; -import com.robotgryphon.compactmachines.block.BlockCompactMachine; -import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; -import com.robotgryphon.compactmachines.client.gui.PersonalShrinkingDeviceScreen; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.persistent.CompactRoomData; -import com.robotgryphon.compactmachines.util.PlayerUtil; -import com.robotgryphon.compactmachines.util.TranslationUtil; -import net.minecraft.block.BlockState; +import dev.compactmods.machines.api.core.Messages; +import dev.compactmods.machines.api.core.Tooltips; +import dev.compactmods.machines.client.gui.PersonalShrinkingDeviceScreen; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.data.persistent.CompactRoomData; +import dev.compactmods.machines.util.PlayerUtil; +import dev.compactmods.machines.util.TranslationUtil; import net.minecraft.client.gui.screen.Screen; import net.minecraft.client.util.ITooltipFlag; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; -import net.minecraft.item.ItemUseContext; -import net.minecraft.tileentity.TileEntity; import net.minecraft.util.ActionResult; -import net.minecraft.util.ActionResultType; import net.minecraft.util.Hand; -import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.ChunkPos; import net.minecraft.util.text.IFormattableTextComponent; import net.minecraft.util.text.ITextComponent; diff --git a/src/main/java/com/robotgryphon/compactmachines/item/TunnelItem.java b/src/main/java/dev/compactmods/machines/item/TunnelItem.java similarity index 90% rename from src/main/java/com/robotgryphon/compactmachines/item/TunnelItem.java rename to src/main/java/dev/compactmods/machines/item/TunnelItem.java index 06312e1e..326280dc 100644 --- a/src/main/java/com/robotgryphon/compactmachines/item/TunnelItem.java +++ b/src/main/java/dev/compactmods/machines/item/TunnelItem.java @@ -1,13 +1,13 @@ -package com.robotgryphon.compactmachines.item; - -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.api.core.Tooltips; -import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; -import com.robotgryphon.compactmachines.block.walls.TunnelWallBlock; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; -import com.robotgryphon.compactmachines.api.tunnels.redstone.IRedstoneReaderTunnel; -import com.robotgryphon.compactmachines.util.TranslationUtil; +package dev.compactmods.machines.item; + +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.api.core.Tooltips; +import dev.compactmods.machines.block.tiles.TunnelWallTile; +import dev.compactmods.machines.block.walls.TunnelWallBlock; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.api.tunnels.TunnelDefinition; +import dev.compactmods.machines.api.tunnels.redstone.IRedstoneReaderTunnel; +import dev.compactmods.machines.util.TranslationUtil; import net.minecraft.block.BlockState; import net.minecraft.client.gui.screen.Screen; import net.minecraft.client.util.ITooltipFlag; @@ -21,7 +21,6 @@ import net.minecraft.server.MinecraftServer; import net.minecraft.util.*; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.registry.Registry; import net.minecraft.util.text.*; import net.minecraft.world.World; import net.minecraft.world.server.ServerWorld; @@ -33,8 +32,6 @@ import java.util.List; import java.util.Optional; -import net.minecraft.item.Item.Properties; - public class TunnelItem extends Item { public TunnelItem(Properties properties) { super(properties); diff --git a/src/main/java/com/robotgryphon/compactmachines/network/CMPacketTargets.java b/src/main/java/dev/compactmods/machines/network/CMPacketTargets.java similarity index 85% rename from src/main/java/com/robotgryphon/compactmachines/network/CMPacketTargets.java rename to src/main/java/dev/compactmods/machines/network/CMPacketTargets.java index 68e68061..394d6781 100644 --- a/src/main/java/com/robotgryphon/compactmachines/network/CMPacketTargets.java +++ b/src/main/java/dev/compactmods/machines/network/CMPacketTargets.java @@ -1,18 +1,14 @@ -package com.robotgryphon.compactmachines.network; +package dev.compactmods.machines.network; -import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; -import com.robotgryphon.compactmachines.data.persistent.MachineConnections; -import net.minecraft.entity.player.ServerPlayerEntity; +import dev.compactmods.machines.data.persistent.CompactMachineData; +import dev.compactmods.machines.data.persistent.MachineConnections; import net.minecraft.network.IPacket; import net.minecraft.network.play.ServerPlayNetHandler; import net.minecraft.server.MinecraftServer; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.ChunkPos; -import net.minecraft.world.Dimension; import net.minecraft.world.World; import net.minecraft.world.chunk.Chunk; -import net.minecraft.world.server.ChunkManager; -import net.minecraft.world.server.ServerChunkProvider; import net.minecraft.world.server.ServerWorld; import net.minecraftforge.fml.network.NetworkDirection; import net.minecraftforge.fml.network.PacketDistributor; diff --git a/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java b/src/main/java/dev/compactmods/machines/network/MachinePlayersChangedPacket.java similarity index 91% rename from src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java rename to src/main/java/dev/compactmods/machines/network/MachinePlayersChangedPacket.java index a56b3bac..50c578c8 100644 --- a/src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java +++ b/src/main/java/dev/compactmods/machines/network/MachinePlayersChangedPacket.java @@ -1,14 +1,14 @@ -package com.robotgryphon.compactmachines.network; +package dev.compactmods.machines.network; import com.google.common.collect.ImmutableSet; import com.mojang.serialization.Codec; import com.mojang.serialization.codecs.RecordCodecBuilder; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.client.machine.MachinePlayerEventHandler; -import com.robotgryphon.compactmachines.data.codec.CodecExtensions; -import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; -import com.robotgryphon.compactmachines.data.persistent.MachineConnections; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.client.machine.MachinePlayerEventHandler; +import dev.compactmods.machines.data.codec.CodecExtensions; +import dev.compactmods.machines.data.persistent.CompactMachineData; +import dev.compactmods.machines.data.persistent.MachineConnections; +import dev.compactmods.machines.teleportation.DimensionalPosition; import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.network.PacketBuffer; import net.minecraft.server.MinecraftServer; diff --git a/src/main/java/com/robotgryphon/compactmachines/network/NetworkHandler.java b/src/main/java/dev/compactmods/machines/network/NetworkHandler.java similarity index 90% rename from src/main/java/com/robotgryphon/compactmachines/network/NetworkHandler.java rename to src/main/java/dev/compactmods/machines/network/NetworkHandler.java index f50d8e08..a093d0e2 100644 --- a/src/main/java/com/robotgryphon/compactmachines/network/NetworkHandler.java +++ b/src/main/java/dev/compactmods/machines/network/NetworkHandler.java @@ -1,13 +1,11 @@ -package com.robotgryphon.compactmachines.network; +package dev.compactmods.machines.network; -import com.robotgryphon.compactmachines.CompactMachines; +import dev.compactmods.machines.CompactMachines; import net.minecraft.util.ResourceLocation; import net.minecraftforge.fml.network.NetworkDirection; import net.minecraftforge.fml.network.NetworkRegistry; import net.minecraftforge.fml.network.simple.SimpleChannel; -import java.util.Optional; - public class NetworkHandler { private static int index = 0; private static final String PROTOCOL_VERSION = "1"; diff --git a/src/main/java/com/robotgryphon/compactmachines/network/TunnelAddedPacket.java b/src/main/java/dev/compactmods/machines/network/TunnelAddedPacket.java similarity index 91% rename from src/main/java/com/robotgryphon/compactmachines/network/TunnelAddedPacket.java rename to src/main/java/dev/compactmods/machines/network/TunnelAddedPacket.java index 228af494..f674b648 100644 --- a/src/main/java/com/robotgryphon/compactmachines/network/TunnelAddedPacket.java +++ b/src/main/java/dev/compactmods/machines/network/TunnelAddedPacket.java @@ -1,6 +1,6 @@ -package com.robotgryphon.compactmachines.network; +package dev.compactmods.machines.network; -import com.robotgryphon.compactmachines.client.ClientTunnelHandler; +import dev.compactmods.machines.client.ClientTunnelHandler; import net.minecraft.network.PacketBuffer; import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.BlockPos; diff --git a/src/main/java/com/robotgryphon/compactmachines/reference/EnumMachineSize.java b/src/main/java/dev/compactmods/machines/reference/EnumMachineSize.java similarity index 96% rename from src/main/java/com/robotgryphon/compactmachines/reference/EnumMachineSize.java rename to src/main/java/dev/compactmods/machines/reference/EnumMachineSize.java index 29679709..792840ab 100644 --- a/src/main/java/com/robotgryphon/compactmachines/reference/EnumMachineSize.java +++ b/src/main/java/dev/compactmods/machines/reference/EnumMachineSize.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.reference; +package dev.compactmods.machines.reference; import com.mojang.serialization.Codec; import net.minecraft.util.IStringSerializable; diff --git a/src/main/java/com/robotgryphon/compactmachines/reference/GuiIds.java b/src/main/java/dev/compactmods/machines/reference/GuiIds.java similarity index 59% rename from src/main/java/com/robotgryphon/compactmachines/reference/GuiIds.java rename to src/main/java/dev/compactmods/machines/reference/GuiIds.java index 720d407a..fcb887ec 100644 --- a/src/main/java/com/robotgryphon/compactmachines/reference/GuiIds.java +++ b/src/main/java/dev/compactmods/machines/reference/GuiIds.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.reference; +package dev.compactmods.machines.reference; public enum GuiIds { PSD_GUIDE, diff --git a/src/main/java/com/robotgryphon/compactmachines/reference/Reference.java b/src/main/java/dev/compactmods/machines/reference/Reference.java similarity index 80% rename from src/main/java/com/robotgryphon/compactmachines/reference/Reference.java rename to src/main/java/dev/compactmods/machines/reference/Reference.java index beb869be..c9c2085f 100644 --- a/src/main/java/com/robotgryphon/compactmachines/reference/Reference.java +++ b/src/main/java/dev/compactmods/machines/reference/Reference.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.reference; +package dev.compactmods.machines.reference; public abstract class Reference { public static class CompactMachines { diff --git a/src/main/java/com/robotgryphon/compactmachines/reference/Resources.java b/src/main/java/dev/compactmods/machines/reference/Resources.java similarity index 73% rename from src/main/java/com/robotgryphon/compactmachines/reference/Resources.java rename to src/main/java/dev/compactmods/machines/reference/Resources.java index 2372ac2e..a9e73c82 100644 --- a/src/main/java/com/robotgryphon/compactmachines/reference/Resources.java +++ b/src/main/java/dev/compactmods/machines/reference/Resources.java @@ -1,7 +1,7 @@ -package com.robotgryphon.compactmachines.reference; +package dev.compactmods.machines.reference; import net.minecraft.util.ResourceLocation; -import com.robotgryphon.compactmachines.CompactMachines; +import dev.compactmods.machines.CompactMachines; public class Resources { public static final class Gui { diff --git a/src/main/java/dev/compactmods/machines/rooms/IRoomHistoryItem.java b/src/main/java/dev/compactmods/machines/rooms/IRoomHistoryItem.java new file mode 100644 index 00000000..8785005a --- /dev/null +++ b/src/main/java/dev/compactmods/machines/rooms/IRoomHistoryItem.java @@ -0,0 +1,10 @@ +package dev.compactmods.machines.rooms; + +import dev.compactmods.machines.teleportation.DimensionalPosition; + +public interface IRoomHistoryItem { + + DimensionalPosition getEntryLocation(); + + int getMachine(); +} diff --git a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/CMRoomHistory.java b/src/main/java/dev/compactmods/machines/rooms/capability/CMRoomHistory.java similarity index 83% rename from src/main/java/com/robotgryphon/compactmachines/rooms/capability/CMRoomHistory.java rename to src/main/java/dev/compactmods/machines/rooms/capability/CMRoomHistory.java index 894ab1f1..d09a6c3d 100644 --- a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/CMRoomHistory.java +++ b/src/main/java/dev/compactmods/machines/rooms/capability/CMRoomHistory.java @@ -1,8 +1,8 @@ -package com.robotgryphon.compactmachines.rooms.capability; +package dev.compactmods.machines.rooms.capability; import java.util.ArrayDeque; import java.util.Deque; -import com.robotgryphon.compactmachines.rooms.IRoomHistoryItem; +import dev.compactmods.machines.rooms.IRoomHistoryItem; public class CMRoomHistory implements IRoomHistory{ diff --git a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/CapabilityRoomHistory.java b/src/main/java/dev/compactmods/machines/rooms/capability/CapabilityRoomHistory.java similarity index 90% rename from src/main/java/com/robotgryphon/compactmachines/rooms/capability/CapabilityRoomHistory.java rename to src/main/java/dev/compactmods/machines/rooms/capability/CapabilityRoomHistory.java index 0261c678..6772a995 100644 --- a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/CapabilityRoomHistory.java +++ b/src/main/java/dev/compactmods/machines/rooms/capability/CapabilityRoomHistory.java @@ -1,7 +1,6 @@ -package com.robotgryphon.compactmachines.rooms.capability; +package dev.compactmods.machines.rooms.capability; import javax.annotation.Nullable; -import com.robotgryphon.compactmachines.rooms.IRoomHistoryItem; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.INBT; import net.minecraft.util.Direction; diff --git a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/IRoomHistory.java b/src/main/java/dev/compactmods/machines/rooms/capability/IRoomHistory.java similarity index 53% rename from src/main/java/com/robotgryphon/compactmachines/rooms/capability/IRoomHistory.java rename to src/main/java/dev/compactmods/machines/rooms/capability/IRoomHistory.java index 0de99554..033f6d32 100644 --- a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/IRoomHistory.java +++ b/src/main/java/dev/compactmods/machines/rooms/capability/IRoomHistory.java @@ -1,7 +1,6 @@ -package com.robotgryphon.compactmachines.rooms.capability; +package dev.compactmods.machines.rooms.capability; -import java.util.Deque; -import com.robotgryphon.compactmachines.rooms.IRoomHistoryItem; +import dev.compactmods.machines.rooms.IRoomHistoryItem; public interface IRoomHistory { diff --git a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/PlayerRoomHistoryCapProvider.java b/src/main/java/dev/compactmods/machines/rooms/capability/PlayerRoomHistoryCapProvider.java similarity index 94% rename from src/main/java/com/robotgryphon/compactmachines/rooms/capability/PlayerRoomHistoryCapProvider.java rename to src/main/java/dev/compactmods/machines/rooms/capability/PlayerRoomHistoryCapProvider.java index 3a3ebae3..40fd2ffd 100644 --- a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/PlayerRoomHistoryCapProvider.java +++ b/src/main/java/dev/compactmods/machines/rooms/capability/PlayerRoomHistoryCapProvider.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.rooms.capability; +package dev.compactmods.machines.rooms.capability; import javax.annotation.Nonnull; import javax.annotation.Nullable; diff --git a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/RoomCapEventHandler.java b/src/main/java/dev/compactmods/machines/rooms/capability/RoomCapEventHandler.java similarity index 64% rename from src/main/java/com/robotgryphon/compactmachines/rooms/capability/RoomCapEventHandler.java rename to src/main/java/dev/compactmods/machines/rooms/capability/RoomCapEventHandler.java index d7d61177..4b15c93e 100644 --- a/src/main/java/com/robotgryphon/compactmachines/rooms/capability/RoomCapEventHandler.java +++ b/src/main/java/dev/compactmods/machines/rooms/capability/RoomCapEventHandler.java @@ -1,17 +1,9 @@ -package com.robotgryphon.compactmachines.rooms.capability; +package dev.compactmods.machines.rooms.capability; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import com.robotgryphon.compactmachines.CompactMachines; +import dev.compactmods.machines.CompactMachines; import net.minecraft.entity.Entity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.entity.player.ServerPlayerEntity; -import net.minecraft.util.Direction; import net.minecraft.util.ResourceLocation; -import net.minecraft.world.World; -import net.minecraftforge.common.capabilities.Capability; -import net.minecraftforge.common.capabilities.ICapabilityProvider; -import net.minecraftforge.common.util.LazyOptional; import net.minecraftforge.event.AttachCapabilitiesEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.fml.common.Mod; diff --git a/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java b/src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java similarity index 95% rename from src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java rename to src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java index 4da58af3..ba0df49b 100644 --- a/src/main/java/com/robotgryphon/compactmachines/teleportation/DimensionalPosition.java +++ b/src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java @@ -1,10 +1,10 @@ -package com.robotgryphon.compactmachines.teleportation; +package dev.compactmods.machines.teleportation; import com.mojang.serialization.Codec; import com.mojang.serialization.DataResult; import com.mojang.serialization.codecs.RecordCodecBuilder; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.data.codec.CodecExtensions; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.data.codec.CodecExtensions; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.INBT; import net.minecraft.nbt.NBTDynamicOps; diff --git a/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java b/src/main/java/dev/compactmods/machines/teleportation/TeleportationEventHandler.java similarity index 87% rename from src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java rename to src/main/java/dev/compactmods/machines/teleportation/TeleportationEventHandler.java index d7625129..74d91672 100644 --- a/src/main/java/com/robotgryphon/compactmachines/teleportation/TeleportationEventHandler.java +++ b/src/main/java/dev/compactmods/machines/teleportation/TeleportationEventHandler.java @@ -1,14 +1,13 @@ -package com.robotgryphon.compactmachines.teleportation; +package dev.compactmods.machines.teleportation; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.api.core.Messages; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.persistent.CompactRoomData; -import com.robotgryphon.compactmachines.util.TranslationUtil; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.api.core.Messages; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.data.persistent.CompactRoomData; +import dev.compactmods.machines.util.TranslationUtil; import net.minecraft.entity.Entity; import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.server.MinecraftServer; -import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.ChunkPos; import net.minecraft.util.math.vector.Vector3d; import net.minecraft.util.text.TextFormatting; diff --git a/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelConnectionInfo.java b/src/main/java/dev/compactmods/machines/tunnels/TunnelConnectionInfo.java similarity index 84% rename from src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelConnectionInfo.java rename to src/main/java/dev/compactmods/machines/tunnels/TunnelConnectionInfo.java index 265b0573..a1a0060f 100644 --- a/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelConnectionInfo.java +++ b/src/main/java/dev/compactmods/machines/tunnels/TunnelConnectionInfo.java @@ -1,9 +1,9 @@ -package com.robotgryphon.compactmachines.tunnels; +package dev.compactmods.machines.tunnels; -import com.robotgryphon.compactmachines.api.tunnels.EnumTunnelSide; -import com.robotgryphon.compactmachines.api.tunnels.ITunnelConnectionInfo; -import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import dev.compactmods.machines.api.tunnels.EnumTunnelSide; +import dev.compactmods.machines.api.tunnels.ITunnelConnectionInfo; +import dev.compactmods.machines.block.tiles.TunnelWallTile; +import dev.compactmods.machines.teleportation.DimensionalPosition; import net.minecraft.block.BlockState; import net.minecraft.server.MinecraftServer; import net.minecraft.util.Direction; diff --git a/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelHelper.java b/src/main/java/dev/compactmods/machines/tunnels/TunnelHelper.java similarity index 90% rename from src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelHelper.java rename to src/main/java/dev/compactmods/machines/tunnels/TunnelHelper.java index 4836bcd4..f5850f0d 100644 --- a/src/main/java/com/robotgryphon/compactmachines/tunnels/TunnelHelper.java +++ b/src/main/java/dev/compactmods/machines/tunnels/TunnelHelper.java @@ -1,17 +1,15 @@ -package com.robotgryphon.compactmachines.tunnels; - -import com.robotgryphon.compactmachines.api.tunnels.EnumTunnelSide; -import com.robotgryphon.compactmachines.api.tunnels.ITunnelConnectionInfo; -import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; -import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; -import com.robotgryphon.compactmachines.block.walls.TunnelWallBlock; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +package dev.compactmods.machines.tunnels; + +import dev.compactmods.machines.api.tunnels.EnumTunnelSide; +import dev.compactmods.machines.api.tunnels.ITunnelConnectionInfo; +import dev.compactmods.machines.api.tunnels.TunnelDefinition; +import dev.compactmods.machines.block.tiles.TunnelWallTile; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.teleportation.DimensionalPosition; import net.minecraft.block.BlockState; import net.minecraft.util.Direction; import net.minecraft.util.RegistryKey; import net.minecraft.util.ResourceLocation; -import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; import net.minecraft.world.IBlockReader; import net.minecraft.world.World; @@ -22,7 +20,6 @@ import java.util.HashSet; import java.util.Optional; import java.util.Set; -import java.util.stream.Collectors; public class TunnelHelper { diff --git a/src/main/java/com/robotgryphon/compactmachines/tunnels/definitions/ItemTunnelDefinition.java b/src/main/java/dev/compactmods/machines/tunnels/definitions/ItemTunnelDefinition.java similarity index 89% rename from src/main/java/com/robotgryphon/compactmachines/tunnels/definitions/ItemTunnelDefinition.java rename to src/main/java/dev/compactmods/machines/tunnels/definitions/ItemTunnelDefinition.java index 28621867..5bd71725 100644 --- a/src/main/java/com/robotgryphon/compactmachines/tunnels/definitions/ItemTunnelDefinition.java +++ b/src/main/java/dev/compactmods/machines/tunnels/definitions/ItemTunnelDefinition.java @@ -1,11 +1,11 @@ -package com.robotgryphon.compactmachines.tunnels.definitions; - -import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; -import com.robotgryphon.compactmachines.block.tiles.TunnelWallTile; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; -import com.robotgryphon.compactmachines.api.tunnels.EnumTunnelSide; -import com.robotgryphon.compactmachines.tunnels.TunnelHelper; -import com.robotgryphon.compactmachines.api.tunnels.IItemTunnel; +package dev.compactmods.machines.tunnels.definitions; + +import dev.compactmods.machines.api.tunnels.TunnelDefinition; +import dev.compactmods.machines.block.tiles.TunnelWallTile; +import dev.compactmods.machines.teleportation.DimensionalPosition; +import dev.compactmods.machines.api.tunnels.EnumTunnelSide; +import dev.compactmods.machines.tunnels.TunnelHelper; +import dev.compactmods.machines.api.tunnels.IItemTunnel; import net.minecraft.block.BlockState; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.Direction; diff --git a/src/main/java/com/robotgryphon/compactmachines/tunnels/definitions/RedstoneInTunnelDefinition.java b/src/main/java/dev/compactmods/machines/tunnels/definitions/RedstoneInTunnelDefinition.java similarity index 75% rename from src/main/java/com/robotgryphon/compactmachines/tunnels/definitions/RedstoneInTunnelDefinition.java rename to src/main/java/dev/compactmods/machines/tunnels/definitions/RedstoneInTunnelDefinition.java index dd87c9a2..73095ada 100644 --- a/src/main/java/com/robotgryphon/compactmachines/tunnels/definitions/RedstoneInTunnelDefinition.java +++ b/src/main/java/dev/compactmods/machines/tunnels/definitions/RedstoneInTunnelDefinition.java @@ -1,10 +1,10 @@ -package com.robotgryphon.compactmachines.tunnels.definitions; +package dev.compactmods.machines.tunnels.definitions; -import com.robotgryphon.compactmachines.api.tunnels.EnumTunnelSide; -import com.robotgryphon.compactmachines.api.tunnels.ITunnelConnectionInfo; -import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; -import com.robotgryphon.compactmachines.api.tunnels.redstone.IRedstoneReaderTunnel; +import dev.compactmods.machines.api.tunnels.EnumTunnelSide; +import dev.compactmods.machines.api.tunnels.ITunnelConnectionInfo; +import dev.compactmods.machines.api.tunnels.TunnelDefinition; +import dev.compactmods.machines.teleportation.DimensionalPosition; +import dev.compactmods.machines.api.tunnels.redstone.IRedstoneReaderTunnel; import net.minecraft.block.BlockState; import net.minecraft.world.IWorldReader; import net.minecraft.world.server.ServerWorld; diff --git a/src/main/java/com/robotgryphon/compactmachines/tunnels/definitions/RedstoneOutTunnelDefinition.java b/src/main/java/dev/compactmods/machines/tunnels/definitions/RedstoneOutTunnelDefinition.java similarity index 60% rename from src/main/java/com/robotgryphon/compactmachines/tunnels/definitions/RedstoneOutTunnelDefinition.java rename to src/main/java/dev/compactmods/machines/tunnels/definitions/RedstoneOutTunnelDefinition.java index ea553e96..fd3ec649 100644 --- a/src/main/java/com/robotgryphon/compactmachines/tunnels/definitions/RedstoneOutTunnelDefinition.java +++ b/src/main/java/dev/compactmods/machines/tunnels/definitions/RedstoneOutTunnelDefinition.java @@ -1,8 +1,8 @@ -package com.robotgryphon.compactmachines.tunnels.definitions; +package dev.compactmods.machines.tunnels.definitions; -import com.robotgryphon.compactmachines.api.tunnels.ITunnelConnectionInfo; -import com.robotgryphon.compactmachines.api.tunnels.TunnelDefinition; -import com.robotgryphon.compactmachines.api.tunnels.redstone.IRedstoneWriterTunnel; +import dev.compactmods.machines.api.tunnels.ITunnelConnectionInfo; +import dev.compactmods.machines.api.tunnels.TunnelDefinition; +import dev.compactmods.machines.api.tunnels.redstone.IRedstoneWriterTunnel; import java.awt.Color; diff --git a/src/main/java/com/robotgryphon/compactmachines/util/CompactStructureGenerator.java b/src/main/java/dev/compactmods/machines/util/CompactStructureGenerator.java similarity index 93% rename from src/main/java/com/robotgryphon/compactmachines/util/CompactStructureGenerator.java rename to src/main/java/dev/compactmods/machines/util/CompactStructureGenerator.java index 74e55aa7..d4485c12 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/CompactStructureGenerator.java +++ b/src/main/java/dev/compactmods/machines/util/CompactStructureGenerator.java @@ -1,7 +1,7 @@ -package com.robotgryphon.compactmachines.util; +package dev.compactmods.machines.util; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.reference.EnumMachineSize; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.reference.EnumMachineSize; import net.minecraft.block.BlockState; import net.minecraft.util.Direction; import net.minecraft.util.math.AxisAlignedBB; diff --git a/src/main/java/com/robotgryphon/compactmachines/util/LocationUtil.java b/src/main/java/dev/compactmods/machines/util/LocationUtil.java similarity index 87% rename from src/main/java/com/robotgryphon/compactmachines/util/LocationUtil.java rename to src/main/java/dev/compactmods/machines/util/LocationUtil.java index 1acceb20..d282e335 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/LocationUtil.java +++ b/src/main/java/dev/compactmods/machines/util/LocationUtil.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.util; +package dev.compactmods.machines.util; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.vector.Vector3d; diff --git a/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java b/src/main/java/dev/compactmods/machines/util/MathUtil.java similarity index 97% rename from src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java rename to src/main/java/dev/compactmods/machines/util/MathUtil.java index 92b38ea4..2741eff4 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/MathUtil.java +++ b/src/main/java/dev/compactmods/machines/util/MathUtil.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.util; +package dev.compactmods.machines.util; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.ChunkPos; diff --git a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java b/src/main/java/dev/compactmods/machines/util/PlayerUtil.java similarity index 87% rename from src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java rename to src/main/java/dev/compactmods/machines/util/PlayerUtil.java index 08781f5b..5583d269 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java +++ b/src/main/java/dev/compactmods/machines/util/PlayerUtil.java @@ -1,24 +1,24 @@ -package com.robotgryphon.compactmachines.util; +package dev.compactmods.machines.util; import com.mojang.authlib.GameProfile; -import com.robotgryphon.compactmachines.CompactMachines; -import com.robotgryphon.compactmachines.advancement.AdvancementTriggers; -import com.robotgryphon.compactmachines.api.core.Messages; -import com.robotgryphon.compactmachines.block.tiles.CompactMachineTile; -import com.robotgryphon.compactmachines.config.ServerConfig; -import com.robotgryphon.compactmachines.core.Registration; -import com.robotgryphon.compactmachines.data.persistent.MachineConnections; -import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData; -import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; -import com.robotgryphon.compactmachines.data.persistent.CompactRoomData; -import com.robotgryphon.compactmachines.network.CMPacketTargets; -import com.robotgryphon.compactmachines.network.MachinePlayersChangedPacket; -import com.robotgryphon.compactmachines.network.NetworkHandler; -import com.robotgryphon.compactmachines.reference.EnumMachineSize; -import com.robotgryphon.compactmachines.rooms.IRoomHistoryItem; -import com.robotgryphon.compactmachines.rooms.capability.CapabilityRoomHistory; -import com.robotgryphon.compactmachines.rooms.capability.IRoomHistory; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.advancement.AdvancementTriggers; +import dev.compactmods.machines.api.core.Messages; +import dev.compactmods.machines.block.tiles.CompactMachineTile; +import dev.compactmods.machines.config.ServerConfig; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.data.persistent.MachineConnections; +import dev.compactmods.machines.data.player.CompactMachinePlayerData; +import dev.compactmods.machines.data.persistent.CompactMachineData; +import dev.compactmods.machines.data.persistent.CompactRoomData; +import dev.compactmods.machines.network.CMPacketTargets; +import dev.compactmods.machines.network.MachinePlayersChangedPacket; +import dev.compactmods.machines.network.NetworkHandler; +import dev.compactmods.machines.reference.EnumMachineSize; +import dev.compactmods.machines.rooms.IRoomHistoryItem; +import dev.compactmods.machines.rooms.capability.CapabilityRoomHistory; +import dev.compactmods.machines.rooms.capability.IRoomHistory; +import dev.compactmods.machines.teleportation.DimensionalPosition; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.server.MinecraftServer; diff --git a/src/main/java/com/robotgryphon/compactmachines/util/TranslationUtil.java b/src/main/java/dev/compactmods/machines/util/TranslationUtil.java similarity index 97% rename from src/main/java/com/robotgryphon/compactmachines/util/TranslationUtil.java rename to src/main/java/dev/compactmods/machines/util/TranslationUtil.java index 55a949e1..9adf25aa 100644 --- a/src/main/java/com/robotgryphon/compactmachines/util/TranslationUtil.java +++ b/src/main/java/dev/compactmods/machines/util/TranslationUtil.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.util; +package dev.compactmods.machines.util; import net.minecraft.util.ResourceLocation; import net.minecraft.util.Util; diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java b/src/test/java/dev/compactmods/machines/tests/GraphTests.java similarity index 96% rename from src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java rename to src/test/java/dev/compactmods/machines/tests/GraphTests.java index 8728713f..94c17bd8 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/GraphTests.java +++ b/src/test/java/dev/compactmods/machines/tests/GraphTests.java @@ -1,13 +1,13 @@ -package com.robotgryphon.compactmachines.tests; +package dev.compactmods.machines.tests; import com.google.common.graph.Graph; import com.mojang.serialization.DataResult; -import com.robotgryphon.compactmachines.data.codec.CodecExtensions; -import com.robotgryphon.compactmachines.data.graph.CompactMachineConnectionGraph; -import com.robotgryphon.compactmachines.data.graph.CompactMachineNode; -import com.robotgryphon.compactmachines.data.graph.CompactMachineRoomNode; -import com.robotgryphon.compactmachines.data.graph.IMachineGraphNode; -import com.robotgryphon.compactmachines.util.MathUtil; +import dev.compactmods.machines.data.codec.CodecExtensions; +import dev.compactmods.machines.data.graph.CompactMachineConnectionGraph; +import dev.compactmods.machines.data.graph.CompactMachineNode; +import dev.compactmods.machines.data.graph.CompactMachineRoomNode; +import dev.compactmods.machines.data.graph.IMachineGraphNode; +import dev.compactmods.machines.util.MathUtil; import net.minecraft.nbt.*; import net.minecraft.util.math.ChunkPos; import net.minecraftforge.common.util.Constants; diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/MathTests.java b/src/test/java/dev/compactmods/machines/tests/MathTests.java similarity index 93% rename from src/test/java/com/robotgryphon/compactmachines/tests/MathTests.java rename to src/test/java/dev/compactmods/machines/tests/MathTests.java index 39a09eb5..6bfd49db 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/MathTests.java +++ b/src/test/java/dev/compactmods/machines/tests/MathTests.java @@ -1,6 +1,6 @@ -package com.robotgryphon.compactmachines.tests; +package dev.compactmods.machines.tests; -import com.robotgryphon.compactmachines.util.MathUtil; +import dev.compactmods.machines.util.MathUtil; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.ChunkPos; import net.minecraft.util.math.vector.Vector3i; diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/codec/CodecTests.java b/src/test/java/dev/compactmods/machines/tests/codec/CodecTests.java similarity index 88% rename from src/test/java/com/robotgryphon/compactmachines/tests/codec/CodecTests.java rename to src/test/java/dev/compactmods/machines/tests/codec/CodecTests.java index f8cec4c5..7da92e27 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/codec/CodecTests.java +++ b/src/test/java/dev/compactmods/machines/tests/codec/CodecTests.java @@ -1,8 +1,8 @@ -package com.robotgryphon.compactmachines.tests.codec; +package dev.compactmods.machines.tests.codec; import com.mojang.serialization.DataResult; -import com.robotgryphon.compactmachines.data.codec.CodecExtensions; -import com.robotgryphon.compactmachines.reference.EnumMachineSize; +import dev.compactmods.machines.data.codec.CodecExtensions; +import dev.compactmods.machines.reference.EnumMachineSize; import net.minecraft.nbt.INBT; import net.minecraft.nbt.ListNBT; import net.minecraft.nbt.NBTDynamicOps; diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java b/src/test/java/dev/compactmods/machines/tests/minecraft/ExampleTest.java similarity index 88% rename from src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java rename to src/test/java/dev/compactmods/machines/tests/minecraft/ExampleTest.java index b10b9645..4e5148c6 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/minecraft/ExampleTest.java +++ b/src/test/java/dev/compactmods/machines/tests/minecraft/ExampleTest.java @@ -1,4 +1,4 @@ -package com.robotgryphon.compactmachines.tests.minecraft; +package dev.compactmods.machines.tests.minecraft; import net.minecraft.server.MinecraftServer; import net.minecraftforge.fml.server.ServerLifecycleHooks; diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/nbt/MachineExternalDataTests.java b/src/test/java/dev/compactmods/machines/tests/nbt/MachineExternalDataTests.java similarity index 86% rename from src/test/java/com/robotgryphon/compactmachines/tests/nbt/MachineExternalDataTests.java rename to src/test/java/dev/compactmods/machines/tests/nbt/MachineExternalDataTests.java index c9141f67..bbead231 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/nbt/MachineExternalDataTests.java +++ b/src/test/java/dev/compactmods/machines/tests/nbt/MachineExternalDataTests.java @@ -1,16 +1,15 @@ -package com.robotgryphon.compactmachines.tests.nbt; +package dev.compactmods.machines.tests.nbt; import com.mojang.serialization.Codec; import com.mojang.serialization.DataResult; -import com.robotgryphon.compactmachines.data.persistent.CompactMachineData; -import com.robotgryphon.compactmachines.teleportation.DimensionalPosition; -import com.robotgryphon.compactmachines.tests.util.FileHelper; +import dev.compactmods.machines.data.persistent.CompactMachineData; +import dev.compactmods.machines.teleportation.DimensionalPosition; +import dev.compactmods.machines.tests.util.FileHelper; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.NBTDynamicOps; import net.minecraft.util.RegistryKey; import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.ChunkPos; import net.minecraft.util.registry.Registry; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.DisplayName; diff --git a/src/test/java/com/robotgryphon/compactmachines/tests/util/FileHelper.java b/src/test/java/dev/compactmods/machines/tests/util/FileHelper.java similarity index 94% rename from src/test/java/com/robotgryphon/compactmachines/tests/util/FileHelper.java rename to src/test/java/dev/compactmods/machines/tests/util/FileHelper.java index d42caeb8..791f26d8 100644 --- a/src/test/java/com/robotgryphon/compactmachines/tests/util/FileHelper.java +++ b/src/test/java/dev/compactmods/machines/tests/util/FileHelper.java @@ -1,11 +1,10 @@ -package com.robotgryphon.compactmachines.tests.util; +package dev.compactmods.machines.tests.util; import com.google.gson.Gson; import com.google.gson.JsonElement; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.CompressedStreamTools; -import javax.annotation.Nullable; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; From b31aeb6c2e01378b103af1a919e8cec43f67342f Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 14 Aug 2021 01:33:00 -0400 Subject: [PATCH 23/36] New PSD and machine claiming advancements --- src/generated/resources/.cache/cache | 10 ++- .../advancements/claimed_machine_giant.json | 29 ++++++++ .../advancements/claimed_machine_large.json | 29 ++++++++ .../advancements/claimed_machine_max.json | 29 ++++++++ .../advancements/claimed_machine_normal.json | 29 ++++++++ .../advancements/claimed_machine_small.json | 29 ++++++++ .../advancements/claimed_machine_tiny.json | 29 ++++++++ .../advancements/foundations.json | 35 ++++++++++ .../advancements/got_shrinking_device.json | 35 ++++++++++ .../compactmachines/advancements/root.json | 2 +- .../advancement/AdvancementTriggers.java | 23 +++++++ .../trigger/ClaimedMachineTrigger.java | 68 +++++++++++++++++++ .../machines/api/core/Advancements.java | 10 +++ .../datagen/AdvancementGenerator.java | 43 ++++++++++++ .../compactmods/machines/util/PlayerUtil.java | 5 +- .../assets/compactmachines/lang/en_us.json | 18 ++++- 16 files changed, 417 insertions(+), 6 deletions(-) create mode 100644 src/generated/resources/data/compactmachines/advancements/claimed_machine_giant.json create mode 100644 src/generated/resources/data/compactmachines/advancements/claimed_machine_large.json create mode 100644 src/generated/resources/data/compactmachines/advancements/claimed_machine_max.json create mode 100644 src/generated/resources/data/compactmachines/advancements/claimed_machine_normal.json create mode 100644 src/generated/resources/data/compactmachines/advancements/claimed_machine_small.json create mode 100644 src/generated/resources/data/compactmachines/advancements/claimed_machine_tiny.json create mode 100644 src/generated/resources/data/compactmachines/advancements/foundations.json create mode 100644 src/generated/resources/data/compactmachines/advancements/got_shrinking_device.json create mode 100644 src/main/java/dev/compactmods/machines/advancement/trigger/ClaimedMachineTrigger.java diff --git a/src/generated/resources/.cache/cache b/src/generated/resources/.cache/cache index 431f4daa..6e1d57a5 100644 --- a/src/generated/resources/.cache/cache +++ b/src/generated/resources/.cache/cache @@ -13,10 +13,18 @@ bb446af024870e7a07d31a3c78cab75797392cd5 assets/compactmachines/models/tunnels/n 2781d8f8d22db668495872f1bb39e2dd1290ab66 assets/compactmachines/models/tunnels/south.json 955410e7497ca2252d75eac53d02fb96992d94c7 assets/compactmachines/models/tunnels/up.json f8748baf2b48a44db2cf8d3872bd09b54a822560 assets/compactmachines/models/tunnels/west.json +7611e10d6cb874469fee3209687504a964c1b7a5 data/compactmachines/advancements/claimed_machine_giant.json +c221bb570100c820a1fe904064492fcdaf245120 data/compactmachines/advancements/claimed_machine_large.json +82bae3a5d1558f86d39b69a31ef015ca25c64dc3 data/compactmachines/advancements/claimed_machine_max.json +fe844f6dfc795652f9b3c659b72a1edbf1a84438 data/compactmachines/advancements/claimed_machine_normal.json +f4bbe5fccc3b629f578958c90b84cce5776618d0 data/compactmachines/advancements/claimed_machine_small.json +5e06a5ab20a4d26b4301e24457546b618b7cee7c data/compactmachines/advancements/claimed_machine_tiny.json +29a4ead6392a01e2572b8047d84752ea461540e8 data/compactmachines/advancements/foundations.json +e08cdedde718a20284432a33903792518801d66c data/compactmachines/advancements/got_shrinking_device.json 26f679025def0ce9b0a9ec9d0e5f6ee83ea50bc3 data/compactmachines/advancements/how_did_you_get_here.json e012e4b65799a56d195a6324c82e2cdf7a5a91be data/compactmachines/advancements/recipes/compactmachines/personal_shrinking_device.json fd7ccf69e4445ba0a2d7b2cd405ebe2ae85be240 data/compactmachines/advancements/recipes/compactmachines/wall.json -8533fe67af279b20dda70b20dbcb03a20b6c4f23 data/compactmachines/advancements/root.json +2e9d5509d633970b1dd01bd99b535fd107e6e91a data/compactmachines/advancements/root.json fb5c7560898ae604661d0655c2a39e923eb1d4b4 data/compactmachines/loot_tables/blocks/machine_giant.json 056d363f46ab1cc37c16f08428a3d2a9e0dd66d2 data/compactmachines/loot_tables/blocks/machine_large.json 38a7648eb331daf18f5076126f31f31b6021ac51 data/compactmachines/loot_tables/blocks/machine_maximum.json diff --git a/src/generated/resources/data/compactmachines/advancements/claimed_machine_giant.json b/src/generated/resources/data/compactmachines/advancements/claimed_machine_giant.json new file mode 100644 index 00000000..2d773d15 --- /dev/null +++ b/src/generated/resources/data/compactmachines/advancements/claimed_machine_giant.json @@ -0,0 +1,29 @@ +{ + "parent": "compactmachines:got_shrinking_device", + "display": { + "icon": { + "item": "compactmachines:machine_giant" + }, + "title": { + "translate": "advancement.compactmachines.claimed_machine_giant" + }, + "description": { + "translate": "advancement.compactmachines.claimed_machine_giant.desc" + }, + "frame": "task", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { + "claimed_machine": { + "trigger": "compactmachines:claimed_machine_giant", + "conditions": {} + } + }, + "requirements": [ + [ + "claimed_machine" + ] + ] +} \ No newline at end of file diff --git a/src/generated/resources/data/compactmachines/advancements/claimed_machine_large.json b/src/generated/resources/data/compactmachines/advancements/claimed_machine_large.json new file mode 100644 index 00000000..58cd546a --- /dev/null +++ b/src/generated/resources/data/compactmachines/advancements/claimed_machine_large.json @@ -0,0 +1,29 @@ +{ + "parent": "compactmachines:got_shrinking_device", + "display": { + "icon": { + "item": "compactmachines:machine_large" + }, + "title": { + "translate": "advancement.compactmachines.claimed_machine_large" + }, + "description": { + "translate": "advancement.compactmachines.claimed_machine_large.desc" + }, + "frame": "task", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { + "claimed_machine": { + "trigger": "compactmachines:claimed_machine_large", + "conditions": {} + } + }, + "requirements": [ + [ + "claimed_machine" + ] + ] +} \ No newline at end of file diff --git a/src/generated/resources/data/compactmachines/advancements/claimed_machine_max.json b/src/generated/resources/data/compactmachines/advancements/claimed_machine_max.json new file mode 100644 index 00000000..381c1cf2 --- /dev/null +++ b/src/generated/resources/data/compactmachines/advancements/claimed_machine_max.json @@ -0,0 +1,29 @@ +{ + "parent": "compactmachines:got_shrinking_device", + "display": { + "icon": { + "item": "compactmachines:machine_maximum" + }, + "title": { + "translate": "advancement.compactmachines.claimed_machine_max" + }, + "description": { + "translate": "advancement.compactmachines.claimed_machine_max.desc" + }, + "frame": "task", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { + "claimed_machine": { + "trigger": "compactmachines:claimed_machine_max", + "conditions": {} + } + }, + "requirements": [ + [ + "claimed_machine" + ] + ] +} \ No newline at end of file diff --git a/src/generated/resources/data/compactmachines/advancements/claimed_machine_normal.json b/src/generated/resources/data/compactmachines/advancements/claimed_machine_normal.json new file mode 100644 index 00000000..e63cc8b3 --- /dev/null +++ b/src/generated/resources/data/compactmachines/advancements/claimed_machine_normal.json @@ -0,0 +1,29 @@ +{ + "parent": "compactmachines:got_shrinking_device", + "display": { + "icon": { + "item": "compactmachines:machine_normal" + }, + "title": { + "translate": "advancement.compactmachines.claimed_machine_normal" + }, + "description": { + "translate": "advancement.compactmachines.claimed_machine_normal.desc" + }, + "frame": "task", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { + "claimed_machine": { + "trigger": "compactmachines:claimed_machine_normal", + "conditions": {} + } + }, + "requirements": [ + [ + "claimed_machine" + ] + ] +} \ No newline at end of file diff --git a/src/generated/resources/data/compactmachines/advancements/claimed_machine_small.json b/src/generated/resources/data/compactmachines/advancements/claimed_machine_small.json new file mode 100644 index 00000000..261d936e --- /dev/null +++ b/src/generated/resources/data/compactmachines/advancements/claimed_machine_small.json @@ -0,0 +1,29 @@ +{ + "parent": "compactmachines:got_shrinking_device", + "display": { + "icon": { + "item": "compactmachines:machine_small" + }, + "title": { + "translate": "advancement.compactmachines.claimed_machine_small" + }, + "description": { + "translate": "advancement.compactmachines.claimed_machine_small.desc" + }, + "frame": "task", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { + "claimed_machine": { + "trigger": "compactmachines:claimed_machine_small", + "conditions": {} + } + }, + "requirements": [ + [ + "claimed_machine" + ] + ] +} \ No newline at end of file diff --git a/src/generated/resources/data/compactmachines/advancements/claimed_machine_tiny.json b/src/generated/resources/data/compactmachines/advancements/claimed_machine_tiny.json new file mode 100644 index 00000000..56c6e65d --- /dev/null +++ b/src/generated/resources/data/compactmachines/advancements/claimed_machine_tiny.json @@ -0,0 +1,29 @@ +{ + "parent": "compactmachines:got_shrinking_device", + "display": { + "icon": { + "item": "compactmachines:machine_tiny" + }, + "title": { + "translate": "advancement.compactmachines.claimed_machine_tiny" + }, + "description": { + "translate": "advancement.compactmachines.claimed_machine_tiny.desc" + }, + "frame": "task", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { + "claimed_machine": { + "trigger": "compactmachines:claimed_machine_tiny", + "conditions": {} + } + }, + "requirements": [ + [ + "claimed_machine" + ] + ] +} \ No newline at end of file diff --git a/src/generated/resources/data/compactmachines/advancements/foundations.json b/src/generated/resources/data/compactmachines/advancements/foundations.json new file mode 100644 index 00000000..4042749b --- /dev/null +++ b/src/generated/resources/data/compactmachines/advancements/foundations.json @@ -0,0 +1,35 @@ +{ + "parent": "compactmachines:root", + "display": { + "icon": { + "item": "compactmachines:wall" + }, + "title": { + "translate": "advancement.compactmachines.foundations" + }, + "description": { + "translate": "advancement.compactmachines.foundations.desc" + }, + "frame": "task", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { + "obtained_wall": { + "trigger": "minecraft:inventory_changed", + "conditions": { + "items": [ + { + "item": "compactmachines:wall" + } + ] + } + } + }, + "requirements": [ + [ + "obtained_wall" + ] + ] +} \ No newline at end of file diff --git a/src/generated/resources/data/compactmachines/advancements/got_shrinking_device.json b/src/generated/resources/data/compactmachines/advancements/got_shrinking_device.json new file mode 100644 index 00000000..b41b78f0 --- /dev/null +++ b/src/generated/resources/data/compactmachines/advancements/got_shrinking_device.json @@ -0,0 +1,35 @@ +{ + "parent": "compactmachines:root", + "display": { + "icon": { + "item": "compactmachines:personal_shrinking_device" + }, + "title": { + "translate": "advancement.compactmachines.got_shrinking_device" + }, + "description": { + "translate": "advancement.compactmachines.got_shrinking_device.desc" + }, + "frame": "task", + "show_toast": true, + "announce_to_chat": true, + "hidden": false + }, + "criteria": { + "obtained_psd": { + "trigger": "minecraft:inventory_changed", + "conditions": { + "items": [ + { + "item": "compactmachines:personal_shrinking_device" + } + ] + } + } + }, + "requirements": [ + [ + "obtained_psd" + ] + ] +} \ No newline at end of file diff --git a/src/generated/resources/data/compactmachines/advancements/root.json b/src/generated/resources/data/compactmachines/advancements/root.json index ce6906be..4f54aaec 100644 --- a/src/generated/resources/data/compactmachines/advancements/root.json +++ b/src/generated/resources/data/compactmachines/advancements/root.json @@ -12,7 +12,7 @@ "frame": "task", "show_toast": false, "announce_to_chat": false, - "hidden": true, + "hidden": false, "background": "compactmachines:textures/block/wall.png" }, "criteria": { diff --git a/src/main/java/dev/compactmods/machines/advancement/AdvancementTriggers.java b/src/main/java/dev/compactmods/machines/advancement/AdvancementTriggers.java index dcb60909..d8e33f53 100644 --- a/src/main/java/dev/compactmods/machines/advancement/AdvancementTriggers.java +++ b/src/main/java/dev/compactmods/machines/advancement/AdvancementTriggers.java @@ -1,11 +1,34 @@ package dev.compactmods.machines.advancement; +import dev.compactmods.machines.advancement.trigger.ClaimedMachineTrigger; import dev.compactmods.machines.advancement.trigger.HowDidYouGetHereTrigger; +import dev.compactmods.machines.api.core.Advancements; +import dev.compactmods.machines.reference.EnumMachineSize; import net.minecraft.advancements.CriteriaTriggers; public class AdvancementTriggers { public static final HowDidYouGetHereTrigger HOW_DID_YOU_GET_HERE = CriteriaTriggers.register(new HowDidYouGetHereTrigger()); + public static final ClaimedMachineTrigger CLAIMED_TINY = CriteriaTriggers.register(new ClaimedMachineTrigger(Advancements.CLAIMED_TINY_MACHINE)); + public static final ClaimedMachineTrigger CLAIMED_SMALL = CriteriaTriggers.register(new ClaimedMachineTrigger(Advancements.CLAIMED_SMALL_MACHINE)); + public static final ClaimedMachineTrigger CLAIMED_NORMAL = CriteriaTriggers.register(new ClaimedMachineTrigger(Advancements.CLAIMED_NORMAL_MACHINE)); + public static final ClaimedMachineTrigger CLAIMED_LARGE = CriteriaTriggers.register(new ClaimedMachineTrigger(Advancements.CLAIMED_LARGE_MACHINE)); + public static final ClaimedMachineTrigger CLAIMED_GIANT = CriteriaTriggers.register(new ClaimedMachineTrigger(Advancements.CLAIMED_GIANT_MACHINE)); + public static final ClaimedMachineTrigger CLAIMED_MAX = CriteriaTriggers.register(new ClaimedMachineTrigger(Advancements.CLAIMED_MAX_MACHINE)); + public static void init() {} + + public static ClaimedMachineTrigger getTriggerForMachineClaim(EnumMachineSize machineSize) { + switch (machineSize) { + case TINY: return CLAIMED_TINY; + case SMALL: return CLAIMED_SMALL; + case NORMAL: return CLAIMED_NORMAL; + case LARGE: return CLAIMED_LARGE; + case GIANT: return CLAIMED_GIANT; + case MAXIMUM: return CLAIMED_MAX; + } + + return CLAIMED_TINY; + } } diff --git a/src/main/java/dev/compactmods/machines/advancement/trigger/ClaimedMachineTrigger.java b/src/main/java/dev/compactmods/machines/advancement/trigger/ClaimedMachineTrigger.java new file mode 100644 index 00000000..1d834382 --- /dev/null +++ b/src/main/java/dev/compactmods/machines/advancement/trigger/ClaimedMachineTrigger.java @@ -0,0 +1,68 @@ +package dev.compactmods.machines.advancement.trigger; + +import com.google.gson.JsonObject; +import dev.compactmods.machines.advancement.GenericAdvancementTriggerListener; +import dev.compactmods.machines.advancement.GenericAdvancementTriggerListenerList; +import dev.compactmods.machines.api.core.Advancements; +import net.minecraft.advancements.ICriterionTrigger; +import net.minecraft.advancements.PlayerAdvancements; +import net.minecraft.advancements.criterion.CriterionInstance; +import net.minecraft.advancements.criterion.EntityPredicate; +import net.minecraft.entity.player.ServerPlayerEntity; +import net.minecraft.loot.ConditionArrayParser; +import net.minecraft.util.ResourceLocation; + +public class ClaimedMachineTrigger implements ICriterionTrigger { + + private final GenericAdvancementTriggerListenerList listeners = new GenericAdvancementTriggerListenerList<>(); + private final ResourceLocation advancementId; + + public ClaimedMachineTrigger(ResourceLocation advancementId) { + this.advancementId = advancementId; + } + + @Override + public ResourceLocation getId() { + return advancementId; + } + + @Override + public void addPlayerListener(PlayerAdvancements advancements, Listener list) { + listeners.addPlayerListener(advancements, list); + } + + @Override + public void removePlayerListener(PlayerAdvancements advancements, Listener list) { + listeners.removePlayerListener(advancements, list); + } + + @Override + public void removePlayerListeners(PlayerAdvancements advancements) { + listeners.removePlayerListeners(advancements); + } + + @Override + public Instance createInstance(JsonObject json, ConditionArrayParser conditions) { + return new Instance(this.advancementId, EntityPredicate.AndPredicate.fromJson(json, "player", conditions)); + } + + public void trigger(ServerPlayerEntity player) { + final GenericAdvancementTriggerListener listeners = this.listeners.getListeners(player); + if(listeners != null) + listeners.trigger(); + } + + public static class Instance extends CriterionInstance { + + private final ResourceLocation advId; + + public Instance(ResourceLocation advId, EntityPredicate.AndPredicate player) { + super(advId, player); + this.advId = advId; + } + + public static Instance create(ResourceLocation advancement) { + return new Instance(advancement, EntityPredicate.AndPredicate.ANY); + } + } +} diff --git a/src/main/java/dev/compactmods/machines/api/core/Advancements.java b/src/main/java/dev/compactmods/machines/api/core/Advancements.java index 7722b1ad..d5a2569e 100644 --- a/src/main/java/dev/compactmods/machines/api/core/Advancements.java +++ b/src/main/java/dev/compactmods/machines/api/core/Advancements.java @@ -5,4 +5,14 @@ public class Advancements { public static final ResourceLocation HOW_DID_YOU_GET_HERE = new ResourceLocation(Constants.MOD_ID, "how_did_you_get_here"); public static final ResourceLocation ROOT = new ResourceLocation(Constants.MOD_ID, "root"); + public static final ResourceLocation FOUNDATIONS = new ResourceLocation(Constants.MOD_ID, "foundations"); + + public static final ResourceLocation GOT_SHRINKING_DEVICE = new ResourceLocation(Constants.MOD_ID, "got_shrinking_device"); + + public static final ResourceLocation CLAIMED_TINY_MACHINE = new ResourceLocation(Constants.MOD_ID, "claimed_machine_tiny"); + public static final ResourceLocation CLAIMED_SMALL_MACHINE = new ResourceLocation(Constants.MOD_ID, "claimed_machine_small"); + public static final ResourceLocation CLAIMED_NORMAL_MACHINE = new ResourceLocation(Constants.MOD_ID, "claimed_machine_normal"); + public static final ResourceLocation CLAIMED_LARGE_MACHINE = new ResourceLocation(Constants.MOD_ID, "claimed_machine_large"); + public static final ResourceLocation CLAIMED_GIANT_MACHINE = new ResourceLocation(Constants.MOD_ID, "claimed_machine_giant"); + public static final ResourceLocation CLAIMED_MAX_MACHINE = new ResourceLocation(Constants.MOD_ID, "claimed_machine_max"); } diff --git a/src/main/java/dev/compactmods/machines/datagen/AdvancementGenerator.java b/src/main/java/dev/compactmods/machines/datagen/AdvancementGenerator.java index db9e0519..45f2e1ca 100644 --- a/src/main/java/dev/compactmods/machines/datagen/AdvancementGenerator.java +++ b/src/main/java/dev/compactmods/machines/datagen/AdvancementGenerator.java @@ -4,19 +4,23 @@ import java.nio.file.Path; import java.util.Set; import java.util.function.Consumer; +import java.util.function.Supplier; import com.google.common.collect.Sets; import com.google.gson.Gson; import com.google.gson.GsonBuilder; import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.advancement.trigger.ClaimedMachineTrigger; import dev.compactmods.machines.advancement.trigger.HowDidYouGetHereTrigger; import dev.compactmods.machines.api.core.Advancements; import dev.compactmods.machines.core.Registration; import dev.compactmods.machines.util.TranslationUtil; import net.minecraft.advancements.*; import net.minecraft.advancements.criterion.ImpossibleTrigger; +import net.minecraft.advancements.criterion.InventoryChangeTrigger; import net.minecraft.data.DataGenerator; import net.minecraft.data.DirectoryCache; import net.minecraft.data.IDataProvider; +import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.util.ResourceLocation; @@ -78,6 +82,45 @@ private void generateAdvancements(Consumer consumer) { .toast(false).hidden(true) .build()) .save(consumer, Advancements.HOW_DID_YOU_GET_HERE.toString()); + + final Advancement wall = Advancement.Builder.advancement() + .parent(root) + .addCriterion("obtained_wall", InventoryChangeTrigger.Instance.hasItems(Registration.BLOCK_BREAKABLE_WALL.get())) + .display(new DisplayBuilder() + .frame(FrameType.TASK) + .item(new ItemStack(Registration.BLOCK_BREAKABLE_WALL.get())) + .id(Advancements.FOUNDATIONS) + .build()) + .save(consumer, Advancements.FOUNDATIONS.toString()); + + final Advancement psd = Advancement.Builder.advancement() + .parent(root) + .addCriterion("obtained_psd", InventoryChangeTrigger.Instance.hasItems(Registration.PERSONAL_SHRINKING_DEVICE.get())) + .display(new DisplayBuilder() + .frame(FrameType.TASK) + .item(new ItemStack(Registration.PERSONAL_SHRINKING_DEVICE.get())) + .id(Advancements.GOT_SHRINKING_DEVICE) + .build()) + .save(consumer, Advancements.GOT_SHRINKING_DEVICE.toString()); + + final Advancement tiny = machineAdvancement(consumer, psd, Advancements.CLAIMED_TINY_MACHINE, Registration.MACHINE_BLOCK_ITEM_TINY); + final Advancement small = machineAdvancement(consumer, psd, Advancements.CLAIMED_SMALL_MACHINE, Registration.MACHINE_BLOCK_ITEM_SMALL); + final Advancement normal = machineAdvancement(consumer, psd, Advancements.CLAIMED_NORMAL_MACHINE, Registration.MACHINE_BLOCK_ITEM_NORMAL); + final Advancement large = machineAdvancement(consumer, psd, Advancements.CLAIMED_LARGE_MACHINE, Registration.MACHINE_BLOCK_ITEM_LARGE); + final Advancement giant = machineAdvancement(consumer, psd, Advancements.CLAIMED_GIANT_MACHINE, Registration.MACHINE_BLOCK_ITEM_GIANT); + final Advancement max = machineAdvancement(consumer, psd, Advancements.CLAIMED_MAX_MACHINE, Registration.MACHINE_BLOCK_ITEM_MAXIMUM); + } + + private Advancement machineAdvancement(Consumer consumer, Advancement root, ResourceLocation advancement, Supplier item) { + return Advancement.Builder.advancement() + .parent(root) + .addCriterion("claimed_machine", ClaimedMachineTrigger.Instance.create(advancement)) + .display(new DisplayBuilder() + .frame(FrameType.TASK) + .item(new ItemStack(item.get())) + .id(advancement) + .build()) + .save(consumer, advancement.toString()); } @Override diff --git a/src/main/java/dev/compactmods/machines/util/PlayerUtil.java b/src/main/java/dev/compactmods/machines/util/PlayerUtil.java index 5583d269..e25f0daf 100644 --- a/src/main/java/dev/compactmods/machines/util/PlayerUtil.java +++ b/src/main/java/dev/compactmods/machines/util/PlayerUtil.java @@ -134,12 +134,11 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl sp.z, (float) sr.y, (float) sr.x); - }); - // TODO - Move machine generation to new method + AdvancementTriggers.getTriggerForMachineClaim(size).trigger(serverPlayer); + }); } - // TODO - Overhaul this to handle nested machines public static void teleportPlayerOutOfMachine(ServerWorld world, @Nonnull ServerPlayerEntity serverPlayer) { MinecraftServer serv = world.getServer(); diff --git a/src/main/resources/assets/compactmachines/lang/en_us.json b/src/main/resources/assets/compactmachines/lang/en_us.json index e6acd8b2..c5d1ed9f 100644 --- a/src/main/resources/assets/compactmachines/lang/en_us.json +++ b/src/main/resources/assets/compactmachines/lang/en_us.json @@ -58,5 +58,21 @@ "advancement.compactmachines.root": "Compact Machines", "advancement.compactmachines.root.desc": "", "advancement.compactmachines.how_did_you_get_here": "How Did You Get Here?!", - "advancement.compactmachines.how_did_you_get_here.desc": "Manage to trap yourself inside a machine room." + "advancement.compactmachines.how_did_you_get_here.desc": "Manage to trap yourself inside a machine room.", + "advancement.compactmachines.foundations": "Foundations", + "advancement.compactmachines.foundations.desc": "Obtain a breakable wall block.", + "advancement.compactmachines.got_shrinking_device": "Personal Shrinking Device", + "advancement.compactmachines.got_shrinking_device.desc": "Obtain a Personal Shrinking Device.", + "advancement.compactmachines.claimed_machine_tiny": "Small Spaces, Big Ideas", + "advancement.compactmachines.claimed_machine_tiny.desc": "Claim a tiny compact machine.", + "advancement.compactmachines.claimed_machine_small": "I Can Breathe", + "advancement.compactmachines.claimed_machine_small.desc": "Claim a small compact machine.", + "advancement.compactmachines.claimed_machine_normal": "Bigger on the Inside", + "advancement.compactmachines.claimed_machine_normal.desc": "Claim a normal compact machine.", + "advancement.compactmachines.claimed_machine_large": "Room to Grow", + "advancement.compactmachines.claimed_machine_large.desc": "Claim a large compact machine.", + "advancement.compactmachines.claimed_machine_giant": "Got Enough Space?", + "advancement.compactmachines.claimed_machine_giant.desc": "Claim a giant compact machine.", + "advancement.compactmachines.claimed_machine_max": "Room for Activities!", + "advancement.compactmachines.claimed_machine_max.desc": "Claim a maximum compact machine." } \ No newline at end of file From 1852e8a9cdd476f4c249c478520e8ffee755e6f0 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 14 Aug 2021 23:11:52 -0400 Subject: [PATCH 24/36] Multilevel player history --- .../block/tiles/CompactMachineTile.java | 46 +++--- .../data/player/CompactMachinePlayerData.java | 58 -------- .../data/player/IPlayerHistoryNode.java | 5 - .../data/player/PlayerMachineHistory.java | 18 --- .../rooms/capability/CMRoomHistory.java | 11 +- .../rooms/capability/IRoomHistory.java | 3 +- .../rooms/{ => history}/IRoomHistoryItem.java | 2 +- .../rooms/history/PlayerRoomHistoryItem.java | 24 +++ .../teleportation/DimensionalPosition.java | 9 +- .../compactmods/machines/util/PlayerUtil.java | 24 ++- .../assets/compactmachines/lang/en_us.json | 1 + .../assets/compactmachines/lang/en_us.lang | 138 ------------------ 12 files changed, 77 insertions(+), 262 deletions(-) delete mode 100644 src/main/java/dev/compactmods/machines/data/player/CompactMachinePlayerData.java delete mode 100644 src/main/java/dev/compactmods/machines/data/player/IPlayerHistoryNode.java delete mode 100644 src/main/java/dev/compactmods/machines/data/player/PlayerMachineHistory.java rename src/main/java/dev/compactmods/machines/rooms/{ => history}/IRoomHistoryItem.java (78%) create mode 100644 src/main/java/dev/compactmods/machines/rooms/history/PlayerRoomHistoryItem.java delete mode 100644 src/main/resources/assets/compactmachines/lang/en_us.lang diff --git a/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java b/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java index 269efd0f..d3a23648 100644 --- a/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java +++ b/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java @@ -1,16 +1,21 @@ package dev.compactmods.machines.block.tiles; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.util.HashSet; +import java.util.Optional; +import java.util.Set; +import java.util.UUID; +import dev.compactmods.machines.api.tunnels.ICapableTunnel; +import dev.compactmods.machines.api.tunnels.TunnelDefinition; import dev.compactmods.machines.config.ServerConfig; import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.data.persistent.CompactMachineData; import dev.compactmods.machines.data.persistent.CompactRoomData; import dev.compactmods.machines.data.persistent.MachineConnections; -import dev.compactmods.machines.data.player.CompactMachinePlayerData; -import dev.compactmods.machines.data.persistent.CompactMachineData; import dev.compactmods.machines.reference.Reference; -import dev.compactmods.machines.api.tunnels.TunnelDefinition; import dev.compactmods.machines.teleportation.DimensionalPosition; import dev.compactmods.machines.tunnels.TunnelHelper; -import dev.compactmods.machines.api.tunnels.ICapableTunnel; import net.minecraft.block.BlockState; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.ListNBT; @@ -29,10 +34,6 @@ import net.minecraftforge.common.util.Constants; import net.minecraftforge.common.util.LazyOptional; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import java.util.*; - public class CompactMachineTile extends TileEntity implements ICapabilityProvider, ITickableTileEntity { public int machineId = -1; private boolean initialized = false; @@ -44,14 +45,10 @@ public class CompactMachineTile extends TileEntity implements ICapabilityProvide protected boolean locked = false; protected Set playerWhiteList; - @Nullable - private CompactMachinePlayerData playerData; - public CompactMachineTile() { super(Registration.MACHINE_TILE_ENTITY.get()); playerWhiteList = new HashSet<>(); - playerData = null; } @Override @@ -188,18 +185,19 @@ public CompoundNBT getUpdateTag() { base.putInt("machine", this.machineId); if (level instanceof ServerWorld) { - Optional playerData = Optional.empty(); - try { - CompactMachinePlayerData psd = CompactMachinePlayerData.get(level.getServer()); - // psd = psd.getPlayersInside(this.machineId); - } catch (Exception e) { - e.printStackTrace(); - } - - playerData.ifPresent(data -> { - CompoundNBT playerNbt = data.serializeNBT(); - base.put("players", playerNbt); - }); + // TODO - Internal player list +// Optional playerData = Optional.empty(); +// try { +// CompactMachinePlayerData psd = CompactMachinePlayerData.get(level.getServer()); +// // psd = psd.getPlayersInside(this.machineId); +// } catch (Exception e) { +// e.printStackTrace(); +// } +// +// playerData.ifPresent(data -> { +// CompoundNBT playerNbt = data.serializeNBT(); +// base.put("players", playerNbt); +// }); if (this.owner != null) base.putUUID("owner", this.owner); diff --git a/src/main/java/dev/compactmods/machines/data/player/CompactMachinePlayerData.java b/src/main/java/dev/compactmods/machines/data/player/CompactMachinePlayerData.java deleted file mode 100644 index ebf20129..00000000 --- a/src/main/java/dev/compactmods/machines/data/player/CompactMachinePlayerData.java +++ /dev/null @@ -1,58 +0,0 @@ -package dev.compactmods.machines.data.player; - -import com.google.common.graph.GraphBuilder; -import com.google.common.graph.MutableGraph; -import dev.compactmods.machines.CompactMachines; -import dev.compactmods.machines.core.Registration; -import net.minecraft.nbt.*; -import net.minecraft.server.MinecraftServer; -import net.minecraft.world.server.ServerWorld; -import net.minecraft.world.storage.DimensionSavedDataManager; -import net.minecraft.world.storage.WorldSavedData; - -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import java.util.*; - -/** - * Holds basic information about players inside a compact machine. - */ -public class CompactMachinePlayerData extends WorldSavedData { - - public static final String DATA_NAME = "players"; - - public MutableGraph history; - private HashMap lookup; - - protected CompactMachinePlayerData() { - super(DATA_NAME); - this.history = GraphBuilder - .directed() - .build(); - - this.lookup = new HashMap<>(0); - } - - @Nullable - public static CompactMachinePlayerData get(MinecraftServer server) { - ServerWorld compactWorld = server.getLevel(Registration.COMPACT_DIMENSION); - if (compactWorld == null) { - CompactMachines.LOGGER.error("No compact dimension found. Report this."); - return null; - } - - DimensionSavedDataManager sd = compactWorld.getDataStorage(); - return sd.computeIfAbsent(CompactMachinePlayerData::new, DATA_NAME); - } - - @Override - public void load(CompoundNBT nbt) { - - } - - @Override - @Nonnull - public CompoundNBT save(CompoundNBT nbt) { - return nbt; - } -} diff --git a/src/main/java/dev/compactmods/machines/data/player/IPlayerHistoryNode.java b/src/main/java/dev/compactmods/machines/data/player/IPlayerHistoryNode.java deleted file mode 100644 index 2272f031..00000000 --- a/src/main/java/dev/compactmods/machines/data/player/IPlayerHistoryNode.java +++ /dev/null @@ -1,5 +0,0 @@ -package dev.compactmods.machines.data.player; - -public interface IPlayerHistoryNode { - -} diff --git a/src/main/java/dev/compactmods/machines/data/player/PlayerMachineHistory.java b/src/main/java/dev/compactmods/machines/data/player/PlayerMachineHistory.java deleted file mode 100644 index 06c7aae1..00000000 --- a/src/main/java/dev/compactmods/machines/data/player/PlayerMachineHistory.java +++ /dev/null @@ -1,18 +0,0 @@ -package dev.compactmods.machines.data.player; - -import dev.compactmods.machines.teleportation.DimensionalPosition; - -import java.util.Deque; - -public class PlayerMachineHistory { - - protected Deque history; - - public DimensionalPosition getLastEntryPoint() { - return history.getLast(); - } - - public DimensionalPosition getOrigin() { - return history.getFirst(); - } -} diff --git a/src/main/java/dev/compactmods/machines/rooms/capability/CMRoomHistory.java b/src/main/java/dev/compactmods/machines/rooms/capability/CMRoomHistory.java index d09a6c3d..9d571cea 100644 --- a/src/main/java/dev/compactmods/machines/rooms/capability/CMRoomHistory.java +++ b/src/main/java/dev/compactmods/machines/rooms/capability/CMRoomHistory.java @@ -2,7 +2,7 @@ import java.util.ArrayDeque; import java.util.Deque; -import dev.compactmods.machines.rooms.IRoomHistoryItem; +import dev.compactmods.machines.rooms.history.IRoomHistoryItem; public class CMRoomHistory implements IRoomHistory{ @@ -12,6 +12,11 @@ public CMRoomHistory() { history = new ArrayDeque<>(10); } + @Override + public void clear() { + history.clear(); + } + @Override public boolean hasHistory() { return !history.isEmpty(); @@ -19,12 +24,12 @@ public boolean hasHistory() { @Override public IRoomHistoryItem peek() { - return history.peek(); + return history.peekLast(); } @Override public IRoomHistoryItem pop() { - return history.pop(); + return history.removeLast(); } @Override diff --git a/src/main/java/dev/compactmods/machines/rooms/capability/IRoomHistory.java b/src/main/java/dev/compactmods/machines/rooms/capability/IRoomHistory.java index 033f6d32..2fde1618 100644 --- a/src/main/java/dev/compactmods/machines/rooms/capability/IRoomHistory.java +++ b/src/main/java/dev/compactmods/machines/rooms/capability/IRoomHistory.java @@ -1,9 +1,10 @@ package dev.compactmods.machines.rooms.capability; -import dev.compactmods.machines.rooms.IRoomHistoryItem; +import dev.compactmods.machines.rooms.history.IRoomHistoryItem; public interface IRoomHistory { + void clear(); boolean hasHistory(); IRoomHistoryItem peek(); IRoomHistoryItem pop(); diff --git a/src/main/java/dev/compactmods/machines/rooms/IRoomHistoryItem.java b/src/main/java/dev/compactmods/machines/rooms/history/IRoomHistoryItem.java similarity index 78% rename from src/main/java/dev/compactmods/machines/rooms/IRoomHistoryItem.java rename to src/main/java/dev/compactmods/machines/rooms/history/IRoomHistoryItem.java index 8785005a..1b583cdc 100644 --- a/src/main/java/dev/compactmods/machines/rooms/IRoomHistoryItem.java +++ b/src/main/java/dev/compactmods/machines/rooms/history/IRoomHistoryItem.java @@ -1,4 +1,4 @@ -package dev.compactmods.machines.rooms; +package dev.compactmods.machines.rooms.history; import dev.compactmods.machines.teleportation.DimensionalPosition; diff --git a/src/main/java/dev/compactmods/machines/rooms/history/PlayerRoomHistoryItem.java b/src/main/java/dev/compactmods/machines/rooms/history/PlayerRoomHistoryItem.java new file mode 100644 index 00000000..1982e197 --- /dev/null +++ b/src/main/java/dev/compactmods/machines/rooms/history/PlayerRoomHistoryItem.java @@ -0,0 +1,24 @@ +package dev.compactmods.machines.rooms.history; + +import dev.compactmods.machines.teleportation.DimensionalPosition; + +public class PlayerRoomHistoryItem implements IRoomHistoryItem { + + private final DimensionalPosition entry; + private final int machine; + + public PlayerRoomHistoryItem(DimensionalPosition entry, int machine) { + this.entry = entry; + this.machine = machine; + } + + @Override + public DimensionalPosition getEntryLocation() { + return entry; + } + + @Override + public int getMachine() { + return machine; + } +} diff --git a/src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java b/src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java index ba0df49b..7d06ff24 100644 --- a/src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java +++ b/src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java @@ -5,6 +5,8 @@ import com.mojang.serialization.codecs.RecordCodecBuilder; import dev.compactmods.machines.CompactMachines; import dev.compactmods.machines.data.codec.CodecExtensions; +import net.minecraft.entity.LivingEntity; +import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.INBT; import net.minecraft.nbt.NBTDynamicOps; @@ -34,7 +36,8 @@ public class DimensionalPosition implements INBTSerializable { CodecExtensions.VECTOR3D.optionalFieldOf("rot", Vector3d.ZERO).forGetter(DimensionalPosition::getRotation) ).apply(i, DimensionalPosition::new)); - private DimensionalPosition() { } + private DimensionalPosition() { + } public DimensionalPosition(RegistryKey world, BlockPos positionBlock) { this(world, Vector3d.ZERO, Vector3d.ZERO); @@ -54,6 +57,10 @@ public DimensionalPosition(RegistryKey dim, Vector3d pos, Vector3d rotati this.rotation = rotation; } + public static DimensionalPosition fromEntity(LivingEntity entity) { + return new DimensionalPosition(entity.level.dimension(), entity.position()); + } + public Optional getWorld(@Nonnull MinecraftServer server) { return Optional.ofNullable(server.getLevel(this.dimension)); } diff --git a/src/main/java/dev/compactmods/machines/util/PlayerUtil.java b/src/main/java/dev/compactmods/machines/util/PlayerUtil.java index e25f0daf..2295eba1 100644 --- a/src/main/java/dev/compactmods/machines/util/PlayerUtil.java +++ b/src/main/java/dev/compactmods/machines/util/PlayerUtil.java @@ -8,16 +8,16 @@ import dev.compactmods.machines.config.ServerConfig; import dev.compactmods.machines.core.Registration; import dev.compactmods.machines.data.persistent.MachineConnections; -import dev.compactmods.machines.data.player.CompactMachinePlayerData; import dev.compactmods.machines.data.persistent.CompactMachineData; import dev.compactmods.machines.data.persistent.CompactRoomData; import dev.compactmods.machines.network.CMPacketTargets; import dev.compactmods.machines.network.MachinePlayersChangedPacket; import dev.compactmods.machines.network.NetworkHandler; import dev.compactmods.machines.reference.EnumMachineSize; -import dev.compactmods.machines.rooms.IRoomHistoryItem; +import dev.compactmods.machines.rooms.history.IRoomHistoryItem; import dev.compactmods.machines.rooms.capability.CapabilityRoomHistory; import dev.compactmods.machines.rooms.capability.IRoomHistory; +import dev.compactmods.machines.rooms.history.PlayerRoomHistoryItem; import dev.compactmods.machines.teleportation.DimensionalPosition; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.entity.player.ServerPlayerEntity; @@ -88,6 +88,7 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl // Generate a new machine inside and update the tile CompactStructureGenerator.generateCompactStructure(compactWorld, size, newCenter); + ChunkPos machineChunk = new ChunkPos(newCenter); tile.setMachineId(nextId); @@ -142,9 +143,6 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl public static void teleportPlayerOutOfMachine(ServerWorld world, @Nonnull ServerPlayerEntity serverPlayer) { MinecraftServer serv = world.getServer(); - CompactMachinePlayerData playerData = CompactMachinePlayerData.get(serv); - if (playerData == null) - return; final LazyOptional history = serverPlayer.getCapability(CapabilityRoomHistory.HISTORY_CAPABILITY); @@ -170,11 +168,13 @@ public static void teleportPlayerOutOfMachine(ServerWorld world, @Nonnull Server serverPlayer.teleportTo(w, worldPos.x(), worldPos.y(), worldPos.z(), (float) entryRot.y, (float) entryRot.x); } else { + hist.clear(); teleportPlayerToRespawnOrOverworld(serv, serverPlayer); } } else { howDidYouGetThere(serverPlayer); + hist.clear(); teleportPlayerToRespawnOrOverworld(serv, serverPlayer); } @@ -199,7 +199,7 @@ private static void howDidYouGetThere(@Nonnull ServerPlayerEntity serverPlayer) ); } - private static void teleportPlayerToRespawnOrOverworld(MinecraftServer serv, @Nonnull ServerPlayerEntity player) { + public static void teleportPlayerToRespawnOrOverworld(MinecraftServer serv, @Nonnull ServerPlayerEntity player) { ServerWorld level = Optional.ofNullable(serv.getLevel(player.getRespawnDimension())).orElse(serv.overworld()); Vector3d worldPos = LocationUtil.blockPosToVector(level.getSharedSpawnPos()); @@ -214,10 +214,6 @@ public static void addPlayerToMachine(ServerPlayerEntity serverPlayer, BlockPos if (serv == null) return; - CompactMachinePlayerData playerData = CompactMachinePlayerData.get(serv); - if (playerData == null) - return; - CompactMachineTile tile = (CompactMachineTile) serverPlayer.getLevel().getBlockEntity(machinePos); if (tile == null) return; @@ -226,9 +222,11 @@ public static void addPlayerToMachine(ServerPlayerEntity serverPlayer, BlockPos final Chunk chunk = serv.getLevel(Registration.COMPACT_DIMENSION) .getChunk(mChunk.x, mChunk.z); - // TODO - Add player to machine data - // playerData.addPlayer(serverPlayer, mChunk); - playerData.setDirty(); + serverPlayer.getCapability(CapabilityRoomHistory.HISTORY_CAPABILITY) + .ifPresent(hist -> { + DimensionalPosition pos = DimensionalPosition.fromEntity(serverPlayer); + hist.addHistory(new PlayerRoomHistoryItem(pos, tile.machineId)); + }); MachinePlayersChangedPacket p = MachinePlayersChangedPacket.Builder.create(serv) .forMachine(mChunk) diff --git a/src/main/resources/assets/compactmachines/lang/en_us.json b/src/main/resources/assets/compactmachines/lang/en_us.json index c5d1ed9f..d007b79b 100644 --- a/src/main/resources/assets/compactmachines/lang/en_us.json +++ b/src/main/resources/assets/compactmachines/lang/en_us.json @@ -11,6 +11,7 @@ "tooltip.compactmachines.details.psd": "Used as in-game documentation and to enter Compact Machines.", "tooltip.compactmachines.details.solid_wall": "Warning! Unbreakable for non-creative players!", + "message.compactmachines.new_machine": "New Machine", "message.compactmachines.cannot_enter": "You fumble with the shrinking device, to no avail. It refuses to work.", "message.compactmachines.spawnpoint_set": "New spawn point set.", "message.compactmachines.no_machine_data": "No machine data loaded; report this.", diff --git a/src/main/resources/assets/compactmachines/lang/en_us.lang b/src/main/resources/assets/compactmachines/lang/en_us.lang deleted file mode 100644 index 9a1b57df..00000000 --- a/src/main/resources/assets/compactmachines/lang/en_us.lang +++ /dev/null @@ -1,138 +0,0 @@ -generator.compactsky=Compact Sky - -tile.compactmachines.tunnel.name=Tunnel -tile.compactmachines.redstonetunnel.name=Redstone Tunnel -tile.compactmachines.fieldprojector.name=Miniaturization Field Projector - -item.compactmachines.psd.spawnpoint_set=Entry point set! - -hint.compactmachines.missing_opposite_projector=Missing opposite field projector! It is required to determine the field size! -hint.compactmachines.missing_projector_at=Missing field projector at %d,%d,%d -hint.compactmachines.currently_crafting=Currently crafting: %s (progress: %s%%) -hint.compactmachines.no_recipe_found=No valid recipe found -hint.compactmachines.found_recipe_for=Recipe for: %s -hint.compactmachines.invalid_block_in_field=Invalid block in field area @ %d,%d,%d: %s -hint.compactmachines.cant_sleep_here=You can not sleep in the Compact Machines dimension -hint.compactmachines.bed_position_set=Respawn position set to this Machine -hint.compactmachines.not_permitted_to_enter=You do not have permission to enter this machine - -hint.compactmachines.skyworld.no_block_breaking=You can not break any blocks in the Compact Hub! -hint.compactmachines.skyworld.no_block_placing=You can not place any blocks in the Compact Hub! -hint.compactmachines.skyworld.only_one_machine_claim=You can only claim a single Compact Machine in the hub! - -top.compactmachines.currently_crafting=Crafting: -top.compactmachines.found_recipe_for=Recipe for: - -tooltip.compactmachines.machine.coords=Machine: -tooltip.compactmachines.machine.coords.unused=Unused -tooltip.compactmachines.machine.schema=Schema: -tooltip.compactmachines.machine.stopitsoaryn=Feedbackloop detected - -tooltip.compactmachines.fieldprojector.hint=Place 4 opposite of each other to create a Miniaturization Crafting field. Right click to get hints where the next projector needs to be! -tooltip.compactmachines.tunneltool.hint=Used to connect Wall blocks with outside Compact Machine faces. -tooltip.compactmachines.redstonetunneltool.hint=Used to transfer redstone signals between wall blocks and outside Compact Machine faces. - -tooltip.compactmachines.lockforotherplayers.checkbox=Lock for other players - -tooltip.compactmachines.jei.crafting_trigger=Throw this into the miniaturization field to start the crafting process. -tooltip.compactmachines.jei.shape=Use these to build the multiblock - -compactmachines.jei.category.multiblock_miniaturization=Multiblock Miniaturization - - -commands.compactmachines.usage=/compactmachines [subcommand, leave empty for list of commands] - -commands.compactmachines.available=Available sub-commands: -commands.compactmachines.denied=You do not have the permission to use this command. - -commands.compactmachines.schema.description=Save/load the contents of machines -commands.compactmachines.schema.save.usage=/compactmachines schema save -commands.compactmachines.schema.save.description=Saves the machine you are in to disk -commands.compactmachines.schema.save.exception.not_in_machine_dimension=You must be in the machine dimension for this command to work. -commands.compactmachines.schema.save.exception.invalid_file=Could not open file for writing! Schema is not saved! -commands.compactmachines.schema.save.exception.not_serializable=Could not serialize machine! Schema is not saved! -commands.compactmachines.schema.save.success=Wrote schema to file: %s - -commands.compactmachines.schema.load.usage=/compactmachines schema load -commands.compactmachines.schema.load.description=Generates the specified schema in the room you are standing in -commands.compactmachines.schema.load.exception.not_in_machine_dimension=You must be in the machine dimension for this command to work. -commands.compactmachines.schema.load.exception.unknown_schema=No schema with that name exists! -commands.compactmachines.schema.load.exception.machine_size_does_not_match=The size of the machine does not match the schema! -commands.compactmachines.schema.load.machine_schema_set_to=Machine set to schema: %s - -commands.compactmachines.schema.set.usage=/compactmachines schema set -commands.compactmachines.schema.set.description=Sets the specified schema to the Compact Machine block you are looking at -commands.compactmachines.schema.set.exception.unknown_schema=No schema with that name exists! -commands.compactmachines.schema.set.exception.look_at_compact_machine=You need to look at a Compact Machine block! -commands.compactmachines.schema.set.exception.machine_size_does_not_match=The size of the machine does not match the schema! -commands.compactmachines.schema.set.exception.machine_is_already_in_use=Machine is already in use. Place a new machine! -commands.compactmachines.schema.set.machine_schema_set_to=Machine set to schema: %s - -commands.compactmachines.schema.reload-files.usage=/compactmachines schema reload-files -commands.compactmachines.schema.reload-files.description=Reloads all the stored schema files from disk and from the jar - - -commands.compactmachines.recipe.description=Stuff related to Multiblock Miniaturization recipes -commands.compactmachines.recipe.unpack-defaults.usage=/compactmachines recipe unpack-defaults [force] -commands.compactmachines.recipe.unpack-defaults.description=Extract the default recipes from the .jar to the config folder. Append "force" to overwrite existing files. - -commands.compactmachines.recipe.copy-shape.usage=/compactmachines recipe copy-shape -commands.compactmachines.recipe.copy-shape.description=Copies the crafting shape of the projector you are looking at into your clipboard -commands.compactmachines.recipe.copy-shape.exception.not_looking_at_projector=You are not looking at a Field Projector -commands.compactmachines.recipe.copy-shape.success=Copied shape to clipboard! - -commands.compactmachines.recipe.copy-item.usage=/compactmachines recipe copy-item [catalyst|target] -commands.compactmachines.recipe.copy-item.description=Copies the stack in your main hand to the clipboard -commands.compactmachines.recipe.copy-item.exception.missing_type=You need to specify whether you want to get the JSON for a catalyst or for the target stack -commands.compactmachines.recipe.copy-item.exception.missing_item=You need to hold something in your hand for this command to work! -commands.compactmachines.recipe.copy-item.success=Copied item to clipboard! - -commands.compactmachines.recipe.generate.usage=/compactmachines recipe generate -commands.compactmachines.recipe.generate.description=Generates the given recipe in world. Warning: Replaces all blocks in area! -commands.compactmachines.recipe.generate.exception.not_looking_at_block=You are not looking at a block where the Recipe will be built. -commands.compactmachines.recipe.generate.exception.unknown_recipe=The given recipe does not seem to exist. -commands.compactmachines.recipe.generate.exception.missing_machine_recipe=You need to specify a recipe name (use tab completion!) - -commands.compactmachines.machines.description=Commands to recover lost/broken machines -commands.compactmachines.machines.give.usage=/compactmachines machines give -commands.compactmachines.machines.give.description=Gives the player a corresponding cube. WARNING: This breaks Machines if they already exist in the world! -commands.compactmachines.machines.give.warning=WARNING: This breaks Machines if they already exist in the world! - -commands.compactmachines.machines.view.usage=/compactmachines machines view [] -commands.compactmachines.machines.view.description=Opens a GUI allowing inspectation of all existing Compact Machines - -commands.compactmachines.machines.clear.usage=/compactmachines machines clear [] -commands.compactmachines.machines.clear.description=Sets all blocks inside the given machine to air. - -gui.compactmachines.psd.welcome.welcome=Compact Machines 3 allows you to build complex machine contraptions within a single block! -gui.compactmachines.psd.welcome.chapters=Available chapters: - -gui.compactmachines.psd.machines.label=Compact Machines -gui.compactmachines.psd.machines.text=Compact Machines are the core mechanic of this mod. They allow you to build large rooms in a single block space connected to the outside world.\nThey come in various sizes ranging from 3x3x3 to 13x13x13.\nYou can use Tunnels to connect the outside block faces with any of the inside walls to transport items, fluids etc.\nYou can enter a Compact Machine by right-clicking it with a Personal Shrinking Device.\nPlease use JEI to look up crafting recipes. - -gui.compactmachines.psd.tunnels.label=Tunnels -gui.compactmachines.psd.tunnels.text=Tunnels are used to connect inside wall faces to outside block faces. Only one connection for each outside face, this means a total of 6 tunnels per machine.\nRight click a Compact Machine Wall with a Tunnel Tool to place a tunnel. Right click it again to cycle through the outside faces it is connected to.\nTunnels are using the Forge Capability system to "connect" the two blocks. Other mods need to use this system for tunnels to work properly. This is the case for most storage, but rarely for multiblock systems, so expect some pipes etc to not work as expected. - -gui.compactmachines.psd.redstone_tunnels.label=Redstone Tunnels -gui.compactmachines.psd.redstone_tunnels.text=These can be used to transfer redstone signals between the machine and the world it is placed in. In comparison to normal Tunnels they are not bidirectional, but need to be configured to be either In- or Output. Press the button in the top right corner to toggle between modes (red=in, green=out).\nYou can use these to either enable/disable redstone based systems inside your machines or to build complicated redstone circuits inside a single block. - -gui.compactmachines.psd.crafting.label=Miniaturization Crafting -gui.compactmachines.psd.crafting.text=To craft Compact Machines you will need to set up a miniaturization crafting structure.\nGrab 4 Miniaturization Field Projectors and place them opposite of each other, with 7, 11 or 15 spaces between them. All of them need to face the center.\nOnce placed correctly they will start emitting a miniaturization field. Build a recipe like specified in JEI and throw the catalyst item inside the field to start the crafting process. - -gui.compactmachines.compactsky.whitelist=Whitelist -gui.compactmachines.compactsky.preview=Preview -gui.compactmachines.compactsky.enter=Enter machine -gui.compactmachines.compactsky.rename=Rename - -gui.compactmachines.compactsky.configuration.startLocked=Start machines in locked state -gui.compactmachines.compactsky.configuration.givePSD=Give players a Shrinking Device on first spawn -gui.compactmachines.compactsky.configuration.voidDimensions=Use void dimensions -gui.compactmachines.compactsky.configuration.schema=Schema -gui.compactmachines.compactsky.configuration.close=Done -gui.compactmachines.compactsky.configuration.label.MachineSize=Machine Size -gui.compactmachines.compactsky.configuration.label.Description=Description -gui.compactmachines.compactsky.configuration.warning.PleaseSpecifyADescription=Please specify a description in the schemas .json file! - -gui.compactmachines.compactsky.configuration.small=16 Players -gui.compactmachines.compactsky.configuration.medium=64 Players -gui.compactmachines.compactsky.configuration.large=256 Players \ No newline at end of file From 0144c92a936cf2aa4682d3020b770e0ea8505db5 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 14 Aug 2021 23:12:23 -0400 Subject: [PATCH 25/36] Fix advancement granting claims if player doesn't own room --- src/main/java/dev/compactmods/machines/util/PlayerUtil.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/java/dev/compactmods/machines/util/PlayerUtil.java b/src/main/java/dev/compactmods/machines/util/PlayerUtil.java index 2295eba1..e871583e 100644 --- a/src/main/java/dev/compactmods/machines/util/PlayerUtil.java +++ b/src/main/java/dev/compactmods/machines/util/PlayerUtil.java @@ -70,6 +70,7 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl if (tile == null) return; + final boolean grantAdvancement = !tile.mapped(); if (!tile.mapped()) { CompactMachineData machines = CompactMachineData.get(serv); CompactRoomData rooms = CompactRoomData.get(serv); @@ -136,7 +137,8 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl (float) sr.y, (float) sr.x); - AdvancementTriggers.getTriggerForMachineClaim(size).trigger(serverPlayer); + if(grantAdvancement) + AdvancementTriggers.getTriggerForMachineClaim(size).trigger(serverPlayer); }); } From 5c252b9d33b9e2d08882b220c7de341536f2e777 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 14 Aug 2021 23:12:42 -0400 Subject: [PATCH 26/36] CM root and eject commands --- .../machines/command/CMCommandRoot.java | 15 +++++++ .../machines/command/CMEjectSubcommand.java | 42 +++++++++++++++++++ .../machines/core/ServerEventHandler.java | 7 ++++ 3 files changed, 64 insertions(+) create mode 100644 src/main/java/dev/compactmods/machines/command/CMCommandRoot.java create mode 100644 src/main/java/dev/compactmods/machines/command/CMEjectSubcommand.java diff --git a/src/main/java/dev/compactmods/machines/command/CMCommandRoot.java b/src/main/java/dev/compactmods/machines/command/CMCommandRoot.java new file mode 100644 index 00000000..16601ea9 --- /dev/null +++ b/src/main/java/dev/compactmods/machines/command/CMCommandRoot.java @@ -0,0 +1,15 @@ +package dev.compactmods.machines.command; + +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.builder.LiteralArgumentBuilder; +import dev.compactmods.machines.CompactMachines; +import net.minecraft.command.CommandSource; + +public class CMCommandRoot { + + public static void register(CommandDispatcher dispatcher) { + final LiteralArgumentBuilder root = LiteralArgumentBuilder.literal(CompactMachines.MOD_ID); + root.then(CMEjectSubcommand.register()); + dispatcher.register(root); + } +} diff --git a/src/main/java/dev/compactmods/machines/command/CMEjectSubcommand.java b/src/main/java/dev/compactmods/machines/command/CMEjectSubcommand.java new file mode 100644 index 00000000..badf36aa --- /dev/null +++ b/src/main/java/dev/compactmods/machines/command/CMEjectSubcommand.java @@ -0,0 +1,42 @@ +package dev.compactmods.machines.command; + +import java.util.Collection; +import com.mojang.brigadier.builder.ArgumentBuilder; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import dev.compactmods.machines.rooms.capability.CapabilityRoomHistory; +import dev.compactmods.machines.rooms.capability.IRoomHistory; +import dev.compactmods.machines.util.PlayerUtil; +import net.minecraft.command.CommandSource; +import net.minecraft.command.Commands; +import net.minecraft.command.arguments.EntityArgument; +import net.minecraft.entity.player.ServerPlayerEntity; + +public class CMEjectSubcommand { + public static ArgumentBuilder register() { + return Commands.literal("eject") + .requires(cs -> cs.hasPermission(2)) + .executes(CMEjectSubcommand::execExecutingPlayer) + .then(Commands.argument("player", EntityArgument.player()) + .executes(CMEjectSubcommand::execSpecificPlayer)); + } + + private static int execSpecificPlayer(CommandContext ctx) throws CommandSyntaxException { + Collection ent = EntityArgument.getPlayers(ctx, "player"); + ent.forEach(player -> { + player.getCapability(CapabilityRoomHistory.HISTORY_CAPABILITY).ifPresent(IRoomHistory::clear); + PlayerUtil.teleportPlayerToRespawnOrOverworld(ctx.getSource().getServer(), player); + }); + + return 0; + } + + private static int execExecutingPlayer(CommandContext ctx) throws CommandSyntaxException { + final ServerPlayerEntity player = ctx.getSource().getPlayerOrException(); + + player.getCapability(CapabilityRoomHistory.HISTORY_CAPABILITY).ifPresent(IRoomHistory::clear); + PlayerUtil.teleportPlayerToRespawnOrOverworld(ctx.getSource().getServer(), player); + + return 0; + } +} diff --git a/src/main/java/dev/compactmods/machines/core/ServerEventHandler.java b/src/main/java/dev/compactmods/machines/core/ServerEventHandler.java index 5a722cc4..5743cc4b 100644 --- a/src/main/java/dev/compactmods/machines/core/ServerEventHandler.java +++ b/src/main/java/dev/compactmods/machines/core/ServerEventHandler.java @@ -1,7 +1,9 @@ package dev.compactmods.machines.core; import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.command.CMCommandRoot; import net.minecraft.server.MinecraftServer; +import net.minecraftforge.event.RegisterCommandsEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.event.server.FMLServerStartingEvent; @@ -14,4 +16,9 @@ public static void onServerStarting(final FMLServerStartingEvent evt) { MinecraftServer server = evt.getServer(); // SavedMachineDataMigrator.migrate(server); } + + @SubscribeEvent + public static void onCommandsRegister(final RegisterCommandsEvent event) { + CMCommandRoot.register(event.getDispatcher()); + } } From 54a706015a457a1a174878384bbe4a5b3fb12d94 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sun, 15 Aug 2021 12:43:14 -0400 Subject: [PATCH 27/36] Implement new fixbiome command --- build.gradle | 2 +- .../machines/api/core/Messages.java | 1 + .../machines/command/CMCommandRoot.java | 1 + .../command/CMFixBiomeSubcommand.java | 92 +++++++++++++++++++ .../machines/level/BiomeHelper.java | 18 ++++ .../resources/META-INF/accesstransformer.cfg | 1 + .../assets/compactmachines/lang/en_us.json | 1 + 7 files changed, 115 insertions(+), 1 deletion(-) create mode 100644 src/main/java/dev/compactmods/machines/command/CMFixBiomeSubcommand.java create mode 100644 src/main/java/dev/compactmods/machines/level/BiomeHelper.java create mode 100644 src/main/resources/META-INF/accesstransformer.cfg diff --git a/build.gradle b/build.gradle index 638c144d..e9dcbb7b 100644 --- a/build.gradle +++ b/build.gradle @@ -42,7 +42,7 @@ minecraft { mappings channel: 'official', version: mappings_version // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable. - // accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg') + accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg') // Default run configurations. // These can be tweaked, removed, or duplicated as needed. diff --git a/src/main/java/dev/compactmods/machines/api/core/Messages.java b/src/main/java/dev/compactmods/machines/api/core/Messages.java index 070b6b37..46668118 100644 --- a/src/main/java/dev/compactmods/machines/api/core/Messages.java +++ b/src/main/java/dev/compactmods/machines/api/core/Messages.java @@ -8,4 +8,5 @@ public abstract class Messages { public static final ResourceLocation MACHINE_SPAWNPOINT_SET = new ResourceLocation(Constants.MOD_ID, "spawnpoint_set"); public static final ResourceLocation TELEPORT_OUT_OF_BOUNDS = new ResourceLocation(Constants.MOD_ID, "teleport_oob"); public static final ResourceLocation HOW_DID_YOU_GET_HERE = new ResourceLocation(Constants.MOD_ID, "how_did_you_get_here"); + public static final ResourceLocation FIXBIOME_IN_BAD_DIMENSION = new ResourceLocation(Constants.MOD_ID, "fixbiome_bad_dim"); } diff --git a/src/main/java/dev/compactmods/machines/command/CMCommandRoot.java b/src/main/java/dev/compactmods/machines/command/CMCommandRoot.java index 16601ea9..4dac5d96 100644 --- a/src/main/java/dev/compactmods/machines/command/CMCommandRoot.java +++ b/src/main/java/dev/compactmods/machines/command/CMCommandRoot.java @@ -10,6 +10,7 @@ public class CMCommandRoot { public static void register(CommandDispatcher dispatcher) { final LiteralArgumentBuilder root = LiteralArgumentBuilder.literal(CompactMachines.MOD_ID); root.then(CMEjectSubcommand.register()); + root.then(CMFixBiomeSubcommand.register()); dispatcher.register(root); } } diff --git a/src/main/java/dev/compactmods/machines/command/CMFixBiomeSubcommand.java b/src/main/java/dev/compactmods/machines/command/CMFixBiomeSubcommand.java new file mode 100644 index 00000000..38000592 --- /dev/null +++ b/src/main/java/dev/compactmods/machines/command/CMFixBiomeSubcommand.java @@ -0,0 +1,92 @@ +package dev.compactmods.machines.command; + +import java.util.Arrays; +import com.mojang.brigadier.builder.ArgumentBuilder; +import com.mojang.brigadier.context.CommandContext; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.api.core.Messages; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.util.TranslationUtil; +import net.minecraft.command.CommandSource; +import net.minecraft.command.Commands; +import net.minecraft.command.arguments.ResourceLocationArgument; +import net.minecraft.command.arguments.SuggestionProviders; +import net.minecraft.network.play.server.SChunkDataPacket; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.RegistryKey; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.vector.Vector3d; +import net.minecraft.util.registry.Registry; +import net.minecraft.world.biome.Biome; +import net.minecraft.world.biome.BiomeContainer; +import net.minecraft.world.biome.Biomes; +import net.minecraft.world.chunk.Chunk; +import net.minecraft.world.server.ServerWorld; +import net.minecraftforge.fml.network.PacketDistributor; + +public class CMFixBiomeSubcommand { + public static ArgumentBuilder register() { + return Commands.literal("fixbiome") + .executes(CMFixBiomeSubcommand::fixBiomeDefault) + .then( + Commands.argument("biome", ResourceLocationArgument.id()) + .suggests(SuggestionProviders.AVAILABLE_BIOMES) + .executes(CMFixBiomeSubcommand::specificBiome) + ); + } + + + private static int specificBiome(CommandContext ctx) { + if(!ctx.getSource().getLevel().dimension().equals(Registration.COMPACT_DIMENSION)) { + ctx.getSource().sendFailure(TranslationUtil.message(Messages.FIXBIOME_IN_BAD_DIMENSION)); + return -1; + } + + final ResourceLocation biomeId = ResourceLocationArgument.getId(ctx, "biome"); + updateBiomeData(ctx, biomeId); + return 0; + } + + + private static int fixBiomeDefault(CommandContext ctx) { + if(!ctx.getSource().getLevel().dimension().equals(Registration.COMPACT_DIMENSION)) { + ctx.getSource().sendFailure(TranslationUtil.message(Messages.FIXBIOME_IN_BAD_DIMENSION)); + return -1; + } + + final ResourceLocation biomeId = Biomes.PLAINS.location(); + updateBiomeData(ctx, biomeId); + return 0; + } + + private static void updateBiomeData(CommandContext ctx, ResourceLocation biomeId) { + final MinecraftServer server = ctx.getSource().getServer(); + final ServerWorld level = server.getLevel(Registration.COMPACT_DIMENSION); + if (level == null) { + CompactMachines.LOGGER.error("Error: Compact dimension not registered."); + return; + } + + final Vector3d position = ctx.getSource().getPosition(); + final BlockPos excAt = new BlockPos(position.x, position.y, position.z); + final Chunk chunkAt = level.getChunkAt(excAt); + + final BiomeContainer biomes = chunkAt.getBiomes(); + if (biomes != null) { + final Biome newBiome = server.registryAccess() + .registryOrThrow(Registry.BIOME_REGISTRY) + .get(RegistryKey.create(Registry.BIOME_REGISTRY, biomeId)); + + Arrays.fill(biomes.biomes, newBiome); + + chunkAt.setUnsaved(true); + + SChunkDataPacket pkt = new SChunkDataPacket(chunkAt, 65535); + + PacketDistributor.TRACKING_CHUNK + .with(() -> level.getChunkAt(excAt)) + .send(pkt); + } + } +} diff --git a/src/main/java/dev/compactmods/machines/level/BiomeHelper.java b/src/main/java/dev/compactmods/machines/level/BiomeHelper.java new file mode 100644 index 00000000..7dd349de --- /dev/null +++ b/src/main/java/dev/compactmods/machines/level/BiomeHelper.java @@ -0,0 +1,18 @@ +package dev.compactmods.machines.level; + +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.MathHelper; +import net.minecraft.world.biome.BiomeContainer; + +public class BiomeHelper { + private static final int WIDTH_BITS = (int)Math.round(Math.log(16.0D) / Math.log(2.0D)) - 2; + + public static int biomeIndex(BlockPos pos) { + int l = (pos.getX() >> 2) & BiomeContainer.HORIZONTAL_MASK; + int m = MathHelper.clamp(pos.getY() >> 2, 0, BiomeContainer.VERTICAL_MASK); + int n = (pos.getZ() >> 2) & BiomeContainer.HORIZONTAL_MASK; + return m << WIDTH_BITS + WIDTH_BITS + | n << WIDTH_BITS + | l; + } +} diff --git a/src/main/resources/META-INF/accesstransformer.cfg b/src/main/resources/META-INF/accesstransformer.cfg new file mode 100644 index 00000000..ae083745 --- /dev/null +++ b/src/main/resources/META-INF/accesstransformer.cfg @@ -0,0 +1 @@ +public net.minecraft.world.biome.BiomeContainer field_227054_f_ # biomes \ No newline at end of file diff --git a/src/main/resources/assets/compactmachines/lang/en_us.json b/src/main/resources/assets/compactmachines/lang/en_us.json index d007b79b..1d1bcd57 100644 --- a/src/main/resources/assets/compactmachines/lang/en_us.json +++ b/src/main/resources/assets/compactmachines/lang/en_us.json @@ -16,6 +16,7 @@ "message.compactmachines.spawnpoint_set": "New spawn point set.", "message.compactmachines.no_machine_data": "No machine data loaded; report this.", "message.compactmachines.teleport_oob": "An otherworldly force prevents your teleportation.", + "message.compactmachines.fixbiome_bad_dim": "Cannot use fixbiome command outside of a machine room.", "block.compactmachines.machine": "Compact Machine", "block.compactmachines.machine_tiny": "Compact Machine (Tiny)", From 72755b7f69b3710c7ef7e65f0a99baa0fd354325 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sun, 15 Aug 2021 15:07:07 -0400 Subject: [PATCH 28/36] Clean up and serialize player history --- .../machines/core/ModBusEvents.java | 4 +++ .../rooms/capability/CMRoomHistory.java | 30 ++++++++++++++++++- .../capability/CapabilityRoomHistory.java | 29 +++++++++--------- .../rooms/capability/IRoomHistory.java | 5 ++-- .../PlayerRoomHistoryCapProvider.java | 20 ++++++++++++- .../rooms/history/PlayerRoomHistoryItem.java | 7 +++++ 6 files changed, 77 insertions(+), 18 deletions(-) diff --git a/src/main/java/dev/compactmods/machines/core/ModBusEvents.java b/src/main/java/dev/compactmods/machines/core/ModBusEvents.java index 94816e2a..4cd69cf0 100644 --- a/src/main/java/dev/compactmods/machines/core/ModBusEvents.java +++ b/src/main/java/dev/compactmods/machines/core/ModBusEvents.java @@ -4,6 +4,7 @@ import dev.compactmods.machines.advancement.AdvancementTriggers; import dev.compactmods.machines.compat.theoneprobe.TheOneProbeCompat; import dev.compactmods.machines.network.NetworkHandler; +import dev.compactmods.machines.rooms.capability.CapabilityRoomHistory; import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.fml.ModList; import net.minecraftforge.fml.common.Mod; @@ -20,6 +21,9 @@ public static void setup(final FMLCommonSetupEvent event) { CompactMachines.LOGGER.trace("Registering advancement triggers."); AdvancementTriggers.init(); + + CompactMachines.LOGGER.trace("Registering capabilities."); + CapabilityRoomHistory.register(); } @SubscribeEvent diff --git a/src/main/java/dev/compactmods/machines/rooms/capability/CMRoomHistory.java b/src/main/java/dev/compactmods/machines/rooms/capability/CMRoomHistory.java index 9d571cea..d6d655bb 100644 --- a/src/main/java/dev/compactmods/machines/rooms/capability/CMRoomHistory.java +++ b/src/main/java/dev/compactmods/machines/rooms/capability/CMRoomHistory.java @@ -2,9 +2,16 @@ import java.util.ArrayDeque; import java.util.Deque; +import java.util.Optional; +import com.mojang.serialization.DataResult; +import dev.compactmods.machines.data.codec.NbtListCollector; import dev.compactmods.machines.rooms.history.IRoomHistoryItem; +import dev.compactmods.machines.rooms.history.PlayerRoomHistoryItem; +import net.minecraft.nbt.INBT; +import net.minecraft.nbt.ListNBT; +import net.minecraft.nbt.NBTDynamicOps; -public class CMRoomHistory implements IRoomHistory{ +public class CMRoomHistory implements IRoomHistory { private final Deque history; @@ -36,4 +43,25 @@ public IRoomHistoryItem pop() { public void addHistory(IRoomHistoryItem item) { history.add(item); } + + @Override + public ListNBT serializeNBT() { + return history.stream() + .map(hi -> PlayerRoomHistoryItem.CODEC.encodeStart(NBTDynamicOps.INSTANCE, hi)) + .map(DataResult::result) + .filter(Optional::isPresent) + .map(Optional::get) + .map(x -> x) + .collect(NbtListCollector.toNbtList()); + } + + @Override + public void deserializeNBT(ListNBT nbt) { + nbt.stream() + .map(it -> PlayerRoomHistoryItem.CODEC.parse(NBTDynamicOps.INSTANCE, it)) + .map(DataResult::result) + .filter(Optional::isPresent) + .map(Optional::get) + .forEach(history::addLast); + } } diff --git a/src/main/java/dev/compactmods/machines/rooms/capability/CapabilityRoomHistory.java b/src/main/java/dev/compactmods/machines/rooms/capability/CapabilityRoomHistory.java index 6772a995..06859dc6 100644 --- a/src/main/java/dev/compactmods/machines/rooms/capability/CapabilityRoomHistory.java +++ b/src/main/java/dev/compactmods/machines/rooms/capability/CapabilityRoomHistory.java @@ -1,8 +1,8 @@ package dev.compactmods.machines.rooms.capability; import javax.annotation.Nullable; -import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.INBT; +import net.minecraft.nbt.ListNBT; import net.minecraft.util.Direction; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.common.capabilities.CapabilityInject; @@ -13,20 +13,21 @@ public class CapabilityRoomHistory { @CapabilityInject(IRoomHistory.class) public static Capability HISTORY_CAPABILITY = null; - public static void setup() { - CapabilityManager.INSTANCE.register( - IRoomHistory.class, - new Capability.IStorage() { - @Nullable - @Override - public INBT writeNBT(Capability capability, IRoomHistory instance, Direction side) { - return new CompoundNBT(); - } + public static class CapabilityRoomHistoryStorage implements Capability.IStorage { + @Nullable + @Override + public INBT writeNBT(Capability capability, IRoomHistory instance, Direction side) { + return instance.serializeNBT(); + } - @Override - public void readNBT(Capability capability, IRoomHistory instance, Direction side, INBT nbt) { + @Override + public void readNBT(Capability capability, IRoomHistory instance, Direction side, INBT nbt) { + if(nbt instanceof ListNBT) + instance.deserializeNBT((ListNBT) nbt); + } + } - } - }, CMRoomHistory::new); + public static void register() { + CapabilityManager.INSTANCE.register(IRoomHistory.class, new CapabilityRoomHistoryStorage(), CMRoomHistory::new); } } diff --git a/src/main/java/dev/compactmods/machines/rooms/capability/IRoomHistory.java b/src/main/java/dev/compactmods/machines/rooms/capability/IRoomHistory.java index 2fde1618..1cce5672 100644 --- a/src/main/java/dev/compactmods/machines/rooms/capability/IRoomHistory.java +++ b/src/main/java/dev/compactmods/machines/rooms/capability/IRoomHistory.java @@ -1,8 +1,10 @@ package dev.compactmods.machines.rooms.capability; import dev.compactmods.machines.rooms.history.IRoomHistoryItem; +import net.minecraft.nbt.ListNBT; +import net.minecraftforge.common.util.INBTSerializable; -public interface IRoomHistory { +public interface IRoomHistory extends INBTSerializable { void clear(); boolean hasHistory(); @@ -10,5 +12,4 @@ public interface IRoomHistory { IRoomHistoryItem pop(); void addHistory(IRoomHistoryItem item); - } diff --git a/src/main/java/dev/compactmods/machines/rooms/capability/PlayerRoomHistoryCapProvider.java b/src/main/java/dev/compactmods/machines/rooms/capability/PlayerRoomHistoryCapProvider.java index 40fd2ffd..ea2227c1 100644 --- a/src/main/java/dev/compactmods/machines/rooms/capability/PlayerRoomHistoryCapProvider.java +++ b/src/main/java/dev/compactmods/machines/rooms/capability/PlayerRoomHistoryCapProvider.java @@ -3,12 +3,15 @@ import javax.annotation.Nonnull; import javax.annotation.Nullable; import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.nbt.CompoundNBT; import net.minecraft.util.Direction; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.common.capabilities.ICapabilityProvider; +import net.minecraftforge.common.util.Constants; +import net.minecraftforge.common.util.INBTSerializable; import net.minecraftforge.common.util.LazyOptional; -public class PlayerRoomHistoryCapProvider implements ICapabilityProvider { +public class PlayerRoomHistoryCapProvider implements ICapabilityProvider, INBTSerializable { private final PlayerEntity player; private final CMRoomHistory history; @@ -28,4 +31,19 @@ public LazyOptional getCapability(@Nonnull Capability cap, @Nullable D return LazyOptional.empty(); } + + @Override + public CompoundNBT serializeNBT() { + CompoundNBT nbt = new CompoundNBT(); + nbt.put("history", history.serializeNBT()); + return nbt; + } + + @Override + public void deserializeNBT(CompoundNBT nbt) { + if(nbt.contains("history")) { + history.clear(); + history.deserializeNBT(nbt.getList("history", Constants.NBT.TAG_COMPOUND)); + } + } } diff --git a/src/main/java/dev/compactmods/machines/rooms/history/PlayerRoomHistoryItem.java b/src/main/java/dev/compactmods/machines/rooms/history/PlayerRoomHistoryItem.java index 1982e197..3248d716 100644 --- a/src/main/java/dev/compactmods/machines/rooms/history/PlayerRoomHistoryItem.java +++ b/src/main/java/dev/compactmods/machines/rooms/history/PlayerRoomHistoryItem.java @@ -1,5 +1,7 @@ package dev.compactmods.machines.rooms.history; +import com.mojang.serialization.Codec; +import com.mojang.serialization.codecs.RecordCodecBuilder; import dev.compactmods.machines.teleportation.DimensionalPosition; public class PlayerRoomHistoryItem implements IRoomHistoryItem { @@ -7,6 +9,11 @@ public class PlayerRoomHistoryItem implements IRoomHistoryItem { private final DimensionalPosition entry; private final int machine; + public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( + DimensionalPosition.CODEC.fieldOf("position").forGetter(IRoomHistoryItem::getEntryLocation), + Codec.INT.fieldOf("machine").forGetter(IRoomHistoryItem::getMachine) + ).apply(i, PlayerRoomHistoryItem::new)); + public PlayerRoomHistoryItem(DimensionalPosition entry, int machine) { this.entry = entry; this.machine = machine; From 0b2728d32721c6b795a060894ab7479f8415e015 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sun, 15 Aug 2021 15:07:18 -0400 Subject: [PATCH 29/36] Misc cleanups --- .../machines/block/tiles/CompactMachineTile.java | 2 +- .../machines/client/gui/PersonalShrinkingDeviceScreen.java | 2 +- .../compactmods/machines/client/gui/guide/GuideSection.java | 4 ++-- .../client/gui/widget/ScrollableWrappedTextWidget.java | 4 ++-- .../compactmods/machines/compat/theoneprobe/ProbeData.java | 6 +++--- .../theoneprobe/providers/CompactMachineProvider.java | 2 +- .../java/dev/compactmods/machines/core/Registration.java | 4 ++-- .../machines/data/persistent/CompactRoomData.java | 2 +- .../compactmods/machines/datagen/BlockLootGenerator.java | 2 +- src/main/java/dev/compactmods/machines/item/TunnelItem.java | 2 +- .../dev/compactmods/machines/reference/EnumMachineSize.java | 4 ++-- .../compactmods/machines/tunnels/TunnelConnectionInfo.java | 2 +- src/main/java/dev/compactmods/machines/util/MathUtil.java | 6 +++--- 13 files changed, 21 insertions(+), 21 deletions(-) diff --git a/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java b/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java index d3a23648..14ef1f0a 100644 --- a/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java +++ b/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java @@ -36,7 +36,7 @@ public class CompactMachineTile extends TileEntity implements ICapabilityProvider, ITickableTileEntity { public int machineId = -1; - private boolean initialized = false; + private final boolean initialized = false; public boolean alreadyNotifiedOnTick = false; public long nextSpawnTick = 0; diff --git a/src/main/java/dev/compactmods/machines/client/gui/PersonalShrinkingDeviceScreen.java b/src/main/java/dev/compactmods/machines/client/gui/PersonalShrinkingDeviceScreen.java index 593c96c2..0de7fddc 100644 --- a/src/main/java/dev/compactmods/machines/client/gui/PersonalShrinkingDeviceScreen.java +++ b/src/main/java/dev/compactmods/machines/client/gui/PersonalShrinkingDeviceScreen.java @@ -22,7 +22,7 @@ public class PersonalShrinkingDeviceScreen extends Screen { private final ResourceLocation emptySection = new ResourceLocation(CompactMachines.MOD_ID, "empty"); @Nullable - private GuideSection currentSection; + private final GuideSection currentSection; protected PersonalShrinkingDeviceScreen() { super(new TranslationTextComponent(CompactMachines.MOD_ID + ".gui.psd.title")); diff --git a/src/main/java/dev/compactmods/machines/client/gui/guide/GuideSection.java b/src/main/java/dev/compactmods/machines/client/gui/guide/GuideSection.java index 0fd33062..6e131073 100644 --- a/src/main/java/dev/compactmods/machines/client/gui/guide/GuideSection.java +++ b/src/main/java/dev/compactmods/machines/client/gui/guide/GuideSection.java @@ -9,8 +9,8 @@ public class GuideSection implements IRenderable, IGuiEventListener { private final List pages; - private int currentPageIndex = 0; - private GuidePage currentPage; + private final int currentPageIndex = 0; + private final GuidePage currentPage; public GuideSection() { this.pages = new ArrayList<>(); diff --git a/src/main/java/dev/compactmods/machines/client/gui/widget/ScrollableWrappedTextWidget.java b/src/main/java/dev/compactmods/machines/client/gui/widget/ScrollableWrappedTextWidget.java index 15979fe3..6d464c34 100644 --- a/src/main/java/dev/compactmods/machines/client/gui/widget/ScrollableWrappedTextWidget.java +++ b/src/main/java/dev/compactmods/machines/client/gui/widget/ScrollableWrappedTextWidget.java @@ -12,9 +12,9 @@ public class ScrollableWrappedTextWidget extends AbstractCMGuiWidget { - private String localeKey; + private final String localeKey; private double yScroll = 0; - private FontRenderer fontRenderer; + private final FontRenderer fontRenderer; private int maxLinesToShow; private int lineIndexStart; diff --git a/src/main/java/dev/compactmods/machines/compat/theoneprobe/ProbeData.java b/src/main/java/dev/compactmods/machines/compat/theoneprobe/ProbeData.java index 74845cd9..0dc0bcdf 100644 --- a/src/main/java/dev/compactmods/machines/compat/theoneprobe/ProbeData.java +++ b/src/main/java/dev/compactmods/machines/compat/theoneprobe/ProbeData.java @@ -5,9 +5,9 @@ import mcjty.theoneprobe.api.ProbeMode; public class ProbeData implements IProbeData { - private IProbeInfo info; - private ProbeMode mode; - private IProbeHitData hitData; + private final IProbeInfo info; + private final ProbeMode mode; + private final IProbeHitData hitData; public ProbeData(IProbeInfo info, ProbeMode mode, IProbeHitData hitData) { this.info = info; diff --git a/src/main/java/dev/compactmods/machines/compat/theoneprobe/providers/CompactMachineProvider.java b/src/main/java/dev/compactmods/machines/compat/theoneprobe/providers/CompactMachineProvider.java index 501f5c7e..d713f5af 100644 --- a/src/main/java/dev/compactmods/machines/compat/theoneprobe/providers/CompactMachineProvider.java +++ b/src/main/java/dev/compactmods/machines/compat/theoneprobe/providers/CompactMachineProvider.java @@ -77,7 +77,7 @@ private static void addProbeInfo(IProbeInfo info, World world, IProbeHitData hit tile.getTunnelDefinition().ifPresent(tunnelDef -> { vertical.text( - new StringTextComponent(pos.toString() + ": " + tunnelDef.getRegistryName().toString()) + new StringTextComponent(pos + ": " + tunnelDef.getRegistryName().toString()) ); }); }); diff --git a/src/main/java/dev/compactmods/machines/core/Registration.java b/src/main/java/dev/compactmods/machines/core/Registration.java index e1ca60e5..6bb33947 100644 --- a/src/main/java/dev/compactmods/machines/core/Registration.java +++ b/src/main/java/dev/compactmods/machines/core/Registration.java @@ -59,14 +59,14 @@ public class Registration { // ================================================================================================================ // PROPERTIES // ================================================================================================================ - private static AbstractBlock.Properties MACHINE_BLOCK_PROPS = AbstractBlock.Properties + private static final AbstractBlock.Properties MACHINE_BLOCK_PROPS = AbstractBlock.Properties .of(Material.METAL) .strength(8.0F, 20.0F) .harvestLevel(1) .harvestTool(ToolType.PICKAXE) .requiresCorrectToolForDrops(); - private static Supplier BASIC_ITEM_PROPS = () -> new Item.Properties() + private static final Supplier BASIC_ITEM_PROPS = () -> new Item.Properties() .tab(CompactMachines.COMPACT_MACHINES_ITEMS); // ================================================================================================================ diff --git a/src/main/java/dev/compactmods/machines/data/persistent/CompactRoomData.java b/src/main/java/dev/compactmods/machines/data/persistent/CompactRoomData.java index 91bee95d..12cb1580 100644 --- a/src/main/java/dev/compactmods/machines/data/persistent/CompactRoomData.java +++ b/src/main/java/dev/compactmods/machines/data/persistent/CompactRoomData.java @@ -36,7 +36,7 @@ public class CompactRoomData extends WorldSavedData { public static final String DATA_NAME = CompactMachines.MOD_ID + "_rooms"; - private Map machineData; + private final Map machineData; public CompactRoomData() { super(DATA_NAME); diff --git a/src/main/java/dev/compactmods/machines/datagen/BlockLootGenerator.java b/src/main/java/dev/compactmods/machines/datagen/BlockLootGenerator.java index f0e0fb87..41b8f341 100644 --- a/src/main/java/dev/compactmods/machines/datagen/BlockLootGenerator.java +++ b/src/main/java/dev/compactmods/machines/datagen/BlockLootGenerator.java @@ -63,7 +63,7 @@ private LootPool.Builder registerSelfDroppedBlock(RegistryObject block, R return builder; } - private ILootFunction.IBuilder CopyOwnerAndReferenceFunction = CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY) + private final ILootFunction.IBuilder CopyOwnerAndReferenceFunction = CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY) .copy(Reference.CompactMachines.OWNER_NBT, Reference.CompactMachines.OWNER_NBT) .copy("coords", "cm.coords"); diff --git a/src/main/java/dev/compactmods/machines/item/TunnelItem.java b/src/main/java/dev/compactmods/machines/item/TunnelItem.java index 326280dc..71c462e9 100644 --- a/src/main/java/dev/compactmods/machines/item/TunnelItem.java +++ b/src/main/java/dev/compactmods/machines/item/TunnelItem.java @@ -111,7 +111,7 @@ public ActionResultType useOn(ItemUseContext context) { Item i = is.getItem(); TunnelItem ti = ((TunnelItem) i); - Optional definition = ti.getDefinition(context.getItemInHand()); + Optional definition = getDefinition(context.getItemInHand()); definition.ifPresent(def -> { BlockState tunnelState = Registration.BLOCK_TUNNEL_WALL.get() diff --git a/src/main/java/dev/compactmods/machines/reference/EnumMachineSize.java b/src/main/java/dev/compactmods/machines/reference/EnumMachineSize.java index 792840ab..96c004fa 100644 --- a/src/main/java/dev/compactmods/machines/reference/EnumMachineSize.java +++ b/src/main/java/dev/compactmods/machines/reference/EnumMachineSize.java @@ -13,8 +13,8 @@ public enum EnumMachineSize implements IStringSerializable { GIANT ("giant", 11), MAXIMUM ("maximum", 13); - private String name; - private int internalSize; + private final String name; + private final int internalSize; public static final Codec CODEC = IStringSerializable.fromEnum( EnumMachineSize::values, EnumMachineSize::getFromSize); diff --git a/src/main/java/dev/compactmods/machines/tunnels/TunnelConnectionInfo.java b/src/main/java/dev/compactmods/machines/tunnels/TunnelConnectionInfo.java index a1a0060f..2d4a3195 100644 --- a/src/main/java/dev/compactmods/machines/tunnels/TunnelConnectionInfo.java +++ b/src/main/java/dev/compactmods/machines/tunnels/TunnelConnectionInfo.java @@ -14,7 +14,7 @@ public class TunnelConnectionInfo implements ITunnelConnectionInfo { - private TunnelWallTile tunnel; + private final TunnelWallTile tunnel; TunnelConnectionInfo(TunnelWallTile tile) { this.tunnel = tile; diff --git a/src/main/java/dev/compactmods/machines/util/MathUtil.java b/src/main/java/dev/compactmods/machines/util/MathUtil.java index 2741eff4..68cbc461 100644 --- a/src/main/java/dev/compactmods/machines/util/MathUtil.java +++ b/src/main/java/dev/compactmods/machines/util/MathUtil.java @@ -22,7 +22,7 @@ public static Vector3i getRegionPositionByIndex(int i) { p = s * s - (s - 2) * (s - 2); } - int ri = (ringIndex + (int) (s / 2)) % p; + int ri = (ringIndex + (s / 2)) % p; int x = 0; if (s > 1) { @@ -43,8 +43,8 @@ public static Vector3i getRegionPositionByIndex(int i) { (ri <= (p / 4 * 3) ? (p / 4) : (p - ri))); - x -= (int) (s / 2); - y -= (int) (s / 2); + x -= s / 2; + y -= s / 2; return new Vector3i(x, 0, y); } From 4e8befb1e128d55a8d6237ffc7e88b4f1fa89575 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sun, 15 Aug 2021 18:36:22 -0400 Subject: [PATCH 30/36] Update JEI, add JEI info for PSD and Machines --- gradle.properties | 6 ++--- .../machines/api/core/JeiInfo.java | 10 +++++++ .../compat/jei/CompactMachinesJeiPlugin.java | 26 +++++++++++++++++++ .../machines/util/TranslationUtil.java | 4 +++ .../assets/compactmachines/lang/en_us.json | 16 +++--------- 5 files changed, 46 insertions(+), 16 deletions(-) create mode 100644 src/main/java/dev/compactmods/machines/api/core/JeiInfo.java diff --git a/gradle.properties b/gradle.properties index f15d63dd..33e0e741 100644 --- a/gradle.properties +++ b/gradle.properties @@ -11,9 +11,9 @@ mod_id=compactmachines mod_version=4.0.0-beta.2 # Dependencies and Libs -jei_mc_version=1.16.4 -jei_version=7.6.1.71 -top_version=1.16-3.0.7-13 +jei_mc_version=1.16.5 +jei_version=7.7.1.110 +top_version=1.16-3.1.4-22 # Curseforge cf_project=224218 diff --git a/src/main/java/dev/compactmods/machines/api/core/JeiInfo.java b/src/main/java/dev/compactmods/machines/api/core/JeiInfo.java new file mode 100644 index 00000000..e3976fef --- /dev/null +++ b/src/main/java/dev/compactmods/machines/api/core/JeiInfo.java @@ -0,0 +1,10 @@ +package dev.compactmods.machines.api.core; + +import com.mojang.datafixers.kinds.Const; +import net.minecraft.util.ResourceLocation; + +public class JeiInfo { + public static final ResourceLocation MACHINE = new ResourceLocation(Constants.MOD_ID, "machines"); + + public static final ResourceLocation SHRINKING_DEVICE = new ResourceLocation(Constants.MOD_ID, "shrinking_device"); +} diff --git a/src/main/java/dev/compactmods/machines/compat/jei/CompactMachinesJeiPlugin.java b/src/main/java/dev/compactmods/machines/compat/jei/CompactMachinesJeiPlugin.java index 08026432..a8758ab4 100644 --- a/src/main/java/dev/compactmods/machines/compat/jei/CompactMachinesJeiPlugin.java +++ b/src/main/java/dev/compactmods/machines/compat/jei/CompactMachinesJeiPlugin.java @@ -1,11 +1,21 @@ package dev.compactmods.machines.compat.jei; +import java.util.Arrays; import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.api.core.JeiInfo; +import dev.compactmods.machines.api.core.Messages; +import dev.compactmods.machines.block.BlockCompactMachine; import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.reference.EnumMachineSize; +import dev.compactmods.machines.util.TranslationUtil; import mezz.jei.api.IModPlugin; import mezz.jei.api.JeiPlugin; +import mezz.jei.api.constants.VanillaTypes; +import mezz.jei.api.ingredients.IIngredientType; +import mezz.jei.api.registration.IRecipeRegistration; import mezz.jei.api.registration.ISubtypeRegistration; import mezz.jei.api.runtime.IJeiRuntime; +import net.minecraft.item.ItemStack; import net.minecraft.util.ResourceLocation; @JeiPlugin @@ -15,6 +25,22 @@ public ResourceLocation getPluginUid() { return new ResourceLocation(CompactMachines.MOD_ID, "main"); } + @Override + public void registerRecipes(IRecipeRegistration registration) { + Arrays.stream(EnumMachineSize.values()) + .map(BlockCompactMachine::getItemBySize) + .forEach(i -> registration.addIngredientInfo( + new ItemStack(i), + VanillaTypes.ITEM, + TranslationUtil.jeiInfo(JeiInfo.MACHINE))); + + + registration.addIngredientInfo( + new ItemStack(Registration.PERSONAL_SHRINKING_DEVICE.get()), + VanillaTypes.ITEM, + TranslationUtil.jeiInfo(JeiInfo.SHRINKING_DEVICE)); + } + @Override public void registerItemSubtypes(ISubtypeRegistration registration) { registration.useNbtForSubtypes(Registration.ITEM_TUNNEL.get()); diff --git a/src/main/java/dev/compactmods/machines/util/TranslationUtil.java b/src/main/java/dev/compactmods/machines/util/TranslationUtil.java index 9adf25aa..68a02ad3 100644 --- a/src/main/java/dev/compactmods/machines/util/TranslationUtil.java +++ b/src/main/java/dev/compactmods/machines/util/TranslationUtil.java @@ -45,4 +45,8 @@ public static TranslationTextComponent advancementTitle(ResourceLocation advance public static TranslationTextComponent advancementDesc(ResourceLocation advancement) { return new TranslationTextComponent(Util.makeDescriptionId("advancement", advancement) + ".desc"); } + + public static TranslationTextComponent jeiInfo(ResourceLocation jei) { + return new TranslationTextComponent(Util.makeDescriptionId("jei", jei)); + } } diff --git a/src/main/resources/assets/compactmachines/lang/en_us.json b/src/main/resources/assets/compactmachines/lang/en_us.json index 1d1bcd57..5932293a 100644 --- a/src/main/resources/assets/compactmachines/lang/en_us.json +++ b/src/main/resources/assets/compactmachines/lang/en_us.json @@ -1,23 +1,19 @@ { "itemGroup.compactmachines": "Compact Machines", - "tooltip.compactmachines.machine.id": "Machine ID: %s", "tooltip.compactmachines.machine.owner": "Owner: %s", "tooltip.compactmachines.machine.size": "Internal Size: %1$sx%1$sx%1$s", "tooltip.compactmachines.unknown_player": "Unknown Player", "tooltip.compactmachines.tunnel_type": "Type ID: %1$s", - "tooltip.compactmachines.hint.hold_shift": "Hold shift for details.", "tooltip.compactmachines.details.psd": "Used as in-game documentation and to enter Compact Machines.", "tooltip.compactmachines.details.solid_wall": "Warning! Unbreakable for non-creative players!", - "message.compactmachines.new_machine": "New Machine", "message.compactmachines.cannot_enter": "You fumble with the shrinking device, to no avail. It refuses to work.", "message.compactmachines.spawnpoint_set": "New spawn point set.", "message.compactmachines.no_machine_data": "No machine data loaded; report this.", "message.compactmachines.teleport_oob": "An otherworldly force prevents your teleportation.", "message.compactmachines.fixbiome_bad_dim": "Cannot use fixbiome command outside of a machine room.", - "block.compactmachines.machine": "Compact Machine", "block.compactmachines.machine_tiny": "Compact Machine (Tiny)", "block.compactmachines.machine_small": "Compact Machine (Small)", @@ -25,24 +21,19 @@ "block.compactmachines.machine_large": "Compact Machine (Large)", "block.compactmachines.machine_giant": "Compact Machine (Giant)", "block.compactmachines.machine_maximum": "Compact Machine (Maximum)", - "block.compactmachines.solid_wall": "Solid Compact Machine Wall", "block.compactmachines.wall": "Compact Machine Wall", "block.compactmachines.tunnel_wall": "Solid Compact Machine Wall (with Tunnel)", - "item.compactmachines.machine_tiny": "Compact Machine (Tiny)", "item.compactmachines.machine_small": "Compact Machine (Small)", "item.compactmachines.machine_normal": "Compact Machine (Normal)", "item.compactmachines.machine_large": "Compact Machine (Large)", "item.compactmachines.machine_giant": "Compact Machine (Giant)", "item.compactmachines.machine_maximum": "Compact Machine (Maximum)", - "item.compactmachines.personal_shrinking_device": "Personal Shrinking Device", - "item.compactmachines.tunnels.item": "Item Tunnel", "item.compactmachines.tunnels.redstone_in": "Redstone Tunnel (In)", "item.compactmachines.tunnels.redstone_out": "Redstone Tunnel (Out)", - "compactmachines.connected_block": "Connected: %s", "compactmachines.direction.side": "Side: %s", "compactmachines.direction.up": "Up", @@ -51,12 +42,9 @@ "compactmachines.direction.south": "South", "compactmachines.direction.west": "West", "compactmachines.direction.east": "East", - "compactmachines.psd.pages.machines.title": "Compact Machines", "compactmachines.psd.pages.machines": "Compact Machines are the core mechanic of this mod. They allow you to build large rooms in a single block space connected to the outside world. They come in various sizes ranging from 3x3x3 to 13x13x13.\n\nYou can use Tunnels to connect the outside block faces with any of the inside walls to transport items, fluids etc.\n\nYou can enter a Compact Machine by right-clicking it with a Personal Shrinking Device. Please use JEI to look up crafting recipes.", - "compactmachines.errors.unknown_tunnel_type": "Unknown Tunnel Type (%s)", - "advancement.compactmachines.root": "Compact Machines", "advancement.compactmachines.root.desc": "", "advancement.compactmachines.how_did_you_get_here": "How Did You Get Here?!", @@ -76,5 +64,7 @@ "advancement.compactmachines.claimed_machine_giant": "Got Enough Space?", "advancement.compactmachines.claimed_machine_giant.desc": "Claim a giant compact machine.", "advancement.compactmachines.claimed_machine_max": "Room for Activities!", - "advancement.compactmachines.claimed_machine_max.desc": "Claim a maximum compact machine." + "advancement.compactmachines.claimed_machine_max.desc": "Claim a maximum compact machine.", + "jei.compactmachines.shrinking_device": "Use the Personal Shrinking Device (PSD) on a machine in order to enter a compact space. You can also right click it in the overworld for more info.", + "jei.compactmachines.machines": "Machines are used to make pocket dimensions. Craft a machine and place it in world, then use a Personal Shrinking Device to go inside." } \ No newline at end of file From fc93d283f0168a285b208cd4420a19f994eab7bd Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 28 Aug 2021 14:23:55 -0400 Subject: [PATCH 31/36] Next steps in chunkloading code --- .../compactmods/machines/CompactMachines.java | 3 + .../block/tiles/CompactMachineTile.java | 37 +++-- .../machines/core/ServerEventHandler.java | 3 + .../machines/data/player/theory.txt | 60 ------- .../CMRoomChunkloadingManager.java | 155 ++++++++++++++++++ .../IRoomChunkloadingManager.java | 15 ++ .../teleportation/DimensionalPosition.java | 15 +- .../machines/util/LocationUtil.java | 4 + 8 files changed, 213 insertions(+), 79 deletions(-) delete mode 100644 src/main/java/dev/compactmods/machines/data/player/theory.txt create mode 100644 src/main/java/dev/compactmods/machines/rooms/chunkloading/CMRoomChunkloadingManager.java create mode 100644 src/main/java/dev/compactmods/machines/rooms/chunkloading/IRoomChunkloadingManager.java diff --git a/src/main/java/dev/compactmods/machines/CompactMachines.java b/src/main/java/dev/compactmods/machines/CompactMachines.java index 9207f457..a379c070 100644 --- a/src/main/java/dev/compactmods/machines/CompactMachines.java +++ b/src/main/java/dev/compactmods/machines/CompactMachines.java @@ -4,6 +4,7 @@ import dev.compactmods.machines.config.EnableVanillaRecipesConfigCondition; import dev.compactmods.machines.config.ServerConfig; import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.rooms.chunkloading.CMRoomChunkloadingManager; import net.minecraft.item.ItemGroup; import net.minecraft.item.ItemStack; import net.minecraftforge.common.crafting.CraftingHelper; @@ -29,6 +30,8 @@ public ItemStack makeIcon() { } }; + public static CMRoomChunkloadingManager CHUNKLOAD_MANAGER; + public CompactMachines() { // Register blocks and items Registration.init(); diff --git a/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java b/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java index 14ef1f0a..36a0afe5 100644 --- a/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java +++ b/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java @@ -6,6 +6,7 @@ import java.util.Optional; import java.util.Set; import java.util.UUID; +import dev.compactmods.machines.CompactMachines; import dev.compactmods.machines.api.tunnels.ICapableTunnel; import dev.compactmods.machines.api.tunnels.TunnelDefinition; import dev.compactmods.machines.config.ServerConfig; @@ -26,6 +27,7 @@ import net.minecraft.tileentity.ITickableTileEntity; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.Direction; +import net.minecraft.util.concurrent.TickDelayedTask; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.ChunkPos; import net.minecraft.world.server.ServerWorld; @@ -33,6 +35,7 @@ import net.minecraftforge.common.capabilities.ICapabilityProvider; import net.minecraftforge.common.util.Constants; import net.minecraftforge.common.util.LazyOptional; +import net.minecraftforge.common.world.ForgeChunkManager; public class CompactMachineTile extends TileEntity implements ICapabilityProvider, ITickableTileEntity { public int machineId = -1; @@ -54,9 +57,21 @@ public CompactMachineTile() { @Override public void clearRemoved() { super.clearRemoved(); + } - if (ServerConfig.MACHINE_CHUNKLOADING.get()) - doChunkload(true); + @Override + public void onLoad() { + super.onLoad(); + + if(level == null || level.isClientSide) + return; + + if (ServerConfig.MACHINE_CHUNKLOADING.get()) { + final MinecraftServer server = ((ServerWorld) level).getServer(); + server.submitAsync(new TickDelayedTask(server.getTickCount() + 5, () -> { + CompactMachines.CHUNKLOAD_MANAGER.onMachineChunkLoad(machineId); + })); + } } @Override @@ -64,7 +79,7 @@ public void onChunkUnloaded() { super.onChunkUnloaded(); if (ServerConfig.MACHINE_CHUNKLOADING.get()) - doChunkload(false); + CompactMachines.CHUNKLOAD_MANAGER.onMachineChunkUnload(machineId); } @Override @@ -72,7 +87,7 @@ public void setRemoved() { super.setRemoved(); if (ServerConfig.MACHINE_CHUNKLOADING.get()) - doChunkload(false); + CompactMachines.CHUNKLOAD_MANAGER.onMachineChunkUnload(machineId); } @Override @@ -275,17 +290,6 @@ public boolean hasPlayersInside() { // .orElse(false); } - protected void doChunkload(boolean force) { - if (level == null || level.isClientSide) - return; - - getInternalChunkPos().ifPresent(chunk -> { - ServerWorld compact = this.level.getServer().getLevel(Registration.COMPACT_DIMENSION); - compact.setChunkForced(chunk.x, chunk.z, force); - - }); - } - public void doPostPlaced() { if (this.level == null || this.level.isClientSide) return; @@ -302,7 +306,8 @@ public void doPostPlaced() { CompactMachineData extern = CompactMachineData.get(serv); extern.setMachineLocation(this.machineId, dp); - doChunkload(true); + if(ServerConfig.MACHINE_CHUNKLOADING.get()) + CompactMachines.CHUNKLOAD_MANAGER.onMachineChunkLoad(machineId); } public void handlePlayerLeft(UUID playerID) { diff --git a/src/main/java/dev/compactmods/machines/core/ServerEventHandler.java b/src/main/java/dev/compactmods/machines/core/ServerEventHandler.java index 5743cc4b..48cfbcc7 100644 --- a/src/main/java/dev/compactmods/machines/core/ServerEventHandler.java +++ b/src/main/java/dev/compactmods/machines/core/ServerEventHandler.java @@ -2,6 +2,7 @@ import dev.compactmods.machines.CompactMachines; import dev.compactmods.machines.command.CMCommandRoot; +import dev.compactmods.machines.rooms.chunkloading.CMRoomChunkloadingManager; import net.minecraft.server.MinecraftServer; import net.minecraftforge.event.RegisterCommandsEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; @@ -14,6 +15,8 @@ public class ServerEventHandler { @SubscribeEvent public static void onServerStarting(final FMLServerStartingEvent evt) { MinecraftServer server = evt.getServer(); + + CompactMachines.CHUNKLOAD_MANAGER = new CMRoomChunkloadingManager(server); // SavedMachineDataMigrator.migrate(server); } diff --git a/src/main/java/dev/compactmods/machines/data/player/theory.txt b/src/main/java/dev/compactmods/machines/data/player/theory.txt deleted file mode 100644 index 3c9fd54e..00000000 --- a/src/main/java/dev/compactmods/machines/data/player/theory.txt +++ /dev/null @@ -1,60 +0,0 @@ -Player P -Machines A,B,C,D - -====================================================================== -machine locations (external) -====================================================================== -A (01): 00, 00, 00 @ overworld -B (02): 26, 40, 26 @ compact_world (inside A) -C (03): 51, 40, 51 @ compact_world (inside B) -D (04): 10, 10, 10 @ overworld -A (05): 76, 40, 76 @ compact_world (inside D) -A (06): 51, 40, 51 @ compact_world (inside C) - -====================================================================== -Tree View of machine nesting -====================================================================== -A from 01 (entangled - at 0,0,0 in overworld) - B from 02 (entered at 01, 40, 01) - C from 03 (entered at 26, 40, 26) - A from 06 (entangled - entered at 51, 40, 51) - -D from 04 (non-entangled, at 10, 10, 10 in overworld) - A from 05 (entangled, at 76, 40, 76 in compact_world) - -====================================================================== -Facts -====================================================================== -B is not entangled and inside A. -C is not entangled and inside B. -A is entangled, and inside C and D. -====================================================================== - -- P enters A from {0,0,0} (entry-1) -- P enters B from A. -- P enters C from B. -- P reenters A from C. - -====================================================================== -Deque status at end of entering A (06) - player_entry_history -====================================================================== -tail DimPos { 51, 40, 51 @ compact_world } (entered A from C) -- DimPos { 26, 40, 26 @ compact_world } (entered C from B) -- DimPos { 01, 40, 01 @ compact_world } (entered B from A) -head DimPos { 00, 00, 00 @ overworld } (entered A) - -Player P is represented as "inside" A, B, and C. -Re-entering machine A does not add a second entry to the list. - -====================================================================== -Deque status at end of entering A (05) - player_entry_history -====================================================================== -tail DimPos { 79, 40, 76 @ compact_world } (entered A from D) -head DimPos { 10, 00, 10 @ overworld } (entered D) - -Player P is represented as "inside" A, B, C, and D. - B and C are included because A is inside C, and the tree was traversed upwards. - - - - diff --git a/src/main/java/dev/compactmods/machines/rooms/chunkloading/CMRoomChunkloadingManager.java b/src/main/java/dev/compactmods/machines/rooms/chunkloading/CMRoomChunkloadingManager.java new file mode 100644 index 00000000..a1e9eafd --- /dev/null +++ b/src/main/java/dev/compactmods/machines/rooms/chunkloading/CMRoomChunkloadingManager.java @@ -0,0 +1,155 @@ +package dev.compactmods.machines.rooms.chunkloading; + +import java.util.*; +import com.google.common.collect.ImmutableList; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.data.graph.CompactMachineConnectionGraph; +import dev.compactmods.machines.data.persistent.CompactMachineData; +import dev.compactmods.machines.data.persistent.MachineConnections; +import dev.compactmods.machines.teleportation.DimensionalPosition; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.world.Dimension; +import net.minecraft.world.server.ServerWorld; +import net.minecraftforge.common.world.ForgeChunkManager; + +public class CMRoomChunkloadingManager implements IRoomChunkloadingManager { + + private final MinecraftServer server; + private final Map tickets; + + // TODO - Finish and serialize data + // see ForcedChunksSaveData + + public CMRoomChunkloadingManager(MinecraftServer server) { + this.server = server; + this.tickets = new HashMap<>(); + } + + @Override + public boolean roomIsLoaded(ChunkPos room) { + return tickets.containsKey(room); + } + + @Override + public boolean hasAnyMachinesLoaded() { + return !tickets.isEmpty(); + } + + @Override + public void onMachineChunkUnload(int machine) { + final Optional attachedRoom = getConnectedRoom(machine); + attachedRoom.ifPresent(room -> { + final Collection machines = getConnectedMachines(room); + switch (machines.size()) { + case 0: + case 1: + // No siblings or this is the only machine connected - unload the room + setChunkForced(room, false); + break; + + default: + // More than one machine attached to the room + // Need to see if any other machine is still loaded before decision + final CompactMachineData machData = CompactMachineData.get(server); + if (machData == null) { + // ohshi- + return; + } + + // true if any connected machine is loaded; false otherwise + boolean anyRoomMachineLoaded = machines.stream() + .map(machData::getMachineLocation) + .anyMatch(machLocation -> machLocation.map(d -> d.isLoaded(server)).orElse(false)); + + if(!anyRoomMachineLoaded) { + setChunkForced(room, false); + } + break; + } + }); + } + + @Override + public void onMachineChunkLoad(int machine) { + final Optional attachedRoom = getConnectedRoom(machine); + attachedRoom.ifPresent(room -> { + // If there's already a ticket for the room, early exit - another machine has it loaded + if (tickets.containsKey(room)) + return; + + setChunkForced(room, true); + }); + } + + private Optional getGraph() { + final MachineConnections conns = MachineConnections.get(server); + if (conns == null) + return Optional.empty(); + + return Optional.of(conns.graph); + } + + private Optional getConnectedRoom(int machine) { + return getGraph().flatMap(graph -> graph.getConnectedRoom(machine)); + } + + + private Collection getConnectedMachines(ChunkPos room) { + return getGraph().map(graph -> graph.getMachinesFor(room)) + .map(connectedMachines -> { + switch (connectedMachines.size()) { + case 0: + case 1: + // release ticket + return Collections.emptySet(); + + default: + // scan connected machines, if at least one is loaded then do not release + return ImmutableList.copyOf(connectedMachines); + } + }).orElse(Collections.emptySet()); + } + + private Collection getRoomConnectedMachines(int machine) { + final CompactMachineConnectionGraph graph = getGraph().orElse(null); + if (graph == null) + return Collections.emptySet(); + + return getConnectedRoom(machine) + .map(this::getConnectedMachines) + .orElse(Collections.emptySet()); + } + + private void setChunkForced(ChunkPos room, boolean force) { + // If trying to force and room was not previously set up + if (force && !tickets.containsKey(room)) { + UUID newTicket = UUID.randomUUID(); + tickets.put(room, newTicket); + } + + UUID ticket = tickets.get(room); + + ServerWorld compact = server.getLevel(Registration.COMPACT_DIMENSION); + + if (compact != null) { + boolean alreadyForced = compact.getForcedChunks().stream() + .anyMatch(chunkLong -> chunkLong.equals(room.toLong())); + + // if force status requires change + if(alreadyForced != force) { + // prevent deadlock? + compact.getChunk(room.x, room.z); + + boolean changed = ForgeChunkManager.forceChunk(compact, CompactMachines.MOD_ID, + ticket, room.x, room.z, force, true); + + if (!force && changed) { + tickets.remove(room); + } + } + } + + } +} diff --git a/src/main/java/dev/compactmods/machines/rooms/chunkloading/IRoomChunkloadingManager.java b/src/main/java/dev/compactmods/machines/rooms/chunkloading/IRoomChunkloadingManager.java new file mode 100644 index 00000000..06d5241a --- /dev/null +++ b/src/main/java/dev/compactmods/machines/rooms/chunkloading/IRoomChunkloadingManager.java @@ -0,0 +1,15 @@ +package dev.compactmods.machines.rooms.chunkloading; + +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.ChunkPos; + +public interface IRoomChunkloadingManager { + + boolean roomIsLoaded(ChunkPos room); + + boolean hasAnyMachinesLoaded(); + + void onMachineChunkUnload(int machine); + + void onMachineChunkLoad(int machine); +} diff --git a/src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java b/src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java index 7d06ff24..4b81b45d 100644 --- a/src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java +++ b/src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java @@ -5,6 +5,7 @@ import com.mojang.serialization.codecs.RecordCodecBuilder; import dev.compactmods.machines.CompactMachines; import dev.compactmods.machines.data.codec.CodecExtensions; +import dev.compactmods.machines.util.LocationUtil; import net.minecraft.entity.LivingEntity; import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.nbt.CompoundNBT; @@ -28,8 +29,10 @@ public class DimensionalPosition implements INBTSerializable { private Vector3d position; private Vector3d rotation; - // Note: We'd use the actual world registry key here, but it static loads the world and does a bunch - // of initialization, making it impossible to unit test without booting a whole server up. + /* + Note: We'd use the actual world registry key here, but it static loads the world and does a bunch + of initialization, making it impossible to unit test without booting a whole server up. + */ public static final Codec CODEC = RecordCodecBuilder.create(i -> i.group( CodecExtensions.WORLD_REGISTRY_KEY.fieldOf("dim").forGetter(DimensionalPosition::getDimension), CodecExtensions.VECTOR3D.fieldOf("pos").forGetter(DimensionalPosition::getPosition), @@ -65,6 +68,12 @@ public Optional getWorld(@Nonnull MinecraftServer server) { return Optional.ofNullable(server.getLevel(this.dimension)); } + public boolean isLoaded(MinecraftServer server) { + return getWorld(server) + .map(w -> w.isLoaded(LocationUtil.vectorToBlockPos(position))) + .orElse(false); + } + public static DimensionalPosition fromNBT(CompoundNBT nbt) { DimensionalPosition dp = new DimensionalPosition(); dp.deserializeNBT(nbt); @@ -104,7 +113,7 @@ public Vector3d getRotation() { } public BlockPos getBlockPosition() { - return new BlockPos(position.x, position.y, position.z); + return LocationUtil.vectorToBlockPos(position); } @Override diff --git a/src/main/java/dev/compactmods/machines/util/LocationUtil.java b/src/main/java/dev/compactmods/machines/util/LocationUtil.java index d282e335..ebefe0ec 100644 --- a/src/main/java/dev/compactmods/machines/util/LocationUtil.java +++ b/src/main/java/dev/compactmods/machines/util/LocationUtil.java @@ -12,4 +12,8 @@ public static Vector3d blockPosToVector(BlockPos pos) { pos.getZ() + 0.5f ); } + + public static BlockPos vectorToBlockPos(Vector3d position) { + return new BlockPos(position.x, position.y, position.z); + } } From 78a48748ebd3aa384440d099dac05819740dfbf2 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 28 Aug 2021 14:31:13 -0400 Subject: [PATCH 32/36] Clean up several code areas around CM blocks --- .../machines/block/BlockCompactMachine.java | 76 ------------------- .../block/tiles/CompactMachineTile.java | 24 +----- 2 files changed, 4 insertions(+), 96 deletions(-) diff --git a/src/main/java/dev/compactmods/machines/block/BlockCompactMachine.java b/src/main/java/dev/compactmods/machines/block/BlockCompactMachine.java index 44a821d9..65bdd41b 100644 --- a/src/main/java/dev/compactmods/machines/block/BlockCompactMachine.java +++ b/src/main/java/dev/compactmods/machines/block/BlockCompactMachine.java @@ -51,11 +51,6 @@ public BlockCompactMachine(EnumMachineSize size, AbstractBlock.Properties props) this.size = size; } - @Override - public void entityInside(BlockState p_196262_1_, World p_196262_2_, BlockPos p_196262_3_, Entity p_196262_4_) { - super.entityInside(p_196262_1_, p_196262_2_, p_196262_3_, p_196262_4_); - } - @Override public float getDestroyProgress(BlockState state, PlayerEntity player, IBlockReader worldIn, BlockPos pos) { CompactMachineTile tile = (CompactMachineTile) worldIn.getBlockEntity(pos); @@ -238,13 +233,6 @@ public ItemStack getPickBlock(BlockState state, RayTraceResult target, IBlockRea return stack; } - -// @Override -// public String getSpecialName(ItemStack stack) { -// return this.getStateFromMeta(stack.getItemDamage()).getValue(SIZE).getName(); -// } - - @Override public boolean hasTileEntity(BlockState state) { return true; @@ -256,27 +244,6 @@ public TileEntity createTileEntity(BlockState state, IBlockReader world) { return new CompactMachineTile(); } - @Override - public void destroy(IWorld world, BlockPos pos, BlockState state) { - if (world.isClientSide()) { - super.destroy(world, pos, state); - return; - } - - if (!(world.getBlockEntity(pos) instanceof CompactMachineTile)) { - return; - } - - CompactMachineTile te = (CompactMachineTile) world.getBlockEntity(pos); -// WorldSavedDataMachines.INSTANCE.removeMachinePosition(te.coords); -// -// BlockMachine.spawnItemWithNBT(world, pos, state.get(BlockMachine.SIZE), te); -// -// ChunkLoadingMachines.unforceChunk(te.coords); - - super.destroy(world, pos, state); - } - @Override public void setPlacedBy(World worldIn, BlockPos pos, BlockState state, @Nullable LivingEntity placer, ItemStack stack) { @@ -315,7 +282,6 @@ public void setPlacedBy(World worldIn, BlockPos pos, BlockState state, @Nullable } tile.doPostPlaced(); - tile.setChanged(); } @Override @@ -350,46 +316,4 @@ public EnumMachineSize getSize() { public void addProbeData(IProbeData data, PlayerEntity player, World world, BlockState state) { CompactMachineProvider.exec(data, world); } - - // 1.12.1 code -// @Override -// public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing side, float hitX, float hitY, float hitZ) { -// if(player.isSneaking()) { -// return false; -// } -// -// if(world.isRemote || !(player instanceof EntityPlayerMP)) { -// return true; -// } -// -// if(!(world.getTileEntity(pos) instanceof TileEntityMachine)) { -// return false; -// } -// -// TileEntityMachine machine = (TileEntityMachine)world.getTileEntity(pos); -// ItemStack playerStack = player.getHeldItemMainhand(); -// if(ShrinkingDeviceUtils.isShrinkingDevice(playerStack)) { -// TeleportationTools.tryToEnterMachine(player, machine); -// return true; -// } -// -// player.openGui(compactmachines.instance, GuiIds.MACHINE_VIEW.ordinal(), world, pos.getX(), pos.getY(), pos.getZ()); -// PackageHandler.instance.sendTo(new MessageMachineContent(machine.coords), (EntityPlayerMP)player); -// PackageHandler.instance.sendTo(new MessageMachineChunk(machine.coords), (EntityPlayerMP)player); -// -// return true; -// } - -// TOP code -// @Override -// public String getID() { -// return CompactMachines.MODID + ":" + "machine"; -// } -// -// @Override -// public void addProbeInfo(ProbeMode mode, IProbeInfo probeInfo, PlayerEntity player, World world, BlockState blockState, IProbeHitData data) { -// String size = this.size.getName(); -// probeInfo.text(new TranslationTextComponent("machines.sizes." + size)); -// - // } } diff --git a/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java b/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java index 36a0afe5..31c3d3b6 100644 --- a/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java +++ b/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java @@ -46,12 +46,9 @@ public class CompactMachineTile extends TileEntity implements ICapabilityProvide protected UUID owner; protected String schema; protected boolean locked = false; - protected Set playerWhiteList; public CompactMachineTile() { super(Registration.MACHINE_TILE_ENTITY.get()); - - playerWhiteList = new HashSet<>(); } @Override @@ -114,12 +111,6 @@ public void load(BlockState state, CompoundNBT nbt) { } else { locked = false; } - - playerWhiteList = new HashSet<>(); - if (nbt.contains("playerWhiteList")) { - ListNBT list = nbt.getList("playerWhiteList", Constants.NBT.TAG_STRING); - list.forEach(nametag -> playerWhiteList.add(nametag.getAsString())); - } } @Override @@ -140,16 +131,6 @@ public CompoundNBT save(CompoundNBT nbt) { nbt.putBoolean("locked", locked); - if (playerWhiteList.size() > 0) { - ListNBT list = new ListNBT(); - playerWhiteList.forEach(player -> { - StringNBT nameTag = StringNBT.valueOf(player); - list.add(nameTag); - }); - - nbt.put("playerWhiteList", list); - } - return nbt; } @@ -291,8 +272,9 @@ public boolean hasPlayersInside() { } public void doPostPlaced() { - if (this.level == null || this.level.isClientSide) + if (this.level == null || this.level.isClientSide) { return; + } MinecraftServer serv = this.level.getServer(); if (serv == null) @@ -308,6 +290,8 @@ public void doPostPlaced() { if(ServerConfig.MACHINE_CHUNKLOADING.get()) CompactMachines.CHUNKLOAD_MANAGER.onMachineChunkLoad(machineId); + + this.setChanged(); } public void handlePlayerLeft(UUID playerID) { From 5e6eadfdfa922506b30b0ccb15584cafb25c229f Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Fri, 5 Nov 2021 23:58:06 -0400 Subject: [PATCH 33/36] Set up API package --- build.gradle | 58 ++++++++++++++----- .../machines/api/core/Advancements.java | 0 .../machines/api/core/Constants.java | 0 .../machines/api/core/JeiInfo.java | 0 .../machines/api/core/Messages.java | 0 .../machines/api/core/Tooltips.java | 23 ++++++++ .../teleportation/IDimensionalPosition.java | 12 ++++ .../machines/api/tunnels/EnumTunnelSide.java | 0 .../machines/api/tunnels/ICapableTunnel.java | 5 ++ .../machines/api/tunnels/IItemTunnel.java | 0 .../api/tunnels/ITunnelConnectionInfo.java | 4 +- .../api/tunnels/TunnelDefinition.java | 2 + .../redstone/IRedstoneReaderTunnel.java | 0 .../api/tunnels/redstone/IRedstoneTunnel.java | 0 .../redstone/IRedstoneWriterTunnel.java | 0 15 files changed, 88 insertions(+), 16 deletions(-) rename src/{main => api}/java/dev/compactmods/machines/api/core/Advancements.java (100%) rename src/{main => api}/java/dev/compactmods/machines/api/core/Constants.java (100%) rename src/{main => api}/java/dev/compactmods/machines/api/core/JeiInfo.java (100%) rename src/{main => api}/java/dev/compactmods/machines/api/core/Messages.java (100%) create mode 100644 src/api/java/dev/compactmods/machines/api/core/Tooltips.java create mode 100644 src/api/java/dev/compactmods/machines/api/teleportation/IDimensionalPosition.java rename src/{main => api}/java/dev/compactmods/machines/api/tunnels/EnumTunnelSide.java (100%) rename src/{main => api}/java/dev/compactmods/machines/api/tunnels/ICapableTunnel.java (71%) rename src/{main => api}/java/dev/compactmods/machines/api/tunnels/IItemTunnel.java (100%) rename src/{main => api}/java/dev/compactmods/machines/api/tunnels/ITunnelConnectionInfo.java (84%) rename src/{main => api}/java/dev/compactmods/machines/api/tunnels/TunnelDefinition.java (83%) rename src/{main => api}/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneReaderTunnel.java (100%) rename src/{main => api}/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneTunnel.java (100%) rename src/{main => api}/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneWriterTunnel.java (100%) diff --git a/build.gradle b/build.gradle index e9dcbb7b..3ddb904b 100644 --- a/build.gradle +++ b/build.gradle @@ -1,7 +1,6 @@ buildscript { repositories { maven { url = 'https://files.minecraftforge.net/maven' } - jcenter() mavenCentral() } @@ -31,9 +30,25 @@ println("Version: ${version}"); sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = '1.8' // Need this here so eclipse task generates correctly. sourceSets { + api { + java { + srcDir "src/api/java" + } + compileClasspath += configurations.getByName("minecraft") + } + main { - resources.srcDir "src/generated/resources" + java { + srcDir "src/api/java" + srcDir "src/main/java" + } + + resources { + srcDir "src/main/resources" + srcDir 'src/generated/resources' + } } + test } @@ -114,19 +129,22 @@ minecraft { unitTests { parent runs.server // This run config inherits settings from the server config workingDirectory project.file('run/test') - main 'com.alcatrazescapee.mcjunitlib.DedicatedTestServerLauncher' // The main class which launches a customized server which then runs JUnit tests + main 'com.alcatrazescapee.mcjunitlib.DedicatedTestServerLauncher' + // The main class which launches a customized server which then runs JUnit tests ideaModule "${project.name}.test" // Tell IDEA to use the classpath of the test module - property 'forge.logging.console.level', 'unittest' // This logging level prevents any other server information messages and leaves only the unit test output + property 'forge.logging.console.level', 'unittest' + // This logging level prevents any other server information messages and leaves only the unit test output environment 'MOD_CLASSES', String.join(File.pathSeparator, "${mod_id}%%${sourceSets.main.output.resourcesDir}", "${mod_id}%%${sourceSets.main.output.classesDirs[0]}", "${mod_id}%%${sourceSets.test.output.resourcesDir}", "${mod_id}%%${sourceSets.test.output.classesDirs[0]}", ) // Forge will ignore all test sources unless we explicitly tell it to include them as mod sources - environment 'target', 'fmltestserver' // This is a custom service used to launch with ModLauncher's transforming class loader + environment 'target', 'fmltestserver' + // This is a custom service used to launch with ModLauncher's transforming class loader mods { compactmachines { // The mod that is being tested - Replace this with your mod ID! - sources sourceSets.main + sources sourceSets.api, sourceSets.main } } } @@ -191,6 +209,14 @@ repositories { name 'MCUnitTests' url 'https://jitpack.io' } + + // Curseforge stuff + maven { + url "https://cursemaven.com" + content { + includeGroup "curse.maven" + } + } } def dev_mods = fileTree(dev_mods_dir).filter { it -> it.isFile() }.files.name.collect({ getModVersion(it) }) @@ -203,10 +229,7 @@ dependencies { // Deobfuscate each dev mod for runtime - dev_mods.each { - compileOnly fg.deobf(it) - runtimeOnly fg.deobf(it) - } + dev_mods.each { implementation(fg.deobf(it)) } // JEI @@ -219,11 +242,20 @@ dependencies { testImplementation(fg.deobf("com.github.alcatrazEscapee:mcjunitlib:1.3.3-${minecraft_version}")) + // Nicephore - Screenshots and Stuff + runtimeOnly(fg.deobf("curse.maven:nicephore-401014:3318114")) + + // Mekanism + Mek Generators - Tunnel testing + runtimeOnly(fg.deobf("curse.maven:mekanism-268560:3206392")) + runtimeOnly(fg.deobf("curse.maven:mekanismgenerators-268566:3206395")) } // Example for how to get properties into the manifest for reading by the runtime.. jar { + from sourceSets.api.output + from sourceSets.main.output destinationDirectory = file("$rootDir/build-out") + finalizedBy('reobfJar') manifest { attributes([ @@ -231,7 +263,7 @@ jar { "Specification-Vendor" : "", "Specification-Version" : "1", // We are version 1 of ourselves "Implementation-Title" : project.name, - "Implementation-Version": isRelease ? archiveVersion : "nightly-${gitCommitHash}", + "Implementation-Version" : isRelease ? archiveVersion : "nightly-${gitCommitHash}", "Implementation-Vendor" : "", "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ") ]) @@ -239,10 +271,8 @@ jar { } task apiJar(type: Jar) { + from sourceSets.api.output // Sources included because of MinecraftForge/ForgeGradle#369 - from(sourceSets.main.allJava) - from(sourceSets.main.output) - include 'com/robotgryphon/compactmachines/api/**' archiveClassifier = 'api' destinationDirectory = file("$rootDir/build-out") } diff --git a/src/main/java/dev/compactmods/machines/api/core/Advancements.java b/src/api/java/dev/compactmods/machines/api/core/Advancements.java similarity index 100% rename from src/main/java/dev/compactmods/machines/api/core/Advancements.java rename to src/api/java/dev/compactmods/machines/api/core/Advancements.java diff --git a/src/main/java/dev/compactmods/machines/api/core/Constants.java b/src/api/java/dev/compactmods/machines/api/core/Constants.java similarity index 100% rename from src/main/java/dev/compactmods/machines/api/core/Constants.java rename to src/api/java/dev/compactmods/machines/api/core/Constants.java diff --git a/src/main/java/dev/compactmods/machines/api/core/JeiInfo.java b/src/api/java/dev/compactmods/machines/api/core/JeiInfo.java similarity index 100% rename from src/main/java/dev/compactmods/machines/api/core/JeiInfo.java rename to src/api/java/dev/compactmods/machines/api/core/JeiInfo.java diff --git a/src/main/java/dev/compactmods/machines/api/core/Messages.java b/src/api/java/dev/compactmods/machines/api/core/Messages.java similarity index 100% rename from src/main/java/dev/compactmods/machines/api/core/Messages.java rename to src/api/java/dev/compactmods/machines/api/core/Messages.java diff --git a/src/api/java/dev/compactmods/machines/api/core/Tooltips.java b/src/api/java/dev/compactmods/machines/api/core/Tooltips.java new file mode 100644 index 00000000..de00d05e --- /dev/null +++ b/src/api/java/dev/compactmods/machines/api/core/Tooltips.java @@ -0,0 +1,23 @@ +package dev.compactmods.machines.api.core; + +import net.minecraft.util.ResourceLocation; + +public abstract class Tooltips { + + public static final ResourceLocation UNKNOWN_PLAYER_NAME = new ResourceLocation(Constants.MOD_ID, "unknown_player"); + + public static abstract class Machines { + public static final ResourceLocation ID = new ResourceLocation(Constants.MOD_ID, "machine.id"); + public static final ResourceLocation OWNER = new ResourceLocation(Constants.MOD_ID, "machine.owner"); + public static final ResourceLocation SIZE = new ResourceLocation(Constants.MOD_ID, "machine.size"); + } + + //#region Hints and Details + public static final ResourceLocation HINT_HOLD_SHIFT = new ResourceLocation(Constants.MOD_ID, "hint.hold_shift"); + + public static abstract class Details { + public static final ResourceLocation PERSONAL_SHRINKING_DEVICE = new ResourceLocation(Constants.MOD_ID, "details.psd"); + public static final ResourceLocation SOLID_WALL = new ResourceLocation(Constants.MOD_ID, "details.solid_wall"); + } + //#endregion +} diff --git a/src/api/java/dev/compactmods/machines/api/teleportation/IDimensionalPosition.java b/src/api/java/dev/compactmods/machines/api/teleportation/IDimensionalPosition.java new file mode 100644 index 00000000..799166ee --- /dev/null +++ b/src/api/java/dev/compactmods/machines/api/teleportation/IDimensionalPosition.java @@ -0,0 +1,12 @@ +package dev.compactmods.machines.api.teleportation; + +import java.util.Optional; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.server.ServerWorld; + +public interface IDimensionalPosition { + BlockPos getBlockPosition(); + + Optional getWorld(MinecraftServer server); +} diff --git a/src/main/java/dev/compactmods/machines/api/tunnels/EnumTunnelSide.java b/src/api/java/dev/compactmods/machines/api/tunnels/EnumTunnelSide.java similarity index 100% rename from src/main/java/dev/compactmods/machines/api/tunnels/EnumTunnelSide.java rename to src/api/java/dev/compactmods/machines/api/tunnels/EnumTunnelSide.java diff --git a/src/main/java/dev/compactmods/machines/api/tunnels/ICapableTunnel.java b/src/api/java/dev/compactmods/machines/api/tunnels/ICapableTunnel.java similarity index 71% rename from src/main/java/dev/compactmods/machines/api/tunnels/ICapableTunnel.java rename to src/api/java/dev/compactmods/machines/api/tunnels/ICapableTunnel.java index cfda3d11..70e363ba 100644 --- a/src/main/java/dev/compactmods/machines/api/tunnels/ICapableTunnel.java +++ b/src/api/java/dev/compactmods/machines/api/tunnels/ICapableTunnel.java @@ -1,5 +1,6 @@ package dev.compactmods.machines.api.tunnels; +import dev.compactmods.machines.api.teleportation.IDimensionalPosition; import net.minecraft.util.Direction; import net.minecraft.util.math.BlockPos; import net.minecraft.world.server.ServerWorld; @@ -7,6 +8,8 @@ import net.minecraftforge.common.util.LazyOptional; import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.util.Map; /** * A base interface that marks a tunnel as supporting capabilities (items, fluids, etc.) @@ -18,4 +21,6 @@ public interface ICapableTunnel { @Nonnull LazyOptional getExternalCapability(ServerWorld world, BlockPos tunnelPos, @Nonnull Capability cap, Direction side); + + Map, LazyOptional> rebuildCapabilityCache(ServerWorld compactLevel, BlockPos tunnelPos, BlockPos inside, @Nullable IDimensionalPosition external); } diff --git a/src/main/java/dev/compactmods/machines/api/tunnels/IItemTunnel.java b/src/api/java/dev/compactmods/machines/api/tunnels/IItemTunnel.java similarity index 100% rename from src/main/java/dev/compactmods/machines/api/tunnels/IItemTunnel.java rename to src/api/java/dev/compactmods/machines/api/tunnels/IItemTunnel.java diff --git a/src/main/java/dev/compactmods/machines/api/tunnels/ITunnelConnectionInfo.java b/src/api/java/dev/compactmods/machines/api/tunnels/ITunnelConnectionInfo.java similarity index 84% rename from src/main/java/dev/compactmods/machines/api/tunnels/ITunnelConnectionInfo.java rename to src/api/java/dev/compactmods/machines/api/tunnels/ITunnelConnectionInfo.java index dde6367c..4e25b726 100644 --- a/src/main/java/dev/compactmods/machines/api/tunnels/ITunnelConnectionInfo.java +++ b/src/api/java/dev/compactmods/machines/api/tunnels/ITunnelConnectionInfo.java @@ -1,6 +1,6 @@ package dev.compactmods.machines.api.tunnels; -import dev.compactmods.machines.teleportation.DimensionalPosition; +import dev.compactmods.machines.api.teleportation.IDimensionalPosition; import net.minecraft.block.BlockState; import net.minecraft.util.Direction; import net.minecraft.world.IWorldReader; @@ -10,7 +10,7 @@ public interface ITunnelConnectionInfo { @Nonnull - Optional getConnectedPosition(EnumTunnelSide side); + Optional getConnectedPosition(EnumTunnelSide side); @Nonnull Optional getConnectedState(EnumTunnelSide side); diff --git a/src/main/java/dev/compactmods/machines/api/tunnels/TunnelDefinition.java b/src/api/java/dev/compactmods/machines/api/tunnels/TunnelDefinition.java similarity index 83% rename from src/main/java/dev/compactmods/machines/api/tunnels/TunnelDefinition.java rename to src/api/java/dev/compactmods/machines/api/tunnels/TunnelDefinition.java index ee4729a6..c8b2a978 100644 --- a/src/main/java/dev/compactmods/machines/api/tunnels/TunnelDefinition.java +++ b/src/api/java/dev/compactmods/machines/api/tunnels/TunnelDefinition.java @@ -1,8 +1,10 @@ package dev.compactmods.machines.api.tunnels; import net.minecraftforge.registries.ForgeRegistryEntry; +import net.minecraftforge.registries.IForgeRegistryEntry; public abstract class TunnelDefinition extends ForgeRegistryEntry + implements IForgeRegistryEntry { /** * The color of a non-indicator (the same color as the wall) diff --git a/src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneReaderTunnel.java b/src/api/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneReaderTunnel.java similarity index 100% rename from src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneReaderTunnel.java rename to src/api/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneReaderTunnel.java diff --git a/src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneTunnel.java b/src/api/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneTunnel.java similarity index 100% rename from src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneTunnel.java rename to src/api/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneTunnel.java diff --git a/src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneWriterTunnel.java b/src/api/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneWriterTunnel.java similarity index 100% rename from src/main/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneWriterTunnel.java rename to src/api/java/dev/compactmods/machines/api/tunnels/redstone/IRedstoneWriterTunnel.java From b9e452c4db96f159939bf0bcf6d176404fe1ad5c Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Fri, 5 Nov 2021 23:58:23 -0400 Subject: [PATCH 34/36] Remove commented FPS code --- .../dev/compactmods/machines/CompactMachines.java | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/src/main/java/dev/compactmods/machines/CompactMachines.java b/src/main/java/dev/compactmods/machines/CompactMachines.java index a379c070..ca60911f 100644 --- a/src/main/java/dev/compactmods/machines/CompactMachines.java +++ b/src/main/java/dev/compactmods/machines/CompactMachines.java @@ -17,7 +17,6 @@ import org.apache.logging.log4j.Logger; @Mod(CompactMachines.MOD_ID) -@Mod.EventBusSubscriber(modid = CompactMachines.MOD_ID) public class CompactMachines { public static final String MOD_ID = "compactmachines"; @@ -42,15 +41,4 @@ public CompactMachines() { CraftingHelper.register(EnableVanillaRecipesConfigCondition.Serializer.INSTANCE); } - - @SubscribeEvent - public static void onTick(TickEvent.RenderTickEvent e) { - // lol frames r good -// ObfuscationReflectionHelper.setPrivateValue( -// Minecraft.class, -// Minecraft.getInstance(), -// -100, -// "field_71420_M" -// ); - } } From 0b41d250b93640d948998f706a1f6c49c196d647 Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 6 Nov 2021 00:00:20 -0400 Subject: [PATCH 35/36] Tunnels: force existing tunnel blocks to unset, to be readded in 1.17 --- .../trigger/ClaimedMachineTrigger.java | 1 - .../machines/api/core/Tooltips.java | 25 ------ .../machines/block/BlockCompactMachine.java | 2 - .../block/tiles/CompactMachineTile.java | 40 --------- .../machines/block/tiles/TunnelWallTile.java | 81 +++++-------------- .../machines/block/walls/TunnelWallBlock.java | 51 +----------- .../compat/jei/CompactMachinesJeiPlugin.java | 1 - .../theoneprobe/providers/TunnelProvider.java | 5 +- .../compactmods/machines/item/TunnelItem.java | 75 ++--------------- .../CMRoomChunkloadingManager.java | 2 - .../teleportation/DimensionalPosition.java | 6 +- .../tunnels/TunnelConnectionInfo.java | 5 +- .../machines/tunnels/TunnelHelper.java | 41 ++++++++-- .../definitions/ItemTunnelDefinition.java | 49 +++++++++-- .../RedstoneInTunnelDefinition.java | 3 +- .../assets/compactmachines/lang/en_us.json | 1 + 16 files changed, 118 insertions(+), 270 deletions(-) delete mode 100644 src/main/java/dev/compactmods/machines/api/core/Tooltips.java diff --git a/src/main/java/dev/compactmods/machines/advancement/trigger/ClaimedMachineTrigger.java b/src/main/java/dev/compactmods/machines/advancement/trigger/ClaimedMachineTrigger.java index 1d834382..b34620ad 100644 --- a/src/main/java/dev/compactmods/machines/advancement/trigger/ClaimedMachineTrigger.java +++ b/src/main/java/dev/compactmods/machines/advancement/trigger/ClaimedMachineTrigger.java @@ -3,7 +3,6 @@ import com.google.gson.JsonObject; import dev.compactmods.machines.advancement.GenericAdvancementTriggerListener; import dev.compactmods.machines.advancement.GenericAdvancementTriggerListenerList; -import dev.compactmods.machines.api.core.Advancements; import net.minecraft.advancements.ICriterionTrigger; import net.minecraft.advancements.PlayerAdvancements; import net.minecraft.advancements.criterion.CriterionInstance; diff --git a/src/main/java/dev/compactmods/machines/api/core/Tooltips.java b/src/main/java/dev/compactmods/machines/api/core/Tooltips.java deleted file mode 100644 index 540e0792..00000000 --- a/src/main/java/dev/compactmods/machines/api/core/Tooltips.java +++ /dev/null @@ -1,25 +0,0 @@ -package dev.compactmods.machines.api.core; - -import net.minecraft.util.ResourceLocation; - -import static dev.compactmods.machines.api.core.Constants.MOD_ID; - -public abstract class Tooltips { - - public static final ResourceLocation UNKNOWN_PLAYER_NAME = new ResourceLocation(MOD_ID, "unknown_player"); - - public static abstract class Machines { - public static final ResourceLocation ID = new ResourceLocation(MOD_ID, "machine.id"); - public static final ResourceLocation OWNER = new ResourceLocation(MOD_ID, "machine.owner"); - public static final ResourceLocation SIZE = new ResourceLocation(MOD_ID, "machine.size"); - } - - //#region Hints and Details - public static final ResourceLocation HINT_HOLD_SHIFT = new ResourceLocation(MOD_ID, "hint.hold_shift"); - - public static abstract class Details { - public static final ResourceLocation PERSONAL_SHRINKING_DEVICE = new ResourceLocation(MOD_ID, "details.psd"); - public static final ResourceLocation SOLID_WALL = new ResourceLocation(MOD_ID, "details.solid_wall"); - } - //#endregion -} diff --git a/src/main/java/dev/compactmods/machines/block/BlockCompactMachine.java b/src/main/java/dev/compactmods/machines/block/BlockCompactMachine.java index 65bdd41b..6b3cbd20 100644 --- a/src/main/java/dev/compactmods/machines/block/BlockCompactMachine.java +++ b/src/main/java/dev/compactmods/machines/block/BlockCompactMachine.java @@ -17,7 +17,6 @@ import net.minecraft.block.AbstractBlock; import net.minecraft.block.Block; import net.minecraft.block.BlockState; -import net.minecraft.entity.Entity; import net.minecraft.entity.LivingEntity; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.entity.player.ServerPlayerEntity; @@ -32,7 +31,6 @@ import net.minecraft.util.math.BlockRayTraceResult; import net.minecraft.util.math.RayTraceResult; import net.minecraft.world.IBlockReader; -import net.minecraft.world.IWorld; import net.minecraft.world.World; import net.minecraft.world.server.ServerWorld; diff --git a/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java b/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java index 31c3d3b6..b056a4ff 100644 --- a/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java +++ b/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java @@ -2,7 +2,6 @@ import javax.annotation.Nonnull; import javax.annotation.Nullable; -import java.util.HashSet; import java.util.Optional; import java.util.Set; import java.util.UUID; @@ -19,8 +18,6 @@ import dev.compactmods.machines.tunnels.TunnelHelper; import net.minecraft.block.BlockState; import net.minecraft.nbt.CompoundNBT; -import net.minecraft.nbt.ListNBT; -import net.minecraft.nbt.StringNBT; import net.minecraft.network.NetworkManager; import net.minecraft.network.play.server.SUpdateTileEntityPacket; import net.minecraft.server.MinecraftServer; @@ -33,9 +30,7 @@ import net.minecraft.world.server.ServerWorld; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.common.capabilities.ICapabilityProvider; -import net.minecraftforge.common.util.Constants; import net.minecraftforge.common.util.LazyOptional; -import net.minecraftforge.common.world.ForgeChunkManager; public class CompactMachineTile extends TileEntity implements ICapabilityProvider, ITickableTileEntity { public int machineId = -1; @@ -134,41 +129,6 @@ public CompoundNBT save(CompoundNBT nbt) { return nbt; } - @Nonnull - @Override - public LazyOptional getCapability(@Nonnull Capability cap, @Nullable Direction side) { - if (level.isClientSide()) - return super.getCapability(cap, side); - - ServerWorld serverWorld = (ServerWorld) level; - ServerWorld compactWorld = serverWorld.getServer().getLevel(Registration.COMPACT_DIMENSION); - if (compactWorld == null) - return LazyOptional.empty(); - - Set tunnelPositions = TunnelHelper.getTunnelsForMachineSide(this.machineId, serverWorld, side); - if (tunnelPositions.isEmpty()) - return LazyOptional.empty(); - - for (BlockPos possibleTunnel : tunnelPositions) { - TunnelWallTile tile = (TunnelWallTile) compactWorld.getBlockEntity(possibleTunnel); - if (tile == null) - continue; - - Optional tunnel = tile.getTunnelDefinition(); - if (!tunnel.isPresent()) - continue; - - TunnelDefinition definition = tunnel.get(); - if (definition instanceof ICapableTunnel) { - LazyOptional capPoss = ((ICapableTunnel) definition).getInternalCapability(compactWorld, possibleTunnel, cap, side); - if (capPoss.isPresent()) - return capPoss; - } - } - - return LazyOptional.empty(); - } - @Nullable @Override public SUpdateTileEntityPacket getUpdatePacket() { diff --git a/src/main/java/dev/compactmods/machines/block/tiles/TunnelWallTile.java b/src/main/java/dev/compactmods/machines/block/tiles/TunnelWallTile.java index 12bd03fc..21a9fd1e 100644 --- a/src/main/java/dev/compactmods/machines/block/tiles/TunnelWallTile.java +++ b/src/main/java/dev/compactmods/machines/block/tiles/TunnelWallTile.java @@ -1,6 +1,8 @@ package dev.compactmods.machines.block.tiles; import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.api.teleportation.IDimensionalPosition; +import dev.compactmods.machines.api.tunnels.EnumTunnelSide; import dev.compactmods.machines.api.tunnels.ICapableTunnel; import dev.compactmods.machines.api.tunnels.TunnelDefinition; import dev.compactmods.machines.block.walls.TunnelWallBlock; @@ -10,9 +12,11 @@ import dev.compactmods.machines.network.NetworkHandler; import dev.compactmods.machines.network.TunnelAddedPacket; import dev.compactmods.machines.teleportation.DimensionalPosition; +import dev.compactmods.machines.tunnels.TunnelHelper; import net.minecraft.block.BlockState; import net.minecraft.nbt.CompoundNBT; import net.minecraft.server.MinecraftServer; +import net.minecraft.tileentity.ITickableTileEntity; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.Direction; import net.minecraft.util.ResourceLocation; @@ -24,19 +28,27 @@ import net.minecraftforge.common.util.LazyOptional; import net.minecraftforge.fml.common.registry.GameRegistry; import net.minecraftforge.fml.network.PacketDistributor; +import net.minecraftforge.items.CapabilityItemHandler; +import net.minecraftforge.items.IItemHandler; +import net.minecraftforge.items.ItemStackHandler; import javax.annotation.Nonnull; import javax.annotation.Nullable; import java.util.Collection; +import java.util.HashMap; +import java.util.Map; import java.util.Optional; -public class TunnelWallTile extends TileEntity { +public class TunnelWallTile extends TileEntity implements ITickableTileEntity { private int connectedMachine; private ResourceLocation tunnelType; + private final HashMap, LazyOptional> capabilityCache; + public TunnelWallTile() { super(Registration.TUNNEL_WALL_TILE.get()); + this.capabilityCache = new HashMap<>(); } @Override @@ -82,38 +94,8 @@ public void handleUpdateTag(BlockState state, CompoundNBT tag) { } } - public Optional getConnectedPosition() { - if (level == null || level.isClientSide()) - return Optional.empty(); - - ServerWorld serverWorld = (ServerWorld) level; - MinecraftServer serv = serverWorld.getServer(); - - MachineConnections connections = MachineConnections.get(serv); - CompactMachineData extern = CompactMachineData.get(serv); - if (connections == null || extern == null) - return Optional.empty(); - - if (this.connectedMachine <= 0) { - Optional mid = tryFindExternalMachineByChunkPos(connections); - - // Map the results - either it found an ID and we can map, or it found nothing - return mid.map(i -> { - this.connectedMachine = i; - Optional pos = extern.getMachineLocation(i); - return pos.map(p -> { - BlockPos bumped = p.getBlockPosition().relative(getConnectedSide(), 1); - return new DimensionalPosition(p.getDimension(), bumped); - }).orElse(null); - }); - } - - Optional pos = extern.getMachineLocation(this.connectedMachine); - return pos.map(p -> { - BlockPos bumped = p.getBlockPosition().relative(getConnectedSide(), 1); - DimensionalPosition bdp = new DimensionalPosition(p.getDimension(), bumped); - return bdp; - }); + public Optional getConnectedPosition() { + return Optional.empty(); } private Optional tryFindExternalMachineByChunkPos(MachineConnections connections) { @@ -172,33 +154,6 @@ public Optional getTunnelDefinition() { return Optional.ofNullable(definition); } - @Nonnull - @Override - public LazyOptional getCapability(@Nonnull Capability cap) { - return LazyOptional.empty(); - } - - @Nonnull - @Override - public LazyOptional getCapability(@Nonnull Capability cap, @Nullable Direction side) { - Optional tunnelDef = getTunnelDefinition(); - - // If we don't have a definition for the tunnel, skip - if (!tunnelDef.isPresent()) - return super.getCapability(cap, side); - - // loop through tunnel definition for capabilities - TunnelDefinition definition = tunnelDef.get(); - if (definition instanceof ICapableTunnel) { - if (!level.isClientSide) { - ServerWorld sw = (ServerWorld) level; - return ((ICapableTunnel) definition).getExternalCapability(sw, worldPosition, cap, side); - } - } - - return super.getCapability(cap, side); - } - public void setTunnelType(ResourceLocation registryName) { this.tunnelType = registryName; @@ -212,4 +167,10 @@ public void setTunnelType(ResourceLocation registryName) { .send(PacketDistributor.TRACKING_CHUNK.with(() -> chunkAt), pkt); } } + + @Override + public void tick() { + // first tick - unset this block, tunnels will be reimplemented in 1.17 + level.setBlockAndUpdate(worldPosition, Registration.BLOCK_SOLID_WALL.get().defaultBlockState()); + } } diff --git a/src/main/java/dev/compactmods/machines/block/walls/TunnelWallBlock.java b/src/main/java/dev/compactmods/machines/block/walls/TunnelWallBlock.java index cedd9f2f..d7eaf154 100644 --- a/src/main/java/dev/compactmods/machines/block/walls/TunnelWallBlock.java +++ b/src/main/java/dev/compactmods/machines/block/walls/TunnelWallBlock.java @@ -26,6 +26,7 @@ import net.minecraft.util.math.BlockRayTraceResult; import net.minecraft.world.IBlockReader; import net.minecraft.world.World; +import net.minecraft.world.server.ServerWorld; import javax.annotation.Nullable; import java.util.Optional; @@ -55,22 +56,12 @@ public Optional getTunnelInfo(IBlockReader world, BlockPos pos @Override public boolean canConnectRedstone(BlockState state, IBlockReader world, BlockPos pos, @Nullable Direction side) { - Optional tunnelInfo = getTunnelInfo(world, pos); - if (!tunnelInfo.isPresent()) - return false; - - TunnelDefinition definition = tunnelInfo.get(); - if (definition instanceof IRedstoneReaderTunnel) { - ITunnelConnectionInfo conn = TunnelHelper.generateConnectionInfo(world, pos); - return ((IRedstoneReaderTunnel) definition).canConnectRedstone(conn); - } - return false; } @Override public boolean isSignalSource(BlockState state) { - return state.getValue(REDSTONE); + return false; } @Override @@ -94,44 +85,6 @@ public int getSignal(BlockState state, IBlockReader world, BlockPos pos, Directi return 0; } - @Override - public ActionResultType use(BlockState state, World worldIn, BlockPos pos, PlayerEntity player, Hand handIn, BlockRayTraceResult hit) { - if (worldIn.isClientSide()) - return ActionResultType.SUCCESS; - - - if (player.isShiftKeyDown()) { - Optional tunnelDef = getTunnelInfo(worldIn, pos); - - if (!tunnelDef.isPresent()) - return ActionResultType.FAIL; - - BlockState solidWall = Registration.BLOCK_SOLID_WALL.get().defaultBlockState(); - - worldIn.setBlockAndUpdate(pos, solidWall); - - TunnelDefinition tunnelRegistration = tunnelDef.get(); - ItemStack stack = new ItemStack(Registration.ITEM_TUNNEL.get(), 1); - CompoundNBT defTag = stack.getOrCreateTagElement("definition"); - defTag.putString("id", tunnelRegistration.getRegistryName().toString()); - - ItemEntity ie = new ItemEntity(worldIn, player.getX(), player.getY(), player.getZ(), stack); - worldIn.addFreshEntity(ie); - -// IFormattableTextComponent t = new StringTextComponent(tunnelRegistration.getRegistryName().toString()) -// .mergeStyle(TextFormatting.GRAY); -// -// player.sendStatusMessage(t, true); - } else { - // Rotate tunnel - Direction dir = state.getValue(CONNECTED_SIDE); - Direction nextDir = TunnelHelper.getNextDirection(dir); - - worldIn.setBlockAndUpdate(pos, state.setValue(CONNECTED_SIDE, nextDir)); - } - return ActionResultType.SUCCESS; - } - @Override protected void createBlockStateDefinition(StateContainer.Builder builder) { builder.add(TUNNEL_SIDE).add(CONNECTED_SIDE).add(REDSTONE); diff --git a/src/main/java/dev/compactmods/machines/compat/jei/CompactMachinesJeiPlugin.java b/src/main/java/dev/compactmods/machines/compat/jei/CompactMachinesJeiPlugin.java index a8758ab4..c3bed33b 100644 --- a/src/main/java/dev/compactmods/machines/compat/jei/CompactMachinesJeiPlugin.java +++ b/src/main/java/dev/compactmods/machines/compat/jei/CompactMachinesJeiPlugin.java @@ -11,7 +11,6 @@ import mezz.jei.api.IModPlugin; import mezz.jei.api.JeiPlugin; import mezz.jei.api.constants.VanillaTypes; -import mezz.jei.api.ingredients.IIngredientType; import mezz.jei.api.registration.IRecipeRegistration; import mezz.jei.api.registration.ISubtypeRegistration; import mezz.jei.api.runtime.IJeiRuntime; diff --git a/src/main/java/dev/compactmods/machines/compat/theoneprobe/providers/TunnelProvider.java b/src/main/java/dev/compactmods/machines/compat/theoneprobe/providers/TunnelProvider.java index e35e670b..c00eab10 100644 --- a/src/main/java/dev/compactmods/machines/compat/theoneprobe/providers/TunnelProvider.java +++ b/src/main/java/dev/compactmods/machines/compat/theoneprobe/providers/TunnelProvider.java @@ -1,6 +1,7 @@ package dev.compactmods.machines.compat.theoneprobe.providers; import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.api.teleportation.IDimensionalPosition; import dev.compactmods.machines.api.tunnels.TunnelDefinition; import dev.compactmods.machines.block.tiles.TunnelWallTile; import dev.compactmods.machines.block.walls.TunnelWallBlock; @@ -49,7 +50,7 @@ private static void addProbeInfo(ProbeMode probeMode, IProbeInfo info, PlayerEnt if (tile == null) return; - Optional outside = TunnelHelper.getTunnelConnectedPosition(tile, EnumTunnelSide.OUTSIDE); + Optional outside = TunnelHelper.getTunnelConnectedPosition(tile, EnumTunnelSide.OUTSIDE); Optional connected = TunnelHelper.getConnectedState(tile, EnumTunnelSide.OUTSIDE); if (probeMode == ProbeMode.EXTENDED) { @@ -92,7 +93,7 @@ private static void addProbeInfo(ProbeMode probeMode, IProbeInfo info, PlayerEnt if (!outside.isPresent()) return; - DimensionalPosition outPos = outside.get(); + IDimensionalPosition outPos = outside.get(); ServerWorld connectedWorld = (ServerWorld) world; BlockPos outPosBlock = outPos.getBlockPosition(); diff --git a/src/main/java/dev/compactmods/machines/item/TunnelItem.java b/src/main/java/dev/compactmods/machines/item/TunnelItem.java index 71c462e9..ba5f2166 100644 --- a/src/main/java/dev/compactmods/machines/item/TunnelItem.java +++ b/src/main/java/dev/compactmods/machines/item/TunnelItem.java @@ -3,6 +3,7 @@ import dev.compactmods.machines.CompactMachines; import dev.compactmods.machines.api.core.Tooltips; import dev.compactmods.machines.block.tiles.TunnelWallTile; +import dev.compactmods.machines.block.walls.SolidWallBlock; import dev.compactmods.machines.block.walls.TunnelWallBlock; import dev.compactmods.machines.core.Registration; import dev.compactmods.machines.api.tunnels.TunnelDefinition; @@ -96,76 +97,16 @@ public static Optional getDefinition(ItemStack stack) { @Override public ActionResultType useOn(ItemUseContext context) { - World w = context.getLevel(); - if (w.isClientSide()) - return ActionResultType.SUCCESS; + final World level = context.getLevel(); + if(!level.isClientSide) { + final PlayerEntity player = context.getPlayer(); + final BlockState state = level.getBlockState(context.getClickedPos()); - BlockPos pos = context.getClickedPos(); - BlockState blockState = w.getBlockState(pos); - - if (blockState.getBlock() != Registration.BLOCK_SOLID_WALL.get()) - return ActionResultType.FAIL; - - if (context.getPlayer() instanceof ServerPlayerEntity) { - ItemStack is = context.getItemInHand(); - Item i = is.getItem(); - - TunnelItem ti = ((TunnelItem) i); - Optional definition = getDefinition(context.getItemInHand()); - - definition.ifPresent(def -> { - BlockState tunnelState = Registration.BLOCK_TUNNEL_WALL.get() - .defaultBlockState() - .setValue(TunnelWallBlock.TUNNEL_SIDE, context.getClickedFace()); - - // Redstone Support - boolean redstone = (def instanceof IRedstoneReaderTunnel); - tunnelState = tunnelState.setValue(TunnelWallBlock.REDSTONE, redstone); - w.setBlock(pos, tunnelState, 3); - - // Get the server and add a deferred task - allows the tile to be created on the client first - MinecraftServer server = ((ServerWorld) context.getLevel()).getServer(); - server.submitAsync(() -> { - TunnelWallTile tile = (TunnelWallTile) context.getLevel().getBlockEntity(context.getClickedPos()); - tile.setTunnelType(def.getRegistryName()); - }); - - is.shrink(1); - }); - - return ActionResultType.CONSUME; - } - - return ActionResultType.FAIL; - } - - /** - * Implementation for easily swapping a tunnel type for another. - * - * @param type - * @param player - * @param hand - * @return - */ - protected ActionResult swapTunnelType(Item type, PlayerEntity player, Hand hand) { - if (player instanceof ServerPlayerEntity) { - if (player.isShiftKeyDown()) { - ServerPlayerEntity serverPlayer = (ServerPlayerEntity) player; - ItemStack stack = serverPlayer.getItemInHand(hand); - ItemStack newStack = new ItemStack(type, stack.getCount()); - - serverPlayer.setItemInHand(hand, newStack); - - IFormattableTextComponent msg = new StringTextComponent("switch state") - .withStyle(TextFormatting.GOLD); - - serverPlayer.displayClientMessage(msg, true); - return ActionResult.consume(newStack); + if(state.getBlock() instanceof SolidWallBlock && player != null) { + player.displayClientMessage(TranslationUtil.message(new ResourceLocation(CompactMachines.MOD_ID, "tunnels_nyi")), true); } } - return ActionResult.pass(player.getItemInHand(hand)); + return ActionResultType.sidedSuccess(level.isClientSide); } - - } diff --git a/src/main/java/dev/compactmods/machines/rooms/chunkloading/CMRoomChunkloadingManager.java b/src/main/java/dev/compactmods/machines/rooms/chunkloading/CMRoomChunkloadingManager.java index a1e9eafd..70a845eb 100644 --- a/src/main/java/dev/compactmods/machines/rooms/chunkloading/CMRoomChunkloadingManager.java +++ b/src/main/java/dev/compactmods/machines/rooms/chunkloading/CMRoomChunkloadingManager.java @@ -7,10 +7,8 @@ import dev.compactmods.machines.data.graph.CompactMachineConnectionGraph; import dev.compactmods.machines.data.persistent.CompactMachineData; import dev.compactmods.machines.data.persistent.MachineConnections; -import dev.compactmods.machines.teleportation.DimensionalPosition; import net.minecraft.server.MinecraftServer; import net.minecraft.util.math.ChunkPos; -import net.minecraft.world.Dimension; import net.minecraft.world.server.ServerWorld; import net.minecraftforge.common.world.ForgeChunkManager; diff --git a/src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java b/src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java index 4b81b45d..0b159a1c 100644 --- a/src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java +++ b/src/main/java/dev/compactmods/machines/teleportation/DimensionalPosition.java @@ -4,10 +4,10 @@ import com.mojang.serialization.DataResult; import com.mojang.serialization.codecs.RecordCodecBuilder; import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.api.teleportation.IDimensionalPosition; import dev.compactmods.machines.data.codec.CodecExtensions; import dev.compactmods.machines.util.LocationUtil; import net.minecraft.entity.LivingEntity; -import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.nbt.CompoundNBT; import net.minecraft.nbt.INBT; import net.minecraft.nbt.NBTDynamicOps; @@ -23,7 +23,7 @@ import java.util.Objects; import java.util.Optional; -public class DimensionalPosition implements INBTSerializable { +public class DimensionalPosition implements INBTSerializable, IDimensionalPosition { private RegistryKey dimension; private Vector3d position; @@ -113,7 +113,7 @@ public Vector3d getRotation() { } public BlockPos getBlockPosition() { - return LocationUtil.vectorToBlockPos(position); + return new BlockPos(position.x, position.y, position.z); } @Override diff --git a/src/main/java/dev/compactmods/machines/tunnels/TunnelConnectionInfo.java b/src/main/java/dev/compactmods/machines/tunnels/TunnelConnectionInfo.java index 2d4a3195..dbc25376 100644 --- a/src/main/java/dev/compactmods/machines/tunnels/TunnelConnectionInfo.java +++ b/src/main/java/dev/compactmods/machines/tunnels/TunnelConnectionInfo.java @@ -1,10 +1,12 @@ package dev.compactmods.machines.tunnels; +import dev.compactmods.machines.api.teleportation.IDimensionalPosition; import dev.compactmods.machines.api.tunnels.EnumTunnelSide; import dev.compactmods.machines.api.tunnels.ITunnelConnectionInfo; import dev.compactmods.machines.block.tiles.TunnelWallTile; import dev.compactmods.machines.teleportation.DimensionalPosition; import net.minecraft.block.BlockState; +import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.server.MinecraftServer; import net.minecraft.util.Direction; import net.minecraft.world.IWorldReader; @@ -22,7 +24,7 @@ public class TunnelConnectionInfo implements ITunnelConnectionInfo { @Nonnull @Override - public Optional getConnectedPosition(EnumTunnelSide side) { + public Optional getConnectedPosition(EnumTunnelSide side) { return TunnelHelper.getTunnelConnectedPosition(tunnel, side); } @@ -33,6 +35,7 @@ public Optional getConnectedState(EnumTunnelSide side) { @Override public Optional getConnectedWorld(EnumTunnelSide side) { + ServerPlayerEntity sp; switch(side) { case INSIDE: return Optional.ofNullable(tunnel.getLevel()); diff --git a/src/main/java/dev/compactmods/machines/tunnels/TunnelHelper.java b/src/main/java/dev/compactmods/machines/tunnels/TunnelHelper.java index f5850f0d..ba39132b 100644 --- a/src/main/java/dev/compactmods/machines/tunnels/TunnelHelper.java +++ b/src/main/java/dev/compactmods/machines/tunnels/TunnelHelper.java @@ -1,25 +1,35 @@ package dev.compactmods.machines.tunnels; +import dev.compactmods.machines.api.teleportation.IDimensionalPosition; import dev.compactmods.machines.api.tunnels.EnumTunnelSide; import dev.compactmods.machines.api.tunnels.ITunnelConnectionInfo; import dev.compactmods.machines.api.tunnels.TunnelDefinition; import dev.compactmods.machines.block.tiles.TunnelWallTile; +import dev.compactmods.machines.block.walls.TunnelWallBlock; import dev.compactmods.machines.core.Registration; +import dev.compactmods.machines.data.persistent.CompactMachineData; +import dev.compactmods.machines.data.persistent.CompactRoomData; +import dev.compactmods.machines.data.persistent.MachineConnections; +import dev.compactmods.machines.reference.EnumMachineSize; import dev.compactmods.machines.teleportation.DimensionalPosition; import net.minecraft.block.BlockState; import net.minecraft.util.Direction; import net.minecraft.util.RegistryKey; import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.ChunkPos; import net.minecraft.world.IBlockReader; import net.minecraft.world.World; import net.minecraft.world.server.ServerWorld; import net.minecraftforge.fml.RegistryObject; import javax.annotation.Nonnull; +import java.util.Collections; import java.util.HashSet; import java.util.Optional; import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; public class TunnelHelper { @@ -71,10 +81,27 @@ public static Optional getTunnelDefinitionFromType(ResourceLoc public static Set getTunnelsForMachineSide(int machine, ServerWorld world, Direction machineSide) { ServerWorld compactWorld = world.getServer().getLevel(Registration.COMPACT_DIMENSION); + if (compactWorld == null) + return Collections.emptySet(); + + final MachineConnections machines = MachineConnections.get(world.getServer()); + final CompactRoomData rooms = CompactRoomData.get(world.getServer()); + if (machines == null || rooms == null) + return Collections.emptySet(); + + // TODO - Reimplement with capability - this is wasteful + return machines.graph.getConnectedRoom(machine).map(roomChunk -> { + return rooms.getInnerBounds(roomChunk) + .map(b -> b.inflate(1)) + .map(BlockPos::betweenClosedStream).orElse(Stream.empty()) + .filter(pos -> { + BlockState state = compactWorld.getBlockState(pos); + return state.getBlock() instanceof TunnelWallBlock; + }) + .map(BlockPos::immutable) + .collect(Collectors.toSet()); + }).orElse(Collections.emptySet()); - Set tunnelPositions = new HashSet<>(); - - // TODO - Reimplement with capability // CompactMachineServerData data = SavedMachineData.getInstance(world.getServer()).getData(); // // Optional mData = data.getMachineData(machine); @@ -110,12 +137,10 @@ public static Set getTunnelsForMachineSide(int machine, ServerWorld wo // tunnelPositions.addAll(tunnelPositionsFiltered); // } // }); - - return tunnelPositions; } @Nonnull - public static Optional getTunnelConnectedPosition(TunnelWallTile tunnel, EnumTunnelSide side) { + public static Optional getTunnelConnectedPosition(TunnelWallTile tunnel, EnumTunnelSide side) { switch (side) { case OUTSIDE: return tunnel.getConnectedPosition(); @@ -133,8 +158,8 @@ public static Optional getTunnelConnectedPosition(TunnelWal @Nonnull public static Optional getConnectedState(TunnelWallTile twt, EnumTunnelSide side) { - DimensionalPosition connectedPosition = getTunnelConnectedPosition(twt, side).orElse(null); - if(connectedPosition == null) + IDimensionalPosition connectedPosition = getTunnelConnectedPosition(twt, side).orElse(null); + if (connectedPosition == null) return Optional.empty(); // We need a server world to reach across dimensions to get information diff --git a/src/main/java/dev/compactmods/machines/tunnels/definitions/ItemTunnelDefinition.java b/src/main/java/dev/compactmods/machines/tunnels/definitions/ItemTunnelDefinition.java index 5bd71725..76be90aa 100644 --- a/src/main/java/dev/compactmods/machines/tunnels/definitions/ItemTunnelDefinition.java +++ b/src/main/java/dev/compactmods/machines/tunnels/definitions/ItemTunnelDefinition.java @@ -1,8 +1,9 @@ package dev.compactmods.machines.tunnels.definitions; +import dev.compactmods.machines.CompactMachines; +import dev.compactmods.machines.api.teleportation.IDimensionalPosition; import dev.compactmods.machines.api.tunnels.TunnelDefinition; import dev.compactmods.machines.block.tiles.TunnelWallTile; -import dev.compactmods.machines.teleportation.DimensionalPosition; import dev.compactmods.machines.api.tunnels.EnumTunnelSide; import dev.compactmods.machines.tunnels.TunnelHelper; import dev.compactmods.machines.api.tunnels.IItemTunnel; @@ -14,13 +15,15 @@ import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.common.util.LazyOptional; import net.minecraftforge.items.CapabilityItemHandler; +import net.minecraftforge.items.IItemHandler; +import net.minecraftforge.registries.IForgeRegistryEntry; import javax.annotation.Nonnull; import javax.annotation.Nullable; import java.awt.*; -import java.util.Optional; +import java.util.*; -public class ItemTunnelDefinition extends TunnelDefinition implements IItemTunnel { +public class ItemTunnelDefinition extends TunnelDefinition implements IItemTunnel, IForgeRegistryEntry { @Override public int getTunnelRingColor() { @@ -41,13 +44,13 @@ public LazyOptional getInternalCapability(ServerWorld compactWorld, Block if (!connectedState.isPresent()) return LazyOptional.empty(); - Optional tunnelConnectedPosition = TunnelHelper.getTunnelConnectedPosition(twt, EnumTunnelSide.INSIDE); + Optional tunnelConnectedPosition = TunnelHelper.getTunnelConnectedPosition(twt, EnumTunnelSide.INSIDE); if (!tunnelConnectedPosition.isPresent()) return LazyOptional.empty(); Direction tunnelSide = twt.getTunnelSide(); - DimensionalPosition connectedInsidePos = tunnelConnectedPosition.get(); + IDimensionalPosition connectedInsidePos = tunnelConnectedPosition.get(); if (connectedState.get().hasTileEntity()) { TileEntity connectedTile = compactWorld.getBlockEntity(connectedInsidePos.getBlockPosition()); if (connectedTile != null) { @@ -75,11 +78,11 @@ public LazyOptional getExternalCapability(ServerWorld world, BlockPos tun return LazyOptional.empty(); // link to external block capability - Optional connectedPosition = twt.getConnectedPosition(); + Optional connectedPosition = twt.getConnectedPosition(); if (!connectedPosition.isPresent()) return LazyOptional.empty(); - DimensionalPosition dimensionalPosition = connectedPosition.get(); + IDimensionalPosition dimensionalPosition = connectedPosition.get(); // CompactMachines.LOGGER.debug(String.format("[%s] %s %s", 0, dimensionalPosition.getDimension(), dimensionalPosition.getPosition())); Optional connectedWorld = dimensionalPosition.getWorld(world.getServer()); @@ -101,5 +104,35 @@ public LazyOptional getExternalCapability(ServerWorld world, BlockPos tun return LazyOptional.empty(); } - + @Override + public Map, LazyOptional> rebuildCapabilityCache(ServerWorld compactLevel, BlockPos tunnelPos, BlockPos inside, @Nullable IDimensionalPosition external) { + HashMap, LazyOptional> set = new HashMap<>(); + + BlockState innerState = compactLevel.getBlockState(inside); + if(!innerState.hasTileEntity()) + return Collections.emptyMap(); + + TileEntity innerTile = compactLevel.getBlockEntity(inside); + final LazyOptional items = innerTile.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY); + if(items.isPresent()) + set.put(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, items); + +// final Optional connectedLevel = external.getWorld(compactLevel.getServer()); +// connectedLevel.ifPresent(externLevel -> { +// final BlockPos externPos = external.getBlockPosition(); +// if (externLevel.isLoaded(externPos)) { +// BlockState connectedState = externLevel.getBlockState(externPos); +// if(connectedState.hasTileEntity()) { +// TileEntity connectedTile = externLevel.getBlockEntity(externPos); +// final LazyOptional items = connectedTile.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY); +// set.put(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, items); +// } +// } else { +// // other world not loaded - we need to defer this somehow TODO +// CompactMachines.LOGGER.debug("not loaded"); +// } +// }); + + return set; + } } diff --git a/src/main/java/dev/compactmods/machines/tunnels/definitions/RedstoneInTunnelDefinition.java b/src/main/java/dev/compactmods/machines/tunnels/definitions/RedstoneInTunnelDefinition.java index 73095ada..bb0f5b22 100644 --- a/src/main/java/dev/compactmods/machines/tunnels/definitions/RedstoneInTunnelDefinition.java +++ b/src/main/java/dev/compactmods/machines/tunnels/definitions/RedstoneInTunnelDefinition.java @@ -1,5 +1,6 @@ package dev.compactmods.machines.tunnels.definitions; +import dev.compactmods.machines.api.teleportation.IDimensionalPosition; import dev.compactmods.machines.api.tunnels.EnumTunnelSide; import dev.compactmods.machines.api.tunnels.ITunnelConnectionInfo; import dev.compactmods.machines.api.tunnels.TunnelDefinition; @@ -29,7 +30,7 @@ public int getTunnelIndicatorColor() { public int getPowerLevel(ITunnelConnectionInfo connectionInfo) { IWorldReader connectedWorld = connectionInfo.getConnectedWorld(EnumTunnelSide.OUTSIDE).orElse(null); if (connectedWorld instanceof ServerWorld) { - DimensionalPosition pos = connectionInfo.getConnectedPosition(EnumTunnelSide.OUTSIDE).orElse(null); + IDimensionalPosition pos = connectionInfo.getConnectedPosition(EnumTunnelSide.OUTSIDE).orElse(null); if (pos == null) return 0; diff --git a/src/main/resources/assets/compactmachines/lang/en_us.json b/src/main/resources/assets/compactmachines/lang/en_us.json index 5932293a..b5b0bb78 100644 --- a/src/main/resources/assets/compactmachines/lang/en_us.json +++ b/src/main/resources/assets/compactmachines/lang/en_us.json @@ -14,6 +14,7 @@ "message.compactmachines.no_machine_data": "No machine data loaded; report this.", "message.compactmachines.teleport_oob": "An otherworldly force prevents your teleportation.", "message.compactmachines.fixbiome_bad_dim": "Cannot use fixbiome command outside of a machine room.", + "message.compactmachines.tunnels_nyi": "Tunnels will be implemented in 1.17.", "block.compactmachines.machine": "Compact Machine", "block.compactmachines.machine_tiny": "Compact Machine (Tiny)", "block.compactmachines.machine_small": "Compact Machine (Small)", From 8c5725b304c2bd11e3aedcbca18bafa12a9da56a Mon Sep 17 00:00:00 2001 From: Ted Senft Date: Sat, 6 Nov 2021 00:11:10 -0400 Subject: [PATCH 36/36] Remove broken chunkloading code, will be reimplemented in 1.17 Toolchain issues are making this harder to implement; will re-evaluate in 1.17. --- .../block/tiles/CompactMachineTile.java | 34 ------------------- .../machines/config/ServerConfig.java | 5 --- 2 files changed, 39 deletions(-) diff --git a/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java b/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java index b056a4ff..313d9083 100644 --- a/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java +++ b/src/main/java/dev/compactmods/machines/block/tiles/CompactMachineTile.java @@ -51,37 +51,6 @@ public void clearRemoved() { super.clearRemoved(); } - @Override - public void onLoad() { - super.onLoad(); - - if(level == null || level.isClientSide) - return; - - if (ServerConfig.MACHINE_CHUNKLOADING.get()) { - final MinecraftServer server = ((ServerWorld) level).getServer(); - server.submitAsync(new TickDelayedTask(server.getTickCount() + 5, () -> { - CompactMachines.CHUNKLOAD_MANAGER.onMachineChunkLoad(machineId); - })); - } - } - - @Override - public void onChunkUnloaded() { - super.onChunkUnloaded(); - - if (ServerConfig.MACHINE_CHUNKLOADING.get()) - CompactMachines.CHUNKLOAD_MANAGER.onMachineChunkUnload(machineId); - } - - @Override - public void setRemoved() { - super.setRemoved(); - - if (ServerConfig.MACHINE_CHUNKLOADING.get()) - CompactMachines.CHUNKLOAD_MANAGER.onMachineChunkUnload(machineId); - } - @Override public void load(BlockState state, CompoundNBT nbt) { super.load(state, nbt); @@ -248,9 +217,6 @@ public void doPostPlaced() { CompactMachineData extern = CompactMachineData.get(serv); extern.setMachineLocation(this.machineId, dp); - if(ServerConfig.MACHINE_CHUNKLOADING.get()) - CompactMachines.CHUNKLOAD_MANAGER.onMachineChunkLoad(machineId); - this.setChanged(); } diff --git a/src/main/java/dev/compactmods/machines/config/ServerConfig.java b/src/main/java/dev/compactmods/machines/config/ServerConfig.java index 6a1947c1..75159948 100644 --- a/src/main/java/dev/compactmods/machines/config/ServerConfig.java +++ b/src/main/java/dev/compactmods/machines/config/ServerConfig.java @@ -12,7 +12,6 @@ public class ServerConfig { public static ForgeConfigSpec CONFIG; public static ForgeConfigSpec.EnumValue MACHINE_PLAYER_BREAK_HANDLING; - public static ForgeConfigSpec.BooleanValue MACHINE_CHUNKLOADING; public static ForgeConfigSpec.IntValue MACHINE_FLOOR_Y; @@ -41,10 +40,6 @@ private static void generateConfig() { EnumMachinePlayersBreakHandling.UNBREAKABLE, EnumGetMethod.NAME_IGNORECASE); - MACHINE_CHUNKLOADING = builder - .comment("Allow machines to chunkload their insides when the machines are loaded.") - .define("chunkloading", true); - MACHINE_FLOOR_Y = builder .comment("The Y-level to spawn machine floors at.") .defineInRange("floor", 40, 10, 200);