From 62f0661370ae823fff056f6d6405df3c12aae623 Mon Sep 17 00:00:00 2001 From: jonathan-x01 Date: Sat, 12 Jul 2025 16:33:31 -0400 Subject: [PATCH 1/4] - Added debug logger --- .../java/net/limit/cubliminal/util/Debug.java | 81 +++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 src/main/java/net/limit/cubliminal/util/Debug.java diff --git a/src/main/java/net/limit/cubliminal/util/Debug.java b/src/main/java/net/limit/cubliminal/util/Debug.java new file mode 100644 index 0000000..201b8c1 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/util/Debug.java @@ -0,0 +1,81 @@ +package net.limit.cubliminal.util; + +import net.limit.cubliminal.Cubliminal; +import org.apache.http.annotation.Obsolete; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class Debug { + private static final String MOD_ID = Cubliminal.MOD_ID; + private static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID); + + public static final String ANSI_BLUE = "\u001B[34m"; + public static final String ANSI_YELLOW = "\u001B[33m"; + public static final String ANSI_CYAN = "\u001B[36m"; + public static final String ANSI_MAGENTO = "\u001B[35m"; + public static final String ANSI_GREEN = "\u001B[32m"; + public static final String ANSI_RED = "\u001B[31m"; + public static final String ANSI_RESET = "\u001B[0m"; + + /** + * Outputs a debug message to the Minecraft log for debugging purposes. + * @param msg The message to include in the debug message. + */ + public static void debug(Object msg){ + StackTraceElement caller = Thread.currentThread().getStackTrace()[2]; + String loc = caller.getClassName() + "." + caller.getMethodName() + "()" + ANSI_MAGENTO + " [Line " + caller.getLineNumber() + "]"; + LOGGER.warn(ANSI_YELLOW + "{DEBUG | " + ANSI_CYAN + MOD_ID + ANSI_YELLOW + " | " + ANSI_BLUE + loc + ANSI_YELLOW + "}"); + String message = "%sMessage : %s%s"; + if (msg == null){ + LOGGER.error(String.format(message, ANSI_RED, "", msg)); + } else { + LOGGER.info(String.format(message, ANSI_GREEN, ANSI_RESET, msg)); + } + LOGGER.warn(ANSI_YELLOW + "-- DEBUG END --"); + } + + /** + * Outputs multiple lines of messages. + * @param msg The list of messages to display. + */ + public static void debug(Object... msg){ + StackTraceElement caller = Thread.currentThread().getStackTrace()[2]; + String loc = caller.getClassName() + "." + caller.getMethodName() + "() " + ANSI_MAGENTO + " [Line " + caller.getLineNumber() + "]" + ANSI_YELLOW; + LOGGER.warn(ANSI_YELLOW + "{DEBUG | " + ANSI_CYAN + MOD_ID + ANSI_YELLOW + " | " + ANSI_BLUE + loc + ANSI_YELLOW + "}"); + for (int i = 0; i < msg.length; i++){ + String message = "%sMessage %s(Line %d)%s : %s"; + if (msg[i] == null){ + LOGGER.error(String.format(message, ANSI_RED, ANSI_MAGENTO, i, ANSI_RED, msg[i])); + } else { + LOGGER.info(String.format(message, ANSI_GREEN, ANSI_MAGENTO, i, ANSI_RESET, msg[i])); + } + } + LOGGER.warn(ANSI_YELLOW + "-- DEBUG END --"); + } + + /** + * Displays a debug message every tick. Useful for methods that would run every tick, that way the IDE can handle it. + * @param age = Simply get the age of the entity. + * @param increment = How many times per tick the message will display. 20 ticks = 1 second + * @param msg = The message to display/ + */ + public static void debug(int age, int increment, Object msg){ + if (age % increment == 0){ + debug(msg); + } + } + + public static void debug(int age, int increment, Object... msg){ + if (age % increment == 0){ + debug(msg); + } + } + + /** + * Displays a message to the Minecraft log to list sectors that was loaded from the mod. + * @param c The class that has loaded. + */ + public static void displayRegisteredSectors(Class c){ + LOGGER.info(ANSI_GREEN + "{ LOADED | " + ANSI_CYAN + MOD_ID + ANSI_GREEN + " } " + ANSI_BLUE + c.getSimpleName()); + } +} From ddb54737b7ccac9a8b7f7171aec3eb94bf5c6620 Mon Sep 17 00:00:00 2001 From: jonathan-x01 Date: Sat, 12 Jul 2025 18:52:47 -0400 Subject: [PATCH 2/4] - Added custom fluids (WIP) --- .../block/fluids/BlackSludgeFluidBlock.java | 22 +++ .../block/fluids/ContaminatedWaterBlock.java | 20 +++ .../block/fluids/CustomFluidBlock.java | 150 ++++++++++++++++++ .../block/fluids/FluidBlockFactory.java | 10 ++ .../cubliminal/client/particle/Bubble.java | 46 ++++++ .../particle/ContaminatedWaterSplash.java | 29 ++++ .../particle/CubliminalParticleManager.java | 70 ++++++++ .../particle/CubliminalPipeLeakParticle.java | 81 ++++++++++ .../util/ParticleColorManagement.java | 29 ++++ .../client/util/CameraAccessor.java | 9 ++ .../client/util/CameraBackroomFluid.java | 33 ++++ .../cubliminal/fluid/AlmondWaterFluid.java | 102 ++++++++++++ .../fluid/BackroomsFlowableFluid.java | 92 +++++++++++ .../cubliminal/fluid/BlackSludgeFluid.java | 101 ++++++++++++ .../fluid/ContaminatedWaterFluid.java | 96 +++++++++++ .../cubliminal/init/CubliminalBlocks.java | 58 +++++++ .../cubliminal/init/CubliminalFluidTags.java | 20 +++ .../cubliminal/init/CubliminalFluids.java | 52 ++++++ .../cubliminal/mixin/LivingEntityMixin.java | 79 +++++++++ .../cubliminal/mixin/PlayerEntityMixin.java | 2 + .../mixin/client/BackgroundRendererMixin.java | 35 +++- .../cubliminal/mixin/client/CameraMixin.java | 29 ++++ .../particle/CubliminalParticleTypes.java | 40 +++++ .../limit/cubliminal/util/ColorManager.java | 35 ++++ .../blockstates/almond_water_fluid.json | 7 + .../blockstates/black_sludge_fluid.json | 7 + .../blockstates/contaminated_water_fluid.json | 7 + src/main/resources/cubliminal.accesswidener | 21 ++- src/main/resources/cubliminal.mixins.json | 2 + .../cubliminal/tags/fluids/custom_fluids.json | 11 ++ .../data/minecraft/tags/fluids/water.json | 9 ++ 31 files changed, 1302 insertions(+), 2 deletions(-) create mode 100644 src/main/java/net/limit/cubliminal/block/fluids/BlackSludgeFluidBlock.java create mode 100644 src/main/java/net/limit/cubliminal/block/fluids/ContaminatedWaterBlock.java create mode 100644 src/main/java/net/limit/cubliminal/block/fluids/CustomFluidBlock.java create mode 100644 src/main/java/net/limit/cubliminal/block/fluids/FluidBlockFactory.java create mode 100644 src/main/java/net/limit/cubliminal/client/particle/Bubble.java create mode 100644 src/main/java/net/limit/cubliminal/client/particle/ContaminatedWaterSplash.java create mode 100644 src/main/java/net/limit/cubliminal/client/particle/CubliminalParticleManager.java create mode 100644 src/main/java/net/limit/cubliminal/client/particle/CubliminalPipeLeakParticle.java create mode 100644 src/main/java/net/limit/cubliminal/client/particle/util/ParticleColorManagement.java create mode 100644 src/main/java/net/limit/cubliminal/client/util/CameraAccessor.java create mode 100644 src/main/java/net/limit/cubliminal/client/util/CameraBackroomFluid.java create mode 100644 src/main/java/net/limit/cubliminal/fluid/AlmondWaterFluid.java create mode 100644 src/main/java/net/limit/cubliminal/fluid/BackroomsFlowableFluid.java create mode 100644 src/main/java/net/limit/cubliminal/fluid/BlackSludgeFluid.java create mode 100644 src/main/java/net/limit/cubliminal/fluid/ContaminatedWaterFluid.java create mode 100644 src/main/java/net/limit/cubliminal/init/CubliminalFluidTags.java create mode 100644 src/main/java/net/limit/cubliminal/init/CubliminalFluids.java create mode 100644 src/main/java/net/limit/cubliminal/mixin/LivingEntityMixin.java create mode 100644 src/main/java/net/limit/cubliminal/mixin/client/CameraMixin.java create mode 100644 src/main/java/net/limit/cubliminal/particle/CubliminalParticleTypes.java create mode 100644 src/main/java/net/limit/cubliminal/util/ColorManager.java create mode 100644 src/main/resources/assets/cubliminal/blockstates/almond_water_fluid.json create mode 100644 src/main/resources/assets/cubliminal/blockstates/black_sludge_fluid.json create mode 100644 src/main/resources/assets/cubliminal/blockstates/contaminated_water_fluid.json create mode 100644 src/main/resources/data/cubliminal/tags/fluids/custom_fluids.json create mode 100644 src/main/resources/data/minecraft/tags/fluids/water.json diff --git a/src/main/java/net/limit/cubliminal/block/fluids/BlackSludgeFluidBlock.java b/src/main/java/net/limit/cubliminal/block/fluids/BlackSludgeFluidBlock.java new file mode 100644 index 0000000..0fc950a --- /dev/null +++ b/src/main/java/net/limit/cubliminal/block/fluids/BlackSludgeFluidBlock.java @@ -0,0 +1,22 @@ +package net.limit.cubliminal.block.fluids; + +import net.limit.cubliminal.init.CubliminalEffects; +import net.minecraft.block.AbstractBlock; +import net.minecraft.entity.effect.StatusEffectInstance; +import net.minecraft.fluid.FlowableFluid; +import net.minecraft.registry.Registries; + +public class BlackSludgeFluidBlock extends CustomFluidBlock { + public BlackSludgeFluidBlock(FlowableFluid fluid, AbstractBlock.Settings settings, CustomFluidBlock.Settings fluidSettings) { + super(fluid, settings, fluidSettings); + } + + @Override + protected StatusEffectInstance[] applyEffectsToEntities() { + super.applyEffectsToEntities(); + + return new StatusEffectInstance[]{ + new StatusEffectInstance(Registries.STATUS_EFFECT.getEntry(CubliminalEffects.PARANOIA), 1800) + }; + } +} diff --git a/src/main/java/net/limit/cubliminal/block/fluids/ContaminatedWaterBlock.java b/src/main/java/net/limit/cubliminal/block/fluids/ContaminatedWaterBlock.java new file mode 100644 index 0000000..5b4502e --- /dev/null +++ b/src/main/java/net/limit/cubliminal/block/fluids/ContaminatedWaterBlock.java @@ -0,0 +1,20 @@ +package net.limit.cubliminal.block.fluids; + +import net.minecraft.block.AbstractBlock; +import net.minecraft.entity.effect.StatusEffectInstance; +import net.minecraft.entity.effect.StatusEffects; +import net.minecraft.fluid.FlowableFluid; + +public class ContaminatedWaterBlock extends CustomFluidBlock { + public ContaminatedWaterBlock(FlowableFluid fluid, AbstractBlock.Settings settings, CustomFluidBlock.Settings fluidSettings) { + super(fluid, settings, fluidSettings); + } + + @Override + protected StatusEffectInstance[] applyEffectsToEntities() { + return new StatusEffectInstance[]{ + new StatusEffectInstance(StatusEffects.NAUSEA, 600, 1), + new StatusEffectInstance(StatusEffects.POISON, 300, 1) + }; + } +} diff --git a/src/main/java/net/limit/cubliminal/block/fluids/CustomFluidBlock.java b/src/main/java/net/limit/cubliminal/block/fluids/CustomFluidBlock.java new file mode 100644 index 0000000..4080473 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/block/fluids/CustomFluidBlock.java @@ -0,0 +1,150 @@ +package net.limit.cubliminal.block.fluids; + +import com.google.common.collect.Iterables; +import com.google.common.collect.Maps; +import net.limit.cubliminal.util.ColorManager; +import net.minecraft.block.AbstractBlock; +import net.minecraft.block.BlockState; +import net.minecraft.block.FluidBlock; +import net.minecraft.entity.Entity; +import net.minecraft.entity.LivingEntity; +import net.minecraft.entity.effect.StatusEffectInstance; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.fluid.FlowableFluid; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Vec3d; +import net.minecraft.world.World; + +import java.util.Map; + +public class CustomFluidBlock extends FluidBlock { + private static final Map FLUIDS = Maps.newIdentityHashMap(); + protected final CustomFluidBlock.Settings settings; + private final FlowableFluid fluid; + + public CustomFluidBlock(FlowableFluid fluid, AbstractBlock.Settings settings, CustomFluidBlock.Settings fluidSettings){ + super(fluid, settings); + this.settings = fluidSettings; + this.fluid = fluid; + FLUIDS.put(fluid, this); + } + + protected StatusEffectInstance[] applyEffectsToEntities(){ + return new StatusEffectInstance[0]; + } + + public static Iterable getAll(){ + return Iterables.unmodifiableIterable(FLUIDS.values()); + } + + public int getColor(int tintIndex) { + return tintIndex == 0 ? this.settings.primaryColor.getHexColor() : 0; + } + + public ColorManager getColor(){ + return this.settings.primaryColor; + } + + public FlowableFluid getFluid(){ + return this.fluid; + } + + private void setEffectsOnEntities(StatusEffectInstance[] effects, LivingEntity living){ + for (StatusEffectInstance effect : effects){ + living.addStatusEffect(effect); + } + } + + public CustomFluidBlock.Settings getFluidSettings(){ + return this.settings; + } + + @Override + public void onEntityCollision(BlockState state, World world, BlockPos pos, Entity entity) { + super.onEntityCollision(state, world, pos, entity); + if (entity instanceof LivingEntity living){ + if (entity instanceof PlayerEntity player){ + if (!player.isCreative()){ + setEffectsOnEntities(applyEffectsToEntities(), living); + } + } else { + setEffectsOnEntities(applyEffectsToEntities(), living); + } + } + } + + public static class Settings { + boolean useDefaultFluidPhysics; + ColorManager primaryColor; + float fogStart; + float fogEnd; + Vec3d drag; + float speed; + + private Settings(){ + this.useDefaultFluidPhysics = true; + this.fogStart = -8.0f; + this.fogEnd = 25.0f; + } + + public static Settings create(){ + return new Settings(); + } + + public Settings useDefaultPhysics(boolean useDefault){ + this.useDefaultFluidPhysics = useDefault; + return this; + } + + public boolean usesDefaultPhysics(){ + return this.useDefaultFluidPhysics; + } + + public Settings setDrag(Vec3d drag){ + this.drag = drag; + this.useDefaultPhysics(false); + return this; + } + + public Vec3d getDrag(){ + return this.drag; + } + + public Settings setColor(int hex){ + this.primaryColor = new ColorManager(hex); + return this; + } + + public ColorManager getColor(){ + return this.primaryColor; + } + + public Settings setFogStart(float fogStart){ + this.fogStart = fogStart; + return this; + } + + public float getFogStart(){ + return this.fogStart; + } + + public Settings setFogEnd(float fogEnd){ + this.fogEnd = fogEnd; + return this; + } + + public float getFogEnd(){ + return this.fogEnd; + } + + public Settings setSpeed(float speed){ + this.speed = speed; + this.useDefaultPhysics(false); + return this; + } + + public float getSpeed(){ + return this.speed; + } + } +} diff --git a/src/main/java/net/limit/cubliminal/block/fluids/FluidBlockFactory.java b/src/main/java/net/limit/cubliminal/block/fluids/FluidBlockFactory.java new file mode 100644 index 0000000..9e2fae5 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/block/fluids/FluidBlockFactory.java @@ -0,0 +1,10 @@ +package net.limit.cubliminal.block.fluids; + +import net.minecraft.block.AbstractBlock; +import net.minecraft.block.Block; +import net.minecraft.fluid.FlowableFluid; + +@FunctionalInterface +public interface FluidBlockFactory { + Block create(FlowableFluid fluid, AbstractBlock.Settings settings, CustomFluidBlock.Settings fluidSettings); +} diff --git a/src/main/java/net/limit/cubliminal/client/particle/Bubble.java b/src/main/java/net/limit/cubliminal/client/particle/Bubble.java new file mode 100644 index 0000000..2d1109e --- /dev/null +++ b/src/main/java/net/limit/cubliminal/client/particle/Bubble.java @@ -0,0 +1,46 @@ +package net.limit.cubliminal.client.particle; + +import net.limit.cubliminal.client.particle.util.ParticleColorManagement; +import net.minecraft.client.particle.Particle; +import net.minecraft.client.particle.ParticleFactory; +import net.minecraft.client.particle.SpriteProvider; +import net.minecraft.client.particle.WaterBubbleParticle; +import net.minecraft.client.world.ClientWorld; +import net.minecraft.particle.SimpleParticleType; + +public class Bubble { + public static class AlmondWaterBubbleFactory implements ParticleFactory { + private final SpriteProvider spriteProvider; + + public AlmondWaterBubbleFactory(SpriteProvider spriteProvider) { + this.spriteProvider = spriteProvider; + } + + @Override + public Particle createParticle(SimpleParticleType type, ClientWorld world, double x, double y, double z, + double velocityX, double velocityY, double velocityZ) { + WaterBubbleParticle particle = new WaterBubbleParticle(world, x, y, z, velocityX, velocityY, velocityZ); + particle.setColor(ParticleColorManagement.ALMOND_WATER[0], ParticleColorManagement.ALMOND_WATER[1], ParticleColorManagement.ALMOND_WATER[2]); + particle.setSprite(spriteProvider); + return particle; + } + } + + public static class ContaminatedWaterBubbleFactory implements ParticleFactory { + private final SpriteProvider spriteProvider; + + public ContaminatedWaterBubbleFactory(SpriteProvider spriteProvider) { + this.spriteProvider = spriteProvider; + } + + @Override + public Particle createParticle(SimpleParticleType type, ClientWorld world, double x, double y, double z, + double velocityX, double velocityY, double velocityZ) { + WaterBubbleParticle particle = new WaterBubbleParticle(world, x, y, z, velocityX, velocityY, velocityZ); + float[] color = ParticleColorManagement.chooseRandomContaminatedWaterColors(); + particle.setColor(color[0], color[1], color[2]); + particle.setSprite(spriteProvider); + return particle; + } + } +} diff --git a/src/main/java/net/limit/cubliminal/client/particle/ContaminatedWaterSplash.java b/src/main/java/net/limit/cubliminal/client/particle/ContaminatedWaterSplash.java new file mode 100644 index 0000000..fed2c2b --- /dev/null +++ b/src/main/java/net/limit/cubliminal/client/particle/ContaminatedWaterSplash.java @@ -0,0 +1,29 @@ +package net.limit.cubliminal.client.particle; + +import net.limit.cubliminal.client.particle.util.ParticleColorManagement; +import net.minecraft.client.particle.Particle; +import net.minecraft.client.particle.ParticleFactory; +import net.minecraft.client.particle.SpriteProvider; +import net.minecraft.client.particle.WaterSplashParticle; +import net.minecraft.client.world.ClientWorld; +import net.minecraft.particle.SimpleParticleType; + +public class ContaminatedWaterSplash { + public static class Factory implements ParticleFactory { + private final SpriteProvider spriteProvider; + + public Factory(SpriteProvider spriteProvider) { + this.spriteProvider = spriteProvider; + } + + @Override + public Particle createParticle(SimpleParticleType type, ClientWorld world, double x, double y, double z, + double velocityX, double velocityY, double velocityZ) { + WaterSplashParticle particle = new WaterSplashParticle(world, x, y, z, velocityX, velocityY, velocityZ); + float[] color = ParticleColorManagement.chooseRandomContaminatedWaterColors(); + particle.setColor(color[0], color[1], color[2]); + particle.setSprite(spriteProvider); + return particle; + } + } +} diff --git a/src/main/java/net/limit/cubliminal/client/particle/CubliminalParticleManager.java b/src/main/java/net/limit/cubliminal/client/particle/CubliminalParticleManager.java new file mode 100644 index 0000000..0ae435f --- /dev/null +++ b/src/main/java/net/limit/cubliminal/client/particle/CubliminalParticleManager.java @@ -0,0 +1,70 @@ +package net.limit.cubliminal.client.particle; + +import net.fabricmc.api.EnvType; +import net.fabricmc.api.Environment; +import net.fabricmc.fabric.api.client.particle.v1.ParticleFactoryRegistry; +import net.limit.cubliminal.Initer; +import net.limit.cubliminal.particle.CubliminalParticleTypes; +import net.minecraft.client.particle.ParticleFactory; +import net.minecraft.client.particle.SpriteBillboardParticle; +import net.minecraft.client.particle.SpriteProvider; +import net.minecraft.client.particle.WaterSplashParticle; +import net.minecraft.particle.ParticleEffect; +import net.minecraft.particle.ParticleType; +import net.minecraft.resource.ResourceManager; +import net.minecraft.resource.ResourceReloader; +import net.minecraft.util.profiler.Profiler; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.Executor; +import java.util.function.Function; + +@Environment(EnvType.CLIENT) +public class CubliminalParticleManager implements ResourceReloader, Initer { + @Override + public void init() { + registerSplashFactory(CubliminalParticleTypes.SPLASH, WaterSplashParticle.SplashFactory::new); + registerFactory(CubliminalParticleTypes.CONTAMINATED_WATER_SPLASH, ContaminatedWaterSplash.Factory::new); + registerFactory(CubliminalParticleTypes.ALMOND_WATER_BUBBLE, Bubble.AlmondWaterBubbleFactory::new); + registerFactory(CubliminalParticleTypes.CONTAMINATED_WATER_BUBBLE, Bubble.ContaminatedWaterBubbleFactory::new); + + registerPipeLeakFactory(CubliminalParticleTypes.DRIPPING_ALMOND_WATER, CubliminalPipeLeakParticle::createDrippingAlmondWater); + registerPipeLeakFactory(CubliminalParticleTypes.FALLING_ALMOND_WATER, CubliminalPipeLeakParticle::createFallingAlmondWater); + registerPipeLeakFactory(CubliminalParticleTypes.LANDING_ALMOND_WATER, CubliminalPipeLeakParticle::createLandingAlmondWater); + + registerPipeLeakFactory(CubliminalParticleTypes.DRIPPING_BLACK_SLUDGE, CubliminalPipeLeakParticle::createDrippingBlackSludge); + registerPipeLeakFactory(CubliminalParticleTypes.FALLING_BLACK_SLUDGE, CubliminalPipeLeakParticle::createFallingBlackSludge); + registerPipeLeakFactory(CubliminalParticleTypes.LANDING_BLACK_SLUDGE, CubliminalPipeLeakParticle::createLandingBlackSludge); + + registerPipeLeakFactory(CubliminalParticleTypes.DRIPPING_CONTAMINATED_WATER, CubliminalPipeLeakParticle::createDrippingContaminatedWater); + registerPipeLeakFactory(CubliminalParticleTypes.FALLING_CONTAMINATED_WATER, CubliminalPipeLeakParticle::createFallingContaminatedWater); + registerPipeLeakFactory(CubliminalParticleTypes.LANDING_CONTAMINATED_WATER, CubliminalPipeLeakParticle::createLandingContaminatedWater); + } + + public static void registerFactory( + ParticleType type, + Function> factoryProvider + ) { + ParticleFactoryRegistry.getInstance().register(type, factoryProvider::apply); + } + + public static void registerSplashFactory(ParticleType type, ParticleFactoryRegistry.PendingParticleFactory factory){ + ParticleFactoryRegistry.getInstance().register(type, factory); + } + + public static void registerPipeLeakFactory(ParticleType type, ParticleFactory.BlockLeakParticleFactory factory) { + ParticleFactoryRegistry.getInstance().register(type, spriteProvider -> + (parameters, world, x, y, z, vx, vy, vz) -> { + SpriteBillboardParticle particle = factory.createParticle(parameters, world, x, y, z, vx, vy, vz); + if (particle != null){ + particle.setSprite(spriteProvider); + } + return particle; + }); + } + + @Override + public CompletableFuture reload(Synchronizer synchronizer, ResourceManager manager, Executor prepareExecutor, Executor applyExecutor) { + return null; + } +} diff --git a/src/main/java/net/limit/cubliminal/client/particle/CubliminalPipeLeakParticle.java b/src/main/java/net/limit/cubliminal/client/particle/CubliminalPipeLeakParticle.java new file mode 100644 index 0000000..a9903c6 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/client/particle/CubliminalPipeLeakParticle.java @@ -0,0 +1,81 @@ +package net.limit.cubliminal.client.particle; + +import net.fabricmc.api.EnvType; +import net.fabricmc.api.Environment; +import net.limit.cubliminal.client.particle.util.ParticleColorManagement; +import net.limit.cubliminal.particle.CubliminalParticleTypes; +import net.minecraft.client.particle.BlockLeakParticle; +import net.minecraft.client.particle.SpriteBillboardParticle; +import net.minecraft.client.particle.WaterSplashParticle; +import net.minecraft.client.world.ClientWorld; +import net.minecraft.fluid.Fluid; +import net.minecraft.fluid.Fluids; +import net.minecraft.particle.SimpleParticleType; + +@Environment(EnvType.CLIENT) +public class CubliminalPipeLeakParticle extends BlockLeakParticle { + public static float[] chosenCWColors; + protected CubliminalPipeLeakParticle(ClientWorld world, double x, double y, double z, Fluid fluid) { + super(world, x, y, z, fluid); + this.gravityStrength = 0.06f; + } + + public static SpriteBillboardParticle createDrippingAlmondWater(SimpleParticleType type, ClientWorld world, double x, double y, double z, double velocityX, double velocityY, double velocityZ) { + BlockLeakParticle particle = new Dripping(world, x, y, z, Fluids.EMPTY, CubliminalParticleTypes.FALLING_ALMOND_WATER); + particle.setColor(ParticleColorManagement.ALMOND_WATER[0], ParticleColorManagement.ALMOND_WATER[1], ParticleColorManagement.ALMOND_WATER[2]); + return particle; + } + + public static SpriteBillboardParticle createFallingAlmondWater(SimpleParticleType type, ClientWorld world, double x, double y, double z, double velocityX, double velocityY, double velocityZ) { + BlockLeakParticle particle = new ContinuousFalling(world, x, y, z, Fluids.EMPTY, CubliminalParticleTypes.LANDING_ALMOND_WATER); + particle.setColor(ParticleColorManagement.ALMOND_WATER[0], ParticleColorManagement.ALMOND_WATER[1], ParticleColorManagement.ALMOND_WATER[2]); + return particle; + } + + public static SpriteBillboardParticle createLandingAlmondWater(SimpleParticleType type, ClientWorld world, double x, double y, double z, double velocityX, double velocityY, double velocityZ){ + SpriteBillboardParticle particle = new WaterSplashParticle(world, x, y, z, velocityX, velocityY, velocityZ); + particle.setColor(ParticleColorManagement.ALMOND_WATER[0], ParticleColorManagement.ALMOND_WATER[1], ParticleColorManagement.ALMOND_WATER[2]); + return particle; + } + + public static SpriteBillboardParticle createDrippingBlackSludge(SimpleParticleType type, ClientWorld world, double x, double y, double z, double velocityX, double velocityY, double velocityZ){ + Dripping dripping = new Dripping(world, x, y, z, Fluids.EMPTY, CubliminalParticleTypes.FALLING_BLACK_SLUDGE); + dripping.gravityStrength *= 0.01f; + dripping.maxAge = 100; + dripping.setColor(ParticleColorManagement.BLACK_SLUDGE[0], ParticleColorManagement.BLACK_SLUDGE[1], ParticleColorManagement.BLACK_SLUDGE[2]); + return dripping; + } + + public static SpriteBillboardParticle createFallingBlackSludge(SimpleParticleType type, ClientWorld world, double x, double y, double z, double velocityX, double velocityY, double velocityZ){ + BlockLeakParticle blockLeakParticle = new FallingHoney(world, x, y, z, Fluids.EMPTY, CubliminalParticleTypes.LANDING_BLACK_SLUDGE); + blockLeakParticle.gravityStrength *= 0.01f; + blockLeakParticle.setColor(ParticleColorManagement.BLACK_SLUDGE[0], ParticleColorManagement.BLACK_SLUDGE[1], ParticleColorManagement.BLACK_SLUDGE[2]); + return blockLeakParticle; + } + + public static SpriteBillboardParticle createLandingBlackSludge(SimpleParticleType type, ClientWorld world, double x, double y, double z, double velocityX, double velocityY, double velocityZ) { + BlockLeakParticle blockLeakParticle = new Landing(world, x, y, z, Fluids.EMPTY); + blockLeakParticle.maxAge = (int)(128.0 / (Math.random() * 0.8 + 0.2)); + blockLeakParticle.setColor(ParticleColorManagement.BLACK_SLUDGE[0], ParticleColorManagement.BLACK_SLUDGE[1], ParticleColorManagement.BLACK_SLUDGE[2]); + return blockLeakParticle; + } + + public static SpriteBillboardParticle createDrippingContaminatedWater(SimpleParticleType type, ClientWorld world, double x, double y, double z, double velocityX, double velocityY, double velocityZ){ + BlockLeakParticle particle = new Dripping(world, x, y, z, Fluids.EMPTY, CubliminalParticleTypes.FALLING_CONTAMINATED_WATER); + chosenCWColors = ParticleColorManagement.chooseRandomContaminatedWaterColors(); + particle.setColor(chosenCWColors[0], chosenCWColors[1], chosenCWColors[2]); + return particle; + } + + public static SpriteBillboardParticle createFallingContaminatedWater(SimpleParticleType type, ClientWorld world, double x, double y, double z, double velocityX, double velocityY, double velocityZ){ + BlockLeakParticle particle = new ContinuousFalling(world, x, y, z, Fluids.EMPTY, CubliminalParticleTypes.LANDING_CONTAMINATED_WATER); + particle.setColor(chosenCWColors[0], chosenCWColors[1], chosenCWColors[2]); + return particle; + } + + public static SpriteBillboardParticle createLandingContaminatedWater(SimpleParticleType type, ClientWorld world, double x, double y, double z, double velocityX, double velocityY, double velocityZ){ + SpriteBillboardParticle particle = new WaterSplashParticle(world, x, y, z, velocityX, velocityY, velocityZ); + particle.setColor(chosenCWColors[0], chosenCWColors[1], chosenCWColors[2]); + return particle; + } +} diff --git a/src/main/java/net/limit/cubliminal/client/particle/util/ParticleColorManagement.java b/src/main/java/net/limit/cubliminal/client/particle/util/ParticleColorManagement.java new file mode 100644 index 0000000..5762a16 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/client/particle/util/ParticleColorManagement.java @@ -0,0 +1,29 @@ +package net.limit.cubliminal.client.particle.util; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +public class ParticleColorManagement { + public static final float[] ALMOND_WATER = registerColor(0.933333F, 0.86F, 0.77F); + public static final float[] BLACK_SLUDGE = registerColor(0f, 0f, 0f); + + private static final List contaminatedWaterColors = new ArrayList<>(List.of( + new float[] {0.384f, 0.408f, 0.275f}, // Murky Green-Brown + new float[] {0.659f, 0.353f, 0.173f}, // Rusty Orange + new float[] {0.235f, 0.255f, 0.267f}, // Dark Grey + new float[] {0.706f, 0.698f, 0.675f}, // Cloudy White-Grey + new float[] {0.569f, 0.588f, 0.255f}, // Sickly Yellow-Green + new float[] {0.157f, 0.235f, 0.412f} // Oil-Slick Blue + )); + + public static float[] registerColor(float red, float green, float blue){ + return new float[]{red, green, blue}; + } + + public static float[] chooseRandomContaminatedWaterColors(){ + Random random = new Random(); + int chosen = random.nextInt(0, contaminatedWaterColors.size()); + return contaminatedWaterColors.get(chosen); + } +} diff --git a/src/main/java/net/limit/cubliminal/client/util/CameraAccessor.java b/src/main/java/net/limit/cubliminal/client/util/CameraAccessor.java new file mode 100644 index 0000000..3980306 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/client/util/CameraAccessor.java @@ -0,0 +1,9 @@ +package net.limit.cubliminal.client.util; + +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.BlockView; + +public interface CameraAccessor { + BlockView getArea(); + BlockPos getBlockPos(); +} diff --git a/src/main/java/net/limit/cubliminal/client/util/CameraBackroomFluid.java b/src/main/java/net/limit/cubliminal/client/util/CameraBackroomFluid.java new file mode 100644 index 0000000..dd9bd1f --- /dev/null +++ b/src/main/java/net/limit/cubliminal/client/util/CameraBackroomFluid.java @@ -0,0 +1,33 @@ +package net.limit.cubliminal.client.util; + +import net.limit.cubliminal.init.CubliminalFluidTags; +import net.minecraft.client.render.Camera; +import net.minecraft.fluid.FluidState; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.BlockView; + +public class CameraBackroomFluid { + private static FluidState fluidState; + + public static boolean isSubmergedInBackroomFluid(Camera camera){ + if (camera instanceof CameraAccessor accessor){ + BlockView view = accessor.getArea(); + BlockPos pos = accessor.getBlockPos(); + FluidState fluidState = view.getFluidState(pos); + if (fluidState.isIn(CubliminalFluidTags.CUSTOM_FLUIDS)){ + setFluidState(fluidState); + double fluidHeight = pos.getY() + fluidState.getHeight(view, pos); + return camera.getPos().y < fluidHeight; + } + } + return false; + } + + public static FluidState getFluidState() { + return fluidState; + } + + private static void setFluidState(FluidState fluidState) { + CameraBackroomFluid.fluidState = fluidState; + } +} diff --git a/src/main/java/net/limit/cubliminal/fluid/AlmondWaterFluid.java b/src/main/java/net/limit/cubliminal/fluid/AlmondWaterFluid.java new file mode 100644 index 0000000..1d94646 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/fluid/AlmondWaterFluid.java @@ -0,0 +1,102 @@ +package net.limit.cubliminal.fluid; + +import net.limit.cubliminal.block.fluids.CustomFluidBlock; +import net.limit.cubliminal.init.CubliminalBlocks; +import net.limit.cubliminal.init.CubliminalFluids; +import net.limit.cubliminal.particle.CubliminalParticleTypes; +import net.minecraft.block.BlockState; +import net.minecraft.block.FluidBlock; +import net.minecraft.fluid.Fluid; +import net.minecraft.fluid.FluidState; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.particle.ParticleEffect; +import net.minecraft.server.world.ServerWorld; +import net.minecraft.sound.SoundCategory; +import net.minecraft.sound.SoundEvents; +import net.minecraft.state.StateManager; +import net.minecraft.world.WorldView; +import org.jetbrains.annotations.Nullable; + +public class AlmondWaterFluid extends BackroomsFlowableFluid { + public AlmondWaterFluid(){ + super(SoundEvents.BLOCK_WATER_AMBIENT, SoundCategory.BLOCKS); + } + + @Override + public Fluid getFlowing() { + return CubliminalFluids.FLOWING_ALMOND_WATER; + } + + @Override + public Fluid getStill() { + return CubliminalFluids.ALMOND_WATER; + } + + @Override + protected boolean isInfinite(ServerWorld world) { + return false; + } + + @Override + protected int getMaxFlowDistance(WorldView world) { + return 4; + } + + @Override + public Item getBucketItem() { + return null; + } + + @Override + public ItemStack getBottleItem() { + return null; + } + + @Override + public CustomFluidBlock getFluidBlock() { + return (CustomFluidBlock) CubliminalBlocks.ALMOND_WATER_BLOCK; + } + + @Override + protected BlockState toBlockState(FluidState state) { + return CubliminalBlocks.ALMOND_WATER_BLOCK.getDefaultState().with(FluidBlock.LEVEL, getBlockStateLevel(state)); + } + + @Nullable + @Override + public ParticleEffect getParticle() { + return CubliminalParticleTypes.DRIPPING_ALMOND_WATER; + } + + public static class Flowing extends AlmondWaterFluid { + public Flowing() { + } + + protected void appendProperties(StateManager.Builder builder) { + super.appendProperties(builder); + builder.add(LEVEL); + } + + public int getLevel(FluidState state) { + return state.get(LEVEL); + } + + public boolean isStill(FluidState state) { + return false; + } + } + + public static class Still extends AlmondWaterFluid { + public Still() { + } + + public int getLevel(FluidState state) { + return 8; + } + + public boolean isStill(FluidState state) { + return true; + } + } +} diff --git a/src/main/java/net/limit/cubliminal/fluid/BackroomsFlowableFluid.java b/src/main/java/net/limit/cubliminal/fluid/BackroomsFlowableFluid.java new file mode 100644 index 0000000..0bc139f --- /dev/null +++ b/src/main/java/net/limit/cubliminal/fluid/BackroomsFlowableFluid.java @@ -0,0 +1,92 @@ +package net.limit.cubliminal.fluid; + +import net.limit.cubliminal.block.fluids.CustomFluidBlock; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.block.entity.BlockEntity; +import net.minecraft.fluid.FlowableFluid; +import net.minecraft.fluid.Fluid; +import net.minecraft.fluid.FluidState; +import net.minecraft.item.ItemStack; +import net.minecraft.particle.ParticleTypes; +import net.minecraft.registry.tag.FluidTags; +import net.minecraft.sound.SoundCategory; +import net.minecraft.sound.SoundEvent; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Direction; +import net.minecraft.world.BlockView; +import net.minecraft.world.World; +import net.minecraft.world.WorldAccess; +import net.minecraft.world.WorldView; + +public abstract class BackroomsFlowableFluid extends FlowableFluid { + private final SoundEvent ambience; + private final SoundCategory category; + + public BackroomsFlowableFluid(SoundEvent ambience, SoundCategory category){ + this.ambience = ambience; + this.category = category; + } + + public abstract ItemStack getBottleItem(); + public abstract CustomFluidBlock getFluidBlock(); + + @Override + protected void randomDisplayTick(World world, BlockPos pos, FluidState state, net.minecraft.util.math.random.Random random) { + if (!state.isStill() && !(Boolean)state.get(FALLING)) { + if (random.nextInt(64) == 0) { + world.playSound((double)pos.getX() + 0.5D, + (double)pos.getY() + 0.5D, (double)pos.getZ() + 0.5D, + this.ambience, this.category, + random.nextFloat() * 0.25F + 0.75F, random.nextFloat() + 0.5F, + false); + } + } else if (random.nextInt(10) == 0) { + world.addParticle(ParticleTypes.UNDERWATER, (double)pos.getX() + random.nextDouble(), + (double)pos.getY() + random.nextDouble(), + (double)pos.getZ() + random.nextDouble(), + 0.0D, 0.0D, 0.0D); + } + } + + @Override + protected void beforeBreakingBlock(WorldAccess world, BlockPos pos, BlockState state) { + BlockEntity blockEntity = state.hasBlockEntity() ? world.getBlockEntity(pos) : null; + Block.dropStacks(state, world, pos, blockEntity); + } + + @Override + protected int getLevelDecreasePerBlock(WorldView world) { + return 1; + } + + @Override + protected boolean canBeReplacedWith(FluidState state, BlockView world, BlockPos pos, Fluid fluid, Direction direction) { + return direction == Direction.DOWN && !fluid.isIn(FluidTags.WATER); + } + + @Override + public int getTickRate(WorldView world) { + return 5; + } + + @Override + protected float getBlastResistance() { + return 100.0f; + } + + @Override + public boolean isStill(FluidState state) { + return false; + } + + @Override + public int getLevel(FluidState state) { + return 7; + } + + @Override + public boolean matchesType(Fluid fluid) { + return fluid == getStill() || fluid == getFlowing(); + } +} diff --git a/src/main/java/net/limit/cubliminal/fluid/BlackSludgeFluid.java b/src/main/java/net/limit/cubliminal/fluid/BlackSludgeFluid.java new file mode 100644 index 0000000..b8258bb --- /dev/null +++ b/src/main/java/net/limit/cubliminal/fluid/BlackSludgeFluid.java @@ -0,0 +1,101 @@ +package net.limit.cubliminal.fluid; + +import net.limit.cubliminal.block.fluids.CustomFluidBlock; +import net.limit.cubliminal.init.CubliminalBlocks; +import net.limit.cubliminal.init.CubliminalFluids; +import net.minecraft.block.BlockState; +import net.minecraft.block.FluidBlock; +import net.minecraft.fluid.Fluid; +import net.minecraft.fluid.FluidState; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.server.world.ServerWorld; +import net.minecraft.sound.SoundCategory; +import net.minecraft.sound.SoundEvents; +import net.minecraft.state.StateManager; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Vec3d; +import net.minecraft.world.BlockView; +import net.minecraft.world.WorldView; + +public class BlackSludgeFluid extends BackroomsFlowableFluid { + public BlackSludgeFluid() { + super(SoundEvents.BLOCK_HONEY_BLOCK_SLIDE, SoundCategory.BLOCKS); + } + + @Override + public Vec3d getVelocity(BlockView world, BlockPos pos, FluidState state) { + return new Vec3d(0.0, -0.2, 0); + } + + @Override + public ItemStack getBottleItem() { + return null; + } + + @Override + public CustomFluidBlock getFluidBlock() { + return (CustomFluidBlock) CubliminalBlocks.BLACK_SLUDGE_BLOCK; + } + + @Override + public Fluid getFlowing() { + return CubliminalFluids.FLOWING_BLACK_SLUDGE; + } + + @Override + public Fluid getStill() { + return CubliminalFluids.BLACK_SLUDGE; + } + + @Override + protected boolean isInfinite(ServerWorld world) { + return false; + } + + @Override + protected int getMaxFlowDistance(WorldView world) { + return 4; + } + + @Override + public Item getBucketItem() { + return null; + } + + @Override + protected BlockState toBlockState(FluidState state) { + return CubliminalBlocks.BLACK_SLUDGE_BLOCK.getDefaultState().with(FluidBlock.LEVEL, getBlockStateLevel(state)); + } + + public static class Flowing extends BlackSludgeFluid { + public Flowing() { + } + + protected void appendProperties(StateManager.Builder builder) { + super.appendProperties(builder); + builder.add(LEVEL); + } + + public int getLevel(FluidState state) { + return state.get(LEVEL); + } + + public boolean isStill(FluidState state) { + return false; + } + } + + public static class Still extends BlackSludgeFluid { + public Still() { + } + + public int getLevel(FluidState state) { + return 8; + } + + public boolean isStill(FluidState state) { + return true; + } + } +} diff --git a/src/main/java/net/limit/cubliminal/fluid/ContaminatedWaterFluid.java b/src/main/java/net/limit/cubliminal/fluid/ContaminatedWaterFluid.java new file mode 100644 index 0000000..0769924 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/fluid/ContaminatedWaterFluid.java @@ -0,0 +1,96 @@ +package net.limit.cubliminal.fluid; + +import net.limit.cubliminal.block.fluids.CustomFluidBlock; +import net.limit.cubliminal.init.CubliminalBlocks; +import net.limit.cubliminal.init.CubliminalFluids; +import net.minecraft.block.BlockState; +import net.minecraft.block.FluidBlock; +import net.minecraft.fluid.Fluid; +import net.minecraft.fluid.FluidState; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.particle.ParticleEffect; +import net.minecraft.server.world.ServerWorld; +import net.minecraft.sound.SoundCategory; +import net.minecraft.sound.SoundEvents; +import net.minecraft.state.StateManager; +import net.minecraft.world.WorldView; +import org.jetbrains.annotations.Nullable; + +public class ContaminatedWaterFluid extends BackroomsFlowableFluid { + public ContaminatedWaterFluid() { + super(SoundEvents.BLOCK_WATER_AMBIENT, SoundCategory.BLOCKS); + } + + @Override + public ItemStack getBottleItem() { + return null; + //return new ItemStack(BackroomItems.CONTAMINATED_WATER); + } + + @Override + public CustomFluidBlock getFluidBlock() { + return (CustomFluidBlock) CubliminalBlocks.CONTAMINATED_WATER_BLOCK; + } + + @Override + public Fluid getFlowing() { + return CubliminalFluids.FLOWING_CONTAMINATED_WATER; + } + + @Override + public Fluid getStill() { + return CubliminalFluids.CONTAMINATED_WATER; + } + + @Override + protected boolean isInfinite(ServerWorld world) { + return false; + } + + @Override + protected int getMaxFlowDistance(WorldView world) { + return 4; + } + + @Override + public Item getBucketItem() { + return null; + } + + @Override + protected BlockState toBlockState(FluidState state) { + return CubliminalBlocks.CONTAMINATED_WATER_BLOCK.getDefaultState().with(FluidBlock.LEVEL, getBlockStateLevel(state)); + } + + public static class Flowing extends ContaminatedWaterFluid { + public Flowing() { + } + + protected void appendProperties(StateManager.Builder builder) { + super.appendProperties(builder); + builder.add(LEVEL); + } + + public int getLevel(FluidState state) { + return state.get(LEVEL); + } + + public boolean isStill(FluidState state) { + return false; + } + } + + public static class Still extends ContaminatedWaterFluid { + public Still() { + } + + public int getLevel(FluidState state) { + return 8; + } + + public boolean isStill(FluidState state) { + return true; + } + } +} diff --git a/src/main/java/net/limit/cubliminal/init/CubliminalBlocks.java b/src/main/java/net/limit/cubliminal/init/CubliminalBlocks.java index 4e3f811..78257de 100644 --- a/src/main/java/net/limit/cubliminal/init/CubliminalBlocks.java +++ b/src/main/java/net/limit/cubliminal/init/CubliminalBlocks.java @@ -7,10 +7,15 @@ import net.limit.cubliminal.block.custom.*; import net.limit.cubliminal.block.custom.template.RotatableBlock; import net.limit.cubliminal.block.custom.template.RotatableLightBlock; +import net.limit.cubliminal.block.fluids.BlackSludgeFluidBlock; +import net.limit.cubliminal.block.fluids.ContaminatedWaterBlock; +import net.limit.cubliminal.block.fluids.CustomFluidBlock; +import net.limit.cubliminal.block.fluids.FluidBlockFactory; import net.limit.cubliminal.item.AlmondWaterBlockItem; import net.minecraft.block.*; import net.minecraft.block.piston.PistonBehavior; import net.minecraft.component.DataComponentTypes; +import net.minecraft.fluid.FlowableFluid; import net.minecraft.item.BlockItem; import net.minecraft.item.Item; import net.minecraft.item.OperatorOnlyBlockItem; @@ -24,6 +29,7 @@ import net.minecraft.state.property.Properties; import net.minecraft.util.DyeColor; import net.minecraft.util.Rarity; +import net.minecraft.util.math.Vec3d; import java.util.function.BiFunction; import java.util.function.Function; @@ -65,6 +71,36 @@ private static Block registerBlock(String id, Block block, BiFunction of(String id) { return TagKey.of(RegistryKeys.BLOCK, Cubliminal.id(id)); } @@ -443,6 +479,9 @@ public static TagKey of(String id) { public static final Block POOL_TILE_WALL = register("pool_tile_wall", WallBlock::new, AbstractBlock.Settings.copy(Blocks.REINFORCED_DEEPSLATE).solid()); + public static Block ALMOND_WATER_BLOCK; + public static Block CONTAMINATED_WATER_BLOCK; + public static Block BLACK_SLUDGE_BLOCK; public static ToIntFunction shouldBeRed(int defaultLevel, int redLevel) { return (state) -> { @@ -473,5 +512,24 @@ public void init() { builder.add(RED_WALLPAPERS.asItem(), 300); builder.add(WOODEN_CRATE.asItem(), 300); }); + + ALMOND_WATER_BLOCK = registerFluidBlock("almond_water", CubliminalFluids.ALMOND_WATER, CustomFluidBlock::new, + CustomFluidBlock.Settings.create() + .setColor(0xFFECB3) + ); + + CONTAMINATED_WATER_BLOCK = registerFluidBlock("contaminated_water", CubliminalFluids.CONTAMINATED_WATER, ContaminatedWaterBlock::new, + CustomFluidBlock.Settings.create() + .setColor(0x556B2F) + ); + + BLACK_SLUDGE_BLOCK = registerFluidBlock("black_sludge", CubliminalFluids.BLACK_SLUDGE, BlackSludgeFluidBlock::new, + CustomFluidBlock.Settings.create() + .setColor(0x000000) + .setSpeed(0.005f) + .setDrag(new Vec3d(0.5, 0.4, 0.5)) + .setFogStart(0.25f) + .setFogEnd(1.0f) + ); } } diff --git a/src/main/java/net/limit/cubliminal/init/CubliminalFluidTags.java b/src/main/java/net/limit/cubliminal/init/CubliminalFluidTags.java new file mode 100644 index 0000000..912e50f --- /dev/null +++ b/src/main/java/net/limit/cubliminal/init/CubliminalFluidTags.java @@ -0,0 +1,20 @@ +package net.limit.cubliminal.init; + +import net.limit.cubliminal.Cubliminal; +import net.limit.cubliminal.Initer; +import net.minecraft.fluid.Fluid; +import net.minecraft.registry.RegistryKeys; +import net.minecraft.registry.tag.TagKey; + +public class CubliminalFluidTags implements Initer { + public static final TagKey CUSTOM_FLUIDS = of("custom_fluids"); + + private static TagKey of(String id) { + return TagKey.of(RegistryKeys.FLUID, Cubliminal.id(id)); + } + + @Override + public void init() { + Initer.super.init(); + } +} diff --git a/src/main/java/net/limit/cubliminal/init/CubliminalFluids.java b/src/main/java/net/limit/cubliminal/init/CubliminalFluids.java new file mode 100644 index 0000000..5df1a3b --- /dev/null +++ b/src/main/java/net/limit/cubliminal/init/CubliminalFluids.java @@ -0,0 +1,52 @@ +package net.limit.cubliminal.init; + +import net.limit.cubliminal.Cubliminal; +import net.limit.cubliminal.Initer; +import net.limit.cubliminal.fluid.AlmondWaterFluid; +import net.limit.cubliminal.fluid.BlackSludgeFluid; +import net.limit.cubliminal.fluid.ContaminatedWaterFluid; +import net.limit.cubliminal.util.Debug; +import net.minecraft.fluid.FlowableFluid; +import net.minecraft.fluid.Fluid; +import net.minecraft.registry.Registries; +import net.minecraft.registry.Registry; + +import java.util.HashMap; +import java.util.Map; + +public class CubliminalFluids implements Initer { + public static FlowableFluid ALMOND_WATER; + public static FlowableFluid FLOWING_ALMOND_WATER; + + public static FlowableFluid CONTAMINATED_WATER; + public static FlowableFluid FLOWING_CONTAMINATED_WATER; + + public static FlowableFluid BLACK_SLUDGE; + public static FlowableFluid FLOWING_BLACK_SLUDGE; + + private static T register(String id, T value) { + return Registry.register(Registries.FLUID, Cubliminal.id(id), value); + } + + private static Map registerFluidTypes(String name, T flowing, T still){ + Map fluidMap = new HashMap<>(); + fluidMap.put("flowing", register("flowing_" + name, flowing)); + fluidMap.put("still", register(name, still)); + return fluidMap; + } + + @Override + public void init() { + Map almondWater = registerFluidTypes("almond_water", new AlmondWaterFluid.Flowing(), new AlmondWaterFluid.Still()); + FLOWING_ALMOND_WATER = almondWater.get("flowing"); + ALMOND_WATER = almondWater.get("still"); + + Map contaminatedWater = registerFluidTypes("contaminated_water", new ContaminatedWaterFluid.Flowing(), new ContaminatedWaterFluid.Still()); + FLOWING_CONTAMINATED_WATER = contaminatedWater.get("flowing"); + CONTAMINATED_WATER = contaminatedWater.get("still"); + + Map blackSludge = registerFluidTypes("black_sludge", new BlackSludgeFluid.Flowing(), new BlackSludgeFluid.Still()); + FLOWING_BLACK_SLUDGE = blackSludge.get("flowing"); + BLACK_SLUDGE = blackSludge.get("still"); + } +} diff --git a/src/main/java/net/limit/cubliminal/mixin/LivingEntityMixin.java b/src/main/java/net/limit/cubliminal/mixin/LivingEntityMixin.java new file mode 100644 index 0000000..8da546d --- /dev/null +++ b/src/main/java/net/limit/cubliminal/mixin/LivingEntityMixin.java @@ -0,0 +1,79 @@ +package net.limit.cubliminal.mixin; + +import net.limit.cubliminal.block.fluids.CustomFluidBlock; +import net.limit.cubliminal.fluid.BackroomsFlowableFluid; +import net.limit.cubliminal.init.CubliminalFluidTags; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityType; +import net.minecraft.entity.LivingEntity; +import net.minecraft.entity.MovementType; +import net.minecraft.entity.damage.DamageSource; +import net.minecraft.entity.data.DataTracker; +import net.minecraft.fluid.Fluid; +import net.minecraft.fluid.FluidState; +import net.minecraft.nbt.NbtCompound; +import net.minecraft.registry.tag.TagKey; +import net.minecraft.server.world.ServerWorld; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Vec3d; +import net.minecraft.world.World; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.Unique; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; + +@Mixin(LivingEntity.class) +public abstract class LivingEntityMixin { + @Shadow protected boolean jumping; + private FluidState fluidState; + + @Unique + private boolean isSubmergedAtFeet(TagKey fluid) { + Entity entity = (Entity)(Object) this; + FluidState fluidState = entity.getWorld().getFluidState(entity.getBlockPos()); + if (fluidState.isIn(fluid)){ + this.fluidState = fluidState; + return true; + } + return false; + } + + @Inject(method = "travel", at = @At("HEAD"), cancellable = true) + private void onTravel(Vec3d movementInput, CallbackInfo ci){ + // Checks to see if player is submerged in backroom fluids. + if (isSubmergedAtFeet(CubliminalFluidTags.CUSTOM_FLUIDS)){ + // Checks to see if the fluid uses Project Backrooms custom implementations + if (this.fluidState.getFluid() instanceof BackroomsFlowableFluid backroomsFluid){ + Entity entity = (Entity)(Object) this; + // Gets the fluid block. + CustomFluidBlock fluidBlock = backroomsFluid.getFluidBlock(); + // Gets the fluid settings from the fluid block. + CustomFluidBlock.Settings settings = fluidBlock.getFluidSettings(); + // Checks to see if the fluid doesn't plan to use the default physics. + if (!settings.usesDefaultPhysics()){ + // The gravity. + double gravity = 0.08; + + entity.updateVelocity(settings.getSpeed(), movementInput); // Speed + entity.move(MovementType.SELF, entity.getVelocity()); + + Vec3d drag = entity.getVelocity().multiply(settings.getDrag().x, settings.getDrag().y, settings.getDrag().z); + if (!entity.hasNoGravity()) { + drag = drag.add(0, -gravity / 4.0, 0); + } + + if (jumping) { + drag = drag.add(0.0, 0.04, 0.0); // swim up slowly + } + + entity.setVelocity(drag); + entity.fallDistance = 0.0F; + ci.cancel(); + } + } + + } + } +} \ No newline at end of file diff --git a/src/main/java/net/limit/cubliminal/mixin/PlayerEntityMixin.java b/src/main/java/net/limit/cubliminal/mixin/PlayerEntityMixin.java index 7990eec..b5a6a15 100644 --- a/src/main/java/net/limit/cubliminal/mixin/PlayerEntityMixin.java +++ b/src/main/java/net/limit/cubliminal/mixin/PlayerEntityMixin.java @@ -106,4 +106,6 @@ private void canSwimInFluids(CallbackInfoReturnable cir) { @Override public void openUSBlockScreen(USBlockBlockEntity blockEntity) { } + + } diff --git a/src/main/java/net/limit/cubliminal/mixin/client/BackgroundRendererMixin.java b/src/main/java/net/limit/cubliminal/mixin/client/BackgroundRendererMixin.java index 482921b..2061795 100644 --- a/src/main/java/net/limit/cubliminal/mixin/client/BackgroundRendererMixin.java +++ b/src/main/java/net/limit/cubliminal/mixin/client/BackgroundRendererMixin.java @@ -1,18 +1,25 @@ package net.limit.cubliminal.mixin.client; +import com.mojang.blaze3d.systems.RenderSystem; import net.fabricmc.api.EnvType; import net.fabricmc.api.Environment; import net.limit.cubliminal.Cubliminal; +import net.limit.cubliminal.block.fluids.CustomFluidBlock; import net.limit.cubliminal.client.render.fog.FogManager; import net.limit.cubliminal.client.render.fog.FogSettings; +import net.limit.cubliminal.client.util.CameraBackroomFluid; import net.limit.cubliminal.config.CubliminalConfig; +import net.limit.cubliminal.fluid.BackroomsFlowableFluid; +import net.limit.cubliminal.util.ColorManager; import net.minecraft.block.enums.CameraSubmersionType; import net.minecraft.client.MinecraftClient; import net.minecraft.client.render.BackgroundRenderer; import net.minecraft.client.render.Camera; import net.minecraft.client.render.Fog; +import net.minecraft.client.render.FogShape; import net.minecraft.client.world.ClientWorld; import net.minecraft.entity.Entity; +import net.minecraft.fluid.FluidState; import net.minecraft.registry.RegistryKey; import net.minecraft.world.biome.Biome; import org.jetbrains.annotations.Nullable; @@ -21,12 +28,13 @@ import org.spongepowered.asm.mixin.Shadow; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; @Environment(EnvType.CLIENT) @Mixin(BackgroundRenderer.class) public abstract class BackgroundRendererMixin { - + // TODO: Improve BackgroundRendererMixin and optimize it to become more flexible. @Shadow @Nullable private static BackgroundRenderer.StatusEffectFogModifier getFogModifier(Entity entity, float tickDelta) { @@ -56,4 +64,29 @@ private static BackgroundRenderer.StatusEffectFogModifier getFogModifier(Entity } } + + // TODO: Integrate this properly with Cubliminal. + @Inject(method = "applyFog", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/BackgroundRenderer;getFogModifier(Lnet/minecraft/entity/Entity;F)Lnet/minecraft/client/render/BackgroundRenderer$StatusEffectFogModifier;", shift = At.Shift.AFTER), cancellable = true) + private static void onApplyFog(Camera camera, BackgroundRenderer.FogType fogType, Vector4f color, float viewDistance, boolean thickenFog, float tickDelta, CallbackInfoReturnable cir) { + if (CameraBackroomFluid.isSubmergedInBackroomFluid(camera)){ + FluidState fluidState = CameraBackroomFluid.getFluidState(); + if (fluidState.getFluid() instanceof BackroomsFlowableFluid backroomFluid){ + CustomFluidBlock.Settings settings = backroomFluid.getFluidBlock().getFluidSettings(); + ColorManager fluidColor = settings.getColor(); + Fog fog = new Fog( + settings.getFogStart(), + settings.getFogEnd(), + FogShape.SPHERE, + fluidColor.getRedDecimal(), + fluidColor.getGreenDecimal(), + fluidColor.getBlueDecimal(), + 0.5f + ); + + RenderSystem.setShaderFog(fog); + + cir.cancel(); + } + } + } } diff --git a/src/main/java/net/limit/cubliminal/mixin/client/CameraMixin.java b/src/main/java/net/limit/cubliminal/mixin/client/CameraMixin.java new file mode 100644 index 0000000..bfa463e --- /dev/null +++ b/src/main/java/net/limit/cubliminal/mixin/client/CameraMixin.java @@ -0,0 +1,29 @@ +package net.limit.cubliminal.mixin.client; + +import net.limit.cubliminal.client.util.CameraAccessor; +import net.minecraft.client.render.Camera; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.BlockView; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.Unique; + +@Mixin(Camera.class) +public abstract class CameraMixin implements CameraAccessor { + @Shadow private BlockView area; + + @Shadow @Final private BlockPos.Mutable blockPos; + + @Unique + @Override + public BlockView getArea(){ + return this.area; + } + + @Unique + @Override + public BlockPos getBlockPos(){ + return this.blockPos; + } +} diff --git a/src/main/java/net/limit/cubliminal/particle/CubliminalParticleTypes.java b/src/main/java/net/limit/cubliminal/particle/CubliminalParticleTypes.java new file mode 100644 index 0000000..9f5f3a0 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/particle/CubliminalParticleTypes.java @@ -0,0 +1,40 @@ +package net.limit.cubliminal.particle; + +import net.fabricmc.fabric.api.particle.v1.FabricParticleTypes; +import net.limit.cubliminal.Cubliminal; +import net.limit.cubliminal.Initer; +import net.minecraft.particle.SimpleParticleType; +import net.minecraft.registry.Registries; +import net.minecraft.registry.Registry; +import net.minecraft.util.Identifier; +import org.apache.http.annotation.Obsolete; + +public class CubliminalParticleTypes implements Initer { + public static final SimpleParticleType CONTAMINATED_WATER_SPLASH = register("contaminated_water_splash", FabricParticleTypes.simple()); + + public static final SimpleParticleType ALMOND_WATER_BUBBLE = register("almond_water_bubble", FabricParticleTypes.simple()); + public static final SimpleParticleType CONTAMINATED_WATER_BUBBLE = register("contaminated_water_bubble", FabricParticleTypes.simple()); + + public static final SimpleParticleType DRIPPING_ALMOND_WATER = register("dripping_almond_water", FabricParticleTypes.simple()); + public static final SimpleParticleType FALLING_ALMOND_WATER = register("falling_almond_water", FabricParticleTypes.simple()); + public static final SimpleParticleType LANDING_ALMOND_WATER = register("landing_almond_water", FabricParticleTypes.simple()); + + public static final SimpleParticleType DRIPPING_BLACK_SLUDGE = register("dripping_black_sludge", FabricParticleTypes.simple()); + public static final SimpleParticleType FALLING_BLACK_SLUDGE = register("falling_black_sludge", FabricParticleTypes.simple()); + public static final SimpleParticleType LANDING_BLACK_SLUDGE = register("landing_black_sludge", FabricParticleTypes.simple()); + + public static final SimpleParticleType DRIPPING_CONTAMINATED_WATER = register("dripping_contaminated_water", FabricParticleTypes.simple()); + public static final SimpleParticleType FALLING_CONTAMINATED_WATER = register("falling_contaminated_water", FabricParticleTypes.simple()); + public static final SimpleParticleType LANDING_CONTAMINATED_WATER = register("landing_contaminated_water", FabricParticleTypes.simple()); + @Obsolete + public static final SimpleParticleType SPLASH = register("splash", FabricParticleTypes.simple()); + + private static SimpleParticleType register(String name, SimpleParticleType type){ + return Registry.register(Registries.PARTICLE_TYPE, Cubliminal.id(name), type); + } + + @Override + public void init() { + Initer.super.init(); + } +} diff --git a/src/main/java/net/limit/cubliminal/util/ColorManager.java b/src/main/java/net/limit/cubliminal/util/ColorManager.java new file mode 100644 index 0000000..4a98036 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/util/ColorManager.java @@ -0,0 +1,35 @@ +package net.limit.cubliminal.util; + +public class ColorManager { + private final int hexColor; + private int red; + private int green; + private int blue; + + public ColorManager(int hexColor){ + this.hexColor = hexColor; + this.calculateRGB(); + } + + private void calculateRGB(){ + this.red = (this.hexColor >> 16) & 0xFF; + this.green = (this.hexColor >> 8) & 0xFF; + this.blue = this.hexColor & 0xFF; + } + + public int getHexColor(){ + return this.hexColor; + } + + public float getRedDecimal(){ + return this.red / 250.0F; + } + + public float getGreenDecimal(){ + return this.green / 250.0F; + } + + public float getBlueDecimal(){ + return this.blue / 250.0F; + } +} diff --git a/src/main/resources/assets/cubliminal/blockstates/almond_water_fluid.json b/src/main/resources/assets/cubliminal/blockstates/almond_water_fluid.json new file mode 100644 index 0000000..99fd360 --- /dev/null +++ b/src/main/resources/assets/cubliminal/blockstates/almond_water_fluid.json @@ -0,0 +1,7 @@ +{ + "variants": { + "": { + "model": "minecraft:block/water" + } + } +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/blockstates/black_sludge_fluid.json b/src/main/resources/assets/cubliminal/blockstates/black_sludge_fluid.json new file mode 100644 index 0000000..99fd360 --- /dev/null +++ b/src/main/resources/assets/cubliminal/blockstates/black_sludge_fluid.json @@ -0,0 +1,7 @@ +{ + "variants": { + "": { + "model": "minecraft:block/water" + } + } +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/blockstates/contaminated_water_fluid.json b/src/main/resources/assets/cubliminal/blockstates/contaminated_water_fluid.json new file mode 100644 index 0000000..99fd360 --- /dev/null +++ b/src/main/resources/assets/cubliminal/blockstates/contaminated_water_fluid.json @@ -0,0 +1,7 @@ +{ + "variants": { + "": { + "model": "minecraft:block/water" + } + } +} \ No newline at end of file diff --git a/src/main/resources/cubliminal.accesswidener b/src/main/resources/cubliminal.accesswidener index 9a6a0f0..a059e7d 100644 --- a/src/main/resources/cubliminal.accesswidener +++ b/src/main/resources/cubliminal.accesswidener @@ -1,4 +1,23 @@ accessWidener v2 named accessible method net/minecraft/client/gl/ShaderProgramKeys register (Ljava/lang/String;Lnet/minecraft/client/render/VertexFormat;)Lnet/minecraft/client/gl/ShaderProgramKey; accessible class net/minecraft/client/render/BackgroundRenderer$StatusEffectFogModifier -accessible method net/minecraft/structure/pool/StructurePoolBasedGenerator generate (Lnet/minecraft/world/gen/noise/NoiseConfig;IZLnet/minecraft/world/gen/chunk/ChunkGenerator;Lnet/minecraft/structure/StructureTemplateManager;Lnet/minecraft/world/HeightLimitView;Lnet/minecraft/util/math/random/Random;Lnet/minecraft/registry/Registry;Lnet/minecraft/structure/PoolStructurePiece;Ljava/util/List;Lnet/minecraft/util/shape/VoxelShape;Lnet/minecraft/structure/pool/alias/StructurePoolAliasLookup;Lnet/minecraft/structure/StructureLiquidSettings;)V \ No newline at end of file +accessible method net/minecraft/structure/pool/StructurePoolBasedGenerator generate (Lnet/minecraft/world/gen/noise/NoiseConfig;IZLnet/minecraft/world/gen/chunk/ChunkGenerator;Lnet/minecraft/structure/StructureTemplateManager;Lnet/minecraft/world/HeightLimitView;Lnet/minecraft/util/math/random/Random;Lnet/minecraft/registry/Registry;Lnet/minecraft/structure/PoolStructurePiece;Ljava/util/List;Lnet/minecraft/util/shape/VoxelShape;Lnet/minecraft/structure/pool/alias/StructurePoolAliasLookup;Lnet/minecraft/structure/StructureLiquidSettings;)V + +# TODO // Transfer to Mixins. +accessible class net/minecraft/client/particle/BlockLeakParticle +accessible method net/minecraft/client/particle/BlockLeakParticle (Lnet/minecraft/client/world/ClientWorld;DDDLnet/minecraft/fluid/Fluid;)V +accessible method net/minecraft/client/particle/BlockLeakParticle$Dripping (Lnet/minecraft/client/world/ClientWorld;DDDLnet/minecraft/fluid/Fluid;Lnet/minecraft/particle/ParticleEffect;)V +accessible method net/minecraft/client/particle/BlockLeakParticle$ContinuousFalling (Lnet/minecraft/client/world/ClientWorld;DDDLnet/minecraft/fluid/Fluid;Lnet/minecraft/particle/ParticleEffect;)V +accessible method net/minecraft/client/particle/BlockLeakParticle$DrippingLava (Lnet/minecraft/client/world/ClientWorld;DDDLnet/minecraft/fluid/Fluid;Lnet/minecraft/particle/ParticleEffect;)V +accessible method net/minecraft/client/particle/BlockLeakParticle$Landing (Lnet/minecraft/client/world/ClientWorld;DDDLnet/minecraft/fluid/Fluid;)V +accessible method net/minecraft/client/particle/BlockLeakParticle$FallingHoney (Lnet/minecraft/client/world/ClientWorld;DDDLnet/minecraft/fluid/Fluid;Lnet/minecraft/particle/ParticleEffect;)V +accessible method net/minecraft/client/particle/BlockLeakParticle$Falling (Lnet/minecraft/client/world/ClientWorld;DDDLnet/minecraft/fluid/Fluid;)V +accessible method net/minecraft/client/particle/BlockLeakParticle$Falling (Lnet/minecraft/client/world/ClientWorld;DDDLnet/minecraft/fluid/Fluid;I)V + +accessible method net/minecraft/client/particle/WaterSplashParticle (Lnet/minecraft/client/world/ClientWorld;DDDDDD)V +accessible method net/minecraft/client/particle/WaterBubbleParticle (Lnet/minecraft/client/world/ClientWorld;DDDDDD)V + +accessible field net/minecraft/client/particle/Particle gravityStrength F +accessible field net/minecraft/client/particle/Particle maxAge I + +accessible method net/minecraft/fluid/Fluid getParticle ()Lnet/minecraft/particle/ParticleEffect; \ No newline at end of file diff --git a/src/main/resources/cubliminal.mixins.json b/src/main/resources/cubliminal.mixins.json index 6dbcc7d..41a76b5 100644 --- a/src/main/resources/cubliminal.mixins.json +++ b/src/main/resources/cubliminal.mixins.json @@ -7,10 +7,12 @@ "ChunkSectionMixin", "ClearAllEffectsConsumeEffectMixin", "EntityMixin", + "LivingEntityMixin", "PlayerEntityMixin" ], "client": [ "client.BackgroundRendererMixin", + "client.CameraMixin", "client.ClientPlayerEntityMixin", "client.GameRendererMixin", "client.ItemRendererMixin" diff --git a/src/main/resources/data/cubliminal/tags/fluids/custom_fluids.json b/src/main/resources/data/cubliminal/tags/fluids/custom_fluids.json new file mode 100644 index 0000000..6b3b69e --- /dev/null +++ b/src/main/resources/data/cubliminal/tags/fluids/custom_fluids.json @@ -0,0 +1,11 @@ +{ + "replace": false, + "values": [ + "cubliminal:black_sludge", + "cubliminal:flowing_black_sludge", + "cubliminal:almond_water", + "cubliminal:flowing_almond_water", + "cubliminal:contaminated_water", + "cubliminal:flowing_contaminated_water" + ] +} \ No newline at end of file diff --git a/src/main/resources/data/minecraft/tags/fluids/water.json b/src/main/resources/data/minecraft/tags/fluids/water.json new file mode 100644 index 0000000..9283d2d --- /dev/null +++ b/src/main/resources/data/minecraft/tags/fluids/water.json @@ -0,0 +1,9 @@ +{ + "replace": false, + "values": [ + "cubliminal:almond_water", + "cubliminal:flowing_almond_water", + "cubliminal:contaminated_water", + "cubliminal:flowing_contaminated_water" + ] +} \ No newline at end of file From 2d29aba670df8352127291a42faa898ef9bac014 Mon Sep 17 00:00:00 2001 From: jonathan-x01 Date: Mon, 14 Jul 2025 19:02:02 -0400 Subject: [PATCH 3/4] - Finished implementing fluids. --- .../java/net/limit/cubliminal/Cubliminal.java | 4 + .../limit/cubliminal/CubliminalClient.java | 28 +++++++ .../particle/CubliminalParticleManager.java | 5 +- .../client/util/CameraBackroomFluid.java | 1 + .../cubliminal/init/CubliminalBlocks.java | 28 +++---- .../cubliminal/init/CubliminalFluidTags.java | 12 ++- .../cubliminal/init/CubliminalFluids.java | 3 +- .../cubliminal/mixin/FluidSplashMixin.java | 71 ++++++++++++++++++ .../cubliminal/mixin/LivingEntityMixin.java | 1 - .../mixin/client/BackgroundRendererMixin.java | 5 +- .../particle/CubliminalParticleTypes.java | 54 ++++++++----- .../particles/almond_water_bubble.json | 5 ++ .../particles/contaminated_water_bubble.json | 5 ++ .../particles/contaminated_water_splash.json | 8 ++ .../particles/dripping_almond_water.json | 5 ++ .../particles/dripping_black_sludge.json | 5 ++ .../dripping_contaminated_water.json | 5 ++ .../particles/falling_almond_water.json | 5 ++ .../particles/falling_black_sludge.json | 5 ++ .../particles/falling_contaminated_water.json | 5 ++ .../particles/landing_almond_water.json | 8 ++ .../particles/landing_black_sludge.json | 5 ++ .../particles/landing_contaminated_water.json | 8 ++ .../assets/cubliminal/particles/splash.json | 8 ++ .../cubliminal/textures/particle/bubble.png | Bin 0 -> 164 bytes .../cubliminal/textures/particle/splash_0.png | Bin 0 -> 129 bytes .../cubliminal/textures/particle/splash_1.png | Bin 0 -> 126 bytes .../cubliminal/textures/particle/splash_2.png | Bin 0 -> 108 bytes .../cubliminal/textures/particle/splash_3.png | Bin 0 -> 112 bytes src/main/resources/cubliminal.mixins.json | 1 + .../tags/{fluids => fluid}/custom_fluids.json | 0 .../tags/{fluids => fluid}/water.json | 0 32 files changed, 244 insertions(+), 46 deletions(-) create mode 100644 src/main/java/net/limit/cubliminal/mixin/FluidSplashMixin.java create mode 100644 src/main/resources/assets/cubliminal/particles/almond_water_bubble.json create mode 100644 src/main/resources/assets/cubliminal/particles/contaminated_water_bubble.json create mode 100644 src/main/resources/assets/cubliminal/particles/contaminated_water_splash.json create mode 100644 src/main/resources/assets/cubliminal/particles/dripping_almond_water.json create mode 100644 src/main/resources/assets/cubliminal/particles/dripping_black_sludge.json create mode 100644 src/main/resources/assets/cubliminal/particles/dripping_contaminated_water.json create mode 100644 src/main/resources/assets/cubliminal/particles/falling_almond_water.json create mode 100644 src/main/resources/assets/cubliminal/particles/falling_black_sludge.json create mode 100644 src/main/resources/assets/cubliminal/particles/falling_contaminated_water.json create mode 100644 src/main/resources/assets/cubliminal/particles/landing_almond_water.json create mode 100644 src/main/resources/assets/cubliminal/particles/landing_black_sludge.json create mode 100644 src/main/resources/assets/cubliminal/particles/landing_contaminated_water.json create mode 100644 src/main/resources/assets/cubliminal/particles/splash.json create mode 100644 src/main/resources/assets/cubliminal/textures/particle/bubble.png create mode 100644 src/main/resources/assets/cubliminal/textures/particle/splash_0.png create mode 100644 src/main/resources/assets/cubliminal/textures/particle/splash_1.png create mode 100644 src/main/resources/assets/cubliminal/textures/particle/splash_2.png create mode 100644 src/main/resources/assets/cubliminal/textures/particle/splash_3.png rename src/main/resources/data/cubliminal/tags/{fluids => fluid}/custom_fluids.json (100%) rename src/main/resources/data/minecraft/tags/{fluids => fluid}/water.json (100%) diff --git a/src/main/java/net/limit/cubliminal/Cubliminal.java b/src/main/java/net/limit/cubliminal/Cubliminal.java index 83aaecb..31aae0e 100644 --- a/src/main/java/net/limit/cubliminal/Cubliminal.java +++ b/src/main/java/net/limit/cubliminal/Cubliminal.java @@ -15,6 +15,7 @@ import net.limit.cubliminal.event.command.SanityCommand; import net.limit.cubliminal.init.*; import net.limit.cubliminal.event.noclip.NoclipDestination; +import net.limit.cubliminal.particle.CubliminalParticleTypes; import net.limit.cubliminal.world.connection.ConnectionPlacementType; import net.limit.cubliminal.world.connection.ConnectionRegistry; import net.limit.cubliminal.world.room.RoomRegistry; @@ -57,6 +58,9 @@ public void onInitialize() { ResourceManagerHelper.get(ResourceType.SERVER_DATA).registerReloadListener(new ConnectionRegistry()); // Init Initers + CubliminalFluidTags.init(); + CubliminalParticleTypes.init(); + CubliminalFluids.initFluid(); Initer.initialise(); NoclipDestination.init(); diff --git a/src/main/java/net/limit/cubliminal/CubliminalClient.java b/src/main/java/net/limit/cubliminal/CubliminalClient.java index ffecea8..ce5f685 100644 --- a/src/main/java/net/limit/cubliminal/CubliminalClient.java +++ b/src/main/java/net/limit/cubliminal/CubliminalClient.java @@ -4,11 +4,18 @@ import net.fabricmc.api.EnvType; import net.fabricmc.api.Environment; import net.fabricmc.fabric.api.blockrenderlayer.v1.BlockRenderLayerMap; +import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents; import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientWorldEvents; +import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper; +import net.fabricmc.fabric.api.client.render.fluid.v1.FluidRenderHandlerRegistry; +import net.fabricmc.fabric.api.client.render.fluid.v1.SimpleFluidRenderHandler; import net.fabricmc.fabric.api.client.rendering.v1.EntityRendererRegistry; import net.fabricmc.fabric.api.client.rendering.v1.HudRenderCallback; +import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents; import net.limit.cubliminal.access.GameRendererAccessor; +import net.limit.cubliminal.block.fluids.CustomFluidBlock; import net.limit.cubliminal.client.hud.SanityBarHudOverlay; +import net.limit.cubliminal.client.particle.CubliminalParticleManager; import net.limit.cubliminal.client.render.FluxCapacitorRenderer; import net.limit.cubliminal.client.render.ManilaGatewayRenderer; import net.limit.cubliminal.client.render.UnlimitedStructureBlockRenderer; @@ -16,14 +23,22 @@ import net.limit.cubliminal.entity.client.SeatRenderer; import net.limit.cubliminal.event.KeyInputHandler; import net.limit.cubliminal.init.*; +import net.limit.cubliminal.util.Debug; +import net.minecraft.client.option.KeyBinding; import net.minecraft.client.render.*; import net.minecraft.client.render.block.entity.BlockEntityRendererFactories; +import net.minecraft.client.util.InputUtil; +import org.lwjgl.glfw.GLFW; + +import java.util.concurrent.atomic.AtomicInteger; @Environment(EnvType.CLIENT) public class CubliminalClient implements ClientModInitializer { @Override public void onInitializeClient() { + CubliminalParticleManager.init(); + BlockRenderLayerMap.INSTANCE.putBlocks(RenderLayer.getCutout(), CubliminalBlocks.THE_LOBBY_GATEWAY_BLOCK, CubliminalBlocks.EMERGENCY_EXIT_DOOR_0, @@ -50,6 +65,19 @@ public void onInitializeClient() { KeyInputHandler.registerKeyInputs(); EntityRendererRegistry.register(CubliminalEntities.SEAT_ENTITY, SeatRenderer::new); + for (CustomFluidBlock backroomFluidBlock : CustomFluidBlock.getAll()) { + FluidRenderHandlerRegistry.INSTANCE.register( + backroomFluidBlock.getFluid().getStill(), + backroomFluidBlock.getFluid().getFlowing(), + new SimpleFluidRenderHandler( + SimpleFluidRenderHandler.WATER_STILL, + SimpleFluidRenderHandler.WATER_FLOWING, + SimpleFluidRenderHandler.WATER_OVERLAY, + backroomFluidBlock.getColor(0) + ) + ); + } + // Init Initers IniterClient.initialise(); diff --git a/src/main/java/net/limit/cubliminal/client/particle/CubliminalParticleManager.java b/src/main/java/net/limit/cubliminal/client/particle/CubliminalParticleManager.java index 0ae435f..028df67 100644 --- a/src/main/java/net/limit/cubliminal/client/particle/CubliminalParticleManager.java +++ b/src/main/java/net/limit/cubliminal/client/particle/CubliminalParticleManager.java @@ -20,9 +20,8 @@ import java.util.function.Function; @Environment(EnvType.CLIENT) -public class CubliminalParticleManager implements ResourceReloader, Initer { - @Override - public void init() { +public class CubliminalParticleManager implements ResourceReloader { + public static void init() { registerSplashFactory(CubliminalParticleTypes.SPLASH, WaterSplashParticle.SplashFactory::new); registerFactory(CubliminalParticleTypes.CONTAMINATED_WATER_SPLASH, ContaminatedWaterSplash.Factory::new); registerFactory(CubliminalParticleTypes.ALMOND_WATER_BUBBLE, Bubble.AlmondWaterBubbleFactory::new); diff --git a/src/main/java/net/limit/cubliminal/client/util/CameraBackroomFluid.java b/src/main/java/net/limit/cubliminal/client/util/CameraBackroomFluid.java index dd9bd1f..9158ef9 100644 --- a/src/main/java/net/limit/cubliminal/client/util/CameraBackroomFluid.java +++ b/src/main/java/net/limit/cubliminal/client/util/CameraBackroomFluid.java @@ -1,6 +1,7 @@ package net.limit.cubliminal.client.util; import net.limit.cubliminal.init.CubliminalFluidTags; +import net.limit.cubliminal.util.Debug; import net.minecraft.client.render.Camera; import net.minecraft.fluid.FluidState; import net.minecraft.util.math.BlockPos; diff --git a/src/main/java/net/limit/cubliminal/init/CubliminalBlocks.java b/src/main/java/net/limit/cubliminal/init/CubliminalBlocks.java index 78257de..1145ca5 100644 --- a/src/main/java/net/limit/cubliminal/init/CubliminalBlocks.java +++ b/src/main/java/net/limit/cubliminal/init/CubliminalBlocks.java @@ -12,10 +12,12 @@ import net.limit.cubliminal.block.fluids.CustomFluidBlock; import net.limit.cubliminal.block.fluids.FluidBlockFactory; import net.limit.cubliminal.item.AlmondWaterBlockItem; +import net.limit.cubliminal.util.Debug; import net.minecraft.block.*; import net.minecraft.block.piston.PistonBehavior; import net.minecraft.component.DataComponentTypes; import net.minecraft.fluid.FlowableFluid; +import net.minecraft.fluid.Fluid; import net.minecraft.item.BlockItem; import net.minecraft.item.Item; import net.minecraft.item.OperatorOnlyBlockItem; @@ -71,8 +73,10 @@ private static Block registerBlock(String id, Block block, BiFunction blockFactory, AbstractBlock.Settings settings) { + RegistryKey blockKey = RegistryKey.of(RegistryKeys.BLOCK, Cubliminal.id(name)); + Block block = blockFactory.apply(settings.registryKey(blockKey)); + return Registry.register(Registries.BLOCK, blockKey, block); } /** @@ -86,18 +90,14 @@ public static Block registerBlockWithoutItem(String name, Block block){ private static Block registerFluidBlock(String name, FlowableFluid flowableFluid, FluidBlockFactory factory, CustomFluidBlock.Settings settings){ return registerBlockWithoutItem( name + "_fluid", - factory.create( - flowableFluid, - AbstractBlock.Settings.create() - .replaceable() - .noCollision() - .strength(100.0f) - .pistonBehavior(PistonBehavior.DESTROY) - .dropsNothing() - .liquid() - .sounds(BlockSoundGroup.INTENTIONALLY_EMPTY), - settings - ) + blockSettings -> factory.create(flowableFluid, blockSettings, settings), + AbstractBlock.Settings.copy(Blocks.WATER) + .replaceable() + .noCollision() + .strength(100.0f) + .pistonBehavior(PistonBehavior.DESTROY) + .dropsNothing() + .liquid() ); } diff --git a/src/main/java/net/limit/cubliminal/init/CubliminalFluidTags.java b/src/main/java/net/limit/cubliminal/init/CubliminalFluidTags.java index 912e50f..13f501f 100644 --- a/src/main/java/net/limit/cubliminal/init/CubliminalFluidTags.java +++ b/src/main/java/net/limit/cubliminal/init/CubliminalFluidTags.java @@ -2,19 +2,23 @@ import net.limit.cubliminal.Cubliminal; import net.limit.cubliminal.Initer; +import net.limit.cubliminal.util.Debug; import net.minecraft.fluid.Fluid; +import net.minecraft.registry.Registries; import net.minecraft.registry.RegistryKeys; import net.minecraft.registry.tag.TagKey; -public class CubliminalFluidTags implements Initer { +import java.util.ArrayList; +import java.util.List; + +public class CubliminalFluidTags { public static final TagKey CUSTOM_FLUIDS = of("custom_fluids"); private static TagKey of(String id) { return TagKey.of(RegistryKeys.FLUID, Cubliminal.id(id)); } - @Override - public void init() { - Initer.super.init(); + public static void init() { + Debug.displayRegisteredSectors(CubliminalFluidTags.class); } } diff --git a/src/main/java/net/limit/cubliminal/init/CubliminalFluids.java b/src/main/java/net/limit/cubliminal/init/CubliminalFluids.java index 5df1a3b..f1890f2 100644 --- a/src/main/java/net/limit/cubliminal/init/CubliminalFluids.java +++ b/src/main/java/net/limit/cubliminal/init/CubliminalFluids.java @@ -35,8 +35,7 @@ private static Map registerFlui return fluidMap; } - @Override - public void init() { + public static void initFluid(){ Map almondWater = registerFluidTypes("almond_water", new AlmondWaterFluid.Flowing(), new AlmondWaterFluid.Still()); FLOWING_ALMOND_WATER = almondWater.get("flowing"); ALMOND_WATER = almondWater.get("still"); diff --git a/src/main/java/net/limit/cubliminal/mixin/FluidSplashMixin.java b/src/main/java/net/limit/cubliminal/mixin/FluidSplashMixin.java new file mode 100644 index 0000000..a5721b2 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/mixin/FluidSplashMixin.java @@ -0,0 +1,71 @@ +package net.limit.cubliminal.mixin; + +import net.limit.cubliminal.init.CubliminalFluids; +import net.limit.cubliminal.particle.CubliminalParticleTypes; +import net.minecraft.entity.Entity; +import net.minecraft.fluid.FlowableFluid; +import net.minecraft.fluid.Fluid; +import net.minecraft.fluid.FluidState; +import net.minecraft.particle.ParticleEffect; +import net.minecraft.particle.ParticleTypes; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.Unique; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.ModifyArg; + +@Mixin(Entity.class) +public abstract class FluidSplashMixin { + @Shadow public abstract World getWorld(); + + @ModifyArg( + method = "onSwimmingStart", + at = @At( + value = "INVOKE", + target = "Lnet/minecraft/world/World;addParticle(Lnet/minecraft/particle/ParticleEffect;DDDDDD)V" + ), + index = 0 + ) + private ParticleEffect redirectSplashParticle(ParticleEffect original) { + Entity self = (Entity) (Object) this; + + if (original == ParticleTypes.SPLASH){ + if (isInAlmondWater(self)){ + return CubliminalParticleTypes.LANDING_ALMOND_WATER; + } else if (isInContaminatedWater(self)){ + return CubliminalParticleTypes.CONTAMINATED_WATER_SPLASH; + } + } else if (original == ParticleTypes.BUBBLE){ + if (isInAlmondWater(self)){ + return CubliminalParticleTypes.ALMOND_WATER_BUBBLE; + } else if (isInContaminatedWater(self)){ + return CubliminalParticleTypes.CONTAMINATED_WATER_BUBBLE; + } + } + return original; + } + + @Unique + private boolean isInAlmondWater(Entity entity){ + return isInFluidCollection(entity, CubliminalFluids.ALMOND_WATER, CubliminalFluids.FLOWING_ALMOND_WATER); + } + + @Unique + private boolean isInContaminatedWater(Entity entity){ + return isInFluidCollection(entity, CubliminalFluids.CONTAMINATED_WATER, CubliminalFluids.FLOWING_CONTAMINATED_WATER); + } + + @Unique + private boolean isInFluidCollection(Entity entity, FlowableFluid fluid1, FlowableFluid fluid2){ + return isInFluid(entity, fluid1) || isInFluid(entity, fluid2); + } + + @Unique + private boolean isInFluid(Entity entity, Fluid fluid) { + BlockPos pos = entity.getBlockPos(); + FluidState fluidState = entity.getWorld().getFluidState(pos); + return fluidState.isOf(fluid); + } +} diff --git a/src/main/java/net/limit/cubliminal/mixin/LivingEntityMixin.java b/src/main/java/net/limit/cubliminal/mixin/LivingEntityMixin.java index 8da546d..b54fed0 100644 --- a/src/main/java/net/limit/cubliminal/mixin/LivingEntityMixin.java +++ b/src/main/java/net/limit/cubliminal/mixin/LivingEntityMixin.java @@ -42,7 +42,6 @@ private boolean isSubmergedAtFeet(TagKey fluid) { @Inject(method = "travel", at = @At("HEAD"), cancellable = true) private void onTravel(Vec3d movementInput, CallbackInfo ci){ - // Checks to see if player is submerged in backroom fluids. if (isSubmergedAtFeet(CubliminalFluidTags.CUSTOM_FLUIDS)){ // Checks to see if the fluid uses Project Backrooms custom implementations if (this.fluidState.getFluid() instanceof BackroomsFlowableFluid backroomsFluid){ diff --git a/src/main/java/net/limit/cubliminal/mixin/client/BackgroundRendererMixin.java b/src/main/java/net/limit/cubliminal/mixin/client/BackgroundRendererMixin.java index 2061795..135690e 100644 --- a/src/main/java/net/limit/cubliminal/mixin/client/BackgroundRendererMixin.java +++ b/src/main/java/net/limit/cubliminal/mixin/client/BackgroundRendererMixin.java @@ -10,7 +10,9 @@ import net.limit.cubliminal.client.util.CameraBackroomFluid; import net.limit.cubliminal.config.CubliminalConfig; import net.limit.cubliminal.fluid.BackroomsFlowableFluid; +import net.limit.cubliminal.init.CubliminalFluidTags; import net.limit.cubliminal.util.ColorManager; +import net.limit.cubliminal.util.Debug; import net.minecraft.block.enums.CameraSubmersionType; import net.minecraft.client.MinecraftClient; import net.minecraft.client.render.BackgroundRenderer; @@ -82,9 +84,8 @@ private static void onApplyFog(Camera camera, BackgroundRenderer.FogType fogType fluidColor.getBlueDecimal(), 0.5f ); - RenderSystem.setShaderFog(fog); - + cir.setReturnValue(fog); cir.cancel(); } } diff --git a/src/main/java/net/limit/cubliminal/particle/CubliminalParticleTypes.java b/src/main/java/net/limit/cubliminal/particle/CubliminalParticleTypes.java index 9f5f3a0..1ec3f26 100644 --- a/src/main/java/net/limit/cubliminal/particle/CubliminalParticleTypes.java +++ b/src/main/java/net/limit/cubliminal/particle/CubliminalParticleTypes.java @@ -6,35 +6,49 @@ import net.minecraft.particle.SimpleParticleType; import net.minecraft.registry.Registries; import net.minecraft.registry.Registry; -import net.minecraft.util.Identifier; import org.apache.http.annotation.Obsolete; -public class CubliminalParticleTypes implements Initer { - public static final SimpleParticleType CONTAMINATED_WATER_SPLASH = register("contaminated_water_splash", FabricParticleTypes.simple()); +public class CubliminalParticleTypes { + public static SimpleParticleType CONTAMINATED_WATER_SPLASH; - public static final SimpleParticleType ALMOND_WATER_BUBBLE = register("almond_water_bubble", FabricParticleTypes.simple()); - public static final SimpleParticleType CONTAMINATED_WATER_BUBBLE = register("contaminated_water_bubble", FabricParticleTypes.simple()); + public static SimpleParticleType ALMOND_WATER_BUBBLE; + public static SimpleParticleType CONTAMINATED_WATER_BUBBLE; - public static final SimpleParticleType DRIPPING_ALMOND_WATER = register("dripping_almond_water", FabricParticleTypes.simple()); - public static final SimpleParticleType FALLING_ALMOND_WATER = register("falling_almond_water", FabricParticleTypes.simple()); - public static final SimpleParticleType LANDING_ALMOND_WATER = register("landing_almond_water", FabricParticleTypes.simple()); + public static SimpleParticleType DRIPPING_ALMOND_WATER; + public static SimpleParticleType FALLING_ALMOND_WATER; + public static SimpleParticleType LANDING_ALMOND_WATER; - public static final SimpleParticleType DRIPPING_BLACK_SLUDGE = register("dripping_black_sludge", FabricParticleTypes.simple()); - public static final SimpleParticleType FALLING_BLACK_SLUDGE = register("falling_black_sludge", FabricParticleTypes.simple()); - public static final SimpleParticleType LANDING_BLACK_SLUDGE = register("landing_black_sludge", FabricParticleTypes.simple()); + public static SimpleParticleType DRIPPING_BLACK_SLUDGE; + public static SimpleParticleType FALLING_BLACK_SLUDGE; + public static SimpleParticleType LANDING_BLACK_SLUDGE; - public static final SimpleParticleType DRIPPING_CONTAMINATED_WATER = register("dripping_contaminated_water", FabricParticleTypes.simple()); - public static final SimpleParticleType FALLING_CONTAMINATED_WATER = register("falling_contaminated_water", FabricParticleTypes.simple()); - public static final SimpleParticleType LANDING_CONTAMINATED_WATER = register("landing_contaminated_water", FabricParticleTypes.simple()); + public static SimpleParticleType DRIPPING_CONTAMINATED_WATER; + public static SimpleParticleType FALLING_CONTAMINATED_WATER; + public static SimpleParticleType LANDING_CONTAMINATED_WATER; @Obsolete - public static final SimpleParticleType SPLASH = register("splash", FabricParticleTypes.simple()); + public static SimpleParticleType SPLASH; - private static SimpleParticleType register(String name, SimpleParticleType type){ - return Registry.register(Registries.PARTICLE_TYPE, Cubliminal.id(name), type); + private static SimpleParticleType register(String name){ + return Registry.register(Registries.PARTICLE_TYPE, Cubliminal.id(name), FabricParticleTypes.simple()); } - @Override - public void init() { - Initer.super.init(); + public static void init() { + CONTAMINATED_WATER_SPLASH = register("contaminated_water_splash"); + ALMOND_WATER_BUBBLE = register("almond_water_bubble"); + CONTAMINATED_WATER_BUBBLE = register("contaminated_water_bubble"); + + DRIPPING_ALMOND_WATER = register("dripping_almond_water"); + FALLING_ALMOND_WATER = register("falling_almond_water"); + LANDING_ALMOND_WATER = register("landing_almond_water"); + + DRIPPING_BLACK_SLUDGE = register("dripping_black_sludge"); + FALLING_BLACK_SLUDGE = register("falling_black_sludge"); + LANDING_BLACK_SLUDGE = register("landing_black_sludge"); + + DRIPPING_CONTAMINATED_WATER = register("dripping_contaminated_water"); + FALLING_CONTAMINATED_WATER = register("falling_contaminated_water"); + LANDING_CONTAMINATED_WATER = register("landing_contaminated_water"); + + SPLASH = register("splash"); } } diff --git a/src/main/resources/assets/cubliminal/particles/almond_water_bubble.json b/src/main/resources/assets/cubliminal/particles/almond_water_bubble.json new file mode 100644 index 0000000..8352fa3 --- /dev/null +++ b/src/main/resources/assets/cubliminal/particles/almond_water_bubble.json @@ -0,0 +1,5 @@ +{ + "textures": [ + "cubliminal:bubble" + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/particles/contaminated_water_bubble.json b/src/main/resources/assets/cubliminal/particles/contaminated_water_bubble.json new file mode 100644 index 0000000..8352fa3 --- /dev/null +++ b/src/main/resources/assets/cubliminal/particles/contaminated_water_bubble.json @@ -0,0 +1,5 @@ +{ + "textures": [ + "cubliminal:bubble" + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/particles/contaminated_water_splash.json b/src/main/resources/assets/cubliminal/particles/contaminated_water_splash.json new file mode 100644 index 0000000..f3d4e7a --- /dev/null +++ b/src/main/resources/assets/cubliminal/particles/contaminated_water_splash.json @@ -0,0 +1,8 @@ +{ + "textures": [ + "cubliminal:splash_0", + "cubliminal:splash_1", + "cubliminal:splash_2", + "cubliminal:splash_3" + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/particles/dripping_almond_water.json b/src/main/resources/assets/cubliminal/particles/dripping_almond_water.json new file mode 100644 index 0000000..987e9f3 --- /dev/null +++ b/src/main/resources/assets/cubliminal/particles/dripping_almond_water.json @@ -0,0 +1,5 @@ +{ + "textures": [ + "minecraft:drip_hang" + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/particles/dripping_black_sludge.json b/src/main/resources/assets/cubliminal/particles/dripping_black_sludge.json new file mode 100644 index 0000000..987e9f3 --- /dev/null +++ b/src/main/resources/assets/cubliminal/particles/dripping_black_sludge.json @@ -0,0 +1,5 @@ +{ + "textures": [ + "minecraft:drip_hang" + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/particles/dripping_contaminated_water.json b/src/main/resources/assets/cubliminal/particles/dripping_contaminated_water.json new file mode 100644 index 0000000..987e9f3 --- /dev/null +++ b/src/main/resources/assets/cubliminal/particles/dripping_contaminated_water.json @@ -0,0 +1,5 @@ +{ + "textures": [ + "minecraft:drip_hang" + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/particles/falling_almond_water.json b/src/main/resources/assets/cubliminal/particles/falling_almond_water.json new file mode 100644 index 0000000..520ad48 --- /dev/null +++ b/src/main/resources/assets/cubliminal/particles/falling_almond_water.json @@ -0,0 +1,5 @@ +{ + "textures": [ + "minecraft:drip_fall" + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/particles/falling_black_sludge.json b/src/main/resources/assets/cubliminal/particles/falling_black_sludge.json new file mode 100644 index 0000000..520ad48 --- /dev/null +++ b/src/main/resources/assets/cubliminal/particles/falling_black_sludge.json @@ -0,0 +1,5 @@ +{ + "textures": [ + "minecraft:drip_fall" + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/particles/falling_contaminated_water.json b/src/main/resources/assets/cubliminal/particles/falling_contaminated_water.json new file mode 100644 index 0000000..520ad48 --- /dev/null +++ b/src/main/resources/assets/cubliminal/particles/falling_contaminated_water.json @@ -0,0 +1,5 @@ +{ + "textures": [ + "minecraft:drip_fall" + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/particles/landing_almond_water.json b/src/main/resources/assets/cubliminal/particles/landing_almond_water.json new file mode 100644 index 0000000..f3d4e7a --- /dev/null +++ b/src/main/resources/assets/cubliminal/particles/landing_almond_water.json @@ -0,0 +1,8 @@ +{ + "textures": [ + "cubliminal:splash_0", + "cubliminal:splash_1", + "cubliminal:splash_2", + "cubliminal:splash_3" + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/particles/landing_black_sludge.json b/src/main/resources/assets/cubliminal/particles/landing_black_sludge.json new file mode 100644 index 0000000..89230de --- /dev/null +++ b/src/main/resources/assets/cubliminal/particles/landing_black_sludge.json @@ -0,0 +1,5 @@ +{ + "textures": [ + "minecraft:drip_land" + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/particles/landing_contaminated_water.json b/src/main/resources/assets/cubliminal/particles/landing_contaminated_water.json new file mode 100644 index 0000000..f3d4e7a --- /dev/null +++ b/src/main/resources/assets/cubliminal/particles/landing_contaminated_water.json @@ -0,0 +1,8 @@ +{ + "textures": [ + "cubliminal:splash_0", + "cubliminal:splash_1", + "cubliminal:splash_2", + "cubliminal:splash_3" + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/particles/splash.json b/src/main/resources/assets/cubliminal/particles/splash.json new file mode 100644 index 0000000..f3d4e7a --- /dev/null +++ b/src/main/resources/assets/cubliminal/particles/splash.json @@ -0,0 +1,8 @@ +{ + "textures": [ + "cubliminal:splash_0", + "cubliminal:splash_1", + "cubliminal:splash_2", + "cubliminal:splash_3" + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/textures/particle/bubble.png b/src/main/resources/assets/cubliminal/textures/particle/bubble.png new file mode 100644 index 0000000000000000000000000000000000000000..2e51a5000fdda4b250be55c5999561ee488ac69f GIT binary patch literal 164 zcmeAS@N?(olHy`uVBq!ia0vp^93afW1|*O0@9PFqoCO|{#S9GG!XV7ZFl&wkP%zBX z#W6%;YVG-hybOvQE*B53SsOXYHp4waYWn`=raRazKORzPVBB?evf=YPFYoR4oW#H= zmHgrBO?IWGjvJ2U%m0*Li_+bFr|r7*9a)EI_hYhiw_Nj?6!(5fShq;p1aF`X44$rj JF6*2UngFz`IPCxc literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/cubliminal/textures/particle/splash_0.png b/src/main/resources/assets/cubliminal/textures/particle/splash_0.png new file mode 100644 index 0000000000000000000000000000000000000000..05de36e9b4b3c4dfedb684892e2791efbba6408d GIT binary patch literal 129 zcmeAS@N?(olHy`uVBq!ia0vp^93afW1|*O0@9PFqoCO|{#S9GG!XV7ZFl&wkP|(=Z z#W6%;>e>Ez~aEOc*VgI`v8aejkY XT9Y)>l{B+MKe+rpAqEAW!&3kBzfJjTpz-d2Pw>nmBBqzGWz=)8@=`buy<+G3vhD3FZyuc^ Ve&B$lmpM=`gQu&X%Q~loCIBg?C0YOg literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/cubliminal/textures/particle/splash_2.png b/src/main/resources/assets/cubliminal/textures/particle/splash_2.png new file mode 100644 index 0000000000000000000000000000000000000000..4a38b51d79fd6606978474c5dc7e2164d36f18bb GIT binary patch literal 108 zcmeAS@N?(olHy`uVBq!ia0vp^93afW1|*O0@9PFqoCO|{#S9GG!XV7ZFl&wkP*Bd( z#W6%;YVx1||LvLW4zz@qZP2>0qfohPy98&YFaui{r}P7cu>U}n44$rjF6*2UngE?k B8lC_E literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/cubliminal/textures/particle/splash_3.png b/src/main/resources/assets/cubliminal/textures/particle/splash_3.png new file mode 100644 index 0000000000000000000000000000000000000000..71ec0d7d4a525dee0025d3663df63779205d3580 GIT binary patch literal 112 zcmeAS@N?(olHy`uVBq!ia0vp^93afW1|*O0@9PFqoCO|{#S9GG!XV7ZFl&wkP*BO! z#W6%;YVx1||LvLW4zz@qZP1)ykjNDF{(z{2q-3HgBf~CrwjhnrRAr!Q22WQ%mvv4F FO#ta*8a@C3 literal 0 HcmV?d00001 diff --git a/src/main/resources/cubliminal.mixins.json b/src/main/resources/cubliminal.mixins.json index 41a76b5..607f3ba 100644 --- a/src/main/resources/cubliminal.mixins.json +++ b/src/main/resources/cubliminal.mixins.json @@ -7,6 +7,7 @@ "ChunkSectionMixin", "ClearAllEffectsConsumeEffectMixin", "EntityMixin", + "FluidSplashMixin", "LivingEntityMixin", "PlayerEntityMixin" ], diff --git a/src/main/resources/data/cubliminal/tags/fluids/custom_fluids.json b/src/main/resources/data/cubliminal/tags/fluid/custom_fluids.json similarity index 100% rename from src/main/resources/data/cubliminal/tags/fluids/custom_fluids.json rename to src/main/resources/data/cubliminal/tags/fluid/custom_fluids.json diff --git a/src/main/resources/data/minecraft/tags/fluids/water.json b/src/main/resources/data/minecraft/tags/fluid/water.json similarity index 100% rename from src/main/resources/data/minecraft/tags/fluids/water.json rename to src/main/resources/data/minecraft/tags/fluid/water.json From 77a76839171fe0595ea46e327e23b5d140e81981 Mon Sep 17 00:00:00 2001 From: jonathan-x01 Date: Tue, 15 Jul 2025 19:00:42 -0400 Subject: [PATCH 4/4] - Implemented pipes - Optimized fluid code --- .../limit/cubliminal/CubliminalClient.java | 11 +- .../block/entity/PipeBlockEntity.java | 93 ++++ .../BlackSludgeFluidBlock.java | 2 +- .../ContaminatedWaterBlock.java | 2 +- .../{fluids => fluid}/CustomFluidBlock.java | 57 ++- .../{fluids => fluid}/FluidBlockFactory.java | 2 +- .../block/pipe/CeilingPipeBlock.java | 59 +++ .../block/pipe/ConnectorPipeBlock.java | 8 + .../block/pipe/LargeHorizontalPipeBlock.java | 46 ++ .../cubliminal/block/pipe/PipeBlock.java | 118 +++++ .../block/pipe/VerticalPipeBlock.java | 40 ++ .../state/pipeType/CeilingPipeTypes.java | 22 + .../pipeType/LargeHorizontalPipeTypes.java | 19 + .../state/pipeType/TypedPipeSupport.java | 10 + .../state/pipeType/VerticalPipeTypes.java | 18 + .../client/util/CameraBackroomFluid.java | 1 - .../cubliminal/fluid/AlmondWaterFluid.java | 2 +- .../fluid/BackroomsFlowableFluid.java | 2 +- .../cubliminal/fluid/BlackSludgeFluid.java | 2 +- .../fluid/ContaminatedWaterFluid.java | 4 +- .../init/CubliminalBlockEntities.java | 3 + .../cubliminal/init/CubliminalBlocks.java | 57 ++- .../cubliminal/init/CubliminalFluidTags.java | 9 +- .../cubliminal/init/CubliminalFluids.java | 1 - .../cubliminal/mixin/FluidSplashMixin.java | 67 +-- .../cubliminal/mixin/LivingEntityMixin.java | 9 +- .../mixin/client/BackgroundRendererMixin.java | 5 +- .../util/{Debug.java => DebugLogger.java} | 10 +- .../cubliminal/blockstates/ceiling_pipe.json | 28 ++ .../blockstates/large_horizontal_pipe.json | 23 + .../cubliminal/blockstates/vertical_pipe.json | 13 + .../assets/cubliminal/lang/en_us.json | 3 + .../models/block/pipes/ceiling_pipe_1.json | 275 +++++++++++ .../models/block/pipes/ceiling_pipe_2.json | 335 +++++++++++++ .../models/block/pipes/ceiling_pipe_3.json | 387 +++++++++++++++ .../models/block/pipes/ceiling_pipe_4.json | 387 +++++++++++++++ .../models/block/pipes/ceiling_pipe_5.json | 457 ++++++++++++++++++ .../models/block/pipes/large_pipe_1.json | 215 ++++++++ .../models/block/pipes/large_pipe_2.json | 124 +++++ .../models/block/pipes/large_pipe_3.json | 253 ++++++++++ .../models/block/pipes/vertical_pipe.json | 84 ++++ .../block/pipes/vertical_pipe_connector.json | 183 +++++++ .../cubliminal/models/item/ceiling_pipe.json | 3 + .../models/item/large_horizontal_pipe.json | 3 + .../cubliminal/models/item/vertical_pipe.json | 3 + .../textures/block/pipes/pipe-ring.png | Bin 0 -> 646 bytes .../cubliminal/textures/block/pipes/pipes.png | Bin 0 -> 738 bytes .../cubliminal/textures/block/pipes/staff.png | Bin 0 -> 713 bytes 48 files changed, 3377 insertions(+), 78 deletions(-) create mode 100644 src/main/java/net/limit/cubliminal/block/entity/PipeBlockEntity.java rename src/main/java/net/limit/cubliminal/block/{fluids => fluid}/BlackSludgeFluidBlock.java (94%) rename src/main/java/net/limit/cubliminal/block/{fluids => fluid}/ContaminatedWaterBlock.java (94%) rename src/main/java/net/limit/cubliminal/block/{fluids => fluid}/CustomFluidBlock.java (68%) rename src/main/java/net/limit/cubliminal/block/{fluids => fluid}/FluidBlockFactory.java (87%) create mode 100644 src/main/java/net/limit/cubliminal/block/pipe/CeilingPipeBlock.java create mode 100644 src/main/java/net/limit/cubliminal/block/pipe/ConnectorPipeBlock.java create mode 100644 src/main/java/net/limit/cubliminal/block/pipe/LargeHorizontalPipeBlock.java create mode 100644 src/main/java/net/limit/cubliminal/block/pipe/PipeBlock.java create mode 100644 src/main/java/net/limit/cubliminal/block/pipe/VerticalPipeBlock.java create mode 100644 src/main/java/net/limit/cubliminal/block/state/pipeType/CeilingPipeTypes.java create mode 100644 src/main/java/net/limit/cubliminal/block/state/pipeType/LargeHorizontalPipeTypes.java create mode 100644 src/main/java/net/limit/cubliminal/block/state/pipeType/TypedPipeSupport.java create mode 100644 src/main/java/net/limit/cubliminal/block/state/pipeType/VerticalPipeTypes.java rename src/main/java/net/limit/cubliminal/util/{Debug.java => DebugLogger.java} (90%) create mode 100644 src/main/resources/assets/cubliminal/blockstates/ceiling_pipe.json create mode 100644 src/main/resources/assets/cubliminal/blockstates/large_horizontal_pipe.json create mode 100644 src/main/resources/assets/cubliminal/blockstates/vertical_pipe.json create mode 100644 src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_1.json create mode 100644 src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_2.json create mode 100644 src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_3.json create mode 100644 src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_4.json create mode 100644 src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_5.json create mode 100644 src/main/resources/assets/cubliminal/models/block/pipes/large_pipe_1.json create mode 100644 src/main/resources/assets/cubliminal/models/block/pipes/large_pipe_2.json create mode 100644 src/main/resources/assets/cubliminal/models/block/pipes/large_pipe_3.json create mode 100644 src/main/resources/assets/cubliminal/models/block/pipes/vertical_pipe.json create mode 100644 src/main/resources/assets/cubliminal/models/block/pipes/vertical_pipe_connector.json create mode 100644 src/main/resources/assets/cubliminal/models/item/ceiling_pipe.json create mode 100644 src/main/resources/assets/cubliminal/models/item/large_horizontal_pipe.json create mode 100644 src/main/resources/assets/cubliminal/models/item/vertical_pipe.json create mode 100644 src/main/resources/assets/cubliminal/textures/block/pipes/pipe-ring.png create mode 100644 src/main/resources/assets/cubliminal/textures/block/pipes/pipes.png create mode 100644 src/main/resources/assets/cubliminal/textures/block/pipes/staff.png diff --git a/src/main/java/net/limit/cubliminal/CubliminalClient.java b/src/main/java/net/limit/cubliminal/CubliminalClient.java index ce5f685..0624f25 100644 --- a/src/main/java/net/limit/cubliminal/CubliminalClient.java +++ b/src/main/java/net/limit/cubliminal/CubliminalClient.java @@ -4,16 +4,13 @@ import net.fabricmc.api.EnvType; import net.fabricmc.api.Environment; import net.fabricmc.fabric.api.blockrenderlayer.v1.BlockRenderLayerMap; -import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents; import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientWorldEvents; -import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper; import net.fabricmc.fabric.api.client.render.fluid.v1.FluidRenderHandlerRegistry; import net.fabricmc.fabric.api.client.render.fluid.v1.SimpleFluidRenderHandler; import net.fabricmc.fabric.api.client.rendering.v1.EntityRendererRegistry; import net.fabricmc.fabric.api.client.rendering.v1.HudRenderCallback; -import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents; import net.limit.cubliminal.access.GameRendererAccessor; -import net.limit.cubliminal.block.fluids.CustomFluidBlock; +import net.limit.cubliminal.block.fluid.CustomFluidBlock; import net.limit.cubliminal.client.hud.SanityBarHudOverlay; import net.limit.cubliminal.client.particle.CubliminalParticleManager; import net.limit.cubliminal.client.render.FluxCapacitorRenderer; @@ -23,14 +20,8 @@ import net.limit.cubliminal.entity.client.SeatRenderer; import net.limit.cubliminal.event.KeyInputHandler; import net.limit.cubliminal.init.*; -import net.limit.cubliminal.util.Debug; -import net.minecraft.client.option.KeyBinding; import net.minecraft.client.render.*; import net.minecraft.client.render.block.entity.BlockEntityRendererFactories; -import net.minecraft.client.util.InputUtil; -import org.lwjgl.glfw.GLFW; - -import java.util.concurrent.atomic.AtomicInteger; @Environment(EnvType.CLIENT) public class CubliminalClient implements ClientModInitializer { diff --git a/src/main/java/net/limit/cubliminal/block/entity/PipeBlockEntity.java b/src/main/java/net/limit/cubliminal/block/entity/PipeBlockEntity.java new file mode 100644 index 0000000..9ad7d37 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/block/entity/PipeBlockEntity.java @@ -0,0 +1,93 @@ +package net.limit.cubliminal.block.entity; + +import net.limit.cubliminal.block.state.pipeType.LargeHorizontalPipeTypes; +import net.limit.cubliminal.init.CubliminalBlockEntities; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.block.entity.BlockEntity; +import net.minecraft.fluid.Fluid; +import net.minecraft.nbt.NbtCompound; +import net.minecraft.network.listener.ClientPlayPacketListener; +import net.minecraft.network.packet.Packet; +import net.minecraft.network.packet.s2c.play.BlockEntityUpdateS2CPacket; +import net.minecraft.registry.Registries; +import net.minecraft.registry.RegistryWrapper; +import net.minecraft.util.Identifier; +import net.minecraft.util.math.BlockPos; +import org.jetbrains.annotations.Nullable; + +public class PipeBlockEntity extends BlockEntity { + private Identifier fluidContainer; + private LargeHorizontalPipeTypes pipeVariety; + private int varietyID = 0; + + public PipeBlockEntity(BlockPos pos, BlockState state) { + super(CubliminalBlockEntities.PIPE_BLOCK_ENTITY, pos, state); + } + + public void setVarietyID(int id){ + this.varietyID = id; + } + + public void setPipeVariety(LargeHorizontalPipeTypes pipeVariety){ + this.pipeVariety = pipeVariety; + } + + public void setFluidContainer(Fluid fluid){ + this.fluidContainer = Registries.FLUID.getId(fluid); + markDirty(); + if (this.world != null && !this.world.isClient) { + this.world.updateListeners(pos, getCachedState(), getCachedState(), Block.NOTIFY_ALL); + } + } + + public int getVarietyID(){ + return this.varietyID; + } + + public LargeHorizontalPipeTypes getPipeVariety(){ + return this.pipeVariety; + } + + public Fluid getFluidContainer(){ + return Registries.FLUID.get(this.fluidContainer); + } + + @Override + public void readNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registries) { + super.readNbt(nbt, registries); + if (nbt.contains("fluid_container")){ + this.fluidContainer = Identifier.of(nbt.getString("fluid_container")); + } else if (nbt.contains("variety")){ + this.pipeVariety = LargeHorizontalPipeTypes.valueOf(nbt.getString("variety")); + } else if (nbt.contains("variety_id")){ + this.varietyID = nbt.getInt("variety_id"); + } + } + + @Override + protected void writeNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registries) { + super.writeNbt(nbt, registries); + if (this.fluidContainer != null){ + nbt.putString("fluid_container",this.fluidContainer.toString()); + } else if (this.pipeVariety != null){ + nbt.putString("variety", this.pipeVariety.asString()); + } else if (this.varietyID != 0){ + nbt.putInt("variety_id", this.varietyID); + } + } + + @Nullable + @Override + public Packet toUpdatePacket() { + return BlockEntityUpdateS2CPacket.create(this); + } + + @Override + public NbtCompound toInitialChunkDataNbt(RegistryWrapper.WrapperLookup registries) { + super.toInitialChunkDataNbt(registries); + NbtCompound nbt = new NbtCompound(); + writeNbt(nbt, registries); + return nbt; + } +} diff --git a/src/main/java/net/limit/cubliminal/block/fluids/BlackSludgeFluidBlock.java b/src/main/java/net/limit/cubliminal/block/fluid/BlackSludgeFluidBlock.java similarity index 94% rename from src/main/java/net/limit/cubliminal/block/fluids/BlackSludgeFluidBlock.java rename to src/main/java/net/limit/cubliminal/block/fluid/BlackSludgeFluidBlock.java index 0fc950a..effbf3f 100644 --- a/src/main/java/net/limit/cubliminal/block/fluids/BlackSludgeFluidBlock.java +++ b/src/main/java/net/limit/cubliminal/block/fluid/BlackSludgeFluidBlock.java @@ -1,4 +1,4 @@ -package net.limit.cubliminal.block.fluids; +package net.limit.cubliminal.block.fluid; import net.limit.cubliminal.init.CubliminalEffects; import net.minecraft.block.AbstractBlock; diff --git a/src/main/java/net/limit/cubliminal/block/fluids/ContaminatedWaterBlock.java b/src/main/java/net/limit/cubliminal/block/fluid/ContaminatedWaterBlock.java similarity index 94% rename from src/main/java/net/limit/cubliminal/block/fluids/ContaminatedWaterBlock.java rename to src/main/java/net/limit/cubliminal/block/fluid/ContaminatedWaterBlock.java index 5b4502e..c4c5230 100644 --- a/src/main/java/net/limit/cubliminal/block/fluids/ContaminatedWaterBlock.java +++ b/src/main/java/net/limit/cubliminal/block/fluid/ContaminatedWaterBlock.java @@ -1,4 +1,4 @@ -package net.limit.cubliminal.block.fluids; +package net.limit.cubliminal.block.fluid; import net.minecraft.block.AbstractBlock; import net.minecraft.entity.effect.StatusEffectInstance; diff --git a/src/main/java/net/limit/cubliminal/block/fluids/CustomFluidBlock.java b/src/main/java/net/limit/cubliminal/block/fluid/CustomFluidBlock.java similarity index 68% rename from src/main/java/net/limit/cubliminal/block/fluids/CustomFluidBlock.java rename to src/main/java/net/limit/cubliminal/block/fluid/CustomFluidBlock.java index 4080473..2331ed3 100644 --- a/src/main/java/net/limit/cubliminal/block/fluids/CustomFluidBlock.java +++ b/src/main/java/net/limit/cubliminal/block/fluid/CustomFluidBlock.java @@ -1,4 +1,4 @@ -package net.limit.cubliminal.block.fluids; +package net.limit.cubliminal.block.fluid; import com.google.common.collect.Iterables; import com.google.common.collect.Maps; @@ -11,6 +11,8 @@ import net.minecraft.entity.effect.StatusEffectInstance; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.fluid.FlowableFluid; +import net.minecraft.particle.ParticleTypes; +import net.minecraft.particle.SimpleParticleType; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.Vec3d; import net.minecraft.world.World; @@ -80,6 +82,7 @@ public static class Settings { float fogEnd; Vec3d drag; float speed; + FluidSplashParticleManager splashParticleManager = null; private Settings(){ this.useDefaultFluidPhysics = true; @@ -146,5 +149,57 @@ public Settings setSpeed(float speed){ public float getSpeed(){ return this.speed; } + + public Settings setSplashParticles(FluidSplashParticleManager splashParticleManager){ + this.splashParticleManager = splashParticleManager; + return this; + } + + public FluidSplashParticleManager getSplashParticles(){ + return this.splashParticleManager; + } + } + + public static class FluidSplashParticleManager { + SimpleParticleType splashParticle; + SimpleParticleType bubbleParticle; + + private FluidSplashParticleManager(SimpleParticleType splashParticle, SimpleParticleType bubbleParticle){ + this.splashParticle = splashParticle; + this.bubbleParticle = bubbleParticle; + } + + public static FluidSplashParticleManager create(){ + return new FluidSplashParticleManager(ParticleTypes.SPLASH, ParticleTypes.BUBBLE); + } + + public FluidSplashParticleManager removeDefaultSplashParticle(){ + this.splashParticle = null; + return this; + } + + public FluidSplashParticleManager removeDefaultBubbleParticle(){ + this.bubbleParticle = null; + return this; + } + + public FluidSplashParticleManager removeDefaultParticles(){ + this.removeDefaultSplashParticle().removeDefaultBubbleParticle(); + return this; + } + + public FluidSplashParticleManager setParticles(SimpleParticleType splashParticle, SimpleParticleType bubbleParticle){ + this.splashParticle = splashParticle; + this.bubbleParticle = bubbleParticle; + return this; + } + + public SimpleParticleType getSplashParticle(){ + return this.splashParticle; + } + + public SimpleParticleType getBubbleParticle(){ + return this.bubbleParticle; + } } } diff --git a/src/main/java/net/limit/cubliminal/block/fluids/FluidBlockFactory.java b/src/main/java/net/limit/cubliminal/block/fluid/FluidBlockFactory.java similarity index 87% rename from src/main/java/net/limit/cubliminal/block/fluids/FluidBlockFactory.java rename to src/main/java/net/limit/cubliminal/block/fluid/FluidBlockFactory.java index 9e2fae5..dcc3de1 100644 --- a/src/main/java/net/limit/cubliminal/block/fluids/FluidBlockFactory.java +++ b/src/main/java/net/limit/cubliminal/block/fluid/FluidBlockFactory.java @@ -1,4 +1,4 @@ -package net.limit.cubliminal.block.fluids; +package net.limit.cubliminal.block.fluid; import net.minecraft.block.AbstractBlock; import net.minecraft.block.Block; diff --git a/src/main/java/net/limit/cubliminal/block/pipe/CeilingPipeBlock.java b/src/main/java/net/limit/cubliminal/block/pipe/CeilingPipeBlock.java new file mode 100644 index 0000000..e7de500 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/block/pipe/CeilingPipeBlock.java @@ -0,0 +1,59 @@ +package net.limit.cubliminal.block.pipe; + +import net.limit.cubliminal.block.state.pipeType.CeilingPipeTypes; +import net.limit.cubliminal.block.state.pipeType.TypedPipeSupport; +import net.limit.cubliminal.init.CubliminalBlocks; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; +import net.minecraft.state.StateManager; +import net.minecraft.state.property.EnumProperty; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Direction; +import net.minecraft.util.math.random.Random; +import net.minecraft.world.WorldAccess; +import net.minecraft.world.WorldView; +import net.minecraft.world.tick.ScheduledTickView; + +import java.util.Objects; + +public class CeilingPipeBlock extends PipeBlock implements TypedPipeSupport { + public static final EnumProperty TYPE = TypedPipeSupport.build(CeilingPipeTypes.class); + public CeilingPipeBlock(Settings settings) { + super(settings); + } + + @Override + protected void appendProperties(StateManager.Builder builder) { + super.appendProperties(builder); + builder.add(TYPE); + } + + /*@Override + protected BlockState getStateForNeighborUpdate(BlockState state, WorldView world, ScheduledTickView tickView, BlockPos pos, Direction direction, BlockPos neighborPos, BlockState neighborState, Random random) { + BlockState up = world.getBlockState(pos.up()); + BlockState down = world.getBlockState(pos.down()); + if (down.isOf(BackroomBlocks.VERTICAL_PIPE)) { + return state.with(CeilingPipeBlock.CONNECTION, down.get(VerticalPipeBlock.FACING)); + } + if (up.isOf(BackroomBlocks.VERTICAL_PIPE)) { + return state.with(CeilingPipeBlock.CONNECTION, up.get(VerticalPipeBlock.FACING)); + } + return state.with(CeilingPipeBlock.CONNECTION, Direction.UP); + }*/ + + @Override + public BlockState getStateForNeighborUpdate(BlockState state, WorldView world, ScheduledTickView tickView, BlockPos pos, Direction direction, BlockPos neighborPos, BlockState neighborState, Random random) { + if (neighborState.isOf(CubliminalBlocks.VERTICAL_PIPE)){ + if (Objects.equals(neighborPos, pos.up()) || Objects.equals(neighborPos, pos.down())){ + Direction neighborDirection = neighborState.get(VerticalPipeBlock.FACING); + return state.with(CeilingPipeBlock.TYPE, CeilingPipeTypes.ONE_LAYER_VERTICAL_PIPE_CONNECTION).with(CeilingPipeBlock.FACING, neighborDirection.getOpposite()); + } + } else if (neighborState.isOf(Blocks.AIR)){ + if (!world.getBlockState(pos.up()).isOf(CubliminalBlocks.VERTICAL_PIPE) && !world.getBlockState(pos.down()).isOf(CubliminalBlocks.VERTICAL_PIPE)){ + return state.with(CeilingPipeBlock.TYPE, CeilingPipeTypes.ONE_LAYER_STRAIGHT); + } + } + return super.getStateForNeighborUpdate(state, world, tickView, pos, direction, neighborPos, neighborState, random); + } +} diff --git a/src/main/java/net/limit/cubliminal/block/pipe/ConnectorPipeBlock.java b/src/main/java/net/limit/cubliminal/block/pipe/ConnectorPipeBlock.java new file mode 100644 index 0000000..b3f68b4 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/block/pipe/ConnectorPipeBlock.java @@ -0,0 +1,8 @@ +package net.limit.cubliminal.block.pipe; + +import net.minecraft.state.property.BooleanProperty; + +public final class ConnectorPipeBlock { + public static final BooleanProperty CONNECTOR = BooleanProperty.of("connector"); + private ConnectorPipeBlock() {} +} diff --git a/src/main/java/net/limit/cubliminal/block/pipe/LargeHorizontalPipeBlock.java b/src/main/java/net/limit/cubliminal/block/pipe/LargeHorizontalPipeBlock.java new file mode 100644 index 0000000..d7aafbc --- /dev/null +++ b/src/main/java/net/limit/cubliminal/block/pipe/LargeHorizontalPipeBlock.java @@ -0,0 +1,46 @@ +package net.limit.cubliminal.block.pipe; + +import net.limit.cubliminal.block.state.pipeType.LargeHorizontalPipeTypes; +import net.limit.cubliminal.block.state.pipeType.TypedPipeSupport; +import net.limit.cubliminal.util.DebugLogger; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.state.StateManager; +import net.minecraft.state.property.EnumProperty; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Direction; +import net.minecraft.util.math.random.Random; +import net.minecraft.world.WorldView; +import net.minecraft.world.tick.ScheduledTickView; + +import static net.limit.cubliminal.block.pipe.ConnectorPipeBlock.CONNECTOR; + +public class LargeHorizontalPipeBlock extends PipeBlock implements TypedPipeSupport { + public static final EnumProperty TYPE = TypedPipeSupport.build(LargeHorizontalPipeTypes.class); + public LargeHorizontalPipeBlock(Settings settings) { + super(settings); + } + + @Override + protected void appendProperties(StateManager.Builder builder) { + super.appendProperties(builder); + builder + .add(CONNECTOR) + .add(TYPE); + } + + @Override + public BlockState getStateForNeighborUpdate(BlockState state, WorldView world, ScheduledTickView tickView, BlockPos pos, Direction direction, BlockPos neighborPos, BlockState neighborState, Random random) { + BlockState north = world.getBlockState(pos.north()); + BlockState east = world.getBlockState(pos.east()); + BlockState south = world.getBlockState(pos.south()); + BlockState west = world.getBlockState(pos.west()); + DebugLogger.debug( + north, + east, + south, + west + ); + return super.getStateForNeighborUpdate(state, world, tickView, pos, direction, neighborPos, neighborState, random); + } +} diff --git a/src/main/java/net/limit/cubliminal/block/pipe/PipeBlock.java b/src/main/java/net/limit/cubliminal/block/pipe/PipeBlock.java new file mode 100644 index 0000000..168e0ca --- /dev/null +++ b/src/main/java/net/limit/cubliminal/block/pipe/PipeBlock.java @@ -0,0 +1,118 @@ +package net.limit.cubliminal.block.pipe; + +import net.limit.cubliminal.block.entity.PipeBlockEntity; +import net.limit.cubliminal.block.state.pipeType.LargeHorizontalPipeTypes; +import net.limit.cubliminal.init.CubliminalFluids; +import net.minecraft.block.*; +import net.minecraft.block.entity.BlockEntity; +import net.minecraft.entity.LivingEntity; +import net.minecraft.fluid.Fluid; +import net.minecraft.fluid.FluidState; +import net.minecraft.fluid.Fluids; +import net.minecraft.item.ItemPlacementContext; +import net.minecraft.item.ItemStack; +import net.minecraft.state.StateManager; +import net.minecraft.state.property.BooleanProperty; +import net.minecraft.state.property.EnumProperty; +import net.minecraft.state.property.Properties; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Direction; +import net.minecraft.util.shape.VoxelShape; +import net.minecraft.world.World; +import org.jetbrains.annotations.Nullable; + +import java.text.DecimalFormat; +import java.util.Random; + +public class PipeBlock extends Block implements Waterloggable, BlockEntityProvider { + public static final BooleanProperty WATERLOGGED = Properties.WATERLOGGED; + public static final BooleanProperty LEAKING = BooleanProperty.of("leaking"); + public static final EnumProperty FACING = Properties.HORIZONTAL_FACING; + + public PipeBlock(Settings settings) { + super(settings); + if (this.getDefaultState().contains(ConnectorPipeBlock.CONNECTOR)){ + this.setDefaultState(this.getDefaultState().with(WATERLOGGED, false).with(ConnectorPipeBlock.CONNECTOR, false)); + } else { + this.setDefaultState(this.getDefaultState().with(WATERLOGGED, false)); + } + } + + @Override + public void onPlaced(World world, BlockPos pos, BlockState state, @Nullable LivingEntity placer, ItemStack itemStack) { + super.onPlaced(world, pos, state, placer, itemStack); + BlockEntity blockEntity = world.getBlockEntity(pos); + if (blockEntity instanceof PipeBlockEntity pipeBlockEntity){ + if (pipeBlockEntity.getFluidContainer() == Fluids.EMPTY) { + pipeBlockEntity.setFluidContainer(CubliminalFluids.ALMOND_WATER); + } + + pipeBlockEntity.setPipeVariety(LargeHorizontalPipeTypes.STRAIGHT_PIPE); + + } + } + + @Nullable + @Override + public BlockState getPlacementState(ItemPlacementContext ctx) { + double chance = new Random().nextDouble();; + boolean leakingDefault = chance < 0.2f; + return this.getDefaultState().with(FACING, ctx.getHorizontalPlayerFacing().getOpposite()).with(LEAKING,leakingDefault); + } + + @Override + protected void appendProperties(StateManager.Builder builder) { + builder + .add(WATERLOGGED) + .add(FACING) + .add(LEAKING); + } + + public double getRandomPosition(double min, double max){ + Random random = new Random(); + double randomDouble = random.nextDouble() * (max - min) + min; + DecimalFormat df = new DecimalFormat("#.##"); + return Double.parseDouble(df.format(randomDouble)); + } + + @Override + public FluidState getFluidState(BlockState state) { + if (state.get(WATERLOGGED).booleanValue()) { + return Fluids.WATER.getStill(false); + } + return super.getFluidState(state); + } + + @Override + public void randomDisplayTick(BlockState state, World world, BlockPos pos, net.minecraft.util.math.random.Random random) { + super.randomDisplayTick(state, world, pos, random); + double chance = random.nextDouble(); + + VoxelShape shape = state.getOutlineShape(world,pos); + double minX = shape.getMin(Direction.Axis.X); + double maxX = shape.getMax(Direction.Axis.X); + double minZ = shape.getMin(Direction.Axis.Z); + double maxZ = shape.getMax(Direction.Axis.Z); + BlockEntity blockEntity = world.getBlockEntity(pos); + if (chance < 0.2f){ + boolean leaking = state.get(LEAKING); + if (leaking){ + if (blockEntity instanceof PipeBlockEntity pipeBlockEntity){ + double x = pos.getX() + getRandomPosition(minX, maxX); + double y = pos.getY(); + double z = pos.getZ() + getRandomPosition(minZ, maxZ); + Fluid fluid = pipeBlockEntity.getFluidContainer(); + if (!fluid.matchesType(Fluids.EMPTY)){ + world.addParticle(pipeBlockEntity.getFluidContainer().getParticle(), x, y, z, 0.0f, 0.0f, 0.0f); + } + } + } + } + } + + @Nullable + @Override + public BlockEntity createBlockEntity(BlockPos pos, BlockState state) { + return new PipeBlockEntity(pos, state); + } +} diff --git a/src/main/java/net/limit/cubliminal/block/pipe/VerticalPipeBlock.java b/src/main/java/net/limit/cubliminal/block/pipe/VerticalPipeBlock.java new file mode 100644 index 0000000..9edd8d5 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/block/pipe/VerticalPipeBlock.java @@ -0,0 +1,40 @@ +package net.limit.cubliminal.block.pipe; + +import net.limit.cubliminal.block.state.pipeType.TypedPipeSupport; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.block.ShapeContext; +import net.minecraft.state.StateManager; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.shape.VoxelShape; +import net.minecraft.world.BlockView; + +import static net.limit.cubliminal.block.pipe.ConnectorPipeBlock.CONNECTOR; + +public class VerticalPipeBlock extends PipeBlock implements TypedPipeSupport { + public static final VoxelShape SHAPE_WEST = Block.createCuboidShape(9.0, 0.0, 4.0, 16.0, 16.0, 12.0); + public static final VoxelShape SHAPE_NORTH = Block.createCuboidShape(4.0, 0.0, 9.0, 12.0, 16.0, 16.0); + public static final VoxelShape SHAPE_EAST = Block.createCuboidShape(0.0, 0.0, 4.0, 7.0, 16.0, 12.0); + public static final VoxelShape SHAPE_SOUTH = Block.createCuboidShape(4.0, 0.0, 0.0, 12.0, 16.0, 7.0); + + public VerticalPipeBlock(Settings settings) { + super(settings); + } + + @Override + protected void appendProperties(StateManager.Builder builder) { + super.appendProperties(builder); + builder + .add(CONNECTOR); + } + + @Override + public VoxelShape getOutlineShape(BlockState state, BlockView world, BlockPos pos, ShapeContext context) { + return switch (state.get(FACING)){ + case WEST -> SHAPE_WEST; + case EAST -> SHAPE_EAST; + case SOUTH -> SHAPE_SOUTH; + default -> SHAPE_NORTH; + }; + } +} diff --git a/src/main/java/net/limit/cubliminal/block/state/pipeType/CeilingPipeTypes.java b/src/main/java/net/limit/cubliminal/block/state/pipeType/CeilingPipeTypes.java new file mode 100644 index 0000000..ed3da03 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/block/state/pipeType/CeilingPipeTypes.java @@ -0,0 +1,22 @@ +package net.limit.cubliminal.block.state.pipeType; + +import net.minecraft.util.StringIdentifiable; + +public enum CeilingPipeTypes implements StringIdentifiable { + ONE_LAYER_STRAIGHT("one_layer_straight"), + ONE_LAYER_VERTICAL_PIPE_CONNECTION("one_layer_vertical_pipe_connection"), + TWO_LAYER_STRAIGHT("two_layer_straight"), + TWO_LAYER_CORNER("two_layer_corner"), + TWO_LAYER_UP("two_layer_up"); + + private final String name; + + CeilingPipeTypes(String name) { + this.name = name; + } + + @Override + public String asString() { + return this.name; + } +} diff --git a/src/main/java/net/limit/cubliminal/block/state/pipeType/LargeHorizontalPipeTypes.java b/src/main/java/net/limit/cubliminal/block/state/pipeType/LargeHorizontalPipeTypes.java new file mode 100644 index 0000000..3240ebf --- /dev/null +++ b/src/main/java/net/limit/cubliminal/block/state/pipeType/LargeHorizontalPipeTypes.java @@ -0,0 +1,19 @@ +package net.limit.cubliminal.block.state.pipeType; + +import net.minecraft.util.StringIdentifiable; + +public enum LargeHorizontalPipeTypes implements StringIdentifiable { + STRAIGHT_PIPE("straight"), + CORNER_PIPE("corner"); + + private final String name; + + LargeHorizontalPipeTypes(String name) { + this.name = name; + } + + @Override + public String asString() { + return this.name; + } +} diff --git a/src/main/java/net/limit/cubliminal/block/state/pipeType/TypedPipeSupport.java b/src/main/java/net/limit/cubliminal/block/state/pipeType/TypedPipeSupport.java new file mode 100644 index 0000000..b2b4943 --- /dev/null +++ b/src/main/java/net/limit/cubliminal/block/state/pipeType/TypedPipeSupport.java @@ -0,0 +1,10 @@ +package net.limit.cubliminal.block.state.pipeType; + +import net.minecraft.state.property.EnumProperty; +import net.minecraft.util.StringIdentifiable; + +public interface TypedPipeSupport { + static & StringIdentifiable> EnumProperty build(Class clazz) { + return EnumProperty.of("type", clazz); + } +} diff --git a/src/main/java/net/limit/cubliminal/block/state/pipeType/VerticalPipeTypes.java b/src/main/java/net/limit/cubliminal/block/state/pipeType/VerticalPipeTypes.java new file mode 100644 index 0000000..eeb3b5b --- /dev/null +++ b/src/main/java/net/limit/cubliminal/block/state/pipeType/VerticalPipeTypes.java @@ -0,0 +1,18 @@ +package net.limit.cubliminal.block.state.pipeType; + +import net.minecraft.util.StringIdentifiable; + +public enum VerticalPipeTypes implements StringIdentifiable { + STRAIGHT("straight"), + PLACEHOLDER("placeholder"); + + private final String name; + VerticalPipeTypes(String name){ + this.name = name; + } + + @Override + public String asString() { + return this.name; + } +} diff --git a/src/main/java/net/limit/cubliminal/client/util/CameraBackroomFluid.java b/src/main/java/net/limit/cubliminal/client/util/CameraBackroomFluid.java index 9158ef9..dd9bd1f 100644 --- a/src/main/java/net/limit/cubliminal/client/util/CameraBackroomFluid.java +++ b/src/main/java/net/limit/cubliminal/client/util/CameraBackroomFluid.java @@ -1,7 +1,6 @@ package net.limit.cubliminal.client.util; import net.limit.cubliminal.init.CubliminalFluidTags; -import net.limit.cubliminal.util.Debug; import net.minecraft.client.render.Camera; import net.minecraft.fluid.FluidState; import net.minecraft.util.math.BlockPos; diff --git a/src/main/java/net/limit/cubliminal/fluid/AlmondWaterFluid.java b/src/main/java/net/limit/cubliminal/fluid/AlmondWaterFluid.java index 1d94646..d34932f 100644 --- a/src/main/java/net/limit/cubliminal/fluid/AlmondWaterFluid.java +++ b/src/main/java/net/limit/cubliminal/fluid/AlmondWaterFluid.java @@ -1,6 +1,6 @@ package net.limit.cubliminal.fluid; -import net.limit.cubliminal.block.fluids.CustomFluidBlock; +import net.limit.cubliminal.block.fluid.CustomFluidBlock; import net.limit.cubliminal.init.CubliminalBlocks; import net.limit.cubliminal.init.CubliminalFluids; import net.limit.cubliminal.particle.CubliminalParticleTypes; diff --git a/src/main/java/net/limit/cubliminal/fluid/BackroomsFlowableFluid.java b/src/main/java/net/limit/cubliminal/fluid/BackroomsFlowableFluid.java index 0bc139f..bdd7dac 100644 --- a/src/main/java/net/limit/cubliminal/fluid/BackroomsFlowableFluid.java +++ b/src/main/java/net/limit/cubliminal/fluid/BackroomsFlowableFluid.java @@ -1,6 +1,6 @@ package net.limit.cubliminal.fluid; -import net.limit.cubliminal.block.fluids.CustomFluidBlock; +import net.limit.cubliminal.block.fluid.CustomFluidBlock; import net.minecraft.block.Block; import net.minecraft.block.BlockState; import net.minecraft.block.entity.BlockEntity; diff --git a/src/main/java/net/limit/cubliminal/fluid/BlackSludgeFluid.java b/src/main/java/net/limit/cubliminal/fluid/BlackSludgeFluid.java index b8258bb..791af9b 100644 --- a/src/main/java/net/limit/cubliminal/fluid/BlackSludgeFluid.java +++ b/src/main/java/net/limit/cubliminal/fluid/BlackSludgeFluid.java @@ -1,6 +1,6 @@ package net.limit.cubliminal.fluid; -import net.limit.cubliminal.block.fluids.CustomFluidBlock; +import net.limit.cubliminal.block.fluid.CustomFluidBlock; import net.limit.cubliminal.init.CubliminalBlocks; import net.limit.cubliminal.init.CubliminalFluids; import net.minecraft.block.BlockState; diff --git a/src/main/java/net/limit/cubliminal/fluid/ContaminatedWaterFluid.java b/src/main/java/net/limit/cubliminal/fluid/ContaminatedWaterFluid.java index 0769924..df2c88b 100644 --- a/src/main/java/net/limit/cubliminal/fluid/ContaminatedWaterFluid.java +++ b/src/main/java/net/limit/cubliminal/fluid/ContaminatedWaterFluid.java @@ -1,6 +1,6 @@ package net.limit.cubliminal.fluid; -import net.limit.cubliminal.block.fluids.CustomFluidBlock; +import net.limit.cubliminal.block.fluid.CustomFluidBlock; import net.limit.cubliminal.init.CubliminalBlocks; import net.limit.cubliminal.init.CubliminalFluids; import net.minecraft.block.BlockState; @@ -9,13 +9,11 @@ import net.minecraft.fluid.FluidState; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; -import net.minecraft.particle.ParticleEffect; import net.minecraft.server.world.ServerWorld; import net.minecraft.sound.SoundCategory; import net.minecraft.sound.SoundEvents; import net.minecraft.state.StateManager; import net.minecraft.world.WorldView; -import org.jetbrains.annotations.Nullable; public class ContaminatedWaterFluid extends BackroomsFlowableFluid { public ContaminatedWaterFluid() { diff --git a/src/main/java/net/limit/cubliminal/init/CubliminalBlockEntities.java b/src/main/java/net/limit/cubliminal/init/CubliminalBlockEntities.java index dc6c3d1..3662c12 100644 --- a/src/main/java/net/limit/cubliminal/init/CubliminalBlockEntities.java +++ b/src/main/java/net/limit/cubliminal/init/CubliminalBlockEntities.java @@ -4,6 +4,7 @@ import net.limit.cubliminal.Cubliminal; import net.limit.cubliminal.Initer; import net.limit.cubliminal.block.entity.*; +import net.minecraft.block.Block; import net.minecraft.block.entity.BlockEntityType; import net.minecraft.registry.Registries; import net.minecraft.registry.Registry; @@ -29,4 +30,6 @@ public static > T register(String id, T blockEntity public static final BlockEntityType USBLOCK_BLOCK_ENTITY = register("unlimited_structure_block", FabricBlockEntityTypeBuilder.create(USBlockBlockEntity::new, CubliminalBlocks.UNLIMITED_STRUCTURE_BLOCK).build()); + public static final BlockEntityType PIPE_BLOCK_ENTITY = + register("pipe_block_entity", FabricBlockEntityTypeBuilder.create(PipeBlockEntity::new, CubliminalBlocks.pipeBlocks.toArray(new Block[0])).build()); } diff --git a/src/main/java/net/limit/cubliminal/init/CubliminalBlocks.java b/src/main/java/net/limit/cubliminal/init/CubliminalBlocks.java index 1145ca5..11e54e4 100644 --- a/src/main/java/net/limit/cubliminal/init/CubliminalBlocks.java +++ b/src/main/java/net/limit/cubliminal/init/CubliminalBlocks.java @@ -7,17 +7,20 @@ import net.limit.cubliminal.block.custom.*; import net.limit.cubliminal.block.custom.template.RotatableBlock; import net.limit.cubliminal.block.custom.template.RotatableLightBlock; -import net.limit.cubliminal.block.fluids.BlackSludgeFluidBlock; -import net.limit.cubliminal.block.fluids.ContaminatedWaterBlock; -import net.limit.cubliminal.block.fluids.CustomFluidBlock; -import net.limit.cubliminal.block.fluids.FluidBlockFactory; +import net.limit.cubliminal.block.fluid.BlackSludgeFluidBlock; +import net.limit.cubliminal.block.fluid.ContaminatedWaterBlock; +import net.limit.cubliminal.block.fluid.CustomFluidBlock; +import net.limit.cubliminal.block.fluid.FluidBlockFactory; +import net.limit.cubliminal.block.pipe.CeilingPipeBlock; +import net.limit.cubliminal.block.pipe.LargeHorizontalPipeBlock; +import net.limit.cubliminal.block.pipe.PipeBlock; +import net.limit.cubliminal.block.pipe.VerticalPipeBlock; import net.limit.cubliminal.item.AlmondWaterBlockItem; -import net.limit.cubliminal.util.Debug; +import net.limit.cubliminal.particle.CubliminalParticleTypes; import net.minecraft.block.*; import net.minecraft.block.piston.PistonBehavior; import net.minecraft.component.DataComponentTypes; import net.minecraft.fluid.FlowableFluid; -import net.minecraft.fluid.Fluid; import net.minecraft.item.BlockItem; import net.minecraft.item.Item; import net.minecraft.item.OperatorOnlyBlockItem; @@ -33,6 +36,8 @@ import net.minecraft.util.Rarity; import net.minecraft.util.math.Vec3d; +import java.util.ArrayList; +import java.util.List; import java.util.function.BiFunction; import java.util.function.Function; import java.util.function.ToIntFunction; @@ -40,12 +45,19 @@ import static net.minecraft.block.Blocks.createLightLevelFromLitBlockState; public class CubliminalBlocks implements Initer { + public static List pipeBlocks = new ArrayList<>(); + private static void groupPipeBlock(Block block){ + if (block instanceof PipeBlock){ + pipeBlocks.add(block); + } + } private static Block register(String id, Function blockFactory, AbstractBlock.Settings blockSettings, BiFunction itemFactory, Item.Settings itemSettings) { RegistryKey itemKey = RegistryKey.of(RegistryKeys.ITEM, Cubliminal.id(id)); RegistryKey blockKey = RegistryKey.of(RegistryKeys.BLOCK, Cubliminal.id(id)); Block block = blockFactory.apply(blockSettings.registryKey(blockKey)); + groupPipeBlock(block); BlockItem item = itemFactory.apply(block, itemSettings.registryKey(itemKey)); Registry.register(Registries.ITEM, itemKey, item); return Registry.register(Registries.BLOCK, blockKey, block); @@ -56,6 +68,7 @@ private static Block register(String id, BiFunction blockKey = RegistryKey.of(RegistryKeys.BLOCK, Cubliminal.id(id)); Block block = blockFactory.apply(constructorData, blockSettings.registryKey(blockKey)); + groupPipeBlock(block); BlockItem item = itemFactory.apply(block, itemSettings.registryKey(itemKey)); Registry.register(Registries.ITEM, itemKey, item); return Registry.register(Registries.BLOCK, blockKey, block); @@ -66,6 +79,7 @@ private static Block register(String id, Function } private static Block registerBlock(String id, Block block, BiFunction itemFactory, Item.Settings itemSettings) { + groupPipeBlock(block); RegistryKey blockKey = RegistryKey.of(RegistryKeys.BLOCK, Cubliminal.id(id)); RegistryKey itemKey = RegistryKey.of(RegistryKeys.ITEM, Cubliminal.id(id)); BlockItem item = itemFactory.apply(block, itemSettings.registryKey(itemKey)); @@ -76,6 +90,7 @@ private static Block registerBlock(String id, Block block, BiFunction blockFactory, AbstractBlock.Settings settings) { RegistryKey blockKey = RegistryKey.of(RegistryKeys.BLOCK, Cubliminal.id(name)); Block block = blockFactory.apply(settings.registryKey(blockKey)); + groupPipeBlock(block); return Registry.register(Registries.BLOCK, blockKey, block); } @@ -479,6 +494,24 @@ public static TagKey of(String id) { public static final Block POOL_TILE_WALL = register("pool_tile_wall", WallBlock::new, AbstractBlock.Settings.copy(Blocks.REINFORCED_DEEPSLATE).solid()); + public static final Block LARGE_HORIZONTAL_PIPE = register( + "large_horizontal_pipe", + LargeHorizontalPipeBlock::new, + AbstractBlock.Settings.create().nonOpaque() + ); + + public static final Block VERTICAL_PIPE = register( + "vertical_pipe", + VerticalPipeBlock::new, + AbstractBlock.Settings.create().nonOpaque() + ); + + public static final Block CEILING_PIPE = register( + "ceiling_pipe", + CeilingPipeBlock::new, + AbstractBlock.Settings.create().nonOpaque() + ); + public static Block ALMOND_WATER_BLOCK; public static Block CONTAMINATED_WATER_BLOCK; public static Block BLACK_SLUDGE_BLOCK; @@ -516,11 +549,19 @@ public void init() { ALMOND_WATER_BLOCK = registerFluidBlock("almond_water", CubliminalFluids.ALMOND_WATER, CustomFluidBlock::new, CustomFluidBlock.Settings.create() .setColor(0xFFECB3) + .setSplashParticles(CustomFluidBlock.FluidSplashParticleManager.create() + .setParticles(CubliminalParticleTypes.LANDING_ALMOND_WATER, CubliminalParticleTypes.ALMOND_WATER_BUBBLE) + ) ); CONTAMINATED_WATER_BLOCK = registerFluidBlock("contaminated_water", CubliminalFluids.CONTAMINATED_WATER, ContaminatedWaterBlock::new, CustomFluidBlock.Settings.create() .setColor(0x556B2F) + .setFogEnd(10.0f) + .setSplashParticles( + CustomFluidBlock.FluidSplashParticleManager.create() + .setParticles(CubliminalParticleTypes.CONTAMINATED_WATER_SPLASH, CubliminalParticleTypes.CONTAMINATED_WATER_BUBBLE) + ) ); BLACK_SLUDGE_BLOCK = registerFluidBlock("black_sludge", CubliminalFluids.BLACK_SLUDGE, BlackSludgeFluidBlock::new, @@ -528,8 +569,8 @@ public void init() { .setColor(0x000000) .setSpeed(0.005f) .setDrag(new Vec3d(0.5, 0.4, 0.5)) - .setFogStart(0.25f) - .setFogEnd(1.0f) + .setFogStart(0.25F) + .setFogEnd(1.0F) ); } } diff --git a/src/main/java/net/limit/cubliminal/init/CubliminalFluidTags.java b/src/main/java/net/limit/cubliminal/init/CubliminalFluidTags.java index 13f501f..78c3caf 100644 --- a/src/main/java/net/limit/cubliminal/init/CubliminalFluidTags.java +++ b/src/main/java/net/limit/cubliminal/init/CubliminalFluidTags.java @@ -1,16 +1,11 @@ package net.limit.cubliminal.init; import net.limit.cubliminal.Cubliminal; -import net.limit.cubliminal.Initer; -import net.limit.cubliminal.util.Debug; +import net.limit.cubliminal.util.DebugLogger; import net.minecraft.fluid.Fluid; -import net.minecraft.registry.Registries; import net.minecraft.registry.RegistryKeys; import net.minecraft.registry.tag.TagKey; -import java.util.ArrayList; -import java.util.List; - public class CubliminalFluidTags { public static final TagKey CUSTOM_FLUIDS = of("custom_fluids"); @@ -19,6 +14,6 @@ private static TagKey of(String id) { } public static void init() { - Debug.displayRegisteredSectors(CubliminalFluidTags.class); + DebugLogger.displayRegisteredSectors(CubliminalFluidTags.class); } } diff --git a/src/main/java/net/limit/cubliminal/init/CubliminalFluids.java b/src/main/java/net/limit/cubliminal/init/CubliminalFluids.java index f1890f2..587f3d8 100644 --- a/src/main/java/net/limit/cubliminal/init/CubliminalFluids.java +++ b/src/main/java/net/limit/cubliminal/init/CubliminalFluids.java @@ -5,7 +5,6 @@ import net.limit.cubliminal.fluid.AlmondWaterFluid; import net.limit.cubliminal.fluid.BlackSludgeFluid; import net.limit.cubliminal.fluid.ContaminatedWaterFluid; -import net.limit.cubliminal.util.Debug; import net.minecraft.fluid.FlowableFluid; import net.minecraft.fluid.Fluid; import net.minecraft.registry.Registries; diff --git a/src/main/java/net/limit/cubliminal/mixin/FluidSplashMixin.java b/src/main/java/net/limit/cubliminal/mixin/FluidSplashMixin.java index a5721b2..3195ba4 100644 --- a/src/main/java/net/limit/cubliminal/mixin/FluidSplashMixin.java +++ b/src/main/java/net/limit/cubliminal/mixin/FluidSplashMixin.java @@ -1,7 +1,12 @@ package net.limit.cubliminal.mixin; +import net.limit.cubliminal.block.fluid.CustomFluidBlock; +import net.limit.cubliminal.fluid.BackroomsFlowableFluid; import net.limit.cubliminal.init.CubliminalFluids; import net.limit.cubliminal.particle.CubliminalParticleTypes; +import net.limit.cubliminal.util.DebugLogger; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; import net.minecraft.entity.Entity; import net.minecraft.fluid.FlowableFluid; import net.minecraft.fluid.Fluid; @@ -9,6 +14,8 @@ import net.minecraft.particle.ParticleEffect; import net.minecraft.particle.ParticleTypes; import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Box; +import net.minecraft.util.math.MathHelper; import net.minecraft.world.World; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.Shadow; @@ -16,6 +23,8 @@ import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.ModifyArg; +import java.util.function.Predicate; + @Mixin(Entity.class) public abstract class FluidSplashMixin { @Shadow public abstract World getWorld(); @@ -30,42 +39,46 @@ public abstract class FluidSplashMixin { ) private ParticleEffect redirectSplashParticle(ParticleEffect original) { Entity self = (Entity) (Object) this; + Fluid fluid = getTouchingFluid(self, f -> f instanceof BackroomsFlowableFluid); - if (original == ParticleTypes.SPLASH){ - if (isInAlmondWater(self)){ - return CubliminalParticleTypes.LANDING_ALMOND_WATER; - } else if (isInContaminatedWater(self)){ - return CubliminalParticleTypes.CONTAMINATED_WATER_SPLASH; - } - } else if (original == ParticleTypes.BUBBLE){ - if (isInAlmondWater(self)){ - return CubliminalParticleTypes.ALMOND_WATER_BUBBLE; - } else if (isInContaminatedWater(self)){ - return CubliminalParticleTypes.CONTAMINATED_WATER_BUBBLE; + if (fluid instanceof BackroomsFlowableFluid flowableFluid){ + CustomFluidBlock.Settings settings = flowableFluid.getFluidBlock().getFluidSettings(); + CustomFluidBlock.FluidSplashParticleManager splashParticle = settings.getSplashParticles(); + if (original == ParticleTypes.SPLASH && splashParticle.getSplashParticle() != null){ + return splashParticle.getSplashParticle(); + } else if (original == ParticleTypes.BUBBLE && splashParticle.getBubbleParticle() != null){ + return splashParticle.getBubbleParticle(); } } return original; } @Unique - private boolean isInAlmondWater(Entity entity){ - return isInFluidCollection(entity, CubliminalFluids.ALMOND_WATER, CubliminalFluids.FLOWING_ALMOND_WATER); - } + private Fluid getTouchingFluid(Entity entity, Predicate filter) { + Box box = entity.getBoundingBox().contract(0.001); // Slightly smaller to avoid edge noise + World world = entity.getWorld(); - @Unique - private boolean isInContaminatedWater(Entity entity){ - return isInFluidCollection(entity, CubliminalFluids.CONTAMINATED_WATER, CubliminalFluids.FLOWING_CONTAMINATED_WATER); - } + int minX = MathHelper.floor(box.minX); + int maxX = MathHelper.floor(box.maxX); + int minY = MathHelper.floor(box.minY); + int maxY = MathHelper.floor(box.maxY); + int minZ = MathHelper.floor(box.minZ); + int maxZ = MathHelper.floor(box.maxZ); - @Unique - private boolean isInFluidCollection(Entity entity, FlowableFluid fluid1, FlowableFluid fluid2){ - return isInFluid(entity, fluid1) || isInFluid(entity, fluid2); - } + for (int x = minX; x <= maxX; ++x) { + for (int y = minY; y <= maxY; ++y) { + for (int z = minZ; z <= maxZ; ++z) { + BlockPos pos = new BlockPos(x, y, z); + FluidState state = world.getFluidState(pos); + Fluid fluid = state.getFluid(); + if (!state.isEmpty() && filter.test(fluid)) { + return fluid; + } + } + } + } - @Unique - private boolean isInFluid(Entity entity, Fluid fluid) { - BlockPos pos = entity.getBlockPos(); - FluidState fluidState = entity.getWorld().getFluidState(pos); - return fluidState.isOf(fluid); + return null; } + } diff --git a/src/main/java/net/limit/cubliminal/mixin/LivingEntityMixin.java b/src/main/java/net/limit/cubliminal/mixin/LivingEntityMixin.java index b54fed0..aa724ac 100644 --- a/src/main/java/net/limit/cubliminal/mixin/LivingEntityMixin.java +++ b/src/main/java/net/limit/cubliminal/mixin/LivingEntityMixin.java @@ -1,22 +1,15 @@ package net.limit.cubliminal.mixin; -import net.limit.cubliminal.block.fluids.CustomFluidBlock; +import net.limit.cubliminal.block.fluid.CustomFluidBlock; import net.limit.cubliminal.fluid.BackroomsFlowableFluid; import net.limit.cubliminal.init.CubliminalFluidTags; import net.minecraft.entity.Entity; -import net.minecraft.entity.EntityType; import net.minecraft.entity.LivingEntity; import net.minecraft.entity.MovementType; -import net.minecraft.entity.damage.DamageSource; -import net.minecraft.entity.data.DataTracker; import net.minecraft.fluid.Fluid; import net.minecraft.fluid.FluidState; -import net.minecraft.nbt.NbtCompound; import net.minecraft.registry.tag.TagKey; -import net.minecraft.server.world.ServerWorld; -import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.Vec3d; -import net.minecraft.world.World; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.Shadow; import org.spongepowered.asm.mixin.Unique; diff --git a/src/main/java/net/limit/cubliminal/mixin/client/BackgroundRendererMixin.java b/src/main/java/net/limit/cubliminal/mixin/client/BackgroundRendererMixin.java index 135690e..7bfee84 100644 --- a/src/main/java/net/limit/cubliminal/mixin/client/BackgroundRendererMixin.java +++ b/src/main/java/net/limit/cubliminal/mixin/client/BackgroundRendererMixin.java @@ -4,15 +4,13 @@ import net.fabricmc.api.EnvType; import net.fabricmc.api.Environment; import net.limit.cubliminal.Cubliminal; -import net.limit.cubliminal.block.fluids.CustomFluidBlock; +import net.limit.cubliminal.block.fluid.CustomFluidBlock; import net.limit.cubliminal.client.render.fog.FogManager; import net.limit.cubliminal.client.render.fog.FogSettings; import net.limit.cubliminal.client.util.CameraBackroomFluid; import net.limit.cubliminal.config.CubliminalConfig; import net.limit.cubliminal.fluid.BackroomsFlowableFluid; -import net.limit.cubliminal.init.CubliminalFluidTags; import net.limit.cubliminal.util.ColorManager; -import net.limit.cubliminal.util.Debug; import net.minecraft.block.enums.CameraSubmersionType; import net.minecraft.client.MinecraftClient; import net.minecraft.client.render.BackgroundRenderer; @@ -30,7 +28,6 @@ import org.spongepowered.asm.mixin.Shadow; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; @Environment(EnvType.CLIENT) diff --git a/src/main/java/net/limit/cubliminal/util/Debug.java b/src/main/java/net/limit/cubliminal/util/DebugLogger.java similarity index 90% rename from src/main/java/net/limit/cubliminal/util/Debug.java rename to src/main/java/net/limit/cubliminal/util/DebugLogger.java index 201b8c1..aca22e6 100644 --- a/src/main/java/net/limit/cubliminal/util/Debug.java +++ b/src/main/java/net/limit/cubliminal/util/DebugLogger.java @@ -1,11 +1,10 @@ package net.limit.cubliminal.util; import net.limit.cubliminal.Cubliminal; -import org.apache.http.annotation.Obsolete; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class Debug { +public class DebugLogger { private static final String MOD_ID = Cubliminal.MOD_ID; private static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID); @@ -65,6 +64,12 @@ public static void debug(int age, int increment, Object msg){ } } + /** + * Displays a debug message every tick. Useful for methods that would run every tick, that way the IDE can handle it. + * @param age = Simply get the age of the entity. + * @param increment = How many times per tick the message will display. 20 ticks = 1 second + * @param msg = The message to display/ + */ public static void debug(int age, int increment, Object... msg){ if (age % increment == 0){ debug(msg); @@ -75,6 +80,7 @@ public static void debug(int age, int increment, Object... msg){ * Displays a message to the Minecraft log to list sectors that was loaded from the mod. * @param c The class that has loaded. */ + @Deprecated public static void displayRegisteredSectors(Class c){ LOGGER.info(ANSI_GREEN + "{ LOADED | " + ANSI_CYAN + MOD_ID + ANSI_GREEN + " } " + ANSI_BLUE + c.getSimpleName()); } diff --git a/src/main/resources/assets/cubliminal/blockstates/ceiling_pipe.json b/src/main/resources/assets/cubliminal/blockstates/ceiling_pipe.json new file mode 100644 index 0000000..5e63db6 --- /dev/null +++ b/src/main/resources/assets/cubliminal/blockstates/ceiling_pipe.json @@ -0,0 +1,28 @@ +{ + "variants": { + "facing=north,type=one_layer_straight": { "model": "cubliminal:block/pipes/ceiling_pipe_1"}, + "facing=east,type=one_layer_straight": { "model": "cubliminal:block/pipes/ceiling_pipe_1", "y": 90}, + "facing=south,type=one_layer_straight": { "model": "cubliminal:block/pipes/ceiling_pipe_1", "y": 180}, + "facing=west,type=one_layer_straight": { "model": "cubliminal:block/pipes/ceiling_pipe_1", "y": 270}, + + "facing=north,type=two_layer_straight": { "model": "cubliminal:block/pipes/ceiling_pipe_2"}, + "facing=east,type=two_layer_straight": { "model": "cubliminal:block/pipes/ceiling_pipe_2", "y": 90}, + "facing=south,type=two_layer_straight": { "model": "cubliminal:block/pipes/ceiling_pipe_2", "y": 180}, + "facing=west,type=two_layer_straight": { "model": "cubliminal:block/pipes/ceiling_pipe_2", "y": 270}, + + "facing=north,type=two_layer_corner": { "model": "cubliminal:block/pipes/ceiling_pipe_3"}, + "facing=east,type=two_layer_corner": { "model": "cubliminal:block/pipes/ceiling_pipe_3", "y": 90}, + "facing=south,type=two_layer_corner": { "model": "cubliminal:block/pipes/ceiling_pipe_3", "y": 180}, + "facing=west,type=two_layer_corner": { "model": "cubliminal:block/pipes/ceiling_pipe_3", "y": 270}, + + "facing=north,type=two_layer_up": { "model": "cubliminal:block/pipes/ceiling_pipe_4"}, + "facing=east,type=two_layer_up": { "model": "cubliminal:block/pipes/ceiling_pipe_4", "y": 90}, + "facing=south,type=two_layer_up": { "model": "cubliminal:block/pipes/ceiling_pipe_4", "y": 180}, + "facing=west,type=two_layer_up": { "model": "cubliminal:block/pipes/ceiling_pipe_4", "y": 270}, + + "facing=north,type=one_layer_vertical_pipe_connection": { "model": "cubliminal:block/pipes/ceiling_pipe_5"}, + "facing=east,type=one_layer_vertical_pipe_connection": { "model": "cubliminal:block/pipes/ceiling_pipe_5", "y": 90}, + "facing=south,type=one_layer_vertical_pipe_connection": { "model": "cubliminal:block/pipes/ceiling_pipe_5", "y": 180}, + "facing=west,type=one_layer_vertical_pipe_connection": { "model": "cubliminal:block/pipes/ceiling_pipe_5", "y": 270} + } +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/blockstates/large_horizontal_pipe.json b/src/main/resources/assets/cubliminal/blockstates/large_horizontal_pipe.json new file mode 100644 index 0000000..6804ae8 --- /dev/null +++ b/src/main/resources/assets/cubliminal/blockstates/large_horizontal_pipe.json @@ -0,0 +1,23 @@ +{ + "variants": { + "facing=north,type=straight,connector=false": { "model": "cubliminal:block/pipes/large_pipe_2"}, + "facing=east,type=straight,connector=false": { "model": "cubliminal:block/pipes/large_pipe_2", "y": 90}, + "facing=south,type=straight,connector=false": { "model": "cubliminal:block/pipes/large_pipe_2", "y": 180}, + "facing=west,type=straight,connector=false": { "model": "cubliminal:block/pipes/large_pipe_2", "y": 270}, + + "facing=north,type=straight,connector=true": { "model": "cubliminal:block/pipes/large_pipe_1"}, + "facing=east,type=straight,connector=true": { "model": "cubliminal:block/pipes/large_pipe_1", "y": 90}, + "facing=south,type=straight,connector=true": { "model": "cubliminal:block/pipes/large_pipe_1", "y": 180}, + "facing=west,type=straight,connector=true": { "model": "cubliminal:block/pipes/large_pipe_1", "y": 270}, + + "facing=north,type=corner,connector=false": { "model": "cubliminal:block/pipes/large_pipe_3"}, + "facing=east,type=corner,connector=false": { "model": "cubliminal:block/pipes/large_pipe_3", "y": 90}, + "facing=south,type=corner,connector=false": { "model": "cubliminal:block/pipes/large_pipe_3", "y": 180}, + "facing=west,type=corner,connector=false": { "model": "cubliminal:block/pipes/large_pipe_3", "y": 270}, + + "facing=north,type=corner,connector=true": { "model": "cubliminal:block/pipes/large_pipe_3"}, + "facing=east,type=corner,connector=true": { "model": "cubliminal:block/pipes/large_pipe_3", "y": 90}, + "facing=south,type=corner,connector=true": { "model": "cubliminal:block/pipes/large_pipe_3", "y": 180}, + "facing=west,type=corner,connector=true": { "model": "cubliminal:block/pipes/large_pipe_3", "y": 270} + } +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/blockstates/vertical_pipe.json b/src/main/resources/assets/cubliminal/blockstates/vertical_pipe.json new file mode 100644 index 0000000..771faed --- /dev/null +++ b/src/main/resources/assets/cubliminal/blockstates/vertical_pipe.json @@ -0,0 +1,13 @@ +{ + "variants": { + "facing=north,connector=false": { "model": "cubliminal:block/pipes/vertical_pipe", "y": 180}, + "facing=east,connector=false": { "model": "cubliminal:block/pipes/vertical_pipe", "y": 270}, + "facing=south,connector=false": { "model": "cubliminal:block/pipes/vertical_pipe"}, + "facing=west,connector=false": { "model": "cubliminal:block/pipes/vertical_pipe", "y": 90}, + + "facing=north,connector=true": { "model": "cubliminal:block/pipes/vertical_pipe_connector", "y": 180}, + "facing=east,connector=true": { "model": "cubliminal:block/pipes/vertical_pipe_connector", "y": 270}, + "facing=south,connector=true": { "model": "cubliminal:block/pipes/vertical_pipe_connector"}, + "facing=west,connector=true": { "model": "cubliminal:block/pipes/vertical_pipe_connector", "y": 90} + } +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/lang/en_us.json b/src/main/resources/assets/cubliminal/lang/en_us.json index b573f17..d90f6f6 100644 --- a/src/main/resources/assets/cubliminal/lang/en_us.json +++ b/src/main/resources/assets/cubliminal/lang/en_us.json @@ -52,6 +52,9 @@ "item.cubliminal.emergency_exit_door_1": "Emergency Exit Door (1)", "item.cubliminal.exit_sign": "Exit Sign", "item.cubliminal.exit_sign_2": "Exit Sign 2", + "item.cubliminal.large_horizontal_pipe": "Large Horizontal Pipe", + "item.cubliminal.vertical_pipe": "Vertical Pipe", + "item.cubliminal.ceiling_pipe": "Ceiling Pipe", "commands.noclip.success.multiple": "Noclipping %s players", "commands.noclip.success.single": "Noclipping %s", "commands.noclip.failed.invalid_range": "The determined value is below the minimum possible ticks", diff --git a/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_1.json b/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_1.json new file mode 100644 index 0000000..38f39c0 --- /dev/null +++ b/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_1.json @@ -0,0 +1,275 @@ +{ + "credit": "Made with Blockbench", + "textures": { + "0": "cubliminal:block/pipes/pipes", + "1": "cubliminal:block/pipes/staff", + "2": "cubliminal:block/pipes/pipe-ring", + "particle": "cubliminal:block/pipes/pipes" + }, + "elements": [ + { + "from": [0, 1, 5], + "to": [16, 2, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 5]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 2, 4], + "to": [16, 4, 7], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 4]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 4, 5], + "to": [16, 5, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 5]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [6, 1.5, 3.5], + "to": [8, 4.5, 7.5], + "rotation": {"angle": 0, "axis": "y", "origin": [6, 1.5, 5.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "from": [0, 4, 10], + "to": [16, 5, 11], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 10]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 2, 9], + "to": [16, 4, 12], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 9]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 1, 10], + "to": [16, 2, 11], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 10]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [12, 1.5, 8.5], + "to": [14, 4.5, 12.5], + "rotation": {"angle": 0, "axis": "y", "origin": [12, 1.5, 10.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "from": [0, 4, 14], + "to": [16, 5, 15], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 14]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 2, 13], + "to": [16, 4, 16], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 13]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 1, 14], + "to": [16, 2, 15], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 14]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [2, 1.5, 12.5], + "to": [4, 4.5, 16.5], + "rotation": {"angle": 0, "axis": "y", "origin": [2, 1.5, 14.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "from": [0, 2, 0], + "to": [16, 4, 3], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 0]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 4, 1], + "to": [16, 5, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 1]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 1, 1], + "to": [16, 2, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 1]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [9, 1.5, -0.5], + "to": [11, 4.5, 3.5], + "rotation": {"angle": 0, "axis": "y", "origin": [9, 1.5, 1.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "name": "Staff", + "from": [2, 0, 0], + "to": [3, 1, 16], + "rotation": {"angle": 0, "axis": "y", "origin": [1, 0, 0]}, + "faces": { + "north": {"uv": [0, 0, 1, 1], "texture": "#1"}, + "east": {"uv": [0, 0, 16, 1], "texture": "#1"}, + "south": {"uv": [0, 0, 1, 1], "texture": "#1"}, + "west": {"uv": [0, 0, 16, 1], "texture": "#1"}, + "up": {"uv": [0, 0, 1, 16], "texture": "#1"}, + "down": {"uv": [0, 0, 1, 16], "texture": "#1"} + } + } + ], + "display": { + "gui": { + "rotation": [26.5, 56, 0], + "translation": [0, 2.25, 0], + "scale": [0.75, 0.75, 0.75] + } + }, + "groups": [ + { + "name": "Pipe", + "origin": [0, 0, 6], + "color": 0, + "nbt": "{}", + "children": [0, 1, 2, 3] + }, + { + "name": "Pipe", + "origin": [0, -2, 10], + "color": 0, + "nbt": "{}", + "children": [4, 5, 6, 7] + }, + { + "name": "Pipe", + "origin": [0, -2, 14], + "color": 0, + "nbt": "{}", + "children": [8, 9, 10, 11] + }, + { + "name": "Pipe", + "origin": [0, -2, 2], + "color": 0, + "nbt": "{}", + "children": [12, 13, 14, 15] + }, + 16 + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_2.json b/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_2.json new file mode 100644 index 0000000..085e321 --- /dev/null +++ b/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_2.json @@ -0,0 +1,335 @@ +{ + "credit": "Made with Blockbench", + "textures": { + "0": "cubliminal:block/pipes/pipes", + "1": "cubliminal:block/pipes/staff", + "2": "cubliminal:block/pipes/pipe-ring", + "particle": "cubliminal:block/pipes/pipes" + }, + "elements": [ + { + "from": [0, 1, 5], + "to": [16, 2, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 5]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 4, 5], + "to": [16, 5, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 5]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 2, 4], + "to": [16, 4, 7], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 4]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [6, 1.5, 3.5], + "to": [8, 4.5, 7.5], + "rotation": {"angle": 0, "axis": "y", "origin": [6, 1.5, 5.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "from": [0, 4, 10], + "to": [16, 5, 11], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 10]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 1, 10], + "to": [16, 2, 11], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 10]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [12, 1.5, 8.5], + "to": [14, 4.5, 12.5], + "rotation": {"angle": 0, "axis": "y", "origin": [12, 1.5, 10.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "from": [0, 2, 9], + "to": [16, 4, 12], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 9]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 4, 14], + "to": [16, 5, 15], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 14]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 1, 14], + "to": [16, 2, 15], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 14]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [2, 1.5, 12.5], + "to": [4, 4.5, 16.5], + "rotation": {"angle": 0, "axis": "y", "origin": [2, 1.5, 14.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "from": [0, 2, 13], + "to": [16, 4, 16], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 13]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 2, 0], + "to": [16, 4, 3], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 0]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 4, 1], + "to": [16, 5, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 1]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 1, 1], + "to": [16, 2, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -2, 1]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [9, 1.5, -0.5], + "to": [11, 4.5, 3.5], + "rotation": {"angle": 0, "axis": "y", "origin": [9, 1.5, 1.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "from": [0, 6, 7], + "to": [16, 7, 8], + "rotation": {"angle": 0, "axis": "y", "origin": [2, 16, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 9, 7], + "to": [16, 10, 8], + "rotation": {"angle": 0, "axis": "y", "origin": [5, 16, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 7, 6], + "to": [16, 9, 9], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 7, 6]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [3, 6.5, 5.5], + "to": [5, 9.5, 9.5], + "rotation": {"angle": 0, "axis": "y", "origin": [3, 6.5, 7.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "name": "Staff", + "from": [2, 0, 0], + "to": [3, 1, 16], + "rotation": {"angle": 0, "axis": "y", "origin": [1, 0, 0]}, + "faces": { + "north": {"uv": [0, 0, 1, 1], "texture": "#1"}, + "east": {"uv": [0, 0, 16, 1], "texture": "#1"}, + "south": {"uv": [0, 0, 1, 1], "texture": "#1"}, + "west": {"uv": [0, 0, 16, 1], "texture": "#1"}, + "up": {"uv": [0, 0, 1, 16], "texture": "#1"}, + "down": {"uv": [0, 0, 1, 16], "texture": "#1"} + } + } + ], + "display": { + "gui": { + "rotation": [26.5, 56, 0], + "translation": [0, 2.25, 0], + "scale": [0.75, 0.75, 0.75] + } + }, + "groups": [ + { + "name": "Pipe", + "origin": [0, 0, 6], + "color": 0, + "nbt": "{}", + "children": [0, 1, 2, 3] + }, + { + "name": "Pipe", + "origin": [0, -2, 10], + "color": 0, + "nbt": "{}", + "children": [4, 5, 6, 7] + }, + { + "name": "Pipe", + "origin": [0, -2, 14], + "color": 0, + "nbt": "{}", + "children": [8, 9, 10, 11] + }, + { + "name": "Pipe", + "origin": [0, -2, 2], + "color": 0, + "nbt": "{}", + "children": [12, 13, 14, 15] + }, + { + "name": "Pipe", + "origin": [0, 0, 6], + "color": 0, + "nbt": "{}", + "children": [16, 17, 18, 19] + }, + 20 + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_3.json b/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_3.json new file mode 100644 index 0000000..3ccfd97 --- /dev/null +++ b/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_3.json @@ -0,0 +1,387 @@ +{ + "credit": "Made with Blockbench", + "textures": { + "0": "cubliminal:block/pipes/pipes", + "1": "cubliminal:block/pipes/staff", + "2": "cubliminal:block/pipes/pipe-ring", + "particle": "cubliminal:block/pipes/pipes" + }, + "elements": [ + { + "from": [0, 1, 5], + "to": [16, 2, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 5]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 2, 4], + "to": [16, 4, 7], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 4]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 4, 5], + "to": [16, 5, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 5]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [6, 1.5, 3.5], + "to": [8, 4.5, 7.5], + "rotation": {"angle": 0, "axis": "y", "origin": [6, 1.5, 5.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "rotation": 180, "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "rotation": 180, "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "rotation": 180, "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "rotation": 180, "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "rotation": 180, "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "rotation": 180, "texture": "#2"} + } + }, + { + "from": [0, 4, 10], + "to": [16, 5, 11], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 10]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 2, 9], + "to": [16, 4, 12], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 9]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 1, 10], + "to": [16, 2, 11], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 10]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [12, 1.5, 8.5], + "to": [14, 4.5, 12.5], + "rotation": {"angle": 0, "axis": "y", "origin": [12, 1.5, 10.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "rotation": 180, "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "rotation": 180, "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "rotation": 180, "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "rotation": 180, "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "rotation": 180, "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "rotation": 180, "texture": "#2"} + } + }, + { + "from": [0, 4, 14], + "to": [16, 5, 15], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 14]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 2, 13], + "to": [16, 4, 16], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 13]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 1, 14], + "to": [16, 2, 15], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 14]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [2, 1.5, 12.5], + "to": [4, 4.5, 16.5], + "rotation": {"angle": 0, "axis": "y", "origin": [2, 1.5, 14.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "rotation": 180, "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "rotation": 180, "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "rotation": 180, "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "rotation": 180, "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "rotation": 180, "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "rotation": 180, "texture": "#2"} + } + }, + { + "from": [0, 2, 0], + "to": [16, 4, 3], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 0]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 4, 1], + "to": [16, 5, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 1]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 1, 1], + "to": [16, 2, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 1]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [9, 1.5, -0.5], + "to": [11, 4.5, 3.5], + "rotation": {"angle": 0, "axis": "y", "origin": [9, 1.5, 1.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "rotation": 180, "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "rotation": 180, "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "rotation": 180, "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "rotation": 180, "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "rotation": 180, "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "rotation": 180, "texture": "#2"} + } + }, + { + "from": [3, 9, 7], + "to": [4, 10, 16], + "rotation": {"angle": 0, "axis": "x", "origin": [4, 10, 15]}, + "faces": { + "north": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 9, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 9, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 1, 9], "texture": "#0"}, + "down": {"uv": [0, 0, 1, 9], "texture": "#0"} + } + }, + { + "from": [2, 7, 6], + "to": [3, 8, 7], + "rotation": {"angle": 0, "axis": "x", "origin": [2, 8, 15]}, + "faces": { + "north": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 1, 1], "texture": "#0"} + } + }, + { + "from": [3, 9, 7], + "to": [16, 10, 8], + "rotation": {"angle": 0, "axis": "x", "origin": [2, 10, 17]}, + "faces": { + "north": {"uv": [0, 0, 13, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 13, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 13, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 13, 1], "texture": "#0"} + } + }, + { + "from": [2, 7, 7], + "to": [5, 9, 16], + "rotation": {"angle": 0, "axis": "z", "origin": [5, 9, 14]}, + "faces": { + "north": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 9, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 9, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 3, 9], "texture": "#0"}, + "down": {"uv": [0, 0, 3, 9], "texture": "#0"} + } + }, + { + "from": [3, 7, 6], + "to": [16, 9, 9], + "rotation": {"angle": 0, "axis": "x", "origin": [2, 7, 6]}, + "faces": { + "north": {"uv": [0, 0, 13, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 13, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 13, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 13, 3], "texture": "#0"} + } + }, + { + "from": [3, 6, 8], + "to": [4, 7, 16], + "rotation": {"angle": 0, "axis": "x", "origin": [4, 7, 15]}, + "faces": { + "north": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 8, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 8, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 1, 8], "texture": "#0"}, + "down": {"uv": [0, 0, 1, 8], "texture": "#0"} + } + }, + { + "from": [5, 6, 7], + "to": [16, 7, 8], + "rotation": {"angle": 0, "axis": "x", "origin": [5, 7, 14]}, + "faces": { + "north": {"uv": [0, 0, 11, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 11, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 11, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 11, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [1.5, 6.5, 11.5], + "to": [5.5, 9.5, 13.5], + "rotation": {"angle": 0, "axis": "x", "origin": [2, 7.5, 13.5]}, + "faces": { + "north": {"uv": [0, 0, 4, 3], "rotation": 180, "texture": "#2"}, + "east": {"uv": [0, 0, 2, 3], "rotation": 180, "texture": "#2"}, + "south": {"uv": [0, 0, 4, 3], "rotation": 180, "texture": "#2"}, + "west": {"uv": [0, 0, 2, 3], "rotation": 180, "texture": "#2"}, + "up": {"uv": [0, 0, 4, 2], "rotation": 180, "texture": "#2"}, + "down": {"uv": [0, 0, 4, 2], "rotation": 180, "texture": "#2"} + } + }, + { + "name": "Staff", + "from": [2, 0, 0], + "to": [3, 1, 16], + "rotation": {"angle": 0, "axis": "y", "origin": [1, 0, 0]}, + "faces": { + "north": {"uv": [0, 0, 1, 1], "texture": "#1"}, + "east": {"uv": [0, 0, 16, 1], "texture": "#1"}, + "south": {"uv": [0, 0, 1, 1], "texture": "#1"}, + "west": {"uv": [0, 0, 16, 1], "texture": "#1"}, + "up": {"uv": [0, 0, 1, 16], "texture": "#1"}, + "down": {"uv": [0, 0, 1, 16], "texture": "#1"} + } + } + ], + "display": { + "gui": { + "rotation": [26.5, 56, 0], + "translation": [0, 2.25, 0], + "scale": [0.75, 0.75, 0.75] + } + }, + "groups": [ + { + "name": "Pipe", + "origin": [0, 0, 6], + "color": 0, + "nbt": "{}", + "children": [0, 1, 2, 3] + }, + { + "name": "Pipe", + "origin": [0, -2, 10], + "color": 0, + "nbt": "{}", + "children": [4, 5, 6, 7] + }, + { + "name": "Pipe", + "origin": [0, -2, 14], + "color": 0, + "nbt": "{}", + "children": [8, 9, 10, 11] + }, + { + "name": "Pipe", + "origin": [0, -2, 2], + "color": 0, + "nbt": "{}", + "children": [12, 13, 14, 15] + }, + { + "name": "Pipe", + "origin": [0, 0, 6], + "color": 0, + "nbt": "{}", + "children": [16, 17, 18, 19, 20, 21, 22, 23] + }, + 24 + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_4.json b/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_4.json new file mode 100644 index 0000000..fce1bcd --- /dev/null +++ b/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_4.json @@ -0,0 +1,387 @@ +{ + "credit": "Made with Blockbench", + "textures": { + "0": "cubliminal:block/pipes/pipes", + "1": "cubliminal:block/pipes/staff", + "2": "cubliminal:block/pipes/pipe-ring", + "particle": "cubliminal:block/pipes/pipes" + }, + "elements": [ + { + "from": [0, 1, 5], + "to": [16, 2, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 5]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 2, 4], + "to": [16, 4, 7], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 4]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 4, 5], + "to": [16, 5, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 5]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [6, 1.5, 3.5], + "to": [8, 4.5, 7.5], + "rotation": {"angle": 0, "axis": "y", "origin": [6, 1.5, 5.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "from": [0, 4, 10], + "to": [16, 5, 11], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 10]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 2, 9], + "to": [16, 4, 12], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 9]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 1, 10], + "to": [16, 2, 11], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 10]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [12, 1.5, 8.5], + "to": [14, 4.5, 12.5], + "rotation": {"angle": 0, "axis": "y", "origin": [12, 1.5, 10.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "from": [0, 4, 14], + "to": [16, 5, 15], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 14]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 2, 13], + "to": [16, 4, 16], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 13]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 1, 14], + "to": [16, 2, 15], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 14]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [2, 1.5, 12.5], + "to": [4, 4.5, 16.5], + "rotation": {"angle": 0, "axis": "y", "origin": [2, 1.5, 14.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "from": [0, 2, 0], + "to": [16, 4, 3], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 0]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 4, 1], + "to": [16, 5, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 1]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 1, 1], + "to": [16, 2, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 1]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [9, 1.5, -0.5], + "to": [11, 4.5, 3.5], + "rotation": {"angle": 0, "axis": "y", "origin": [9, 1.5, 1.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "from": [1, 8, 7], + "to": [2, 16, 8], + "rotation": {"angle": 0, "axis": "y", "origin": [2, 16, 7]}, + "faces": { + "north": {"uv": [0, 0, 1, 8], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 8], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 8], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 8], "texture": "#0"}, + "up": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 1, 1], "texture": "#0"} + } + }, + { + "from": [2, 7, 7], + "to": [3, 8, 8], + "rotation": {"angle": 0, "axis": "y", "origin": [2, 16, 7]}, + "faces": { + "north": {"uv": [0, 0, 1, 1], "texture": "#missing"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#missing"}, + "south": {"uv": [0, 0, 1, 1], "texture": "#missing"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#missing"}, + "up": {"uv": [0, 0, 1, 1], "texture": "#missing"}, + "down": {"uv": [0, 0, 1, 1], "texture": "#missing"} + } + }, + { + "from": [3, 6, 7], + "to": [16, 7, 8], + "rotation": {"angle": 0, "axis": "y", "origin": [2, 16, 7]}, + "faces": { + "north": {"uv": [0, 0, 13, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 13, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 13, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 13, 1], "texture": "#0"} + } + }, + { + "from": [2, 8, 6], + "to": [4, 16, 9], + "rotation": {"angle": 0, "axis": "y", "origin": [2, 16, 6]}, + "faces": { + "north": {"uv": [0, 0, 2, 8], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 8], "texture": "#0"}, + "south": {"uv": [0, 0, 2, 8], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 8], "texture": "#0"}, + "up": {"uv": [0, 0, 2, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 2, 3], "texture": "#0"} + } + }, + { + "from": [3, 7, 6], + "to": [16, 9, 9], + "rotation": {"angle": 0, "axis": "y", "origin": [2, 7, 6]}, + "faces": { + "north": {"uv": [0, 0, 13, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 13, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 13, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 13, 3], "texture": "#0"} + } + }, + { + "from": [4, 9, 7], + "to": [5, 16, 8], + "rotation": {"angle": 0, "axis": "y", "origin": [5, 16, 7]}, + "faces": { + "north": {"uv": [0, 0, 1, 7], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 7], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 7], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 7], "texture": "#0"}, + "up": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 1, 1], "texture": "#0"} + } + }, + { + "from": [5, 9, 7], + "to": [16, 10, 8], + "rotation": {"angle": 0, "axis": "y", "origin": [5, 16, 7]}, + "faces": { + "north": {"uv": [0, 0, 11, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 11, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 11, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 11, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [1.5, 12, 5.5], + "to": [4.5, 14, 9.5], + "rotation": {"angle": 0, "axis": "y", "origin": [1.5, 14, 7.5]}, + "faces": { + "north": {"uv": [0, 0, 3, 2], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 2], "texture": "#2"}, + "south": {"uv": [0, 0, 3, 2], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 2], "texture": "#2"}, + "up": {"uv": [0, 0, 3, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 3, 4], "texture": "#2"} + } + }, + { + "name": "Staff", + "from": [2, 0, 0], + "to": [3, 1, 16], + "rotation": {"angle": 0, "axis": "y", "origin": [1, 0, 0]}, + "faces": { + "north": {"uv": [0, 0, 1, 1], "texture": "#1"}, + "east": {"uv": [0, 0, 16, 1], "texture": "#1"}, + "south": {"uv": [0, 0, 1, 1], "texture": "#1"}, + "west": {"uv": [0, 0, 16, 1], "texture": "#1"}, + "up": {"uv": [0, 0, 1, 16], "texture": "#1"}, + "down": {"uv": [0, 0, 1, 16], "texture": "#1"} + } + } + ], + "display": { + "gui": { + "rotation": [26.5, 56, 0], + "translation": [0, 2.25, 0], + "scale": [0.75, 0.75, 0.75] + } + }, + "groups": [ + { + "name": "Pipe", + "origin": [0, 0, 6], + "color": 0, + "nbt": "{}", + "children": [0, 1, 2, 3] + }, + { + "name": "Pipe", + "origin": [0, -2, 10], + "color": 0, + "nbt": "{}", + "children": [4, 5, 6, 7] + }, + { + "name": "Pipe", + "origin": [0, -2, 14], + "color": 0, + "nbt": "{}", + "children": [8, 9, 10, 11] + }, + { + "name": "Pipe", + "origin": [0, -2, 2], + "color": 0, + "nbt": "{}", + "children": [12, 13, 14, 15] + }, + { + "name": "Pipe", + "origin": [0, 0, 6], + "color": 0, + "nbt": "{}", + "children": [16, 17, 18, 19, 20, 21, 22, 23] + }, + 24 + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_5.json b/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_5.json new file mode 100644 index 0000000..287d47b --- /dev/null +++ b/src/main/resources/assets/cubliminal/models/block/pipes/ceiling_pipe_5.json @@ -0,0 +1,457 @@ +{ + "credit": "Made with Blockbench", + "textures": { + "0": "cubliminal:block/pipes/pipes", + "1": "cubliminal:block/pipes/staff", + "2": "cubliminal:block/pipes/pipe-ring", + "particle": "cubliminal:block/pipes/pipes" + }, + "elements": [ + { + "from": [0, 1, 5], + "to": [16, 2, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 5]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 2, 4], + "to": [16, 4, 7], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 4]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 4, 5], + "to": [16, 5, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 5]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [6, 1.5, 3.5], + "to": [8, 4.5, 7.5], + "rotation": {"angle": 0, "axis": "y", "origin": [6, 1.5, 5.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "from": [0, 4, 10], + "to": [16, 5, 11], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 10]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 2, 9], + "to": [16, 4, 12], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 9]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 1, 10], + "to": [16, 2, 11], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 10]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [12, 1.5, 8.5], + "to": [14, 4.5, 12.5], + "rotation": {"angle": 0, "axis": "y", "origin": [12, 1.5, 10.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "from": [0, 4, 14], + "to": [16, 5, 15], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 14]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "from": [0, 2, 13], + "to": [16, 4, 16], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 13]}, + "faces": { + "north": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 3], "texture": "#0"} + } + }, + { + "from": [0, 1, 14], + "to": [16, 2, 15], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 14]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#0"} + } + }, + { + "name": "Ring", + "from": [2, 1.5, 12.5], + "to": [4, 4.5, 16.5], + "rotation": {"angle": 0, "axis": "y", "origin": [2, 1.5, 14.5]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 3], "texture": "#2"}, + "up": {"uv": [0, 0, 2, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 2, 4], "texture": "#2"} + } + }, + { + "from": [13, 2, 0], + "to": [16, 4, 3], + "rotation": {"angle": 0, "axis": "y", "origin": [13, 2, 0]}, + "faces": { + "north": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 3, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 3, 3], "texture": "#0"} + } + }, + { + "from": [13, 1, 0], + "to": [14, 2, 1], + "rotation": {"angle": 0, "axis": "y", "origin": [13, -1, 1]}, + "faces": { + "north": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 1, 1], "rotation": 270, "texture": "#0"}, + "down": {"uv": [0, 0, 1, 1], "rotation": 90, "texture": "#0"} + } + }, + { + "from": [13, 4, 0], + "to": [14, 5, 1], + "rotation": {"angle": 0, "axis": "y", "origin": [13, 1, 1]}, + "faces": { + "north": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 1, 1], "rotation": 270, "texture": "#0"}, + "down": {"uv": [0, 0, 1, 1], "rotation": 90, "texture": "#0"} + } + }, + { + "from": [12, 2, 0], + "to": [13, 4, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [10, 2, 1]}, + "faces": { + "north": {"uv": [0, 0, 1, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 2, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 2, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 2, 1], "rotation": 270, "texture": "#0"}, + "down": {"uv": [0, 0, 2, 1], "rotation": 90, "texture": "#0"} + } + }, + { + "from": [14, 4, 1], + "to": [16, 5, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [13, 1, 1]}, + "faces": { + "north": {"uv": [0, 0, 2, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 2, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 2, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 2, 1], "texture": "#0"} + } + }, + { + "from": [14, 1, 1], + "to": [16, 2, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [13, -1, 1]}, + "faces": { + "north": {"uv": [0, 0, 2, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 2, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 2, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 2, 1], "texture": "#0"} + } + }, + { + "from": [0, 2, 0], + "to": [3, 4, 3], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 0]}, + "faces": { + "north": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 3, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 3, 3], "texture": "#0"}, + "down": {"uv": [0, 0, 3, 3], "texture": "#0"} + } + }, + { + "from": [2, 1, 0], + "to": [3, 2, 1], + "rotation": {"angle": 0, "axis": "y", "origin": [2, -1, 1]}, + "faces": { + "north": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 1, 1], "rotation": 270, "texture": "#0"}, + "down": {"uv": [0, 0, 1, 1], "rotation": 90, "texture": "#0"} + } + }, + { + "from": [2, 4, 0], + "to": [3, 5, 1], + "rotation": {"angle": 0, "axis": "y", "origin": [2, 1, 1]}, + "faces": { + "north": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 1, 1], "rotation": 270, "texture": "#0"}, + "down": {"uv": [0, 0, 1, 1], "rotation": 90, "texture": "#0"} + } + }, + { + "from": [3, 2, 0], + "to": [4, 4, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [1, 2, 1]}, + "faces": { + "north": {"uv": [0, 0, 1, 2], "texture": "#0"}, + "east": {"uv": [0, 0, 2, 2], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 2], "texture": "#0"}, + "west": {"uv": [0, 0, 2, 2], "texture": "#0"}, + "up": {"uv": [0, 0, 2, 1], "rotation": 270, "texture": "#0"}, + "down": {"uv": [0, 0, 2, 1], "rotation": 90, "texture": "#0"} + } + }, + { + "from": [0, 4, 1], + "to": [2, 5, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 1, 1]}, + "faces": { + "north": {"uv": [0, 0, 3, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 3, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 3, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 3, 1], "texture": "#0"} + } + }, + { + "from": [0, 1, 1], + "to": [2, 2, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [0, -1, 1]}, + "faces": { + "north": {"uv": [0, 0, 3, 1], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "south": {"uv": [0, 0, 3, 1], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 1], "texture": "#0"}, + "up": {"uv": [0, 0, 3, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 3, 1], "texture": "#0"} + } + }, + { + "name": "Staff", + "from": [2, 0, 0], + "to": [3, 1, 16], + "rotation": {"angle": 0, "axis": "y", "origin": [1, 0, 0]}, + "faces": { + "north": {"uv": [0, 0, 1, 1], "texture": "#1"}, + "east": {"uv": [0, 0, 16, 1], "texture": "#1"}, + "south": {"uv": [0, 0, 1, 1], "texture": "#1"}, + "west": {"uv": [0, 0, 16, 1], "texture": "#1"}, + "up": {"uv": [0, 0, 1, 16], "texture": "#1"}, + "down": {"uv": [0, 0, 1, 16], "texture": "#1"} + } + }, + { + "from": [7, 0, 0], + "to": [9, 16, 1], + "rotation": {"angle": 0, "axis": "y", "origin": [-2, 0, -2]}, + "faces": { + "north": {"uv": [12, 0, 14, 16], "texture": "#0"}, + "east": {"uv": [9, 0, 10, 16], "texture": "#0"}, + "south": {"uv": [9, 0, 11, 16], "texture": "#0"}, + "west": {"uv": [9, 0, 10, 16], "texture": "#0"}, + "up": {"uv": [9, 0, 11, 1], "texture": "#0"}, + "down": {"uv": [9, 0, 11, 1], "texture": "#0"} + } + }, + { + "from": [6, 0, 1], + "to": [10, 16, 5], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 0, 1]}, + "faces": { + "north": {"uv": [9, 0, 13, 16], "texture": "#0"}, + "east": {"uv": [9, 0, 13, 16], "texture": "#0"}, + "south": {"uv": [9, 0, 13, 16], "texture": "#0"}, + "west": {"uv": [9, 0, 13, 16], "texture": "#0"}, + "up": {"uv": [9, 0, 13, 4], "texture": "#0"}, + "down": {"uv": [9, 0, 13, 4], "texture": "#0"} + } + }, + { + "from": [10, 0, 2], + "to": [11, 16, 4], + "rotation": {"angle": 0, "axis": "y", "origin": [1, 0, 1]}, + "faces": { + "north": {"uv": [9, 0, 10, 16], "texture": "#0"}, + "east": {"uv": [9, 0, 11, 16], "texture": "#0"}, + "south": {"uv": [9, 0, 10, 16], "texture": "#0"}, + "west": {"uv": [9, 0, 11, 16], "texture": "#0"}, + "up": {"uv": [9, 0, 10, 2], "texture": "#0"}, + "down": {"uv": [9, 0, 10, 2], "texture": "#0"} + } + }, + { + "from": [7, 0, 5], + "to": [9, 16, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [-2, 0, 3]}, + "faces": { + "north": {"uv": [9, 0, 11, 16], "texture": "#0"}, + "east": {"uv": [9, 0, 10, 16], "texture": "#0"}, + "south": {"uv": [9, 0, 11, 16], "texture": "#0"}, + "west": {"uv": [9, 0, 10, 16], "texture": "#0"}, + "up": {"uv": [9, 0, 11, 1], "texture": "#0"}, + "down": {"uv": [9, 0, 11, 1], "texture": "#0"} + } + }, + { + "from": [5, 0, 2], + "to": [6, 16, 4], + "rotation": {"angle": 0, "axis": "y", "origin": [-4, 0, 1]}, + "faces": { + "north": {"uv": [9, 0, 10, 16], "texture": "#0"}, + "east": {"uv": [9, 0, 11, 16], "texture": "#0"}, + "south": {"uv": [9, 0, 10, 16], "texture": "#0"}, + "west": {"uv": [9, 0, 11, 16], "texture": "#0"}, + "up": {"uv": [9, 0, 10, 2], "texture": "#0"}, + "down": {"uv": [9, 0, 10, 2], "texture": "#0"} + } + } + ], + "display": { + "gui": { + "rotation": [26.5, 56, 0], + "translation": [0, 2.25, 0], + "scale": [0.75, 0.75, 0.75] + } + }, + "groups": [ + { + "name": "Pipe", + "origin": [0, 0, 6], + "color": 0, + "nbt": "{}", + "children": [0, 1, 2, 3] + }, + { + "name": "Pipe", + "origin": [0, -2, 10], + "color": 0, + "nbt": "{}", + "children": [4, 5, 6, 7] + }, + { + "name": "Pipe", + "origin": [0, -2, 14], + "color": 0, + "nbt": "{}", + "children": [8, 9, 10, 11] + }, + { + "name": "Pipe", + "origin": [0, -2, 2], + "color": 0, + "nbt": "{}", + "children": [12, 13, 14, 15, 16, 17] + }, + { + "name": "Pipe", + "origin": [0, -2, 2], + "color": 0, + "nbt": "{}", + "children": [18, 19, 20, 21, 22, 23] + }, + 24, + { + "name": "VerticalPipe", + "origin": [8, 8, 8], + "color": 0, + "nbt": "{}", + "children": [25, 26, 27, 28, 29] + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/models/block/pipes/large_pipe_1.json b/src/main/resources/assets/cubliminal/models/block/pipes/large_pipe_1.json new file mode 100644 index 0000000..5c0ff74 --- /dev/null +++ b/src/main/resources/assets/cubliminal/models/block/pipes/large_pipe_1.json @@ -0,0 +1,215 @@ +{ + "credit": "Made with Blockbench", + "textures": { + "1": "cubliminal:block/pipes/pipe-ring", + "2": "cubliminal:block/pipes/pipes", + "particle": "cubliminal:block/pipes/pipes" + }, + "elements": [ + { + "from": [0, 4, 3], + "to": [16, 12, 13], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 0, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 8], "texture": "#2"}, + "east": {"uv": [0, 0, 10, 8], "texture": "#2"}, + "south": {"uv": [0, 0, 16, 8], "texture": "#2"}, + "west": {"uv": [0, 0, 10, 8], "texture": "#2"}, + "up": {"uv": [0, 0, 16, 10], "texture": "#2"}, + "down": {"uv": [0, 0, 16, 10], "texture": "#2"} + } + }, + { + "from": [0, 6, 2], + "to": [16, 10, 3], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 0, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 4], "texture": "#2"}, + "east": {"uv": [0, 0, 1, 4], "texture": "#2"}, + "south": {"uv": [0, 0, 16, 4], "texture": "#2"}, + "west": {"uv": [0, 0, 1, 4], "texture": "#2"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#2"} + } + }, + { + "from": [0, 6, 13], + "to": [16, 10, 14], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 0, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 4], "texture": "#2"}, + "east": {"uv": [0, 0, 1, 4], "texture": "#2"}, + "south": {"uv": [0, 0, 16, 4], "texture": "#2"}, + "west": {"uv": [0, 0, 1, 4], "texture": "#2"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#2"} + } + }, + { + "from": [0, 3, 4], + "to": [16, 4, 12], + "rotation": {"angle": 0, "axis": "y", "origin": [7, -2, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 8, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 8, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 16, 8], "texture": "#2"}, + "down": {"uv": [0, 0, 16, 8], "texture": "#2"} + } + }, + { + "from": [0, 12, 4], + "to": [16, 13, 12], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 8, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 8, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 8, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 16, 8], "texture": "#2"}, + "down": {"uv": [0, 0, 16, 8], "texture": "#2"} + } + }, + { + "from": [0, 13, 6], + "to": [16, 14, 10], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 8, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 16, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 16, 4], "texture": "#2"} + } + }, + { + "from": [0, 2, 6], + "to": [16, 3, 10], + "rotation": {"angle": 0, "axis": "y", "origin": [7, -2, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 16, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 16, 4], "texture": "#2"} + } + }, + { + "from": [7, 6, 1], + "to": [9, 10, 5], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 5, 1]}, + "faces": { + "north": {"uv": [0, 0, 2, 4], "texture": "#1"}, + "east": {"uv": [0, 0, 1, 4], "texture": "#1"}, + "south": {"uv": [0, 0, 2, 4], "texture": "#1"}, + "west": {"uv": [0, 0, 1, 4], "texture": "#1"}, + "up": {"uv": [0, 0, 2, 1], "texture": "#1"}, + "down": {"uv": [0, 0, 2, 1], "texture": "#1"} + } + }, + { + "from": [7, 3, 2], + "to": [9, 6, 7], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 5, 1]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#1"}, + "east": {"uv": [0, 0, 2, 3], "texture": "#1"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#1"}, + "west": {"uv": [0, 0, 2, 3], "texture": "#1"}, + "up": {"uv": [0, 0, 2, 2], "texture": "#1"}, + "down": {"uv": [0, 0, 2, 2], "texture": "#1"} + } + }, + { + "from": [7, 14, 4], + "to": [9, 15, 16], + "rotation": {"angle": 0, "axis": "z", "origin": [7, 18, 1]}, + "faces": { + "north": {"uv": [0, 0, 2, 1], "texture": "#1"}, + "east": {"uv": [0, 0, 9, 1], "texture": "#1"}, + "south": {"uv": [0, 0, 2, 1], "texture": "#1"}, + "west": {"uv": [0, 0, 9, 1], "texture": "#1"}, + "up": {"uv": [0, 0, 2, 9], "texture": "#1"}, + "down": {"uv": [0, 0, 2, 9], "texture": "#1"} + } + }, + { + "from": [7, 13, 3], + "to": [9, 14, 9], + "rotation": {"angle": 0, "axis": "z", "origin": [7, 18, 1]}, + "faces": { + "north": {"uv": [0, 0, 2, 1], "texture": "#1"}, + "east": {"uv": [0, 0, 3, 1], "texture": "#1"}, + "south": {"uv": [0, 0, 2, 1], "texture": "#1"}, + "west": {"uv": [0, 0, 3, 1], "texture": "#1"}, + "up": {"uv": [0, 0, 2, 3], "texture": "#1"}, + "down": {"uv": [0, 0, 2, 3], "texture": "#1"} + } + }, + { + "from": [7, 10, 2], + "to": [9, 13, 7], + "rotation": {"angle": 0, "axis": "z", "origin": [7, 18, 1]}, + "faces": { + "north": {"uv": [0, 0, 2, 3], "texture": "#1"}, + "east": {"uv": [0, 0, 2, 3], "texture": "#1"}, + "south": {"uv": [0, 0, 2, 3], "texture": "#1"}, + "west": {"uv": [0, 0, 2, 3], "texture": "#1"}, + "up": {"uv": [0, 0, 2, 2], "texture": "#1"}, + "down": {"uv": [0, 0, 2, 2], "texture": "#1"} + } + }, + { + "from": [7, 2, 3], + "to": [9, 3, 9], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 5, 1]}, + "faces": { + "north": {"uv": [0, 0, 2, 1], "texture": "#1"}, + "east": {"uv": [0, 0, 3, 1], "texture": "#1"}, + "south": {"uv": [0, 0, 2, 1], "texture": "#1"}, + "west": {"uv": [0, 0, 3, 1], "texture": "#1"}, + "up": {"uv": [0, 0, 2, 3], "texture": "#1"}, + "down": {"uv": [0, 0, 2, 3], "texture": "#1"} + } + }, + { + "from": [7, 1, 4], + "to": [9, 2, 16], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 5, 1]}, + "faces": { + "north": {"uv": [0, 0, 2, 1], "texture": "#1"}, + "east": {"uv": [0, 0, 9, 1], "texture": "#1"}, + "south": {"uv": [0, 0, 2, 1], "texture": "#1"}, + "west": {"uv": [0, 0, 9, 1], "texture": "#1"}, + "up": {"uv": [0, 0, 2, 9], "texture": "#1"}, + "down": {"uv": [0, 0, 2, 9], "texture": "#1"} + } + } + ], + "display": { + "gui": { + "rotation": [22.6, 131, 0], + "translation": [-1.5, 0, 0], + "scale": [0.75, 0.75, 0.75] + } + }, + "groups": [ + { + "name": "Pipe", + "origin": [8, 8, 8], + "color": 0, + "nbt": "{}", + "children": [0, 1, 2, 3, 4, 5, 6] + }, + { + "name": "Ring", + "origin": [8, 8, 8], + "color": 0, + "nbt": "{}", + "children": [7, 8, 9, 10, 11, 12, 13] + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/models/block/pipes/large_pipe_2.json b/src/main/resources/assets/cubliminal/models/block/pipes/large_pipe_2.json new file mode 100644 index 0000000..302721b --- /dev/null +++ b/src/main/resources/assets/cubliminal/models/block/pipes/large_pipe_2.json @@ -0,0 +1,124 @@ +{ + "format_version": "1.21.6", + "credit": "Made with Blockbench", + "textures": { + "2": "cubliminal:block/pipes/pipes", + "particle": "cubliminal:block/pipes/pipes" + }, + "elements": [ + { + "from": [0, 4, 3], + "to": [16, 12, 13], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 0, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 8], "texture": "#2"}, + "east": {"uv": [0, 0, 10, 8], "texture": "#2"}, + "south": {"uv": [0, 0, 16, 8], "texture": "#2"}, + "west": {"uv": [0, 0, 10, 8], "texture": "#2"}, + "up": {"uv": [0, 0, 16, 10], "texture": "#2"}, + "down": {"uv": [0, 0, 16, 10], "texture": "#2"} + } + }, + { + "from": [0, 6, 13], + "to": [16, 10, 14], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 0, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 4], "texture": "#2"}, + "east": {"uv": [0, 0, 1, 4], "texture": "#2"}, + "south": {"uv": [0, 0, 16, 4], "texture": "#2"}, + "west": {"uv": [0, 0, 1, 4], "texture": "#2"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#2"} + } + }, + { + "from": [0, 6, 2], + "to": [16, 10, 3], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 0, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 4], "texture": "#2"}, + "east": {"uv": [0, 0, 1, 4], "texture": "#2"}, + "south": {"uv": [0, 0, 16, 8], "texture": "#2"}, + "west": {"uv": [0, 0, 1, 4], "texture": "#2"}, + "up": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "down": {"uv": [0, 0, 16, 1], "texture": "#2"} + } + }, + { + "from": [0, 3, 4], + "to": [16, 4, 12], + "rotation": {"angle": 0, "axis": "y", "origin": [7, -2, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 8, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 8, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 16, 8], "texture": "#2"}, + "down": {"uv": [0, 0, 16, 8], "texture": "#2"} + } + }, + { + "from": [0, 12, 4], + "to": [16, 13, 12], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 8, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 8, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 8, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 16, 8], "texture": "#2"}, + "down": {"uv": [0, 0, 16, 8], "texture": "#2"} + } + }, + { + "from": [0, 13, 6], + "to": [16, 14, 10], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 8, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 16, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 16, 4], "texture": "#2"} + } + }, + { + "from": [0, 2, 6], + "to": [16, 3, 10], + "rotation": {"angle": 0, "axis": "y", "origin": [7, -2, 7]}, + "faces": { + "north": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 16, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 16, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 16, 4], "texture": "#2"} + } + } + ], + "display": { + "thirdperson_righthand": { + "translation": [-6.25, 4.5, 0] + }, + "thirdperson_lefthand": { + "translation": [-6.25, 4.5, 0] + }, + "firstperson_righthand": { + "translation": [-9, 0, 0] + }, + "gui": { + "rotation": [22.6, 131, 0], + "scale": [0.75, 0.75, 0.75] + } + }, + "groups": [ + { + "name": "Pipe", + "origin": [8, 8, 8], + "color": 0, + "children": [0, 1, 2, 3, 4, 5, 6] + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/models/block/pipes/large_pipe_3.json b/src/main/resources/assets/cubliminal/models/block/pipes/large_pipe_3.json new file mode 100644 index 0000000..22edcaa --- /dev/null +++ b/src/main/resources/assets/cubliminal/models/block/pipes/large_pipe_3.json @@ -0,0 +1,253 @@ +{ + "credit": "Made with Blockbench", + "textures": { + "2": "cubliminal:block/pipes/pipes", + "particle": "cubliminal:block/pipes/pipe-ring" + }, + "elements": [ + { + "from": [6, 13, 0], + "to": [10, 14, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 8, 7]}, + "faces": { + "north": {"uv": [0, 0, 1, 4], "rotation": 270, "texture": "#2"}, + "east": {"uv": [0, 0, 1, 6], "rotation": 270, "texture": "#2"}, + "south": {"uv": [0, 0, 1, 4], "rotation": 270, "texture": "#2"}, + "west": {"uv": [0, 0, 1, 6], "rotation": 270, "texture": "#2"}, + "up": {"uv": [0, 0, 6, 4], "rotation": 270, "texture": "#2"}, + "down": {"uv": [0, 0, 6, 4], "rotation": 270, "texture": "#2"} + } + }, + { + "from": [4, 12, 0], + "to": [12, 13, 4], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 8, 7]}, + "faces": { + "north": {"uv": [0, 0, 1, 8], "rotation": 270, "texture": "#2"}, + "east": {"uv": [0, 0, 1, 4], "rotation": 270, "texture": "#2"}, + "south": {"uv": [0, 0, 1, 8], "rotation": 270, "texture": "#2"}, + "west": {"uv": [0, 0, 1, 4], "rotation": 270, "texture": "#2"}, + "up": {"uv": [0, 0, 4, 8], "rotation": 270, "texture": "#2"}, + "down": {"uv": [0, 0, 4, 8], "rotation": 270, "texture": "#2"} + } + }, + { + "from": [3, 4, 0], + "to": [13, 12, 3], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 0, 7]}, + "faces": { + "north": {"uv": [0, 0, 8, 10], "rotation": 270, "texture": "#2"}, + "east": {"uv": [0, 0, 8, 3], "rotation": 270, "texture": "#2"}, + "south": {"uv": [0, 0, 8, 10], "rotation": 270, "texture": "#2"}, + "west": {"uv": [0, 0, 8, 3], "rotation": 270, "texture": "#2"}, + "up": {"uv": [0, 0, 3, 10], "rotation": 270, "texture": "#2"}, + "down": {"uv": [0, 0, 3, 10], "rotation": 270, "texture": "#2"} + } + }, + { + "from": [2, 6, 0], + "to": [3, 10, 14], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 0, 7]}, + "faces": { + "north": {"uv": [0, 0, 4, 1], "rotation": 270, "texture": "#2"}, + "east": {"uv": [0, 0, 4, 14], "rotation": 270, "texture": "#2"}, + "south": {"uv": [0, 0, 4, 1], "rotation": 270, "texture": "#2"}, + "west": {"uv": [0, 0, 4, 14], "rotation": 270, "texture": "#2"}, + "up": {"uv": [0, 0, 14, 1], "rotation": 270, "texture": "#2"}, + "down": {"uv": [0, 0, 14, 1], "rotation": 270, "texture": "#2"} + } + }, + { + "from": [13, 6, 0], + "to": [14, 10, 2], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 0, 7]}, + "faces": { + "north": {"uv": [0, 0, 4, 1], "rotation": 270, "texture": "#2"}, + "east": {"uv": [0, 0, 4, 2], "rotation": 270, "texture": "#2"}, + "south": {"uv": [0, 0, 4, 1], "rotation": 270, "texture": "#2"}, + "west": {"uv": [0, 0, 4, 2], "rotation": 270, "texture": "#2"}, + "up": {"uv": [0, 0, 2, 1], "rotation": 270, "texture": "#2"}, + "down": {"uv": [0, 0, 2, 1], "rotation": 270, "texture": "#2"} + } + }, + { + "from": [6, 2, 0], + "to": [10, 3, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [7, -2, 7]}, + "faces": { + "north": {"uv": [0, 0, 1, 4], "rotation": 270, "texture": "#2"}, + "east": {"uv": [0, 0, 1, 6], "rotation": 270, "texture": "#2"}, + "south": {"uv": [0, 0, 1, 4], "rotation": 270, "texture": "#2"}, + "west": {"uv": [0, 0, 1, 6], "rotation": 270, "texture": "#2"}, + "up": {"uv": [0, 0, 6, 4], "rotation": 270, "texture": "#2"}, + "down": {"uv": [0, 0, 6, 4], "rotation": 270, "texture": "#2"} + } + }, + { + "from": [4, 3, 0], + "to": [12, 4, 9], + "rotation": {"angle": 0, "axis": "y", "origin": [7, -2, 7]}, + "faces": { + "north": {"uv": [0, 0, 1, 8], "rotation": 270, "texture": "#2"}, + "east": {"uv": [0, 0, 1, 9], "rotation": 270, "texture": "#2"}, + "south": {"uv": [0, 0, 1, 8], "rotation": 270, "texture": "#2"}, + "west": {"uv": [0, 0, 1, 9], "rotation": 270, "texture": "#2"}, + "up": {"uv": [0, 0, 9, 8], "rotation": 270, "texture": "#2"}, + "down": {"uv": [0, 0, 9, 8], "rotation": 270, "texture": "#2"} + } + }, + { + "from": [3, 4, 3], + "to": [16, 12, 13], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 0, 7]}, + "faces": { + "north": {"uv": [0, 0, 13, 8], "texture": "#2"}, + "east": {"uv": [0, 0, 10, 8], "texture": "#2"}, + "south": {"uv": [0, 0, 13, 8], "texture": "#2"}, + "west": {"uv": [0, 0, 10, 8], "texture": "#2"}, + "up": {"uv": [0, 0, 13, 10], "texture": "#2"}, + "down": {"uv": [0, 0, 13, 10], "texture": "#2"} + } + }, + { + "from": [3, 6, 13], + "to": [16, 10, 14], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 0, 7]}, + "faces": { + "north": {"uv": [0, 0, 13, 4], "texture": "#2"}, + "east": {"uv": [0, 0, 1, 4], "texture": "#2"}, + "south": {"uv": [0, 0, 13, 4], "texture": "#2"}, + "west": {"uv": [0, 0, 1, 4], "texture": "#2"}, + "up": {"uv": [0, 0, 13, 1], "texture": "#2"}, + "down": {"uv": [0, 0, 13, 1], "texture": "#2"} + } + }, + { + "from": [11, 6, 2], + "to": [16, 10, 3], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 0, 7]}, + "faces": { + "north": {"uv": [0, 0, 5, 4], "texture": "#2"}, + "east": {"uv": [0, 0, 1, 4], "texture": "#2"}, + "south": {"uv": [0, 0, 5, 4], "texture": "#2"}, + "west": {"uv": [0, 0, 1, 4], "texture": "#2"}, + "up": {"uv": [0, 0, 5, 1], "texture": "#2"}, + "down": {"uv": [0, 0, 5, 1], "texture": "#2"} + } + }, + { + "from": [10, 3, 4], + "to": [16, 4, 12], + "rotation": {"angle": 0, "axis": "y", "origin": [7, -2, 7]}, + "faces": { + "north": {"uv": [0, 0, 6, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 8, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 6, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 8, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 6, 8], "texture": "#2"}, + "down": {"uv": [0, 0, 6, 8], "texture": "#2"} + } + }, + { + "from": [4, 3, 9], + "to": [10, 4, 12], + "rotation": {"angle": 0, "axis": "y", "origin": [7, -2, 7]}, + "faces": { + "north": {"uv": [0, 0, 6, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 3, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 6, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 3, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 6, 3], "texture": "#2"}, + "down": {"uv": [0, 0, 6, 3], "texture": "#2"} + } + }, + { + "from": [10, 12, 4], + "to": [16, 13, 12], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 8, 7]}, + "faces": { + "north": {"uv": [0, 0, 6, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 8, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 6, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 8, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 6, 8], "texture": "#2"}, + "down": {"uv": [0, 0, 6, 8], "texture": "#2"} + } + }, + { + "from": [4, 12, 6], + "to": [10, 13, 12], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 8, 7]}, + "faces": { + "north": {"uv": [0, 0, 6, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 6, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 6, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 6, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 6, 6], "texture": "#2"}, + "down": {"uv": [0, 0, 6, 6], "texture": "#2"} + } + }, + { + "from": [4, 12, 4], + "to": [10, 13, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 8, 7]}, + "faces": { + "north": {"uv": [0, 0, 6, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 2, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 6, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 2, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 6, 2], "texture": "#2"}, + "down": {"uv": [0, 0, 6, 2], "texture": "#2"} + } + }, + { + "from": [6, 13, 6], + "to": [16, 14, 10], + "rotation": {"angle": 0, "axis": "y", "origin": [7, 8, 7]}, + "faces": { + "north": {"uv": [0, 0, 10, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 10, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 10, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 10, 4], "texture": "#2"} + } + }, + { + "from": [6, 2, 6], + "to": [16, 3, 10], + "rotation": {"angle": 0, "axis": "y", "origin": [7, -2, 7]}, + "faces": { + "north": {"uv": [0, 0, 10, 1], "texture": "#2"}, + "east": {"uv": [0, 0, 4, 1], "texture": "#2"}, + "south": {"uv": [0, 0, 10, 1], "texture": "#2"}, + "west": {"uv": [0, 0, 4, 1], "texture": "#2"}, + "up": {"uv": [0, 0, 10, 4], "texture": "#2"}, + "down": {"uv": [0, 0, 10, 4], "texture": "#2"} + } + } + ], + "display": { + "gui": { + "rotation": [22.6, 131, 0], + "translation": [-1, 0, 0], + "scale": [0.75, 0.75, 0.75] + } + }, + "groups": [ + { + "name": "Pipe", + "origin": [7, 0, 7], + "color": 0, + "nbt": "{}", + "children": [0, 1, 2, 3, 4, 5, 6] + }, + { + "name": "Pipe", + "origin": [8, 8, 8], + "color": 0, + "nbt": "{}", + "children": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16] + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/models/block/pipes/vertical_pipe.json b/src/main/resources/assets/cubliminal/models/block/pipes/vertical_pipe.json new file mode 100644 index 0000000..927a840 --- /dev/null +++ b/src/main/resources/assets/cubliminal/models/block/pipes/vertical_pipe.json @@ -0,0 +1,84 @@ +{ + "format_version": "1.21.6", + "credit": "Made with Blockbench", + "parent": "block/cube_all", + "textures": { + "0": "cubliminal:block/pipes/pipes", + "particle": "cubliminal:block/pipes/pipes" + }, + "elements": [ + { + "from": [6, 0, 1], + "to": [10, 16, 5], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 0, 1]}, + "faces": { + "north": {"uv": [12, 0, 16, 16], "texture": "#0"}, + "east": {"uv": [3, 0, 7, 16], "texture": "#0"}, + "south": {"uv": [3, 0, 7, 16], "texture": "#0"}, + "west": {"uv": [3, 0, 7, 16], "texture": "#0"}, + "up": {"uv": [3, 0, 7, 4], "texture": "#0"}, + "down": {"uv": [3, 0, 7, 4], "texture": "#0"} + } + }, + { + "from": [10, 0, 2], + "to": [11, 16, 4], + "rotation": {"angle": 0, "axis": "y", "origin": [1, 0, 1]}, + "faces": { + "north": {"uv": [6, 0, 7, 16], "texture": "#0"}, + "east": {"uv": [0, 0, 2, 16], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 16], "texture": "#0"}, + "west": {"uv": [0, 0, 2, 16], "texture": "#0"}, + "up": {"uv": [0, 0, 1, 2], "texture": "#0"}, + "down": {"uv": [0, 0, 1, 2], "texture": "#0"} + } + }, + { + "from": [5, 0, 2], + "to": [6, 16, 4], + "rotation": {"angle": 0, "axis": "y", "origin": [-4, 0, 1]}, + "faces": { + "north": {"uv": [6, 0, 7, 16], "texture": "#0"}, + "east": {"uv": [0, 0, 2, 16], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 16], "texture": "#0"}, + "west": {"uv": [0, 0, 2, 16], "texture": "#0"}, + "up": {"uv": [0, 0, 1, 2], "texture": "#0"}, + "down": {"uv": [0, 0, 1, 2], "texture": "#0"} + } + }, + { + "from": [7, 0, 5], + "to": [9, 16, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [-2, 0, 3]}, + "faces": { + "north": {"uv": [6, 0, 8, 16], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 16], "texture": "#0"}, + "south": {"uv": [0, 0, 2, 16], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 16], "texture": "#0"}, + "up": {"uv": [0, 0, 2, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 2, 1], "texture": "#0"} + } + }, + { + "from": [7, 0, 0], + "to": [9, 16, 1], + "rotation": {"angle": 0, "axis": "y", "origin": [-2, 0, -2]}, + "faces": { + "north": {"uv": [6, 0, 8, 16], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 16], "texture": "#0"}, + "south": {"uv": [0, 0, 2, 16], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 16], "texture": "#0"}, + "up": {"uv": [0, 0, 2, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 2, 1], "texture": "#0"} + } + } + ], + "display": { + "thirdperson_righthand": { + "translation": [0, 0, 3.25] + }, + "thirdperson_lefthand": { + "translation": [0, 0, 3.25] + } + } +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/models/block/pipes/vertical_pipe_connector.json b/src/main/resources/assets/cubliminal/models/block/pipes/vertical_pipe_connector.json new file mode 100644 index 0000000..806a32b --- /dev/null +++ b/src/main/resources/assets/cubliminal/models/block/pipes/vertical_pipe_connector.json @@ -0,0 +1,183 @@ +{ + "credit": "Made with Blockbench", + "parent": "block/cube_all", + "textures": { + "0": "cubliminal:block/pipes/pipes", + "1": "cubliminal:block/pipes/pipe-ring", + "particle": "cubliminal:block/pipes/pipes" + }, + "elements": [ + { + "from": [6, 0, 1], + "to": [10, 16, 5], + "rotation": {"angle": 0, "axis": "y", "origin": [0, 0, 1]}, + "faces": { + "north": {"uv": [12, 0, 16, 16], "texture": "#0"}, + "east": {"uv": [3, 0, 7, 16], "texture": "#0"}, + "south": {"uv": [3, 0, 7, 16], "texture": "#0"}, + "west": {"uv": [3, 0, 7, 16], "texture": "#0"}, + "up": {"uv": [3, 0, 7, 4], "texture": "#0"}, + "down": {"uv": [3, 0, 7, 4], "texture": "#0"} + } + }, + { + "from": [10, 0, 2], + "to": [11, 16, 4], + "rotation": {"angle": 0, "axis": "y", "origin": [1, 0, 1]}, + "faces": { + "north": {"uv": [6, 0, 7, 16], "texture": "#0"}, + "east": {"uv": [0, 0, 2, 16], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 16], "texture": "#0"}, + "west": {"uv": [0, 0, 2, 16], "texture": "#0"}, + "up": {"uv": [0, 0, 1, 2], "texture": "#0"}, + "down": {"uv": [0, 0, 1, 2], "texture": "#0"} + } + }, + { + "from": [5, 0, 2], + "to": [6, 16, 4], + "rotation": {"angle": 0, "axis": "y", "origin": [-4, 0, 1]}, + "faces": { + "north": {"uv": [6, 0, 7, 16], "texture": "#0"}, + "east": {"uv": [0, 0, 2, 16], "texture": "#0"}, + "south": {"uv": [0, 0, 1, 16], "texture": "#0"}, + "west": {"uv": [0, 0, 2, 16], "texture": "#0"}, + "up": {"uv": [0, 0, 1, 2], "texture": "#0"}, + "down": {"uv": [0, 0, 1, 2], "texture": "#0"} + } + }, + { + "from": [7, 0, 5], + "to": [9, 16, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [-2, 0, 3]}, + "faces": { + "north": {"uv": [6, 0, 8, 16], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 16], "texture": "#0"}, + "south": {"uv": [0, 0, 2, 16], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 16], "texture": "#0"}, + "up": {"uv": [0, 0, 2, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 2, 1], "texture": "#0"} + } + }, + { + "from": [7, 0, 0], + "to": [9, 16, 1], + "rotation": {"angle": 0, "axis": "y", "origin": [-2, 0, -2]}, + "faces": { + "north": {"uv": [6, 0, 8, 16], "texture": "#0"}, + "east": {"uv": [0, 0, 1, 16], "texture": "#0"}, + "south": {"uv": [0, 0, 2, 16], "texture": "#0"}, + "west": {"uv": [0, 0, 1, 16], "texture": "#0"}, + "up": {"uv": [0, 0, 2, 1], "texture": "#0"}, + "down": {"uv": [0, 0, 2, 1], "texture": "#0"} + } + }, + { + "from": [4, 7, 0], + "to": [5, 9, 5], + "rotation": {"angle": 0, "axis": "y", "origin": [4, 8, 0]}, + "faces": { + "north": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "east": {"uv": [0, 0, 5, 2], "texture": "#1"}, + "south": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "west": {"uv": [0, 0, 5, 2], "texture": "#1"}, + "up": {"uv": [0, 0, 1, 5], "texture": "#1"}, + "down": {"uv": [0, 0, 1, 5], "texture": "#1"} + } + }, + { + "from": [5, 7, 4], + "to": [6, 9, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [4, 8, 0]}, + "faces": { + "north": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "east": {"uv": [0, 0, 2, 2], "texture": "#1"}, + "south": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "west": {"uv": [0, 0, 2, 2], "texture": "#1"}, + "up": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "down": {"uv": [0, 0, 1, 2], "texture": "#1"} + } + }, + { + "from": [6, 7, 5], + "to": [7, 9, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [4, 8, 0]}, + "faces": { + "north": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "east": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "south": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "west": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "up": {"uv": [0, 0, 1, 1], "texture": "#1"}, + "down": {"uv": [0, 0, 1, 1], "texture": "#1"} + } + }, + { + "from": [6, 7, 6], + "to": [10, 9, 7], + "rotation": {"angle": 0, "axis": "y", "origin": [4, 8, 0]}, + "faces": { + "north": {"uv": [0, 0, 4, 2], "texture": "#1"}, + "east": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "south": {"uv": [0, 0, 4, 2], "texture": "#1"}, + "west": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "up": {"uv": [0, 0, 4, 1], "texture": "#1"}, + "down": {"uv": [0, 0, 4, 1], "texture": "#1"} + } + }, + { + "from": [9, 7, 5], + "to": [10, 9, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [4, 8, 0]}, + "faces": { + "north": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "east": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "south": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "west": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "up": {"uv": [0, 0, 1, 1], "texture": "#1"}, + "down": {"uv": [0, 0, 1, 1], "texture": "#1"} + } + }, + { + "from": [10, 7, 4], + "to": [11, 9, 6], + "rotation": {"angle": 0, "axis": "y", "origin": [4, 8, 0]}, + "faces": { + "north": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "east": {"uv": [0, 0, 2, 2], "texture": "#1"}, + "south": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "west": {"uv": [0, 0, 2, 2], "texture": "#1"}, + "up": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "down": {"uv": [0, 0, 1, 2], "texture": "#1"} + } + }, + { + "from": [11, 7, 0], + "to": [12, 9, 5], + "rotation": {"angle": 0, "axis": "y", "origin": [4, 8, 0]}, + "faces": { + "north": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "east": {"uv": [0, 0, 5, 2], "texture": "#1"}, + "south": {"uv": [0, 0, 1, 2], "texture": "#1"}, + "west": {"uv": [0, 0, 5, 2], "texture": "#1"}, + "up": {"uv": [0, 0, 1, 5], "texture": "#1"}, + "down": {"uv": [0, 0, 1, 5], "texture": "#1"} + } + } + ], + "groups": [ + { + "name": "Pipe", + "origin": [4, 8, 0], + "color": 0, + "nbt": "{}", + "children": [0, 1, 2, 3, 4] + }, + { + "name": "Connector", + "origin": [8, 8, 8], + "color": 0, + "nbt": "{}", + "children": [5, 6, 7, 8, 9, 10, 11] + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/models/item/ceiling_pipe.json b/src/main/resources/assets/cubliminal/models/item/ceiling_pipe.json new file mode 100644 index 0000000..1e3d656 --- /dev/null +++ b/src/main/resources/assets/cubliminal/models/item/ceiling_pipe.json @@ -0,0 +1,3 @@ +{ + "parent": "cubliminal:block/pipes/ceiling_pipe_1" +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/models/item/large_horizontal_pipe.json b/src/main/resources/assets/cubliminal/models/item/large_horizontal_pipe.json new file mode 100644 index 0000000..a33ef6f --- /dev/null +++ b/src/main/resources/assets/cubliminal/models/item/large_horizontal_pipe.json @@ -0,0 +1,3 @@ +{ + "parent": "cubliminal:block/pipes/large_pipe_2" +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/models/item/vertical_pipe.json b/src/main/resources/assets/cubliminal/models/item/vertical_pipe.json new file mode 100644 index 0000000..0618eb7 --- /dev/null +++ b/src/main/resources/assets/cubliminal/models/item/vertical_pipe.json @@ -0,0 +1,3 @@ +{ + "parent": "cubliminal:block/pipes/vertical_pipe" +} \ No newline at end of file diff --git a/src/main/resources/assets/cubliminal/textures/block/pipes/pipe-ring.png b/src/main/resources/assets/cubliminal/textures/block/pipes/pipe-ring.png new file mode 100644 index 0000000000000000000000000000000000000000..6e98c803c19460f5ccda1b4fa920bf30812abca6 GIT binary patch literal 646 zcmV;10(t$3P)n!?of9<@!zFKP; zV?qc3kWx<5)c1W^mPwNQ{r%N-on_hOaw&?!T8sbv`zNJTN*xXd$8n}<0)WTIM{BK8 z>htq6NfIGMS(co0Ap|&%b37jBc^-!0a=Fa&?EC&SP1f4Fu3gtf2pMB;w;KTDc@7xk zudlDJ>kvXg5Ku~+rqNnUDG4EYo>NM-*8BawEX#2mVV>uQhle$= zCJ2JQ@3SoPeIEck&m)9z&H+Gc%{ga`DWwoX=kpm{*L{C~4}xG>mbPs@&l5sywcKvE zG)+&Z)4HxzRat9~$D>Or4a2Z)+w=Jx$FY<$Ns?)rnx@I~ysqoR;lMd>+m z2=L3xi7L#_43uIsuqP3yXb&5Kg{_VyNr;kE+L^Oj{9$8kFm gLeex{*A*f3A1-`)R`apr!2kdN07*qoM6N<$g1g%_4gdfE literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/cubliminal/textures/block/pipes/pipes.png b/src/main/resources/assets/cubliminal/textures/block/pipes/pipes.png new file mode 100644 index 0000000000000000000000000000000000000000..18895bf79166d22d7793f19e1e03b95c73ff6c89 GIT binary patch literal 738 zcmV<80v-K{P)-jrSoLjfFd!Q;0X`d z-FNZpvMANAKAofb#P|2Nsj3RgvTz*dxy!O7O;ftA!?taN5VUQ}%gYPf?G~jJp64Np zq9BfA(lo_&U5qi*b05yx@xJdf3CMHEGJUH4Dodc7vkb2gg|%jFVd3`vq; zj6q8IMA+?i91aJB5bXDR0HhFt?RLxkekY0|+O|bXNtR_4MM2Xv2qAD?m$$b!vMl3t zI`R4Wi4fu+f>Mew47pq`q-n}DP4siwZ`{-_WM0m zRpI+S^6_{u3LTwQVIb3e!ru&CP@;m*DFdXj4||m{}lK4_lFRIVHh}_ zP8egD&*%R-@qb0@y2f!Fet&-%#}V7Mab1@30eArOR0f7Bu!_5B~Gv#PCB0imUV z5OC}yzJp#e^JvR!ul)tDudiN8NnO`077H$y3tiVCguq&h)*9y=LI}3oEm~`gG2GwZ zBc&t+D9e)he2x$T=N!fu>bfQf0!E_|-g^N4{riX3n#p9s@p!~JN0=lD&(F`S*K5}6 zHBw59F_dMAl#swl7x?s59+$+ ziXMD^etH0{HT(UZ!0a=l)8(TrRY2%Vx7dYt3vn!x)27 zilQipYD_nzm3s;X$32CX$^St5j>sw$Es8FXh^ zMi2yl0mtK!t4d=GQ52D;DMeB6^z?*t4y6=*-;-q-0Q>!(>2%8JbRrDH5Tz8qzrT3z z+3)vMRYe@f91aKaJjZ*_cDo&PhG97TG`u#O=Q++f7K;Vm`+@uG>kIEaFE1~{8l{v( zQN(JsB5d21zVA^=adUG+RaF23R-Wf*ttpCvvMh