Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/hbmmods/hbm-s-nuclear-tech-git/llms.txt

Use this file to discover all available pages before exploring further.

The conveyor belt system in HBM’s Nuclear Tech Mod provides a powerful, player-independent way to move items across your factory floor. Rather than relying on hoppers or manual chest-to-chest transfers, conveyors carry individual item entities across a network of connected belt tiles, depositing them into machines as they arrive at compatible faces. This allows large-scale manufacturing pipelines — from ore washing to fuel rod assembly — to operate continuously without player interaction. The system is modular: straight belts, curved sections, vertical lifts, and filter-capable tubes can all be combined, and the Conveyor Wand (contributed by MellowArpeggiation) makes configuring multi-block layouts far easier.

​
Core Interfaces

The conveyor system is built around four tightly related Java interfaces. Understanding them clarifies how items flow and how to extend the system.
Any block that acts as a conveyor must implement api.hbm.conveyor.IConveyorBelt. The interface exposes three methods:
// Returns true if the item should stay on the belt; false causes it to drop off
public boolean canItemStay(World world, int x, int y, int z, Vec3 itemPos);

// Returns the next position the item should move toward, accounting for belt speed
public Vec3 getTravelLocation(World world, int x, int y, int z, Vec3 itemPos, double speed);

// Snaps an item to the nearest valid centre-line on the belt
public Vec3 getClosestSnappingPosition(World world, int x, int y, int z, Vec3 itemPos);
getTravelLocation is called every tick on the server. The returned Vec3 is the destination the item entity moves toward; the speed parameter comes from the item entity itself and may be modified by belt modifiers. canItemStay lets belts eject items at specific positions — for example, a sorter belt can return false when an item does not match its filter, causing it to fall into a chute below.
Entities that can travel on conveyor belts implement api.hbm.conveyor.IConveyorItem:
public ItemStack getItemStack();
The entity exposes its payload as a standard ItemStack. Belt tile entities query this to apply filter logic and to determine what to place into destination machine inventories.
For higher-throughput transport, packages group multiple stacks together:
public ItemStack[] getItemStacks();
A package entity can carry an array of stacks and is treated as a single travelling unit. This reduces the number of entities on the belt and improves performance for bulk transfers.
Any block that should receive items from an arriving belt must implement api.hbm.conveyor.IEnterableBlock:
public boolean canItemEnter(World world, int x, int y, int z, ForgeDirection dir, IConveyorItem entity);
public void onItemEnter(World world, int x, int y, int z, ForgeDirection dir, IConveyorItem entity);

public boolean canPackageEnter(World world, int x, int y, int z, ForgeDirection dir, IConveyorPackage entity);
public void onPackageEnter(World world, int x, int y, int z, ForgeDirection dir, IConveyorPackage entity);
When a belt item reaches the edge of a belt tile adjacent to an IEnterableBlock, it calls canItemEnter with the approach direction. If that returns true, onItemEnter fires, the entity despawns, and the machine handles inserting the item into its inventory. This is how belts feed furnaces, presses, centrifuges, and other processing machines automatically.

​
Available Conveyor Types

NTM ships several belt variants, each suited to a different part of a factory layout:
BlockClassPurpose
Classic ConveyorBlockConveyorClassicStraight single-lane belt, the bread-and-butter of any factory
Bendable ConveyorBlockConveyorBendableCurved section for 90° turns without a gap
Double ConveyorBlockConveyorDoubleSide-by-side dual lanes, doubles throughput
Triple ConveyorBlockConveyorTripleTriple-lane belt for bulk material lines
Express ConveyorBlockConveyorExpressFaster belt for time-sensitive transfers
Conveyor LiftBlockConveyorLiftVertical transport between floors
Conveyor ChuteBlockConveyorChuteDrops items downward under gravity
Belts are directional. Right-clicking a belt with the Conveyor Wand (contributed by MellowArpeggiation) allows you to rotate sections and set filter patterns on applicable belt types without breaking and replacing blocks.

​
Connecting Belts to Machines

For a machine to accept items from a belt, its tile entity must implement IEnterableBlock. Most NTM processing machines already do. The key rules:
1

Orient the belt toward the correct face

Most machines have a designated input face. Check the machine’s GUI — the slot highlighted as “input” corresponds to the side the belt should approach from.
2

Ensure the belt terminates adjacent to the machine

The last belt tile must share a face with the machine block. A gap of even one block will cause the item entity to drop as a loose item rather than enter the machine.
3

Check filter configuration (if applicable)

Some belts support item filters via the ModulePatternMatcher system. Open the belt’s GUI with the Conveyor Wand and place filter items in the pattern slots. Only matching items will be routed to that output face; non-matching items continue along the belt.
4

Test with a single item

Before running production, throw a single item onto the input end of the belt and watch it travel. Confirm it enters the machine rather than falling off the end.

​
Pneumatic Item Transport

For longer distances or situations where belts are impractical, NTM includes a pneumatic tube network. Pneumatic transport is handled by TileEntityPneumoTube, with storage nodes connected via TileEntityPneumoStorageAccess and clutter filters via TileEntityPneumoStorageClutter. Any block can participate in the pneumatic network by implementing api.hbm.ntl.IPneumaticConnector: 
public interface IPneumaticConnector {
    /**
     * Whether the given side can be connected to.
     * @param dir The side of this block, not the one trying to connect.
     */
    public default boolean canConnectPneumatic(ForgeDirection dir) {
        return dir != ForgeDirection.UNKNOWN;
    }
}
By default the interface allows connection from any cardinal direction. Override canConnectPneumatic to restrict connections to specific faces (e.g., only the top or bottom of a machine). The TileEntityPneumoTube supports:
  • 15-slot item filter with pattern matching via ModulePatternMatcher
  • Configurable insertion and ejection directions
  • Whitelist / blacklist mode toggle
  • Redstone gate (enable/disable transport on redstone signal)
  • Send and receive order settings for priority routing
  • An internal air pressure tank (Fluids.AIR at 4,000 mB with 1 pressure) that powers the tube
The pneumatic network requires the tube segments to form a contiguous network registered in UniNodespace. Breaking a tube mid-network will split the network; items in transit at the time of the break will be lost.

​
Factory Layout Tips

Long unbroken belts with no branches are fine for throughput, but they make debugging hard. Add a labeled chest or barrel at key waypoints so you can inspect what items are flowing past.
Rather than snaking belts around your base, use BlockConveyorLift to carry items directly up a single column. Pair with a chute at the top floor to redirect items horizontally.
Place a sorting belt one block before the machine input rather than at the belt’s origin. This ensures incorrectly-routed items are caught close to their destination and can be redirected rather than travelling the entire line.
Wire an RoR Item Counter to a chest at the end of a production line. When count thresholds are met, use an RoR Controller to halt upstream belts via redstone signals, preventing overflow. See the Redstone Over Radio page for setup details.

Build docs developers (and LLMs) love

Get started for freeTalk to us