Перевод [Ⅰ-Ⅱ части] Обучающий API-интерфейс Zero CORE Multiblock

protected abstract int getMaximumXSize();

protected abstract int getMaximumZSize();

protected abstract int getMaximumYSize();

protected int getMinimumXSize()

protected int getMinimumYSize()

protected int getMinimumZSize()

private MightyFurnaceIOPortTileEntity _inputPort;
private MightyFurnaceIOPortTileEntity _outputPort;
private MightyFurnacePowerTileEntity _powerPort;
private boolean _active;

@Override
protected boolean isBlockGoodForFrame(World world, int x, int y, int z, IMultiblockValidator validatorCallback) {

    validatorCallback.setLastError("Zero COREtest:api.multiblock.validation.invalid_block", x, y, z);
    return false;
}

@Override
protected int getMinimumNumberOfBlocksForAssembledMachine() {return 27;}

@Override
protected int getMaximumXSize() {return MACHINE_SIZE;}

@Override
protected int getMaximumZSize() {return MACHINE_SIZE;}

@Override
protected int getMaximumYSize() {return MACHINE_SIZE;}

@Override
protected int getMinimumXSize() {return MACHINE_SIZE;}

@Override
protected int getMinimumYSize() {return MACHINE_SIZE;}

@Override
protected int getMinimumZSize() {return MACHINE_SIZE;}

private static final int MACHINE_SIZE = 3;

@Override
protected boolean isMachineWhole(IMultiblockValidator validatorCallback) {

    MightyFurnacePowerTileEntity powerPort = null;
    MightyFurnaceIOPortTileEntity inputPort = null;
    MightyFurnaceIOPortTileEntity outputPort = null;

    if (!super.isMachineWhole(validatorCallback))
        return false;

for (IMultiblockPart part : this.connectedParts) {

        if (part instanceof MightyFurnacePowerTileEntity) {

            if (null != powerPort) {

                validatorCallback.setLastError("Zero COREtest:api.multiblock.validation.powerport_already_present");
                return false;
            }

            powerPort = (MightyFurnacePowerTileEntity)part;

 else if (part instanceof MightyFurnaceIOPortTileEntity) {

            MightyFurnaceIOPortTileEntity io = (MightyFurnaceIOPortTileEntity) part;
            boolean isInput = io.isInput();

            if (isInput) {

                if (null != inputPort) {

                    validatorCallback.setLastError("Zero COREtest:api.multiblock.validation.inputport_already_present");
                    return false;
                }

                inputPort = io;

            } else {

                if (null != outputPort) {

                    validatorCallback.setLastError("Zero COREtest:api.multiblock.validation.outputport_already_present");
                    return false;
                }

                outputPort = io;
            }
        }
    }

if (null == powerPort) {

        validatorCallback.setLastError("Zero COREtest:api.multiblock.validation.powerport_missing");
        return false;
    }

    if (null == inputPort) {

        validatorCallback.setLastError("Zero COREtest:api.multiblock.validation.inputport_missing");
        return false;
    }

    if (null == outputPort) {

        validatorCallback.setLastError("Zero COREtest:api.multiblock.validation.outputport_missing");
        return false;
    }

    return true;
}

@Override
protected void onMachineAssembled() {

    this.lookupPorts();

    if (WorldHelper.calledByLogicalClient(this.WORLD))
        //На клиенте принудительно обновить рендер
        this.markMultiblockForRenderUpdate();
}

@Override
protected void onBlockRemoved(IMultiblockPart oldPart) {

    if (oldPart instanceof MightyFurnacePowerTileEntity) {

        MightyFurnacePowerTileEntity tile = (MightyFurnacePowerTileEntity)oldPart;

        if (this._powerPort == tile)
            this._powerPort = null;

    } else if (oldPart instanceof MightyFurnaceIOPortTileEntity) {

        MightyFurnaceIOPortTileEntity tile = (MightyFurnaceIOPortTileEntity)oldPart;

        if (this._outputPort == tile)
            this._outputPort = null;
        else if (this._inputPort == tile)
            this._inputPort = null;
    }
}

public void setActive(boolean active) {

    if (this._active == active)
        return;

    //Состояние было изменено
    this._active = active;

    if (WorldHelper.calledByLogicalServer(this.WORLD)) {

        //На стороне сервера, запросите обновление, которое будет отправлено клиенту
        this.markReferenceCoordForUpdate();
        this.markReferenceCoordDirty();

    } else {

        //На клиенте, запросите обновление рендеринга
        this.markMultiblockForRenderUpdate();
    }
}

public void toggleActive() {
    this.setActive(!this._active);
}

@Override
protected void syncDataTo(NBTTagCompound data, ModTileEntity.SyncReason syncReason) {
    data.setBoolean("isActive", this.isActive());

@Override
protected void syncDataFrom(NBTTagCompound data, ModTileEntity.SyncReason syncReason) {

    if (data.hasKey("isActive"))
        this.setActive(data.getBoolean("isActive"));

@Override
public Class<? extends MultiblockControllerBase> getMultiblockControllerType() {
    return MightyFurnaceController.class;
}

@Override
public MultiblockControllerBase createNewMultiblock() {
    return new MightyFurnaceController(this.worldObj);
}

@Override
public boolean isGoodForFrame(IMultiblockValidator validatorCallback) {

    validatorCallback.setLastError(MightyFurnaceIOPortTileEntity.s_invalidPosition);
    return false;
}

private static ValidationError s_invalidPosition = new     ValidationError("Zero COREtest:api.multiblock.validation.ioport_invalid_position");

protected MightyFurnaceController getFurnaceController(IBlockAccess world, BlockPos position) {

    MultiblockControllerBase controller = this.getMultiblockController(world, position);

    return controller instanceof MightyFurnaceController ? (MightyFurnaceController)controller : null;

@Override
public boolean onBlockActivated(World world, BlockPos position, IBlockState state, EntityPlayer player, EnumHand hand, ItemStack heldItem, EnumFacing side, float hitX, float hitY, float hitZ) {

    if (world.isRemote || (hand != EnumHand.OFF_HAND) || (null != heldItem))
        return false;

MightyFurnaceController controller = this.getFurnaceController(world, position);

    if (null != controller) {

        if (player.isSneaking()) {

            //Переключить состояние машины
            controller.toggleActive();
            return true;

        } else {

            //Отображать любые ошибки проверки

            ValidationError status = controller.getLastError();

            if (null != status) {

                player.addChatMessage(status.getChatMessage());
                return true;
            }

    }
    return false;
}

protected IMultiblockPart getMultiblockPartAt(IBlockAccess world, BlockPos position) {

    TileEntity te = world.getTileEntity(position);

    return te instanceof IMultiblockPart ? (IMultiblockPart)te : null;
}

@Override
public IBlockState getActualState(IBlockState state, IBlockAccess world, BlockPos position) {

    IMultiblockPart part = this.getMultiblockPartAt(world, position);

    if (part instanceof MightyFurnaceTileEntity) {

        MightyFurnaceTileEntity wallTile = (MightyFurnaceTileEntity)part;
        boolean assembled = wallTile.isConnected() && wallTile.getMultiblockController().isAssembled();

        state = state.withProperty(ASSEMBLED, assembled);

        if (assembled) {

            switch (wallTile.getPartPosition()) {

                case NorthFace:
                    state = state.withProperty(HFACING, EnumFacing.NORTH);
                    break;

                case SouthFace:
                    state = state.withProperty(HFACING, EnumFacing.SOUTH);
                    break;

                case WestFace:
                    state = state.withProperty(HFACING, EnumFacing.WEST);
                    break;

                case EastFace:
                    state = state.withProperty(HFACING, EnumFacing.EAST);
                    break;
            }
        }
    }

    return state;
}