beJS & screenJS multiblock w/ i/o "hatches"

multiblock_with_io.js

StartupEvents.registry('block', event => {

	event.create('output_item', 'entity').material('metal').hardness(1.0).displayName('Item Output Hatch')
	    .entity(builder => {
	        builder.itemHandler(9, false)
    })

    event.create('input_item', 'entity').material('metal').hardness(1.0).displayName('Item Input Hatch')
    	.entity(builder => {
    	    builder.itemHandler(9, true)
    })

    event.create('input_energy', 'entity').material('metal').hardness(1.0).displayName('Energy Input Hatch')
        .entity(builder => {
            builder.energyHandler(10000, 1000, 0)
    })

    event.create('output_energy', 'entity').material('metal').hardness(1.0).displayName('Energy Output Hatch')
        .entity(builder => {
            builder.energyHandler(10000, 0, 1000)
    })

    event.create('input_fluid', 'entity').material('metal').hardness(1.0).displayName('Fluid Input Hatch')
        .entity(builder => {
            builder.fluidHandler(1000)
            builder.fluidHandler(1000, fluidStack => true)
            builder.fluidHandler(1000, fluidStack => true)
    })

    event.create('output_fluid', 'entity').material('metal').hardness(1.0).displayName('Fluid Output Hatch')
        .entity(builder => {
            builder.fluidHandler(1000, fluidStack => false)
            builder.fluidHandler(1000, fluidStack => false)
            builder.fluidHandler(1000, fluidStack => false)
    })

})

StartupEvents.registry('menu', event => {

    event.create('output_item', 'block_entity')
        .loop(builder => {
            for (let y = 0; y < 3; y++) {
                for(let x = 0; x < 3; x++) {
                    builder.addOutputSlot(x * 18 + 8, y * 18 + 18, x + y * 3)
                }
            }
        })
        .setBlockEntity('kubejs:output_item')

    event.create('input_item', 'block_entity')
        .loop(builder => {
            for (let y = 0; y < 3; y++) {
                for(let x = 0; x < 3; x++) {
                    builder.addSlot(x * 18 + 8, y * 18 + 18, x + y * 3, 0)
                }
            }
        })
        .setBlockEntity('kubejs:input_item')

    event.create('input_energy', 'block_entity')
        .progressDrawable(8, 66, new Rectangle(0, 0, 16, 48), 'forge:textures/white.png', 'up', 'energy')
        .setBlockEntity('kubejs:input_energy')

    event.create('output_energy', 'block_entity')
        .progressDrawable(8, 66, new Rectangle(0, 0, 16, 48), 'forge:textures/white.png', 'up', 'energy')
        .setBlockEntity('kubejs:output_energy')

    event.create('input_fluid', 'block_entity')
        .fluidDrawable(8, 66, new Rectangle(0, 0, 16, 48), 'forge:textures/white.png', 'up', 0)
        .fluidDrawable(32, 66, new Rectangle(0, 0, 16, 48), 'forge:textures/white.png', 'up', 1)
        .fluidDrawable(48, 66, new Rectangle(0, 0, 16, 48), 'forge:textures/white.png', 'up', 2)
        .setBlockEntity('kubejs:input_fluid')

    event.create('output_fluid', 'block_entity')
        .fluidDrawable(8, 66, new Rectangle(0, 0, 16, 48), 'forge:textures/white.png', 'up', 0)
        .fluidDrawable(32, 66, new Rectangle(0, 0, 16, 48), 'forge:textures/white.png', 'up', 1)
        .fluidDrawable(48, 66, new Rectangle(0, 0, 16, 48), 'forge:textures/white.png', 'up', 2)
        .setBlockEntity('kubejs:output_fluid')
})

StartupEvents.registry('block', event => {
    let CAP_PREDICATE = be => {
        return be != null && (be.getCapability(ForgeCapabilities.ITEM_HANDLER).present || be.getCapability(ForgeCapabilities.FLUID_HANDLER).present || be.getCapability(ForgeCapabilities.ENERGY).present)
    }

	event.create('multi_block', 'multiblock').material('wood').hardness(1.0).displayName('Multiblock')
	    .entity(builder => { // adds a BlockEntity onto this block
	        builder.ticker((level, pos, state, be) => { // a tick method, called on block entity tick
                multi(level, pos, state, be)
        	})
        	.pattern(() => {
        	    return BlockPatternBuilder.start()
        	        .aisle( 'BBB',
                            'ACA',
                            'AAA')
                    .aisle( 'BBB',
                            'AAA',
                            'AAA')
                    .aisle( 'BBB',
                            'AAA',
                            'AAA')
                    .where('A', BlockInWorld.or(BlockInWorld.hasState(BlockPredicate.forBlock('minecraft:iron_block')), BlockInWorld.hasBlockEntity(CAP_PREDICATE)))
                    .where('C', BlockInWorld.hasState(BlockPredicate.forBlock('kubejs:multi_block')))
                    .where('B', BlockInWorld.hasState(BlockPredicate.forBlock('minecraft:copper_block')))
        	})
        })
        .property(BlockProperties.HORIZONTAL_FACING)
        .defaultState(state => {
            state.setValue(BlockProperties.HORIZONTAL_FACING, Direction.NORTH)
        })
        .placementState(state => {
            state.setValue(BlockProperties.HORIZONTAL_FACING, state.horizontalDirection.opposite)
        })
})

StartupEvents.registry('recipe_type', event => {
    event.create('multi_block')
        .assembler((recipe, container) => {
            let results = recipe.results
            for (let i = 0; i < results.size(); ++i) {
                container.setItem(i, results.get(i))
            }
        })
        .maxInputs(2)
        .maxOutputs(4)
        .toastSymbol('kubejs:multi_block')
})


function multi(level, pos, state, be) {
    if(!level.clientSide) {
        if(level.levelData.gameTime % 20 == 0) {
            let energyInput = be.inputEnergy
            let outputItems = be.outputItem
            let outputFluids = be.outputFluid
            let inputItems = be.inputItem
            if (inputItems == null || outputItems == null || outputFluids == null || energyInput == null) {
                return
            }
            //console.info('passed 1')

            let item = inputItems.getContainer(0)

            let wrapper = new RecipeWrapper(item)
            let recipe = level.server.recipeManager.getRecipeFor('kubejs:multi_block', wrapper, level).orElse(null)

            if (recipe != null && energyInput.extractEnergy(recipe.energy, true) >= recipe.energy) {
                let outputItem = outputItems.getContainer(0)

                console.info('passed 2')

                let itemsFinal = new Map()
                let fluidsFinal = new Map()

                energyInput.extractEnergy(recipe.energy, false)

                for (let i = 0; i < recipe.itemResults.size(); ++i) {
                    let resultStack = recipe.itemResults.get(i)
                    let firstFreeSlot = findFirstFreeSlot(outputItem, resultStack)
                    if (firstFreeSlot != -1) {
                        itemsFinal.set(firstFreeSlot, resultStack)
                    } else {
                        return
                    }
                }
                console.info('passed 3')

                for (let i = 0; i < recipe.fluidResults.size(); ++i) {
                    let resultStack = recipe.fluidResults.get(i)
                    let firstFreeTank = findFirstFreeTank(outputFluids, resultStack)
                    if (firstFreeTank != -1) {
                        fluidsFinal.set(firstFreeTank, resultStack)
                    } else {
                        return
                    }
                }
                console.info('passed 4')

                for (let [key, value] of itemsFinal) {
                    outputItem.setStackInSlot(key, value)
                }
                for (let [key, value] of fluidsFinal) {
                    outputFluids.setFluid(key, value)
                }
                console.info('passed 5')
            }
        }

    }
}

function findFirstFreeSlot(container, stack) {
    for (let i = 0; i < container.slots; ++i) {
        let slotStack = container.getStackInSlot(i)
        if (slotStack.empty || (slotStack.matches(slotStack, stack) && container.getSlotLimit(i) >= slotStack.count + stack.count)) {
            return i
        }
    }
    return -1
}

function findFirstFreeTank(handler, stack) {
    for (let i = 0; i < handler.tanks; ++i) {
        let slotStack = handler.getFluidInTank(i)
        if (slotStack.empty || (slotStack['isFluidEqual(net.minecraftforge.fluids.FluidStack)'](stack) && handler.getTankCapacity(i) >= slotStack.amount + stack.amount)) {
            return i
        }
    }
    return -1
}

recipe.js

// priority: 0

console.info('Hello, World! (You will see this line every time server resources reload)')

ServerEvents.recipes(event => {
	// Change recipes here
	event.recipes.kubejs.multi_block(
	    ['3x minecraft:dirt', '1x minecraft:grass', '5x kubejs:example_block', '2x minecraft:cobblestone'],
	    ['10x minecraft:stone'],
	    [Fluid.of('minecraft:milk', 100)],
	    [Fluid.of('minecraft:water', 1000), Fluid.of('minecraft:lava', 500)])
	    .energy(1000)
	    .time(100)
})

ServerEvents.tags('item', event => {
	// Get the #forge:cobblestone tag collection and add Diamond Ore to it
	// event.get('forge:cobblestone').add('minecraft:diamond_ore')

	// Get the #forge:cobblestone tag collection and remove Mossy Cobblestone from it
	// event.get('forge:cobblestone').remove('minecraft:mossy_cobblestone')
})