From 27f46bdd991945b7175d58e53f7e716c2bf2ca47 Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Wed, 17 Feb 2021 16:10:52 +0100 Subject: [PATCH 01/18] WIP Covers --- .../refinedmods/refinedstorage/RSItems.java | 4 + .../api/network/node/ICoverable.java | 9 + .../network/node/CableNetworkNode.java | 32 +- .../apiimpl/network/node/cover/Cover.java | 22 ++ .../network/node/cover/CoverManager.java | 199 ++++++++++ .../apiimpl/network/node/cover/CoverType.java | 14 + .../integration/jei/RSJeiPlugin.java | 7 + .../refinedstorage/item/CoverItem.java | 164 ++++++++ .../refinedstorage/item/HollowCoverItem.java | 17 + .../refinedstorage/render/ConstantsCable.java | 67 ++++ .../render/collision/CollisionGroup.java | 48 +++ .../render/model/BakedModelCableCover.java | 364 ++++++++++++++++++ .../render/model/BakedModelCover.java | 158 ++++++++ .../render/model/CubeBuilder.java | 354 +++++++++++++++++ .../refinedstorage/setup/ClientSetup.java | 14 + .../refinedstorage/tile/CableTile.java | 57 +++ .../refinedstorage/util/CollisionUtils.java | 5 + .../refinedstorage/util/RenderUtils.java | 120 +++++- 18 files changed, 1650 insertions(+), 5 deletions(-) create mode 100644 src/main/java/com/refinedmods/refinedstorage/api/network/node/ICoverable.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/Cover.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverType.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/item/HollowCoverItem.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/render/ConstantsCable.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/render/collision/CollisionGroup.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCover.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/render/model/CubeBuilder.java diff --git a/src/main/java/com/refinedmods/refinedstorage/RSItems.java b/src/main/java/com/refinedmods/refinedstorage/RSItems.java index e787f4371..ceb7d993d 100644 --- a/src/main/java/com/refinedmods/refinedstorage/RSItems.java +++ b/src/main/java/com/refinedmods/refinedstorage/RSItems.java @@ -43,6 +43,8 @@ public final class RSItems { public static final RegistryObject WIRELESS_CRAFTING_MONITOR; public static final RegistryObject CREATIVE_WIRELESS_CRAFTING_MONITOR; public static final RegistryObject MACHINE_CASING; + public static final RegistryObject COVER; + public static final RegistryObject HOLLOW_COVER; public static final Map> PROCESSORS = new EnumMap<>(ProcessorItem.Type.class); @@ -121,6 +123,8 @@ public final class RSItems { registerBlockItemFor(RSBlocks.QUARTZ_ENRICHED_IRON); MACHINE_CASING = registerBlockItemFor(RSBlocks.MACHINE_CASING); + COVER = ITEMS.register("cover", CoverItem::new); + HOLLOW_COVER = ITEMS.register("hollow_cover", HollowCoverItem::new); registerBlockItemFor(RSBlocks.CABLE); registerBlockItemFor(RSBlocks.DISK_DRIVE); diff --git a/src/main/java/com/refinedmods/refinedstorage/api/network/node/ICoverable.java b/src/main/java/com/refinedmods/refinedstorage/api/network/node/ICoverable.java new file mode 100644 index 000000000..32df42678 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/api/network/node/ICoverable.java @@ -0,0 +1,9 @@ +package com.refinedmods.refinedstorage.api.network.node; + +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; + +public interface ICoverable { + + CoverManager getCoverManager(); + +} diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/CableNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/CableNetworkNode.java index 4d9af480a..3476316b4 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/CableNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/CableNetworkNode.java @@ -1,15 +1,22 @@ package com.refinedmods.refinedstorage.apiimpl.network.node; import com.refinedmods.refinedstorage.RS; +import com.refinedmods.refinedstorage.api.network.node.ICoverable; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; +import com.refinedmods.refinedstorage.util.WorldUtils; +import net.minecraft.nbt.CompoundNBT; import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; -public class CableNetworkNode extends NetworkNode { +public class CableNetworkNode extends NetworkNode implements ICoverable { public static final ResourceLocation ID = new ResourceLocation(RS.ID, "cable"); + private CoverManager coverManager; + public CableNetworkNode(World world, BlockPos pos) { super(world, pos); + this.coverManager = new CoverManager(this); } @Override @@ -21,4 +28,27 @@ public class CableNetworkNode extends NetworkNode { public ResourceLocation getId() { return ID; } + + @Override + public CoverManager getCoverManager() { + return coverManager; + } + + @Override + public void read(CompoundNBT tag) { + if (tag.contains("Cover")) this.coverManager.readFromNbt(tag.getCompound("Cover")); + super.read(tag); + } + + @Override + public void update() { + super.update(); + //WorldUtils.updateBlock(world, pos); + } + + @Override + public CompoundNBT write(CompoundNBT tag) { + tag.put("Cover", this.coverManager.writeToNbt()); + return super.write(tag); + } } diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/Cover.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/Cover.java new file mode 100644 index 000000000..a43740a9e --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/Cover.java @@ -0,0 +1,22 @@ +package com.refinedmods.refinedstorage.apiimpl.network.node.cover; + +import net.minecraft.item.ItemStack; + +public class Cover { + + private ItemStack stack; + private CoverType type; + + public Cover(ItemStack stack, CoverType type) { + this.stack = stack; + this.type = type; + } + + public ItemStack getStack() { + return stack; + } + + public CoverType getType() { + return type; + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java new file mode 100644 index 000000000..f78320724 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java @@ -0,0 +1,199 @@ +package com.refinedmods.refinedstorage.apiimpl.network.node.cover; + +import com.refinedmods.refinedstorage.api.network.node.ICoverable; +import com.refinedmods.refinedstorage.api.network.node.INetworkNode; +import com.refinedmods.refinedstorage.api.util.Action; +import com.refinedmods.refinedstorage.apiimpl.API; +import com.refinedmods.refinedstorage.apiimpl.network.node.CableNetworkNode; +import com.refinedmods.refinedstorage.apiimpl.network.node.NetworkNode; +import com.refinedmods.refinedstorage.item.CoverItem; +import net.minecraft.block.*; +import net.minecraft.client.Minecraft; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.CompoundNBT; +import net.minecraft.util.Direction; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.server.ServerWorld; +import net.minecraftforge.client.model.data.ModelProperty; +import net.minecraftforge.items.IItemHandlerModifiable; +import net.minecraftforge.items.ItemStackHandler; + +import javax.annotation.Nullable; +import java.util.HashMap; +import java.util.Map; + +public class CoverManager { + + public static final ModelProperty PROPERTY = new ModelProperty<>(); + + private static final String NBT_DIRECTION = "Direction"; + private static final String NBT_ITEM = "Item"; + private static final String NBT_TYPE = "Type"; + + private Map covers = new HashMap<>(); + private NetworkNode node; + + public CoverManager(NetworkNode node) { + this.node = node; + } + + public boolean canConduct(Direction direction) { + Cover cover = getCover(direction); + if (cover != null && cover.getType() != CoverType.HOLLOW) { + return false; + } + + if (node.getWorld() instanceof ServerWorld){ + INetworkNode neighbor = API.instance().getNetworkNodeManager((ServerWorld) node.getWorld()).getNode(node.getPos().offset(direction)); + if (neighbor instanceof ICoverable) { + cover = ((ICoverable) neighbor).getCoverManager().getCover(direction.getOpposite()); + + if (cover != null && cover.getType() != CoverType.HOLLOW) { + return false; + } + } + } + + return true; + } + + @Nullable + public Cover getCover(Direction facing) { + return covers.get(facing); + } + + public boolean hasCover(Direction facing) { + return covers.containsKey(facing); + } + + public boolean setCover(Direction facing, @Nullable Cover cover) { + if (cover == null || (isValidCover(cover.getStack()) && !hasCover(facing))) { + if (cover != null) { + if (!(node instanceof CableNetworkNode) && facing == node.getDirection() && cover.getType() != CoverType.HOLLOW) { + return false; + } + } + + if (cover == null) { + covers.remove(facing); + } else { + covers.put(facing, cover); + } + + node.markDirty(); + + if (node.getNetwork() != null) { + node.getNetwork().getNodeGraph().invalidate(Action.PERFORM, node.getNetwork().getWorld(), node.getNetwork().getPosition()); + } + + return true; + } + + return false; + } + + public void readFromNbt(CompoundNBT nbt) { + covers.clear(); + System.out.println(nbt); + for (String s : nbt.keySet()) { + CompoundNBT tag = nbt.getCompound(s); + if (tag.contains(NBT_DIRECTION) && tag.contains(NBT_ITEM)) { + Direction direction = Direction.byIndex(tag.getInt(NBT_DIRECTION)); + ItemStack item = ItemStack.read(tag.getCompound(NBT_ITEM)); + int type = tag.contains(NBT_TYPE) ? tag.getInt(NBT_TYPE) : 0; + + if (type >= CoverType.values().length) { + type = 0; + } + + if (isValidCover(item)) { + covers.put(direction, new Cover(item, CoverType.values()[type])); + } + } + } + } + + public CompoundNBT writeToNbt() { + CompoundNBT list = new CompoundNBT(); + + for (Map.Entry entry : covers.entrySet()) { + CompoundNBT tag = new CompoundNBT(); + + tag.putInt(NBT_DIRECTION, entry.getKey().ordinal()); + tag.put(NBT_ITEM, entry.getValue().getStack().serializeNBT()); + tag.putInt(NBT_TYPE, entry.getValue().getType().ordinal()); + + list.put(entry.getKey().ordinal() + "",tag); + } + return list; + } + + public IItemHandlerModifiable getAsInventory() { + ItemStackHandler handler = new ItemStackHandler(covers.size()); + + int i = 0; + + for (Map.Entry entry : covers.entrySet()) { + ItemStack cover = entry.getValue().getType().createStack(); + + CoverItem.setItem(cover, entry.getValue().getStack()); + + handler.setStackInSlot(i++, cover); + } + + return handler; + } + + @SuppressWarnings("deprecation") + public static boolean isValidCover(ItemStack item) { + if (item.isEmpty()) { + return false; + } + + Block block = getBlock(item); + + BlockState state = getBlockState(item); + + return block != null && state != null && ((isModelSupported(state) && !block.ticksRandomly(state) && !block.hasTileEntity(state)) || block instanceof GlassBlock || block instanceof StainedGlassBlock); //Removed is top solid as it needs world param + } + + private static boolean isModelSupported(BlockState state) { + if (state.getRenderType() != BlockRenderType.MODEL) { + return false; + } + + return state.isSolid() && state.isSolidSide(Minecraft.getInstance().world, new BlockPos(0,0,0), Direction.UP); //I dont trust this + } + + @Nullable + public static Block getBlock(@Nullable ItemStack item) { + if (item == null) { + return null; + } + + Block block = Block.getBlockFromItem(item.getItem()); + + if (block == Blocks.AIR) { + return null; + } + + return block; + } + + @Nullable + @SuppressWarnings("deprecation") + public static BlockState getBlockState(@Nullable ItemStack item) { + Block block = getBlock(item); + + if (block == null) { + return null; + } + + try { + return block.getDefaultState(); + } catch (Exception e) { + return null; + } + } + +} diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverType.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverType.java new file mode 100644 index 000000000..443af0481 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverType.java @@ -0,0 +1,14 @@ +package com.refinedmods.refinedstorage.apiimpl.network.node.cover; + +import com.refinedmods.refinedstorage.RSItems; +import net.minecraft.block.Blocks; +import net.minecraft.item.ItemStack; + +public enum CoverType { + NORMAL, + HOLLOW; + + public ItemStack createStack() { + return new ItemStack(this == NORMAL ? RSItems.COVER.get() : RSItems.HOLLOW_COVER.get() ); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/integration/jei/RSJeiPlugin.java b/src/main/java/com/refinedmods/refinedstorage/integration/jei/RSJeiPlugin.java index 4da6927ba..4c5ab5abd 100644 --- a/src/main/java/com/refinedmods/refinedstorage/integration/jei/RSJeiPlugin.java +++ b/src/main/java/com/refinedmods/refinedstorage/integration/jei/RSJeiPlugin.java @@ -1,11 +1,13 @@ package com.refinedmods.refinedstorage.integration.jei; import com.refinedmods.refinedstorage.RS; +import com.refinedmods.refinedstorage.RSItems; import com.refinedmods.refinedstorage.screen.BaseScreen; import mezz.jei.api.IModPlugin; import mezz.jei.api.JeiPlugin; import mezz.jei.api.registration.IGuiHandlerRegistration; import mezz.jei.api.registration.IRecipeTransferRegistration; +import mezz.jei.api.registration.ISubtypeRegistration; import mezz.jei.api.runtime.IJeiRuntime; import net.minecraft.util.ResourceLocation; @@ -39,4 +41,9 @@ public class RSJeiPlugin implements IModPlugin { public static IJeiRuntime getRuntime() { return runtime; } + + @Override + public void registerItemSubtypes(ISubtypeRegistration registration) { + registration.useNbtForSubtypes(RSItems.COVER.get(), RSItems.HOLLOW_COVER.get()); + } } diff --git a/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java b/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java new file mode 100644 index 000000000..771bf1c5b --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java @@ -0,0 +1,164 @@ +package com.refinedmods.refinedstorage.item; + +import com.refinedmods.refinedstorage.RS; +import com.refinedmods.refinedstorage.api.network.node.ICoverable; +import com.refinedmods.refinedstorage.api.network.node.INetworkNode; +import com.refinedmods.refinedstorage.api.network.security.Permission; +import com.refinedmods.refinedstorage.apiimpl.API; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType; +import com.refinedmods.refinedstorage.tile.NetworkNodeTile; +import com.refinedmods.refinedstorage.util.WorldUtils; +import net.minecraft.block.Block; +import net.minecraft.block.Blocks; +import net.minecraft.client.util.ITooltipFlag; +import net.minecraft.item.*; +import net.minecraft.nbt.CompoundNBT; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ActionResultType; +import net.minecraft.util.Direction; +import net.minecraft.util.NonNullList; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.text.ITextComponent; +import net.minecraft.world.World; +import net.minecraft.world.server.ServerWorld; +import net.minecraftforge.client.model.ModelDataManager; +import net.minecraftforge.registries.ForgeRegistries; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.util.List; + +public class CoverItem extends Item { + + private static final String NBT_ITEM = "Item"; + + public static final ItemStack HIDDEN_COVER_ALTERNATIVE = new ItemStack(Blocks.STONE_BRICKS); + + + public CoverItem() { + super(new Item.Properties().group(RS.MAIN_GROUP)); + } + + public static void setItem(ItemStack cover, ItemStack item) { + if (!cover.hasTag()) { + cover.setTag(new CompoundNBT()); + } + + cover.getTag().put(NBT_ITEM, item.serializeNBT()); + } + + @Nonnull + public static ItemStack getItem(ItemStack cover) { + if (!cover.hasTag() || !cover.getTag().contains(NBT_ITEM)) { + return ItemStack.EMPTY; + } + + return ItemStack.read(cover.getTag().getCompound(NBT_ITEM)); + } + + @Override + public void addInformation(ItemStack stack, @Nullable World worldIn, List tooltip, ITooltipFlag flagIn) { + super.addInformation(stack, worldIn, tooltip, flagIn); + ItemStack item = getItem(stack); + + if (!item.isEmpty()) { + tooltip.add(item.getItem().getDisplayName(item)); + } + } + + @Override + public void fillItemGroup(ItemGroup group, NonNullList items) { + + //if (RS.INSTANCE.config.hideCovers) { + // ItemStack stack = new ItemStack(this); + + //setItem(stack, HIDDEN_COVER_ALTERNATIVE); + + //items.add(stack); + + //return; + //} + if (this.isInGroup(group)) { + for (Block block : ForgeRegistries.BLOCKS.getValues()) { + Item item = Item.getItemFromBlock(block); + + if (item == Items.AIR) { + continue; + } + + NonNullList subBlocks = NonNullList.create(); + + block.fillItemGroup(ItemGroup.SEARCH, subBlocks); + + for (ItemStack subBlock : subBlocks) { + if (CoverManager.isValidCover(subBlock)) { + ItemStack stack = new ItemStack(this); + + setItem(stack, subBlock); + + items.add(stack); + } + } + } + } + } + + @Override + public ActionResultType onItemUse(ItemUseContext context) { + BlockPos pos = context.getPos(); + Direction facing = context.getFace(); + World world = context.getWorld(); + + ItemStack stack = context.getPlayer().getHeldItem(context.getHand()); + + TileEntity tile = world.getTileEntity(pos); + + // Support placing on the bottom side without too much hassle. + if (!canPlaceOn(tile)) { + pos = pos.up(); + + facing = Direction.DOWN; + + tile = world.getTileEntity(pos); + } + + if (canPlaceOn(tile)) { + if (world.isRemote) { + ModelDataManager.requestModelDataRefresh(tile); + return ActionResultType.SUCCESS; + } + + INetworkNode node = ((NetworkNodeTile) tile).getNode(); + + if (node.getNetwork() != null && !node.getNetwork().getSecurityManager().hasPermission(Permission.BUILD, context.getPlayer())) { + WorldUtils.sendNoPermissionMessage(context.getPlayer()); + + return ActionResultType.FAIL; + } + + if (((ICoverable) node).getCoverManager().setCover(facing, createCover(getItem(stack)))) { + context.getPlayer().getHeldItem(context.getHand()).shrink(1); + + WorldUtils.updateBlock(world, pos); + API.instance().getNetworkNodeManager((ServerWorld) world).markForSaving(); + return ActionResultType.SUCCESS; + } + + return ActionResultType.FAIL; + } + + return ActionResultType.PASS; + } + + + private boolean canPlaceOn(TileEntity tile) { + return tile instanceof NetworkNodeTile && ((NetworkNodeTile) tile).getNode() instanceof ICoverable; + } + + protected Cover createCover(ItemStack stack) { + return new Cover(stack, CoverType.NORMAL); + } + +} diff --git a/src/main/java/com/refinedmods/refinedstorage/item/HollowCoverItem.java b/src/main/java/com/refinedmods/refinedstorage/item/HollowCoverItem.java new file mode 100644 index 000000000..fb8997125 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/item/HollowCoverItem.java @@ -0,0 +1,17 @@ +package com.refinedmods.refinedstorage.item; + +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType; +import net.minecraft.item.ItemStack; + +public class HollowCoverItem extends CoverItem{ + + public HollowCoverItem() { + super(); + } + + @Override + protected Cover createCover(ItemStack stack) { + return new Cover(stack, CoverType.HOLLOW); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/render/ConstantsCable.java b/src/main/java/com/refinedmods/refinedstorage/render/ConstantsCable.java new file mode 100644 index 000000000..6ef2fbe99 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/render/ConstantsCable.java @@ -0,0 +1,67 @@ +package com.refinedmods.refinedstorage.render; + +import com.refinedmods.refinedstorage.render.collision.CollisionGroup; +import com.refinedmods.refinedstorage.util.CollisionUtils; +import net.minecraft.util.Direction; +import net.minecraft.util.math.AxisAlignedBB; + +import javax.annotation.Nonnull; + +public class ConstantsCable { + + public static final CollisionGroup CORE = new CollisionGroup().addItem(CollisionUtils.getBounds(6, 6, 6, 10, 10, 10)); + public static final CollisionGroup NORTH = new CollisionGroup().addItem(CollisionUtils.getBounds(6, 6, 0, 10, 10, 6)); + public static final CollisionGroup EAST = new CollisionGroup().addItem(CollisionUtils.getBounds(10, 6, 6, 16, 10, 10)); + public static final CollisionGroup SOUTH = new CollisionGroup().addItem(CollisionUtils.getBounds(6, 6, 10, 10, 10, 16)); + public static final CollisionGroup WEST = new CollisionGroup().addItem(CollisionUtils.getBounds(0, 6, 6, 6, 10, 10)); + public static final CollisionGroup UP = new CollisionGroup().addItem(CollisionUtils.getBounds(6, 10, 6, 10, 16, 10)); + public static final CollisionGroup DOWN = new CollisionGroup().addItem(CollisionUtils.getBounds(6, 0, 6, 10, 6, 10)); + + public static final CollisionGroup HOLDER_NORTH = new CollisionGroup().addItem(getHolderBounds(Direction.NORTH)); + public static final CollisionGroup HOLDER_EAST = new CollisionGroup().addItem(getHolderBounds(Direction.EAST)); + public static final CollisionGroup HOLDER_SOUTH = new CollisionGroup().addItem(getHolderBounds(Direction.SOUTH)); + public static final CollisionGroup HOLDER_WEST = new CollisionGroup().addItem(getHolderBounds(Direction.WEST)); + public static final CollisionGroup HOLDER_UP = new CollisionGroup().addItem(getHolderBounds(Direction.UP)); + public static final CollisionGroup HOLDER_DOWN = new CollisionGroup().addItem(getHolderBounds(Direction.DOWN)); + + @Nonnull + public static AxisAlignedBB getCoverBounds(Direction side) { + switch (side) { + case DOWN: + return CollisionUtils.getBounds(0, 0, 0, 16, 2, 16); + case UP: + return CollisionUtils.getBounds(0, 14, 0, 16, 16, 16); + case NORTH: + return CollisionUtils.getBounds(0, 0, 0, 16, 16, 2); + case SOUTH: + return CollisionUtils.getBounds(0, 0, 14, 16, 16, 16); + case WEST: + return CollisionUtils.getBounds(0, 0, 0, 2, 16, 16); + case EAST: + return CollisionUtils.getBounds(14, 0, 0, 16, 16, 16); + default: + return null; + } + } + + @Nonnull + public static AxisAlignedBB getHolderBounds(Direction side) { + switch (side) { + case DOWN: + return CollisionUtils.getBounds(7, 2, 7, 9, 6, 9); + case UP: + return CollisionUtils.getBounds(7, 10, 7, 9, 14, 9); + case NORTH: + return CollisionUtils.getBounds(7, 7, 2, 9, 9, 6); + case SOUTH: + return CollisionUtils.getBounds(7, 7, 10, 9, 9, 14); + case WEST: + return CollisionUtils.getBounds(2, 7, 7, 6, 9, 9); + case EAST: + return CollisionUtils.getBounds(10, 7, 7, 14, 9, 9); + default: + return null; + } + } + +} diff --git a/src/main/java/com/refinedmods/refinedstorage/render/collision/CollisionGroup.java b/src/main/java/com/refinedmods/refinedstorage/render/collision/CollisionGroup.java new file mode 100644 index 000000000..06ed72c43 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/render/collision/CollisionGroup.java @@ -0,0 +1,48 @@ +package com.refinedmods.refinedstorage.render.collision; + +import net.minecraft.util.Direction; +import net.minecraft.util.math.AxisAlignedBB; + +import javax.annotation.Nullable; +import java.util.ArrayList; +import java.util.List; + +public class CollisionGroup { + + private List items = new ArrayList<>(); + private boolean canAccessGui; + @Nullable + private Direction direction; + + public CollisionGroup addItem(AxisAlignedBB item) { + items.add(item); + + return this; + } + + public List getItems() { + return items; + } + + public boolean canAccessGui() { + return canAccessGui; + } + + public CollisionGroup setCanAccessGui(boolean canAccessGui) { + this.canAccessGui = canAccessGui; + + return this; + } + + public CollisionGroup setDirection(Direction direction) { + this.direction = direction; + + return this; + } + + @Nullable + public Direction getDirection() { + return direction; + } + +} diff --git a/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java b/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java new file mode 100644 index 000000000..f6b4db704 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java @@ -0,0 +1,364 @@ +package com.refinedmods.refinedstorage.render.model; + +import com.refinedmods.refinedstorage.RS; +import com.refinedmods.refinedstorage.RSBlocks; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; +import com.refinedmods.refinedstorage.block.BaseBlock; +import com.refinedmods.refinedstorage.render.ConstantsCable; +import com.refinedmods.refinedstorage.util.RenderUtils; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.Atlases; +import net.minecraft.client.renderer.model.BakedQuad; +import net.minecraft.client.renderer.model.IBakedModel; +import net.minecraft.client.renderer.texture.AtlasTexture; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.util.Direction; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.math.vector.Vector3f; +import net.minecraftforge.client.model.data.IModelData; + +import javax.annotation.Nullable; +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +public class BakedModelCableCover extends DelegateBakedModel{ + + private static TextureAtlasSprite BORDER_SPRITE; + + public BakedModelCableCover(IBakedModel base) { + super(base); + } + + @Override + public List getQuads(@Nullable BlockState state, @Nullable Direction side, Random rand, IModelData data) { + List quads = new ArrayList<>(base.getQuads(state, side, rand, data)); + if (data != null && data.hasProperty(CoverManager.PROPERTY)) { + CoverManager manager = data.getData(CoverManager.PROPERTY); + addCover(quads, manager.getCover(Direction.NORTH), Direction.NORTH, side, rand, manager, state, true); + addCover(quads, manager.getCover(Direction.DOWN), Direction.SOUTH, side, rand, manager, state, true); + addCover(quads, manager.getCover(Direction.EAST), Direction.EAST, side, rand, manager, state, true); + addCover(quads, manager.getCover(Direction.WEST), Direction.WEST, side, rand, manager, state, true); + addCover(quads, manager.getCover(Direction.DOWN), Direction.DOWN, side, rand, manager, state, true); + addCover(quads, manager.getCover(Direction.UP), Direction.UP, side, rand, manager, state, true); + } + return quads; + } + + private static int getHollowCoverSize(@Nullable BlockState state, Direction coverSide) { + if (state == null) { + return 6; + } + + BaseBlock block = (BaseBlock) state.getBlock(); + if (block == RSBlocks.CABLE.get()){ + return 6; + } + + if (block.getDirection() != null && state.get(block.getDirection().getProperty()) == coverSide) { + if (block == RSBlocks.EXPORTER.get()) { + return 6; + } else if (block == RSBlocks.EXTERNAL_STORAGE.get() || block == RSBlocks.IMPORTER.get()) { + return 3; + } else if (block == RSBlocks.CONSTRUCTOR.get() || block == RSBlocks.DESTRUCTOR.get()) { //Removed reader and writer + return 2; + } + } + + return 6; + } + + protected static void addCover(List quads, @Nullable Cover cover, Direction coverSide, Direction side, Random rand, @Nullable CoverManager manager, BlockState state, boolean handle) { + if (cover == null) { + return; + } + + BlockState coverState = CoverManager.getBlockState(cover.getStack()); + + if (coverState == null) { + return; + } + + boolean hasUp = false, hasDown = false, hasEast = false, hasWest = false; + + if (manager != null) { + hasUp = manager.hasCover(Direction.UP); + hasDown = manager.hasCover(Direction.DOWN); + hasEast = manager.hasCover(Direction.EAST); + hasWest = manager.hasCover(Direction.WEST); + } + + TextureAtlasSprite sprite = RenderUtils.getSprite(Minecraft.getInstance().getBlockRendererDispatcher().getModelForState(coverState), coverState, side, rand); + + switch (cover.getType()) { + case NORMAL: + addNormalCover(quads, sprite, coverSide, hasUp, hasDown, hasEast, hasWest, handle); + break; + case HOLLOW: + addHollowCover(quads, sprite, coverSide, hasUp, hasDown, hasEast, hasWest, getHollowCoverSize(state, coverSide)); + break; + } + } + + private static void addNormalCover(List quads, TextureAtlasSprite sprite, Direction coverSide, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest, boolean handle) { + AxisAlignedBB bounds = ConstantsCable.getCoverBounds(coverSide); + + Vector3f from = new Vector3f((float) bounds.minX * 16, (float) bounds.minY * 16, (float) bounds.minZ * 16); + Vector3f to = new Vector3f((float) bounds.maxX * 16, (float) bounds.maxY * 16, (float) bounds.maxZ * 16); + + if (coverSide == Direction.NORTH) { + if (hasWest) { + from.setX(2); + } + + if (hasEast) { + to.setX(14); + } + } else if (coverSide == Direction.SOUTH) { + if (hasWest) { + from.setX(2); + } + + if (hasEast) { + to.setX(14); + } + } + + if (coverSide.getAxis() != Direction.Axis.Y) { + if (hasDown) { + from.setY(2); + } + + if (hasUp) { + to.setY(14); + } + } + + quads.addAll(new CubeBuilder().from(from.getX(), from.getY(), from.getZ()).to(to.getX(), to.getY(), to.getZ()).addFaces(face -> new CubeBuilder.Face(face, sprite)).bake()); + + if (handle) { + if (BORDER_SPRITE == null) { + BORDER_SPRITE = Minecraft.getInstance().getAtlasSpriteGetter(AtlasTexture.LOCATION_BLOCKS_TEXTURE).apply(new ResourceLocation(RS.ID , "block/cable_part_border")); + } + + bounds = ConstantsCable.getHolderBounds(coverSide); + + from = new Vector3f((float) bounds.minX * 16, (float) bounds.minY * 16, (float) bounds.minZ * 16); + to = new Vector3f((float) bounds.maxX * 16, (float) bounds.maxY * 16, (float) bounds.maxZ * 16); + + quads.addAll(new CubeBuilder().from(from.getX(), from.getY(), from.getZ()).to(to.getX(), to.getY(), to.getZ()).addFaces(face -> new CubeBuilder.Face(face, BORDER_SPRITE)).bake()); + } + } + + private static void addHollowCover(List quads, TextureAtlasSprite sprite, Direction coverSide, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest, int size) { + AxisAlignedBB bounds = ConstantsCable.getCoverBounds(coverSide); + + Vector3f from = new Vector3f((float) bounds.minX * 16, (float) bounds.minY * 16, (float) bounds.minZ * 16); + Vector3f to = new Vector3f((float) bounds.maxX * 16, (float) bounds.maxY * 16, (float) bounds.maxZ * 16); + + if (coverSide.getAxis() != Direction.Axis.Y) { + if (hasDown) { + from.setY(2); + } + + if (hasUp) { + to.setY(14); + } + } + + // Right + if (coverSide == Direction.NORTH) { + if (hasWest) { + from.setX(2); + } else { + from.setX(0); + } + + to.setX(size); + } else if (coverSide == Direction.SOUTH) { + if (hasEast) { + to.setX(14); + } else { + to.setX(16); + } + + from.setX(16 - size); + } else if (coverSide == Direction.EAST) { + from.setZ(0); + to.setZ(size); + } else if (coverSide == Direction.WEST) { + from.setZ(16 - size); + to.setZ(16); + } else if (coverSide == Direction.DOWN || coverSide == Direction.UP) { + from.setZ(16 - size); + to.setZ(16); + } + + quads.addAll(new CubeBuilder() + .from(from.getX(), from.getY(), from.getZ()) + .to(to.getX(), to.getY(), to.getZ()) + .addFaces(face -> new CubeBuilder.Face(face, sprite)) + .bake() + ); + + // Left + if (coverSide == Direction.NORTH) { + if (hasEast) { + to.setX(14); + } else { + to.setX(16); + } + + from.setX(16 - size); + } else if (coverSide == Direction.SOUTH) { + if (hasWest) { + from.setX(2); + } else { + from.setX(0); + } + + to.setX(size); + } else if (coverSide == Direction.EAST) { + from.setZ(16 - size); + to.setZ(16); + } else if (coverSide == Direction.WEST) { + from.setZ(0); + to.setZ(size); + } else if (coverSide == Direction.DOWN || coverSide == Direction.UP) { + from.setZ(0); + to.setZ(size); + } + + quads.addAll(new CubeBuilder() + .from(from.getX(), from.getY(), from.getZ()) + .to(to.getX(), to.getY(), to.getZ()) + .addFaces(face -> new CubeBuilder.Face(face, sprite)) + .bake() + ); + + // Bottom + if (coverSide == Direction.NORTH) { + from.setX(size); + to.setX(16 - size); + + if (hasDown) { + from.setY(2); + } else { + from.setY(0); + } + + to.setY(size); + } else if (coverSide == Direction.SOUTH) { + from.setX(size); + to.setX(16 - size); + + if (hasDown) { + from.setY(2); + } else { + from.setY(0); + } + + to.setY(size); + } else if (coverSide == Direction.EAST) { + from.setZ(size); + to.setZ(16 - size); + + if (hasDown) { + from.setY(2); + } else { + from.setY(0); + } + + to.setY(size); + } else if (coverSide == Direction.WEST) { + from.setZ(size); + to.setZ(16 - size); + + if (hasDown) { + from.setY(2); + } else { + from.setY(0); + } + + to.setY(size); + } else if (coverSide == Direction.DOWN || coverSide == Direction.UP) { + from.setZ(size); + to.setZ(16 - size); + + from.setX(0); + to.setX(size); + } + + quads.addAll(new CubeBuilder() + .from(from.getX(), from.getY(), from.getZ()) + .to(to.getX(), to.getY(), to.getZ()) + .addFaces(face -> new CubeBuilder.Face(face, sprite)) + .bake() + ); + + // Up + if (coverSide == Direction.NORTH) { + from.setX(size); + to.setX(16 - size); + + if (hasUp) { + to.setY(14); + } else { + to.setY(16); + } + + from.setY(16 - size); + } else if (coverSide == Direction.SOUTH) { + from.setX(size); + to.setX(16 - size); + + if (hasUp) { + to.setY(14); + } else { + to.setY(16); + } + + from.setY(16 - size); + } else if (coverSide == Direction.EAST) { + from.setZ(size); + to.setZ(16 - size); + + if (hasUp) { + to.setY(14); + } else { + to.setY(16); + } + + from.setY(16 - size); + } else if (coverSide == Direction.WEST) { + from.setZ(size); + to.setZ(16 - size); + + if (hasUp) { + to.setY(14); + } else { + to.setY(16); + } + + from.setY(16 - size); + } else if (coverSide == Direction.DOWN || coverSide == Direction.UP) { + from.setZ(size); + to.setZ(16 - size); + + from.setX(16 - size); + to.setX(16); + } + + quads.addAll(new CubeBuilder() + .from(from.getX(), from.getY(), from.getZ()) + .to(to.getX(), to.getY(), to.getZ()) + .addFaces(face -> new CubeBuilder.Face(face, sprite)) + .bake() + ); + } +} + diff --git a/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCover.java b/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCover.java new file mode 100644 index 000000000..4e2592f9d --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCover.java @@ -0,0 +1,158 @@ +package com.refinedmods.refinedstorage.render.model; + +import com.google.common.cache.CacheBuilder; +import com.google.common.cache.CacheLoader; +import com.google.common.cache.LoadingCache; +import com.mojang.blaze3d.matrix.MatrixStack; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType; +import com.refinedmods.refinedstorage.item.CoverItem; +import com.refinedmods.refinedstorage.util.RenderUtils; +import net.minecraft.block.BlockState; +import net.minecraft.client.renderer.model.BakedQuad; +import net.minecraft.client.renderer.model.IBakedModel; +import net.minecraft.client.renderer.model.ItemCameraTransforms; +import net.minecraft.client.renderer.model.ItemOverrideList; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.world.ClientWorld; +import net.minecraft.entity.LivingEntity; +import net.minecraft.item.ItemStack; +import net.minecraft.util.Direction; +import net.minecraft.util.math.vector.TransformationMatrix; + +import javax.annotation.Nullable; +import java.util.*; + +public class BakedModelCover extends BakedModelCableCover{ + + private class CacheKey { + private BlockState state; + private ItemStack stack; + private Direction side; + private CoverType type; + + CacheKey(BlockState state, ItemStack stack, Direction side, CoverType type) { + this.state = state; + this.stack = stack; + this.side = side; + this.type = type; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + + if (o == null || getClass() != o.getClass()) { + return false; + } + + BakedModelCover.CacheKey cacheKey = (BakedModelCover.CacheKey) o; + + return cacheKey.type == type && cacheKey.stack.getItem() == stack.getItem() /* && cacheKey.stack.getItemDamage() == stack.getItemDamage()*/ && cacheKey.side == side && Objects.equals(cacheKey.state, state); + } + + @Override + public int hashCode() { + int result = stack.getItem().hashCode(); + //result = 31 * result + stack.getDamage(); + result = 31 * result + (side != null ? side.hashCode() : 0); + result = 31 * result + (state != null ? state.hashCode() : 0); + result = 31 * result + type.hashCode(); + return result; + } + } + + private static final LoadingCache> CACHE = CacheBuilder.newBuilder().build(new CacheLoader>() { + @Override + public List load(CacheKey key) { + List quads = new ArrayList<>(); + + addCover(quads, new Cover(key.stack, key.type), Direction.NORTH, key.side, new Random(), null, null, true); + + return quads; + } + }); + + private ItemStack stack; + private CoverType type; + + public BakedModelCover(ItemStack stack, CoverType type) { + super(null); + + this.stack = stack; + this.type = type; + } + + @Override + public List getQuads(@Nullable BlockState state, @Nullable Direction side, Random rand) { + if (stack.isEmpty()) { + return Collections.emptyList(); + } + + CacheKey key = new CacheKey(state, CoverItem.getItem(stack), side, type); + + return CACHE.getUnchecked(key); + } + + @Override + public ItemOverrideList getOverrides() { + return new ItemOverrideList() { + @Override + public IBakedModel func_239290_a_(IBakedModel originalModel, ItemStack stack, @Nullable ClientWorld world, @Nullable LivingEntity entity) { + return new BakedModelCover(stack, type); + } + }; + } + + // @Override + // public Pair handlePerspective(ItemCameraTransforms.TransformType cameraTransformType) { + // TRSRTransformation transform = RenderUtils.getDefaultBlockTransforms().get(cameraTransformType); + // + // return Pair.of(this, transform == null ? RenderUtils.EMPTY_MATRIX_TRANSFORM : transform.getMatrix()); + // } + + @Override + public IBakedModel handlePerspective(ItemCameraTransforms.TransformType cameraTransformType, MatrixStack matrixStack) { + TransformationMatrix transform = RenderUtils.getDefaultBlockTransforms().get(cameraTransformType); + if (transform != null) transform.push(matrixStack); + return this; + } + + @Override + public boolean isAmbientOcclusion() { + return true; + } + + @Override + public boolean isGui3d() { + return true; + } + + @Override + public boolean isBuiltInRenderer() { + return false; + } + + @Override + public TextureAtlasSprite getParticleTexture() { + return null; + } + + @Override + public boolean isAmbientOcclusion(BlockState state) { + return true; + } + + @Override + @SuppressWarnings("deprecation") + public ItemCameraTransforms getItemCameraTransforms() { + return ItemCameraTransforms.DEFAULT; + } + + @Override + public boolean func_230044_c_() { + return true; + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/render/model/CubeBuilder.java b/src/main/java/com/refinedmods/refinedstorage/render/model/CubeBuilder.java new file mode 100644 index 000000000..6052bc808 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/render/model/CubeBuilder.java @@ -0,0 +1,354 @@ +package com.refinedmods.refinedstorage.render.model; + +import com.refinedmods.refinedstorage.util.RenderUtils; +import net.minecraft.client.renderer.model.BakedQuad; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.renderer.vertex.DefaultVertexFormats; +import net.minecraft.client.renderer.vertex.VertexFormat; +import net.minecraft.client.renderer.vertex.VertexFormatElement; +import net.minecraft.util.Direction; +import net.minecraft.util.math.vector.Vector3f; +import net.minecraftforge.client.model.pipeline.BakedQuadBuilder; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.function.Function; + +public class CubeBuilder { + + public enum UvRotation { + CLOCKWISE_0, + CLOCKWISE_90, + CLOCKWISE_180, + CLOCKWISE_270 + } + + private static class Uv { + private float xFrom; + private float xTo; + private float yFrom; + private float yTo; + } + + public static class Face { + private Direction face; + private TextureAtlasSprite sprite; + private int light; + private UvRotation uvRotation = UvRotation.CLOCKWISE_0; + + public Face(Direction face, TextureAtlasSprite sprite) { + this.face = face; + this.sprite = sprite; + } + + public Face(Direction face, TextureAtlasSprite sprite, UvRotation uvRotation) { + this(face, sprite); + + this.uvRotation = uvRotation; + } + + public Face(Direction face, TextureAtlasSprite sprite, UvRotation uvRotation, int light) { + this(face, sprite, uvRotation); + + this.light = light; + } + } + + private Vector3f from; + private Vector3f to; + private VertexFormat format = DefaultVertexFormats.BLOCK; //Changed from Item + private Map faces = new HashMap<>(); + private int color = 0xFFFFFFFF; + + public CubeBuilder from(float x, float y, float z) { + this.from = new Vector3f(x / 16, y / 16, z / 16); + + return this; + } + + public CubeBuilder to(float x, float y, float z) { + this.to = new Vector3f(x / 16, y / 16, z / 16); + + return this; + } + + public CubeBuilder color(int color) { + this.color = color; + + return this; + } + + public CubeBuilder lightmap() { + this.format = RenderUtils.getFormatWithLightMap(format); + + return this; + } + + public CubeBuilder addFaces(Function faceSupplier) { + for (Direction facing : Direction.values()) { + addFace(faceSupplier.apply(facing)); + } + + return this; + } + + public CubeBuilder addFace(Face face) { + faces.put(face.face, face); + + return this; + } + + public List bake() { + List quads = new ArrayList<>(); + + for (Map.Entry entry : faces.entrySet()) { + quads.add(bakeFace(entry.getKey(), entry.getValue())); + } + + return quads; + } + + private BakedQuad bakeFace(Direction facing, Face cubeFace) { + BakedQuadBuilder builder = new BakedQuadBuilder(cubeFace.sprite); //TODO See if can change the vertex format + + //builder.setTexture(cubeFace.sprite); + builder.setQuadOrientation(facing); + builder.setQuadTint(-1); + builder.setApplyDiffuseLighting(true); + + Uv uv = getDefaultUv(facing, cubeFace.sprite, from.getX(), from.getY(), from.getZ(), to.getX(), to.getY(), to.getZ()); + + switch (facing) { + case DOWN: + addVertexTopRight(builder, cubeFace, to.getX(), from.getY(), from.getZ(), uv); + addVertexBottomRight(builder, cubeFace, to.getX(), from.getY(), to.getZ(), uv); + addVertexBottomLeft(builder, cubeFace, from.getX(), from.getY(), to.getZ(), uv); + addVertexTopLeft(builder, cubeFace, from.getX(), from.getY(), from.getZ(), uv); + break; + case UP: + addVertexTopLeft(builder, cubeFace, from.getX(), to.getY(), from.getZ(), uv); + addVertexBottomLeft(builder, cubeFace, from.getX(), to.getY(), to.getZ(), uv); + addVertexBottomRight(builder, cubeFace, to.getX(), to.getY(), to.getZ(), uv); + addVertexTopRight(builder, cubeFace, to.getX(), to.getY(), from.getZ(), uv); + break; + case NORTH: + addVertexBottomRight(builder, cubeFace, to.getX(), to.getY(), from.getZ(), uv); + addVertexTopRight(builder, cubeFace, to.getX(), from.getY(), from.getZ(), uv); + addVertexTopLeft(builder, cubeFace, from.getX(), from.getY(), from.getZ(), uv); + addVertexBottomLeft(builder, cubeFace, from.getX(), to.getY(), from.getZ(), uv); + break; + case SOUTH: + addVertexBottomLeft(builder, cubeFace, from.getX(), to.getY(), to.getZ(), uv); + addVertexTopLeft(builder, cubeFace, from.getX(), from.getY(), to.getZ(), uv); + addVertexTopRight(builder, cubeFace, to.getX(), from.getY(), to.getZ(), uv); + addVertexBottomRight(builder, cubeFace, to.getX(), to.getY(), to.getZ(), uv); + break; + case WEST: + addVertexTopLeft(builder, cubeFace, from.getX(), from.getY(), from.getZ(), uv); + addVertexTopRight(builder, cubeFace, from.getX(), from.getY(), to.getZ(), uv); + addVertexBottomRight(builder, cubeFace, from.getX(), to.getY(), to.getZ(), uv); + addVertexBottomLeft(builder, cubeFace, from.getX(), to.getY(), from.getZ(), uv); + break; + case EAST: + addVertexBottomRight(builder, cubeFace, to.getX(), to.getY(), from.getZ(), uv); + addVertexBottomLeft(builder, cubeFace, to.getX(), to.getY(), to.getZ(), uv); + addVertexTopLeft(builder, cubeFace, to.getX(), from.getY(), to.getZ(), uv); + addVertexTopRight(builder, cubeFace, to.getX(), from.getY(), from.getZ(), uv); + break; + } + + return builder.build(); + } + + private Uv getDefaultUv(Direction face, TextureAtlasSprite texture, float fromX, float fromY, float fromZ, float toX, float toY, float toZ) { + Uv uv = new Uv(); + + switch (face) { + case DOWN: + uv.xFrom = texture.getInterpolatedU(fromX * 16); + uv.yFrom = texture.getInterpolatedV(16 - fromZ * 16); + uv.xTo = texture.getInterpolatedU(toX * 16); + uv.yTo = texture.getInterpolatedV(16 - toZ * 16); + break; + case UP: + uv.xFrom = texture.getInterpolatedU(fromX * 16); + uv.yFrom = texture.getInterpolatedV(fromZ * 16); + uv.xTo = texture.getInterpolatedU(toX * 16); + uv.yTo = texture.getInterpolatedV(toZ * 16); + break; + case NORTH: + uv.xFrom = texture.getInterpolatedU(16 - fromX * 16); + uv.yFrom = texture.getInterpolatedV(16 - fromY * 16); + uv.xTo = texture.getInterpolatedU(16 - toX * 16); + uv.yTo = texture.getInterpolatedV(16 - toY * 16); + break; + case SOUTH: + uv.xFrom = texture.getInterpolatedU(fromX * 16); + uv.yFrom = texture.getInterpolatedV(16 - fromY * 16); + uv.xTo = texture.getInterpolatedU(toX * 16); + uv.yTo = texture.getInterpolatedV(16 - toY * 16); + break; + case WEST: + uv.xFrom = texture.getInterpolatedU(fromZ * 16); + uv.yFrom = texture.getInterpolatedV(16 - fromY * 16); + uv.xTo = texture.getInterpolatedU(toZ * 16); + uv.yTo = texture.getInterpolatedV(16 - toY * 16); + break; + case EAST: + uv.xFrom = texture.getInterpolatedU(16 - toZ * 16); + uv.yFrom = texture.getInterpolatedV(16 - fromY * 16); + uv.xTo = texture.getInterpolatedU(16 - fromZ * 16); + uv.yTo = texture.getInterpolatedV(16 - toY * 16); + break; + } + + return uv; + } + + private void addVertexTopLeft(BakedQuadBuilder builder, Face face, float x, float y, float z, Uv uv) { + float u; + float v; + + switch (face.uvRotation) { + default: + case CLOCKWISE_0: + u = uv.xFrom; + v = uv.yFrom; + break; + case CLOCKWISE_90: + u = uv.xFrom; + v = uv.yTo; + break; + case CLOCKWISE_180: + u = uv.xTo; + v = uv.yTo; + break; + case CLOCKWISE_270: + u = uv.xTo; + v = uv.yFrom; + break; + } + + addVertex(builder, face, x, y, z, u, v); + } + + private void addVertexTopRight(BakedQuadBuilder builder, Face face, float x, float y, float z, Uv uv) { + float u; + float v; + + switch (face.uvRotation) { + default: + case CLOCKWISE_0: + u = uv.xTo; + v = uv.yFrom; + break; + case CLOCKWISE_90: + u = uv.xFrom; + v = uv.yFrom; + break; + case CLOCKWISE_180: + u = uv.xFrom; + v = uv.yTo; + break; + case CLOCKWISE_270: + u = uv.xTo; + v = uv.yTo; + break; + } + + addVertex(builder, face, x, y, z, u, v); + } + + private void addVertexBottomRight(BakedQuadBuilder builder, Face face, float x, float y, float z, Uv uv) { + float u; + float v; + + switch (face.uvRotation) { + default: + case CLOCKWISE_0: + u = uv.xTo; + v = uv.yTo; + break; + case CLOCKWISE_90: + u = uv.xTo; + v = uv.yFrom; + break; + case CLOCKWISE_180: + u = uv.xFrom; + v = uv.yFrom; + break; + case CLOCKWISE_270: + u = uv.xFrom; + v = uv.yTo; + break; + } + + addVertex(builder, face, x, y, z, u, v); + } + + private void addVertexBottomLeft(BakedQuadBuilder builder, Face face, float x, float y, float z, Uv uv) { + float u; + float v; + + switch (face.uvRotation) { + default: + case CLOCKWISE_0: + u = uv.xFrom; + v = uv.yTo; + break; + case CLOCKWISE_90: + u = uv.xTo; + v = uv.yTo; + break; + case CLOCKWISE_180: + u = uv.xTo; + v = uv.yFrom; + break; + case CLOCKWISE_270: + u = uv.xFrom; + v = uv.yFrom; + break; + } + + addVertex(builder, face, x, y, z, u, v); + } + + private void addVertex(BakedQuadBuilder builder, Face face, float x, float y, float z, float u, float v) { + VertexFormat format = builder.getVertexFormat(); + + for (int i = 0; i < format.getElements().size(); i++) { + VertexFormatElement e = format.getElements().get(i); + + switch (e.getUsage()) { + case POSITION: + builder.put(i, x, y, z); + break; + case NORMAL: + builder.put(i, face.face.getXOffset(), face.face.getYOffset(), face.face.getZOffset()); + break; + case COLOR: + float r = (color >> 16 & 0xFF) / 255F; + float g = (color >> 8 & 0xFF) / 255F; + float b = (color & 0xFF) / 255F; + float a = (color >> 24 & 0xFF) / 255F; + + builder.put(i, r, g, b, a); + break; + case UV: + if (e.getIndex() == 0) { + builder.put(i, u, v); + } else { + builder.put(i, (float) (face.light * 0x20) / 0xFFFF, (float) (face.light * 0x20) / 0xFFFF); + } + + break; + default: + builder.put(i); + break; + } + } + } + +} diff --git a/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java b/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java index 508d6b31d..323e3e418 100644 --- a/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java +++ b/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java @@ -2,6 +2,7 @@ package com.refinedmods.refinedstorage.setup; import com.refinedmods.refinedstorage.*; import com.refinedmods.refinedstorage.apiimpl.API; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType; import com.refinedmods.refinedstorage.container.CrafterContainer; import com.refinedmods.refinedstorage.container.CrafterManagerContainer; import com.refinedmods.refinedstorage.container.slot.CrafterManagerSlot; @@ -23,14 +24,17 @@ import net.minecraft.client.gui.ScreenManager; import net.minecraft.client.gui.screen.Screen; import net.minecraft.client.renderer.RenderType; import net.minecraft.client.renderer.RenderTypeLookup; +import net.minecraft.client.renderer.texture.AtlasTexture; import net.minecraft.inventory.container.Container; import net.minecraft.inventory.container.Slot; import net.minecraft.item.DyeColor; import net.minecraft.item.ItemModelsProperties; +import net.minecraft.item.ItemStack; import net.minecraft.resources.IReloadableResourceManager; import net.minecraft.resources.IResourceManager; import net.minecraft.util.ResourceLocation; import net.minecraftforge.client.event.ModelBakeEvent; +import net.minecraftforge.client.event.TextureStitchEvent; import net.minecraftforge.client.model.ModelLoader; import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.eventbus.api.SubscribeEvent; @@ -107,6 +111,9 @@ public class ClientSetup { false, new ResourceLocation(RS.ID, "block/disks/leds") )); + bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "cable"), (base, registry) -> new BakedModelCableCover(base)); + bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "cover"), (base, registry) -> new BakedModelCover(ItemStack.EMPTY, CoverType.NORMAL)); + bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "hollow_cover"), (base, registry) -> new BakedModelCover(ItemStack.EMPTY, CoverType.HOLLOW)); forEachColorApply("disk_manipulator", (name, color) -> bakedModelOverrideRegistry.add(name, (base, registry) -> new FullbrightBakedModel( new DiskManipulatorBakedModel( @@ -167,6 +174,7 @@ public class ClientSetup { FMLJavaModLoadingContext.get().getModEventBus().addListener(this::onClientSetup); FMLJavaModLoadingContext.get().getModEventBus().addListener(this::onModelBake); + FMLJavaModLoadingContext.get().getModEventBus().addListener(this::onTextureStitch); MinecraftForge.EVENT_BUS.addListener(new ExperimentalLightingPipelineNagger()::onPlayerLoggedIn); API.instance().addPatternRenderHandler(pattern -> Screen.hasShiftDown()); @@ -305,4 +313,10 @@ public class ClientSetup { } } } + + @SubscribeEvent + public void onTextureStitch(TextureStitchEvent.Pre event){ + if (event.getMap().getTextureLocation().equals(AtlasTexture.LOCATION_BLOCKS_TEXTURE)) + event.addSprite(new ResourceLocation(RS.ID ,"block/cable_part_border")); + } } diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java index a3910ae86..e482637c1 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java @@ -1,15 +1,46 @@ package com.refinedmods.refinedstorage.tile; import com.refinedmods.refinedstorage.RSTiles; +import com.refinedmods.refinedstorage.api.network.node.ICoverable; import com.refinedmods.refinedstorage.apiimpl.network.node.CableNetworkNode; +import com.refinedmods.refinedstorage.apiimpl.network.node.DiskState; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; +import com.refinedmods.refinedstorage.tile.data.TileDataManager; +import com.refinedmods.refinedstorage.tile.data.TileDataParameter; +import com.refinedmods.refinedstorage.util.WorldUtils; +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; +import net.minecraft.client.Minecraft; +import net.minecraft.nbt.CompoundNBT; +import net.minecraft.nbt.IntNBT; +import net.minecraft.nbt.ListNBT; +import net.minecraft.network.datasync.DataSerializers; +import net.minecraft.network.datasync.IDataSerializer; +import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import net.minecraftforge.client.model.ModelDataManager; +import net.minecraftforge.client.model.data.IModelData; +import net.minecraftforge.client.model.data.ModelDataMap; +import net.minecraftforge.client.model.data.ModelProperty; +import net.minecraftforge.common.util.Constants; import javax.annotation.Nonnull; +import java.util.HashMap; public class CableTile extends NetworkNodeTile { + + public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), t -> t.getNode().getCoverManager().writeToNbt(), (t, v) -> t.getNode().getCoverManager().readFromNbt(v), (initial, p) -> Minecraft.getInstance().enqueue(() -> { + + })); + + static { + TileDataManager.registerParameter(COVER_MANAGER); + } + public CableTile() { super(RSTiles.CABLE); + dataManager.addWatchedParameter(COVER_MANAGER); } @Override @@ -17,4 +48,30 @@ public class CableTile extends NetworkNodeTile { public CableNetworkNode createNode(World world, BlockPos pos) { return new CableNetworkNode(world, pos); } + + @Nonnull + @Override + public IModelData getModelData() { + return new ModelDataMap.Builder().withInitial(CoverManager.PROPERTY, this.getNode().getCoverManager()).build(); + } + + @Override + public CompoundNBT writeUpdate(CompoundNBT tag) { + super.writeUpdate(tag); + tag.put("Covers", this.getNode().getCoverManager().writeToNbt()); + return tag; + } + + @Override + public void readUpdate(CompoundNBT tag) { + super.readUpdate(tag); + + this.getNode().getCoverManager().readFromNbt(tag.getCompound("Covers")); + + requestModelDataUpdate(); + + WorldUtils.updateBlock(world, pos); + } + + } diff --git a/src/main/java/com/refinedmods/refinedstorage/util/CollisionUtils.java b/src/main/java/com/refinedmods/refinedstorage/util/CollisionUtils.java index f298ca8c2..8eebc7273 100644 --- a/src/main/java/com/refinedmods/refinedstorage/util/CollisionUtils.java +++ b/src/main/java/com/refinedmods/refinedstorage/util/CollisionUtils.java @@ -19,4 +19,9 @@ public final class CollisionUtils { && hit.z >= aabb.minZ && hit.z <= aabb.maxZ; } + + public static AxisAlignedBB getBounds(int fromX, int fromY, int fromZ, int toX, int toY, int toZ) { + return new AxisAlignedBB((float) fromX / 16F, (float) fromY / 16F, (float) fromZ / 16F, (float) toX / 16F, (float) toY / 16F, (float) toZ / 16F); + } + } diff --git a/src/main/java/com/refinedmods/refinedstorage/util/RenderUtils.java b/src/main/java/com/refinedmods/refinedstorage/util/RenderUtils.java index a3238868d..002ea91b8 100644 --- a/src/main/java/com/refinedmods/refinedstorage/util/RenderUtils.java +++ b/src/main/java/com/refinedmods/refinedstorage/util/RenderUtils.java @@ -1,29 +1,45 @@ package com.refinedmods.refinedstorage.util; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; import com.mojang.blaze3d.matrix.MatrixStack; import com.mojang.blaze3d.systems.RenderSystem; import com.refinedmods.refinedstorage.api.util.IComparer; import com.refinedmods.refinedstorage.apiimpl.API; import com.refinedmods.refinedstorage.render.Styles; import com.refinedmods.refinedstorage.screen.BaseScreen; +import net.minecraft.block.BlockState; import net.minecraft.client.Minecraft; import net.minecraft.client.gui.FontRenderer; import net.minecraft.client.renderer.IRenderTypeBuffer; +import net.minecraft.client.renderer.RenderType; import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.model.BakedQuad; +import net.minecraft.client.renderer.model.IBakedModel; +import net.minecraft.client.renderer.model.ItemCameraTransforms; +import net.minecraft.client.renderer.model.ItemTransformVec3f; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.renderer.vertex.DefaultVertexFormats; +import net.minecraft.client.renderer.vertex.VertexFormat; +import net.minecraft.client.renderer.vertex.VertexFormatElement; import net.minecraft.client.util.ITooltipFlag; import net.minecraft.item.ItemStack; +import net.minecraft.util.Direction; import net.minecraft.util.math.vector.Matrix4f; +import net.minecraft.util.math.vector.Quaternion; +import net.minecraft.util.math.vector.TransformationMatrix; +import net.minecraft.util.math.vector.Vector3f; import net.minecraft.util.text.*; +import net.minecraftforge.client.ForgeHooksClient; +import net.minecraftforge.client.MinecraftForgeClient; import net.minecraftforge.client.event.RenderTooltipEvent; import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fml.client.gui.GuiUtils; import javax.annotation.Nonnull; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Set; +import java.util.*; +import java.util.function.Consumer; public final class RenderUtils { private RenderUtils() { @@ -299,4 +315,100 @@ public final class RenderUtils { public static boolean inBounds(int x, int y, int w, int h, double ox, double oy) { return ox >= x && ox <= x + w && oy >= y && oy <= y + h; } + + public static boolean isLightMapDisabled() { + return false; //FMLClientHandler.instance().hasOptifine() || !ForgeModContainer.forgeLightPipelineEnabled; TODO + } + + public static VertexFormat getFormatWithLightMap(VertexFormat format) { + if (isLightMapDisabled()) { + return format; + } + + if (format == DefaultVertexFormats.BLOCK) { + return DefaultVertexFormats.BLOCK; + } else if (!format.hasUV(1)) { ; + return new VertexFormat(ImmutableList.builder().addAll(format.getElements()).add(DefaultVertexFormats.TEX_2S).build()); + } + + return format; + } + + public static TextureAtlasSprite getSprite(IBakedModel coverModel, BlockState coverState, Direction facing, Random rand) { + TextureAtlasSprite sprite = null; + + RenderType originalLayer = MinecraftForgeClient.getRenderLayer(); + + try { + for (RenderType layer : RenderType.getBlockRenderTypes()) { + ForgeHooksClient.setRenderLayer(layer); + + for (BakedQuad bakedQuad : coverModel.getQuads(coverState, facing, rand)) { + return bakedQuad.func_187508_a(); + } + + for (BakedQuad bakedQuad : coverModel.getQuads(coverState, null, rand)) { + if (sprite == null) { + sprite = bakedQuad.func_187508_a(); + } + + if (bakedQuad.getFace() == facing) { + return bakedQuad.func_187508_a(); + } + } + } + } catch (Exception e) { + // NO OP + } finally { + ForgeHooksClient.setRenderLayer(originalLayer); + } + + if (sprite == null) { + try { + sprite = coverModel.getParticleTexture(); + } catch (Exception e) { + // NO OP + } + } + + if (sprite == null) { + sprite = null; //TODO Get missing sprite + } + + return sprite; + } + + private static ImmutableMap DEFAULT_BLOCK_TRANSFORM; + + public static ImmutableMap getDefaultBlockTransforms() { + if (DEFAULT_BLOCK_TRANSFORM != null) { + return DEFAULT_BLOCK_TRANSFORM; + } + + TransformationMatrix thirdperson = getTransform(0, 2.5f, 0, 75, 45, 0, 0.375f); + + return DEFAULT_BLOCK_TRANSFORM = ImmutableMap.builder() + .put(ItemCameraTransforms.TransformType.GUI, getTransform(0, 0, 0, 30, 225, 0, 0.625f)) + .put(ItemCameraTransforms.TransformType.GROUND, getTransform(0, 3, 0, 0, 0, 0, 0.25f)) + .put(ItemCameraTransforms.TransformType.FIXED, getTransform(0, 0, 0, 0, 0, 0, 0.5f)) + .put(ItemCameraTransforms.TransformType.THIRD_PERSON_RIGHT_HAND, thirdperson) + .put(ItemCameraTransforms.TransformType.THIRD_PERSON_LEFT_HAND, leftifyTransform(thirdperson)) + .put(ItemCameraTransforms.TransformType.FIRST_PERSON_RIGHT_HAND, getTransform(0, 0, 0, 0, 45, 0, 0.4f)) + .put(ItemCameraTransforms.TransformType.FIRST_PERSON_LEFT_HAND, getTransform(0, 0, 0, 0, 225, 0, 0.4f)) + .build(); + } + + private static TransformationMatrix leftifyTransform(TransformationMatrix transform) { + return transform.blockCornerToCenter().blockCenterToCorner(); + } + + private static TransformationMatrix getTransform(float tx, float ty, float tz, float ax, float ay, float az, float s) { + return new TransformationMatrix( + new Vector3f(tx / 16, ty / 16, tz / 16), + new Quaternion(ax, ay, az, true), + new Vector3f(s, s, s), + null + ); + } + } From 7104424af8246a535f649af490f1ef25bbf35d6f Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Fri, 19 Feb 2021 18:30:08 +0100 Subject: [PATCH 02/18] Added Cover Collision --- .../refinedstorage/block/CableBlock.java | 8 ++++- .../block/ConstructorBlock.java | 3 +- .../refinedstorage/block/DestructorBlock.java | 3 +- .../refinedstorage/block/ExporterBlock.java | 3 +- .../block/ExternalStorageBlock.java | 3 +- .../refinedstorage/block/ImporterBlock.java | 3 +- .../refinedstorage/render/ConstantsCable.java | 32 ++++++++++++++++++- 7 files changed, 48 insertions(+), 7 deletions(-) diff --git a/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java index d4d32932b..a07b62072 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java @@ -1,8 +1,14 @@ package com.refinedmods.refinedstorage.block; +import com.refinedmods.refinedstorage.api.network.node.ICoverable; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType; import com.refinedmods.refinedstorage.block.shape.ShapeCache; import com.refinedmods.refinedstorage.capability.NetworkNodeProxyCapability; +import com.refinedmods.refinedstorage.render.ConstantsCable; import com.refinedmods.refinedstorage.tile.CableTile; +import com.refinedmods.refinedstorage.tile.NetworkNodeTile; import com.refinedmods.refinedstorage.util.BlockUtils; import net.minecraft.block.Block; import net.minecraft.block.BlockState; @@ -69,7 +75,7 @@ public class CableBlock extends NetworkNodeBlock implements IWaterLoggable { @Override @SuppressWarnings("deprecation") public VoxelShape getShape(BlockState state, IBlockReader world, BlockPos pos, ISelectionContext ctx) { - return ShapeCache.getOrCreate(state, CableBlock::getCableShape); + return ConstantsCable.addCoverVoxelShapes(ShapeCache.getOrCreate(state, CableBlock::getCableShape), world, pos); } protected static VoxelShape getCableShape(BlockState state) { diff --git a/src/main/java/com/refinedmods/refinedstorage/block/ConstructorBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/ConstructorBlock.java index 5aa3ad32e..6c00d8526 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/ConstructorBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/ConstructorBlock.java @@ -3,6 +3,7 @@ package com.refinedmods.refinedstorage.block; import com.refinedmods.refinedstorage.block.shape.ShapeCache; import com.refinedmods.refinedstorage.container.ConstructorContainer; import com.refinedmods.refinedstorage.container.factory.PositionalTileContainerProvider; +import com.refinedmods.refinedstorage.render.ConstantsCable; import com.refinedmods.refinedstorage.tile.ConstructorTile; import com.refinedmods.refinedstorage.util.BlockUtils; import com.refinedmods.refinedstorage.util.CollisionUtils; @@ -56,7 +57,7 @@ public class ConstructorBlock extends CableBlock { shape = VoxelShapes.or(shape, getHeadShape(s)); - return shape; + return ConstantsCable.addCoverVoxelShapes(shape, world, pos); }); } diff --git a/src/main/java/com/refinedmods/refinedstorage/block/DestructorBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/DestructorBlock.java index c587de070..71c25d66e 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/DestructorBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/DestructorBlock.java @@ -3,6 +3,7 @@ package com.refinedmods.refinedstorage.block; import com.refinedmods.refinedstorage.block.shape.ShapeCache; import com.refinedmods.refinedstorage.container.DestructorContainer; import com.refinedmods.refinedstorage.container.factory.PositionalTileContainerProvider; +import com.refinedmods.refinedstorage.render.ConstantsCable; import com.refinedmods.refinedstorage.tile.DestructorTile; import com.refinedmods.refinedstorage.util.BlockUtils; import com.refinedmods.refinedstorage.util.CollisionUtils; @@ -56,7 +57,7 @@ public class DestructorBlock extends CableBlock { shape = VoxelShapes.or(shape, getHeadShape(s)); - return shape; + return ConstantsCable.addCoverVoxelShapes(shape, world, pos); }); } diff --git a/src/main/java/com/refinedmods/refinedstorage/block/ExporterBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/ExporterBlock.java index c8788e9a9..26703e67a 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/ExporterBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/ExporterBlock.java @@ -3,6 +3,7 @@ package com.refinedmods.refinedstorage.block; import com.refinedmods.refinedstorage.block.shape.ShapeCache; import com.refinedmods.refinedstorage.container.ExporterContainer; import com.refinedmods.refinedstorage.container.factory.PositionalTileContainerProvider; +import com.refinedmods.refinedstorage.render.ConstantsCable; import com.refinedmods.refinedstorage.tile.ExporterTile; import com.refinedmods.refinedstorage.util.BlockUtils; import com.refinedmods.refinedstorage.util.CollisionUtils; @@ -73,7 +74,7 @@ public class ExporterBlock extends CableBlock { shape = VoxelShapes.or(shape, getLineShape(s)); - return shape; + return ConstantsCable.addCoverVoxelShapes(shape, world, pos); }); } diff --git a/src/main/java/com/refinedmods/refinedstorage/block/ExternalStorageBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/ExternalStorageBlock.java index 0a96357e1..7d69ab68b 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/ExternalStorageBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/ExternalStorageBlock.java @@ -6,6 +6,7 @@ import com.refinedmods.refinedstorage.apiimpl.network.node.ExternalStorageNetwor import com.refinedmods.refinedstorage.block.shape.ShapeCache; import com.refinedmods.refinedstorage.container.ExternalStorageContainer; import com.refinedmods.refinedstorage.container.factory.PositionalTileContainerProvider; +import com.refinedmods.refinedstorage.render.ConstantsCable; import com.refinedmods.refinedstorage.tile.ExternalStorageTile; import com.refinedmods.refinedstorage.util.BlockUtils; import com.refinedmods.refinedstorage.util.CollisionUtils; @@ -54,7 +55,7 @@ public class ExternalStorageBlock extends CableBlock { shape = VoxelShapes.or(shape, getHeadShape(s)); - return shape; + return ConstantsCable.addCoverVoxelShapes(shape, world, pos); }); } diff --git a/src/main/java/com/refinedmods/refinedstorage/block/ImporterBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/ImporterBlock.java index b34077769..aeb86c061 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/ImporterBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/ImporterBlock.java @@ -3,6 +3,7 @@ package com.refinedmods.refinedstorage.block; import com.refinedmods.refinedstorage.block.shape.ShapeCache; import com.refinedmods.refinedstorage.container.ImporterContainer; import com.refinedmods.refinedstorage.container.factory.PositionalTileContainerProvider; +import com.refinedmods.refinedstorage.render.ConstantsCable; import com.refinedmods.refinedstorage.tile.ImporterTile; import com.refinedmods.refinedstorage.util.BlockUtils; import com.refinedmods.refinedstorage.util.CollisionUtils; @@ -73,7 +74,7 @@ public class ImporterBlock extends CableBlock { shape = VoxelShapes.or(shape, getLineShape(s)); - return shape; + return ConstantsCable.addCoverVoxelShapes(shape, world, pos); }); } diff --git a/src/main/java/com/refinedmods/refinedstorage/render/ConstantsCable.java b/src/main/java/com/refinedmods/refinedstorage/render/ConstantsCable.java index 6ef2fbe99..a09f38f4d 100644 --- a/src/main/java/com/refinedmods/refinedstorage/render/ConstantsCable.java +++ b/src/main/java/com/refinedmods/refinedstorage/render/ConstantsCable.java @@ -1,9 +1,20 @@ package com.refinedmods.refinedstorage.render; +import com.refinedmods.refinedstorage.api.network.node.ICoverable; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType; import com.refinedmods.refinedstorage.render.collision.CollisionGroup; +import com.refinedmods.refinedstorage.tile.NetworkNodeTile; import com.refinedmods.refinedstorage.util.CollisionUtils; +import net.minecraft.tileentity.TileEntity; import net.minecraft.util.Direction; import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.shapes.VoxelShape; +import net.minecraft.util.math.shapes.VoxelShapes; +import net.minecraft.world.IBlockReader; +import net.minecraft.world.IWorldReader; import javax.annotation.Nonnull; @@ -63,5 +74,24 @@ public class ConstantsCable { return null; } } - + + public static VoxelShape addCoverVoxelShapes(VoxelShape shape, IBlockReader world, BlockPos pos){ + if (world != null){ + TileEntity entity = world.getTileEntity(pos); + if (entity instanceof NetworkNodeTile && ((NetworkNodeTile) entity).getNode() instanceof ICoverable){ + CoverManager coverManager = ((ICoverable) ((NetworkNodeTile) entity).getNode()).getCoverManager(); + for (Direction value : Direction.values()) { + Cover cover = coverManager.getCover(value); + if (cover != null){ + shape = VoxelShapes.or(shape, VoxelShapes.create(ConstantsCable.getCoverBounds(value))); + if (cover.getType() == CoverType.NORMAL){ + shape = VoxelShapes.or(shape, VoxelShapes.create(ConstantsCable.getHolderBounds(value))); + } + } + } + } + } + return shape; + } + } From 4a78c775bba67a9e52cc2232fc35cfba1a35b947 Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Fri, 19 Feb 2021 18:31:14 +0100 Subject: [PATCH 03/18] Fixed Cover rendering on the south side --- .../refinedstorage/render/model/BakedModelCableCover.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java b/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java index f6b4db704..e21eeebf6 100644 --- a/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java +++ b/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java @@ -40,7 +40,7 @@ public class BakedModelCableCover extends DelegateBakedModel{ if (data != null && data.hasProperty(CoverManager.PROPERTY)) { CoverManager manager = data.getData(CoverManager.PROPERTY); addCover(quads, manager.getCover(Direction.NORTH), Direction.NORTH, side, rand, manager, state, true); - addCover(quads, manager.getCover(Direction.DOWN), Direction.SOUTH, side, rand, manager, state, true); + addCover(quads, manager.getCover(Direction.SOUTH), Direction.SOUTH, side, rand, manager, state, true); addCover(quads, manager.getCover(Direction.EAST), Direction.EAST, side, rand, manager, state, true); addCover(quads, manager.getCover(Direction.WEST), Direction.WEST, side, rand, manager, state, true); addCover(quads, manager.getCover(Direction.DOWN), Direction.DOWN, side, rand, manager, state, true); From 3fa0b2b9d06dc3369baf408de53434337418f795 Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Sat, 11 Sep 2021 12:31:14 +0200 Subject: [PATCH 04/18] Added cover cable connectivity --- .../refinedmods/refinedstorage/block/CableBlock.java | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java index a07b62072..4e2bba435 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java @@ -1,6 +1,7 @@ package com.refinedmods.refinedstorage.block; import com.refinedmods.refinedstorage.api.network.node.ICoverable; +import com.refinedmods.refinedstorage.api.network.node.INetworkNodeProxy; import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover; import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType; @@ -155,7 +156,14 @@ public class CableBlock extends NetworkNodeBlock implements IWaterLoggable { return false; } - return tile.getCapability(NetworkNodeProxyCapability.NETWORK_NODE_PROXY_CAPABILITY, direction).isPresent(); + return tile.getCapability(NetworkNodeProxyCapability.NETWORK_NODE_PROXY_CAPABILITY, direction).isPresent() && isSideNotCoveredOrHollow(tile, direction) && isSideNotCoveredOrHollow(world.getTileEntity(pos.offset(direction)), direction.getOpposite()); + } + + private boolean isSideNotCoveredOrHollow(TileEntity tile, Direction direction){ + if (tile == null){ + return false; + } + return tile.getCapability(NetworkNodeProxyCapability.NETWORK_NODE_PROXY_CAPABILITY, direction).map(INetworkNodeProxy::getNode).map(iNetworkNode -> iNetworkNode instanceof ICoverable && (!((ICoverable) iNetworkNode).getCoverManager().hasCover(direction) || ((ICoverable) iNetworkNode).getCoverManager().getCover(direction).getType() == CoverType.HOLLOW)).orElse(false); } private BlockState getState(BlockState currentState, IWorld world, BlockPos pos) { From 2f90b6b592263c3cde832adc759128d6afb8ddd7 Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Sat, 11 Sep 2021 12:50:43 +0200 Subject: [PATCH 05/18] Added localization for the cover items and filtered out transparent blocks from being a cover --- .../network/node/cover/CoverManager.java | 22 +------------------ .../assets/refinedstorage/lang/en_us.json | 2 ++ 2 files changed, 3 insertions(+), 21 deletions(-) diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java index f78320724..0e81cc9d9 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java @@ -37,26 +37,6 @@ public class CoverManager { this.node = node; } - public boolean canConduct(Direction direction) { - Cover cover = getCover(direction); - if (cover != null && cover.getType() != CoverType.HOLLOW) { - return false; - } - - if (node.getWorld() instanceof ServerWorld){ - INetworkNode neighbor = API.instance().getNetworkNodeManager((ServerWorld) node.getWorld()).getNode(node.getPos().offset(direction)); - if (neighbor instanceof ICoverable) { - cover = ((ICoverable) neighbor).getCoverManager().getCover(direction.getOpposite()); - - if (cover != null && cover.getType() != CoverType.HOLLOW) { - return false; - } - } - } - - return true; - } - @Nullable public Cover getCover(Direction facing) { return covers.get(facing); @@ -154,7 +134,7 @@ public class CoverManager { BlockState state = getBlockState(item); - return block != null && state != null && ((isModelSupported(state) && !block.ticksRandomly(state) && !block.hasTileEntity(state)) || block instanceof GlassBlock || block instanceof StainedGlassBlock); //Removed is top solid as it needs world param + return block != null && state != null && ((isModelSupported(state) && !block.ticksRandomly(state) && !block.hasTileEntity(state) && !state.isTransparent())); //Removed is top solid as it needs world param } private static boolean isModelSupported(BlockState state) { diff --git a/src/main/resources/assets/refinedstorage/lang/en_us.json b/src/main/resources/assets/refinedstorage/lang/en_us.json index ac71499b3..0a6a8244a 100644 --- a/src/main/resources/assets/refinedstorage/lang/en_us.json +++ b/src/main/resources/assets/refinedstorage/lang/en_us.json @@ -301,6 +301,8 @@ "item.refinedstorage.security_card": "Security Card", "item.refinedstorage.security_card.owner": "Bound to: %s", "item.refinedstorage.processor_binding": "Processor Binding", + "item.refinedstorage.cover": "Cover", + "item.refinedstorage.hollow_cover": "Hollow Cover", "commands.refinedstorage.disk.create.error.disk_not_found": "Disk %s was not found.", "commands.refinedstorage.disk.create.success": "Successfully gave disk %s to %s.", "commands.refinedstorage.network.list.pos": "Network at X: %d, Y: %d, Z: %d", From 3fa1fbb2720eb66adbcfb3cd0473942795674742 Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Sat, 11 Sep 2021 13:15:45 +0200 Subject: [PATCH 06/18] Wrench now removes covers --- .../network/node/cover/CoverManager.java | 16 ++++++++++++++ .../refinedstorage/block/CableBlock.java | 6 ++++++ .../refinedstorage/item/WrenchItem.java | 21 +++++++++++++++++-- 3 files changed, 41 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java index 0e81cc9d9..977b16b4a 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java @@ -72,6 +72,22 @@ public class CoverManager { return false; } + @Nullable + public Cover removeCover(Direction direction){ + if (hasCover(direction)){ + Cover cover = covers.remove(direction); + + node.markDirty(); + + if (node.getNetwork() != null) { + node.getNetwork().getNodeGraph().invalidate(Action.PERFORM, node.getNetwork().getWorld(), node.getNetwork().getPosition()); + } + + return cover; + } + return null; + } + public void readFromNbt(CompoundNBT nbt) { covers.clear(); System.out.println(nbt); diff --git a/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java index 4e2bba435..c19bc0bea 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java @@ -123,6 +123,12 @@ public class CableBlock extends NetworkNodeBlock implements IWaterLoggable { super.onDirectionChanged(world, pos, newDirection); } + @Override + public void neighborChanged(BlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos, boolean isMoving) { + super.neighborChanged(state, world, pos, blockIn, fromPos, isMoving); + world.setBlockState(pos, getState(world.getBlockState(pos), world, pos)); + } + @Nullable @Override public BlockState getStateForPlacement(BlockItemUseContext ctx) { diff --git a/src/main/java/com/refinedmods/refinedstorage/item/WrenchItem.java b/src/main/java/com/refinedmods/refinedstorage/item/WrenchItem.java index 28c6afd7b..feb331842 100644 --- a/src/main/java/com/refinedmods/refinedstorage/item/WrenchItem.java +++ b/src/main/java/com/refinedmods/refinedstorage/item/WrenchItem.java @@ -2,7 +2,11 @@ package com.refinedmods.refinedstorage.item; import com.refinedmods.refinedstorage.RS; import com.refinedmods.refinedstorage.api.network.INetwork; +import com.refinedmods.refinedstorage.api.network.node.ICoverable; +import com.refinedmods.refinedstorage.api.network.node.INetworkNode; import com.refinedmods.refinedstorage.api.network.security.Permission; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType; import com.refinedmods.refinedstorage.util.NetworkUtils; import com.refinedmods.refinedstorage.util.WorldUtils; import net.minecraft.block.BlockState; @@ -11,6 +15,7 @@ import net.minecraft.item.ItemStack; import net.minecraft.item.ItemUseContext; import net.minecraft.util.ActionResultType; import net.minecraft.util.Rotation; +import net.minecraftforge.items.ItemHandlerHelper; public class WrenchItem extends Item { public WrenchItem() { @@ -23,15 +28,27 @@ public class WrenchItem extends Item { return ActionResultType.CONSUME; } - INetwork network = NetworkUtils.getNetworkFromNode(NetworkUtils.getNodeFromTile(ctx.getWorld().getTileEntity(ctx.getPos()))); + INetworkNode node = NetworkUtils.getNodeFromTile(ctx.getWorld().getTileEntity(ctx.getPos())); + INetwork network = NetworkUtils.getNetworkFromNode(node); if (network != null && !network.getSecurityManager().hasPermission(Permission.BUILD, ctx.getPlayer())) { WorldUtils.sendNoPermissionMessage(ctx.getPlayer()); return ActionResultType.FAIL; } - BlockState state = ctx.getWorld().getBlockState(ctx.getPos()); + if (node instanceof ICoverable && ((ICoverable) node).getCoverManager().hasCover(ctx.getFace())){ + Cover cover = ((ICoverable) node).getCoverManager().removeCover(ctx.getFace()); + if (cover != null){ + ItemStack stack1 = cover.getType().createStack(); + CoverItem.setItem(stack1, cover.getStack()); + ItemHandlerHelper.giveItemToPlayer(ctx.getPlayer(), stack1); + ctx.getWorld().notifyBlockUpdate(ctx.getPos(), state, state, 3); + ctx.getWorld().notifyNeighborsOfStateChange(ctx.getPos(), ctx.getWorld().getBlockState(ctx.getPos()).getBlock()); + return ActionResultType.SUCCESS; + } + } + ctx.getWorld().setBlockState(ctx.getPos(), state.rotate(ctx.getWorld(), ctx.getPos(), Rotation.CLOCKWISE_90)); return ActionResultType.CONSUME; From a6884690d4c3f39ee9815b6ba03b23268b86c0b5 Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Sat, 11 Sep 2021 20:05:35 +0200 Subject: [PATCH 07/18] Added cover recipes --- .../jei/CoverCraftingCategoryExtension.java | 84 +++++++++++++ .../HollowCoverCraftingCategoryExtension.java | 67 +++++++++++ .../integration/jei/RSJeiPlugin.java | 15 ++- .../refinedstorage/item/CoverItem.java | 9 +- .../refinedstorage/recipe/CoverRecipe.java | 111 ++++++++++++++++++ .../recipe/HollowCoverRecipe.java | 89 ++++++++++++++ .../refinedstorage/setup/CommonSetup.java | 5 + .../data/refinedstorage/recipes/cover.json | 3 + .../refinedstorage/recipes/hollow_cover.json | 3 + 9 files changed, 380 insertions(+), 6 deletions(-) create mode 100644 src/main/java/com/refinedmods/refinedstorage/integration/jei/CoverCraftingCategoryExtension.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/integration/jei/HollowCoverCraftingCategoryExtension.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/recipe/CoverRecipe.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/recipe/HollowCoverRecipe.java create mode 100644 src/main/resources/data/refinedstorage/recipes/cover.json create mode 100644 src/main/resources/data/refinedstorage/recipes/hollow_cover.json diff --git a/src/main/java/com/refinedmods/refinedstorage/integration/jei/CoverCraftingCategoryExtension.java b/src/main/java/com/refinedmods/refinedstorage/integration/jei/CoverCraftingCategoryExtension.java new file mode 100644 index 000000000..5f4ef3cc0 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/integration/jei/CoverCraftingCategoryExtension.java @@ -0,0 +1,84 @@ +package com.refinedmods.refinedstorage.integration.jei; + +import com.refinedmods.refinedstorage.RSItems; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; +import com.refinedmods.refinedstorage.item.CoverItem; +import com.refinedmods.refinedstorage.recipe.CoverRecipe; +import mezz.jei.api.constants.VanillaTypes; +import mezz.jei.api.gui.IRecipeLayout; +import mezz.jei.api.ingredients.IIngredients; +import mezz.jei.api.recipe.category.extensions.vanilla.crafting.ICraftingCategoryExtension; +import mezz.jei.api.recipe.category.extensions.vanilla.crafting.ICustomCraftingCategoryExtension; +import net.minecraft.block.Block; +import net.minecraft.block.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemGroup; +import net.minecraft.item.ItemStack; +import net.minecraft.item.Items; +import net.minecraft.util.NonNullList; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.common.Tags; +import net.minecraftforge.common.util.Size2i; +import net.minecraftforge.registries.ForgeRegistries; + +import javax.annotation.Nullable; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + +public class CoverCraftingCategoryExtension implements ICustomCraftingCategoryExtension { + + @Override + public void setIngredients(IIngredients ingredients) { + List input = new ArrayList<>(); + List output = new ArrayList<>(); + for (Block block : ForgeRegistries.BLOCKS.getValues()) { + Item item = Item.getItemFromBlock(block); + if (item == Items.AIR) { + continue; + } + NonNullList subBlocks = NonNullList.create(); + block.fillItemGroup(ItemGroup.SEARCH, subBlocks); + for (ItemStack subBlock : subBlocks) { + if (CoverManager.isValidCover(subBlock)) { + input.add(subBlock); + ItemStack stack = new ItemStack(RSItems.COVER.get()); + CoverItem.setItem(stack, subBlock); + output.add(stack); + } + } + } + ingredients.setInputLists(VanillaTypes.ITEM, Arrays.asList(Tags.Items.NUGGETS_IRON.getAllElements().stream().map(ItemStack::new).collect(Collectors.toList()), input)); + ingredients.setOutputs(VanillaTypes.ITEM, output); + } + + @Nullable + @Override + public Size2i getSize() { + return new Size2i(2, 1); + } + + @Nullable + @Override + public ResourceLocation getRegistryName() { + return CoverRecipe.SERIALIZER.getRegistryName(); + } + + @Override + public void setRecipe(IRecipeLayout recipeLayout, IIngredients ingredients) { + ItemStack stack = recipeLayout.getFocus(VanillaTypes.ITEM).getValue(); + if (stack.getItem() instanceof CoverItem){ + recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(4, Tags.Items.NUGGETS_IRON.getAllElements().stream().map(ItemStack::new).collect(Collectors.toList())); + recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(5, CoverItem.getItem(stack)); + recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(0, stack); + }else { + recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(4, Tags.Items.NUGGETS_IRON.getAllElements().stream().map(ItemStack::new).collect(Collectors.toList())); + recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(5, stack); + ItemStack output = new ItemStack(RSItems.COVER.get()); + CoverItem.setItem(output, stack); + recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(0, output); + } + + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/integration/jei/HollowCoverCraftingCategoryExtension.java b/src/main/java/com/refinedmods/refinedstorage/integration/jei/HollowCoverCraftingCategoryExtension.java new file mode 100644 index 000000000..cc0b3f9d8 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/integration/jei/HollowCoverCraftingCategoryExtension.java @@ -0,0 +1,67 @@ +package com.refinedmods.refinedstorage.integration.jei; + +import com.refinedmods.refinedstorage.RSItems; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; +import com.refinedmods.refinedstorage.item.CoverItem; +import com.refinedmods.refinedstorage.recipe.CoverRecipe; +import com.refinedmods.refinedstorage.recipe.HollowCoverRecipe; +import mezz.jei.api.constants.VanillaTypes; +import mezz.jei.api.gui.IRecipeLayout; +import mezz.jei.api.ingredients.IIngredients; +import mezz.jei.api.recipe.category.extensions.vanilla.crafting.ICustomCraftingCategoryExtension; +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ItemGroup; +import net.minecraft.item.ItemStack; +import net.minecraft.item.Items; +import net.minecraft.util.NonNullList; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.common.Tags; +import net.minecraftforge.common.util.Size2i; +import net.minecraftforge.registries.ForgeRegistries; + +import javax.annotation.Nullable; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + +public class HollowCoverCraftingCategoryExtension implements ICustomCraftingCategoryExtension { + + @Override + public void setIngredients(IIngredients ingredients) { + ingredients.setInput(VanillaTypes.ITEM, new ItemStack(RSItems.COVER.get())); + ingredients.setOutput(VanillaTypes.ITEM, new ItemStack(RSItems.HOLLOW_COVER.get())); + } + + @Nullable + @Override + public Size2i getSize() { + return new Size2i(2, 1); + } + + @Nullable + @Override + public ResourceLocation getRegistryName() { + return HollowCoverRecipe.SERIALIZER.getRegistryName(); + } + + @Override + public void setRecipe(IRecipeLayout recipeLayout, IIngredients ingredients) { + ItemStack stack = recipeLayout.getFocus(VanillaTypes.ITEM).getValue(); + + if (stack.getItem() == RSItems.COVER.get()){ + recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(5, stack); + ItemStack output = new ItemStack(RSItems.HOLLOW_COVER.get()); + CoverItem.setItem(output, CoverItem.getItem(stack)); + recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(0, output); + }else { + ItemStack input = new ItemStack(RSItems.COVER.get()); + CoverItem.setItem(input, CoverItem.getItem(stack)); + recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(5, input); + + recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(0, stack); + } + + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/integration/jei/RSJeiPlugin.java b/src/main/java/com/refinedmods/refinedstorage/integration/jei/RSJeiPlugin.java index 4c5ab5abd..87185dfb7 100644 --- a/src/main/java/com/refinedmods/refinedstorage/integration/jei/RSJeiPlugin.java +++ b/src/main/java/com/refinedmods/refinedstorage/integration/jei/RSJeiPlugin.java @@ -2,15 +2,18 @@ package com.refinedmods.refinedstorage.integration.jei; import com.refinedmods.refinedstorage.RS; import com.refinedmods.refinedstorage.RSItems; +import com.refinedmods.refinedstorage.recipe.CoverRecipe; +import com.refinedmods.refinedstorage.recipe.HollowCoverRecipe; import com.refinedmods.refinedstorage.screen.BaseScreen; import mezz.jei.api.IModPlugin; import mezz.jei.api.JeiPlugin; -import mezz.jei.api.registration.IGuiHandlerRegistration; -import mezz.jei.api.registration.IRecipeTransferRegistration; -import mezz.jei.api.registration.ISubtypeRegistration; +import mezz.jei.api.constants.VanillaRecipeCategoryUid; +import mezz.jei.api.registration.*; import mezz.jei.api.runtime.IJeiRuntime; import net.minecraft.util.ResourceLocation; +import java.util.Collections; + @JeiPlugin public class RSJeiPlugin implements IModPlugin { private static final ResourceLocation ID = new ResourceLocation(RS.ID, "plugin"); @@ -46,4 +49,10 @@ public class RSJeiPlugin implements IModPlugin { public void registerItemSubtypes(ISubtypeRegistration registration) { registration.useNbtForSubtypes(RSItems.COVER.get(), RSItems.HOLLOW_COVER.get()); } + + @Override + public void registerVanillaCategoryExtensions(IVanillaCategoryExtensionRegistration registration) { + registration.getCraftingCategory().addCategoryExtension(CoverRecipe.class, (cover) -> new CoverCraftingCategoryExtension()); + registration.getCraftingCategory().addCategoryExtension(HollowCoverRecipe.class, (cover) -> new HollowCoverCraftingCategoryExtension()); + } } diff --git a/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java b/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java index 771bf1c5b..761588cbe 100644 --- a/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java +++ b/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java @@ -21,6 +21,8 @@ import net.minecraft.util.Direction; import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.util.text.ITextComponent; +import net.minecraft.util.text.TextComponent; +import net.minecraft.util.text.TextFormatting; import net.minecraft.world.World; import net.minecraft.world.server.ServerWorld; import net.minecraftforge.client.model.ModelDataManager; @@ -45,8 +47,9 @@ public class CoverItem extends Item { if (!cover.hasTag()) { cover.setTag(new CompoundNBT()); } - - cover.getTag().put(NBT_ITEM, item.serializeNBT()); + ItemStack result = item.copy(); + result.setCount(1); + cover.getTag().put(NBT_ITEM, result.serializeNBT()); } @Nonnull @@ -64,7 +67,7 @@ public class CoverItem extends Item { ItemStack item = getItem(stack); if (!item.isEmpty()) { - tooltip.add(item.getItem().getDisplayName(item)); + tooltip.add(((TextComponent)item.getItem().getDisplayName(item)).mergeStyle(TextFormatting.GRAY)); } } diff --git a/src/main/java/com/refinedmods/refinedstorage/recipe/CoverRecipe.java b/src/main/java/com/refinedmods/refinedstorage/recipe/CoverRecipe.java new file mode 100644 index 000000000..01d055a38 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/recipe/CoverRecipe.java @@ -0,0 +1,111 @@ +package com.refinedmods.refinedstorage.recipe; + + +import com.google.common.collect.Lists; +import com.refinedmods.refinedstorage.RSItems; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; +import com.refinedmods.refinedstorage.item.CoverItem; +import com.refinedmods.refinedstorage.item.WrenchItem; +import net.minecraft.inventory.CraftingInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.IRecipeSerializer; +import net.minecraft.item.crafting.SpecialRecipe; +import net.minecraft.item.crafting.SpecialRecipeSerializer; +import net.minecraft.tags.ItemTags; +import net.minecraft.util.ResourceLocation; +import net.minecraft.world.World; +import net.minecraftforge.common.Tags; + +import java.util.List; + +public class CoverRecipe extends SpecialRecipe { + + public static IRecipeSerializer SERIALIZER = new SpecialRecipeSerializer<>(CoverRecipe::new); + + public CoverRecipe(ResourceLocation idIn) { + super(idIn); + } + + public static boolean stackMatches(ItemStack first) { + return CoverManager.isValidCover(first); + } + + public static boolean matches(List list) { + return list.size() == 2; + } + + public static ItemStack getResult(List list) { + if (list.size() == 2) { + ItemStack first = list.get(0); + ItemStack second = list.get(1); + return getResult(first, second); + } + return ItemStack.EMPTY; + } + + public static ItemStack getResult(ItemStack first, ItemStack second){ + if (first.getItem().isIn(Tags.Items.NUGGETS_IRON)){ + ItemStack stack = new ItemStack(RSItems.COVER.get()); + CoverItem.setItem(stack, second); + stack.setCount(6); + return stack; + } + if (second.getItem().isIn(Tags.Items.NUGGETS_IRON)){ + ItemStack stack = new ItemStack(RSItems.COVER.get()); + CoverItem.setItem(stack, first); + stack.setCount(6); + return stack; + } + return ItemStack.EMPTY; + } + + @Override + public boolean matches(CraftingInventory inv, World worldIn) { + List list = Lists.newArrayList(); + int ingots = 0; + for (int i = 0; i < inv.getSizeInventory(); ++i) { + ItemStack itemstack = inv.getStackInSlot(i); + if (!itemstack.isEmpty()) { + list.add(itemstack); + if (itemstack.getItem().isIn(Tags.Items.NUGGETS_IRON)){ + ++ingots; + } else if (!stackMatches(itemstack)){ + return false; + } + } + } + return matches(list) && ingots == 1; + } + + @Override + public ItemStack getCraftingResult(CraftingInventory inv) { + List list = Lists.newArrayList(); + int ingots = 0; + for (int i = 0; i < inv.getSizeInventory(); ++i) { + ItemStack itemstack = inv.getStackInSlot(i); + if (!itemstack.isEmpty()) { + list.add(itemstack); + if (itemstack.getItem().isIn(Tags.Items.NUGGETS_IRON)){ + ++ingots; + } else if (!stackMatches(itemstack)){ + return ItemStack.EMPTY; + } + } + } + if (ingots > 1){ + return ItemStack.EMPTY; + } + return getResult(list); + } + + @Override + public boolean canFit(int width, int height) { + return width * height >= 2; + } + + @Override + public IRecipeSerializer getSerializer() { + return SERIALIZER; + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/recipe/HollowCoverRecipe.java b/src/main/java/com/refinedmods/refinedstorage/recipe/HollowCoverRecipe.java new file mode 100644 index 000000000..e7cdd997a --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/recipe/HollowCoverRecipe.java @@ -0,0 +1,89 @@ +package com.refinedmods.refinedstorage.recipe; + + +import com.google.common.collect.Lists; +import com.refinedmods.refinedstorage.RSItems; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; +import com.refinedmods.refinedstorage.item.CoverItem; +import net.minecraft.inventory.CraftingInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.IRecipeSerializer; +import net.minecraft.item.crafting.SpecialRecipe; +import net.minecraft.item.crafting.SpecialRecipeSerializer; +import net.minecraft.util.ResourceLocation; +import net.minecraft.world.World; +import net.minecraftforge.common.Tags; + +import java.util.List; + +public class HollowCoverRecipe extends SpecialRecipe { + + public static IRecipeSerializer SERIALIZER = new SpecialRecipeSerializer<>(HollowCoverRecipe::new); + + public HollowCoverRecipe(ResourceLocation idIn) { + super(idIn); + } + + public static boolean stackMatches(ItemStack first) { + return first.getItem() == RSItems.COVER.get(); + } + + public static boolean matches(List list) { + return list.size() == 1; + } + + public static ItemStack getResult(List list) { + if (list.size() == 1) { + ItemStack first = list.get(0); + return getResult(first); + } + return ItemStack.EMPTY; + } + + public static ItemStack getResult(ItemStack first){ + ItemStack stack = CoverItem.getItem(first); + ItemStack result = new ItemStack(RSItems.HOLLOW_COVER.get()); + CoverItem.setItem(result, stack); + return result; + } + + @Override + public boolean matches(CraftingInventory inv, World worldIn) { + List list = Lists.newArrayList(); + for (int i = 0; i < inv.getSizeInventory(); ++i) { + ItemStack itemstack = inv.getStackInSlot(i); + if (!itemstack.isEmpty()) { + list.add(itemstack); + if (!stackMatches(itemstack)){ + return false; + } + } + } + return matches(list); + } + + @Override + public ItemStack getCraftingResult(CraftingInventory inv) { + List list = Lists.newArrayList(); + for (int i = 0; i < inv.getSizeInventory(); ++i) { + ItemStack itemstack = inv.getStackInSlot(i); + if (!itemstack.isEmpty()) { + list.add(itemstack); + if (!stackMatches(itemstack)){ + return ItemStack.EMPTY; + } + } + } + return getResult(list); + } + + @Override + public boolean canFit(int width, int height) { + return width * height >= 2; + } + + @Override + public IRecipeSerializer getSerializer() { + return SERIALIZER; + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/setup/CommonSetup.java b/src/main/java/com/refinedmods/refinedstorage/setup/CommonSetup.java index 6242f2797..6d9aa8b3a 100644 --- a/src/main/java/com/refinedmods/refinedstorage/setup/CommonSetup.java +++ b/src/main/java/com/refinedmods/refinedstorage/setup/CommonSetup.java @@ -35,6 +35,8 @@ import com.refinedmods.refinedstorage.container.factory.*; import com.refinedmods.refinedstorage.integration.craftingtweaks.CraftingTweaksIntegration; import com.refinedmods.refinedstorage.integration.inventorysorter.InventorySorterIntegration; import com.refinedmods.refinedstorage.item.blockitem.PortableGridBlockItem; +import com.refinedmods.refinedstorage.recipe.CoverRecipe; +import com.refinedmods.refinedstorage.recipe.HollowCoverRecipe; import com.refinedmods.refinedstorage.recipe.UpgradeWithEnchantedBookRecipeSerializer; import com.refinedmods.refinedstorage.tile.*; import com.refinedmods.refinedstorage.tile.craftingmonitor.CraftingMonitorTile; @@ -46,6 +48,7 @@ import net.minecraft.item.crafting.IRecipeSerializer; import net.minecraft.nbt.CompoundNBT; import net.minecraft.tileentity.TileEntity; import net.minecraft.tileentity.TileEntityType; +import net.minecraft.util.ResourceLocation; import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.common.extensions.IForgeContainerType; import net.minecraftforge.event.RegistryEvent; @@ -141,6 +144,8 @@ public class CommonSetup { @SubscribeEvent public void onRegisterRecipeSerializers(RegistryEvent.Register> e) { e.getRegistry().register(new UpgradeWithEnchantedBookRecipeSerializer().setRegistryName(RS.ID, "upgrade_with_enchanted_book")); + e.getRegistry().register(CoverRecipe.SERIALIZER.setRegistryName(new ResourceLocation(RS.ID, "cover_recipe"))); + e.getRegistry().register(HollowCoverRecipe.SERIALIZER.setRegistryName(new ResourceLocation(RS.ID, "hollow_cover_recipe"))); } @SubscribeEvent diff --git a/src/main/resources/data/refinedstorage/recipes/cover.json b/src/main/resources/data/refinedstorage/recipes/cover.json new file mode 100644 index 000000000..51760e5ee --- /dev/null +++ b/src/main/resources/data/refinedstorage/recipes/cover.json @@ -0,0 +1,3 @@ +{ + "type": "refinedstorage:cover_recipe" +} \ No newline at end of file diff --git a/src/main/resources/data/refinedstorage/recipes/hollow_cover.json b/src/main/resources/data/refinedstorage/recipes/hollow_cover.json new file mode 100644 index 000000000..489454aee --- /dev/null +++ b/src/main/resources/data/refinedstorage/recipes/hollow_cover.json @@ -0,0 +1,3 @@ +{ + "type": "refinedstorage:hollow_cover_recipe" +} \ No newline at end of file From b187baeb767a0b269a348ab25c1d07cd5fd5c8ef Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Sat, 11 Sep 2021 20:19:40 +0200 Subject: [PATCH 08/18] Added config to hide all the covers from JEI --- .../refinedstorage/config/ClientConfig.java | 22 ++++++++++++++++++- .../refinedstorage/item/CoverItem.java | 19 ++++++++-------- 2 files changed, 30 insertions(+), 11 deletions(-) diff --git a/src/main/java/com/refinedmods/refinedstorage/config/ClientConfig.java b/src/main/java/com/refinedmods/refinedstorage/config/ClientConfig.java index 2e529c2a1..c03e34721 100644 --- a/src/main/java/com/refinedmods/refinedstorage/config/ClientConfig.java +++ b/src/main/java/com/refinedmods/refinedstorage/config/ClientConfig.java @@ -8,11 +8,12 @@ public class ClientConfig { private final Grid grid; private final CrafterManager crafterManager; + private final Cover cover; public ClientConfig() { grid = new Grid(); crafterManager = new CrafterManager(); - + cover = new Cover(); spec = builder.build(); } @@ -28,6 +29,10 @@ public class ClientConfig { return crafterManager; } + public Cover getCover() { + return cover; + } + public class Grid { private final ForgeConfigSpec.IntValue maxRowsStretch; private final ForgeConfigSpec.BooleanValue detailedTooltip; @@ -83,4 +88,19 @@ public class ClientConfig { return maxRowsStretch.get(); } } + + public class Cover{ + + private final ForgeConfigSpec.BooleanValue showAllCoversInJEI; + + public Cover() { + builder.push("cover"); + showAllCoversInJEI = builder.comment("When true all the possible covers will be added to JEI (Game restart required)").define("showAllCoversInJEI", true); + builder.pop(); + } + + public boolean showAllRecipesInJEI() { + return showAllCoversInJEI.get(); + } + } } diff --git a/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java b/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java index 761588cbe..740cc5871 100644 --- a/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java +++ b/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java @@ -73,17 +73,16 @@ public class CoverItem extends Item { @Override public void fillItemGroup(ItemGroup group, NonNullList items) { - - //if (RS.INSTANCE.config.hideCovers) { - // ItemStack stack = new ItemStack(this); - - //setItem(stack, HIDDEN_COVER_ALTERNATIVE); - - //items.add(stack); - - //return; - //} if (this.isInGroup(group)) { + if (!RS.CLIENT_CONFIG.getCover().showAllRecipesInJEI()) { + ItemStack stack = new ItemStack(this); + + setItem(stack, HIDDEN_COVER_ALTERNATIVE); + + items.add(stack); + + return; + } for (Block block : ForgeRegistries.BLOCKS.getValues()) { Item item = Item.getItemFromBlock(block); From 1c06b87c1d187b5d610e22d0cb4b089f905834e4 Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Sat, 11 Sep 2021 20:53:40 +0200 Subject: [PATCH 09/18] Improved TextureAtlasSprite discovery so each side of the cover renders the proper side of the block --- .../render/model/BakedModelCableCover.java | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java b/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java index e21eeebf6..5db3a1c1e 100644 --- a/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java +++ b/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java @@ -23,6 +23,7 @@ import net.minecraftforge.client.model.data.IModelData; import javax.annotation.Nullable; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; import java.util.Random; @@ -92,19 +93,17 @@ public class BakedModelCableCover extends DelegateBakedModel{ hasWest = manager.hasCover(Direction.WEST); } - TextureAtlasSprite sprite = RenderUtils.getSprite(Minecraft.getInstance().getBlockRendererDispatcher().getModelForState(coverState), coverState, side, rand); - switch (cover.getType()) { case NORMAL: - addNormalCover(quads, sprite, coverSide, hasUp, hasDown, hasEast, hasWest, handle); + addNormalCover(quads, coverState, coverSide, hasUp, hasDown, hasEast, hasWest, handle, rand); break; case HOLLOW: - addHollowCover(quads, sprite, coverSide, hasUp, hasDown, hasEast, hasWest, getHollowCoverSize(state, coverSide)); + addHollowCover(quads, coverState, coverSide, hasUp, hasDown, hasEast, hasWest, getHollowCoverSize(state, coverSide), rand); break; } } - private static void addNormalCover(List quads, TextureAtlasSprite sprite, Direction coverSide, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest, boolean handle) { + private static void addNormalCover(List quads, BlockState state, Direction coverSide, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest, boolean handle, Random random) { AxisAlignedBB bounds = ConstantsCable.getCoverBounds(coverSide); Vector3f from = new Vector3f((float) bounds.minX * 16, (float) bounds.minY * 16, (float) bounds.minZ * 16); @@ -138,7 +137,8 @@ public class BakedModelCableCover extends DelegateBakedModel{ } } - quads.addAll(new CubeBuilder().from(from.getX(), from.getY(), from.getZ()).to(to.getX(), to.getY(), to.getZ()).addFaces(face -> new CubeBuilder.Face(face, sprite)).bake()); + HashMap spriteCache = new HashMap<>(); + quads.addAll(new CubeBuilder().from(from.getX(), from.getY(), from.getZ()).to(to.getX(), to.getY(), to.getZ()).addFaces(face -> new CubeBuilder.Face(face, spriteCache.computeIfAbsent(face, direction -> RenderUtils.getSprite(Minecraft.getInstance().getBlockRendererDispatcher().getModelForState(state), state, direction, random)))).bake()); if (handle) { if (BORDER_SPRITE == null) { @@ -154,7 +154,7 @@ public class BakedModelCableCover extends DelegateBakedModel{ } } - private static void addHollowCover(List quads, TextureAtlasSprite sprite, Direction coverSide, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest, int size) { + private static void addHollowCover(List quads, BlockState state, Direction coverSide, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest, int size, Random random) { AxisAlignedBB bounds = ConstantsCable.getCoverBounds(coverSide); Vector3f from = new Vector3f((float) bounds.minX * 16, (float) bounds.minY * 16, (float) bounds.minZ * 16); @@ -197,11 +197,11 @@ public class BakedModelCableCover extends DelegateBakedModel{ from.setZ(16 - size); to.setZ(16); } - + HashMap spriteCache = new HashMap<>(); quads.addAll(new CubeBuilder() .from(from.getX(), from.getY(), from.getZ()) .to(to.getX(), to.getY(), to.getZ()) - .addFaces(face -> new CubeBuilder.Face(face, sprite)) + .addFaces(face -> new CubeBuilder.Face(face, spriteCache.computeIfAbsent(face, direction -> RenderUtils.getSprite(Minecraft.getInstance().getBlockRendererDispatcher().getModelForState(state), state, direction, random)))) .bake() ); @@ -236,7 +236,7 @@ public class BakedModelCableCover extends DelegateBakedModel{ quads.addAll(new CubeBuilder() .from(from.getX(), from.getY(), from.getZ()) .to(to.getX(), to.getY(), to.getZ()) - .addFaces(face -> new CubeBuilder.Face(face, sprite)) + .addFaces(face -> new CubeBuilder.Face(face, spriteCache.computeIfAbsent(face, direction -> RenderUtils.getSprite(Minecraft.getInstance().getBlockRendererDispatcher().getModelForState(state), state, direction, random)))) .bake() ); @@ -296,7 +296,7 @@ public class BakedModelCableCover extends DelegateBakedModel{ quads.addAll(new CubeBuilder() .from(from.getX(), from.getY(), from.getZ()) .to(to.getX(), to.getY(), to.getZ()) - .addFaces(face -> new CubeBuilder.Face(face, sprite)) + .addFaces(face -> new CubeBuilder.Face(face, spriteCache.computeIfAbsent(face, direction -> RenderUtils.getSprite(Minecraft.getInstance().getBlockRendererDispatcher().getModelForState(state), state, direction, random)))) .bake() ); @@ -356,7 +356,7 @@ public class BakedModelCableCover extends DelegateBakedModel{ quads.addAll(new CubeBuilder() .from(from.getX(), from.getY(), from.getZ()) .to(to.getX(), to.getY(), to.getZ()) - .addFaces(face -> new CubeBuilder.Face(face, sprite)) + .addFaces(face -> new CubeBuilder.Face(face, spriteCache.computeIfAbsent(face, direction -> RenderUtils.getSprite(Minecraft.getInstance().getBlockRendererDispatcher().getModelForState(state), state, direction, random)))) .bake() ); } From f555f378dbdc2d0ac81fb1f4d39fabd24c001032 Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Sun, 12 Sep 2021 12:03:57 +0200 Subject: [PATCH 10/18] Fixed cables not connecting to things that dont support covers --- .../refinedstorage/apiimpl/network/node/cover/CoverManager.java | 1 - .../java/com/refinedmods/refinedstorage/block/CableBlock.java | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java index 977b16b4a..37b7ae91e 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java @@ -90,7 +90,6 @@ public class CoverManager { public void readFromNbt(CompoundNBT nbt) { covers.clear(); - System.out.println(nbt); for (String s : nbt.keySet()) { CompoundNBT tag = nbt.getCompound(s); if (tag.contains(NBT_DIRECTION) && tag.contains(NBT_ITEM)) { diff --git a/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java index c19bc0bea..bfb46e3ed 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java @@ -169,7 +169,7 @@ public class CableBlock extends NetworkNodeBlock implements IWaterLoggable { if (tile == null){ return false; } - return tile.getCapability(NetworkNodeProxyCapability.NETWORK_NODE_PROXY_CAPABILITY, direction).map(INetworkNodeProxy::getNode).map(iNetworkNode -> iNetworkNode instanceof ICoverable && (!((ICoverable) iNetworkNode).getCoverManager().hasCover(direction) || ((ICoverable) iNetworkNode).getCoverManager().getCover(direction).getType() == CoverType.HOLLOW)).orElse(false); + return tile.getCapability(NetworkNodeProxyCapability.NETWORK_NODE_PROXY_CAPABILITY, direction).map(INetworkNodeProxy::getNode).map(iNetworkNode -> !(iNetworkNode instanceof ICoverable) || (!((ICoverable) iNetworkNode).getCoverManager().hasCover(direction) || ((ICoverable) iNetworkNode).getCoverManager().getCover(direction).getType() == CoverType.HOLLOW)).orElse(false); } private BlockState getState(BlockState currentState, IWorld world, BlockPos pos) { From 499fd5b26173a9beb755b32970cb7317e6defbc2 Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Sun, 12 Sep 2021 14:59:25 +0200 Subject: [PATCH 11/18] Importers and Exporters support covers --- .../network/node/CableNetworkNode.java | 6 --- .../network/node/ExporterNetworkNode.java | 17 +++++-- .../network/node/ImporterNetworkNode.java | 16 +++++-- .../refinedstorage/block/ExporterBlock.java | 7 +-- .../refinedstorage/block/ImporterBlock.java | 6 +-- .../refinedstorage/setup/ClientSetup.java | 2 + .../refinedstorage/tile/CableTile.java | 6 ++- .../refinedstorage/tile/ExporterTile.java | 45 ++++++++++++++++++ .../refinedstorage/tile/ImporterTile.java | 46 +++++++++++++++++++ 9 files changed, 130 insertions(+), 21 deletions(-) diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/CableNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/CableNetworkNode.java index 3476316b4..f39b2ba3a 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/CableNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/CableNetworkNode.java @@ -40,12 +40,6 @@ public class CableNetworkNode extends NetworkNode implements ICoverable { super.read(tag); } - @Override - public void update() { - super.update(); - //WorldUtils.updateBlock(world, pos); - } - @Override public CompoundNBT write(CompoundNBT tag) { tag.put("Cover", this.coverManager.writeToNbt()); diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExporterNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExporterNetworkNode.java index be8c15f04..381778e42 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExporterNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExporterNetworkNode.java @@ -1,9 +1,11 @@ package com.refinedmods.refinedstorage.apiimpl.network.node; import com.refinedmods.refinedstorage.RS; +import com.refinedmods.refinedstorage.api.network.node.ICoverable; import com.refinedmods.refinedstorage.api.util.Action; import com.refinedmods.refinedstorage.api.util.IComparer; import com.refinedmods.refinedstorage.apiimpl.API; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; import com.refinedmods.refinedstorage.inventory.fluid.FluidInventory; import com.refinedmods.refinedstorage.inventory.item.BaseItemHandler; import com.refinedmods.refinedstorage.inventory.item.UpgradeItemHandler; @@ -27,7 +29,7 @@ import net.minecraftforge.items.IItemHandler; import net.minecraftforge.items.IItemHandlerModifiable; import net.minecraftforge.items.ItemHandlerHelper; -public class ExporterNetworkNode extends NetworkNode implements IComparable, IType { +public class ExporterNetworkNode extends NetworkNode implements IComparable, IType, ICoverable { public static final ResourceLocation ID = new ResourceLocation(RS.ID, "exporter"); private static final String NBT_COMPARE = "Compare"; @@ -72,8 +74,11 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy private int filterSlot; + private CoverManager coverManager; + public ExporterNetworkNode(World world, BlockPos pos) { super(world, pos); + this.coverManager = new CoverManager(this); } @Override @@ -244,9 +249,8 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy @Override public CompoundNBT write(CompoundNBT tag) { super.write(tag); - + tag.put("Cover", this.coverManager.writeToNbt()); StackUtils.writeItems(upgrades, 1, tag); - return tag; } @@ -267,7 +271,7 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy @Override public void read(CompoundNBT tag) { super.read(tag); - + if (tag.contains("Cover")) this.coverManager.readFromNbt(tag.getCompound("Cover")); StackUtils.readItems(upgrades, 1, tag); } @@ -320,4 +324,9 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy public FluidInventory getFluidFilters() { return fluidFilters; } + + @Override + public CoverManager getCoverManager() { + return coverManager; + } } diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ImporterNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ImporterNetworkNode.java index bb79f79c8..102e81b09 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ImporterNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ImporterNetworkNode.java @@ -1,8 +1,10 @@ package com.refinedmods.refinedstorage.apiimpl.network.node; import com.refinedmods.refinedstorage.RS; +import com.refinedmods.refinedstorage.api.network.node.ICoverable; import com.refinedmods.refinedstorage.api.util.Action; import com.refinedmods.refinedstorage.api.util.IComparer; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; import com.refinedmods.refinedstorage.inventory.fluid.FluidInventory; import com.refinedmods.refinedstorage.inventory.item.BaseItemHandler; import com.refinedmods.refinedstorage.inventory.item.UpgradeItemHandler; @@ -28,7 +30,7 @@ import net.minecraftforge.fluids.capability.IFluidHandler; import net.minecraftforge.items.IItemHandler; import net.minecraftforge.items.IItemHandlerModifiable; -public class ImporterNetworkNode extends NetworkNode implements IComparable, IWhitelistBlacklist, IType { +public class ImporterNetworkNode extends NetworkNode implements IComparable, IWhitelistBlacklist, IType, ICoverable { public static final ResourceLocation ID = new ResourceLocation(RS.ID, "importer"); private static final String NBT_COMPARE = "Compare"; @@ -47,8 +49,11 @@ public class ImporterNetworkNode extends NetworkNode implements IComparable, IWh private int currentSlot; + private CoverManager coverManager; + public ImporterNetworkNode(World world, BlockPos pos) { super(world, pos); + this.coverManager = new CoverManager(this); } @Override @@ -148,7 +153,7 @@ public class ImporterNetworkNode extends NetworkNode implements IComparable, IWh @Override public void read(CompoundNBT tag) { super.read(tag); - + if (tag.contains("Cover")) this.coverManager.readFromNbt(tag.getCompound("Cover")); StackUtils.readItems(upgrades, 1, tag); } @@ -160,7 +165,7 @@ public class ImporterNetworkNode extends NetworkNode implements IComparable, IWh @Override public CompoundNBT write(CompoundNBT tag) { super.write(tag); - + tag.put("Cover", this.coverManager.writeToNbt()); StackUtils.writeItems(upgrades, 1, tag); return tag; @@ -234,4 +239,9 @@ public class ImporterNetworkNode extends NetworkNode implements IComparable, IWh public FluidInventory getFluidFilters() { return fluidFilters; } + + @Override + public CoverManager getCoverManager() { + return coverManager; + } } diff --git a/src/main/java/com/refinedmods/refinedstorage/block/ExporterBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/ExporterBlock.java index 26703e67a..ea67fcbd8 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/ExporterBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/ExporterBlock.java @@ -69,15 +69,16 @@ public class ExporterBlock extends CableBlock { @Override public VoxelShape getShape(BlockState state, IBlockReader world, BlockPos pos, ISelectionContext ctx) { - return ShapeCache.getOrCreate(state, s -> { + return ConstantsCable.addCoverVoxelShapes(ShapeCache.getOrCreate(state, s -> { VoxelShape shape = getCableShape(s); shape = VoxelShapes.or(shape, getLineShape(s)); - return ConstantsCable.addCoverVoxelShapes(shape, world, pos); - }); + return shape; + }), world, pos); } + private VoxelShape getLineShape(BlockState state) { Direction direction = state.get(getDirection().getProperty()); diff --git a/src/main/java/com/refinedmods/refinedstorage/block/ImporterBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/ImporterBlock.java index aeb86c061..7df60ec7f 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/ImporterBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/ImporterBlock.java @@ -69,13 +69,13 @@ public class ImporterBlock extends CableBlock { @Override public VoxelShape getShape(BlockState state, IBlockReader world, BlockPos pos, ISelectionContext ctx) { - return ShapeCache.getOrCreate(state, s -> { + return ConstantsCable.addCoverVoxelShapes(ShapeCache.getOrCreate(state, s -> { VoxelShape shape = getCableShape(s); shape = VoxelShapes.or(shape, getLineShape(s)); - return ConstantsCable.addCoverVoxelShapes(shape, world, pos); - }); + return shape; + }), world, pos); } private VoxelShape getLineShape(BlockState state) { diff --git a/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java b/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java index 323e3e418..e8e912b8d 100644 --- a/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java +++ b/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java @@ -112,6 +112,8 @@ public class ClientSetup { new ResourceLocation(RS.ID, "block/disks/leds") )); bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "cable"), (base, registry) -> new BakedModelCableCover(base)); + bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "exporter"), (base, registry) -> new BakedModelCableCover(base)); + bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "importer"), (base, registry) -> new BakedModelCableCover(base)); bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "cover"), (base, registry) -> new BakedModelCover(ItemStack.EMPTY, CoverType.NORMAL)); bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "hollow_cover"), (base, registry) -> new BakedModelCover(ItemStack.EMPTY, CoverType.HOLLOW)); diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java index e482637c1..1dc5c96c2 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java @@ -30,8 +30,10 @@ import java.util.HashMap; public class CableTile extends NetworkNodeTile { - public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), t -> t.getNode().getCoverManager().writeToNbt(), (t, v) -> t.getNode().getCoverManager().readFromNbt(v), (initial, p) -> Minecraft.getInstance().enqueue(() -> { - + public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), + t -> t.getNode().getCoverManager().writeToNbt(), + (t, v) -> t.getNode().getCoverManager().readFromNbt(v), + (initial, p) -> Minecraft.getInstance().enqueue(() -> { })); static { diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/ExporterTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/ExporterTile.java index 81637b2cf..78c9a3630 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/ExporterTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/ExporterTile.java @@ -2,23 +2,43 @@ package com.refinedmods.refinedstorage.tile; import com.refinedmods.refinedstorage.RSTiles; import com.refinedmods.refinedstorage.apiimpl.network.node.ExporterNetworkNode; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; import com.refinedmods.refinedstorage.tile.config.IComparable; import com.refinedmods.refinedstorage.tile.config.IType; +import com.refinedmods.refinedstorage.tile.data.TileDataManager; import com.refinedmods.refinedstorage.tile.data.TileDataParameter; +import com.refinedmods.refinedstorage.util.WorldUtils; +import net.minecraft.client.Minecraft; +import net.minecraft.nbt.CompoundNBT; +import net.minecraft.network.datasync.DataSerializers; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import net.minecraftforge.client.model.data.IModelData; +import net.minecraftforge.client.model.data.ModelDataMap; import javax.annotation.Nonnull; public class ExporterTile extends NetworkNodeTile { + + public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), + t -> t.getNode().getCoverManager().writeToNbt(), + (t, v) -> t.getNode().getCoverManager().readFromNbt(v), + (initial, p) -> Minecraft.getInstance().enqueue(() -> { + })); + public static final TileDataParameter COMPARE = IComparable.createParameter(); public static final TileDataParameter TYPE = IType.createParameter(); + static { + TileDataManager.registerParameter(COVER_MANAGER); + } + public ExporterTile() { super(RSTiles.EXPORTER); dataManager.addWatchedParameter(COMPARE); dataManager.addWatchedParameter(TYPE); + dataManager.addWatchedParameter(COVER_MANAGER); } @Override @@ -26,4 +46,29 @@ public class ExporterTile extends NetworkNodeTile { public ExporterNetworkNode createNode(World world, BlockPos pos) { return new ExporterNetworkNode(world, pos); } + + @Nonnull + @Override + public IModelData getModelData() { + return new ModelDataMap.Builder().withInitial(CoverManager.PROPERTY, this.getNode().getCoverManager()).build(); + } + + @Override + public CompoundNBT writeUpdate(CompoundNBT tag) { + super.writeUpdate(tag); + tag.put("Covers", this.getNode().getCoverManager().writeToNbt()); + + return tag; + } + + @Override + public void readUpdate(CompoundNBT tag) { + super.readUpdate(tag); + + this.getNode().getCoverManager().readFromNbt(tag.getCompound("Covers")); + + requestModelDataUpdate(); + + WorldUtils.updateBlock(world, pos); + } } diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/ImporterTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/ImporterTile.java index 6f0ba7366..962b9749b 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/ImporterTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/ImporterTile.java @@ -2,12 +2,20 @@ package com.refinedmods.refinedstorage.tile; import com.refinedmods.refinedstorage.RSTiles; import com.refinedmods.refinedstorage.apiimpl.network.node.ImporterNetworkNode; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; import com.refinedmods.refinedstorage.tile.config.IComparable; import com.refinedmods.refinedstorage.tile.config.IType; import com.refinedmods.refinedstorage.tile.config.IWhitelistBlacklist; +import com.refinedmods.refinedstorage.tile.data.TileDataManager; import com.refinedmods.refinedstorage.tile.data.TileDataParameter; +import com.refinedmods.refinedstorage.util.WorldUtils; +import net.minecraft.client.Minecraft; +import net.minecraft.nbt.CompoundNBT; +import net.minecraft.network.datasync.DataSerializers; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import net.minecraftforge.client.model.data.IModelData; +import net.minecraftforge.client.model.data.ModelDataMap; import javax.annotation.Nonnull; @@ -16,12 +24,24 @@ public class ImporterTile extends NetworkNodeTile { public static final TileDataParameter WHITELIST_BLACKLIST = IWhitelistBlacklist.createParameter(); public static final TileDataParameter TYPE = IType.createParameter(); + public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), + t -> t.getNode().getCoverManager().writeToNbt(), + (t, v) -> t.getNode().getCoverManager().readFromNbt(v), + (initial, p) -> Minecraft.getInstance().enqueue(() -> { + })); + + static { + TileDataManager.registerParameter(COVER_MANAGER); + } + + public ImporterTile() { super(RSTiles.IMPORTER); dataManager.addWatchedParameter(COMPARE); dataManager.addWatchedParameter(WHITELIST_BLACKLIST); dataManager.addWatchedParameter(TYPE); + dataManager.addWatchedParameter(COVER_MANAGER); } @Override @@ -29,4 +49,30 @@ public class ImporterTile extends NetworkNodeTile { public ImporterNetworkNode createNode(World world, BlockPos pos) { return new ImporterNetworkNode(world, pos); } + + + @Nonnull + @Override + public IModelData getModelData() { + return new ModelDataMap.Builder().withInitial(CoverManager.PROPERTY, this.getNode().getCoverManager()).build(); + } + + @Override + public CompoundNBT writeUpdate(CompoundNBT tag) { + super.writeUpdate(tag); + tag.put("Covers", this.getNode().getCoverManager().writeToNbt()); + + return tag; + } + + @Override + public void readUpdate(CompoundNBT tag) { + super.readUpdate(tag); + + this.getNode().getCoverManager().readFromNbt(tag.getCompound("Covers")); + + requestModelDataUpdate(); + + WorldUtils.updateBlock(world, pos); + } } From 7cf838d7426bb3f7acf0bf2c4906e7bed10859e9 Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Sun, 12 Sep 2021 22:16:48 +0200 Subject: [PATCH 12/18] Added cover support for the constructor and destructor --- .../network/node/ConstructorNetworkNode.java | 16 ++++++- .../network/node/DestructorNetworkNode.java | 16 ++++++- .../network/node/ExporterNetworkNode.java | 4 ++ .../network/node/ImporterNetworkNode.java | 4 ++ .../block/ConstructorBlock.java | 6 +-- .../refinedstorage/block/DestructorBlock.java | 6 +-- .../refinedstorage/setup/ClientSetup.java | 4 +- .../refinedstorage/tile/CableTile.java | 3 +- .../refinedstorage/tile/ConstructorTile.java | 43 +++++++++++++++++++ .../refinedstorage/tile/DestructorTile.java | 42 ++++++++++++++++++ .../refinedstorage/tile/ExporterTile.java | 3 +- .../refinedstorage/tile/ImporterTile.java | 6 +-- 12 files changed, 135 insertions(+), 18 deletions(-) diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ConstructorNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ConstructorNetworkNode.java index 143f1392b..c4c5b6012 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ConstructorNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ConstructorNetworkNode.java @@ -1,8 +1,10 @@ package com.refinedmods.refinedstorage.apiimpl.network.node; import com.refinedmods.refinedstorage.RS; +import com.refinedmods.refinedstorage.api.network.node.ICoverable; import com.refinedmods.refinedstorage.api.util.Action; import com.refinedmods.refinedstorage.api.util.IComparer; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; import com.refinedmods.refinedstorage.inventory.fluid.FluidInventory; import com.refinedmods.refinedstorage.inventory.item.BaseItemHandler; import com.refinedmods.refinedstorage.inventory.item.UpgradeItemHandler; @@ -43,7 +45,7 @@ import net.minecraftforge.items.IItemHandlerModifiable; import javax.annotation.Nonnull; import javax.annotation.Nullable; -public class ConstructorNetworkNode extends NetworkNode implements IComparable, IType { +public class ConstructorNetworkNode extends NetworkNode implements IComparable, IType, ICoverable { public static final ResourceLocation ID = new ResourceLocation(RS.ID, "constructor"); private static final String NBT_COMPARE = "Compare"; @@ -64,8 +66,11 @@ public class ConstructorNetworkNode extends NetworkNode implements IComparable, private int type = IType.ITEMS; private boolean drop = false; + private CoverManager coverManager; + public ConstructorNetworkNode(World world, BlockPos pos) { super(world, pos); + this.coverManager = new CoverManager(this); } @Override @@ -174,6 +179,8 @@ public class ConstructorNetworkNode extends NetworkNode implements IComparable, public void read(CompoundNBT tag) { super.read(tag); + if (tag.contains("Cover")) this.coverManager.readFromNbt(tag.getCompound("Cover")); + StackUtils.readItems(upgrades, 1, tag); } @@ -186,6 +193,8 @@ public class ConstructorNetworkNode extends NetworkNode implements IComparable, public CompoundNBT write(CompoundNBT tag) { super.write(tag); + tag.put("Cover", this.coverManager.writeToNbt()); + StackUtils.writeItems(upgrades, 1, tag); return tag; @@ -268,6 +277,11 @@ public class ConstructorNetworkNode extends NetworkNode implements IComparable, return fluidFilters; } + @Override + public CoverManager getCoverManager() { + return coverManager; + } + private class NetworkFluidHandler implements IFluidHandler { private final FluidStack resource; diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/DestructorNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/DestructorNetworkNode.java index 2ad795f7c..9705edd0f 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/DestructorNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/DestructorNetworkNode.java @@ -1,8 +1,10 @@ package com.refinedmods.refinedstorage.apiimpl.network.node; import com.refinedmods.refinedstorage.RS; +import com.refinedmods.refinedstorage.api.network.node.ICoverable; import com.refinedmods.refinedstorage.api.util.Action; import com.refinedmods.refinedstorage.api.util.IComparer; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; import com.refinedmods.refinedstorage.inventory.fluid.FluidInventory; import com.refinedmods.refinedstorage.inventory.item.BaseItemHandler; import com.refinedmods.refinedstorage.inventory.item.UpgradeItemHandler; @@ -47,7 +49,7 @@ import net.minecraftforge.items.IItemHandlerModifiable; import java.util.ArrayList; import java.util.List; -public class DestructorNetworkNode extends NetworkNode implements IComparable, IWhitelistBlacklist, IType { +public class DestructorNetworkNode extends NetworkNode implements IComparable, IWhitelistBlacklist, IType, ICoverable { public static final ResourceLocation ID = new ResourceLocation(RS.ID, "destructor"); private static final String NBT_COMPARE = "Compare"; @@ -71,8 +73,11 @@ public class DestructorNetworkNode extends NetworkNode implements IComparable, I private boolean pickupItem = false; private ItemStack tool = createTool(); + private CoverManager coverManager; + public DestructorNetworkNode(World world, BlockPos pos) { super(world, pos); + this.coverManager = new CoverManager(this); } @Override @@ -250,6 +255,8 @@ public class DestructorNetworkNode extends NetworkNode implements IComparable, I public void read(CompoundNBT tag) { super.read(tag); + if (tag.contains("Cover")) this.coverManager.readFromNbt(tag.getCompound("Cover")); + StackUtils.readItems(upgrades, 1, tag); } @@ -262,6 +269,8 @@ public class DestructorNetworkNode extends NetworkNode implements IComparable, I public CompoundNBT write(CompoundNBT tag) { super.write(tag); + tag.put("Cover", this.coverManager.writeToNbt()); + StackUtils.writeItems(upgrades, 1, tag); return tag; @@ -348,4 +357,9 @@ public class DestructorNetworkNode extends NetworkNode implements IComparable, I public void setPickupItem(boolean pickupItem) { this.pickupItem = pickupItem; } + + @Override + public CoverManager getCoverManager() { + return coverManager; + } } diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExporterNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExporterNetworkNode.java index 381778e42..d19b7f4bc 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExporterNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExporterNetworkNode.java @@ -249,7 +249,9 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy @Override public CompoundNBT write(CompoundNBT tag) { super.write(tag); + tag.put("Cover", this.coverManager.writeToNbt()); + StackUtils.writeItems(upgrades, 1, tag); return tag; } @@ -271,7 +273,9 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy @Override public void read(CompoundNBT tag) { super.read(tag); + if (tag.contains("Cover")) this.coverManager.readFromNbt(tag.getCompound("Cover")); + StackUtils.readItems(upgrades, 1, tag); } diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ImporterNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ImporterNetworkNode.java index 102e81b09..35841cd00 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ImporterNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ImporterNetworkNode.java @@ -153,7 +153,9 @@ public class ImporterNetworkNode extends NetworkNode implements IComparable, IWh @Override public void read(CompoundNBT tag) { super.read(tag); + if (tag.contains("Cover")) this.coverManager.readFromNbt(tag.getCompound("Cover")); + StackUtils.readItems(upgrades, 1, tag); } @@ -165,7 +167,9 @@ public class ImporterNetworkNode extends NetworkNode implements IComparable, IWh @Override public CompoundNBT write(CompoundNBT tag) { super.write(tag); + tag.put("Cover", this.coverManager.writeToNbt()); + StackUtils.writeItems(upgrades, 1, tag); return tag; diff --git a/src/main/java/com/refinedmods/refinedstorage/block/ConstructorBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/ConstructorBlock.java index 6c00d8526..029c25788 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/ConstructorBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/ConstructorBlock.java @@ -52,13 +52,13 @@ public class ConstructorBlock extends CableBlock { @Override public VoxelShape getShape(BlockState state, IBlockReader world, BlockPos pos, ISelectionContext ctx) { - return ShapeCache.getOrCreate(state, s -> { + return ConstantsCable.addCoverVoxelShapes(ShapeCache.getOrCreate(state, s -> { VoxelShape shape = getCableShape(s); shape = VoxelShapes.or(shape, getHeadShape(s)); - return ConstantsCable.addCoverVoxelShapes(shape, world, pos); - }); + return shape; + }), world, pos); } private VoxelShape getHeadShape(BlockState state) { diff --git a/src/main/java/com/refinedmods/refinedstorage/block/DestructorBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/DestructorBlock.java index 71c25d66e..39f1fee7a 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/DestructorBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/DestructorBlock.java @@ -52,13 +52,13 @@ public class DestructorBlock extends CableBlock { @Override public VoxelShape getShape(BlockState state, IBlockReader world, BlockPos pos, ISelectionContext ctx) { - return ShapeCache.getOrCreate(state, s -> { + return ConstantsCable.addCoverVoxelShapes(ShapeCache.getOrCreate(state, s -> { VoxelShape shape = getCableShape(s); shape = VoxelShapes.or(shape, getHeadShape(s)); - return ConstantsCable.addCoverVoxelShapes(shape, world, pos); - }); + return shape; + }), world, pos); } private VoxelShape getHeadShape(BlockState state) { diff --git a/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java b/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java index e8e912b8d..44d165f9a 100644 --- a/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java +++ b/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java @@ -97,8 +97,6 @@ public class ClientSetup { "block/security_manager/cutouts/right_") ))); forEachColorApply("wireless_transmitter", (name, color) -> bakedModelOverrideRegistry.add(name, (base, registry) -> new FullbrightBakedModel(base, true, getColoredModel(color, "block/wireless_transmitter/cutouts/")))); - bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "constructor"), (base, registry) -> new FullbrightBakedModel(base, true, new ResourceLocation(RS.ID, "block/constructor/cutouts/connected"))); - bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "destructor"), (base, registry) -> new FullbrightBakedModel(base, true, new ResourceLocation(RS.ID, "block/destructor/cutouts/connected"))); bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "disk_drive"), (base, registry) -> new FullbrightBakedModel( new DiskDriveBakedModel( @@ -114,6 +112,8 @@ public class ClientSetup { bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "cable"), (base, registry) -> new BakedModelCableCover(base)); bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "exporter"), (base, registry) -> new BakedModelCableCover(base)); bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "importer"), (base, registry) -> new BakedModelCableCover(base)); + bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "constructor"), (base, registry) -> new BakedModelCableCover(new FullbrightBakedModel(base, true, new ResourceLocation(RS.ID, "block/constructor/cutouts/connected")))); + bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "destructor"), (base, registry) -> new BakedModelCableCover(new FullbrightBakedModel(base, true, new ResourceLocation(RS.ID, "block/destructor/cutouts/connected")))); bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "cover"), (base, registry) -> new BakedModelCover(ItemStack.EMPTY, CoverType.NORMAL)); bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "hollow_cover"), (base, registry) -> new BakedModelCover(ItemStack.EMPTY, CoverType.HOLLOW)); diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java index 1dc5c96c2..d84f97f38 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java @@ -33,8 +33,7 @@ public class CableTile extends NetworkNodeTile { public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), t -> t.getNode().getCoverManager().writeToNbt(), (t, v) -> t.getNode().getCoverManager().readFromNbt(v), - (initial, p) -> Minecraft.getInstance().enqueue(() -> { - })); + (initial, p) -> Minecraft.getInstance().enqueue(() -> {})); static { TileDataManager.registerParameter(COVER_MANAGER); diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/ConstructorTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/ConstructorTile.java index c43bf1fc6..3c0cbc220 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/ConstructorTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/ConstructorTile.java @@ -2,12 +2,19 @@ package com.refinedmods.refinedstorage.tile; import com.refinedmods.refinedstorage.RSTiles; import com.refinedmods.refinedstorage.apiimpl.network.node.ConstructorNetworkNode; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; import com.refinedmods.refinedstorage.tile.config.IComparable; import com.refinedmods.refinedstorage.tile.config.IType; +import com.refinedmods.refinedstorage.tile.data.TileDataManager; import com.refinedmods.refinedstorage.tile.data.TileDataParameter; +import com.refinedmods.refinedstorage.util.WorldUtils; +import net.minecraft.client.Minecraft; +import net.minecraft.nbt.CompoundNBT; import net.minecraft.network.datasync.DataSerializers; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import net.minecraftforge.client.model.data.IModelData; +import net.minecraftforge.client.model.data.ModelDataMap; import javax.annotation.Nonnull; @@ -19,12 +26,22 @@ public class ConstructorTile extends NetworkNodeTile { t.getNode().markDirty(); }); + public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), + t -> t.getNode().getCoverManager().writeToNbt(), + (t, v) -> t.getNode().getCoverManager().readFromNbt(v), + (initial, p) -> Minecraft.getInstance().enqueue(() -> {})); + + static { + TileDataManager.registerParameter(COVER_MANAGER); + } + public ConstructorTile() { super(RSTiles.CONSTRUCTOR); dataManager.addWatchedParameter(COMPARE); dataManager.addWatchedParameter(TYPE); dataManager.addWatchedParameter(DROP); + dataManager.addWatchedParameter(COVER_MANAGER); } @Override @@ -32,4 +49,30 @@ public class ConstructorTile extends NetworkNodeTile { public ConstructorNetworkNode createNode(World world, BlockPos pos) { return new ConstructorNetworkNode(world, pos); } + + @Nonnull + @Override + public IModelData getModelData() { + return new ModelDataMap.Builder().withInitial(CoverManager.PROPERTY, this.getNode().getCoverManager()).build(); + } + + @Override + public CompoundNBT writeUpdate(CompoundNBT tag) { + super.writeUpdate(tag); + + tag.put("Covers", this.getNode().getCoverManager().writeToNbt()); + + return tag; + } + + @Override + public void readUpdate(CompoundNBT tag) { + super.readUpdate(tag); + + this.getNode().getCoverManager().readFromNbt(tag.getCompound("Covers")); + + requestModelDataUpdate(); + + WorldUtils.updateBlock(world, pos); + } } diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/DestructorTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/DestructorTile.java index bee1ad2bf..5498d723a 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/DestructorTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/DestructorTile.java @@ -2,13 +2,20 @@ package com.refinedmods.refinedstorage.tile; import com.refinedmods.refinedstorage.RSTiles; import com.refinedmods.refinedstorage.apiimpl.network.node.DestructorNetworkNode; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; import com.refinedmods.refinedstorage.tile.config.IComparable; import com.refinedmods.refinedstorage.tile.config.IType; import com.refinedmods.refinedstorage.tile.config.IWhitelistBlacklist; +import com.refinedmods.refinedstorage.tile.data.TileDataManager; import com.refinedmods.refinedstorage.tile.data.TileDataParameter; +import com.refinedmods.refinedstorage.util.WorldUtils; +import net.minecraft.client.Minecraft; +import net.minecraft.nbt.CompoundNBT; import net.minecraft.network.datasync.DataSerializers; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import net.minecraftforge.client.model.data.IModelData; +import net.minecraftforge.client.model.data.ModelDataMap; import javax.annotation.Nonnull; @@ -21,6 +28,15 @@ public class DestructorTile extends NetworkNodeTile { t.getNode().markDirty(); }); + public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), + t -> t.getNode().getCoverManager().writeToNbt(), + (t, v) -> t.getNode().getCoverManager().readFromNbt(v), + (initial, p) -> Minecraft.getInstance().enqueue(() -> {})); + + static { + TileDataManager.registerParameter(COVER_MANAGER); + } + public DestructorTile() { super(RSTiles.DESTRUCTOR); @@ -35,4 +51,30 @@ public class DestructorTile extends NetworkNodeTile { public DestructorNetworkNode createNode(World world, BlockPos pos) { return new DestructorNetworkNode(world, pos); } + + @Nonnull + @Override + public IModelData getModelData() { + return new ModelDataMap.Builder().withInitial(CoverManager.PROPERTY, this.getNode().getCoverManager()).build(); + } + + @Override + public CompoundNBT writeUpdate(CompoundNBT tag) { + super.writeUpdate(tag); + + tag.put("Covers", this.getNode().getCoverManager().writeToNbt()); + + return tag; + } + + @Override + public void readUpdate(CompoundNBT tag) { + super.readUpdate(tag); + + this.getNode().getCoverManager().readFromNbt(tag.getCompound("Covers")); + + requestModelDataUpdate(); + + WorldUtils.updateBlock(world, pos); + } } diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/ExporterTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/ExporterTile.java index 78c9a3630..a171bb13c 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/ExporterTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/ExporterTile.java @@ -23,8 +23,7 @@ public class ExporterTile extends NetworkNodeTile { public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), t -> t.getNode().getCoverManager().writeToNbt(), (t, v) -> t.getNode().getCoverManager().readFromNbt(v), - (initial, p) -> Minecraft.getInstance().enqueue(() -> { - })); + (initial, p) -> Minecraft.getInstance().enqueue(() -> {})); public static final TileDataParameter COMPARE = IComparable.createParameter(); public static final TileDataParameter TYPE = IType.createParameter(); diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/ImporterTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/ImporterTile.java index 962b9749b..54e1b50a3 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/ImporterTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/ImporterTile.java @@ -27,14 +27,12 @@ public class ImporterTile extends NetworkNodeTile { public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), t -> t.getNode().getCoverManager().writeToNbt(), (t, v) -> t.getNode().getCoverManager().readFromNbt(v), - (initial, p) -> Minecraft.getInstance().enqueue(() -> { - })); + (initial, p) -> Minecraft.getInstance().enqueue(() -> {})); static { TileDataManager.registerParameter(COVER_MANAGER); } - public ImporterTile() { super(RSTiles.IMPORTER); @@ -50,7 +48,6 @@ public class ImporterTile extends NetworkNodeTile { return new ImporterNetworkNode(world, pos); } - @Nonnull @Override public IModelData getModelData() { @@ -60,6 +57,7 @@ public class ImporterTile extends NetworkNodeTile { @Override public CompoundNBT writeUpdate(CompoundNBT tag) { super.writeUpdate(tag); + tag.put("Covers", this.getNode().getCoverManager().writeToNbt()); return tag; From 32f88fbd37e0868b3d6f4cd6c345b46a235a1fa7 Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Sun, 12 Sep 2021 23:38:19 +0200 Subject: [PATCH 13/18] Added cover support for the external storage and fixed some mappings issues --- build.gradle | 14 ------ .../node/ExternalStorageNetworkNode.java | 30 ++++++++++++- .../block/ExternalStorageBlock.java | 6 +-- .../render/model/BakedModelCover.java | 4 +- .../refinedstorage/setup/ClientSetup.java | 1 + .../refinedstorage/tile/DestructorTile.java | 1 + .../tile/ExternalStorageTile.java | 44 +++++++++++++++++++ .../refinedstorage/util/RenderUtils.java | 6 +-- 8 files changed, 83 insertions(+), 23 deletions(-) diff --git a/build.gradle b/build.gradle index f4caed76d..982c41889 100755 --- a/build.gradle +++ b/build.gradle @@ -97,20 +97,6 @@ sourceSets { main.resources.srcDirs += 'src/generated/resources' } -processResources { - inputs.property 'version', project.version - - from(sourceSets.main.resources.srcDirs) { - include 'META-INF/mods.toml' - - expand 'version': project.version - } - - from(sourceSets.main.resources.srcDirs) { - exclude 'META-INF/mods.toml' - } -} - dependencies { minecraft 'net.minecraftforge:forge:1.16.5-36.1.31' diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExternalStorageNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExternalStorageNetworkNode.java index 8620a8f45..99c7431b8 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExternalStorageNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExternalStorageNetworkNode.java @@ -2,6 +2,7 @@ package com.refinedmods.refinedstorage.apiimpl.network.node; import com.refinedmods.refinedstorage.RS; import com.refinedmods.refinedstorage.api.network.INetwork; +import com.refinedmods.refinedstorage.api.network.node.ICoverable; import com.refinedmods.refinedstorage.api.storage.AccessType; import com.refinedmods.refinedstorage.api.storage.IStorage; import com.refinedmods.refinedstorage.api.storage.IStorageProvider; @@ -12,6 +13,7 @@ import com.refinedmods.refinedstorage.api.storage.externalstorage.IExternalStora import com.refinedmods.refinedstorage.api.storage.externalstorage.IExternalStorageProvider; import com.refinedmods.refinedstorage.api.util.IComparer; import com.refinedmods.refinedstorage.apiimpl.API; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; import com.refinedmods.refinedstorage.apiimpl.storage.cache.FluidStorageCache; import com.refinedmods.refinedstorage.apiimpl.storage.cache.ItemStorageCache; import com.refinedmods.refinedstorage.inventory.fluid.FluidInventory; @@ -39,7 +41,7 @@ import org.apache.logging.log4j.Logger; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; -public class ExternalStorageNetworkNode extends NetworkNode implements IStorageProvider, IStorageScreen, IComparable, IWhitelistBlacklist, IPrioritizable, IType, IAccessType, IExternalStorageContext { +public class ExternalStorageNetworkNode extends NetworkNode implements IStorageProvider, IStorageScreen, IComparable, IWhitelistBlacklist, IPrioritizable, IType, IAccessType, IExternalStorageContext, ICoverable { public static final ResourceLocation ID = new ResourceLocation(RS.ID, "external_storage"); private static final Logger LOGGER = LogManager.getLogger(ExternalStorageNetworkNode.class); @@ -63,8 +65,11 @@ public class ExternalStorageNetworkNode extends NetworkNode implements IStorageP private final List> itemStorages = new CopyOnWriteArrayList<>(); private final List> fluidStorages = new CopyOnWriteArrayList<>(); + private CoverManager coverManager; + public ExternalStorageNetworkNode(World world, BlockPos pos) { super(world, pos); + this.coverManager = new CoverManager(this); } @Override @@ -319,4 +324,27 @@ public class ExternalStorageNetworkNode extends NetworkNode implements IStorageP public List> getFluidStorages() { return fluidStorages; } + + @Override + public CoverManager getCoverManager() { + return coverManager; + } + + @Override + public void read(CompoundNBT tag) { + super.read(tag); + + if (tag.contains("Cover")) this.coverManager.readFromNbt(tag.getCompound("Cover")); + } + + + + @Override + public CompoundNBT write(CompoundNBT tag) { + super.write(tag); + + tag.put("Cover", this.coverManager.writeToNbt()); + + return tag; + } } diff --git a/src/main/java/com/refinedmods/refinedstorage/block/ExternalStorageBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/ExternalStorageBlock.java index 7d69ab68b..67255e7f0 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/ExternalStorageBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/ExternalStorageBlock.java @@ -50,13 +50,13 @@ public class ExternalStorageBlock extends CableBlock { @Override public VoxelShape getShape(BlockState state, IBlockReader world, BlockPos pos, ISelectionContext ctx) { - return ShapeCache.getOrCreate(state, s -> { + return ConstantsCable.addCoverVoxelShapes(ShapeCache.getOrCreate(state, s -> { VoxelShape shape = getCableShape(s); shape = VoxelShapes.or(shape, getHeadShape(s)); - return ConstantsCable.addCoverVoxelShapes(shape, world, pos); - }); + return shape; + }), world, pos); } private VoxelShape getHeadShape(BlockState state) { diff --git a/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCover.java b/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCover.java index 4e2592f9d..4ee1b2ace 100644 --- a/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCover.java +++ b/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCover.java @@ -100,7 +100,7 @@ public class BakedModelCover extends BakedModelCableCover{ public ItemOverrideList getOverrides() { return new ItemOverrideList() { @Override - public IBakedModel func_239290_a_(IBakedModel originalModel, ItemStack stack, @Nullable ClientWorld world, @Nullable LivingEntity entity) { + public IBakedModel getOverrideModel(IBakedModel originalModel, ItemStack stack, @Nullable ClientWorld world, @Nullable LivingEntity entity) { return new BakedModelCover(stack, type); } }; @@ -152,7 +152,7 @@ public class BakedModelCover extends BakedModelCableCover{ } @Override - public boolean func_230044_c_() { + public boolean isSideLit() { return true; } } diff --git a/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java b/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java index a945dfb8b..579d66fca 100644 --- a/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java +++ b/src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java @@ -108,6 +108,7 @@ public class ClientSetup { bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "importer"), (base, registry) -> new BakedModelCableCover(base)); bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "constructor"), (base, registry) -> new BakedModelCableCover(new FullbrightBakedModel(base, true, new ResourceLocation(RS.ID, "block/constructor/cutouts/connected")))); bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "destructor"), (base, registry) -> new BakedModelCableCover(new FullbrightBakedModel(base, true, new ResourceLocation(RS.ID, "block/destructor/cutouts/connected")))); + bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "external_storage"), (base, registry) -> new BakedModelCableCover(base)); bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "cover"), (base, registry) -> new BakedModelCover(ItemStack.EMPTY, CoverType.NORMAL)); bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "hollow_cover"), (base, registry) -> new BakedModelCover(ItemStack.EMPTY, CoverType.HOLLOW)); diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/DestructorTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/DestructorTile.java index 5498d723a..94804686f 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/DestructorTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/DestructorTile.java @@ -44,6 +44,7 @@ public class DestructorTile extends NetworkNodeTile { dataManager.addWatchedParameter(WHITELIST_BLACKLIST); dataManager.addWatchedParameter(TYPE); dataManager.addWatchedParameter(PICKUP); + dataManager.addWatchedParameter(COVER_MANAGER); } @Override diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/ExternalStorageTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/ExternalStorageTile.java index 8d9fbc4d5..c2da86ca8 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/ExternalStorageTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/ExternalStorageTile.java @@ -4,12 +4,20 @@ import com.refinedmods.refinedstorage.RSTiles; import com.refinedmods.refinedstorage.api.storage.AccessType; import com.refinedmods.refinedstorage.api.storage.externalstorage.IExternalStorage; import com.refinedmods.refinedstorage.apiimpl.network.node.ExternalStorageNetworkNode; +import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager; import com.refinedmods.refinedstorage.tile.config.*; import com.refinedmods.refinedstorage.tile.data.RSSerializers; +import com.refinedmods.refinedstorage.tile.data.TileDataManager; import com.refinedmods.refinedstorage.tile.data.TileDataParameter; +import com.refinedmods.refinedstorage.util.WorldUtils; +import net.minecraft.client.Minecraft; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.CompoundNBT; +import net.minecraft.network.datasync.DataSerializers; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import net.minecraftforge.client.model.data.IModelData; +import net.minecraftforge.client.model.data.ModelDataMap; import net.minecraftforge.fluids.FluidStack; import javax.annotation.Nonnull; @@ -47,6 +55,15 @@ public class ExternalStorageTile extends NetworkNodeTile COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), + t -> t.getNode().getCoverManager().writeToNbt(), + (t, v) -> t.getNode().getCoverManager().readFromNbt(v), + (initial, p) -> Minecraft.getInstance().enqueue(() -> {})); + + static { + TileDataManager.registerParameter(COVER_MANAGER); + } + public ExternalStorageTile() { super(RSTiles.EXTERNAL_STORAGE); @@ -57,6 +74,7 @@ public class ExternalStorageTile extends NetworkNodeTile Date: Sun, 12 Sep 2021 23:44:04 +0200 Subject: [PATCH 14/18] Added some comments to easily check what I changed from the straight copied files --- .../apiimpl/network/node/cover/CoverManager.java | 2 +- .../java/com/refinedmods/refinedstorage/item/CoverItem.java | 2 +- .../refinedstorage/render/model/BakedModelCableCover.java | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java index 37b7ae91e..0107de823 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java @@ -149,7 +149,7 @@ public class CoverManager { BlockState state = getBlockState(item); - return block != null && state != null && ((isModelSupported(state) && !block.ticksRandomly(state) && !block.hasTileEntity(state) && !state.isTransparent())); //Removed is top solid as it needs world param + return block != null && state != null && ((isModelSupported(state) && !block.ticksRandomly(state) && !block.hasTileEntity(state) && !state.isTransparent())); //Changed from 1.12: to use 1.16 methods } private static boolean isModelSupported(BlockState state) { diff --git a/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java b/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java index 740cc5871..e71e9a36f 100644 --- a/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java +++ b/src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java @@ -73,7 +73,7 @@ public class CoverItem extends Item { @Override public void fillItemGroup(ItemGroup group, NonNullList items) { - if (this.isInGroup(group)) { + if (this.isInGroup(group)) { //Changed from 1.12: to use 1.16 configs if (!RS.CLIENT_CONFIG.getCover().showAllRecipesInJEI()) { ItemStack stack = new ItemStack(this); diff --git a/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java b/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java index 5db3a1c1e..da2364919 100644 --- a/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java +++ b/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java @@ -137,7 +137,7 @@ public class BakedModelCableCover extends DelegateBakedModel{ } } - HashMap spriteCache = new HashMap<>(); + HashMap spriteCache = new HashMap<>(); //Changed from 1.12: to improve sprite getting for each side quads.addAll(new CubeBuilder().from(from.getX(), from.getY(), from.getZ()).to(to.getX(), to.getY(), to.getZ()).addFaces(face -> new CubeBuilder.Face(face, spriteCache.computeIfAbsent(face, direction -> RenderUtils.getSprite(Minecraft.getInstance().getBlockRendererDispatcher().getModelForState(state), state, direction, random)))).bake()); if (handle) { @@ -197,7 +197,7 @@ public class BakedModelCableCover extends DelegateBakedModel{ from.setZ(16 - size); to.setZ(16); } - HashMap spriteCache = new HashMap<>(); + HashMap spriteCache = new HashMap<>(); //Changed from 1.12: to improve sprite getting for each side quads.addAll(new CubeBuilder() .from(from.getX(), from.getY(), from.getZ()) .to(to.getX(), to.getY(), to.getZ()) From 72300917503bd60fff06694d1e182429699ec5e1 Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Sun, 12 Sep 2021 23:53:55 +0200 Subject: [PATCH 15/18] Fixed server side issues --- .../refinedstorage/apiimpl/network/node/cover/CoverManager.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java index 0107de823..8c9f34fe2 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java @@ -157,7 +157,7 @@ public class CoverManager { return false; } - return state.isSolid() && state.isSolidSide(Minecraft.getInstance().world, new BlockPos(0,0,0), Direction.UP); //I dont trust this + return state.isSolid(); } @Nullable From fe59c33047a84d61d067697e77aeaf999cd8c11a Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Sun, 12 Sep 2021 23:57:46 +0200 Subject: [PATCH 16/18] Reverted unwanted build.gradle change --- build.gradle | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/build.gradle b/build.gradle index 982c41889..f4caed76d 100755 --- a/build.gradle +++ b/build.gradle @@ -97,6 +97,20 @@ sourceSets { main.resources.srcDirs += 'src/generated/resources' } +processResources { + inputs.property 'version', project.version + + from(sourceSets.main.resources.srcDirs) { + include 'META-INF/mods.toml' + + expand 'version': project.version + } + + from(sourceSets.main.resources.srcDirs) { + exclude 'META-INF/mods.toml' + } +} + dependencies { minecraft 'net.minecraftforge:forge:1.16.5-36.1.31' From 1da6e4d876521e02c22656dcb925d072d159fb41 Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Sun, 17 Oct 2021 19:45:56 +0200 Subject: [PATCH 17/18] Adressed PR comments --- .../apiimpl/network/node/CableNetworkNode.java | 8 +++++--- .../apiimpl/network/node/ConstructorNetworkNode.java | 8 +++++--- .../apiimpl/network/node/DestructorNetworkNode.java | 8 +++++--- .../apiimpl/network/node/ExporterNetworkNode.java | 8 +++++--- .../network/node/ExternalStorageNetworkNode.java | 8 +++++--- .../apiimpl/network/node/ImporterNetworkNode.java | 8 +++++--- .../apiimpl/network/node/cover/CoverManager.java | 11 +++++------ .../refinedmods/refinedstorage/block/CableBlock.java | 11 +++++++++-- .../jei/CoverCraftingCategoryExtension.java | 3 +-- .../jei/HollowCoverCraftingCategoryExtension.java | 5 +---- .../refinedstorage/render/ConstantsCable.java | 8 ++++---- .../refinedstorage/render/model/BakedModelCover.java | 7 ------- .../refinedstorage/render/model/CubeBuilder.java | 1 - .../refinedmods/refinedstorage/tile/CableTile.java | 12 +++++------- .../refinedstorage/tile/ConstructorTile.java | 10 +++------- .../refinedstorage/tile/DestructorTile.java | 10 +++------- .../refinedstorage/tile/ExporterTile.java | 11 ++++------- .../refinedstorage/tile/ExternalStorageTile.java | 10 +++------- .../refinedstorage/tile/ImporterTile.java | 10 +++------- .../refinedmods/refinedstorage/util/RenderUtils.java | 3 ++- 20 files changed, 73 insertions(+), 87 deletions(-) diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/CableNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/CableNetworkNode.java index f39b2ba3a..27d6f0bbc 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/CableNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/CableNetworkNode.java @@ -12,7 +12,7 @@ import net.minecraft.world.World; public class CableNetworkNode extends NetworkNode implements ICoverable { public static final ResourceLocation ID = new ResourceLocation(RS.ID, "cable"); - private CoverManager coverManager; + private final CoverManager coverManager; public CableNetworkNode(World world, BlockPos pos) { super(world, pos); @@ -36,13 +36,15 @@ public class CableNetworkNode extends NetworkNode implements ICoverable { @Override public void read(CompoundNBT tag) { - if (tag.contains("Cover")) this.coverManager.readFromNbt(tag.getCompound("Cover")); + if (tag.contains(CoverManager.NBT_COVER_MANAGER)){ + this.coverManager.readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER)); + } super.read(tag); } @Override public CompoundNBT write(CompoundNBT tag) { - tag.put("Cover", this.coverManager.writeToNbt()); + tag.put(CoverManager.NBT_COVER_MANAGER, this.coverManager.writeToNbt()); return super.write(tag); } } diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ConstructorNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ConstructorNetworkNode.java index c4c5b6012..b7d4ab9fe 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ConstructorNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ConstructorNetworkNode.java @@ -66,7 +66,7 @@ public class ConstructorNetworkNode extends NetworkNode implements IComparable, private int type = IType.ITEMS; private boolean drop = false; - private CoverManager coverManager; + private final CoverManager coverManager; public ConstructorNetworkNode(World world, BlockPos pos) { super(world, pos); @@ -179,7 +179,9 @@ public class ConstructorNetworkNode extends NetworkNode implements IComparable, public void read(CompoundNBT tag) { super.read(tag); - if (tag.contains("Cover")) this.coverManager.readFromNbt(tag.getCompound("Cover")); + if (tag.contains(CoverManager.NBT_COVER_MANAGER)){ + this.coverManager.readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER)); + } StackUtils.readItems(upgrades, 1, tag); } @@ -193,7 +195,7 @@ public class ConstructorNetworkNode extends NetworkNode implements IComparable, public CompoundNBT write(CompoundNBT tag) { super.write(tag); - tag.put("Cover", this.coverManager.writeToNbt()); + tag.put(CoverManager.NBT_COVER_MANAGER, this.coverManager.writeToNbt()); StackUtils.writeItems(upgrades, 1, tag); diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/DestructorNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/DestructorNetworkNode.java index 9705edd0f..e677d5329 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/DestructorNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/DestructorNetworkNode.java @@ -73,7 +73,7 @@ public class DestructorNetworkNode extends NetworkNode implements IComparable, I private boolean pickupItem = false; private ItemStack tool = createTool(); - private CoverManager coverManager; + private final CoverManager coverManager; public DestructorNetworkNode(World world, BlockPos pos) { super(world, pos); @@ -255,7 +255,9 @@ public class DestructorNetworkNode extends NetworkNode implements IComparable, I public void read(CompoundNBT tag) { super.read(tag); - if (tag.contains("Cover")) this.coverManager.readFromNbt(tag.getCompound("Cover")); + if (tag.contains(CoverManager.NBT_COVER_MANAGER)){ + this.coverManager.readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER)); + } StackUtils.readItems(upgrades, 1, tag); } @@ -269,7 +271,7 @@ public class DestructorNetworkNode extends NetworkNode implements IComparable, I public CompoundNBT write(CompoundNBT tag) { super.write(tag); - tag.put("Cover", this.coverManager.writeToNbt()); + tag.put(CoverManager.NBT_COVER_MANAGER, this.coverManager.writeToNbt()); StackUtils.writeItems(upgrades, 1, tag); diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExporterNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExporterNetworkNode.java index d19b7f4bc..e07ef3da0 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExporterNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExporterNetworkNode.java @@ -74,7 +74,7 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy private int filterSlot; - private CoverManager coverManager; + private final CoverManager coverManager; public ExporterNetworkNode(World world, BlockPos pos) { super(world, pos); @@ -250,7 +250,7 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy public CompoundNBT write(CompoundNBT tag) { super.write(tag); - tag.put("Cover", this.coverManager.writeToNbt()); + tag.put(CoverManager.NBT_COVER_MANAGER, this.coverManager.writeToNbt()); StackUtils.writeItems(upgrades, 1, tag); return tag; @@ -274,7 +274,9 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy public void read(CompoundNBT tag) { super.read(tag); - if (tag.contains("Cover")) this.coverManager.readFromNbt(tag.getCompound("Cover")); + if (tag.contains(CoverManager.NBT_COVER_MANAGER)){ + this.coverManager.readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER)); + } StackUtils.readItems(upgrades, 1, tag); } diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExternalStorageNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExternalStorageNetworkNode.java index 99c7431b8..a9b7ada18 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExternalStorageNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExternalStorageNetworkNode.java @@ -65,7 +65,7 @@ public class ExternalStorageNetworkNode extends NetworkNode implements IStorageP private final List> itemStorages = new CopyOnWriteArrayList<>(); private final List> fluidStorages = new CopyOnWriteArrayList<>(); - private CoverManager coverManager; + private final CoverManager coverManager; public ExternalStorageNetworkNode(World world, BlockPos pos) { super(world, pos); @@ -334,7 +334,9 @@ public class ExternalStorageNetworkNode extends NetworkNode implements IStorageP public void read(CompoundNBT tag) { super.read(tag); - if (tag.contains("Cover")) this.coverManager.readFromNbt(tag.getCompound("Cover")); + if (tag.contains(CoverManager.NBT_COVER_MANAGER)) { + this.coverManager.readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER)); + } } @@ -343,7 +345,7 @@ public class ExternalStorageNetworkNode extends NetworkNode implements IStorageP public CompoundNBT write(CompoundNBT tag) { super.write(tag); - tag.put("Cover", this.coverManager.writeToNbt()); + tag.put(CoverManager.NBT_COVER_MANAGER, this.coverManager.writeToNbt()); return tag; } diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ImporterNetworkNode.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ImporterNetworkNode.java index 35841cd00..2193b0cd4 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ImporterNetworkNode.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ImporterNetworkNode.java @@ -49,7 +49,7 @@ public class ImporterNetworkNode extends NetworkNode implements IComparable, IWh private int currentSlot; - private CoverManager coverManager; + private final CoverManager coverManager; public ImporterNetworkNode(World world, BlockPos pos) { super(world, pos); @@ -154,7 +154,9 @@ public class ImporterNetworkNode extends NetworkNode implements IComparable, IWh public void read(CompoundNBT tag) { super.read(tag); - if (tag.contains("Cover")) this.coverManager.readFromNbt(tag.getCompound("Cover")); + if (tag.contains(CoverManager.NBT_COVER_MANAGER)) { + this.coverManager.readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER)); + } StackUtils.readItems(upgrades, 1, tag); } @@ -168,7 +170,7 @@ public class ImporterNetworkNode extends NetworkNode implements IComparable, IWh public CompoundNBT write(CompoundNBT tag) { super.write(tag); - tag.put("Cover", this.coverManager.writeToNbt()); + tag.put(CoverManager.NBT_COVER_MANAGER, this.coverManager.writeToNbt()); StackUtils.writeItems(upgrades, 1, tag); diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java index 8c9f34fe2..d426f5ccd 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java @@ -24,6 +24,8 @@ import java.util.Map; public class CoverManager { + public static String NBT_COVER_MANAGER = "Cover"; + public static final ModelProperty PROPERTY = new ModelProperty<>(); private static final String NBT_DIRECTION = "Direction"; @@ -149,7 +151,8 @@ public class CoverManager { BlockState state = getBlockState(item); - return block != null && state != null && ((isModelSupported(state) && !block.ticksRandomly(state) && !block.hasTileEntity(state) && !state.isTransparent())); //Changed from 1.12: to use 1.16 methods + return block != null && state != null && isModelSupported(state) && !block.ticksRandomly(state) + && !block.hasTileEntity(state) && !state.isTransparent(); //Changed from 1.12: to use 1.16 methods } private static boolean isModelSupported(BlockState state) { @@ -184,11 +187,7 @@ public class CoverManager { return null; } - try { - return block.getDefaultState(); - } catch (Exception e) { - return null; - } + return block.getDefaultState(); } } diff --git a/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java b/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java index 09653f047..f1f01a8cd 100644 --- a/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java +++ b/src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java @@ -168,14 +168,21 @@ public class CableBlock extends NetworkNodeBlock implements IWaterLoggable { return false; } - return tile.getCapability(NetworkNodeProxyCapability.NETWORK_NODE_PROXY_CAPABILITY, direction).isPresent() && isSideNotCoveredOrHollow(tile, direction) && isSideNotCoveredOrHollow(world.getTileEntity(pos.offset(direction)), direction.getOpposite()); + return tile.getCapability(NetworkNodeProxyCapability.NETWORK_NODE_PROXY_CAPABILITY, direction).isPresent() + && isSideNotCoveredOrHollow(tile, direction) + && isSideNotCoveredOrHollow(world.getTileEntity(pos.offset(direction)), direction.getOpposite()); } private boolean isSideNotCoveredOrHollow(TileEntity tile, Direction direction){ if (tile == null){ return false; } - return tile.getCapability(NetworkNodeProxyCapability.NETWORK_NODE_PROXY_CAPABILITY, direction).map(INetworkNodeProxy::getNode).map(iNetworkNode -> !(iNetworkNode instanceof ICoverable) || (!((ICoverable) iNetworkNode).getCoverManager().hasCover(direction) || ((ICoverable) iNetworkNode).getCoverManager().getCover(direction).getType() == CoverType.HOLLOW)).orElse(false); + return tile.getCapability(NetworkNodeProxyCapability.NETWORK_NODE_PROXY_CAPABILITY, direction) + .map(INetworkNodeProxy::getNode) + .map(iNetworkNode -> !(iNetworkNode instanceof ICoverable) + || (!((ICoverable) iNetworkNode).getCoverManager().hasCover(direction) + || ((ICoverable) iNetworkNode).getCoverManager().getCover(direction).getType() == CoverType.HOLLOW)) + .orElse(false); } private BlockState getState(BlockState currentState, IWorld world, BlockPos pos) { diff --git a/src/main/java/com/refinedmods/refinedstorage/integration/jei/CoverCraftingCategoryExtension.java b/src/main/java/com/refinedmods/refinedstorage/integration/jei/CoverCraftingCategoryExtension.java index 5f4ef3cc0..d18173726 100644 --- a/src/main/java/com/refinedmods/refinedstorage/integration/jei/CoverCraftingCategoryExtension.java +++ b/src/main/java/com/refinedmods/refinedstorage/integration/jei/CoverCraftingCategoryExtension.java @@ -72,13 +72,12 @@ public class CoverCraftingCategoryExtension implements ICustomCraftingCategoryEx recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(4, Tags.Items.NUGGETS_IRON.getAllElements().stream().map(ItemStack::new).collect(Collectors.toList())); recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(5, CoverItem.getItem(stack)); recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(0, stack); - }else { + } else { recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(4, Tags.Items.NUGGETS_IRON.getAllElements().stream().map(ItemStack::new).collect(Collectors.toList())); recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(5, stack); ItemStack output = new ItemStack(RSItems.COVER.get()); CoverItem.setItem(output, stack); recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(0, output); } - } } diff --git a/src/main/java/com/refinedmods/refinedstorage/integration/jei/HollowCoverCraftingCategoryExtension.java b/src/main/java/com/refinedmods/refinedstorage/integration/jei/HollowCoverCraftingCategoryExtension.java index cc0b3f9d8..9f273c2ed 100644 --- a/src/main/java/com/refinedmods/refinedstorage/integration/jei/HollowCoverCraftingCategoryExtension.java +++ b/src/main/java/com/refinedmods/refinedstorage/integration/jei/HollowCoverCraftingCategoryExtension.java @@ -49,19 +49,16 @@ public class HollowCoverCraftingCategoryExtension implements ICustomCraftingCate @Override public void setRecipe(IRecipeLayout recipeLayout, IIngredients ingredients) { ItemStack stack = recipeLayout.getFocus(VanillaTypes.ITEM).getValue(); - if (stack.getItem() == RSItems.COVER.get()){ recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(5, stack); ItemStack output = new ItemStack(RSItems.HOLLOW_COVER.get()); CoverItem.setItem(output, CoverItem.getItem(stack)); recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(0, output); - }else { + } else { ItemStack input = new ItemStack(RSItems.COVER.get()); CoverItem.setItem(input, CoverItem.getItem(stack)); recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(5, input); - recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(0, stack); } - } } diff --git a/src/main/java/com/refinedmods/refinedstorage/render/ConstantsCable.java b/src/main/java/com/refinedmods/refinedstorage/render/ConstantsCable.java index a09f38f4d..0cfc2d3c9 100644 --- a/src/main/java/com/refinedmods/refinedstorage/render/ConstantsCable.java +++ b/src/main/java/com/refinedmods/refinedstorage/render/ConstantsCable.java @@ -76,15 +76,15 @@ public class ConstantsCable { } public static VoxelShape addCoverVoxelShapes(VoxelShape shape, IBlockReader world, BlockPos pos){ - if (world != null){ + if (world != null) { TileEntity entity = world.getTileEntity(pos); - if (entity instanceof NetworkNodeTile && ((NetworkNodeTile) entity).getNode() instanceof ICoverable){ + if (entity instanceof NetworkNodeTile && ((NetworkNodeTile) entity).getNode() instanceof ICoverable) { CoverManager coverManager = ((ICoverable) ((NetworkNodeTile) entity).getNode()).getCoverManager(); for (Direction value : Direction.values()) { Cover cover = coverManager.getCover(value); - if (cover != null){ + if (cover != null) { shape = VoxelShapes.or(shape, VoxelShapes.create(ConstantsCable.getCoverBounds(value))); - if (cover.getType() == CoverType.NORMAL){ + if (cover.getType() == CoverType.NORMAL) { shape = VoxelShapes.or(shape, VoxelShapes.create(ConstantsCable.getHolderBounds(value))); } } diff --git a/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCover.java b/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCover.java index 4ee1b2ace..28bb80fb2 100644 --- a/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCover.java +++ b/src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCover.java @@ -106,13 +106,6 @@ public class BakedModelCover extends BakedModelCableCover{ }; } - // @Override - // public Pair handlePerspective(ItemCameraTransforms.TransformType cameraTransformType) { - // TRSRTransformation transform = RenderUtils.getDefaultBlockTransforms().get(cameraTransformType); - // - // return Pair.of(this, transform == null ? RenderUtils.EMPTY_MATRIX_TRANSFORM : transform.getMatrix()); - // } - @Override public IBakedModel handlePerspective(ItemCameraTransforms.TransformType cameraTransformType, MatrixStack matrixStack) { TransformationMatrix transform = RenderUtils.getDefaultBlockTransforms().get(cameraTransformType); diff --git a/src/main/java/com/refinedmods/refinedstorage/render/model/CubeBuilder.java b/src/main/java/com/refinedmods/refinedstorage/render/model/CubeBuilder.java index 6052bc808..ab87a0d31 100644 --- a/src/main/java/com/refinedmods/refinedstorage/render/model/CubeBuilder.java +++ b/src/main/java/com/refinedmods/refinedstorage/render/model/CubeBuilder.java @@ -113,7 +113,6 @@ public class CubeBuilder { private BakedQuad bakeFace(Direction facing, Face cubeFace) { BakedQuadBuilder builder = new BakedQuadBuilder(cubeFace.sprite); //TODO See if can change the vertex format - //builder.setTexture(cubeFace.sprite); builder.setQuadOrientation(facing); builder.setQuadTint(-1); builder.setApplyDiffuseLighting(true); diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java index d84f97f38..b211a84bd 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java @@ -33,11 +33,7 @@ public class CableTile extends NetworkNodeTile { public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), t -> t.getNode().getCoverManager().writeToNbt(), (t, v) -> t.getNode().getCoverManager().readFromNbt(v), - (initial, p) -> Minecraft.getInstance().enqueue(() -> {})); - - static { - TileDataManager.registerParameter(COVER_MANAGER); - } + (initial, p) -> {}); public CableTile() { super(RSTiles.CABLE); @@ -59,7 +55,9 @@ public class CableTile extends NetworkNodeTile { @Override public CompoundNBT writeUpdate(CompoundNBT tag) { super.writeUpdate(tag); - tag.put("Covers", this.getNode().getCoverManager().writeToNbt()); + + tag.put(CoverManager.NBT_COVER_MANAGER, this.getNode().getCoverManager().writeToNbt()); + return tag; } @@ -67,7 +65,7 @@ public class CableTile extends NetworkNodeTile { public void readUpdate(CompoundNBT tag) { super.readUpdate(tag); - this.getNode().getCoverManager().readFromNbt(tag.getCompound("Covers")); + this.getNode().getCoverManager().readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER)); requestModelDataUpdate(); diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/ConstructorTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/ConstructorTile.java index 3c0cbc220..90d4deeca 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/ConstructorTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/ConstructorTile.java @@ -29,11 +29,7 @@ public class ConstructorTile extends NetworkNodeTile { public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), t -> t.getNode().getCoverManager().writeToNbt(), (t, v) -> t.getNode().getCoverManager().readFromNbt(v), - (initial, p) -> Minecraft.getInstance().enqueue(() -> {})); - - static { - TileDataManager.registerParameter(COVER_MANAGER); - } + (initial, p) -> {}); public ConstructorTile() { super(RSTiles.CONSTRUCTOR); @@ -60,7 +56,7 @@ public class ConstructorTile extends NetworkNodeTile { public CompoundNBT writeUpdate(CompoundNBT tag) { super.writeUpdate(tag); - tag.put("Covers", this.getNode().getCoverManager().writeToNbt()); + tag.put(CoverManager.NBT_COVER_MANAGER, this.getNode().getCoverManager().writeToNbt()); return tag; } @@ -69,7 +65,7 @@ public class ConstructorTile extends NetworkNodeTile { public void readUpdate(CompoundNBT tag) { super.readUpdate(tag); - this.getNode().getCoverManager().readFromNbt(tag.getCompound("Covers")); + this.getNode().getCoverManager().readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER)); requestModelDataUpdate(); diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/DestructorTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/DestructorTile.java index 94804686f..ba382fc1c 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/DestructorTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/DestructorTile.java @@ -31,11 +31,7 @@ public class DestructorTile extends NetworkNodeTile { public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), t -> t.getNode().getCoverManager().writeToNbt(), (t, v) -> t.getNode().getCoverManager().readFromNbt(v), - (initial, p) -> Minecraft.getInstance().enqueue(() -> {})); - - static { - TileDataManager.registerParameter(COVER_MANAGER); - } + (initial, p) -> {}); public DestructorTile() { super(RSTiles.DESTRUCTOR); @@ -63,7 +59,7 @@ public class DestructorTile extends NetworkNodeTile { public CompoundNBT writeUpdate(CompoundNBT tag) { super.writeUpdate(tag); - tag.put("Covers", this.getNode().getCoverManager().writeToNbt()); + tag.put(CoverManager.NBT_COVER_MANAGER, this.getNode().getCoverManager().writeToNbt()); return tag; } @@ -72,7 +68,7 @@ public class DestructorTile extends NetworkNodeTile { public void readUpdate(CompoundNBT tag) { super.readUpdate(tag); - this.getNode().getCoverManager().readFromNbt(tag.getCompound("Covers")); + this.getNode().getCoverManager().readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER)); requestModelDataUpdate(); diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/ExporterTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/ExporterTile.java index a171bb13c..f1f227a7a 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/ExporterTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/ExporterTile.java @@ -23,15 +23,11 @@ public class ExporterTile extends NetworkNodeTile { public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), t -> t.getNode().getCoverManager().writeToNbt(), (t, v) -> t.getNode().getCoverManager().readFromNbt(v), - (initial, p) -> Minecraft.getInstance().enqueue(() -> {})); + (initial, p) -> {}); public static final TileDataParameter COMPARE = IComparable.createParameter(); public static final TileDataParameter TYPE = IType.createParameter(); - static { - TileDataManager.registerParameter(COVER_MANAGER); - } - public ExporterTile() { super(RSTiles.EXPORTER); @@ -55,7 +51,8 @@ public class ExporterTile extends NetworkNodeTile { @Override public CompoundNBT writeUpdate(CompoundNBT tag) { super.writeUpdate(tag); - tag.put("Covers", this.getNode().getCoverManager().writeToNbt()); + + tag.put(CoverManager.NBT_COVER_MANAGER, this.getNode().getCoverManager().writeToNbt()); return tag; } @@ -64,7 +61,7 @@ public class ExporterTile extends NetworkNodeTile { public void readUpdate(CompoundNBT tag) { super.readUpdate(tag); - this.getNode().getCoverManager().readFromNbt(tag.getCompound("Covers")); + this.getNode().getCoverManager().readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER)); requestModelDataUpdate(); diff --git a/src/main/java/com/refinedmods/refinedstorage/tile/ExternalStorageTile.java b/src/main/java/com/refinedmods/refinedstorage/tile/ExternalStorageTile.java index c2da86ca8..b0831ab6e 100644 --- a/src/main/java/com/refinedmods/refinedstorage/tile/ExternalStorageTile.java +++ b/src/main/java/com/refinedmods/refinedstorage/tile/ExternalStorageTile.java @@ -58,11 +58,7 @@ public class ExternalStorageTile extends NetworkNodeTile COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), t -> t.getNode().getCoverManager().writeToNbt(), (t, v) -> t.getNode().getCoverManager().readFromNbt(v), - (initial, p) -> Minecraft.getInstance().enqueue(() -> {})); - - static { - TileDataManager.registerParameter(COVER_MANAGER); - } + (initial, p) -> {}); public ExternalStorageTile() { super(RSTiles.EXTERNAL_STORAGE); @@ -93,7 +89,7 @@ public class ExternalStorageTile extends NetworkNodeTile { public static final TileDataParameter COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(), t -> t.getNode().getCoverManager().writeToNbt(), (t, v) -> t.getNode().getCoverManager().readFromNbt(v), - (initial, p) -> Minecraft.getInstance().enqueue(() -> {})); - - static { - TileDataManager.registerParameter(COVER_MANAGER); - } + (initial, p) -> {}); public ImporterTile() { super(RSTiles.IMPORTER); @@ -58,7 +54,7 @@ public class ImporterTile extends NetworkNodeTile { public CompoundNBT writeUpdate(CompoundNBT tag) { super.writeUpdate(tag); - tag.put("Covers", this.getNode().getCoverManager().writeToNbt()); + tag.put(CoverManager.NBT_COVER_MANAGER, this.getNode().getCoverManager().writeToNbt()); return tag; } @@ -67,7 +63,7 @@ public class ImporterTile extends NetworkNodeTile { public void readUpdate(CompoundNBT tag) { super.readUpdate(tag); - this.getNode().getCoverManager().readFromNbt(tag.getCompound("Covers")); + this.getNode().getCoverManager().readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER)); requestModelDataUpdate(); diff --git a/src/main/java/com/refinedmods/refinedstorage/util/RenderUtils.java b/src/main/java/com/refinedmods/refinedstorage/util/RenderUtils.java index d54bdfb4e..ee83d8f95 100644 --- a/src/main/java/com/refinedmods/refinedstorage/util/RenderUtils.java +++ b/src/main/java/com/refinedmods/refinedstorage/util/RenderUtils.java @@ -35,6 +35,7 @@ import net.minecraftforge.client.MinecraftForgeClient; import net.minecraftforge.client.event.RenderTooltipEvent; import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fml.ModList; import net.minecraftforge.fml.client.gui.GuiUtils; import javax.annotation.Nonnull; @@ -317,7 +318,7 @@ public final class RenderUtils { } public static boolean isLightMapDisabled() { - return false; //FMLClientHandler.instance().hasOptifine() || !ForgeModContainer.forgeLightPipelineEnabled; TODO + return false; } public static VertexFormat getFormatWithLightMap(VertexFormat format) { From b6f4aec45c2a7f2e74ca066f760fad5b7ad10a33 Mon Sep 17 00:00:00 2001 From: Buuz135 Date: Sun, 17 Oct 2021 19:59:59 +0200 Subject: [PATCH 18/18] Adressed PR comments --- .../apiimpl/network/node/cover/CoverManager.java | 6 +++--- .../refinedstorage/render/model/CubeBuilder.java | 2 +- .../com/refinedmods/refinedstorage/util/RenderUtils.java | 4 +++- 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java index d426f5ccd..d7cd93b8d 100644 --- a/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java +++ b/src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java @@ -164,8 +164,8 @@ public class CoverManager { } @Nullable - public static Block getBlock(@Nullable ItemStack item) { - if (item == null) { + public static Block getBlock(ItemStack item) { + if (item.isEmpty()) { return null; } @@ -180,7 +180,7 @@ public class CoverManager { @Nullable @SuppressWarnings("deprecation") - public static BlockState getBlockState(@Nullable ItemStack item) { + public static BlockState getBlockState(ItemStack item) { Block block = getBlock(item); if (block == null) { diff --git a/src/main/java/com/refinedmods/refinedstorage/render/model/CubeBuilder.java b/src/main/java/com/refinedmods/refinedstorage/render/model/CubeBuilder.java index ab87a0d31..feb54adb5 100644 --- a/src/main/java/com/refinedmods/refinedstorage/render/model/CubeBuilder.java +++ b/src/main/java/com/refinedmods/refinedstorage/render/model/CubeBuilder.java @@ -111,7 +111,7 @@ public class CubeBuilder { } private BakedQuad bakeFace(Direction facing, Face cubeFace) { - BakedQuadBuilder builder = new BakedQuadBuilder(cubeFace.sprite); //TODO See if can change the vertex format + BakedQuadBuilder builder = new BakedQuadBuilder(cubeFace.sprite); builder.setQuadOrientation(facing); builder.setQuadTint(-1); diff --git a/src/main/java/com/refinedmods/refinedstorage/util/RenderUtils.java b/src/main/java/com/refinedmods/refinedstorage/util/RenderUtils.java index ee83d8f95..810538550 100644 --- a/src/main/java/com/refinedmods/refinedstorage/util/RenderUtils.java +++ b/src/main/java/com/refinedmods/refinedstorage/util/RenderUtils.java @@ -373,7 +373,9 @@ public final class RenderUtils { } if (sprite == null) { - sprite = null; //TODO Get missing sprite + for (BakedQuad quad : Minecraft.getInstance().getModelManager().getMissingModel().getQuads(coverState, facing, rand)) { + return quad.getSprite(); + } } return sprite;