Печка

Версия Minecraft
1.12.2
683
3
21
Почему не открывается печка?
Java:
package en.tiref.Mydecoratedworld.inventory.tileentity;

import en.tiref.Mydecoratedworld.blocks.machines.DrumBlock;
import en.tiref.Mydecoratedworld.util.RecipesMachine.DrumBlockRecipes;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ItemStackHelper;
import net.minecraft.inventory.SlotFurnaceFuel;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemHoe;
import net.minecraft.item.ItemStack;
import net.minecraft.item.ItemSword;
import net.minecraft.item.ItemTool;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ITickable;
import net.minecraft.util.NonNullList;
import net.minecraft.util.text.ITextComponent;
import net.minecraft.util.text.TextComponentString;
import net.minecraft.util.text.TextComponentTranslation;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.fml.common.registry.GameRegistry;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import net.minecraftforge.items.CapabilityItemHandler;

public class TileEntityDrum extends TileEntity implements IInventory, ITickable
{
    private NonNullList<ItemStack> inventory = NonNullList.<ItemStack>withSize(4, ItemStack.EMPTY);
    private String customname;
    
    private int burnTime;
    private int currentBurnTime;
    private int cookTime;
    private int totalCookTime;
    @Override
    public String getName()
    {
        return this.hasCustomName() ? this.customname : "container.machines_block";
    }
    @Override
    public boolean hasCustomName()
    {
        return this.customname != null && !this.customname.isEmpty();
    }
    
    public void setCustomname(String customname)
    {
        this.customname = customname;
    }
    
    @Override
    public ITextComponent getDisplayName()
    {
        return this.hasCustomName() ? new TextComponentString(this.getName()) : new TextComponentTranslation(this.getName());
    }
    
    @Override
    public int getSizeInventory()
    {
        return this.inventory.size();
    }
    @Override
    public boolean isEmpty()
    {
     for(ItemStack stack : this.inventory)
       {
         if(!stack.isEmpty())return false;
       }
      return true;
    }
    @Override
    public ItemStack getStackInSlot(int index)
    {
        return (ItemStack)this.inventory.get(index);
    }
    @Override
    public ItemStack decrStackSize(int index, int count)
    {
        return ItemStackHelper.getAndSplit(this.inventory, index, count);
    }
    @Override
    public ItemStack removeStackFromSlot(int index)
    {
        return ItemStackHelper.getAndRemove(this.inventory, index);
    }
    @Override
    public void setInventorySlotContents(int index, ItemStack stack)
    {
     ItemStack itemstack = (ItemStack)this.inventory.get(index);
     boolean flag = !stack.isEmpty() && stack.isItemEqual(itemstack) && ItemStack.areItemStackTagsEqual(stack, itemstack);
     this.inventory.set(index, stack);
    
     if(stack.getCount() > this.getInventoryStackLimit())
         stack.setCount(this.getInventoryStackLimit());
     if(index == 0 && index + 1 == 1 && !flag)
     {
         ItemStack stack1 = (ItemStack)this.inventory.get(index + 1);
         this.totalCookTime = this.getCookTime(stack, stack1);
         this.cookTime = 0;
         this.markDirty();
     }
    }
    
    public int getCookTime(ItemStack stack, ItemStack stack1)
    {
        return 200;
    }
    
    @Override
    public void readFromNBT(NBTTagCompound compound)
    {
        super.readFromNBT(compound);
        this.inventory = NonNullList.<ItemStack>withSize(this.getSizeInventory(), ItemStack.EMPTY);
        ItemStackHelper.loadAllItems(compound, this.inventory);
        this.burnTime = compound.getInteger("BurnTime");
        this.cookTime = compound.getInteger("CookTime");
        this.totalCookTime = compound.getInteger("CookTimeTotal");
        this.currentBurnTime = getItemBurnTime((ItemStack)this.inventory.get(2));
        
        if(compound.hasKey("CustomName", 8))this.setCustomname(compound.getString("CustomName"));
    }
    
    public static int getItemBurnTime(ItemStack fuel)
    {
        if(fuel.isEmpty()) return 0;
        else
        {
            Item item = fuel.getItem();

            if (item instanceof ItemBlock && Block.getBlockFromItem(item) != Blocks.AIR)
            {
                Block block = Block.getBlockFromItem(item);

                if (block == Blocks.WOODEN_SLAB) return 150;
                if (block.getDefaultState().getMaterial() == Material.WOOD) return 300;
                if (block == Blocks.COAL_BLOCK) return 16000;
            }

            if (item instanceof ItemTool && "WOOD".equals(((ItemTool)item).getToolMaterialName())) return 200;
            if (item instanceof ItemSword && "WOOD".equals(((ItemSword)item).getToolMaterialName())) return 200;
            if (item instanceof ItemHoe && "WOOD".equals(((ItemHoe)item).getMaterialName())) return 200;
            if (item == Items.STICK) return 100;
            if (item == Items.COAL) return 1600;
            if (item == Items.LAVA_BUCKET) return 20000;
            if (item == Item.getItemFromBlock(Blocks.SAPLING)) return 100;
            if (item == Items.BLAZE_ROD) return 2400;

            return GameRegistry.getFuelValue(fuel);
        }
    }
    
    
    @Override
    public NBTTagCompound writeToNBT(NBTTagCompound compound)
    {
        super.writeToNBT(compound);
        compound.setInteger("BurnTime", (short)this.burnTime);
        compound.setInteger("CookTime", (short)this.cookTime);
        compound.setInteger("CookTimeTotal", (short)this.totalCookTime);
        ItemStackHelper.saveAllItems(compound, this.inventory);
        
        if(this.hasCustomName()) compound.setString("CustomName", this.customname);
        return compound;
    }
    
    public String getGuiID()
    {
        return "mdw:drum_block";
        
    }
    
    @Override
    public int getInventoryStackLimit()
    {
        return 64;
    }
    
    public boolean isBurning()
    {
        return this.burnTime > 0;
    }
    
    @SideOnly(Side.CLIENT)
    public static boolean isBurning(IInventory inventory)
    {
        return inventory.getField(0) > 0;
    }
    
    @Override
    public boolean isUsableByPlayer(EntityPlayer player)
    {
        return this.world.getTileEntity(this.pos) != this ? false : player.getDistanceSq((double)this.pos.getX() + 0.5D, (double)this.pos.getY() + 0.5D, (double)this.pos.getZ() + 0.5D) <= 64.0D;
    }
    @Override
    public void openInventory(EntityPlayer player)
    {

    }
    @Override
    public void closeInventory(EntityPlayer player)
    {
    }
    @Override
    public boolean isItemValidForSlot(int index, ItemStack stack)
        {
            if (index == 3) return false;
            else if (index != 2) return true;
            else
            {
                return isItemFuel(stack);
            }
        }
    
    public static boolean isItemFuel(ItemStack fuel)
    {
        return getItemBurnTime(fuel) > 0;
    }
    
    @Override
    public int getField(int id)
        {
            switch(id)
            {
            case 0:
                return this.burnTime;
            case 1:
                return this.currentBurnTime;
            case 2:
                return this.cookTime;
            case 3:
                return this.totalCookTime;
            default:
                return 0;
            }
        }
    @Override
    public void setField(int id, int value)
        {
            switch(id)
            {
            case 0:
                this.burnTime = value;
                break;
            case 1:
                this.currentBurnTime = value;
                break;
            case 2:
                this.cookTime = value;
                break;
            case 3:
                this.totalCookTime = value;
            }
        }
    @Override
    public int getFieldCount()
    {
        return 4;
    }
    @Override
    public void clear()
    {
        this.inventory.clear();
    }

    public void update()
    {
        boolean flag = this.isBurning();
        boolean flag1 = false;

        if (this.isBurning())
        {
            --this.burnTime;
        }

        if (!this.world.isRemote)
        {
            ItemStack itemstack = this.inventory.get(1);

            if (this.isBurning() || !itemstack.isEmpty() && !((ItemStack)this.inventory.get(0)).isEmpty())
            {
                if (!this.isBurning() && this.canSmelt())
                {
                    this.burnTime = getItemBurnTime(itemstack);
                    this.currentBurnTime = this.burnTime;

                    if (this.isBurning())
                    {
                        flag1 = true;

                        if (!itemstack.isEmpty())
                        {
                            Item item = itemstack.getItem();
                            itemstack.shrink(1);

                            if (itemstack.isEmpty())
                            {
                                ItemStack item1 = item.getContainerItem(itemstack);
                                this.inventory.set(1, item1);
                            }
                        }
                    }
                }

            }
        }
    }

    private boolean canSmelt()
    {
        if(((ItemStack)this.inventory.get(0)).isEmpty() || ((ItemStack)this.inventory.get(1)).isEmpty()) return false;
        else
        {
            ItemStack result = DrumBlockRecipes.getInstance().getDrumResult((ItemStack)this.inventory.get(0), (ItemStack)this.inventory.get(1));   
            if(result.isEmpty()) return false;
            else
            {
                ItemStack output = (ItemStack)this.inventory.get(3);
                if(output.isEmpty()) return true;
                if(!output.isItemEqual(result)) return false;
                int res = output.getCount() + result.getCount();
                return res <= 64 && res <= output.getMaxStackSize();
            }
        }
    }
public void smeltItem()
{
    if(this.canSmelt())
    {
        ItemStack input1 = (ItemStack)this.inventory.get(0);
        ItemStack input2 = (ItemStack)this.inventory.get(1);
        ItemStack result =  DrumBlockRecipes.getInstance().getDrumResult(input1, input2);
        ItemStack output = (ItemStack)this.inventory.get(3);
    }
   }
}



Java:
public class DrumBlock extends BlockBase implements ITileEntityProvider {

    public static final PropertyDirection FACING = BlockHorizontal.FACING;
    public static final PropertyBool BURNING = PropertyBool.create("burning");
    
    public DrumBlock(String name) {
        super(name , Material.IRON);
        this.setSoundType(blockSoundType.METAL);
        this.setUnlocalizedName(name);
        this.setHardness(3);
        this.setResistance(20);
        this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH).withProperty(BURNING, false));
    }
 
    @Override
    public Item getItemDropped(IBlockState state, Random rand, int fortune)
    {
        return Item.getItemFromBlock(ModBlocks.DRUM_BLOCK);
    }
    
    @Override
    public ItemStack getItem(World worldIn, BlockPos pos, IBlockState state)
    {
        return new ItemStack(ModBlocks.DRUM_BLOCK);
    }

    @Override
    public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ)
    {
        if(!worldIn.isRemote)
        {
            playerIn.openGui(Main.instance, Reference.GUI_DRUM_BLOCK, worldIn, pos.getX(), pos.getY(), pos.getZ());
        }
       return true;
    }
    
    @Override
    public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state)
    {
    if(!worldIn.isRemote)
    {
        IBlockState north = worldIn.getBlockState(pos.north());
        IBlockState south = worldIn.getBlockState(pos.south());
        IBlockState west = worldIn.getBlockState(pos.west());
        IBlockState east = worldIn.getBlockState(pos.east());
        EnumFacing face = (EnumFacing)state.getValue(FACING);

        if (face == EnumFacing.NORTH && north.isFullBlock() && !south.isFullBlock()) face = EnumFacing.SOUTH;
        else if (face == EnumFacing.SOUTH && south.isFullBlock() && !north.isFullBlock()) face = EnumFacing.NORTH;
        else if (face == EnumFacing.WEST && west.isFullBlock() && !east.isFullBlock()) face = EnumFacing.EAST;
        else if (face == EnumFacing.EAST && east.isFullBlock() && !west.isFullBlock()) face = EnumFacing.WEST;
        worldIn.setBlockState(pos, state.withProperty(FACING, face), 2);
    }
  }
    public static void setState(boolean active, World worldIn, BlockPos pos)
    {
        IBlockState state = worldIn.getBlockState(pos);
        TileEntity tileentity = worldIn.getTileEntity(pos);
        
        if(active) worldIn.setBlockState(pos, ModBlocks.DRUM_BLOCK.getDefaultState().withProperty(FACING, state.getValue(FACING)).withProperty(BURNING, true), 3);
        else worldIn.setBlockState(pos, ModBlocks.DRUM_BLOCK.getDefaultState().withProperty(FACING, state.getValue(FACING)).withProperty(BURNING, false), 3);
        
        if(tileentity != null)
        {
            tileentity.validate();
            worldIn.setTileEntity(pos, tileentity);
        }
    }
@Override
public boolean hasTileEntity(IBlockState state)
{
    return true;
}
@Override
public TileEntity createNewTileEntity(World worldIn, int meta)
{
    return new TileEntityDrum();
}

@Override
public IBlockState getStateForPlacement(World world, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer, EnumHand hand)
{
    return this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite());
}

@Override
public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack)
{
    worldIn.setBlockState(pos, this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite()), 2);
}

  @Override
public void breakBlock(World worldIn, BlockPos pos, IBlockState state)
  {
    TileEntityDrum tileentity = (TileEntityDrum)worldIn.getTileEntity(pos);
    InventoryHelper.dropInventoryItems(worldIn, pos, tileentity);
    super.breakBlock(worldIn, pos, state);;
  }

@Override
public EnumBlockRenderType getRenderType(IBlockState state)
{
    return EnumBlockRenderType.MODEL;
}

@Override
public IBlockState withRotation(IBlockState state, Rotation rot)
{
    return state.withProperty(FACING, rot.rotate((EnumFacing)state.getValue(FACING)));
}

@Override
public IBlockState withMirror(IBlockState state, Mirror mirrorIn)
{
   return state.withRotation(mirrorIn.toRotation((EnumFacing)state.getValue(FACING)));
}

@Override
protected BlockStateContainer createBlockState()
{
  return new BlockStateContainer(this, new IProperty[] {BURNING, FACING});
}

@Override
public IBlockState getStateFromMeta(int meta)
{
    EnumFacing facing = EnumFacing.getFront(meta);
    if(facing.getAxis() == EnumFacing.Axis.Y) facing = EnumFacing.NORTH;
    return this.getDefaultState().withProperty(FACING, facing);
}

@Override
public int getMetaFromState(IBlockState state)
 {
    return ((EnumFacing)state.getValue(FACING)).getIndex();
 }
}

Java:
package en.tiref.Mydecoratedworld.inventory.container;

import en.tiref.Mydecoratedworld.inventory.Slots.SlotDrumFuel;
import en.tiref.Mydecoratedworld.inventory.Slots.SlotDrumFurnaceOutput;
import en.tiref.Mydecoratedworld.inventory.tileentity.TileEntityDrum;
import en.tiref.Mydecoratedworld.util.RecipesMachine.DrumBlockRecipes;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.IContainerListener;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

public class ContainerDrum extends Container
{
private final TileEntityDrum tileentity;
private int  cookTime, totalCookTime, burnTime, currentBurnTime;

public ContainerDrum(InventoryPlayer player, TileEntityDrum tileentity)
  {
    this.tileentity = tileentity;
    
    this.addSlotToContainer(new Slot(tileentity, 0, 27, 12));
    this.addSlotToContainer(new Slot(tileentity, 0, 26, 59));
    this.addSlotToContainer(new SlotDrumFuel(tileentity, 2, 7, 35));
    this.addSlotToContainer(new SlotDrumFurnaceOutput(player.player, tileentity, 3, 81, 36));
 
    for(int y = 0; y < 3; y++)
    {
        for(int x = 0; x < 9; x++)
        {
            this.addSlotToContainer(new Slot(player, x + y*9 + 9, 8 + x*18, 84 + y*18));
        }
    }
    
    for(int x = 0; x < 9; x++)
    {
        this.addSlotToContainer(new Slot(player, x, 8 + x * 18, 142));
    }
  }
  @Override
    public void addListener(IContainerListener listener)
    {
        super.addListener(listener);
        listener.sendAllWindowProperties(this, this.tileentity);
    }
 
    
    @Override
    public void detectAndSendChanges()
    {
        super.detectAndSendChanges();
        
        for(int i = 0; i < this.listeners.size(); ++i)
        {
            IContainerListener listener = (IContainerListener)this.listeners.get(i);
            
            if(this.cookTime != this.tileentity.getField(2)) listener.sendWindowProperty(this, 2, this.tileentity.getField(2));
            if(this.burnTime != this.tileentity.getField(0)) listener.sendWindowProperty(this, 0, this.tileentity.getField(0));
            if(this.currentBurnTime != this.tileentity.getField(1)) listener.sendWindowProperty(this, 1, this.tileentity.getField(1));
            if(this.totalCookTime != this.tileentity.getField(3)) listener.sendWindowProperty(this, 3, this.tileentity.getField(3));
        }
        
        this.cookTime = this.tileentity.getField(2);
        this.burnTime = this.tileentity.getField(0);
        this.currentBurnTime = this.tileentity.getField(1);
        this.totalCookTime = this.tileentity.getField(3);
    }
    
    @Override
    @SideOnly(Side.CLIENT)
    public void updateProgressBar(int id, int data)
    {
        this.tileentity.setField(id, data);
    }
    
    @Override
    public boolean canInteractWith(EntityPlayer playerIn)
    {
        return this.tileentity.isUsableByPlayer(playerIn);
    }
    
    @Override
    public ItemStack transferStackInSlot(EntityPlayer playerIn, int index)
    {
        ItemStack stack = ItemStack.EMPTY;
        Slot slot = (Slot)this.inventorySlots.get(index);
        
        if(slot != null && slot.getHasStack())
        {
            ItemStack stack1 = slot.getStack();
            stack = stack1.copy();
            
            if(index == 3)
            {
                if(!this.mergeItemStack(stack1, 4, 40, true)) return ItemStack.EMPTY;
                slot.onSlotChange(stack1, stack);
            }
            else if(index != 2 && index != 1 && index != 0)
            {       
                Slot slot1 = (Slot)this.inventorySlots.get(index + 1);
                
                if(!DrumBlockRecipes.getInstance().getDrumResult(stack1, slot1.getStack()).isEmpty())
                {
                    if(!this.mergeItemStack(stack1, 0, 2, false))
                    {
                        return ItemStack.EMPTY;
                    }
                    else if(TileEntityDrum.isItemFuel(stack1))
                    {
                        if(!this.mergeItemStack(stack1, 2, 3, false)) return ItemStack.EMPTY;
                    }
                    else if(TileEntityDrum.isItemFuel(stack1))
                    {
                        if(!this.mergeItemStack(stack1, 2, 3, false)) return ItemStack.EMPTY;
                    }
                    else if(TileEntityDrum.isItemFuel(stack1))
                    {
                        if(!this.mergeItemStack(stack1, 2, 3, false)) return ItemStack.EMPTY;
                    }
                    else if(index >= 4 && index < 31)
                    {
                        if(!this.mergeItemStack(stack1, 31, 40, false)) return ItemStack.EMPTY;
                    }
                    else if(index >= 31 && index < 40 && !this.mergeItemStack(stack1, 4, 31, false))
                    {
                        return ItemStack.EMPTY;
                    }
                }
            }
            else if(!this.mergeItemStack(stack1, 4, 40, false))
            {
                return ItemStack.EMPTY;
            }
            if(stack1.isEmpty())
            {
                slot.putStack(ItemStack.EMPTY);
            }
            else
            {
                slot.onSlotChanged();

            }
            if(stack1.getCount() == stack.getCount()) return ItemStack.EMPTY;
            slot.onTake(playerIn, stack1);
        }
        return stack;
    }
}



Java:
ackage en.tiref.Mydecoratedworld.inventory.Gui;

import en.tiref.Mydecoratedworld.inventory.container.ContainerDrum;
import en.tiref.Mydecoratedworld.inventory.tileentity.TileEntityDrum;
import en.tiref.Mydecoratedworld.util.Reference;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.util.ResourceLocation;


public class GuiDrum extends GuiContainer
{

private static final ResourceLocation TEXTURES = new ResourceLocation(Reference.MOD_ID + ":textures/gui/drum_gui.png");

 private final InventoryPlayer player;
 private final TileEntityDrum tileentity;
 
 public GuiDrum(InventoryPlayer player, TileEntityDrum tileentity)
 {
    super(new ContainerDrum(player, tileentity));
    this.player = player;
    this.tileentity = tileentity;
            
}
 
 @Override
    protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY)
    {
        String tileName = this.tileentity.getDisplayName().getUnformattedText();
        this.fontRenderer.drawString(tileName, (this.xSize / 2 - this.fontRenderer.getStringWidth(tileName) / 2) + 3, 8, 4210752);
        this.fontRenderer.drawString(this.player.getDisplayName().getUnformattedText(), 122, this.ySize - 96 + 2, 4210752);
    }
 
 @Override
    protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY)
    {
        GlStateManager.color(1.0f, 1.0f, 1.0f, 1.0f);
        this.mc.getTextureManager().bindTexture(TEXTURES);
        this.drawTexturedModalRect(this.guiLeft, this.guiTop, 0, 0, this.xSize, this.ySize);
    }
 
 private int getBurnLeftScaled(int pixels)
 {
        int i = this.tileentity.getField(1);
        if(i == 0) i = 200;
        return this.tileentity.getField(0) * pixels / i;
 }
 
    private int getCookProgressScaled(int pixels)
    {
        int i = this.tileentity.getField(2);
        int j = this.tileentity.getField(3);
        return j != 0 && i != 0 ? i * pixels / j : 0;
    }
}
 
683
3
21
Java:
package en.tiref.Mydecoratedworld.inventory.Gui;

import en.tiref.Mydecoratedworld.inventory.container.ContainerDrum;
import en.tiref.Mydecoratedworld.inventory.tileentity.TileEntityDrum;
import en.tiref.Mydecoratedworld.util.Reference;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.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)
{
    if(ID == Reference.GUI_DRUM_BLOCK) return new ContainerDrum(player.inventory, (TileEntityDrum)world.getTileEntity(new BlockPos(x,y,z)));
    return null;
}
@Override
    public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z)
   {
    if(ID == Reference.GUI_DRUM_BLOCK) return new GuiDrum(player.inventory, (TileEntityDrum)world.getTileEntity(new BlockPos(x,y,z)));
        return null;
    }
}
Мне кажется что тут чего-то нехватает:unsure:
 

timaxa007

Модератор
5,831
409
672
699
9
53
Java:
 public void initRegistries()
{
     NetworkRegistry.INSTANCE.registerGuiHandler(Main.instance, new GuiHandler());
}
А initRegistries() ты где вызываешь?
//Оффтоп
Что у тебя за странная система именования пакетов? Почему en.tiref? Ты англичанин? Более правильно будет ru.tiref, и названия пакетов правильнее писать с маленькой буквы вместо Mydecoratedworld mydecoratedworld, а ещё лучше вместо mydecoratedworld модид мода, если он конечно другой.
 
Последнее редактирование:
Сверху