Bonjour,
J’ai essayé à l’aide du tutoriel de créer mon propre bloc cependant j’ai un problème à l’ouverture de celui-ci. La texture prend toute la taille de l’écran et je ne comprends pas pourquoi (elle fait 256*256).
Voici mon code :
Classe du gui :
| package com.sebenforce; |
| |
| import net.minecraft.client.gui.inventory.GuiContainer; |
| import net.minecraft.client.resources.I18n; |
| import net.minecraft.entity.player.InventoryPlayer; |
| import net.minecraft.inventory.IInventory; |
| import net.minecraft.util.ResourceLocation; |
| |
| import org.lwjgl.opengl.GL11; |
| |
| public class GuiMachineTuto extends GuiContainer { |
| |
| private static final ResourceLocation texture = new ResourceLocation(Main.MODID,"textures/gui/container/gui.png"); |
| @SuppressWarnings("unused") |
| private TileEntityMachineTuto tileMachineTuto; |
| private IInventory playerInv; |
| |
| public GuiMachineTuto(TileEntityMachineTuto tile, InventoryPlayer inventory) |
| { |
| super(new ContainerMachineTuto(tile, inventory)); |
| this.tileMachineTuto = tile; |
| this.playerInv = inventory; |
| this.allowUserInput = false; |
| this.ySize = 256; |
| this.xSize = 256; |
| } |
| |
| @Override |
| protected void drawGuiContainerBackgroundLayer(float partialRenderTick, int x, int y) |
| { |
| |
| GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); |
| this.mc.getTextureManager().bindTexture(texture); |
| int k = (this.width - this.xSize) / 2; |
| int l = (this.height - this.ySize) / 2; |
| this.drawTexturedModalRect(k, l, 0, 0, this.xSize, this.ySize); |
| this.drawTexturedModalRect(0, 0, 176, 14, 100 + 1, 16); |
| |
| } |
| |
| protected void drawGuiContainerForegroundLayer(int x, int y) |
| { |
| this.fontRendererObj.drawString(this.playerInv.hasCustomInventoryName() ? this.playerInv.getInventoryName() : I18n.format(this.playerInv.getInventoryName()), 10, this.ySize - 98, 4210752); |
| } |
| |
| } |
| |
Classe guiHandler :
| package com.sebenforce; |
| |
| import net.minecraft.entity.player.EntityPlayer; |
| import net.minecraft.tileentity.TileEntity; |
| import net.minecraft.world.World; |
| import cpw.mods.fml.common.network.IGuiHandler; |
| |
| public class GuiHandler implements IGuiHandler |
| { |
| |
| @Override |
| public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) { |
| TileEntity tile = world.getTileEntity(x, y, z); |
| if(tile instanceof TileEntityMachineTuto) |
| { |
| return new ContainerMachineTuto((TileEntityMachineTuto)tile, player.inventory); |
| } |
| return null; |
| } |
| |
| @Override |
| public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) { |
| TileEntity tile = world.getTileEntity(x, y, z); |
| if(tile instanceof TileEntityMachineTuto) |
| { |
| return new GuiMachineTuto((TileEntityMachineTuto)tile, player.inventory); |
| } |
| return null; |
| } |
| |
| } |
Et les autre classe si ça peut être utile, TileEntity :
| package com.sebenforce; |
| |
| import net.minecraft.entity.player.EntityPlayer; |
| import net.minecraft.inventory.IInventory; |
| import net.minecraft.item.ItemStack; |
| import net.minecraft.nbt.NBTTagCompound; |
| import net.minecraft.nbt.NBTTagList; |
| import net.minecraft.tileentity.TileEntity; |
| |
| public class TileEntityMachineTuto extends TileEntity implements IInventory { |
| |
| private ItemStack[] contents = new ItemStack[4]; |
| private int workingTime = 0; |
| private int workingTimeNeeded = 200; |
| |
| @Override |
| public void writeToNBT(NBTTagCompound compound) |
| { |
| super.writeToNBT(compound); |
| NBTTagList nbttaglist = new NBTTagList(); |
| |
| for (int i = 0; i < this.contents.length; ++i) |
| { |
| if (this.contents* != null) |
| { |
| NBTTagCompound nbttagcompound1 = new NBTTagCompound(); |
| nbttagcompound1.setByte("Slot", (byte)i); |
| this.contents*.writeToNBT(nbttagcompound1); |
| nbttaglist.appendTag(nbttagcompound1); |
| } |
| } |
| |
| compound.setTag("Items", nbttaglist); |
| compound.setShort("workingTime",(short)this.workingTime); |
| compound.setShort("workingTimeNeeded", (short)this.workingTimeNeeded); |
| } |
| |
| @Override |
| public void readFromNBT(NBTTagCompound compound) |
| { |
| super.readFromNBT(compound); |
| |
| NBTTagList nbttaglist = compound.getTagList("Items", 10); |
| this.contents = new ItemStack[this.getSizeInventory()]; |
| |
| for (int i = 0; i < nbttaglist.tagCount(); ++i) |
| { |
| NBTTagCompound nbttagcompound1 = nbttaglist.getCompoundTagAt(i); |
| int j = nbttagcompound1.getByte("Slot") & 255; |
| |
| if (j >= 0 && j < this.contents.length) |
| { |
| this.contents[j] = ItemStack.loadItemStackFromNBT(nbttagcompound1); |
| } |
| } |
| |
| this.workingTime = compound.getShort("workingTime"); |
| this.workingTimeNeeded = compound.getShort("workingTimeNeeded"); |
| } |
| |
| @Override |
| public int getSizeInventory() { |
| return this.contents.length; |
| } |
| |
| @Override |
| public ItemStack getStackInSlot(int slotIndex) { |
| return this.contents[slotIndex]; |
| } |
| |
| @Override |
| public ItemStack decrStackSize(int slotIndex, int amount) { |
| if (this.contents[slotIndex] != null) |
| { |
| ItemStack itemstack; |
| |
| if (this.contents[slotIndex].stackSize <= amount) |
| { |
| itemstack = this.contents[slotIndex]; |
| this.contents[slotIndex] = null; |
| this.markDirty(); |
| return itemstack; |
| } |
| else |
| { |
| itemstack = this.contents[slotIndex].splitStack(amount); |
| |
| if (this.contents[slotIndex].stackSize == 0) |
| { |
| this.contents[slotIndex] = null; |
| } |
| |
| this.markDirty(); |
| return itemstack; |
| } |
| } |
| else |
| { |
| return null; |
| } |
| } |
| |
| @Override |
| public ItemStack getStackInSlotOnClosing(int slotIndex) { |
| if (this.contents[slotIndex] != null) |
| { |
| ItemStack itemstack = this.contents[slotIndex]; |
| this.contents[slotIndex] = null; |
| return itemstack; |
| } |
| else |
| { |
| return null; |
| } |
| } |
| |
| @Override |
| public void setInventorySlotContents(int slotIndex, ItemStack stack) { |
| this.contents[slotIndex] = stack; |
| |
| if (stack != null && stack.stackSize > this.getInventoryStackLimit()) |
| { |
| stack.stackSize = this.getInventoryStackLimit(); |
| } |
| |
| this.markDirty(); |
| } |
| |
| @Override |
| public String getInventoryName() { |
| return "tile.machineTuto"; |
| } |
| |
| @Override |
| public boolean hasCustomInventoryName() { |
| return false; |
| } |
| |
| @Override |
| public int getInventoryStackLimit() { |
| return 64; |
| } |
| |
| @Override |
| public boolean isUseableByPlayer(EntityPlayer player) { |
| return this.worldObj.getTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : player.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D; |
| } |
| |
| @Override |
| public void openInventory() { |
| |
| } |
| |
| @Override |
| public void closeInventory() { |
| |
| } |
| |
| @Override |
| public boolean isItemValidForSlot(int slot, ItemStack stack) { |
| return slot == 3 ? false : true; |
| } |
| |
| public boolean isBurning() |
| { |
| return this.workingTime > 0; |
| } |
| |
| private boolean canSmelt() |
| { |
| if (this.contents[0] == null || this.contents[1] == null || this.contents[2] == null) |
| { |
| return false; |
| } |
| else |
| { |
| ItemStack itemstack = MachineTutoRecipes.smelting().getSmeltingResult(new ItemStack[]{this.contents[0], this.contents[1], this.contents[2]}); |
| if (itemstack == null) return false; |
| if (this.contents[3] == null) return true; |
| if (!this.contents[3].isItemEqual(itemstack)) return false; |
| int result = contents[3].stackSize + itemstack.stackSize; |
| return result <= getInventoryStackLimit() && result <= this.contents[3].getMaxStackSize(); |
| } |
| } |
| |
| public void updateEntity() |
| { |
| if(this.isBurning() && this.canSmelt()) |
| { |
| ++this.workingTime; |
| } |
| if(this.canSmelt() && !this.isBurning()) |
| { |
| this.workingTime = 1; |
| } |
| if(this.canSmelt() && this.workingTime == this.workingTimeNeeded) |
| { |
| this.smeltItem(); |
| this.workingTime = 0; |
| } |
| if(!this.canSmelt()) |
| { |
| this.workingTime= 0; |
| } |
| } |
| |
| public void smeltItem() |
| { |
| if (this.canSmelt()) |
| { |
| ItemStack itemstack = MachineTutoRecipes.smelting().getSmeltingResult(new ItemStack[]{this.contents[0], this.contents[1], this.contents[2]}); |
| if (this.contents[3] == null) |
| { |
| this.contents[3] = itemstack.copy(); |
| } |
| else if (this.contents[3].getItem() == itemstack.getItem()) |
| { |
| this.contents[3].stackSize += itemstack.stackSize; |
| } |
| |
| –this.contents[0].stackSize; |
| –this.contents[1].stackSize; |
| –this.contents[2].stackSize; |
| |
| if (this.contents[0].stackSize <= 0) |
| { |
| this.contents[0] = null; |
| } |
| if (this.contents[1].stackSize <= 0) |
| { |
| this.contents[1] = null; |
| } |
| if (this.contents[2].stackSize <= 0) |
| { |
| this.contents[2] = null; |
| } |
| } |
| } |
| } |
| |
Le container :
| package com.sebenforce; |
| |
| import net.minecraft.entity.player.EntityPlayer; |
| import net.minecraft.entity.player.InventoryPlayer; |
| import net.minecraft.inventory.Container; |
| import net.minecraft.inventory.Slot; |
| import net.minecraft.item.ItemStack; |
| |
| public class ContainerMachineTuto extends Container { |
| |
| private TileEntityMachineTuto tileMachineTuto; |
| |
| public ContainerMachineTuto(TileEntityMachineTuto tile, InventoryPlayer inventory) |
| { |
| this.tileMachineTuto = tile; |
| this.addSlotToContainer(new Slot(tile, 0, 49, 75)); |
| this.addSlotToContainer(new Slot(tile, 1, 89, 75)); |
| this.addSlotToContainer(new Slot(tile, 2, 129, 75)); |
| this.addSlotToContainer(new SlotResult(tile, 3, 89, 135)); |
| this.bindPlayerInventory(inventory); |
| } |
| |
| @Override |
| public boolean canInteractWith(EntityPlayer player) { |
| return this.tileMachineTuto.isUseableByPlayer(player); |
| } |
| |
| private void bindPlayerInventory(InventoryPlayer inventory) |
| { |
| int i; |
| for (i = 0; i < 3; ++i) |
| { |
| for (int j = 0; j < 9; ++j) |
| { |
| this.addSlotToContainer(new Slot(inventory, j + i * 9 + 9, 17 + j * 18, 171 + i * 18)); |
| } |
| } |
| |
| for (i = 0; i < 9; ++i) |
| { |
| this.addSlotToContainer(new Slot(inventory, i, 17 + i * 18, 229)); |
| } |
| } |
| |
| public ItemStack transferStackInSlot(EntityPlayer player, int quantity) |
| { |
| ItemStack itemstack = null; |
| Slot slot = (Slot)this.inventorySlots.get(quantity); |
| |
| if (slot != null && slot.getHasStack()) |
| { |
| ItemStack itemstack1 = slot.getStack(); |
| itemstack = itemstack1.copy(); |
| |
| if (quantity < this.tileMachineTuto.getSizeInventory()) |
| { |
| if (!this.mergeItemStack(itemstack1, this.tileMachineTuto.getSizeInventory(), this.inventorySlots.size(), true)) |
| { |
| return null; |
| } |
| } |
| else if (!this.mergeItemStack(itemstack1, 0, this.tileMachineTuto.getSizeInventory(), false)) |
| { |
| return null; |
| } |
| |
| if (itemstack1.stackSize == 0) |
| { |
| slot.putStack((ItemStack)null); |
| } |
| else |
| { |
| slot.onSlotChanged(); |
| } |
| } |
| |
| return itemstack; |
| } |
| |
| public void onContainerClosed(EntityPlayer player) |
| { |
| super.onContainerClosed(player); |
| this.tileMachineTuto.closeInventory(); |
| } |
| } |
| |
Et voici le rendu que j’ai :

Merci d’avance.