Multiblock Modules Advanced

What are Multiblock Modules?

The LOGO machine is a multiblock structure built from physical blocks. With the API, addon mods can register custom block types that the multiblock validator recognizes. This lets you add blocks that read new kinds of inputs (rotation, fluid levels, RF rates) or write new kinds of outputs (motor speeds, valve positions) — all integrated into the standard LOGO programming environment.

What you need

Multiblock Layout

The LOGO multiblock is a 3-tall grid that extends rightward from the processing unit:

SpcMultiblockPosition — Where Modules Go

SpcModuleType — Declaring a Module

SpcModuleType is a record that declares a custom module type's identity and placement rules.

Record components

Constructors

// Custom input module type:
SpcModuleType ROT_INPUT = new SpcModuleType(
    "mymod:rotational_input",
    "Rotational Input",
    SpcMultiblockPosition.INPUT_ROW
);

// Custom structural module (no I/O):
SpcModuleType CUSTOM_CASING = new SpcModuleType(
    "mymod:reinforced_casing",
    "Reinforced Casing",
    SpcMultiblockPosition.MIDDLE_ROW,
    false  // not an I/O module
);

ISpcMultiblockModule — Block Interface

Implement this @FunctionalInterface on your Block subclass. The multiblock BFS discovery recognizes blocks that implement this interface.

public class RotationalInputBlock extends Block implements ISpcMultiblockModule {
    @Override
    public String getModuleTypeId() {
        return "mymod:rotational_input";
    }
}

ISpcPhysicalIoHandler — Reading & Writing

The I/O handler bridges your physical block to the signal bus. Registered alongside the SpcModuleType.

public class RotationalIoHandler implements ISpcPhysicalIoHandler {
    @Override
    public SpcSignalValue readInput(ServerLevel level, BlockPos modulePos) {
        var be = level.getBlockEntity(modulePos);
        if (be instanceof RotationalInputBlockEntity rot) {
            return SpcSignalValue.integer(rot.getRotationalSpeed());
        }
        return SpcSignalValue.INTEGER_ZERO;
    }
}

SpcModuleTypeRegistry — Registration

Methods

SpcModuleTypeRegistration (inner record)

Step-by-Step: Custom Input Module

SpcModuleType ROT_INPUT = new SpcModuleType(
    "mymod:rotational_input",
    "Rotational Input",
    SpcMultiblockPosition.INPUT_ROW
);

public class RotationalIoHandler implements ISpcPhysicalIoHandler {
    @Override
    public SpcSignalValue readInput(ServerLevel level, BlockPos pos) {
        if (level.getBlockEntity(pos) instanceof RotInputBE be)
            return SpcSignalValue.integer(be.getRpm());
        return SpcSignalValue.INTEGER_ZERO;
    }
}

public class RotationalInputBlock extends Block implements ISpcMultiblockModule {
    @Override
    public String getModuleTypeId() {
        return "mymod:rotational_input";
    }
}

SpcModuleTypeRegistry.register(ROT_INPUT, new RotationalIoHandler());

SpcSignalValue rpm = context.readCustomInput("mymod:rotational_input", 1);
int speed = rpm.asInteger();

Step-by-Step: Custom Output Module

Same process as input, but:

• Use SpcMultiblockPosition.OUTPUT_ROW
• Override applyOutput() instead of readInput()
• Called during OUTPUT_APPLY phase

public class MotorOutputHandler implements ISpcPhysicalIoHandler {
    @Override
    public void applyOutput(ServerLevel level, BlockPos pos, SpcSignalValue value) {
        if (level.getBlockEntity(pos) instanceof MotorOutputBE be) {
            be.setTargetSpeed(value.asInteger());
        }
    }
}

// Registration:
SpcModuleType MOTOR_OUT = new SpcModuleType(
    "mymod:motor_output", "Motor Output",
    SpcMultiblockPosition.OUTPUT_ROW);
SpcModuleTypeRegistry.register(MOTOR_OUT, new MotorOutputHandler());

// Writing from a node:
context.applyCustomOutputs("mymod:motor_output",
    Map.of(1, SpcSignalValue.integer(targetSpeed)));

Step-by-Step: Non-I/O Module

Structural modules (custom casings, decorative panels) don't provide I/O channels but still validate as part of the multiblock.

// Just register the type with isIoModule = false, no handler:
SpcModuleType CASING = new SpcModuleType(
    "mymod:reinforced_casing", "Reinforced Casing",
    SpcMultiblockPosition.MIDDLE_ROW, false);
SpcModuleTypeRegistry.register(CASING);

// Block still implements ISpcMultiblockModule:
public class ReinforcedCasingBlock extends Block implements ISpcMultiblockModule {
    @Override
    public String getModuleTypeId() {
        return "mymod:reinforced_casing";
    }
}

Reading Custom Modules in Nodes

Once registered, custom modules appear as channels on the execution context. Use readCustomInput() and applyCustomOutputs() (see Execution Context → Custom Module I/O).