当前位置：首页 > CN2资讯 > 正文内容

我的世界java版复制方块模组

9小时前CN2资讯


Minecraft1.12.2 方块实体教程

MC中有许多很有趣的方块实体如旗帜、钟、附魔台…我们今天在1.18的版本下实现一个类似于熔炉的方块实体。

1.在blocks包中新建一个我们的方块实体包virusgenerator，包中新建一个我们的方块类VirusGeneratorBlock：

VirusGeneratorBlock.java

package com.joy187.re8joymod.blocks.virusgenerator; import net.minecraft.world.level.block.BaseEntityBlock; import net.minecraft.world.level.block.state.properties.BlockStateProperties; import net.minecraft.world.level.block.state.properties.BooleanProperty; import net.minecraft.world.level.block.state.properties.DirectionProperty; import net.minecraft.world.phys.shapes.VoxelShape; import net.minecraft.core.BlockPos; import net.minecraft.core.Direction; import net.minecraft.server.level.ServerPlayer; import net.minecraft.world.InteractionHand; import net.minecraft.world.InteractionResult; import net.minecraft.world.entity.player.Player; import net.minecraft.world.item.context.BlockPlaceContext; import net.minecraft.world.level.BlockGetter; import net.minecraft.world.level.Level; import net.minecraft.world.level.block.*; import net.minecraft.world.level.block.entity.BlockEntity; import net.minecraft.world.level.block.entity.BlockEntityTicker; import net.minecraft.world.level.block.entity.BlockEntityType; import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.block.state.StateDefinition; import net.minecraft.world.phys.BlockHitResult; import net.minecraft.world.phys.shapes.CollisionContext; import net.minecraftforge.network.NetworkHooks; import org.jetbrains.annotations.Nullable; import com.joy187.re8joymod.init.BlockEntityInit; public class VirusGeneratorBlock extends BaseEntityBlock { public static final DirectionProperty FACING = BlockStateProperties.HORIZONTAL_FACING; public static final BooleanProperty LIT = BlockStateProperties.LIT; public VirusGeneratorBlock(Properties properties) { super(properties); this.registerDefaultState(this.stateDefinition.any().setValue(FACING, Direction.NORTH).setValue(LIT, Boolean.valueOf(false))); } private static final VoxelShape SHAPE = Block.box(0, 0, 0, 16, 15, 16); @Override public VoxelShape getShape(BlockState pState, BlockGetter pLevel, BlockPos pPos, CollisionContext pContext) { return SHAPE; } /* FACING */ @Override public BlockState getStateForPlacement(BlockPlaceContext pContext) { return this.defaultBlockState().setValue(FACING, pContext.getHorizontalDirection().getOpposite()); } @Override public BlockState rotate(BlockState pState, Rotation pRotation) { return pState.setValue(FACING, pRotation.rotate(pState.getValue(FACING))); } @Override public BlockState mirror(BlockState pState, Mirror pMirror) { return pState.rotate(pMirror.getRotation(pState.getValue(FACING))); } @Override protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> pBuilder) { pBuilder.add(FACING,LIT); } @Override public RenderShape getRenderShape(BlockState pState) { return RenderShape.MODEL; } @Override public void onRemove(BlockState pState, Level pLevel, BlockPos pPos, BlockState pNewState, boolean pIsMoving) { if (pState.getBlock() != pNewState.getBlock()) { BlockEntity blockEntity = pLevel.getBlockEntity(pPos); if (blockEntity instanceof VirusGeneratorBlockEntity) { ((VirusGeneratorBlockEntity) blockEntity).drops(); } } super.onRemove(pState, pLevel, pPos, pNewState, pIsMoving); } @Override public InteractionResult use(BlockState pState, Level pLevel, BlockPos pPos, Player pPlayer, InteractionHand pHand, BlockHitResult pHit) { if (!pLevel.isClientSide()) { BlockEntity entity = pLevel.getBlockEntity(pPos); if(entity instanceof VirusGeneratorBlockEntity) { NetworkHooks.openGui(((ServerPlayer)pPlayer), (VirusGeneratorBlockEntity)entity, pPos); } else { throw new IllegalStateException("Our Container provider is missing!"); } } return InteractionResult.sidedSuccess(pLevel.isClientSide()); } @Nullable @Override public BlockEntity newBlockEntity(BlockPos pPos, BlockState pState) { return new VirusGeneratorBlockEntity(pPos, pState); } @Nullable @Override public <T extends BlockEntity> BlockEntityTicker<T> getTicker(Level pLevel, BlockState pState, BlockEntityType<T> pBlockEntityType) { return createTickerHelper(pBlockEntityType, BlockEntityInit.VIRUS_GENERATOR_BLOCK_ENTITY.get(), VirusGeneratorBlockEntity::tick); } }
在BlockInit中注册我们的方块：
public static final RegistryObject<Block> VIRUS_GENERATOR_BLOCK = registerBlock("virus_generator", () -> new VirusGeneratorBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK).noOcclusion()), Main.TUTORIAL_TAB);

2.在virusgenerator包中新建一个我们的实体类VirusGeneratorBlockEntity:

VirusGeneratorBlockEntity.java

package com.joy187.re8joymod.blocks.virusgenerator; import net.minecraft.core.BlockPos; import net.minecraft.core.Direction; import net.minecraft.nbt.CompoundTag; import net.minecraft.network.chat.Component; import net.minecraft.network.chat.TextComponent; import net.minecraft.network.chat.TranslatableComponent; import net.minecraft.world.Containers; import net.minecraft.world.MenuProvider; import net.minecraft.world.SimpleContainer; import net.minecraft.world.entity.player.Inventory; import net.minecraft.world.entity.player.Player; import net.minecraft.world.inventory.AbstractContainerMenu; import net.minecraft.world.inventory.ContainerData; import net.minecraft.world.item.ItemStack; import net.minecraft.world.item.Items; import net.minecraft.world.item.alchemy.PotionUtils; import net.minecraft.world.item.alchemy.Potions; import net.minecraft.world.level.Level; import net.minecraft.world.level.block.AbstractFurnaceBlock; import net.minecraft.world.level.block.entity.BlockEntity; import net.minecraft.world.level.block.state.BlockState; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.common.util.LazyOptional; import net.minecraftforge.items.CapabilityItemHandler; import net.minecraftforge.items.IItemHandler; import net.minecraftforge.items.ItemStackHandler; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import com.joy187.re8joymod.init.BlockEntityInit; import com.joy187.re8joymod.init.ItemInit; import com.joy187.re8joymod.screen.VirusGeneratorMenu; import javax.annotation.Nonnull; import java.util.Optional; import java.util.Random; public class VirusGeneratorBlockEntity extends BlockEntity implements MenuProvider { private BlockState blockState; private final ItemStackHandler itemHandler = new ItemStackHandler(4) { @Override protected void onContentsChanged(int slot) { setChanged(); } }; private LazyOptional<IItemHandler> lazyItemHandler = LazyOptional.empty(); protected final ContainerData data; private int progress = 0; //你熔炼一个物品所需要的时间刻tick private int maxProgress = 72; public VirusGeneratorBlockEntity(BlockPos pWorldPosition, BlockState pBlockState) { super(BlockEntityInit.VIRUS_GENERATOR_BLOCK_ENTITY.get(), pWorldPosition, pBlockState); this.data = new ContainerData() { public int get(int index) { switch (index) { case 0: return VirusGeneratorBlockEntity.this.progress; case 1: return VirusGeneratorBlockEntity.this.maxProgress; default: return 0; } } public void set(int index, int value) { switch(index) { case 0: VirusGeneratorBlockEntity.this.progress = value; break; case 1: VirusGeneratorBlockEntity.this.maxProgress = value; break; } } public int getCount() { return 2; } }; } @Override public Component getDisplayName() { return new TranslatableComponent("container.virus_generator"); } // protected Component getDefaultName() { // return new TranslatableComponent("container.virus_generator"); // } @Nullable @Override public AbstractContainerMenu createMenu(int pContainerId, Inventory pInventory, Player pPlayer) { return new VirusGeneratorMenu(pContainerId, pInventory, this, this.data); } @Nonnull @Override public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @javax.annotation.Nullable Direction side) { if (cap == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) { return lazyItemHandler.cast(); } return super.getCapability(cap, side); } @Override public void onLoad() { super.onLoad(); lazyItemHandler = LazyOptional.of(() -> itemHandler); } @Override public void invalidateCaps() { super.invalidateCaps(); lazyItemHandler.invalidate(); } @Override protected void saveAdditional(@NotNull CompoundTag tag) { tag.put("inventory", itemHandler.serializeNBT()); tag.putInt("virus_generator.progress", progress); super.saveAdditional(tag); } @Override public void load(CompoundTag nbt) { super.load(nbt); itemHandler.deserializeNBT(nbt.getCompound("inventory")); progress = nbt.getInt("virus_generator.progress"); } public void drops() { SimpleContainer inventory = new SimpleContainer(itemHandler.getSlots()); for (int i = 0; i < itemHandler.getSlots(); i++) { inventory.setItem(i, itemHandler.getStackInSlot(i)); } Containers.dropContents(this.level, this.worldPosition, inventory); } public static void tick(Level pLevel, BlockPos pPos, BlockState pState, VirusGeneratorBlockEntity pBlockEntity) { if(hasRecipe(pBlockEntity)) { pState.setValue(VirusGeneratorBlock.LIT, Boolean.valueOf(true)); pBlockEntity.progress++; setChanged(pLevel, pPos, pState); if(pBlockEntity.progress > pBlockEntity.maxProgress) { craftItem(pBlockEntity); } } else { pState.setValue(VirusGeneratorBlock.LIT, Boolean.valueOf(false)); pBlockEntity.resetProgress(); setChanged(pLevel, pPos, pState); } // if(hasRecipe(pBlockEntity) && notReachLimit(pBlockEntity)) { // craftItem(pBlockEntity); // } } private static boolean hasRecipe(VirusGeneratorBlockEntity entity) { Level level = entity.level; SimpleContainer inventory = new SimpleContainer(entity.itemHandler.getSlots()); for (int i = 0; i < entity.itemHandler.getSlots(); i++) { inventory.setItem(i, entity.itemHandler.getStackInSlot(i)); } Optional<VirusGeneratorRecipe> match = level.getRecipeManager() .getRecipeFor(VirusGeneratorRecipe.Type.INSTANCE, inventory, level); return match.isPresent() && canInsertAmountIntoOutputSlot(inventory) && canInsertItemIntoOutputSlot(inventory, match.get().getResultItem()) && hasFuelSlot(entity); // && has0Slot(entity) && has1Slot(entity); // boolean canUse = has0Slot(entity) && hasFuelSlot(entity) && has1Slot(entity); // if(canUse) entity.blockState = entity.blockState.setValue(VirusGeneratorBlock.LIT, Boolean.valueOf(true)); // else entity.blockState = entity.blockState.setValue(VirusGeneratorBlock.LIT, Boolean.valueOf(false)); // return canUse; } // private static boolean has0Slot(VirusGeneratorBlockEntity entity) { // return entity.itemHandler.getStackInSlot(0).getItem() == Items.ROTTEN_FLESH; // } // private static boolean has1Slot(VirusGeneratorBlockEntity entity) { // return entity.itemHandler.getStackInSlot(1).getItem() == ItemInit.LYEYE.get(); // } //你的燃料槽 private static boolean hasFuelSlot(VirusGeneratorBlockEntity entity) { return entity.itemHandler.getStackInSlot(2).getItem() == ItemInit.BLACKSHEEP.get() || entity.itemHandler.getStackInSlot(2).getItem() == Items.FERMENTED_SPIDER_EYE; } //检查物品槽是否放了原料 private static void craftItem(VirusGeneratorBlockEntity entity) { Level level = entity.level; SimpleContainer inventory = new SimpleContainer(entity.itemHandler.getSlots()); for (int i = 0; i < entity.itemHandler.getSlots(); i++) { inventory.setItem(i, entity.itemHandler.getStackInSlot(i)); } //检查是否有这个配方 Optional<VirusGeneratorRecipe> match = level.getRecipeManager() .getRecipeFor(VirusGeneratorRecipe.Type.INSTANCE, inventory, level); if(match.isPresent()) { //if(has0Slot(entity) && has1Slot(entity) && hasFuelSlot(entity)) { entity.itemHandler.extractItem(0,1, false); entity.itemHandler.extractItem(1,1, false); entity.itemHandler.extractItem(2,1, false); //产出物品 entity.itemHandler.setStackInSlot(3, new ItemStack(match.get().getResultItem().getItem(), entity.itemHandler.getStackInSlot(3).getCount() + 1)); // entity.itemHandler.setStackInSlot(3, new ItemStack(ItemInit.HUMUS.get(), // entity.itemHandler.getStackInSlot(3).getCount() + 1)); entity.resetProgress(); } } private void resetProgress() { this.progress = 0; } //我们设定了3号槽是产物槽 private static boolean canInsertItemIntoOutputSlot(SimpleContainer inventory, ItemStack output) { return inventory.getItem(3).getItem() == output.getItem() || inventory.getItem(3).isEmpty(); } private static boolean canInsertAmountIntoOutputSlot(SimpleContainer inventory) { return inventory.getItem(3).getMaxStackSize() > inventory.getItem(3).getCount(); } private static boolean notReachLimit(VirusGeneratorBlockEntity entity) { return entity.itemHandler.getStackInSlot(3).getCount()<64; } // @Override // public BlockState getBlockState() { // return this.blockState; // } }
在init包中新建一个BlockEntityInit类，注册我们模组中所有的方块实体：

BlockEntityInit.java

package com.joy187.re8joymod.init; import com.joy187.re8joymod.Main; import com.joy187.re8joymod.blocks.virusgenerator.VirusGeneratorBlockEntity; import net.minecraft.world.level.block.entity.BlockEntityType; import net.minecraftforge.eventbus.api.IEventBus; import net.minecraftforge.registries.DeferredRegister; import net.minecraftforge.registries.ForgeRegistries; import net.minecraftforge.registries.RegistryObject; public class BlockEntityInit { public static final DeferredRegister<BlockEntityType<?>> BLOCK_ENTITIES = DeferredRegister.create(ForgeRegistries.BLOCK_ENTITIES, Main.MOD_ID); public static final RegistryObject<BlockEntityType<VirusGeneratorBlockEntity>> VIRUS_GENERATOR_BLOCK_ENTITY = BLOCK_ENTITIES.register("virus_generator_block_entity", () -> BlockEntityType.Builder.of(VirusGeneratorBlockEntity::new, BlockInit.VIRUS_GENERATOR_BLOCK.get()).build(null)); // public static final RegistryObject<BlockEntityType<GeneratorBlockEntity>> GENERATOR_BLOCK_ENTITY = // BLOCK_ENTITIES.register("generator_block_entity", () -> // BlockEntityType.Builder.of(GeneratorBlockEntity::new, // BlockInit.GENERATOR_BLOCK.get()).build(null)); public static void register(IEventBus eventBus) { BLOCK_ENTITIES.register(eventBus); } }
在我们的项目主类中的Main函数中将BlockEntityInit类进行注册：
public Main() { IEventBus bus = FMLJavaModLoadingContext.get().getModEventBus(); ItemInit.ITEMS.register(bus); BlockInit.BLOCKS.register(bus); EntityInit.ENTITY_TYPES.register(bus); EffectInit.EFFECTS.register(bus); PotionInit.POTIONS.register(bus); SoundInit.SOUNDS.register(bus); //添加这个 BlockEntityInit.register(bus); MinecraftForge.EVENT_BUS.register(this); }

3.在virusgenerator包中新建一个我们的配方类VirusGeneratorRecipe:

VirusGeneratorRecipe.java

package com.joy187.re8joymod.blocks.virusgenerator; import com.google.gson.JsonArray; import com.google.gson.JsonObject; import com.joy187.re8joymod.Main; import com.joy187.re8joymod.init.BlockInit; import com.joy187.re8joymod.init.ItemInit; import net.minecraft.core.NonNullList; import net.minecraft.network.FriendlyByteBuf; import net.minecraft.resources.ResourceLocation; import net.minecraft.util.GsonHelper; import net.minecraft.world.SimpleContainer; import net.minecraft.world.item.ItemStack; import net.minecraft.world.item.Items; import net.minecraft.world.item.crafting.*; import net.minecraft.world.level.Level; import net.minecraft.world.level.block.Blocks; import com.google.common.collect.HashBasedTable; import com.google.common.collect.Maps; import com.google.common.collect.Table; import java.util.Map; import java.util.Map.Entry; import javax.annotation.Nullable; public class VirusGeneratorRecipe implements Recipe<SimpleContainer> { private final ResourceLocation id; private final ItemStack output; private final NonNullList<Ingredient> recipeItems; public VirusGeneratorRecipe(ResourceLocation id, ItemStack output, NonNullList<Ingredient> recipeItems) { this.id = id; this.output = output; this.recipeItems = recipeItems; } @Override public boolean matches(SimpleContainer pContainer, Level pLevel) { return recipeItems.get(0).test(pContainer.getItem(1)) && recipeItems.get(1).test(pContainer.getItem(0)); } @Override public NonNullList<Ingredient> getIngredients() { return recipeItems; } @Override public ItemStack assemble(SimpleContainer pContainer) { return output; } @Override public boolean canCraftInDimensions(int pWidth, int pHeight) { return true; } @Override public ItemStack getResultItem() { return output.copy(); } @Override public ResourceLocation getId() { return id; } @Override public RecipeSerializer<?> getSerializer() { return Serializer.INSTANCE; } @Override public RecipeType<?> getType() { return Type.INSTANCE; } public static class Type implements RecipeType<VirusGeneratorRecipe> { private Type() { } public static final Type INSTANCE = new Type(); //这个就是我们之后的配方类的字段 public static final String ID = "virus_generator"; } public static class Serializer implements RecipeSerializer<VirusGeneratorRecipe> { public static final Serializer INSTANCE = new Serializer(); public static final ResourceLocation ID = new ResourceLocation(Main.MOD_ID,"virus_generator"); @Override public VirusGeneratorRecipe fromJson(ResourceLocation id, JsonObject json) { ItemStack output = ShapedRecipe.itemStackFromJson(GsonHelper.getAsJsonObject(json, "output")); JsonArray ingredients = GsonHelper.getAsJsonArray(json, "ingredients"); //这里说明一共有几个原料，我们需要2个，就写2，需要3个，就改成3 NonNullList<Ingredient> inputs = NonNullList.withSize(2, Ingredient.EMPTY); for (int i = 0; i < inputs.size(); i++) { inputs.set(i, Ingredient.fromJson(ingredients.get(i))); } return new VirusGeneratorRecipe(id, output, inputs); } @Override public VirusGeneratorRecipe fromNetwork(ResourceLocation id, FriendlyByteBuf buf) { NonNullList<Ingredient> inputs = NonNullList.withSize(buf.readInt(), Ingredient.EMPTY); for (int i = 0; i < inputs.size(); i++) { inputs.set(i, Ingredient.fromNetwork(buf)); } ItemStack output = buf.readItem(); return new VirusGeneratorRecipe(id, output, inputs); } @Override public void toNetwork(FriendlyByteBuf buf, VirusGeneratorRecipe recipe) { buf.writeInt(recipe.getIngredients().size()); for (Ingredient ing : recipe.getIngredients()) { ing.toNetwork(buf); } buf.writeItemStack(recipe.getResultItem(), false); } @Override public RecipeSerializer<?> setRegistryName(ResourceLocation name) { return INSTANCE; } @Nullable @Override public ResourceLocation getRegistryName() { return ID; } @Override public Class<RecipeSerializer<?>> getRegistryType() { return Serializer.castClass(RecipeSerializer.class); } @SuppressWarnings("unchecked") // Need this wrapper, because generics private static <G> Class<G> castClass(Class<?> cls) { return (Class<G>)cls; } } }

4.方块和实体的代码部分结束，进入到GUI的制作环节。在Java包中新建一个screen包 -> screen包中新建VirusGeneratorScreen类指明我们GUI贴图存放的位置：

VirusGeneratorScreen.java

package com.joy187.re8joymod.screen; import com.joy187.re8joymod.Main; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.PoseStack; import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen; import net.minecraft.client.renderer.GameRenderer; import net.minecraft.network.chat.Component; import net.minecraft.resources.ResourceLocation; import net.minecraft.world.entity.player.Inventory; public class VirusGeneratorScreen extends AbstractContainerScreen<VirusGeneratorMenu> { //指明我们材质的位置 private static final ResourceLocation TEXTURE = new ResourceLocation(Main.MOD_ID, "textures/gui/virus_generator.png"); public VirusGeneratorScreen(VirusGeneratorMenu pMenu, Inventory pPlayerInventory, Component pTitle) { super(pMenu, pPlayerInventory, pTitle); } @Override protected void renderBg(PoseStack pPoseStack, float pPartialTick, int pMouseX, int pMouseY) { RenderSystem.setShader(GameRenderer::getPositionTexShader); RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F); RenderSystem.setShaderTexture(0, TEXTURE); int x = (width - imageWidth) / 2; int y = (height - imageHeight) / 2; this.blit(pPoseStack, x, y, 0, 0, imageWidth, imageHeight); if(menu.isCrafting()) { //blit(pPoseStack, x + 102, y + 41, 176, 0, 8, menu.getScaledProgress()); blit(pPoseStack, x + 8, y + 54+12-13, 176, 12-13, 14, menu.getScaledProgress()); } } //this.drawTexturedModalRect(this.guiLeft + 8, this.guiTop + 54 + 12 - k, 176, 12 - k, 14, k + 1); @Override public void render(PoseStack pPoseStack, int mouseX, int mouseY, float delta) { renderBackground(pPoseStack); super.render(pPoseStack, mouseX, mouseY, delta); renderTooltip(pPoseStack, mouseX, mouseY); } }
在我们项目主类的clientSetup()函数中将screen时间进行注册：
private void clientSetup(final FMLClientSetupEvent event) { //EntityRenderers.register(EntityInit.DUND1.get(), RenderDund::new); ItemBlockRenderTypes.setRenderLayer(BlockInit.EBONY_LEAVES.get(), RenderType.cutout()); ItemBlockRenderTypes.setRenderLayer(BlockInit.HERB_BLOCK.get(), RenderType.cutout()); ItemBlockRenderTypes.setRenderLayer(BlockInit.EBONY_SAPLING.get(), RenderType.cutout()); //添加这个，第一个参数机器方块的GUI，后面是这个机器方块的screen MenuScreens.register(MenuInit.VIRUS_GENERATOR_MENU.get(), VirusGeneratorScreen::new); }
screen包中新建VirusGeneratorMenu类将所有的槽位的位置都指出来：

VirusGeneratorMenu.java

package com.joy187.re8joymod.screen; import net.minecraft.network.FriendlyByteBuf; import net.minecraft.world.entity.player.Inventory; import net.minecraft.world.entity.player.Player; import net.minecraft.world.inventory.*; import net.minecraft.world.item.ItemStack; import net.minecraft.world.level.Level; import net.minecraft.world.level.block.entity.BlockEntity; import net.minecraftforge.items.CapabilityItemHandler; import net.minecraftforge.items.SlotItemHandler; import org.jetbrains.annotations.Nullable; import com.joy187.re8joymod.blocks.virusgenerator.VirusGeneratorBlock; import com.joy187.re8joymod.blocks.virusgenerator.VirusGeneratorBlockEntity; import com.joy187.re8joymod.init.BlockInit; import com.joy187.re8joymod.init.MenuInit; import com.joy187.re8joymod.screen.slot.ModResultSlot; public class VirusGeneratorMenu extends AbstractContainerMenu { private final VirusGeneratorBlockEntity blockEntity; private final Level level; private final ContainerData data; public VirusGeneratorMenu(int pContainerId, Inventory inv, FriendlyByteBuf extraData) { this(pContainerId, inv, inv.player.level.getBlockEntity(extraData.readBlockPos()), new SimpleContainerData(2)); } public VirusGeneratorMenu(int pContainerId, Inventory inv, BlockEntity entity, ContainerData data) { super(MenuInit.VIRUS_GENERATOR_MENU.get(), pContainerId); checkContainerSize(inv, 4); blockEntity = ((VirusGeneratorBlockEntity) entity); this.level = inv.player.level; this.data = data; addPlayerInventory(inv); addPlayerHotbar(inv); //将所有我们的槽位的位置都标注出来 this.blockEntity.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY).ifPresent(handler -> { this.addSlot(new SlotItemHandler(handler, 0, 26, 11)); this.addSlot(new SlotItemHandler(handler, 1, 26, 59)); this.addSlot(new SlotItemHandler(handler, 2, 7, 35)); this.addSlot(new ModResultSlot(handler, 3, 81, 36)); }); addDataSlots(data); } public boolean isCrafting() { return data.get(0) > 0; } //这个是播放我们方块工作时的执行进度的动画，类似于熔炉燃烧时中间的进度条 public int getScaledProgress() { int progress = this.data.get(0); int maxProgress = this.data.get(1); // Max Progress //我们的进度条高13像素 int progressArrowSize = 13; return maxProgress != 0 && progress != 0 ? progress * progressArrowSize / maxProgress : 0; } // CREDIT GOES TO: diesieben07 | https:///diesieben07/SevenCommons // must assign a slot number to each of the slots used by the GUI. // For this container, we can see both the tile inventory's slots as well as the player inventory slots and the hotbar. // Each time we add a Slot to the container, it automatically increases the slotIndex, which means // 0 - 8 = hotbar slots (which will map to the InventoryPlayer slot numbers 0 - 8) // 9 - 35 = player inventory slots (which map to the InventoryPlayer slot numbers 9 - 35) // 36 - 44 = TileInventory slots, which map to our TileEntity slot numbers 0 - 8) private static final int HOTBAR_SLOT_COUNT = 9; private static final int PLAYER_INVENTORY_ROW_COUNT = 3; private static final int PLAYER_INVENTORY_COLUMN_COUNT = 9; private static final int PLAYER_INVENTORY_SLOT_COUNT = PLAYER_INVENTORY_COLUMN_COUNT * PLAYER_INVENTORY_ROW_COUNT; private static final int VANILLA_SLOT_COUNT = HOTBAR_SLOT_COUNT + PLAYER_INVENTORY_SLOT_COUNT; private static final int VANILLA_FIRST_SLOT_INDEX = 0; private static final int TE_INVENTORY_FIRST_SLOT_INDEX = VANILLA_FIRST_SLOT_INDEX + VANILLA_SLOT_COUNT; // THIS YOU HAVE TO DEFINE! private static final int TE_INVENTORY_SLOT_COUNT = 4; // must be the number of slots you have! @Override public ItemStack quickMoveStack(Player playerIn, int index) { Slot sourceSlot = slots.get(index); if (sourceSlot == null || !sourceSlot.hasItem()) return ItemStack.EMPTY; //EMPTY_ITEM ItemStack sourceStack = sourceSlot.getItem(); ItemStack copyOfSourceStack = sourceStack.copy(); // Check if the slot clicked is one of the vanilla container slots if (index < VANILLA_FIRST_SLOT_INDEX + VANILLA_SLOT_COUNT) { // This is a vanilla container slot so merge the stack into the tile inventory if (!moveItemStackTo(sourceStack, TE_INVENTORY_FIRST_SLOT_INDEX, TE_INVENTORY_FIRST_SLOT_INDEX + TE_INVENTORY_SLOT_COUNT, false)) { return ItemStack.EMPTY; // EMPTY_ITEM } } else if (index < TE_INVENTORY_FIRST_SLOT_INDEX + TE_INVENTORY_SLOT_COUNT) { // This is a TE slot so merge the stack into the players inventory if (!moveItemStackTo(sourceStack, VANILLA_FIRST_SLOT_INDEX, VANILLA_FIRST_SLOT_INDEX + VANILLA_SLOT_COUNT, false)) { return ItemStack.EMPTY; } } else { System.out.println("Invalid slotIndex:" + index); return ItemStack.EMPTY; } // If stack size == 0 (the entire stack was moved) set slot contents to null if (sourceStack.getCount() == 0) { sourceSlot.set(ItemStack.EMPTY); } else { sourceSlot.setChanged(); } sourceSlot.onTake(playerIn, sourceStack); return copyOfSourceStack; } @Override public boolean stillValid(Player pPlayer) { return stillValid(ContainerLevelAccess.create(level, blockEntity.getBlockPos()), pPlayer, BlockInit.VIRUS_GENERATOR_BLOCK.get()); } //3行物品栏 private void addPlayerInventory(Inventory playerInventory) { for (int i = 0; i < 3; ++i) { for (int l = 0; l < 9; ++l) { this.addSlot(new Slot(playerInventory, l + i * 9 + 9, 8 + l * 18, 84 + i * 18)); } } } //一行你的个人栏 private void addPlayerHotbar(Inventory playerInventory) { for (int i = 0; i < 9; ++i) { this.addSlot(new Slot(playerInventory, i, 8 + i * 18, 142)); } } }
我们的槽位对应关系，左上角为坐标原点：

我们13像素的进度条就是用右上角的图案覆盖左下角的图案。

在screen包中新建ModResultSlot类，将我们的产物放置进行预设。

ModResultSlot.java

public class ModResultSlot extends SlotItemHandler { public ModResultSlot(IItemHandler itemHandler, int index, int x, int y) { super(itemHandler, index, x, y); } @Override public boolean mayPlace(ItemStack stack) { return false; } }

5.在init包中新建MenuInit类，将我们第四步中的菜单进行注册：

MenuInit.java

package com.joy187.re8joymod.init; import com.joy187.re8joymod.Main; import com.joy187.re8joymod.screen.VirusGeneratorMenu; import net.minecraft.world.inventory.AbstractContainerMenu; import net.minecraft.world.inventory.MenuType; import net.minecraftforge.common.extensions.IForgeMenuType; import net.minecraftforge.eventbus.api.IEventBus; import net.minecraftforge.network.IContainerFactory; import net.minecraftforge.registries.DeferredRegister; import net.minecraftforge.registries.ForgeRegistries; import net.minecraftforge.registries.RegistryObject; public class MenuInit { public static final DeferredRegister<MenuType<?>> MENUS = DeferredRegister.create(ForgeRegistries.CONTAINERS, Main.MOD_ID); //注册我们的方块菜单界面 public static final RegistryObject<MenuType<VirusGeneratorMenu>> VIRUS_GENERATOR_MENU = registerMenuType(VirusGeneratorMenu::new, "virus_generator_menu"); private static <T extends AbstractContainerMenu>RegistryObject<MenuType<T>> registerMenuType(IContainerFactory<T> factory, String name) { return MENUS.register(name, () -> IForgeMenuType.create(factory)); } public static void register(IEventBus eventBus) { MENUS.register(eventBus); } }
在我们的项目主类中的Main函数中将MenuInit类进行注册：
public Main() { IEventBus bus = FMLJavaModLoadingContext.get().getModEventBus(); ItemInit.ITEMS.register(bus); BlockInit.BLOCKS.register(bus); EntityInit.ENTITY_TYPES.register(bus); EffectInit.EFFECTS.register(bus); PotionInit.POTIONS.register(bus); SoundInit.SOUNDS.register(bus); BlockEntityInit.register(bus); //添加这个 MenuInit.register(bus); MinecraftForge.EVENT_BUS.register(this); }

6.在init包中新建RecipeInit类，将我们第三步中的配方类进行注册：

RecipeInit.java

package com.joy187.re8joymod.init; import com.joy187.re8joymod.Main; import com.joy187.re8joymod.blocks.virusgenerator.VirusGeneratorRecipe; import net.minecraft.world.item.crafting.RecipeSerializer; import net.minecraftforge.eventbus.api.IEventBus; import net.minecraftforge.registries.DeferredRegister; import net.minecraftforge.registries.ForgeRegistries; import net.minecraftforge.registries.RegistryObject; public class RecipeInit { public static final DeferredRegister<RecipeSerializer<?>> SERIALIZERS = DeferredRegister.create(ForgeRegistries.RECIPE_SERIALIZERS, Main.MOD_ID); public static final RegistryObject<RecipeSerializer<VirusGeneratorRecipe>> VIRUS_GENERATOR_SERIALIZER = SERIALIZERS.register("virus_generator", () -> VirusGeneratorRecipe.Serializer.INSTANCE); public static void register(IEventBus eventBus) { SERIALIZERS.register(eventBus); } }
在我们的项目主类中的Main函数中将RecipeInit类进行注册：
public Main() { IEventBus bus = FMLJavaModLoadingContext.get().getModEventBus(); ItemInit.ITEMS.register(bus); BlockInit.BLOCKS.register(bus); EntityInit.ENTITY_TYPES.register(bus); EffectInit.EFFECTS.register(bus); PotionInit.POTIONS.register(bus); SoundInit.SOUNDS.register(bus); BlockEntityInit.register(bus); MenuInit.register(bus); //添加这个 RecipeInit.register(bus); MinecraftForge.EVENT_BUS.register(this); }
在ClientModEventSubscriber类中添加我们的配方类型的类进行注册

ClientModEventSubscriber.java

@SubscribeEvent public static void registerRecipeTypes(final RegistryEvent.Register<RecipeSerializer<?>> event) { Registry.register(Registry.RECIPE_TYPE, VirusGeneratorRecipe.Type.ID, VirusGeneratorRecipe.Type.INSTANCE); }

7.代码部分结束，来到资源包制做。在src\main\resources\assets\你的modid\blockstates中新建我们的方块的状态文件：

virus_generator.json

{ "variants": { "facing=east,lit=false": { "model": "re8joymod:block/virus_generator", "y": 90 }, "facing=east,lit=true": { "model": "re8joymod:block/virus_generator_on", "y": 90 }, "facing=north,lit=false": { "model": "re8joymod:block/virus_generator" }, "facing=north,lit=true": { "model": "re8joymod:block/virus_generator_on" }, "facing=south,lit=false": { "model": "re8joymod:block/virus_generator", "y": 180 }, "facing=south,lit=true": { "model": "re8joymod:block/virus_generator_on", "y": 180 }, "facing=west,lit=false": { "model": "re8joymod:block/virus_generator", "y": 270 }, "facing=west,lit=true": { "model": "re8joymod:block/virus_generator_on", "y": 270 } } }
在src\main\resources\assets\你的modid\models\block中新建两个我们的方块模型文件：
方块平时的模型

virus_generator.json

{ "parent": "block/orientable", "textures": { "top": "re8joymod:block/virus_generator_side", "front": "re8joymod:block/virus_generator", "side": "re8joymod:block/virus_generator_side" } }
方块工作时的模型

virus_generator_on.json

{ "parent": "block/orientable", "textures": { "top": "re8joymod:block/virus_generator_side", "front": "re8joymod:block/virus_generator_on", "side": "re8joymod:block/virus_generator_side" } }
在models\item中添加我们手拿方块时的模型文件

virus_generator.json

{ "parent": "re8joymod:block/virus_generator" }
在textures\block中添加我们方块的侧面、正面不工作、正面工作时的贴图：

在textures包中新建gui包 -> gui包中把我们的gui(大小为256×256像素点)放进去：

在lang包中的en_us.json文件中加上我们方块实体的名称和打开机器后上面显示的名称：
"block.re8joymod.virus_generator":"Virus Analyser", "container.virus_generator":"Virus Analyser",

8.在src\main\resources\data\你的modid\recipes中新建几个属于我们的方块实体的配方:

记得在第三步中我们把配方类型设置为virus_generator，所以配方的type就写为virus_generator：

evirus.json

{ "type":"re8joymod:virus_generator", "ingredients":[ { "item":"re8joymod:humus" }, { "item":"re8joymod:herbglass" } ], "output":{ "item":"re8joymod:evirus" } }

9.保存所有文件 -> 进入游戏调试：

首先拿出我们的机器并放置下来，外观显示正常

将燃料和产物放入，成功产出了产物！


    你可能想看：

    我的世界java 模组 我的世界Java模组要钱吗

    我的世界java命令方块 我的世界java命令方块字幕

    我的世界java命令方块指令延迟设置 我的世界java版命令方块

    我的世界java命令方块怎么弄延迟 我的世界java版命令方块

    我的世界java模组怎么转基岩版模组 我的世界java版转基岩版

    我的世界java命令方块延时指令 我的世界java命令方块延迟

    我的世界java 允许方块 我的世界允许方块儿

    我的世界java启用命令方块指令 我的世界命令方块

    我的世界java版怎么在游戏界面删模组 我的世界怎样删掉模组

    我的世界Java复制指令 我的世界java复制物品

    扫描二维码推送至手机访问。

    版权声明：本文由皇冠云发布，如需转载请注明出处。

    本文链接：https://www.idchg.com/info/31795.html

    标签: 我的世界java版复制方块模组Java
    分享给朋友：
    返回列表

    上一篇：我的世界兔子用Python怎么画

    下一篇：HMCL连接docker环境运行我的世界

    “我的世界java版复制方块模组” 的相关文章

    性价比VPS：高效节约的虚拟专用服务器选择指南

    在讨论性价比VPS之前，我觉得先弄清楚什么是性价比VPS特别重要。简而言之，性价比VPS是指在一定的价格范围内，提供较高的性能和稳定性的虚拟专用服务器。这类服务在近几年变得越来越受欢迎，特别是对于那些预算有限但又希望拥有高质量主机服务的人来说，性价比高的VPS就像是一道光，照亮了他们的选择之路。 性...

    详解VPS中转教程：提升网络连接的速度与稳定性

    我想给大家介绍一下VPS中转技术。这是一种通过一台或多台服务器进行流量转发的技术，能有效提升网络连接的效率和稳定性。说白了，它就像是在你的网络旅途中增加了一些中转站，让你的数据在传输时更加顺畅和可靠。 在我使用VPS中转技术的过程中，我发现它的应用场景相当广泛。比如，在网络受限的环境中，VPS中转能...

    如何选择适合你的匿名服务器以保护隐私和数据安全

    在当今互联网时代，保护个人隐私和数据安全变得尤为重要。匿名服务器的概念应运而生，成为许多人实现在线安全和隐私的一种方式。简单来说，匿名服务器是一种特殊的服务器，能够隐藏用户的真实IP地址，从而在用户上网时保护其身份和活动。这对于那些希望自由浏览网络、避免被追踪的用户尤其重要。 匿名服务器通常与虚拟私...

    选择和管理海外服务器的最佳策略与优势

    在如今这个信息高度发达的时代，海外服务器逐渐成为许多企业的不二选择。简单来说，海外服务器是指那些位于中国境外的数据处理设备。这些服务器致力于为全球用户提供高效的服务，不论是数据存储、网站托管还是其他在线服务。通过使用海外服务器，企业能够接触到更广阔的市场以及可定制的解决方案，以满足特定需求。 选择海...

    AMD EPYC 7K62：数据中心理想选择的高性能服务器CPU

    在数据中心的世界中，选对一款合适的服务器CPU至关重要。今天，我想聊聊AMD EPYC 7K62，这款处理器以其高性价比赢得了许多用户的青睐。这个型号的CPU被设计为服务器专用，接下来我们将深入了解它的基本信息、技术规格以及市场定位。 AMD EPYC 7K62的型号很直接，名称中就带有AMD和EP...

    HostDare VPS主机服务评测：高性价比与用户体验的完美结合

    在与HostDare的互动中，我感受到这家公司在客户支持与用户体验方面的一些亮点和不足。正如我们所知，HostDare是一家致力于提供高性价比VPS主机服务的公司，尤其在针对中国大陆用户的优化上表现突出。虽然服务上有一些待改善之处，但总体而言，它的客户支持体系还是相对高效的。 首先，HostDare...

    Copyright 皇冠云 Rights Reserved.