Merge branch 'mc1.15/contraption-experimental' into mc1.15/dev

src/main/java/com/simibubi/create/AllBlocks.java

@@ -46,6 +46,7 @@ import com.simibubi.create.content.contraptions.components.motor.CreativeMotorGe
 import com.simibubi.create.content.contraptions.components.press.MechanicalPressBlock;
 import com.simibubi.create.content.contraptions.components.saw.SawBlock;
 import com.simibubi.create.content.contraptions.components.saw.SawGenerator;
+import com.simibubi.create.content.contraptions.components.structureMovement.bearing.StabilizedBearingMovementBehaviour;
 import com.simibubi.create.content.contraptions.components.structureMovement.bearing.ClockworkBearingBlock;
 import com.simibubi.create.content.contraptions.components.structureMovement.bearing.MechanicalBearingBlock;
 import com.simibubi.create.content.contraptions.components.structureMovement.bearing.SailBlock;
@@ -668,6 +669,7 @@ public class AllBlocks {
 		REGISTRATE.block("mechanical_bearing", MechanicalBearingBlock::new)
 			.transform(BuilderTransformers.bearing("mechanical", "gearbox", false))
 			.transform(StressConfigDefaults.setImpact(4.0))
+			.onRegister(addMovementBehaviour(new StabilizedBearingMovementBehaviour()))
 			.register();
 
 	public static final BlockEntry<ClockworkBearingBlock> CLOCKWORK_BEARING =

src/main/java/com/simibubi/create/AllEntityTypes.java

@@ -1,8 +1,11 @@
 package com.simibubi.create;
 
 import com.simibubi.create.content.contraptions.components.actors.SeatEntity;
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntityRenderer;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.ControlledContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.ControlledContraptionEntityRenderer;
+import com.simibubi.create.content.contraptions.components.structureMovement.OrientedContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.OrientedContraptionEntityRenderer;
 import com.simibubi.create.content.contraptions.components.structureMovement.glue.SuperGlueEntity;
 import com.simibubi.create.content.contraptions.components.structureMovement.glue.SuperGlueRenderer;
 import com.simibubi.create.foundation.utility.Lang;
@@ -19,34 +22,38 @@ import net.minecraftforge.fml.client.registry.RenderingRegistry;
 
 public class AllEntityTypes {
 
-	public static final RegistryEntry<EntityType<ContraptionEntity>> CONTRAPTION =
-			register("contraption", ContraptionEntity::new, EntityClassification.MISC, 5, 3, true, ContraptionEntity::build);
-	public static final RegistryEntry<EntityType<ContraptionEntity>> STATIONARY_CONTRAPTION =
-			register("stationary_contraption", ContraptionEntity::new, EntityClassification.MISC, 20, 40, false, ContraptionEntity::build);
-	public static final RegistryEntry<EntityType<SuperGlueEntity>> SUPER_GLUE =
-			register("super_glue", SuperGlueEntity::new, EntityClassification.MISC, 10, Integer.MAX_VALUE, false, SuperGlueEntity::build);
+	public static final RegistryEntry<EntityType<OrientedContraptionEntity>> ORIENTED_CONTRAPTION =
+		register("contraption", OrientedContraptionEntity::new, EntityClassification.MISC, 5, 3, true,
+			AbstractContraptionEntity::build);
+	public static final RegistryEntry<EntityType<ControlledContraptionEntity>> CONTROLLED_CONTRAPTION =
+		register("stationary_contraption", ControlledContraptionEntity::new, EntityClassification.MISC, 20, 40, false,
+			AbstractContraptionEntity::build);
+	public static final RegistryEntry<EntityType<SuperGlueEntity>> SUPER_GLUE = register("super_glue",
+		SuperGlueEntity::new, EntityClassification.MISC, 10, Integer.MAX_VALUE, false, SuperGlueEntity::build);
 	public static final RegistryEntry<EntityType<SeatEntity>> SEAT =
-			register("seat", SeatEntity::new, EntityClassification.MISC, 0, Integer.MAX_VALUE, false, SeatEntity::build);
+		register("seat", SeatEntity::new, EntityClassification.MISC, 0, Integer.MAX_VALUE, false, SeatEntity::build);
 
 	private static <T extends Entity> RegistryEntry<EntityType<T>> register(String name, IFactory<T> factory,
-			EntityClassification group, int range, int updateFrequency, boolean sendVelocity,
-			NonNullConsumer<EntityType.Builder<T>> propertyBuilder) {
+		EntityClassification group, int range, int updateFrequency, boolean sendVelocity,
+		NonNullConsumer<EntityType.Builder<T>> propertyBuilder) {
 		String id = Lang.asId(name);
-		return Create.registrate().entity(id, factory, group)
-				.properties(b -> b
-					.setTrackingRange(range)
-					.setUpdateInterval(updateFrequency)
-					.setShouldReceiveVelocityUpdates(sendVelocity))
-				.properties(propertyBuilder)
-				.register();
+		return Create.registrate()
+			.entity(id, factory, group)
+			.properties(b -> b.setTrackingRange(range)
+				.setUpdateInterval(updateFrequency)
+				.setShouldReceiveVelocityUpdates(sendVelocity))
+			.properties(propertyBuilder)
+			.register();
 	}
 
 	public static void register() {}
 
 	@OnlyIn(value = Dist.CLIENT)
 	public static void registerRenderers() {
-		RenderingRegistry.registerEntityRenderingHandler(STATIONARY_CONTRAPTION.get(), ContraptionEntityRenderer::new);
-		RenderingRegistry.registerEntityRenderingHandler(CONTRAPTION.get(), ContraptionEntityRenderer::new);
+		RenderingRegistry.registerEntityRenderingHandler(CONTROLLED_CONTRAPTION.get(),
+			ControlledContraptionEntityRenderer::new);
+		RenderingRegistry.registerEntityRenderingHandler(ORIENTED_CONTRAPTION.get(),
+			OrientedContraptionEntityRenderer::new);
 		RenderingRegistry.registerEntityRenderingHandler(SUPER_GLUE.get(), SuperGlueRenderer::new);
 		RenderingRegistry.registerEntityRenderingHandler(SEAT.get(), SeatEntity.Render::new);
 	}

src/main/java/com/simibubi/create/AllMovementBehaviours.java

@@ -12,6 +12,7 @@ import com.simibubi.create.content.contraptions.components.structureMovement.Mov
 import com.tterrag.registrate.util.nullness.NonNullConsumer;
 
 import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
 import net.minecraft.block.Blocks;
 import net.minecraft.util.ResourceLocation;
 
@@ -29,16 +30,21 @@ public class AllMovementBehaviours {
 	}
 
 	@Nullable
-	public static MovementBehaviour getMovementBehaviour(ResourceLocation resourceLocation) {
+	public static MovementBehaviour of(ResourceLocation resourceLocation) {
 		return movementBehaviours.getOrDefault(resourceLocation, null);
 	}
 
 	@Nullable
-	public static MovementBehaviour getMovementBehaviour(Block block) {
-		return getMovementBehaviour(block.getRegistryName());
+	public static MovementBehaviour of(Block block) {
+		return of(block.getRegistryName());
 	}
 	
-	public static boolean hasMovementBehaviour(Block block) {
+	@Nullable
+	public static MovementBehaviour of(BlockState state) {
+		return of(state.getBlock());
+	}
+
+	public static boolean contains(Block block) {
 		return movementBehaviours.containsKey(block.getRegistryName());
 	}
 

src/main/java/com/simibubi/create/content/contraptions/components/actors/BlockBreakingMovementBehaviour.java

@@ -1,6 +1,6 @@
 package com.simibubi.create.content.contraptions.components.actors;
 
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
 import com.simibubi.create.content.contraptions.components.structureMovement.MovementBehaviour;
 import com.simibubi.create.content.contraptions.components.structureMovement.MovementContext;
 import com.simibubi.create.foundation.utility.BlockHelper;
@@ -52,12 +52,12 @@ public class BlockBreakingMovementBehaviour extends MovementBehaviour {
 		Entities: for (Entity entity : world.getEntitiesWithinAABB(Entity.class, new AxisAlignedBB(pos))) {
 			if (entity instanceof ItemEntity)
 				continue;
-			if (entity instanceof ContraptionEntity)
+			if (entity instanceof AbstractContraptionEntity)
 				continue;
 			if (entity instanceof AbstractMinecartEntity)
 				for (Entity passenger : entity.getRecursivePassengers())
-					if (passenger instanceof ContraptionEntity
-							&& ((ContraptionEntity) passenger).getContraption() == context.contraption)
+					if (passenger instanceof AbstractContraptionEntity
+							&& ((AbstractContraptionEntity) passenger).getContraption() == context.contraption)
 						continue Entities;
 
 			if (damageSource != null && !world.isRemote) {

src/main/java/com/simibubi/create/content/contraptions/components/actors/SeatBlock.java

@@ -16,7 +16,6 @@ import net.minecraft.block.Blocks;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.entity.MobEntity;
-import net.minecraft.entity.item.minecart.AbstractMinecartEntity;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.DyeColor;
 import net.minecraft.item.ItemGroup;
@@ -132,8 +131,7 @@ public class SeatBlock extends Block {
 	}
 
 	public static boolean canBePickedUp(Entity passenger) {
-		return !(passenger instanceof PlayerEntity)
-			&& (passenger instanceof LivingEntity || passenger instanceof AbstractMinecartEntity);
+		return !(passenger instanceof PlayerEntity) && (passenger instanceof LivingEntity);
 	}
 
 	public static void sitDown(World world, BlockPos pos, Entity entity) {

src/main/java/com/simibubi/create/content/contraptions/components/actors/SeatMovementBehaviour.java

@@ -4,7 +4,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
 import com.simibubi.create.content.contraptions.components.structureMovement.MovementBehaviour;
 import com.simibubi.create.content.contraptions.components.structureMovement.MovementContext;
 import com.simibubi.create.foundation.utility.VecHelper;
@@ -30,7 +30,8 @@ public class SeatMovementBehaviour extends MovementBehaviour {
 	@Override
 	public void visitNewPosition(MovementContext context, BlockPos pos) {
 		super.visitNewPosition(context, pos);
-		ContraptionEntity contraptionEntity = context.contraption.entity;
+		
+		AbstractContraptionEntity contraptionEntity = context.contraption.entity;
 		if (contraptionEntity == null)
 			return;
 		int index = context.data.getInt("SeatIndex");

src/main/java/com/simibubi/create/content/contraptions/components/deployer/DeployerMovementBehaviour.java

@@ -7,7 +7,7 @@ import org.apache.commons.lang3.tuple.Pair;
 
 import com.mojang.blaze3d.matrix.MatrixStack;
 import com.simibubi.create.content.contraptions.components.deployer.DeployerTileEntity.Mode;
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
 import com.simibubi.create.content.contraptions.components.structureMovement.MovementBehaviour;
 import com.simibubi.create.content.contraptions.components.structureMovement.MovementContext;
 import com.simibubi.create.content.logistics.item.filter.FilterItem;
@@ -53,8 +53,8 @@ public class DeployerMovementBehaviour extends MovementBehaviour {
 			.getDirectionVec());
 		facingVec = context.rotation.apply(facingVec);
 		Vec3d vec = context.position.subtract(facingVec.scale(2));
-		player.rotationYaw = ContraptionEntity.yawFromVector(facingVec);
-		player.rotationPitch = ContraptionEntity.pitchFromVector(facingVec) - 90;
+		player.rotationYaw = AbstractContraptionEntity.yawFromVector(facingVec);
+		player.rotationPitch = AbstractContraptionEntity.pitchFromVector(facingVec) - 90;
 
 		DeployerHandler.activate(player, vec, pos, facingVec, mode);
 	}

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/AbstractContraptionEntity.java

@@ -0,0 +1,582 @@
+package com.simibubi.create.content.contraptions.components.structureMovement;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.UUID;
+
+import org.apache.commons.lang3.tuple.MutablePair;
+
+import com.simibubi.create.AllMovementBehaviours;
+import com.simibubi.create.content.contraptions.components.actors.SeatEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.glue.SuperGlueEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.sync.ContraptionSeatMappingPacket;
+import com.simibubi.create.foundation.collision.Matrix3d;
+import com.simibubi.create.foundation.networking.AllPackets;
+import com.simibubi.create.foundation.utility.AngleHelper;
+import com.simibubi.create.foundation.utility.VecHelper;
+
+import net.minecraft.block.material.PushReaction;
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.IProjectile;
+import net.minecraft.entity.item.HangingEntity;
+import net.minecraft.entity.item.minecart.AbstractMinecartEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.network.IPacket;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.network.datasync.DataParameter;
+import net.minecraft.network.datasync.DataSerializers;
+import net.minecraft.network.datasync.EntityDataManager;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Hand;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+import net.minecraft.world.gen.feature.template.Template.BlockInfo;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.fml.common.registry.IEntityAdditionalSpawnData;
+import net.minecraftforge.fml.network.NetworkHooks;
+import net.minecraftforge.fml.network.PacketDistributor;
+
+public abstract class AbstractContraptionEntity extends Entity implements IEntityAdditionalSpawnData {
+
+	private static final DataParameter<Boolean> STALLED =
+		EntityDataManager.createKey(AbstractContraptionEntity.class, DataSerializers.BOOLEAN);
+
+	public final List<Entity> collidingEntities = new ArrayList<>();
+
+	protected Contraption contraption;
+	protected boolean initialized;
+	private boolean prevPosInvalid;
+
+	public AbstractContraptionEntity(EntityType<?> entityTypeIn, World worldIn) {
+		super(entityTypeIn, worldIn);
+		prevPosInvalid = true;
+	}
+
+	protected void setContraption(Contraption contraption) {
+		this.contraption = contraption;
+		if (contraption == null)
+			return;
+		if (world.isRemote)
+			return;
+		contraption.onEntityCreated(this);
+	}
+
+	protected void contraptionInitialize() {
+		contraption.onEntityInitialize(world, this);
+		initialized = true;
+	}
+
+	public boolean collisionEnabled() {
+		return true;
+	}
+
+	public void addSittingPassenger(Entity passenger, int seatIndex) {
+		passenger.startRiding(this, true);
+		if (world.isRemote)
+			return;
+		contraption.getSeatMapping()
+			.put(passenger.getUniqueID(), seatIndex);
+		AllPackets.channel.send(PacketDistributor.TRACKING_ENTITY.with(() -> this),
+			new ContraptionSeatMappingPacket(getEntityId(), contraption.getSeatMapping()));
+	}
+
+	@Override
+	protected void removePassenger(Entity passenger) {
+		Vec3d transformedVector = getPassengerPosition(passenger, 1);
+		super.removePassenger(passenger);
+		if (world.isRemote)
+			return;
+		if (transformedVector != null)
+			passenger.getPersistentData()
+				.put("ContraptionDismountLocation", VecHelper.writeNBT(transformedVector));
+		contraption.getSeatMapping()
+			.remove(passenger.getUniqueID());
+		AllPackets.channel.send(PacketDistributor.TRACKING_ENTITY.with(() -> this),
+			new ContraptionSeatMappingPacket(getEntityId(), contraption.getSeatMapping()));
+	}
+
+	@Override
+	public void updatePassengerPosition(Entity passenger, IMoveCallback callback) {
+		if (!isPassenger(passenger))
+			return;
+		Vec3d transformedVector = getPassengerPosition(passenger, 1);
+		if (transformedVector == null)
+			return;
+		callback.accept(passenger, transformedVector.x, transformedVector.y, transformedVector.z);
+	}
+
+	protected Vec3d getPassengerPosition(Entity passenger, float partialTicks) {
+		UUID id = passenger.getUniqueID();
+		if (passenger instanceof OrientedContraptionEntity) {
+			BlockPos localPos = contraption.getBearingPosOf(id);
+			if (localPos != null)
+				return toGlobalVector(VecHelper.getCenterOf(localPos), partialTicks)
+					.add(VecHelper.getCenterOf(BlockPos.ZERO))
+					.subtract(.5f, 1, .5f);
+		}
+
+		AxisAlignedBB bb = passenger.getBoundingBox();
+		double ySize = bb.getYSize();
+		BlockPos seat = contraption.getSeatOf(id);
+		if (seat == null)
+			return null;
+		Vec3d transformedVector =
+			toGlobalVector(new Vec3d(seat).add(.5, passenger.getYOffset() + ySize - .15f, .5), partialTicks)
+				.add(VecHelper.getCenterOf(BlockPos.ZERO))
+				.subtract(0.5, ySize, 0.5);
+		return transformedVector;
+	}
+
+	@Override
+	protected boolean canFitPassenger(Entity p_184219_1_) {
+		if (p_184219_1_ instanceof OrientedContraptionEntity)
+			return true;
+		return contraption.getSeatMapping()
+			.size() < contraption.getSeats()
+				.size();
+	}
+
+	public boolean handlePlayerInteraction(PlayerEntity player, BlockPos localPos, Direction side,
+		Hand interactionHand) {
+		int indexOfSeat = contraption.getSeats()
+			.indexOf(localPos);
+		if (indexOfSeat == -1)
+			return false;
+
+		// Eject potential existing passenger
+		Entity toDismount = null;
+		for (Entry<UUID, Integer> entry : contraption.getSeatMapping()
+			.entrySet()) {
+			if (entry.getValue() != indexOfSeat)
+				continue;
+			for (Entity entity : getPassengers()) {
+				if (!entry.getKey()
+					.equals(entity.getUniqueID()))
+					continue;
+				if (entity instanceof PlayerEntity)
+					return false;
+				toDismount = entity;
+			}
+		}
+
+		if (toDismount != null && !world.isRemote) {
+			Vec3d transformedVector = getPassengerPosition(toDismount, 1);
+			toDismount.stopRiding();
+			if (transformedVector != null)
+				toDismount.setPositionAndUpdate(transformedVector.x, transformedVector.y, transformedVector.z);
+		}
+
+		if (world.isRemote)
+			return true;
+		addSittingPassenger(player, indexOfSeat);
+		return true;
+	}
+
+	public Vec3d toGlobalVector(Vec3d localVec, float partialTicks) {
+		Vec3d rotationOffset = VecHelper.getCenterOf(BlockPos.ZERO);
+		localVec = localVec.subtract(rotationOffset);
+		localVec = applyRotation(localVec, partialTicks);
+		localVec = localVec.add(rotationOffset)
+			.add(getAnchorVec());
+		return localVec;
+	}
+
+	public Vec3d toLocalVector(Vec3d globalVec, float partialTicks) {
+		Vec3d rotationOffset = VecHelper.getCenterOf(BlockPos.ZERO);
+		globalVec = globalVec.subtract(getAnchorVec())
+			.subtract(rotationOffset);
+		globalVec = reverseRotation(globalVec, partialTicks);
+		globalVec = globalVec.add(rotationOffset);
+		return globalVec;
+	}
+
+	@Override
+	public final void tick() {
+		if (contraption == null) {
+			remove();
+			return;
+		}
+
+		prevPosX = getX();
+		prevPosY = getY();
+		prevPosZ = getZ();
+		prevPosInvalid = false;
+
+		if (!initialized)
+			contraptionInitialize();
+		tickContraption();
+		super.tick();
+	}
+
+	protected abstract void tickContraption();
+
+	public abstract Vec3d applyRotation(Vec3d localPos, float partialTicks);
+
+	public abstract Vec3d reverseRotation(Vec3d localPos, float partialTicks);
+
+	public void tickActors() {
+		boolean stalledPreviously = contraption.stalled;
+
+		if (!world.isRemote)
+			contraption.stalled = false;
+
+		for (MutablePair<BlockInfo, MovementContext> pair : contraption.getActors()) {
+			MovementContext context = pair.right;
+			BlockInfo blockInfo = pair.left;
+			MovementBehaviour actor = AllMovementBehaviours.of(blockInfo.state);
+
+			Vec3d actorPosition = toGlobalVector(VecHelper.getCenterOf(blockInfo.pos)
+				.add(actor.getActiveAreaOffset(context)), 1);
+			BlockPos gridPosition = new BlockPos(actorPosition);
+			boolean newPosVisited =
+				!context.stall && shouldActorTrigger(context, blockInfo, actor, actorPosition, gridPosition);
+
+			context.rotation = v -> applyRotation(v, 1);
+			context.position = actorPosition;
+
+			Vec3d oldMotion = context.motion;
+			if (!actor.isActive(context))
+				continue;
+			if (newPosVisited && !context.stall) {
+				actor.visitNewPosition(context, gridPosition);
+				context.firstMovement = false;
+			}
+			if (!oldMotion.equals(context.motion))
+				actor.onSpeedChanged(context, oldMotion, context.motion);
+			actor.tick(context);
+			contraption.stalled |= context.stall;
+		}
+
+		for (Entity entity : getPassengers()) {
+			if (!(entity instanceof OrientedContraptionEntity))
+				continue;
+			if (!contraption.stabilizedSubContraptions.containsKey(entity.getUniqueID()))
+				continue;
+			OrientedContraptionEntity orientedCE = (OrientedContraptionEntity) entity;
+			if (orientedCE.contraption != null && orientedCE.contraption.stalled) {
+				contraption.stalled = true;
+				break;
+			}
+		}
+
+		if (!world.isRemote) {
+			if (!stalledPreviously && contraption.stalled)
+				onContraptionStalled();
+			dataManager.set(STALLED, contraption.stalled);
+			return;
+		}
+
+		contraption.stalled = isStalled();
+	}
+
+	protected void onContraptionStalled() {
+		AllPackets.channel.send(PacketDistributor.TRACKING_ENTITY.with(() -> this),
+			new ContraptionStallPacket(getEntityId(), getX(), getY(), getZ(), getStalledAngle()));
+	}
+
+	protected boolean shouldActorTrigger(MovementContext context, BlockInfo blockInfo, MovementBehaviour actor,
+		Vec3d actorPosition, BlockPos gridPosition) {
+		Vec3d previousPosition = context.position;
+		if (previousPosition == null)
+			return false;
+
+		context.motion = actorPosition.subtract(previousPosition);
+		Vec3d relativeMotion = context.motion;
+		relativeMotion = reverseRotation(relativeMotion, 1);
+		context.relativeMotion = relativeMotion;
+		return !new BlockPos(previousPosition).equals(gridPosition)
+			|| context.relativeMotion.length() > 0 && context.firstMovement;
+	}
+
+	public void move(double x, double y, double z) {
+		setPosition(getX() + x, getY() + y, getZ() + z);
+	}
+
+	public Vec3d getAnchorVec() {
+		return getPositionVec();
+	}
+
+	public float getYawOffset() {
+		return 0;
+	}
+
+	@Override
+	public void setPosition(double x, double y, double z) {
+		super.setPosition(x, y, z);
+		if (contraption == null)
+			return;
+		AxisAlignedBB cbox = contraption.bounds;
+		if (cbox == null)
+			return;
+		Vec3d actualVec = getAnchorVec();
+		setBoundingBox(cbox.offset(actualVec));
+	}
+
+	public static float yawFromVector(Vec3d vec) {
+		return (float) ((3 * Math.PI / 2 + Math.atan2(vec.z, vec.x)) / Math.PI * 180);
+	}
+
+	public static float pitchFromVector(Vec3d vec) {
+		return (float) ((Math.acos(vec.y)) / Math.PI * 180);
+	}
+
+	public static EntityType.Builder<?> build(EntityType.Builder<?> builder) {
+		@SuppressWarnings("unchecked")
+		EntityType.Builder<AbstractContraptionEntity> entityBuilder =
+			(EntityType.Builder<AbstractContraptionEntity>) builder;
+		return entityBuilder.size(1, 1);
+	}
+
+	@Override
+	protected void registerData() {
+		this.dataManager.register(STALLED, false);
+	}
+
+	@Override
+	protected void readAdditional(CompoundNBT compound) {
+		initialized = compound.getBoolean("Initialized");
+		contraption = Contraption.fromNBT(world, compound.getCompound("Contraption"));
+		contraption.entity = this;
+		dataManager.set(STALLED, compound.getBoolean("Stalled"));
+	}
+
+	@Override
+	protected void writeAdditional(CompoundNBT compound) {
+		if (contraption != null)
+			compound.put("Contraption", contraption.writeNBT());
+		compound.putBoolean("Stalled", isStalled());
+		compound.putBoolean("Initialized", initialized);
+	}
+
+	@Override
+	public IPacket<?> createSpawnPacket() {
+		return NetworkHooks.getEntitySpawningPacket(this);
+	}
+
+	@Override
+	public void writeSpawnData(PacketBuffer buffer) {
+		CompoundNBT compound = new CompoundNBT();
+		writeAdditional(compound);
+		buffer.writeCompoundTag(compound);
+	}
+
+	@Override
+	public void readSpawnData(PacketBuffer additionalData) {
+		readAdditional(additionalData.readCompoundTag());
+	}
+
+	public void disassemble() {
+		if (!isAlive())
+			return;
+		if (contraption == null)
+			return;
+		remove();
+		StructureTransform transform = makeStructureTransform();
+		contraption.addBlocksToWorld(world, transform);
+		contraption.addPassengersToWorld(world, transform, getPassengers());
+
+		for (Entity entity : getPassengers()) {
+			if (!(entity instanceof OrientedContraptionEntity))
+				continue;
+			UUID id = entity.getUniqueID();
+			if (!contraption.stabilizedSubContraptions.containsKey(id))
+				continue;
+			BlockPos transformed = transform.apply(contraption.stabilizedSubContraptions.get(id)
+				.getConnectedPos());
+			entity.setPosition(transformed.getX(), transformed.getY(), transformed.getZ());
+			((AbstractContraptionEntity) entity).disassemble();
+		}
+
+		removePassengers();
+
+		for (Entity entity : collidingEntities) {
+			Vec3d positionVec = getPositionVec();
+			Vec3d localVec = entity.getPositionVec()
+				.subtract(positionVec);
+			localVec = reverseRotation(localVec, 1);
+			Vec3d transformed = transform.apply(localVec);
+			entity.setPositionAndUpdate(transformed.x, transformed.y, transformed.z);
+		}
+	}
+
+	protected abstract StructureTransform makeStructureTransform();
+
+	@Override
+	public void onKillCommand() {
+		removePassengers();
+		super.onKillCommand();
+	}
+
+	@Override
+	protected void outOfWorld() {
+		removePassengers();
+		super.outOfWorld();
+	}
+
+	@Override
+	public void onRemovedFromWorld() {
+		super.onRemovedFromWorld();
+		if (world != null && world.isRemote)
+			return;
+		getPassengers().forEach(Entity::remove);
+	}
+
+	@Override
+	protected void doWaterSplashEffect() {}
+
+	public Contraption getContraption() {
+		return contraption;
+	}
+
+	public boolean isStalled() {
+		return dataManager.get(STALLED);
+	}
+
+	@OnlyIn(Dist.CLIENT)
+	static void handleStallPacket(ContraptionStallPacket packet) {
+		Entity entity = Minecraft.getInstance().world.getEntityByID(packet.entityID);
+		if (!(entity instanceof AbstractContraptionEntity))
+			return;
+		AbstractContraptionEntity ce = (AbstractContraptionEntity) entity;
+		ce.handleStallInformation(packet.x, packet.y, packet.z, packet.angle);
+	}
+
+	protected abstract float getStalledAngle();
+
+	protected abstract void handleStallInformation(float x, float y, float z, float angle);
+
+	@Override
+	@SuppressWarnings("deprecation")
+	public CompoundNBT writeWithoutTypeId(CompoundNBT nbt) {
+		Vec3d vec = getPositionVec();
+		List<Entity> passengers = getPassengers();
+
+		for (Entity entity : passengers) {
+			// setPos has world accessing side-effects when removed == false
+			entity.removed = true;
+
+			// Gather passengers into same chunk when saving
+			Vec3d prevVec = entity.getPositionVec();
+			entity.setPos(vec.x, prevVec.y, vec.z);
+
+			// Super requires all passengers to not be removed in order to write them to the
+			// tag
+			entity.removed = false;
+		}
+
+		CompoundNBT tag = super.writeWithoutTypeId(nbt);
+		return tag;
+	}
+
+	@Override
+	// Make sure nothing can move contraptions out of the way
+	public void setMotion(Vec3d motionIn) {}
+
+	@Override
+	public PushReaction getPushReaction() {
+		return PushReaction.IGNORE;
+	}
+
+	public void setContraptionMotion(Vec3d vec) {
+		super.setMotion(vec);
+	}
+
+	@Override
+	public boolean canBeCollidedWith() {
+		return false;
+	}
+
+	@Override
+	public boolean attackEntityFrom(DamageSource source, float amount) {
+		return false;
+	}
+
+	public Vec3d getPrevPositionVec() {
+		return prevPosInvalid ? getPositionVec() : new Vec3d(prevPosX, prevPosY, prevPosZ);
+	}
+
+	public abstract ContraptionRotationState getRotationState();
+
+	public Vec3d getContactPointMotion(Vec3d globalContactPoint) {
+		if (prevPosInvalid)
+			return Vec3d.ZERO;
+		Vec3d contactPoint = toGlobalVector(toLocalVector(globalContactPoint, 0), 1);
+		return contactPoint.subtract(globalContactPoint)
+			.add(getPositionVec().subtract(getPrevPositionVec()));
+	}
+
+	public boolean canCollideWith(Entity e) {
+		if (e instanceof PlayerEntity && e.isSpectator())
+			return false;
+		if (e.noClip)
+			return false;
+		if (e instanceof HangingEntity)
+			return false;
+		if (e instanceof AbstractMinecartEntity)
+			return false;
+		if (e instanceof SuperGlueEntity)
+			return false;
+		if (e instanceof SeatEntity)
+			return false;
+		if (e instanceof IProjectile)
+			return false;
+		if (e.getRidingEntity() != null)
+			return false;
+
+		Entity riding = this.getRidingEntity();
+		while (riding != null) {
+			if (riding == e)
+				return false;
+			riding = riding.getRidingEntity();
+		}
+
+		return e.getPushReaction() == PushReaction.NORMAL;
+	}
+
+	@Override
+	public boolean isOnePlayerRiding() {
+		return false;
+	}
+
+	public static class ContraptionRotationState {
+		static final ContraptionRotationState NONE = new ContraptionRotationState();
+
+		float xRotation = 0;
+		float yRotation = 0;
+		float zRotation = 0;
+		float secondYRotation = 0;
+		Matrix3d matrix;
+
+		public Matrix3d asMatrix() {
+			if (matrix != null)
+				return matrix;
+
+			matrix = new Matrix3d().asIdentity();
+			if (xRotation != 0)
+				matrix.multiply(new Matrix3d().asXRotation(AngleHelper.rad(-xRotation)));
+			if (yRotation != 0)
+				matrix.multiply(new Matrix3d().asYRotation(AngleHelper.rad(yRotation)));
+			if (zRotation != 0)
+				matrix.multiply(new Matrix3d().asZRotation(AngleHelper.rad(-zRotation)));
+			return matrix;
+		}
+
+		public boolean hasVerticalRotation() {
+			return xRotation != 0 || zRotation != 0;
+		}
+
+		public float getYawOffset() {
+			return secondYRotation;
+		}
+
+	}
+
+}

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/AbstractContraptionEntityRenderer.java

@@ -0,0 +1,65 @@
+package com.simibubi.create.content.contraptions.components.structureMovement;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.culling.ClippingHelperImpl;
+import net.minecraft.client.renderer.entity.EntityRenderer;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.MathHelper;
+
+public abstract class AbstractContraptionEntityRenderer<C extends AbstractContraptionEntity> extends EntityRenderer<C> {
+
+	protected AbstractContraptionEntityRenderer(EntityRendererManager p_i46179_1_) {
+		super(p_i46179_1_);
+	}
+
+	@Override
+	public ResourceLocation getEntityTexture(C p_110775_1_) {
+		return null;
+	}
+
+	protected abstract void transform(C contraptionEntity, float partialTicks, MatrixStack[] matrixStacks);
+
+	@Override
+	public boolean shouldRender(C entity, ClippingHelperImpl p_225626_2_, double p_225626_3_, double p_225626_5_,
+		double p_225626_7_) {
+		if (!super.shouldRender(entity, p_225626_2_, p_225626_3_, p_225626_5_, p_225626_7_))
+			return false;
+		if (!entity.isAlive())
+			return false;
+		if (entity.getContraption() == null)
+			return false;
+		return true;
+	}
+
+	@Override
+	public void render(C entity, float yaw, float partialTicks, MatrixStack ms, IRenderTypeBuffer buffers,
+		int overlay) {
+		super.render(entity, yaw, partialTicks, ms, buffers, overlay);
+
+		// Keep a copy of the transforms in order to determine correct lighting
+		MatrixStack msLocal = getLocalTransform(entity);
+		MatrixStack[] matrixStacks = new MatrixStack[] { ms, msLocal };
+
+		ms.push();
+		transform(entity, partialTicks, matrixStacks);
+		ContraptionRenderer.render(entity.world, entity.getContraption(), ms, msLocal, buffers);
+		ms.pop();
+
+	}
+
+	protected MatrixStack getLocalTransform(AbstractContraptionEntity entity) {
+		double pt = Minecraft.getInstance()
+			.getRenderPartialTicks();
+		MatrixStack matrixStack = new MatrixStack();
+		double x = MathHelper.lerp(pt, entity.lastTickPosX, entity.getX());
+		double y = MathHelper.lerp(pt, entity.lastTickPosY, entity.getY());
+		double z = MathHelper.lerp(pt, entity.lastTickPosZ, entity.getZ());
+		matrixStack.translate(x, y, z);
+		return matrixStack;
+	}
+
+}

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/AllContraptionTypes.java

@@ -4,6 +4,7 @@ import java.util.function.Supplier;
 
 import com.simibubi.create.content.contraptions.components.structureMovement.bearing.BearingContraption;
 import com.simibubi.create.content.contraptions.components.structureMovement.bearing.ClockworkContraption;
+import com.simibubi.create.content.contraptions.components.structureMovement.bearing.StabilizedContraption;
 import com.simibubi.create.content.contraptions.components.structureMovement.mounted.MountedContraption;
 import com.simibubi.create.content.contraptions.components.structureMovement.piston.PistonContraption;
 import com.simibubi.create.content.contraptions.components.structureMovement.pulley.PulleyContraption;
@@ -16,6 +17,7 @@ public enum AllContraptionTypes {
 	PULLEY(PulleyContraption::new),
 	CLOCKWORK(ClockworkContraption::new),
 	MOUNTED(MountedContraption::new),
+	STABILIZED(StabilizedContraption::new),
 	
 	;
 
@@ -28,10 +30,9 @@ public enum AllContraptionTypes {
 	}
 	
 	public static Contraption fromType(String type) {
-		for (AllContraptionTypes allContraptionTypes : values()) {
+		for (AllContraptionTypes allContraptionTypes : values()) 
 			if (type.equals(allContraptionTypes.id))
 				return allContraptionTypes.factory.get();
-		}
 		return null;
 	}
 

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/BlockMovementTraits.java

@@ -194,6 +194,8 @@ public class BlockMovementTraits {
 	public static boolean notSupportive(BlockState state, Direction facing) {
 		if (AllBlocks.MECHANICAL_DRILL.has(state))
 			return state.get(BlockStateProperties.FACING) == facing;
+		if (AllBlocks.MECHANICAL_BEARING.has(state))
+			return state.get(BlockStateProperties.FACING) == facing;
 		if (AllBlocks.CART_ASSEMBLER.has(state))
 			return Direction.DOWN == facing;
 		if (AllBlocks.MECHANICAL_SAW.has(state))

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/Contraption.java

@@ -10,6 +10,7 @@ import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
 import java.util.function.BiConsumer;
@@ -25,6 +26,8 @@ import com.simibubi.create.AllMovementBehaviours;
 import com.simibubi.create.content.contraptions.base.KineticTileEntity;
 import com.simibubi.create.content.contraptions.components.actors.SeatBlock;
 import com.simibubi.create.content.contraptions.components.actors.SeatEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.bearing.MechanicalBearingBlock;
+import com.simibubi.create.content.contraptions.components.structureMovement.bearing.StabilizedContraption;
 import com.simibubi.create.content.contraptions.components.structureMovement.chassis.AbstractChassisBlock;
 import com.simibubi.create.content.contraptions.components.structureMovement.chassis.ChassisTileEntity;
 import com.simibubi.create.content.contraptions.components.structureMovement.glue.SuperGlueEntity;
@@ -40,6 +43,7 @@ import com.simibubi.create.content.contraptions.relays.belt.BeltBlock;
 import com.simibubi.create.content.logistics.block.inventories.AdjustableCrateBlock;
 import com.simibubi.create.content.logistics.block.redstone.RedstoneContactBlock;
 import com.simibubi.create.foundation.config.AllConfigs;
+import com.simibubi.create.foundation.utility.BlockFace;
 import com.simibubi.create.foundation.utility.Iterate;
 import com.simibubi.create.foundation.utility.NBTHelper;
 import com.simibubi.create.foundation.utility.VecHelper;
@@ -54,8 +58,6 @@ import net.minecraft.block.DoorBlock;
 import net.minecraft.block.IWaterLoggable;
 import net.minecraft.block.PressurePlateBlock;
 import net.minecraft.block.SlimeBlock;
-import net.minecraft.client.renderer.RenderType;
-import net.minecraft.client.renderer.RenderTypeLookup;
 import net.minecraft.entity.Entity;
 import net.minecraft.fluid.Fluids;
 import net.minecraft.fluid.IFluidState;
@@ -83,54 +85,58 @@ import net.minecraftforge.items.wrapper.CombinedInvWrapper;
 
 public abstract class Contraption {
 
-	public Map<BlockPos, BlockInfo> blocks;
-	public Map<BlockPos, MountedStorage> storage;
-	public List<MutablePair<BlockInfo, MovementContext>> actors;
+	public AbstractContraptionEntity entity;
 	public CombinedInvWrapper inventory;
-	public List<TileEntity> customRenderTEs;
-	public Set<Pair<BlockPos, Direction>> superglue;
-	public ContraptionEntity entity;
-
 	public AxisAlignedBB bounds;
+	public BlockPos anchor;
 	public boolean stalled;
 
+	protected Map<BlockPos, BlockInfo> blocks;
+	protected Map<BlockPos, MountedStorage> storage;
+	protected List<MutablePair<BlockInfo, MovementContext>> actors;
+	protected Set<Pair<BlockPos, Direction>> superglue;
 	protected List<BlockPos> seats;
 	protected Map<UUID, Integer> seatMapping;
-	protected Map<BlockPos, Entity> initialPassengers;
+	protected Map<UUID, BlockFace> stabilizedSubContraptions;
 
-	protected Set<BlockPos> cachedColliders;
-	protected Direction cachedColliderDirection;
-	protected BlockPos anchor;
-	protected List<SuperGlueEntity> glueToRemove;
-	List<BlockPos> renderOrder;
+	private List<SuperGlueEntity> glueToRemove;
+	private Map<BlockPos, Entity> initialPassengers;
+	private List<BlockFace> pendingSubContraptions;
+
+	// Client
+	public List<TileEntity> renderedTileEntities;
 
 	public Contraption() {
 		blocks = new HashMap<>();
 		storage = new HashMap<>();
-		actors = new ArrayList<>();
 		seats = new ArrayList<>();
-		seatMapping = new HashMap<>();
-		initialPassengers = new HashMap<>();
+		actors = new ArrayList<>();
 		superglue = new HashSet<>();
-		renderOrder = new ArrayList<>();
-		customRenderTEs = new ArrayList<>();
+		seatMapping = new HashMap<>();
 		glueToRemove = new ArrayList<>();
+		initialPassengers = new HashMap<>();
+		renderedTileEntities = new ArrayList<>();
+		pendingSubContraptions = new ArrayList<>();
+		stabilizedSubContraptions = new HashMap<>();
 	}
 
-	protected static boolean isChassis(BlockState state) {
-		return state.getBlock() instanceof AbstractChassisBlock;
+	public abstract boolean assemble(World world, BlockPos pos);
+
+	protected abstract boolean canAxisBeStabilized(Axis axis);
+
+	protected abstract AllContraptionTypes getType();
+
+	protected boolean customBlockPlacement(IWorld world, BlockPos pos, BlockState state) {
+		return false;
 	}
 
-	public static CompoundNBT getTileEntityNBT(World world, BlockPos pos) {
-		TileEntity tileentity = world.getTileEntity(pos);
-		CompoundNBT compoundnbt = null;
-		if (tileentity != null) {
-			compoundnbt = tileentity.write(new CompoundNBT());
-			compoundnbt.remove("x");
-			compoundnbt.remove("y");
-			compoundnbt.remove("z");
-		}
-		return compoundnbt;
+	protected boolean customBlockRemoval(IWorld world, BlockPos pos, BlockState state) {
+		return false;
+	}
+
+	protected boolean addToInitialFrontier(World world, BlockPos pos, Direction forcedDirection,
+		List<BlockPos> frontier) {
+		return true;
 	}
 
 	public static Contraption fromNBT(World world, CompoundNBT nbt) {
@@ -140,35 +146,6 @@ public abstract class Contraption {
 		return contraption;
 	}
 
-	protected static MovementBehaviour getMovement(BlockState state) {
-		Block block = state.getBlock();
-		if (!AllMovementBehaviours.hasMovementBehaviour(block))
-			return null;
-		return AllMovementBehaviours.getMovementBehaviour(block);
-	}
-
-	public Set<BlockPos> getColliders(World world, Direction movementDirection) {
-		if (blocks == null)
-			return null;
-		if (cachedColliders == null || cachedColliderDirection != movementDirection) {
-			cachedColliders = new HashSet<>();
-			cachedColliderDirection = movementDirection;
-
-			for (BlockInfo info : blocks.values()) {
-				BlockPos offsetPos = info.pos.offset(movementDirection);
-				if (info.state.getCollisionShape(world, offsetPos)
-					.isEmpty())
-					continue;
-				if (blocks.containsKey(offsetPos) && !blocks.get(offsetPos).state.getCollisionShape(world, offsetPos)
-					.isEmpty())
-					continue;
-				cachedColliders.add(info.pos);
-			}
-
-		}
-		return cachedColliders;
-	}
-
 	public boolean searchMovedStructure(World world, BlockPos pos, @Nullable Direction forcedDirection) {
 		initialPassengers.clear();
 		List<BlockPos> frontier = new ArrayList<>();
@@ -191,7 +168,27 @@ public abstract class Contraption {
 		return false;
 	}
 
-	public void gatherStoredItems() {
+	public void onEntityCreated(AbstractContraptionEntity entity) {
+		this.entity = entity;
+
+		// Create subcontraptions
+		for (BlockFace blockFace : pendingSubContraptions) {
+			Direction face = blockFace.getFace();
+			StabilizedContraption subContraption = new StabilizedContraption(face);
+			World world = entity.world;
+			BlockPos pos = blockFace.getPos();
+			if (!subContraption.assemble(world, pos))
+				continue;
+			subContraption.removeBlocksFromWorld(world, BlockPos.ZERO);
+			OrientedContraptionEntity movedContraption =
+				OrientedContraptionEntity.create(world, subContraption, Optional.of(face));
+			BlockPos anchor = blockFace.getConnectedPos();
+			movedContraption.setPosition(anchor.getX() + .5f, anchor.getY(), anchor.getZ() + .5f);
+			world.addEntity(movedContraption);
+			stabilizedSubContraptions.put(movedContraption.getUniqueID(), new BlockFace(toLocalPos(pos), face));
+		}
+
+		// Gather itemhandlers of mounted storage
 		List<IItemHandlerModifiable> list = storage.values()
 			.stream()
 			.map(MountedStorage::getItemHandler)
@@ -199,10 +196,16 @@ public abstract class Contraption {
 		inventory = new CombinedInvWrapper(Arrays.copyOf(list.toArray(), list.size(), IItemHandlerModifiable[].class));
 	}
 
-	public void mountPassengers(ContraptionEntity contraptionEntity) {
-		this.entity = contraptionEntity;
-		if (contraptionEntity.world.isRemote)
+	public void onEntityInitialize(World world, AbstractContraptionEntity contraptionEntity) {
+		if (world.isRemote)
 			return;
+
+		for (OrientedContraptionEntity orientedCE : world.getEntitiesWithinAABB(OrientedContraptionEntity.class,
+			contraptionEntity.getBoundingBox()
+				.grow(1)))
+			if (stabilizedSubContraptions.containsKey(orientedCE.getUniqueID()))
+				orientedCE.startRiding(contraptionEntity);
+
 		for (BlockPos seatPos : getSeats()) {
 			Entity passenger = initialPassengers.get(seatPos);
 			if (passenger == null)
@@ -214,11 +217,6 @@ public abstract class Contraption {
 		}
 	}
 
-	protected boolean addToInitialFrontier(World world, BlockPos pos, Direction forcedDirection,
-		List<BlockPos> frontier) {
-		return true;
-	}
-
 	protected boolean moveBlock(World world, BlockPos pos, Direction forcedDirection, List<BlockPos> frontier,
 		Set<BlockPos> visited) {
 		visited.add(pos);
@@ -233,96 +231,32 @@ public abstract class Contraption {
 		if (!movementAllowed(world, pos))
 			return false;
 		BlockState state = world.getBlockState(pos);
-		if (isChassis(state) && !moveChassis(world, pos, forcedDirection, frontier, visited))
+		if (state.getBlock() instanceof AbstractChassisBlock
+			&& !moveChassis(world, pos, forcedDirection, frontier, visited))
 			return false;
 
 		if (AllBlocks.ADJUSTABLE_CRATE.has(state))
 			AdjustableCrateBlock.splitCrate(world, pos);
-		if (AllBlocks.BELT.has(state)) {
-			BlockPos nextPos = BeltBlock.nextSegmentPosition(state, pos, true);
-			BlockPos prevPos = BeltBlock.nextSegmentPosition(state, pos, false);
-			if (nextPos != null && !visited.contains(nextPos))
-				frontier.add(nextPos);
-			if (prevPos != null && !visited.contains(prevPos))
-				frontier.add(prevPos);
-		}
+
+		if (AllBlocks.BELT.has(state))
+			moveBelt(pos, frontier, visited, state);
+
+		// Bearings potentially create stabilized sub-contraptions
+		if (AllBlocks.MECHANICAL_BEARING.has(state))
+			moveBearing(pos, frontier, visited, state);
 
 		// Seats transfer their passenger to the contraption
-		if (state.getBlock() instanceof SeatBlock) {
-			BlockPos local = toLocalPos(pos);
-			getSeats().add(local);
-			List<SeatEntity> seatsEntities = world.getEntitiesWithinAABB(SeatEntity.class, new AxisAlignedBB(pos));
-			if (!seatsEntities.isEmpty()) {
-				SeatEntity seat = seatsEntities.get(0);
-				List<Entity> passengers = seat.getPassengers();
-				if (!passengers.isEmpty())
-					initialPassengers.put(local, passengers.get(0));
-			}
-		}
+		if (state.getBlock() instanceof SeatBlock)
+			moveSeat(world, pos);
 
 		// Pulleys drag their rope and their attached structure
-		if (state.getBlock() instanceof PulleyBlock) {
-			int limit = AllConfigs.SERVER.kinetics.maxRopeLength.get();
-			BlockPos ropePos = pos;
-			while (limit-- >= 0) {
-				ropePos = ropePos.down();
-				if (!world.isBlockPresent(ropePos))
-					break;
-				BlockState ropeState = world.getBlockState(ropePos);
-				Block block = ropeState.getBlock();
-				if (!(block instanceof RopeBlock) && !(block instanceof MagnetBlock)) {
-					if (!visited.contains(ropePos))
-						frontier.add(ropePos);
-					break;
-				}
-				add(ropePos, capture(world, ropePos));
-			}
-		}
+		if (state.getBlock() instanceof PulleyBlock)
+			movePulley(world, pos, frontier, visited);
 
 		// Pistons drag their attaches poles and extension
-		if (state.getBlock() instanceof MechanicalPistonBlock) {
-			int limit = AllConfigs.SERVER.kinetics.maxPistonPoles.get();
-			Direction direction = state.get(MechanicalPistonBlock.FACING);
-			if (state.get(MechanicalPistonBlock.STATE) == PistonState.EXTENDED) {
-				BlockPos searchPos = pos;
-				while (limit-- >= 0) {
-					searchPos = searchPos.offset(direction);
-					BlockState blockState = world.getBlockState(searchPos);
-					if (isExtensionPole(blockState)) {
-						if (blockState.get(PistonExtensionPoleBlock.FACING)
-							.getAxis() != direction.getAxis())
-							break;
-						if (!visited.contains(searchPos))
-							frontier.add(searchPos);
-						continue;
-					}
-					if (isPistonHead(blockState))
-						if (!visited.contains(searchPos))
-							frontier.add(searchPos);
-					break;
-				}
-				if (limit <= -1)
-					return false;
-			}
-
-			BlockPos searchPos = pos;
-			while (limit-- >= 0) {
-				searchPos = searchPos.offset(direction.getOpposite());
-				BlockState blockState = world.getBlockState(searchPos);
-				if (isExtensionPole(blockState)) {
-					if (blockState.get(PistonExtensionPoleBlock.FACING)
-						.getAxis() != direction.getAxis())
-						break;
-					if (!visited.contains(searchPos))
-						frontier.add(searchPos);
-					continue;
-				}
-				break;
-			}
-
-			if (limit <= -1)
+		if (state.getBlock() instanceof MechanicalPistonBlock)
+			if (!moveMechanicalPiston(world, pos, frontier, visited, state))
 				return false;
-		}
 
 		// Doors try to stay whole
 		if (state.getBlock() instanceof DoorBlock) {
@@ -363,16 +297,104 @@ public abstract class Contraption {
 				addGlue(superglue.get(offset));
 		}
 
-		add(pos, capture(world, pos));
+		addBlock(pos, capture(world, pos));
 		return blocks.size() <= AllConfigs.SERVER.kinetics.maxBlocksMoved.get();
 	}
 
-	protected boolean movementAllowed(World world, BlockPos pos) {
-		return BlockMovementTraits.movementAllowed(world, pos);
+	private void moveBearing(BlockPos pos, List<BlockPos> frontier, Set<BlockPos> visited, BlockState state) {
+		Direction facing = state.get(MechanicalBearingBlock.FACING);
+		if (!canAxisBeStabilized(facing.getAxis())) {
+			BlockPos offset = pos.offset(facing);
+			if (!visited.contains(offset))
+				frontier.add(offset);
+			return;
+		}
+		pendingSubContraptions.add(new BlockFace(pos, facing));
 	}
 
-	protected boolean isAnchoringBlockAt(BlockPos pos) {
-		return pos.equals(anchor);
+	private void moveBelt(BlockPos pos, List<BlockPos> frontier, Set<BlockPos> visited, BlockState state) {
+		BlockPos nextPos = BeltBlock.nextSegmentPosition(state, pos, true);
+		BlockPos prevPos = BeltBlock.nextSegmentPosition(state, pos, false);
+		if (nextPos != null && !visited.contains(nextPos))
+			frontier.add(nextPos);
+		if (prevPos != null && !visited.contains(prevPos))
+			frontier.add(prevPos);
+	}
+
+	private void moveSeat(World world, BlockPos pos) {
+		BlockPos local = toLocalPos(pos);
+		getSeats().add(local);
+		List<SeatEntity> seatsEntities = world.getEntitiesWithinAABB(SeatEntity.class, new AxisAlignedBB(pos));
+		if (!seatsEntities.isEmpty()) {
+			SeatEntity seat = seatsEntities.get(0);
+			List<Entity> passengers = seat.getPassengers();
+			if (!passengers.isEmpty())
+				initialPassengers.put(local, passengers.get(0));
+		}
+	}
+
+	private void movePulley(World world, BlockPos pos, List<BlockPos> frontier, Set<BlockPos> visited) {
+		int limit = AllConfigs.SERVER.kinetics.maxRopeLength.get();
+		BlockPos ropePos = pos;
+		while (limit-- >= 0) {
+			ropePos = ropePos.down();
+			if (!world.isBlockPresent(ropePos))
+				break;
+			BlockState ropeState = world.getBlockState(ropePos);
+			Block block = ropeState.getBlock();
+			if (!(block instanceof RopeBlock) && !(block instanceof MagnetBlock)) {
+				if (!visited.contains(ropePos))
+					frontier.add(ropePos);
+				break;
+			}
+			addBlock(ropePos, capture(world, ropePos));
+		}
+	}
+
+	private boolean moveMechanicalPiston(World world, BlockPos pos, List<BlockPos> frontier, Set<BlockPos> visited,
+		BlockState state) {
+		int limit = AllConfigs.SERVER.kinetics.maxPistonPoles.get();
+		Direction direction = state.get(MechanicalPistonBlock.FACING);
+		if (state.get(MechanicalPistonBlock.STATE) == PistonState.EXTENDED) {
+			BlockPos searchPos = pos;
+			while (limit-- >= 0) {
+				searchPos = searchPos.offset(direction);
+				BlockState blockState = world.getBlockState(searchPos);
+				if (isExtensionPole(blockState)) {
+					if (blockState.get(PistonExtensionPoleBlock.FACING)
+						.getAxis() != direction.getAxis())
+						break;
+					if (!visited.contains(searchPos))
+						frontier.add(searchPos);
+					continue;
+				}
+				if (isPistonHead(blockState))
+					if (!visited.contains(searchPos))
+						frontier.add(searchPos);
+				break;
+			}
+			if (limit <= -1)
+				return false;
+		}
+
+		BlockPos searchPos = pos;
+		while (limit-- >= 0) {
+			searchPos = searchPos.offset(direction.getOpposite());
+			BlockState blockState = world.getBlockState(searchPos);
+			if (isExtensionPole(blockState)) {
+				if (blockState.get(PistonExtensionPoleBlock.FACING)
+					.getAxis() != direction.getAxis())
+					break;
+				if (!visited.contains(searchPos))
+					frontier.add(searchPos);
+				continue;
+			}
+			break;
+		}
+
+		if (limit <= -1)
+			return false;
+		return true;
 	}
 
 	private boolean moveChassis(World world, BlockPos pos, Direction movementDirection, List<BlockPos> frontier,
@@ -414,18 +436,7 @@ public abstract class Contraption {
 		return Pair.of(new BlockInfo(pos, blockstate, compoundnbt), tileentity);
 	}
 
-	public void addGlue(SuperGlueEntity entity) {
-		BlockPos pos = entity.getHangingPosition();
-		Direction direction = entity.getFacingDirection();
-		this.superglue.add(Pair.of(toLocalPos(pos), direction));
-		glueToRemove.add(entity);
-	}
-
-	public BlockPos toLocalPos(BlockPos globalPos) {
-		return globalPos.subtract(anchor);
-	}
-
-	public void add(BlockPos pos, Pair<BlockInfo, TileEntity> pair) {
+	protected void addBlock(BlockPos pos, Pair<BlockInfo, TileEntity> pair) {
 		BlockInfo captured = pair.getKey();
 		BlockPos localPos = pos.subtract(anchor);
 		BlockInfo blockInfo = new BlockInfo(localPos, captured.state, captured.nbt);
@@ -437,14 +448,44 @@ public abstract class Contraption {
 		TileEntity te = pair.getValue();
 		if (te != null && MountedStorage.canUseAsStorage(te))
 			storage.put(localPos, new MountedStorage(te));
-		if (AllMovementBehaviours.hasMovementBehaviour(captured.state.getBlock()))
+		if (AllMovementBehaviours.contains(captured.state.getBlock()))
 			actors.add(MutablePair.of(blockInfo, null));
 	}
 
+	@Nullable
+	protected CompoundNBT getTileEntityNBT(World world, BlockPos pos) {
+		TileEntity tileentity = world.getTileEntity(pos);
+		if (tileentity == null)
+			return null;
+		CompoundNBT nbt = tileentity.write(new CompoundNBT());
+		nbt.remove("x");
+		nbt.remove("y");
+		nbt.remove("z");
+		return nbt;
+	}
+
+	protected void addGlue(SuperGlueEntity entity) {
+		BlockPos pos = entity.getHangingPosition();
+		Direction direction = entity.getFacingDirection();
+		this.superglue.add(Pair.of(toLocalPos(pos), direction));
+		glueToRemove.add(entity);
+	}
+
+	protected BlockPos toLocalPos(BlockPos globalPos) {
+		return globalPos.subtract(anchor);
+	}
+
+	protected boolean movementAllowed(World world, BlockPos pos) {
+		return BlockMovementTraits.movementAllowed(world, pos);
+	}
+
+	protected boolean isAnchoringBlockAt(BlockPos pos) {
+		return pos.equals(anchor);
+	}
+
 	public void readNBT(World world, CompoundNBT nbt) {
 		blocks.clear();
-		renderOrder.clear();
-		customRenderTEs.clear();
+		renderedTileEntities.clear();
 
 		nbt.getList("Blocks", 10)
 			.forEach(c -> {
@@ -456,12 +497,8 @@ public abstract class Contraption {
 
 				if (world.isRemote) {
 					Block block = info.state.getBlock();
-					if (RenderTypeLookup.canRenderInLayer(info.state, RenderType.getTranslucent()))
-						renderOrder.add(info.pos);
-					else
-						renderOrder.add(0, info.pos);
 					CompoundNBT tag = info.nbt;
-					MovementBehaviour movementBehaviour = AllMovementBehaviours.getMovementBehaviour(block);
+					MovementBehaviour movementBehaviour = AllMovementBehaviours.of(block);
 					if (tag == null || (movementBehaviour != null && movementBehaviour.hasSpecialMovementRenderer()))
 						return;
 
@@ -485,7 +522,7 @@ public abstract class Contraption {
 					if (te instanceof KineticTileEntity)
 						((KineticTileEntity) te).setSpeed(0);
 					te.getBlockState();
-					customRenderTEs.add(te);
+					renderedTileEntities.add(te);
 				}
 			});
 
@@ -494,8 +531,7 @@ public abstract class Contraption {
 			.forEach(c -> {
 				CompoundNBT comp = (CompoundNBT) c;
 				BlockInfo info = blocks.get(NBTUtil.readBlockPos(comp.getCompound("Pos")));
-				MovementContext context = MovementContext.readNBT(world, info, comp);
-				context.contraption = this;
+				MovementContext context = MovementContext.readNBT(world, info, comp, this);
 				getActors().add(MutablePair.of(info, context));
 			});
 
@@ -510,6 +546,10 @@ public abstract class Contraption {
 		NBTHelper.iterateCompoundList(nbt.getList("Passengers", NBT.TAG_COMPOUND),
 			c -> seatMapping.put(NBTUtil.readUniqueId(c.getCompound("Id")), c.getInt("Seat")));
 
+		stabilizedSubContraptions.clear();
+		NBTHelper.iterateCompoundList(nbt.getList("SubContraptions", NBT.TAG_COMPOUND), c -> stabilizedSubContraptions
+			.put(NBTUtil.readUniqueId(c.getCompound("Id")), BlockFace.fromNBT(c.getCompound("Location"))));
+
 		storage.clear();
 		NBTHelper.iterateCompoundList(nbt.getList("Storage", NBT.TAG_COMPOUND), c -> storage
 			.put(NBTUtil.readBlockPos(c.getCompound("Pos")), MountedStorage.deserialize(c.getCompound("Data"))));
@@ -544,7 +584,8 @@ public abstract class Contraption {
 		for (MutablePair<BlockInfo, MovementContext> actor : getActors()) {
 			CompoundNBT compound = new CompoundNBT();
 			compound.put("Pos", NBTUtil.writeBlockPos(actor.left.pos));
-			getMovement(actor.left.state).writeExtraData(actor.right);
+			AllMovementBehaviours.of(actor.left.state)
+				.writeExtraData(actor.right);
 			actor.right.writeToNBT(compound);
 			actorsNBT.add(compound);
 		}
@@ -577,6 +618,14 @@ public abstract class Contraption {
 			return tag;
 		}));
 
+		nbt.put("SubContraptions", NBTHelper.writeCompoundList(stabilizedSubContraptions.entrySet(), e -> {
+			CompoundNBT tag = new CompoundNBT();
+			tag.put("Id", NBTUtil.writeUniqueId(e.getKey()));
+			tag.put("Location", e.getValue()
+				.serializeNBT());
+			return tag;
+		}));
+
 		nbt.put("Blocks", blocksNBT);
 		nbt.put("Actors", actorsNBT);
 		nbt.put("Superglue", superglueNBT);
@@ -592,14 +641,6 @@ public abstract class Contraption {
 		return nbt;
 	}
 
-	protected boolean customBlockPlacement(IWorld world, BlockPos pos, BlockState state) {
-		return false;
-	}
-
-	protected boolean customBlockRemoval(IWorld world, BlockPos pos, BlockState state) {
-		return false;
-	}
-
 	public void removeBlocksFromWorld(IWorld world, BlockPos offset) {
 		storage.values()
 			.forEach(MountedStorage::removeStorageFromWorld);
@@ -732,27 +773,15 @@ public abstract class Contraption {
 		}
 	}
 
-	public void initActors(World world) {
+	public void startMoving(World world) {
 		for (MutablePair<BlockInfo, MovementContext> pair : actors) {
-			MovementContext context = new MovementContext(world, pair.left);
-			context.contraption = this;
-			getMovement(pair.left.state).startMoving(context);
+			MovementContext context = new MovementContext(world, pair.left, this);
+			AllMovementBehaviours.of(pair.left.state)
+				.startMoving(context);
 			pair.setRight(context);
 		}
 	}
 
-	public AxisAlignedBB getBoundingBox() {
-		return bounds;
-	}
-
-	public List<MutablePair<BlockInfo, MovementContext>> getActors() {
-		return actors;
-	}
-
-	public BlockPos getAnchor() {
-		return anchor;
-	}
-
 	public void stop(World world) {
 		foreachActor(world, (behaviour, ctx) -> {
 			behaviour.stopMoving(ctx);
@@ -765,7 +794,7 @@ public abstract class Contraption {
 
 	public void foreachActor(World world, BiConsumer<MovementBehaviour, MovementContext> callBack) {
 		for (MutablePair<BlockInfo, MovementContext> pair : actors)
-			callBack.accept(getMovement(pair.getLeft().state), pair.getRight());
+			callBack.accept(AllMovementBehaviours.of(pair.getLeft().state), pair.getRight());
 	}
 
 	public void expandBoundsAroundAxis(Axis axis) {
@@ -792,7 +821,13 @@ public abstract class Contraption {
 		bounds = new AxisAlignedBB(min, max);
 	}
 
-	public BlockPos getSeat(UUID entityId) {
+	public void addExtraInventories(Entity entity) {}
+
+	public Map<UUID, Integer> getSeatMapping() {
+		return seatMapping;
+	}
+
+	public BlockPos getSeatOf(UUID entityId) {
 		if (!getSeatMapping().containsKey(entityId))
 			return null;
 		int seatIndex = getSeatMapping().get(entityId);
@@ -801,10 +836,11 @@ public abstract class Contraption {
 		return getSeats().get(seatIndex);
 	}
 
-	protected abstract AllContraptionTypes getType();
-
-	public Map<UUID, Integer> getSeatMapping() {
-		return seatMapping;
+	public BlockPos getBearingPosOf(UUID subContraptionEntityId) {
+		if (stabilizedSubContraptions.containsKey(subContraptionEntityId))
+			return stabilizedSubContraptions.get(subContraptionEntityId)
+				.getConnectedPos();
+		return null;
 	}
 
 	public void setSeatMapping(Map<UUID, Integer> seatMapping) {
@@ -815,5 +851,12 @@ public abstract class Contraption {
 		return seats;
 	}
 
-	public void addExtraInventories(Entity entity) {};
+	public Map<BlockPos, BlockInfo> getBlocks() {
+		return blocks;
+	}
+
+	public List<MutablePair<BlockInfo, MovementContext>> getActors() {
+		return actors;
+	}
+
 }

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/ContraptionCollider.java

@@ -15,12 +15,12 @@ import com.google.common.collect.ImmutableSet;
 import com.simibubi.create.AllBlocks;
 import com.simibubi.create.AllMovementBehaviours;
 import com.simibubi.create.content.contraptions.components.actors.BlockBreakingMovementBehaviour;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity.ContraptionRotationState;
 import com.simibubi.create.content.contraptions.components.structureMovement.sync.ClientMotionPacket;
 import com.simibubi.create.foundation.collision.ContinuousOBBCollider.ContinuousSeparationManifold;
 import com.simibubi.create.foundation.collision.Matrix3d;
 import com.simibubi.create.foundation.collision.OrientedBB;
 import com.simibubi.create.foundation.networking.AllPackets;
-import com.simibubi.create.foundation.utility.AngleHelper;
 import com.simibubi.create.foundation.utility.Iterate;
 import com.simibubi.create.foundation.utility.VecHelper;
 
@@ -28,7 +28,7 @@ import net.minecraft.block.BlockState;
 import net.minecraft.block.CocoaBlock;
 import net.minecraft.client.entity.player.ClientPlayerEntity;
 import net.minecraft.entity.Entity;
-import net.minecraft.entity.EntityType;
+import net.minecraft.entity.item.ItemEntity;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.entity.player.ServerPlayerEntity;
 import net.minecraft.util.Direction;
@@ -55,68 +55,58 @@ public class ContraptionCollider {
 		NONE, CLIENT, REMOTE, SERVER
 	}
 
-	static void collideEntities(ContraptionEntity contraptionEntity) {
+	static void collideEntities(AbstractContraptionEntity contraptionEntity) {
 		World world = contraptionEntity.getEntityWorld();
 		Contraption contraption = contraptionEntity.getContraption();
 		AxisAlignedBB bounds = contraptionEntity.getBoundingBox();
-		Vec3d contraptionPosition = contraptionEntity.getPositionVec();
-		Vec3d contraptionRotation = contraptionEntity.getRotationVec();
-		Vec3d contraptionMotion = contraptionEntity.stationary ? Vec3d.ZERO
-			: contraptionPosition.subtract(contraptionEntity.getPrevPositionVec());
-		contraptionEntity.collidingEntities.clear();
 
 		if (contraption == null)
 			return;
 		if (bounds == null)
 			return;
 
-		Vec3d centerOfBlock = VecHelper.getCenterOf(BlockPos.ZERO);
-		double conRotX = contraptionRotation.x;
-		double conRotY = contraptionRotation.y + contraptionEntity.getInitialYaw();
-		double conRotZ = contraptionRotation.z;
+		contraptionEntity.collidingEntities.clear();
 
-		double reverseYaw = 0;
+		Vec3d contraptionPosition = contraptionEntity.getPositionVec();
+		Vec3d contraptionMotion = contraptionPosition.subtract(contraptionEntity.getPrevPositionVec());
+		Vec3d anchorVec = contraptionEntity.getAnchorVec();
+		Vec3d centerOfBlock = VecHelper.CENTER_OF_ORIGIN;
+		ContraptionRotationState rotation = null;
 
-		// Collision algorithm does not support rotation around two axes -> rotate
-		// entities manually
-		if (conRotZ != 0 && contraptionRotation.y != 0) {
-			reverseYaw = contraptionRotation.y;
-			conRotY = contraptionEntity.getInitialYaw();
-		}
+		// After death, multiple refs to the client player may show up in the area
+		boolean skipClientPlayer = false;
 
-		Vec3d contraptionCentreOffset = contraptionEntity.stationary ? centerOfBlock : Vec3d.ZERO.add(0, 0.5, 0);
-		boolean axisAlignedCollision = contraptionRotation.equals(Vec3d.ZERO);
-		Matrix3d rotation = null;
-
-		for (Entity entity : world.getEntitiesWithinAABB((EntityType<?>) null, bounds.grow(2)
-			.expand(0, 32, 0), contraptionEntity::canCollideWith)) {
+		List<Entity> entitiesWithinAABB = world.getEntitiesWithinAABB(Entity.class, bounds.grow(2)
+			.expand(0, 32, 0), contraptionEntity::canCollideWith);
+		for (Entity entity : entitiesWithinAABB) {
 
 			PlayerType playerType = getPlayerType(entity);
 			if (playerType == PlayerType.REMOTE)
 				continue;
+			if (playerType == PlayerType.CLIENT)
+				if (skipClientPlayer)
+					continue;
+				else
+					skipClientPlayer = true;
 
 			// Init matrix
-			if (rotation == null) {
-				rotation = new Matrix3d().asIdentity();
-				if (!axisAlignedCollision) {
-					rotation.multiply(new Matrix3d().asXRotation(AngleHelper.rad(-conRotX)));
-					rotation.multiply(new Matrix3d().asYRotation(AngleHelper.rad(conRotY)));
-					rotation.multiply(new Matrix3d().asZRotation(AngleHelper.rad(-conRotZ)));
-				}
-			}
+			if (rotation == null)
+				rotation = contraptionEntity.getRotationState();
+			Matrix3d rotationMatrix = rotation.asMatrix();
 
 			// Transform entity position and motion to local space
 			Vec3d entityPosition = entity.getPositionVec();
 			AxisAlignedBB entityBounds = entity.getBoundingBox();
 			Vec3d centerY = new Vec3d(0, entityBounds.getYSize() / 2, 0);
 			Vec3d motion = entity.getMotion();
+			float yawOffset = rotation.getYawOffset();
 
 			Vec3d position = entityPosition;
-			position = position.subtract(contraptionCentreOffset);
 			position = position.add(centerY);
-			position = position.subtract(contraptionPosition);
-			position = VecHelper.rotate(position, -reverseYaw, Axis.Y);
-			position = rotation.transform(position);
+			position = position.subtract(centerOfBlock);
+			position = position.subtract(anchorVec);
+			position = VecHelper.rotate(position, -yawOffset, Axis.Y);
+			position = rotationMatrix.transform(position);
 			position = position.add(centerOfBlock);
 			position = position.subtract(centerY);
 			position = position.subtract(entityPosition);
@@ -132,14 +122,10 @@ public class ContraptionCollider {
 
 			// Prepare entity bounds
 			OrientedBB obb = new OrientedBB(localBB);
-			obb.setRotation(rotation);
-			motion = rotation.transform(motion);
+			obb.setRotation(rotationMatrix);
+			motion = rotationMatrix.transform(motion);
 			motion = motion.subtract(contraptionMotion);
 
-//			Vec3d visualizerOrigin = new Vec3d(10, 64, 0);
-//			CollisionDebugger.OBB = obb.copy();
-//			CollisionDebugger.OBB.move(visualizerOrigin);
-
 			MutableObject<Vec3d> collisionResponse = new MutableObject<>(Vec3d.ZERO);
 			MutableObject<Vec3d> allowedMotion = new MutableObject<>(motion);
 			MutableBoolean futureCollision = new MutableBoolean(false);
@@ -152,7 +138,7 @@ public class ContraptionCollider {
 				.forEach(shape -> shape.toBoundingBoxList()
 					.forEach(bbs::add));
 
-			boolean doHorizontalPass = conRotX == 0 && conRotZ == 0;
+			boolean doHorizontalPass = !rotation.hasVerticalRotation();
 			for (boolean horizontalPass : Iterate.trueAndFalse) {
 
 				for (AxisAlignedBB bb : bbs) {
@@ -200,13 +186,12 @@ public class ContraptionCollider {
 			Vec3d motionResponse = allowedMotion.getValue();
 			boolean hardCollision = !totalResponse.equals(Vec3d.ZERO);
 
-
-			rotation.transpose();
-			motionResponse = rotation.transform(motionResponse)
+			rotationMatrix.transpose();
+			motionResponse = rotationMatrix.transform(motionResponse)
 				.add(contraptionMotion);
-			totalResponse = rotation.transform(totalResponse);
-			totalResponse = VecHelper.rotate(totalResponse, reverseYaw, Axis.Y);
-			rotation.transpose();
+			totalResponse = rotationMatrix.transform(totalResponse);
+			totalResponse = VecHelper.rotate(totalResponse, yawOffset, Axis.Y);
+			rotationMatrix.transpose();
 
 			if (futureCollision.isTrue() && playerType != PlayerType.SERVER) {
 				if (motionResponse.y != entityMotion.y) {
@@ -216,15 +201,6 @@ public class ContraptionCollider {
 				}
 			}
 
-			Vec3d contactPointMotion = Vec3d.ZERO;
-			if (surfaceCollision.isTrue()) {
-				entity.fallDistance = 0;
-				entity.onGround = true;
-				contraptionEntity.collidingEntities.add(entity);
-				if (playerType != PlayerType.SERVER) 
-					contactPointMotion = contraptionEntity.getContactPointMotion(entityPosition);
-			}
-
 			if (hardCollision) {
 				double motionX = entityMotion.getX();
 				double motionY = entityMotion.getY();
@@ -250,13 +226,30 @@ public class ContraptionCollider {
 				continue;
 			}
 
-			
-			totalResponse = totalResponse.add(contactPointMotion);
+//			totalResponse = totalResponse.add(contactPointMotion);
 			Vec3d allowedMovement = getAllowedMovement(totalResponse, entity);
 			contraptionEntity.collidingEntities.add(entity);
 			entity.velocityChanged = true;
 			entity.setPosition(entityPosition.x + allowedMovement.x, entityPosition.y + allowedMovement.y,
 				entityPosition.z + allowedMovement.z);
+			entityPosition = entity.getPositionVec();
+
+			Vec3d contactPointMotion = Vec3d.ZERO;
+			if (surfaceCollision.isTrue()) {
+				entity.fallDistance = 0;
+				entity.onGround = true;
+				contraptionEntity.collidingEntities.add(entity);
+				if (entity instanceof ItemEntity)
+					entityMotion = entityMotion.mul(.5f, 1, .5f);
+
+				if (playerType != PlayerType.SERVER) {
+					contactPointMotion = contraptionEntity.getContactPointMotion(entityPosition);
+					allowedMovement = getAllowedMovement(contactPointMotion, entity);
+					entity.setPosition(entityPosition.x + allowedMovement.x, entityPosition.y + allowedMovement.y,
+						entityPosition.z + allowedMovement.z);
+				}
+			}
+
 			entity.setMotion(entityMotion);
 
 			if (playerType != PlayerType.CLIENT)
@@ -342,10 +335,12 @@ public class ContraptionCollider {
 		BlockPos max = new BlockPos(blockScanBB.maxX, blockScanBB.maxY, blockScanBB.maxZ);
 
 		ReuseableStream<VoxelShape> potentialHits = new ReuseableStream<>(BlockPos.getAllInBox(min, max)
-			.filter(contraption.blocks::containsKey)
+			.filter(contraption.getBlocks()::containsKey)
 			.map(p -> {
-				BlockState blockState = contraption.blocks.get(p).state;
-				BlockPos pos = contraption.blocks.get(p).pos;
+				BlockState blockState = contraption.getBlocks()
+					.get(p).state;
+				BlockPos pos = contraption.getBlocks()
+					.get(p).pos;
 				VoxelShape collisionShape = blockState.getCollisionShape(world, p);
 				return collisionShape.withOffset(pos.getX(), pos.getY(), pos.getZ());
 			})
@@ -354,13 +349,13 @@ public class ContraptionCollider {
 		return potentialHits;
 	}
 
-	public static boolean collideBlocks(ContraptionEntity contraptionEntity) {
-		if (!contraptionEntity.collisionEnabled())
+	public static boolean collideBlocks(ControlledContraptionEntity contraptionEntity) {
+		if (!contraptionEntity.supportsTerrainCollision())
 			return false;
 
 		World world = contraptionEntity.getEntityWorld();
 		Vec3d motion = contraptionEntity.getMotion();
-		Contraption contraption = contraptionEntity.getContraption();
+		TranslatingContraption contraption = (TranslatingContraption) contraptionEntity.getContraption();
 		AxisAlignedBB bounds = contraptionEntity.getBoundingBox();
 		Vec3d position = contraptionEntity.getPositionVec();
 		BlockPos gridPos = new BlockPos(position);
@@ -381,14 +376,14 @@ public class ContraptionCollider {
 			return true;
 
 		// Other moving Contraptions
-		for (ContraptionEntity otherContraptionEntity : world.getEntitiesWithinAABB(ContraptionEntity.class,
-			bounds.grow(1), e -> !e.equals(contraptionEntity))) {
+		for (ControlledContraptionEntity otherContraptionEntity : world.getEntitiesWithinAABB(
+			ControlledContraptionEntity.class, bounds.grow(1), e -> !e.equals(contraptionEntity))) {
 
-			if (!otherContraptionEntity.collisionEnabled())
+			if (!otherContraptionEntity.supportsTerrainCollision())
 				continue;
 
 			Vec3d otherMotion = otherContraptionEntity.getMotion();
-			Contraption otherContraption = otherContraptionEntity.getContraption();
+			TranslatingContraption otherContraption = (TranslatingContraption) otherContraptionEntity.getContraption();
 			AxisAlignedBB otherBounds = otherContraptionEntity.getBoundingBox();
 			Vec3d otherPosition = otherContraptionEntity.getPositionVec();
 
@@ -404,7 +399,8 @@ public class ContraptionCollider {
 			for (BlockPos colliderPos : contraption.getColliders(world, movementDirection)) {
 				colliderPos = colliderPos.add(gridPos)
 					.subtract(new BlockPos(otherPosition));
-				if (!otherContraption.blocks.containsKey(colliderPos))
+				if (!otherContraption.getBlocks()
+					.containsKey(colliderPos))
 					continue;
 				return true;
 			}
@@ -413,7 +409,7 @@ public class ContraptionCollider {
 		return false;
 	}
 
-	public static boolean isCollidingWithWorld(World world, Contraption contraption, BlockPos anchor,
+	public static boolean isCollidingWithWorld(World world, TranslatingContraption contraption, BlockPos anchor,
 		Direction movementDirection) {
 		for (BlockPos pos : contraption.getColliders(world, movementDirection)) {
 			BlockPos colliderPos = pos.add(anchor);
@@ -422,11 +418,11 @@ public class ContraptionCollider {
 				return true;
 
 			BlockState collidedState = world.getBlockState(colliderPos);
-			BlockInfo blockInfo = contraption.blocks.get(pos);
+			BlockInfo blockInfo = contraption.getBlocks()
+				.get(pos);
 
-			if (AllMovementBehaviours.hasMovementBehaviour(blockInfo.state.getBlock())) {
-				MovementBehaviour movementBehaviour =
-					AllMovementBehaviours.getMovementBehaviour(blockInfo.state.getBlock());
+			if (AllMovementBehaviours.contains(blockInfo.state.getBlock())) {
+				MovementBehaviour movementBehaviour = AllMovementBehaviours.of(blockInfo.state.getBlock());
 				if (movementBehaviour instanceof BlockBreakingMovementBehaviour) {
 					BlockBreakingMovementBehaviour behaviour = (BlockBreakingMovementBehaviour) movementBehaviour;
 					if (!behaviour.canBreak(world, colliderPos, collidedState)

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/ContraptionEntityRenderer.java

@@ -1,102 +0,0 @@
-package com.simibubi.create.content.contraptions.components.structureMovement;
-
-import com.mojang.blaze3d.matrix.MatrixStack;
-import com.simibubi.create.foundation.utility.MatrixStacker;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.IRenderTypeBuffer;
-import net.minecraft.client.renderer.entity.EntityRenderer;
-import net.minecraft.client.renderer.entity.EntityRendererManager;
-import net.minecraft.entity.Entity;
-import net.minecraft.entity.item.minecart.AbstractMinecartEntity;
-import net.minecraft.util.ResourceLocation;
-import net.minecraft.util.math.MathHelper;
-import net.minecraft.util.math.Vec3d;
-
-public class ContraptionEntityRenderer extends EntityRenderer<ContraptionEntity> {
-
-	public ContraptionEntityRenderer(EntityRendererManager rendererManager) {
-		super(rendererManager);
-	}
-
-	@Override
-	public ResourceLocation getEntityTexture(ContraptionEntity arg0) {
-		return null;
-	}
-
-	@Override
-	public void render(ContraptionEntity entity, float yaw, float partialTicks, MatrixStack ms,
-		IRenderTypeBuffer buffers, int overlay) {
-		if (!entity.isAlive())
-			return;
-		if (entity.getContraption() == null)
-			return;
-		if (entity.getContraption()
-			.getType() == AllContraptionTypes.MOUNTED && entity.getRidingEntity() == null)
-			return;
-
-		// Keep a copy of the transforms in order to determine correct lighting
-		MatrixStack msLocal = getLocalTransform(entity);
-		MatrixStack[] matrixStacks = new MatrixStack[] { ms, msLocal };
-
-		float angleInitialYaw = entity.getInitialYaw();
-		float angleYaw = entity.getYaw(partialTicks);
-		float anglePitch = entity.getPitch(partialTicks);
-		float angleRoll = entity.getRoll(partialTicks);
-
-		ms.push();
-		Entity ridingEntity = entity.getRidingEntity();
-		if (ridingEntity != null && ridingEntity instanceof AbstractMinecartEntity) {
-			AbstractMinecartEntity cart = (AbstractMinecartEntity) ridingEntity;
-			double cartX = MathHelper.lerp(partialTicks, cart.lastTickPosX, cart.getX());
-			double cartY = MathHelper.lerp(partialTicks, cart.lastTickPosY, cart.getY());
-			double cartZ = MathHelper.lerp(partialTicks, cart.lastTickPosZ, cart.getZ());
-			Vec3d cartPos = cart.getPos(cartX, cartY, cartZ);
-
-			for (MatrixStack stack : matrixStacks)
-				stack.translate(-.5f, 0, -.5f);
-
-			if (cartPos != null) {
-				Vec3d cartPosFront = cart.getPosOffset(cartX, cartY, cartZ, (double) 0.3F);
-				Vec3d cartPosBack = cart.getPosOffset(cartX, cartY, cartZ, (double) -0.3F);
-				if (cartPosFront == null)
-					cartPosFront = cartPos;
-				if (cartPosBack == null)
-					cartPosBack = cartPos;
-
-				cartX = cartPos.x - cartX;
-				cartY = (cartPosFront.y + cartPosBack.y) / 2.0D - cartY;
-				cartZ = cartPos.z - cartZ;
-
-				for (MatrixStack stack : matrixStacks)
-					stack.translate(cartX, cartY, cartZ);
-			}
-		}
-
-		for (MatrixStack stack : matrixStacks)
-			MatrixStacker.of(stack)
-				.nudge(entity.getEntityId())
-				.centre()
-				.rotateY(angleYaw)
-				.rotateZ(anglePitch)
-				.rotateY(angleInitialYaw)
-				.rotateX(angleRoll)
-				.unCentre();
-		ContraptionRenderer.render(entity.world, entity.getContraption(), ms, msLocal, buffers);
-		ms.pop();
-
-		super.render(entity, yaw, partialTicks, ms, buffers, overlay);
-	}
-
-	protected MatrixStack getLocalTransform(ContraptionEntity entity) {
-		double pt = Minecraft.getInstance()
-			.getRenderPartialTicks();
-		MatrixStack matrixStack = new MatrixStack();
-		double x = MathHelper.lerp(pt, entity.lastTickPosX, entity.getX());
-		double y = MathHelper.lerp(pt, entity.lastTickPosY, entity.getY());
-		double z = MathHelper.lerp(pt, entity.lastTickPosZ, entity.getZ());
-		matrixStack.translate(x, y, z);
-		return matrixStack;
-	}
-
-}

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/ContraptionHandler.java

@@ -1,9 +1,11 @@
 package com.simibubi.create.content.contraptions.components.structureMovement;
 
 import java.lang.ref.WeakReference;
-import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 
 import com.simibubi.create.foundation.utility.VecHelper;
 import com.simibubi.create.foundation.utility.WorldAttached;
@@ -21,25 +23,26 @@ public class ContraptionHandler {
 
 	/* Global map of loaded contraptions */
 
-	public static WorldAttached<List<WeakReference<ContraptionEntity>>> loadedContraptions;
-	static WorldAttached<List<ContraptionEntity>> queuedAdditions;
+	public static WorldAttached<Map<Integer, WeakReference<AbstractContraptionEntity>>> loadedContraptions;
+	static WorldAttached<List<AbstractContraptionEntity>> queuedAdditions;
 
 	static {
-		loadedContraptions = new WorldAttached<>(ArrayList::new);
+		loadedContraptions = new WorldAttached<>(HashMap::new);
 		queuedAdditions = new WorldAttached<>(() -> ObjectLists.synchronize(new ObjectArrayList<>()));
 	}
 
 	public static void tick(World world) {
-		List<WeakReference<ContraptionEntity>> list = loadedContraptions.get(world);
-		List<ContraptionEntity> queued = queuedAdditions.get(world);
+		Map<Integer, WeakReference<AbstractContraptionEntity>> map = loadedContraptions.get(world);
+		List<AbstractContraptionEntity> queued = queuedAdditions.get(world);
 
-		for (ContraptionEntity contraptionEntity : queued)
-			list.add(new WeakReference<>(contraptionEntity));
+		for (AbstractContraptionEntity contraptionEntity : queued)
+			map.put(contraptionEntity.getEntityId(), new WeakReference<>(contraptionEntity));
 		queued.clear();
 
-		for (Iterator<WeakReference<ContraptionEntity>> iterator = list.iterator(); iterator.hasNext();) {
-			WeakReference<ContraptionEntity> weakReference = iterator.next();
-			ContraptionEntity contraptionEntity = weakReference.get();
+		Collection<WeakReference<AbstractContraptionEntity>> values = map.values();
+		for (Iterator<WeakReference<AbstractContraptionEntity>> iterator = values.iterator(); iterator.hasNext();) {
+			WeakReference<AbstractContraptionEntity> weakReference = iterator.next();
+			AbstractContraptionEntity contraptionEntity = weakReference.get();
 			if (contraptionEntity == null || !contraptionEntity.isAlive()) {
 				iterator.remove();
 				continue;
@@ -49,9 +52,9 @@ public class ContraptionHandler {
 	}
 
 	public static void addSpawnedContraptionsToCollisionList(Entity entity, World world) {
-		if (entity instanceof ContraptionEntity)
+		if (entity instanceof AbstractContraptionEntity)
 			queuedAdditions.get(world)
-				.add((ContraptionEntity) entity);
+				.add((AbstractContraptionEntity) entity);
 	}
 
 	public static void entitiesWhoJustDismountedGetSentToTheRightLocation(LivingEntity entityLiving, World world) {

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/ContraptionHandlerClient.java

@@ -75,7 +75,7 @@ public class ContraptionHandlerClient {
 				.distanceTo(origin), reach);
 
 		Vec3d target = RaycastHelper.getTraceTarget(player, reach, origin);
-		for (ContraptionEntity contraptionEntity : mc.world.getEntitiesWithinAABB(ContraptionEntity.class,
+		for (AbstractContraptionEntity contraptionEntity : mc.world.getEntitiesWithinAABB(AbstractContraptionEntity.class,
 			new AxisAlignedBB(origin, target))) {
 
 			Vec3d localOrigin = contraptionEntity.toLocalVector(origin, 1);
@@ -84,7 +84,7 @@ public class ContraptionHandlerClient {
 
 			MutableObject<BlockRayTraceResult> mutableResult = new MutableObject<>();
 			PredicateTraceResult predicateResult = RaycastHelper.rayTraceUntil(localOrigin, localTarget, p -> {
-				BlockInfo blockInfo = contraption.blocks.get(p);
+				BlockInfo blockInfo = contraption.getBlocks().get(p);
 				if (blockInfo == null)
 					return false;
 				BlockState state = blockInfo.state;

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/ContraptionRenderer.java

@@ -7,6 +7,7 @@ import org.apache.commons.lang3.tuple.Pair;
 import org.lwjgl.opengl.GL11;
 
 import com.mojang.blaze3d.matrix.MatrixStack;
+import com.simibubi.create.AllMovementBehaviours;
 import com.simibubi.create.CreateClient;
 import com.simibubi.create.foundation.utility.MatrixStacker;
 import com.simibubi.create.foundation.utility.SuperByteBuffer;
@@ -70,7 +71,7 @@ public class ContraptionRenderer {
 
 	private static void renderTileEntities(World world, Contraption c, MatrixStack ms, MatrixStack msLocal,
 		IRenderTypeBuffer buffer) {
-		TileEntityRenderHelper.renderTileEntities(world, c.customRenderTEs, ms, msLocal, buffer);
+		TileEntityRenderHelper.renderTileEntities(world, c.renderedTileEntities, ms, msLocal, buffer);
 	}
 
 	private static SuperByteBuffer buildStructureBuffer(Contraption c, RenderType layer) {
@@ -86,10 +87,9 @@ public class ContraptionRenderer {
 		BufferBuilder builder = new BufferBuilder(DefaultVertexFormats.BLOCK.getIntegerSize());
 		builder.begin(GL11.GL_QUADS, DefaultVertexFormats.BLOCK);
 
-		for (BlockInfo info : c.blocks.values())
+		for (BlockInfo info : c.getBlocks().values())
 			renderWorld.setBlockState(info.pos, info.state);
-		for (BlockPos pos : c.renderOrder) {
-			BlockInfo info = c.blocks.get(pos);
+		for (BlockInfo info : c.getBlocks().values()) {
 			BlockState state = info.state;
 
 			if (state.getRenderType() == BlockRenderType.ENTITYBLOCK_ANIMATED)
@@ -126,7 +126,7 @@ public class ContraptionRenderer {
 					.translate(blockInfo.pos);
 			}
 
-			MovementBehaviour movementBehaviour = Contraption.getMovement(blockInfo.state);
+			MovementBehaviour movementBehaviour = AllMovementBehaviours.of(blockInfo.state);
 			if (movementBehaviour != null)
 				movementBehaviour.renderInContraption(context, ms, msLocal, buffer);
 

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/ContraptionStallPacket.java

@@ -15,18 +15,14 @@ public class ContraptionStallPacket extends SimplePacketBase {
 	float x;
 	float y;
 	float z;
-	float yaw;
-	float pitch;
-	float roll;
+	float angle;
 
-	public ContraptionStallPacket(int entityID, double posX, double posY, double posZ, float yaw, float pitch, float roll) {
+	public ContraptionStallPacket(int entityID, double posX, double posY, double posZ, float angle) {
 		this.entityID = entityID;
 		this.x = (float) posX;
 		this.y = (float) posY;
 		this.z = (float) posZ;
-		this.yaw = yaw;
-		this.pitch = pitch;
-		this.roll = roll;
+		this.angle = angle;
 	}
 
 	public ContraptionStallPacket(PacketBuffer buffer) {
@@ -34,21 +30,19 @@ public class ContraptionStallPacket extends SimplePacketBase {
 		x = buffer.readFloat();
 		y = buffer.readFloat();
 		z = buffer.readFloat();
-		yaw = buffer.readFloat();
-		pitch = buffer.readFloat();
-		roll = buffer.readFloat();
+		angle = buffer.readFloat();
 	}
 
 	@Override
 	public void write(PacketBuffer buffer) {
 		buffer.writeInt(entityID);
-		writeAll(buffer, x, y, z, yaw, pitch, roll);
+		writeAll(buffer, x, y, z, angle);
 	}
 
 	@Override
 	public void handle(Supplier<Context> context) {
 		context.get().enqueueWork(
-				() -> DistExecutor.runWhenOn(Dist.CLIENT, () -> () -> ContraptionEntity.handleStallPacket(this)));
+				() -> DistExecutor.runWhenOn(Dist.CLIENT, () -> () -> AbstractContraptionEntity.handleStallPacket(this)));
 		context.get().setPacketHandled(true);
 	}
 

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/ControlledContraptionEntity.java

@@ -0,0 +1,221 @@
+package com.simibubi.create.content.contraptions.components.structureMovement;
+
+import static com.simibubi.create.foundation.utility.AngleHelper.angleLerp;
+
+import com.simibubi.create.AllEntityTypes;
+import com.simibubi.create.content.contraptions.components.structureMovement.bearing.BearingContraption;
+import com.simibubi.create.foundation.utility.NBTHelper;
+import com.simibubi.create.foundation.utility.VecHelper;
+
+import net.minecraft.entity.EntityType;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.nbt.NBTUtil;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Direction.Axis;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+import net.minecraft.world.gen.feature.template.Template.BlockInfo;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+/**
+ * Ex: Pistons, bearings <br>
+ * Controlled Contraption Entities can rotate around one axis and translate.
+ * <br>
+ * They are bound to an {@link IControlContraption}
+ */
+public class ControlledContraptionEntity extends AbstractContraptionEntity {
+
+	protected BlockPos controllerPos;
+	protected Axis rotationAxis;
+	protected float prevAngle;
+	protected float angle;
+
+	public ControlledContraptionEntity(EntityType<?> type, World world) {
+		super(type, world);
+	}
+
+	public static ControlledContraptionEntity create(World world, IControlContraption controller,
+		Contraption contraption) {
+		ControlledContraptionEntity entity =
+			new ControlledContraptionEntity(AllEntityTypes.CONTROLLED_CONTRAPTION.get(), world);
+		entity.controllerPos = controller.getBlockPosition();
+		entity.setContraption(contraption);
+		return entity;
+	}
+
+	public boolean supportsTerrainCollision() {
+		return contraption instanceof TranslatingContraption;
+	}
+
+	@Override
+	protected void setContraption(Contraption contraption) {
+		super.setContraption(contraption);
+		if (contraption instanceof BearingContraption)
+			rotationAxis = ((BearingContraption) contraption).getFacing()
+				.getAxis();
+
+	}
+
+	@Override
+	protected void readAdditional(CompoundNBT compound) {
+		super.readAdditional(compound);
+		controllerPos = NBTUtil.readBlockPos(compound.getCompound("Controller"));
+		if (compound.contains("Axis"))
+			rotationAxis = NBTHelper.readEnum(compound, "Axis", Axis.class);
+		angle = compound.getFloat("Angle");
+	}
+
+	@Override
+	protected void writeAdditional(CompoundNBT compound) {
+		super.writeAdditional(compound);
+		compound.put("Controller", NBTUtil.writeBlockPos(controllerPos));
+		if (rotationAxis != null)
+			NBTHelper.writeEnum(compound, "Axis", rotationAxis);
+		compound.putFloat("Angle", angle);
+	}
+
+	@Override
+	public ContraptionRotationState getRotationState() {
+		ContraptionRotationState crs = new ContraptionRotationState();
+		if (rotationAxis == Axis.X)
+			crs.xRotation = angle;
+		if (rotationAxis == Axis.Y)
+			crs.yRotation = angle;
+		if (rotationAxis == Axis.Z)
+			crs.zRotation = angle;
+		return crs;
+	}
+
+	@Override
+	public Vec3d applyRotation(Vec3d localPos, float partialTicks) {
+		localPos = VecHelper.rotate(localPos, getAngle(partialTicks), rotationAxis);
+		return localPos;
+	}
+
+	@Override
+	public Vec3d reverseRotation(Vec3d localPos, float partialTicks) {
+		localPos = VecHelper.rotate(localPos, -getAngle(partialTicks), rotationAxis);
+		return localPos;
+	}
+
+	public void setAngle(float angle) {
+		this.angle = angle;
+	}
+
+	public float getAngle(float partialTicks) {
+		return partialTicks == 1.0F ? angle : angleLerp(partialTicks, prevAngle, angle);
+	}
+
+	public void setRotationAxis(Axis rotationAxis) {
+		this.rotationAxis = rotationAxis;
+	}
+
+	public Axis getRotationAxis() {
+		return rotationAxis;
+	}
+
+	@Override
+	public void setPositionAndUpdate(double p_70634_1_, double p_70634_3_, double p_70634_5_) {}
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void setPositionAndRotationDirect(double x, double y, double z, float yw, float pt, int inc, boolean t) {}
+
+	protected void tickContraption() {
+		prevAngle = angle;
+		tickActors();
+		
+		if (controllerPos == null)
+			return;
+		if (!world.isBlockPresent(controllerPos))
+			return;
+		IControlContraption controller = getController();
+		if (controller == null) {
+			remove();
+			return;
+		}
+		if (!controller.isAttachedTo(this)) {
+			controller.attach(this);
+			if (world.isRemote)
+				setPosition(getX(), getY(), getZ());
+		}
+
+		Vec3d motion = getMotion();
+		if (motion.length() < 1 / 4098f)
+			setMotion(Vec3d.ZERO);
+		move(motion.x, motion.y, motion.z);
+		if (ContraptionCollider.collideBlocks(this))
+			getController().collided();
+	}
+
+	@Override
+	protected boolean shouldActorTrigger(MovementContext context, BlockInfo blockInfo, MovementBehaviour actor,
+		Vec3d actorPosition, BlockPos gridPosition) {
+		if (super.shouldActorTrigger(context, blockInfo, actor, actorPosition, gridPosition))
+			return true;
+
+		// Special activation timer for actors in the center of a bearing contraption
+		if (!(contraption instanceof BearingContraption))
+			return false;
+		BearingContraption bc = (BearingContraption) contraption;
+		Direction facing = bc.getFacing();
+		Vec3d activeAreaOffset = actor.getActiveAreaOffset(context);
+		if (!activeAreaOffset.mul(VecHelper.axisAlingedPlaneOf(new Vec3d(facing.getDirectionVec())))
+			.equals(Vec3d.ZERO))
+			return false;
+		if (!VecHelper.onSameAxis(blockInfo.pos, BlockPos.ZERO, facing.getAxis()))
+			return false;
+		context.motion = new Vec3d(facing.getDirectionVec()).scale(angle - prevAngle);
+		context.relativeMotion = context.motion;
+		int timer = context.data.getInt("StationaryTimer");
+		if (timer > 0) {
+			context.data.putInt("StationaryTimer", timer - 1);
+			return false;
+		}
+
+		context.data.putInt("StationaryTimer", 20);
+		return true;
+	}
+
+	protected IControlContraption getController() {
+		if (controllerPos == null)
+			return null;
+		if (!world.isBlockPresent(controllerPos))
+			return null;
+		TileEntity te = world.getTileEntity(controllerPos);
+		if (!(te instanceof IControlContraption))
+			return null;
+		return (IControlContraption) te;
+	}
+
+	@Override
+	protected StructureTransform makeStructureTransform() {
+		BlockPos offset = new BlockPos(getAnchorVec().add(.5, .5, .5));
+		float xRot = rotationAxis == Axis.X ? angle : 0;
+		float yRot = rotationAxis == Axis.Y ? angle : 0;
+		float zRot = rotationAxis == Axis.Z ? angle : 0;
+		return new StructureTransform(offset, xRot, yRot, zRot);
+	}
+
+	@Override
+	protected void onContraptionStalled() {
+		IControlContraption controller = getController();
+		if (controller != null)
+			controller.onStall();
+		super.onContraptionStalled();
+	}
+
+	@Override
+	protected float getStalledAngle() {
+		return angle;
+	}
+
+	@Override
+	protected void handleStallInformation(float x, float y, float z, float angle) {
+		setPos(x, y, z);
+		this.angle = angle;
+	}
+}

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/ControlledContraptionEntityRenderer.java

@@ -0,0 +1,29 @@
+package com.simibubi.create.content.contraptions.components.structureMovement;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.simibubi.create.foundation.utility.MatrixStacker;
+
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.util.Direction.Axis;
+
+public class ControlledContraptionEntityRenderer extends AbstractContraptionEntityRenderer<ControlledContraptionEntity> {
+
+	public ControlledContraptionEntityRenderer(EntityRendererManager p_i46179_1_) {
+		super(p_i46179_1_);
+	}
+
+	@Override
+	protected void transform(ControlledContraptionEntity entity, float partialTicks,
+		MatrixStack[] matrixStacks) {
+		float angle = entity.getAngle(partialTicks);
+		Axis axis = entity.getRotationAxis();
+
+		for (MatrixStack stack : matrixStacks)
+			MatrixStacker.of(stack)
+				.nudge(entity.getEntityId())
+				.centre()
+				.rotate(angle, axis)
+				.unCentre();
+	}
+
+}

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/IControlContraption.java

@@ -4,16 +4,22 @@ import com.simibubi.create.foundation.gui.AllIcons;
 import com.simibubi.create.foundation.tileEntity.behaviour.scrollvalue.INamedIconOptions;
 import com.simibubi.create.foundation.utility.Lang;
 
+import net.minecraft.util.math.BlockPos;
+
 public interface IControlContraption {
 
-	public boolean isAttachedTo(ContraptionEntity contraption);
+	public boolean isAttachedTo(AbstractContraptionEntity contraption);
 	
-	public void attach(ContraptionEntity contraption);
+	public void attach(ControlledContraptionEntity contraption);
 
 	public void onStall();
 
 	public boolean isValid();
 	
+	public void collided();
+	
+	public BlockPos getBlockPosition();
+
 	static enum MovementMode implements INamedIconOptions {
 
 		MOVE_PLACE(AllIcons.I_MOVE_PLACE),
@@ -70,6 +76,4 @@ public interface IControlContraption {
 
 	}
 
-	public void collided();
-
 }

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/MountedFluidStorage.java

@@ -0,0 +1,5 @@
+package com.simibubi.create.content.contraptions.components.structureMovement;
+
+public class MountedFluidStorage {
+
+}

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/MountedStorage.java

@@ -20,7 +20,6 @@ import net.minecraftforge.items.IItemHandler;
 import net.minecraftforge.items.IItemHandlerModifiable;
 import net.minecraftforge.items.ItemStackHandler;
 
-//FIXME: More dynamic mounted storage in .4
 public class MountedStorage {
 
 	private static final ItemStackHandler dummyHandler = new ItemStackHandler();

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/MovementContext.java

@@ -29,10 +29,11 @@ public class MovementContext {
 	public Contraption contraption;
 	public Object temporaryData;
 
-	public MovementContext(World world, BlockInfo info) {
+	public MovementContext(World world, BlockInfo info, Contraption contraption) {
 		this.world = world;
 		this.state = info.state;
 		this.tileData = info.nbt;
+		this.contraption = contraption;
 		localPos = info.pos;
 
 		firstMovement = true;
@@ -54,8 +55,8 @@ public class MovementContext {
 		return (((int) (length * modifier + 100 * Math.signum(length))) / 100) * 100;
 	}
 
-	public static MovementContext readNBT(World world, BlockInfo info, CompoundNBT nbt) {
-		MovementContext context = new MovementContext(world, info);
+	public static MovementContext readNBT(World world, BlockInfo info, CompoundNBT nbt, Contraption contraption) {
+		MovementContext context = new MovementContext(world, info, contraption);
 		context.motion = VecHelper.readNBT(nbt.getList("Motion", NBT.TAG_DOUBLE));
 		context.relativeMotion = VecHelper.readNBT(nbt.getList("RelativeMotion", NBT.TAG_DOUBLE));
 		if (nbt.contains("Position"))

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/OrientedContraptionEntity.java

@@ -0,0 +1,493 @@
+package com.simibubi.create.content.contraptions.components.structureMovement;
+
+import static com.simibubi.create.foundation.utility.AngleHelper.angleLerp;
+
+import java.util.Optional;
+import java.util.UUID;
+
+import javax.annotation.Nullable;
+
+import com.simibubi.create.AllEntityTypes;
+import com.simibubi.create.content.contraptions.components.structureMovement.bearing.StabilizedContraption;
+import com.simibubi.create.content.contraptions.components.structureMovement.mounted.CartAssemblerTileEntity.CartMovementMode;
+import com.simibubi.create.content.contraptions.components.structureMovement.mounted.MountedContraption;
+import com.simibubi.create.content.contraptions.components.structureMovement.train.capability.CapabilityMinecartController;
+import com.simibubi.create.content.contraptions.components.structureMovement.train.capability.MinecartController;
+import com.simibubi.create.foundation.entity.CreateDataSerializers;
+import com.simibubi.create.foundation.item.ItemHelper;
+import com.simibubi.create.foundation.utility.AngleHelper;
+import com.simibubi.create.foundation.utility.Couple;
+import com.simibubi.create.foundation.utility.NBTHelper;
+import com.simibubi.create.foundation.utility.VecHelper;
+
+import net.minecraft.block.BlockState;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.item.minecart.AbstractMinecartEntity;
+import net.minecraft.entity.item.minecart.FurnaceMinecartEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.nbt.ListNBT;
+import net.minecraft.nbt.NBTUtil;
+import net.minecraft.network.datasync.DataParameter;
+import net.minecraft.network.datasync.DataSerializers;
+import net.minecraft.network.datasync.EntityDataManager;
+import net.minecraft.tags.BlockTags;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Direction.Axis;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.LazyOptional;
+
+/**
+ * Ex: Minecarts, Couplings <br>
+ * Oriented Contraption Entities can rotate freely around two axes
+ * simultaneously.
+ */
+public class OrientedContraptionEntity extends AbstractContraptionEntity {
+
+	private static final Ingredient FUEL_ITEMS = Ingredient.fromItems(Items.COAL, Items.CHARCOAL);
+
+	private static final DataParameter<Optional<UUID>> COUPLING =
+		EntityDataManager.createKey(OrientedContraptionEntity.class, DataSerializers.OPTIONAL_UNIQUE_ID);
+	private static final DataParameter<Optional<Direction>> INITIAL_ORIENTATION =
+		EntityDataManager.createKey(OrientedContraptionEntity.class, CreateDataSerializers.OPTIONAL_DIRECTION);
+
+	protected Vec3d motionBeforeStall;
+	protected boolean forceAngle;
+	private boolean isSerializingFurnaceCart;
+	private boolean attachedExtraInventories;
+
+	public float prevYaw;
+	public float yaw;
+	public float targetYaw;
+
+	public float prevPitch;
+	public float pitch;
+	public float targetPitch;
+
+	// When placed using a contraption item
+	private float initialYawOffset;
+
+	public OrientedContraptionEntity(EntityType<?> type, World world) {
+		super(type, world);
+		motionBeforeStall = Vec3d.ZERO;
+		attachedExtraInventories = false;
+		isSerializingFurnaceCart = false;
+		initialYawOffset = -1;
+	}
+
+	public static OrientedContraptionEntity create(World world, Contraption contraption,
+		Optional<Direction> initialOrientation) {
+		OrientedContraptionEntity entity =
+			new OrientedContraptionEntity(AllEntityTypes.ORIENTED_CONTRAPTION.get(), world);
+		entity.setContraption(contraption);
+		initialOrientation.ifPresent(entity::setInitialOrientation);
+		entity.startAtInitialYaw();
+		return entity;
+	}
+
+	public void setInitialOrientation(Direction direction) {
+		dataManager.set(INITIAL_ORIENTATION, Optional.of(direction));
+	}
+
+	public Optional<Direction> getInitialOrientation() {
+		return dataManager.get(INITIAL_ORIENTATION);
+	}
+
+	public void deferOrientation(Direction newInitialAngle) {
+		dataManager.set(INITIAL_ORIENTATION, Optional.empty());
+		yaw = initialYawOffset = newInitialAngle.getHorizontalAngle();
+	}
+
+	@Override
+	public float getYawOffset() {
+		return getInitialYaw();
+	}
+
+	public float getInitialYaw() {
+		return dataManager.get(INITIAL_ORIENTATION)
+			.orElse(Direction.SOUTH)
+			.getHorizontalAngle();
+	}
+
+	@Override
+	protected void registerData() {
+		super.registerData();
+		dataManager.register(COUPLING, Optional.empty());
+		dataManager.register(INITIAL_ORIENTATION, Optional.empty());
+	}
+
+	@Override
+	public ContraptionRotationState getRotationState() {
+		ContraptionRotationState crs = new ContraptionRotationState();
+
+		float yawOffset = getYawOffset();
+		crs.zRotation = pitch;
+		crs.yRotation = -yaw + yawOffset;
+
+		if (pitch != 0 && yaw != 0) {
+			crs.secondYRotation = -yaw;
+			crs.yRotation = yawOffset;
+		}
+
+		return crs;
+	}
+
+	@Override
+	public void stopRiding() {
+		if (!world.isRemote && isAlive())
+			disassemble();
+		super.stopRiding();
+	}
+
+	@Override
+	protected void readAdditional(CompoundNBT compound) {
+		super.readAdditional(compound);
+
+		if (compound.contains("InitialOrientation"))
+			setInitialOrientation(NBTHelper.readEnum(compound, "InitialOrientation", Direction.class));
+		if (compound.contains("ForceYaw"))
+			startAtYaw(compound.getFloat("ForceYaw"));
+
+		ListNBT vecNBT = compound.getList("CachedMotion", 6);
+		if (!vecNBT.isEmpty()) {
+			motionBeforeStall = new Vec3d(vecNBT.getDouble(0), vecNBT.getDouble(1), vecNBT.getDouble(2));
+			if (!motionBeforeStall.equals(Vec3d.ZERO))
+				targetYaw = prevYaw = yaw += yawFromVector(motionBeforeStall);
+			setMotion(Vec3d.ZERO);
+		}
+
+		yaw = compound.getFloat("Yaw");
+		pitch = compound.getFloat("Pitch");
+
+		setCouplingId(
+			compound.contains("OnCoupling") ? NBTUtil.readUniqueId(compound.getCompound("OnCoupling")) : null);
+	}
+
+	@Override
+	protected void writeAdditional(CompoundNBT compound) {
+		super.writeAdditional(compound);
+
+		if (motionBeforeStall != null)
+			compound.put("CachedMotion",
+				newDoubleNBTList(motionBeforeStall.x, motionBeforeStall.y, motionBeforeStall.z));
+
+		Optional<Direction> optional = dataManager.get(INITIAL_ORIENTATION);
+		if (optional.isPresent())
+			NBTHelper.writeEnum(compound, "InitialOrientation", optional.get());
+		if (forceAngle) {
+			compound.putFloat("ForceYaw", yaw);
+			forceAngle = false;
+		}
+
+		compound.putFloat("Yaw", yaw);
+		compound.putFloat("Pitch", pitch);
+
+		if (getCouplingId() != null)
+			compound.put("OnCoupling", NBTUtil.writeUniqueId(getCouplingId()));
+	}
+
+	@Override
+	public void notifyDataManagerChange(DataParameter<?> key) {
+		super.notifyDataManagerChange(key);
+		if (key == INITIAL_ORIENTATION && dataManager.get(INITIAL_ORIENTATION)
+			.isPresent())
+			startAtInitialYaw();
+	}
+
+	public void startAtInitialYaw() {
+		startAtYaw(getInitialYaw());
+	}
+
+	public void startAtYaw(float yaw) {
+		targetYaw = this.yaw = prevYaw = yaw;
+		forceAngle = true;
+	}
+
+	@Override
+	public Vec3d applyRotation(Vec3d localPos, float partialTicks) {
+		localPos = VecHelper.rotate(localPos, getInitialYaw(), Axis.Y);
+		localPos = VecHelper.rotate(localPos, getPitch(partialTicks), Axis.Z);
+		localPos = VecHelper.rotate(localPos, getYaw(partialTicks), Axis.Y);
+		return localPos;
+	}
+
+	@Override
+	public Vec3d reverseRotation(Vec3d localPos, float partialTicks) {
+		localPos = VecHelper.rotate(localPos, -getYaw(partialTicks), Axis.Y);
+		localPos = VecHelper.rotate(localPos, -getPitch(partialTicks), Axis.Z);
+		localPos = VecHelper.rotate(localPos, -getInitialYaw(), Axis.Y);
+		return localPos;
+	}
+
+	public float getYaw(float partialTicks) {
+		return -(partialTicks == 1.0F ? yaw : angleLerp(partialTicks, prevYaw, yaw));
+	}
+
+	public float getPitch(float partialTicks) {
+		return partialTicks == 1.0F ? pitch : angleLerp(partialTicks, prevPitch, pitch);
+	}
+
+	@Override
+	protected void tickContraption() {
+		Entity e = getRidingEntity();
+		if (e == null)
+			return;
+
+		boolean rotationLock = false;
+		boolean pauseWhileRotating = false;
+		boolean wasStalled = isStalled();
+		if (contraption instanceof MountedContraption) {
+			MountedContraption mountedContraption = (MountedContraption) contraption;
+			rotationLock = mountedContraption.rotationMode == CartMovementMode.ROTATION_LOCKED;
+			pauseWhileRotating = mountedContraption.rotationMode == CartMovementMode.ROTATE_PAUSED;
+		}
+
+		Entity riding = e;
+		while (riding.getRidingEntity() != null && !(contraption instanceof StabilizedContraption))
+			riding = riding.getRidingEntity();
+
+		boolean isOnCoupling = false;
+		UUID couplingId = getCouplingId();
+		isOnCoupling = couplingId != null && riding instanceof AbstractMinecartEntity;
+
+		if (!attachedExtraInventories) {
+			attachInventoriesFromRidingCarts(riding, isOnCoupling, couplingId);
+			attachedExtraInventories = true;
+		}
+
+		boolean rotating = updateOrientation(rotationLock, wasStalled, riding, isOnCoupling);
+		if (!rotating || !pauseWhileRotating)
+			tickActors();
+		boolean isStalled = isStalled();
+
+		LazyOptional<MinecartController> capability =
+			riding.getCapability(CapabilityMinecartController.MINECART_CONTROLLER_CAPABILITY);
+		if (capability.isPresent()) {
+			if (!world.isRemote())
+				capability.orElse(null)
+					.setStalledExternally(isStalled);
+		} else {
+			if (isStalled) {
+				if (!wasStalled)
+					motionBeforeStall = riding.getMotion();
+				riding.setMotion(0, 0, 0);
+			}
+			if (wasStalled && !isStalled) {
+				riding.setMotion(motionBeforeStall);
+				motionBeforeStall = Vec3d.ZERO;
+			}
+		}
+
+		if (world.isRemote)
+			return;
+
+		if (!isStalled()) {
+			if (isOnCoupling) {
+				Couple<MinecartController> coupledCarts = getCoupledCartsIfPresent();
+				if (coupledCarts == null)
+					return;
+				coupledCarts.map(MinecartController::cart)
+					.forEach(this::powerFurnaceCartWithFuelFromStorage);
+				return;
+			}
+			powerFurnaceCartWithFuelFromStorage(riding);
+		}
+	}
+
+	protected boolean updateOrientation(boolean rotationLock, boolean wasStalled, Entity riding, boolean isOnCoupling) {
+		if (isOnCoupling) {
+			Couple<MinecartController> coupledCarts = getCoupledCartsIfPresent();
+			if (coupledCarts == null)
+				return false;
+
+			Vec3d positionVec = coupledCarts.getFirst()
+				.cart()
+				.getPositionVec();
+			Vec3d coupledVec = coupledCarts.getSecond()
+				.cart()
+				.getPositionVec();
+
+			double diffX = positionVec.x - coupledVec.x;
+			double diffY = positionVec.y - coupledVec.y;
+			double diffZ = positionVec.z - coupledVec.z;
+
+			prevYaw = yaw;
+			prevPitch = pitch;
+			yaw = (float) (MathHelper.atan2(diffZ, diffX) * 180 / Math.PI);
+			pitch = (float) (Math.atan2(diffY, Math.sqrt(diffX * diffX + diffZ * diffZ)) * 180 / Math.PI);
+
+			if (getCouplingId().equals(riding.getUniqueID())) {
+				pitch *= -1;
+				yaw += 180;
+			}
+			return false;
+		}
+
+		if (contraption instanceof StabilizedContraption) {
+			if (!(riding instanceof OrientedContraptionEntity))
+				return false;
+			StabilizedContraption stabilized = (StabilizedContraption) contraption;
+			Direction facing = stabilized.getFacing();
+			if (facing.getAxis()
+				.isVertical())
+				return false;
+			OrientedContraptionEntity parent = (OrientedContraptionEntity) riding;
+			prevYaw = yaw;
+			yaw = -parent.getYaw(1);
+			return false;
+		}
+
+		if (wasStalled)
+			return false;
+
+		boolean rotating = false;
+		Vec3d movementVector = riding.getMotion();
+
+		if (!(riding instanceof AbstractMinecartEntity))
+			movementVector = getPositionVec().subtract(prevPosX, prevPosY, prevPosZ);
+		Vec3d motion = movementVector.normalize();
+
+		if (!dataManager.get(INITIAL_ORIENTATION)
+			.isPresent() && !world.isRemote) {
+			if (motion.length() > 0) {
+				Direction facingFromVector = Direction.getFacingFromVector(motion.x, motion.y, motion.z);
+				if (initialYawOffset != -1)
+					facingFromVector = Direction.fromAngle(facingFromVector.getHorizontalAngle() - initialYawOffset);
+				if (facingFromVector.getAxis()
+					.isHorizontal())
+					setInitialOrientation(facingFromVector);
+			}
+		}
+
+		if (!rotationLock) {
+			if (motion.length() > 0) {
+				targetYaw = yawFromVector(motion);
+				if (targetYaw < 0)
+					targetYaw += 360;
+				if (yaw < 0)
+					yaw += 360;
+			}
+
+			prevYaw = yaw;
+			yaw = angleLerp(0.4f, yaw, targetYaw);
+			if (Math.abs(AngleHelper.getShortestAngleDiff(yaw, targetYaw)) < 1f)
+				yaw = targetYaw;
+			else
+				rotating = true;
+		}
+		return rotating;
+	}
+
+	protected void powerFurnaceCartWithFuelFromStorage(Entity riding) {
+		if (!(riding instanceof FurnaceMinecartEntity))
+			return;
+		FurnaceMinecartEntity furnaceCart = (FurnaceMinecartEntity) riding;
+
+		// Notify to not trigger serialization side-effects
+		isSerializingFurnaceCart = true;
+		CompoundNBT nbt = furnaceCart.serializeNBT();
+		isSerializingFurnaceCart = false;
+
+		int fuel = nbt.getInt("Fuel");
+		int fuelBefore = fuel;
+		double pushX = nbt.getDouble("PushX");
+		double pushZ = nbt.getDouble("PushZ");
+
+		int i = MathHelper.floor(furnaceCart.getX());
+		int j = MathHelper.floor(furnaceCart.getY());
+		int k = MathHelper.floor(furnaceCart.getZ());
+		if (furnaceCart.world.getBlockState(new BlockPos(i, j - 1, k))
+			.isIn(BlockTags.RAILS))
+			--j;
+
+		BlockPos blockpos = new BlockPos(i, j, k);
+		BlockState blockstate = this.world.getBlockState(blockpos);
+		if (furnaceCart.canUseRail() && blockstate.isIn(BlockTags.RAILS))
+			if (fuel > 1)
+				riding.setMotion(riding.getMotion()
+					.normalize()
+					.scale(1));
+		if (fuel < 5 && contraption != null) {
+			ItemStack coal = ItemHelper.extract(contraption.inventory, FUEL_ITEMS, 1, false);
+			if (!coal.isEmpty())
+				fuel += 3600;
+		}
+
+		if (fuel != fuelBefore || pushX != 0 || pushZ != 0) {
+			nbt.putInt("Fuel", fuel);
+			nbt.putDouble("PushX", 0);
+			nbt.putDouble("PushZ", 0);
+			furnaceCart.deserializeNBT(nbt);
+		}
+	}
+
+	@Nullable
+	public Couple<MinecartController> getCoupledCartsIfPresent() {
+		UUID couplingId = getCouplingId();
+		if (couplingId == null)
+			return null;
+		MinecartController controller = CapabilityMinecartController.getIfPresent(world, couplingId);
+		if (controller == null || !controller.isPresent())
+			return null;
+		UUID coupledCart = controller.getCoupledCart(true);
+		MinecartController coupledController = CapabilityMinecartController.getIfPresent(world, coupledCart);
+		if (coupledController == null || !coupledController.isPresent())
+			return null;
+		return Couple.create(controller, coupledController);
+	}
+
+	protected void attachInventoriesFromRidingCarts(Entity riding, boolean isOnCoupling, UUID couplingId) {
+		if (isOnCoupling) {
+			Couple<MinecartController> coupledCarts = getCoupledCartsIfPresent();
+			if (coupledCarts == null)
+				return;
+			coupledCarts.map(MinecartController::cart)
+				.forEach(contraption::addExtraInventories);
+			return;
+		}
+		contraption.addExtraInventories(riding);
+	}
+
+	@Override
+	public CompoundNBT writeWithoutTypeId(CompoundNBT nbt) {
+		return isSerializingFurnaceCart ? nbt : super.writeWithoutTypeId(nbt);
+	}
+
+	@Nullable
+	public UUID getCouplingId() {
+		Optional<UUID> uuid = dataManager.get(COUPLING);
+		return uuid == null ? null : uuid.isPresent() ? uuid.get() : null;
+	}
+
+	public void setCouplingId(UUID id) {
+		dataManager.set(COUPLING, Optional.ofNullable(id));
+	}
+
+	@Override
+	public Vec3d getAnchorVec() {
+		return new Vec3d(getX() - .5, getY(), getZ() - .5);
+	}
+
+	@Override
+	protected StructureTransform makeStructureTransform() {
+		BlockPos offset = new BlockPos(getAnchorVec().add(.5, .5, .5));
+		return new StructureTransform(offset, 0, -yaw + getInitialYaw(), 0);
+	}
+
+	@Override
+	protected float getStalledAngle() {
+		return yaw;
+	}
+
+	@Override
+	protected void handleStallInformation(float x, float y, float z, float angle) {
+		yaw = angle;
+	}
+
+}

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/OrientedContraptionEntityRenderer.java

@@ -0,0 +1,96 @@
+package com.simibubi.create.content.contraptions.components.structureMovement;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.simibubi.create.foundation.utility.MatrixStacker;
+
+import net.minecraft.client.renderer.culling.ClippingHelperImpl;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.minecart.AbstractMinecartEntity;
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.math.Vec3d;
+
+public class OrientedContraptionEntityRenderer extends AbstractContraptionEntityRenderer<OrientedContraptionEntity> {
+
+	public OrientedContraptionEntityRenderer(EntityRendererManager p_i46179_1_) {
+		super(p_i46179_1_);
+	}
+
+	@Override
+	public boolean shouldRender(OrientedContraptionEntity entity, ClippingHelperImpl p_225626_2_, double p_225626_3_,
+		double p_225626_5_, double p_225626_7_) {
+		if (!super.shouldRender(entity, p_225626_2_, p_225626_3_, p_225626_5_, p_225626_7_))
+			return false;
+		if (entity.getContraption()
+			.getType() == AllContraptionTypes.MOUNTED && entity.getRidingEntity() == null)
+			return false;
+		return true;
+	}
+
+	@Override
+	protected void transform(OrientedContraptionEntity entity, float partialTicks, MatrixStack[] matrixStacks) {
+		float angleInitialYaw = entity.getInitialYaw();
+		float angleYaw = entity.getYaw(partialTicks);
+		float anglePitch = entity.getPitch(partialTicks);
+
+		for (MatrixStack stack : matrixStacks)
+			stack.translate(-.5f, 0, -.5f);
+
+		Entity ridingEntity = entity.getRidingEntity();
+		if (ridingEntity instanceof AbstractMinecartEntity)
+			repositionOnCart(partialTicks, matrixStacks, ridingEntity);
+		if (ridingEntity instanceof AbstractContraptionEntity) {
+			if (ridingEntity.getRidingEntity() instanceof AbstractMinecartEntity)
+				repositionOnCart(partialTicks, matrixStacks, ridingEntity.getRidingEntity());
+			else
+				repositionOnContraption(entity, partialTicks, matrixStacks, ridingEntity);
+		}
+
+		for (MatrixStack stack : matrixStacks)
+			MatrixStacker.of(stack)
+				.nudge(entity.getEntityId())
+				.centre()
+				.rotateY(angleYaw)
+				.rotateZ(anglePitch)
+				.rotateY(angleInitialYaw)
+				.unCentre();
+	}
+
+	private void repositionOnContraption(OrientedContraptionEntity entity, float partialTicks,
+		MatrixStack[] matrixStacks, Entity ridingEntity) {
+		AbstractContraptionEntity parent = (AbstractContraptionEntity) ridingEntity;
+		Vec3d passengerPosition = parent.getPassengerPosition(entity, partialTicks);
+		double x = passengerPosition.x - MathHelper.lerp(partialTicks, entity.lastTickPosX, entity.getX());
+		double y = passengerPosition.y - MathHelper.lerp(partialTicks, entity.lastTickPosY, entity.getY());
+		double z = passengerPosition.z - MathHelper.lerp(partialTicks, entity.lastTickPosZ, entity.getZ());
+		for (MatrixStack stack : matrixStacks)
+			stack.translate(x, y, z);
+	}
+
+	// Minecarts do not always render at their exact location, so the contraption
+	// has to adjust aswell
+	private void repositionOnCart(float partialTicks, MatrixStack[] matrixStacks, Entity ridingEntity) {
+		AbstractMinecartEntity cart = (AbstractMinecartEntity) ridingEntity;
+		double cartX = MathHelper.lerp(partialTicks, cart.lastTickPosX, cart.getX());
+		double cartY = MathHelper.lerp(partialTicks, cart.lastTickPosY, cart.getY());
+		double cartZ = MathHelper.lerp(partialTicks, cart.lastTickPosZ, cart.getZ());
+		Vec3d cartPos = cart.getPos(cartX, cartY, cartZ);
+
+		if (cartPos != null) {
+			Vec3d cartPosFront = cart.getPosOffset(cartX, cartY, cartZ, (double) 0.3F);
+			Vec3d cartPosBack = cart.getPosOffset(cartX, cartY, cartZ, (double) -0.3F);
+			if (cartPosFront == null)
+				cartPosFront = cartPos;
+			if (cartPosBack == null)
+				cartPosBack = cartPos;
+
+			cartX = cartPos.x - cartX;
+			cartY = (cartPosFront.y + cartPosBack.y) / 2.0D - cartY;
+			cartZ = cartPos.z - cartZ;
+
+			for (MatrixStack stack : matrixStacks)
+				stack.translate(cartX, cartY, cartZ);
+		}
+	}
+
+}

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/StructureTransform.java

@@ -40,19 +40,19 @@ public class StructureTransform {
 	Axis rotationAxis;
 	BlockPos offset;
 
-	public StructureTransform(BlockPos offset, Vec3d rotation) {
+	public StructureTransform(BlockPos offset, float xRotation, float yRotation, float zRotation) {
 		this.offset = offset;
-		if (rotation.x != 0) {
+		if (xRotation != 0) {
 			rotationAxis = Axis.X;
-			angle = (int) (Math.round(rotation.x / 90) * 90);
+			angle = (int) (Math.round(xRotation / 90) * 90);
 		}
-		if (rotation.y != 0) {
+		if (yRotation != 0) {
 			rotationAxis = Axis.Y;
-			angle = (int) (Math.round(rotation.y / 90) * 90);
+			angle = (int) (Math.round(yRotation / 90) * 90);
 		}
-		if (rotation.z != 0) {
+		if (zRotation != 0) {
 			rotationAxis = Axis.Z;
-			angle = (int) (Math.round(rotation.z / 90) * 90);
+			angle = (int) (Math.round(zRotation / 90) * 90);
 		}
 
 		angle %= 360;

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/TranslatingContraption.java

@@ -0,0 +1,45 @@
+package com.simibubi.create.content.contraptions.components.structureMovement;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import net.minecraft.util.Direction;
+import net.minecraft.util.Direction.Axis;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import net.minecraft.world.gen.feature.template.Template.BlockInfo;
+
+public abstract class TranslatingContraption extends Contraption {
+
+	protected Set<BlockPos> cachedColliders;
+	protected Direction cachedColliderDirection;
+
+	public Set<BlockPos> getColliders(World world, Direction movementDirection) {
+		if (getBlocks() == null)
+			return null;
+		if (cachedColliders == null || cachedColliderDirection != movementDirection) {
+			cachedColliders = new HashSet<>();
+			cachedColliderDirection = movementDirection;
+
+			for (BlockInfo info : getBlocks().values()) {
+				BlockPos offsetPos = info.pos.offset(movementDirection);
+				if (info.state.getCollisionShape(world, offsetPos)
+					.isEmpty())
+					continue;
+				if (getBlocks().containsKey(offsetPos)
+					&& !getBlocks().get(offsetPos).state.getCollisionShape(world, offsetPos)
+						.isEmpty())
+					continue;
+				cachedColliders.add(info.pos);
+			}
+
+		}
+		return cachedColliders;
+	}
+
+	@Override
+	protected boolean canAxisBeStabilized(Axis axis) {
+		return false;
+	}
+	
+}

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/bearing/BearingContraption.java

@@ -6,9 +6,11 @@ import com.simibubi.create.AllTags.AllBlockTags;
 import com.simibubi.create.content.contraptions.components.structureMovement.AllContraptionTypes;
 import com.simibubi.create.content.contraptions.components.structureMovement.Contraption;
 
+import net.minecraft.client.renderer.FaceDirection;
 import net.minecraft.nbt.CompoundNBT;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.Direction;
+import net.minecraft.util.Direction.Axis;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 import net.minecraft.world.gen.feature.template.Template.BlockInfo;
@@ -18,40 +20,52 @@ public class BearingContraption extends Contraption {
 	protected int sailBlocks;
 	protected Direction facing;
 	
+	private boolean isWindmill;
+
+	public BearingContraption() {}
+
+	public BearingContraption(boolean isWindmill, Direction facing) {
+		this.isWindmill = isWindmill;
+		this.facing = facing;
+	}
+
+	@Override
+	public boolean assemble(World world, BlockPos pos) {
+		BlockPos offset = pos.offset(facing);
+		if (!searchMovedStructure(world, offset, null))
+			return false;
+		startMoving(world);
+		expandBoundsAroundAxis(facing.getAxis());
+		if (isWindmill && sailBlocks == 0)
+			return false;
+		if (blocks.isEmpty())
+			return false;
+		return true;
+	}
+
 	@Override
 	protected AllContraptionTypes getType() {
 		return AllContraptionTypes.BEARING;
 	}
 
-	public static BearingContraption assembleBearingAt(World world, BlockPos pos, Direction direction) {
-		BearingContraption construct = new BearingContraption();
-		construct.facing = direction;
-		BlockPos offset = pos.offset(direction);
-		if (!construct.searchMovedStructure(world, offset, null))
-			return null;
-		construct.initActors(world);
-		construct.expandBoundsAroundAxis(direction.getAxis());
-		return construct;
-	}
-
 	@Override
 	protected boolean isAnchoringBlockAt(BlockPos pos) {
 		return pos.equals(anchor.offset(facing.getOpposite()));
 	}
 
 	@Override
-	public void add(BlockPos pos, Pair<BlockInfo, TileEntity> capture) {
+	public void addBlock(BlockPos pos, Pair<BlockInfo, TileEntity> capture) {
 		BlockPos localPos = pos.subtract(anchor);
-		if (!blocks.containsKey(localPos) && AllBlockTags.WINDMILL_SAILS.matches(capture.getKey().state))
+		if (!getBlocks().containsKey(localPos) && AllBlockTags.WINDMILL_SAILS.matches(capture.getKey().state))
 			sailBlocks++;
-		super.add(pos, capture);
+		super.addBlock(pos, capture);
 	}
 
 	@Override
 	public CompoundNBT writeNBT() {
 		CompoundNBT tag = super.writeNBT();
 		tag.putInt("Sails", sailBlocks);
-		tag.putInt("facing", facing.getIndex());
+		tag.putInt("Facing", facing.getIndex());
 		return tag;
 	}
 
@@ -70,4 +84,9 @@ public class BearingContraption extends Contraption {
 		return facing;
 	}
 
+	@Override
+	protected boolean canAxisBeStabilized(Axis axis) {
+		return axis == facing.getAxis();
+	}
+
 }

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/bearing/ClockworkBearingTileEntity.java

@@ -5,7 +5,8 @@ import java.util.List;
 import org.apache.commons.lang3.tuple.Pair;
 
 import com.simibubi.create.content.contraptions.base.KineticTileEntity;
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.ControlledContraptionEntity;
 import com.simibubi.create.content.contraptions.components.structureMovement.bearing.ClockworkContraption.HandType;
 import com.simibubi.create.foundation.gui.AllIcons;
 import com.simibubi.create.foundation.tileEntity.TileEntityBehaviour;
@@ -15,20 +16,19 @@ import com.simibubi.create.foundation.utility.AngleHelper;
 import com.simibubi.create.foundation.utility.Lang;
 import com.simibubi.create.foundation.utility.ServerSpeedProvider;
 
+import net.minecraft.block.BlockState;
 import net.minecraft.nbt.CompoundNBT;
 import net.minecraft.state.properties.BlockStateProperties;
 import net.minecraft.tileentity.TileEntityType;
 import net.minecraft.util.Direction;
 import net.minecraft.util.Direction.Axis;
-import net.minecraft.util.Direction.AxisDirection;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.MathHelper;
-import net.minecraft.util.math.Vec3d;
 
 public class ClockworkBearingTileEntity extends KineticTileEntity implements IBearingTileEntity {
 
-	protected ContraptionEntity hourHand;
-	protected ContraptionEntity minuteHand;
+	protected ControlledContraptionEntity hourHand;
+	protected ControlledContraptionEntity minuteHand;
 	protected float hourAngle;
 	protected float minuteAngle;
 	protected float clientHourAngleDiff;
@@ -71,7 +71,9 @@ public class ClockworkBearingTileEntity extends KineticTileEntity implements IBe
 			assembleNextTick = false;
 			if (running) {
 				boolean canDisassemble = true;
-				if (speed == 0 && (canDisassemble || hourHand == null || hourHand.getContraption().blocks.isEmpty())) {
+				if (speed == 0 && (canDisassemble || hourHand == null || hourHand.getContraption()
+					.getBlocks()
+					.isEmpty())) {
 					if (hourHand != null)
 						hourHand.getContraption()
 							.stop(world);
@@ -103,19 +105,18 @@ public class ClockworkBearingTileEntity extends KineticTileEntity implements IBe
 	}
 
 	protected void applyRotations() {
-		Axis axis = getBlockState().get(BlockStateProperties.FACING)
-			.getAxis();
-		Direction direction = Direction.getFacingFromAxis(AxisDirection.POSITIVE, axis);
-		Vec3d directionVec = new Vec3d(direction.getDirectionVec());
+		BlockState blockState = getBlockState();
+		Axis axis = Axis.X;
+		if (blockState.has(BlockStateProperties.FACING))
+			axis = blockState.get(BlockStateProperties.FACING).getAxis();
+			
 		if (hourHand != null) {
-			Vec3d vec = new Vec3d(1, 1, 1).scale(hourAngle)
-				.mul(directionVec);
-			hourHand.rotateTo(vec.x, vec.y, vec.z);
+			hourHand.setAngle(hourAngle);
+			hourHand.setRotationAxis(axis);
 		}
 		if (minuteHand != null) {
-			Vec3d vec = new Vec3d(1, 1, 1).scale(minuteAngle)
-				.mul(directionVec);
-			minuteHand.rotateTo(vec.x, vec.y, vec.z);
+			minuteHand.setAngle(minuteAngle);
+			minuteHand.setRotationAxis(axis);
 		}
 	}
 
@@ -202,24 +203,26 @@ public class ClockworkBearingTileEntity extends KineticTileEntity implements IBe
 			return;
 		if (contraption.getLeft() == null)
 			return;
-		if (contraption.getLeft().blocks.isEmpty())
+		if (contraption.getLeft()
+			.getBlocks()
+			.isEmpty())
 			return;
 		BlockPos anchor = pos.offset(direction);
 
 		contraption.getLeft()
 			.removeBlocksFromWorld(world, BlockPos.ZERO);
-		hourHand = ContraptionEntity.createStationary(world, contraption.getLeft())
-			.controlledBy(this);
+		hourHand = ControlledContraptionEntity.create(world, this, contraption.getLeft());
 		hourHand.setPosition(anchor.getX(), anchor.getY(), anchor.getZ());
+		hourHand.setRotationAxis(direction.getAxis());
 		world.addEntity(hourHand);
 
 		if (contraption.getRight() != null) {
 			anchor = pos.offset(direction, contraption.getRight().offset + 1);
 			contraption.getRight()
 				.removeBlocksFromWorld(world, BlockPos.ZERO);
-			minuteHand = ContraptionEntity.createStationary(world, contraption.getRight())
-				.controlledBy(this);
+			minuteHand = ControlledContraptionEntity.create(world, this, contraption.getRight());
 			minuteHand.setPosition(anchor.getX(), anchor.getY(), anchor.getZ());
+			minuteHand.setRotationAxis(direction.getAxis());
 			world.addEntity(minuteHand);
 		}
 
@@ -251,7 +254,7 @@ public class ClockworkBearingTileEntity extends KineticTileEntity implements IBe
 	}
 
 	@Override
-	public void attach(ContraptionEntity contraption) {
+	public void attach(ControlledContraptionEntity contraption) {
 		if (!(contraption.getContraption() instanceof ClockworkContraption))
 			return;
 
@@ -339,7 +342,7 @@ public class ClockworkBearingTileEntity extends KineticTileEntity implements IBe
 	public void collided() {}
 
 	@Override
-	public boolean isAttachedTo(ContraptionEntity contraption) {
+	public boolean isAttachedTo(AbstractContraptionEntity contraption) {
 		if (!(contraption.getContraption() instanceof ClockworkContraption))
 			return false;
 		ClockworkContraption cc = (ClockworkContraption) contraption.getContraption();
@@ -381,4 +384,9 @@ public class ClockworkBearingTileEntity extends KineticTileEntity implements IBe
 
 	}
 
+	@Override
+	public BlockPos getBlockPosition() {
+		return pos;
+	}
+
 }

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/bearing/ClockworkContraption.java

@@ -12,6 +12,7 @@ import com.simibubi.create.foundation.utility.NBTHelper;
 
 import net.minecraft.nbt.CompoundNBT;
 import net.minecraft.util.Direction;
+import net.minecraft.util.Direction.Axis;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
@@ -38,7 +39,7 @@ public class ClockworkContraption extends Contraption {
 	}
 
 	public static Pair<ClockworkContraption, ClockworkContraption> assembleClockworkAt(World world, BlockPos pos,
-			Direction direction) {
+		Direction direction) {
 		int hourArmBlocks = 0;
 
 		ClockworkContraption hourArm = new ClockworkContraption();
@@ -46,11 +47,12 @@ public class ClockworkContraption extends Contraption {
 
 		hourArm.facing = direction;
 		hourArm.handType = HandType.HOUR;
-		if (!hourArm.searchMovedStructure(world, pos, direction))
+		if (!hourArm.assemble(world, pos))
 			return null;
 		for (int i = 0; i < 16; i++) {
 			BlockPos offsetPos = BlockPos.ZERO.offset(direction, i);
-			if (hourArm.blocks.containsKey(offsetPos))
+			if (hourArm.getBlocks()
+				.containsKey(offsetPos))
 				continue;
 			hourArmBlocks = i;
 			break;
@@ -61,22 +63,29 @@ public class ClockworkContraption extends Contraption {
 			minuteArm.facing = direction;
 			minuteArm.handType = HandType.MINUTE;
 			minuteArm.offset = hourArmBlocks;
-			minuteArm.ignoreBlocks(hourArm.blocks.keySet(), hourArm.anchor);
-			if (!minuteArm.searchMovedStructure(world, pos, direction))
+			minuteArm.ignoreBlocks(hourArm.getBlocks()
+				.keySet(), hourArm.anchor);
+			if (!minuteArm.assemble(world, pos))
 				return null;
-			if (minuteArm.blocks.isEmpty())
+			if (minuteArm.getBlocks()
+				.isEmpty())
 				minuteArm = null;
 		}
 
-		hourArm.initActors(world);
+		hourArm.startMoving(world);
 		hourArm.expandBoundsAroundAxis(direction.getAxis());
 		if (minuteArm != null) {
-			minuteArm.initActors(world);
+			minuteArm.startMoving(world);
 			minuteArm.expandBoundsAroundAxis(direction.getAxis());
 		}
 		return Pair.of(hourArm, minuteArm);
 	}
 	
+	@Override
+	public boolean assemble(World world, BlockPos pos) {
+		return searchMovedStructure(world, pos, facing);
+	}
+
 	@Override
 	public boolean searchMovedStructure(World world, BlockPos pos, Direction direction) {
 		return super.searchMovedStructure(world, pos.offset(direction, offset + 1), null);
@@ -84,7 +93,7 @@ public class ClockworkContraption extends Contraption {
 
 	@Override
 	protected boolean moveBlock(World world, BlockPos pos, Direction direction, List<BlockPos> frontier,
-			Set<BlockPos> visited) {
+		Set<BlockPos> visited) {
 		if (ignoreBlocks.contains(pos))
 			return true;
 		return super.moveBlock(world, pos, direction, frontier, visited);
@@ -107,6 +116,11 @@ public class ClockworkContraption extends Contraption {
 		super.readNBT(world, tag);
 	}
 
+	@Override
+	protected boolean canAxisBeStabilized(Axis axis) {
+		return axis == facing.getAxis();
+	}
+	
 	public static enum HandType {
 		HOUR, MINUTE
 	}

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/bearing/MechanicalBearingTileEntity.java

@@ -5,7 +5,8 @@ import static net.minecraft.state.properties.BlockStateProperties.FACING;
 import java.util.List;
 
 import com.simibubi.create.content.contraptions.base.GeneratingKineticTileEntity;
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.ControlledContraptionEntity;
 import com.simibubi.create.foundation.item.TooltipHelper;
 import com.simibubi.create.foundation.tileEntity.TileEntityBehaviour;
 import com.simibubi.create.foundation.tileEntity.behaviour.scrollvalue.ScrollOptionBehaviour;
@@ -15,18 +16,16 @@ import com.simibubi.create.foundation.utility.ServerSpeedProvider;
 
 import net.minecraft.block.BlockState;
 import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.state.properties.BlockStateProperties;
 import net.minecraft.tileentity.TileEntityType;
 import net.minecraft.util.Direction;
-import net.minecraft.util.Direction.Axis;
-import net.minecraft.util.Direction.AxisDirection;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.MathHelper;
-import net.minecraft.util.math.Vec3d;
 
 public class MechanicalBearingTileEntity extends GeneratingKineticTileEntity implements IBearingTileEntity {
 
 	protected ScrollOptionBehaviour<RotationMode> movementMode;
-	protected ContraptionEntity movedContraption;
+	protected ControlledContraptionEntity movedContraption;
 	protected float angle;
 	protected boolean running;
 	protected boolean assembleNextTick;
@@ -108,30 +107,28 @@ public class MechanicalBearingTileEntity extends GeneratingKineticTileEntity imp
 		return false;
 	}
 
+	@Override
+	public BlockPos getBlockPosition() {
+		return pos;
+	}
+
 	public void assemble() {
 		if (!(world.getBlockState(pos)
 			.getBlock() instanceof BearingBlock))
 			return;
 
 		Direction direction = getBlockState().get(FACING);
+		BearingContraption contraption = new BearingContraption(isWindmill(), direction);
+		if (!contraption.assemble(world, pos))
+			return;
 
-		// Collect Construct
-		BearingContraption contraption = BearingContraption.assembleBearingAt(world, pos, direction);
-		if (contraption == null)
-			return;
-		if (isWindmill() && contraption.getSailBlocks() == 0)
-			return;
-		if (contraption.blocks.isEmpty())
-			return;
 		contraption.removeBlocksFromWorld(world, BlockPos.ZERO);
-
-		movedContraption = ContraptionEntity.createStationary(world, contraption)
-			.controlledBy(this);
+		movedContraption = ControlledContraptionEntity.create(world, this, contraption);
 		BlockPos anchor = pos.offset(direction);
 		movedContraption.setPosition(anchor.getX(), anchor.getY(), anchor.getZ());
+		movedContraption.setRotationAxis(direction.getAxis());
 		world.addEntity(movedContraption);
 
-		// Run
 		running = true;
 		angle = 0;
 		sendData();
@@ -166,8 +163,9 @@ public class MechanicalBearingTileEntity extends GeneratingKineticTileEntity imp
 			if (running) {
 				boolean canDisassemble = movementMode.get() == RotationMode.ROTATE_PLACE
 					|| (isNearInitialAngle() && movementMode.get() == RotationMode.ROTATE_PLACE_RETURNED);
-				if (speed == 0 && (canDisassemble || movedContraption == null
-					|| movedContraption.getContraption().blocks.isEmpty())) {
+				if (speed == 0 && (canDisassemble || movedContraption == null || movedContraption.getContraption()
+					.getBlocks()
+					.isEmpty())) {
 					if (movedContraption != null)
 						movedContraption.getContraption()
 							.stop(world);
@@ -206,18 +204,17 @@ public class MechanicalBearingTileEntity extends GeneratingKineticTileEntity imp
 	}
 
 	protected void applyRotation() {
-		if (movedContraption != null) {
-			Axis axis = getBlockState().get(FACING)
-				.getAxis();
-			Direction direction = Direction.getFacingFromAxis(AxisDirection.POSITIVE, axis);
-			Vec3d vec = new Vec3d(1, 1, 1).scale(angle)
-				.mul(new Vec3d(direction.getDirectionVec()));
-			movedContraption.rotateTo(vec.x, vec.y, vec.z);
-		}
+		if (movedContraption == null)
+			return;
+		movedContraption.setAngle(angle);
+		BlockState blockState = getBlockState();
+		if (blockState.has(BlockStateProperties.FACING))
+			movedContraption.setRotationAxis(blockState.get(BlockStateProperties.FACING)
+				.getAxis());
 	}
 
 	@Override
-	public void attach(ContraptionEntity contraption) {
+	public void attach(ControlledContraptionEntity contraption) {
 		BlockState blockState = getBlockState();
 		if (!(contraption.getContraption() instanceof BearingContraption))
 			return;
@@ -249,7 +246,7 @@ public class MechanicalBearingTileEntity extends GeneratingKineticTileEntity imp
 	public void collided() {}
 
 	@Override
-	public boolean isAttachedTo(ContraptionEntity contraption) {
+	public boolean isAttachedTo(AbstractContraptionEntity contraption) {
 		return movedContraption == contraption;
 	}
 
@@ -263,15 +260,14 @@ public class MechanicalBearingTileEntity extends GeneratingKineticTileEntity imp
 			return true;
 		if (isPlayerSneaking)
 			return false;
-		if (isWindmill())
-			return false;
-		if (getSpeed() == 0)
+		if (!isWindmill() && getSpeed() == 0)
 			return false;
 		if (running)
 			return false;
 		BlockState state = getBlockState();
 		if (!(state.getBlock() instanceof BearingBlock))
 			return false;
+		
 		BlockState attachedState = world.getBlockState(pos.offset(state.get(BearingBlock.FACING)));
 		if (attachedState.getMaterial()
 			.isReplaceable())

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/bearing/StabilizedBearingMovementBehaviour.java

@@ -0,0 +1,73 @@
+package com.simibubi.create.content.contraptions.components.structureMovement.bearing;
+
+import java.util.Optional;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.simibubi.create.AllBlockPartials;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.ControlledContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.MovementBehaviour;
+import com.simibubi.create.content.contraptions.components.structureMovement.MovementContext;
+import com.simibubi.create.content.contraptions.components.structureMovement.OrientedContraptionEntity;
+import com.simibubi.create.foundation.utility.AngleHelper;
+import com.simibubi.create.foundation.utility.SuperByteBuffer;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.state.properties.BlockStateProperties;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Direction.Axis;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+public class StabilizedBearingMovementBehaviour extends MovementBehaviour {
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void renderInContraption(MovementContext context, MatrixStack ms, MatrixStack msLocal,
+		IRenderTypeBuffer buffer) {
+		Direction facing = context.state.get(BlockStateProperties.FACING);
+		AllBlockPartials top = AllBlockPartials.BEARING_TOP;
+		SuperByteBuffer superBuffer = top.renderOn(context.state);
+		float renderPartialTicks = Minecraft.getInstance()
+			.getRenderPartialTicks();
+
+		// rotate to match blockstate
+		Axis axis = facing.getAxis();
+		if (axis.isHorizontal())
+			superBuffer.rotateCentered(Direction.UP,
+				AngleHelper.rad(AngleHelper.horizontalAngle(facing.getOpposite())));
+		superBuffer.rotateCentered(Direction.EAST, AngleHelper.rad(-90 - AngleHelper.verticalAngle(facing)));
+
+		// rotate against parent
+		float offset = 0;
+		int offsetMultiplier = facing.getAxisDirection().getOffset();
+		
+		AbstractContraptionEntity entity = context.contraption.entity;
+		if (entity instanceof ControlledContraptionEntity) {
+			ControlledContraptionEntity controlledCE = (ControlledContraptionEntity) entity;
+			if (controlledCE.getRotationAxis() == axis)
+				offset = -controlledCE.getAngle(renderPartialTicks);
+
+		} else if (entity instanceof OrientedContraptionEntity) {
+			OrientedContraptionEntity orientedCE = (OrientedContraptionEntity) entity;
+			if (axis.isVertical())
+				offset = -orientedCE.getYaw(renderPartialTicks);
+			else {
+				Optional<Direction> initialOrientation = orientedCE.getInitialOrientation();
+				if (initialOrientation.isPresent() && initialOrientation.get()
+					.getAxis() == axis)
+					offset = -orientedCE.getPitch(renderPartialTicks);
+			}
+		}
+		if (offset != 0)
+			superBuffer.rotateCentered(Direction.UP, AngleHelper.rad(offset * offsetMultiplier));
+
+		// render
+		superBuffer.light(msLocal.peek()
+			.getModel());
+		superBuffer.renderInto(ms, buffer.getBuffer(RenderType.getSolid()));
+	}
+
+}

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/bearing/StabilizedContraption.java

@@ -0,0 +1,66 @@
+package com.simibubi.create.content.contraptions.components.structureMovement.bearing;
+
+import com.simibubi.create.content.contraptions.components.structureMovement.AllContraptionTypes;
+import com.simibubi.create.content.contraptions.components.structureMovement.Contraption;
+
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Direction.Axis;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+public class StabilizedContraption extends Contraption {
+
+	private Direction facing;
+
+	public StabilizedContraption() {}
+
+	public StabilizedContraption(Direction facing) {
+		this.facing = facing;
+	}
+
+	@Override
+	public boolean assemble(World world, BlockPos pos) {
+		BlockPos offset = pos.offset(facing);
+		if (!searchMovedStructure(world, offset, null))
+			return false;
+		startMoving(world);
+		expandBoundsAroundAxis(Axis.Y);
+		if (blocks.isEmpty())
+			return false;
+		return true;
+	}
+	
+	@Override
+	protected boolean isAnchoringBlockAt(BlockPos pos) {
+		return false;
+	}
+
+	@Override
+	protected AllContraptionTypes getType() {
+		return AllContraptionTypes.STABILIZED;
+	}
+	
+	@Override
+	public CompoundNBT writeNBT() {
+		CompoundNBT tag = super.writeNBT();
+		tag.putInt("Facing", facing.getIndex());
+		return tag;
+	}
+
+	@Override
+	public void readNBT(World world, CompoundNBT tag) {
+		facing = Direction.byIndex(tag.getInt("Facing"));
+		super.readNBT(world, tag);
+	}
+	
+	@Override
+	protected boolean canAxisBeStabilized(Axis axis) {
+		return false;
+	}
+	
+	public Direction getFacing() {
+		return facing;
+	}
+
+}

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/mounted/CartAssemblerBlock.java

@@ -11,7 +11,7 @@ import javax.annotation.Nullable;
 import com.simibubi.create.AllBlocks;
 import com.simibubi.create.AllShapes;
 import com.simibubi.create.AllTileEntities;
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.OrientedContraptionEntity;
 import com.simibubi.create.content.contraptions.components.structureMovement.mounted.CartAssemblerTileEntity.CartMovementMode;
 import com.simibubi.create.content.contraptions.components.structureMovement.train.CouplingHandler;
 import com.simibubi.create.content.contraptions.components.structureMovement.train.capability.CapabilityMinecartController;
@@ -225,13 +225,13 @@ public class CartAssemblerBlock extends AbstractRailBlock
 			.isCoupledThroughContraption())
 			return;
 
-		MountedContraption contraption = MountedContraption.assembleMinecart(world, pos);
-		if (contraption == null)
-			return;
-		if (contraption.blocks.size() == 1)
-			return;
+		CartMovementMode mode =
+			getTileEntityOptional(world, pos).map(te -> CartMovementMode.values()[te.movementMode.value])
+				.orElse(CartMovementMode.ROTATE);
 
-		withTileEntityDo(world, pos, te -> contraption.rotationMode = CartMovementMode.values()[te.movementMode.value]);
+		MountedContraption contraption = new MountedContraption(mode);
+		if (!contraption.assemble(world, pos))
+			return;
 
 		boolean couplingFound = contraption.connectedCart != null;
 		Optional<Direction> initialOrientation = cart.getMotion()
@@ -245,7 +245,7 @@ public class CartAssemblerBlock extends AbstractRailBlock
 		}
 
 		contraption.removeBlocksFromWorld(world, BlockPos.ZERO);
-		contraption.initActors(world);
+		contraption.startMoving(world);
 		contraption.expandBoundsAroundAxis(Axis.Y);
 
 		if (couplingFound) {
@@ -254,7 +254,7 @@ public class CartAssemblerBlock extends AbstractRailBlock
 			initialOrientation = Optional.of(Direction.fromAngle(MathHelper.atan2(diff.z, diff.x) * 180 / Math.PI));
 		}
 
-		ContraptionEntity entity = ContraptionEntity.createMounted(world, contraption, initialOrientation);
+		OrientedContraptionEntity entity = OrientedContraptionEntity.create(world, contraption, initialOrientation);
 		if (couplingFound)
 			entity.setCouplingId(cart.getUniqueID());
 		entity.setPosition(pos.getX(), pos.getY(), pos.getZ());
@@ -275,9 +275,9 @@ public class CartAssemblerBlock extends AbstractRailBlock
 			return;
 		Entity entity = cart.getPassengers()
 			.get(0);
-		if (!(entity instanceof ContraptionEntity))
+		if (!(entity instanceof OrientedContraptionEntity))
 			return;
-		ContraptionEntity contraption = (ContraptionEntity) entity;
+		OrientedContraptionEntity contraption = (OrientedContraptionEntity) entity;
 		UUID couplingId = contraption.getCouplingId();
 
 		if (couplingId == null) {

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/mounted/MinecartContraptionItem.java

@@ -6,8 +6,9 @@ import java.util.Optional;
 import javax.annotation.Nullable;
 
 import com.simibubi.create.AllItems;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
 import com.simibubi.create.content.contraptions.components.structureMovement.Contraption;
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.OrientedContraptionEntity;
 import com.simibubi.create.foundation.utility.NBTHelper;
 
 import net.minecraft.block.AbstractRailBlock;
@@ -29,7 +30,6 @@ import net.minecraft.state.properties.RailShape;
 import net.minecraft.tags.BlockTags;
 import net.minecraft.util.ActionResultType;
 import net.minecraft.util.Direction;
-import net.minecraft.util.Direction.Axis;
 import net.minecraft.util.NonNullList;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
@@ -162,16 +162,14 @@ public class MinecartContraptionItem extends Item {
 		if (tag.contains("Contraption")) {
 			CompoundNBT contraptionTag = tag.getCompound("Contraption");
 
-			Direction initialOrientation = Direction.SOUTH;
+			Optional<Direction> intialOrientation = Optional.empty();
 			if (contraptionTag.contains("InitialOrientation"))
-				initialOrientation = NBTHelper.readEnum(contraptionTag, "InitialOrientation", Direction.class);
+				intialOrientation =
+					Optional.of(NBTHelper.readEnum(contraptionTag, "InitialOrientation", Direction.class));
 
 			Contraption mountedContraption = Contraption.fromNBT(world, contraptionTag);
-			ContraptionEntity contraptionEntity =
-				ContraptionEntity.createMounted(world, mountedContraption, Optional.of(initialOrientation));
-
-			if (newFacing != null)
-				contraptionEntity.reOrientate(newFacing.getAxis() == Axis.X ? newFacing : newFacing.getOpposite());
+			OrientedContraptionEntity contraptionEntity =
+				OrientedContraptionEntity.create(world, mountedContraption, intialOrientation);
 
 			contraptionEntity.startRiding(cart);
 			contraptionEntity.setPosition(cart.getX(), cart.getY(), cart.getZ());
@@ -197,7 +195,7 @@ public class MinecartContraptionItem extends Item {
 		ItemStack wrench = player.getHeldItem(event.getHand());
 		if (!AllItems.WRENCH.isIn(wrench))
 			return;
-		if (entity instanceof ContraptionEntity)
+		if (entity instanceof AbstractContraptionEntity)
 			entity = entity.getRidingEntity();
 		if (!(entity instanceof AbstractMinecartEntity))
 			return;
@@ -206,9 +204,9 @@ public class MinecartContraptionItem extends Item {
 		if (type != Type.RIDEABLE && type != Type.FURNACE && type != Type.CHEST)
 			return;
 		List<Entity> passengers = cart.getPassengers();
-		if (passengers.isEmpty() || !(passengers.get(0) instanceof ContraptionEntity))
+		if (passengers.isEmpty() || !(passengers.get(0) instanceof OrientedContraptionEntity))
 			return;
-		ContraptionEntity contraption = (ContraptionEntity) passengers.get(0);
+		OrientedContraptionEntity contraption = (OrientedContraptionEntity) passengers.get(0);
 
 		if (!event.getWorld().isRemote) {
 			player.inventory.placeItemBackInInventory(event.getWorld(), create(type, contraption));
@@ -220,21 +218,26 @@ public class MinecartContraptionItem extends Item {
 		event.setCanceled(true);
 	}
 
-	public static ItemStack create(Type type, ContraptionEntity entity) {
+	public static ItemStack create(Type type, OrientedContraptionEntity entity) {
 		ItemStack stack = ItemStack.EMPTY;
+		
 		switch (type) {
-			case RIDEABLE:
-				stack = AllItems.MINECART_CONTRAPTION.asStack();
-				break;
-			case FURNACE:
-				stack = AllItems.FURNACE_MINECART_CONTRAPTION.asStack();
-				break;
-			case CHEST:
-				stack = AllItems.CHEST_MINECART_CONTRAPTION.asStack();
-				break;
+		case RIDEABLE:
+			stack = AllItems.MINECART_CONTRAPTION.asStack();
+			break;
+		case FURNACE:
+			stack = AllItems.FURNACE_MINECART_CONTRAPTION.asStack();
+			break;
+		case CHEST:
+			stack = AllItems.CHEST_MINECART_CONTRAPTION.asStack();
+			break;
+		default:
+			break;
 		}
-		if (stack == ItemStack.EMPTY)
+		
+		if (stack.isEmpty())
 			return stack;
+
 		CompoundNBT tag = entity.getContraption()
 			.writeNBT();
 		tag.remove("UUID");
@@ -243,7 +246,7 @@ public class MinecartContraptionItem extends Item {
 
 		Optional<Direction> initialOrientation = entity.getInitialOrientation();
 		if (initialOrientation.isPresent())
-			NBTHelper.writeEnum(tag, "InitialOrientation", initialOrientation.orElse(null));
+			NBTHelper.writeEnum(tag, "InitialOrientation", initialOrientation.get());
 
 		stack.getOrCreateTag()
 			.put("Contraption", tag);

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/mounted/MountedContraption.java

@@ -39,7 +39,11 @@ public class MountedContraption extends Contraption {
 	public AbstractMinecartEntity connectedCart;
 
 	public MountedContraption() {
-		rotationMode = CartMovementMode.ROTATE;
+		this(CartMovementMode.ROTATE);
+	}
+
+	public MountedContraption(CartMovementMode mode) {
+		rotationMode = mode;
 	}
 
 	@Override
@@ -47,19 +51,22 @@ public class MountedContraption extends Contraption {
 		return AllContraptionTypes.MOUNTED;
 	}
 	
-	public static MountedContraption assembleMinecart(World world, BlockPos pos) {
+	@Override
+	public boolean assemble(World world, BlockPos pos) {
 		BlockState state = world.getBlockState(pos);
 		if (!state.has(RAIL_SHAPE))
-			return null;
-
-		MountedContraption contraption = new MountedContraption();
-		if (!contraption.searchMovedStructure(world, pos, null))
-			return null;
+			return false;
+		if (!searchMovedStructure(world, pos, null))
+			return false;
 		
 		Axis axis = state.get(RAIL_SHAPE) == RailShape.EAST_WEST ? Axis.X : Axis.Z;
-		contraption.add(pos, Pair.of(new BlockInfo(pos, AllBlocks.MINECART_ANCHOR.getDefaultState()
+		addBlock(pos, Pair.of(new BlockInfo(pos, AllBlocks.MINECART_ANCHOR.getDefaultState()
 			.with(BlockStateProperties.HORIZONTAL_AXIS, axis), null), null));
-		return contraption;
+		
+		if (blocks.size() == 1)
+			return false;
+		
+		return true;
 	}
 	
 	@Override
@@ -141,6 +148,11 @@ public class MountedContraption extends Contraption {
 		return AllBlocks.MINECART_ANCHOR.has(state);
 	}
 	
+	@Override
+	protected boolean canAxisBeStabilized(Axis axis) {
+		return true;
+	}
+	
 	@Override
 	public void addExtraInventories(Entity cart) {
 		if (!(cart instanceof IInventory))

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/piston/LinearActuatorTileEntity.java

@@ -3,7 +3,8 @@ package com.simibubi.create.content.contraptions.components.structureMovement.pi
 import java.util.List;
 
 import com.simibubi.create.content.contraptions.base.KineticTileEntity;
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.ControlledContraptionEntity;
 import com.simibubi.create.content.contraptions.components.structureMovement.IControlContraption;
 import com.simibubi.create.foundation.tileEntity.TileEntityBehaviour;
 import com.simibubi.create.foundation.tileEntity.behaviour.ValueBoxTransform;
@@ -13,6 +14,7 @@ import com.simibubi.create.foundation.utility.ServerSpeedProvider;
 
 import net.minecraft.nbt.CompoundNBT;
 import net.minecraft.tileentity.TileEntityType;
+import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.Vec3d;
 
@@ -21,7 +23,7 @@ public abstract class LinearActuatorTileEntity extends KineticTileEntity impleme
 	public float offset;
 	public boolean running;
 	public boolean assembleNextTick;
-	public ContraptionEntity movedContraption;
+	public AbstractContraptionEntity movedContraption;
 	protected boolean forceMove;
 	protected ScrollOptionBehaviour<MovementMode> movementMode;
 	protected boolean waitingForSpeedChange;
@@ -267,7 +269,7 @@ public abstract class LinearActuatorTileEntity extends KineticTileEntity impleme
 	}
 
 	@Override
-	public void attach(ContraptionEntity contraption) {
+	public void attach(ControlledContraptionEntity contraption) {
 		this.movedContraption = contraption;
 		if (!world.isRemote) {
 			this.running = true;
@@ -276,8 +278,13 @@ public abstract class LinearActuatorTileEntity extends KineticTileEntity impleme
 	}
 
 	@Override
-	public boolean isAttachedTo(ContraptionEntity contraption) {
+	public boolean isAttachedTo(AbstractContraptionEntity contraption) {
 		return movedContraption == contraption;
 	}
 	
+	@Override
+	public BlockPos getBlockPosition() {
+		return pos;
+	}
+
 }

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/piston/MechanicalPistonTileEntity.java

@@ -3,7 +3,7 @@ package com.simibubi.create.content.contraptions.components.structureMovement.pi
 import com.simibubi.create.AllBlocks;
 import com.simibubi.create.content.contraptions.base.IRotate;
 import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionCollider;
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.ControlledContraptionEntity;
 import com.simibubi.create.content.contraptions.components.structureMovement.DirectionalExtenderScrollOptionSlot;
 import com.simibubi.create.content.contraptions.components.structureMovement.piston.MechanicalPistonBlock.PistonState;
 import com.simibubi.create.foundation.tileEntity.behaviour.ValueBoxTransform;
@@ -49,20 +49,17 @@ public class MechanicalPistonTileEntity extends LinearActuatorTileEntity {
 		Direction direction = getBlockState().get(BlockStateProperties.FACING);
 
 		// Collect Construct
-		PistonContraption contraption = PistonContraption.movePistonAt(world, pos, direction, getMovementSpeed() < 0);
+		PistonContraption contraption = new PistonContraption(direction, getMovementSpeed() < 0);
+		if (!contraption.assemble(world, pos))
+			return;
+
 		Direction positive = Direction.getFacingFromAxis(AxisDirection.POSITIVE, direction.getAxis());
 		Direction movementDirection =
 			getSpeed() > 0 ^ direction.getAxis() != Axis.Z ? positive : positive.getOpposite();
 
-		if (contraption != null) {
-			BlockPos anchor = contraption.getAnchor()
-				.offset(direction, contraption.initialExtensionProgress);
-			if (ContraptionCollider.isCollidingWithWorld(world, contraption, anchor.offset(movementDirection),
-				movementDirection))
-				contraption = null;
-		}
-
-		if (contraption == null)
+		BlockPos anchor = contraption.anchor.offset(direction, contraption.initialExtensionProgress);
+		if (ContraptionCollider.isCollidingWithWorld(world, contraption, anchor.offset(movementDirection),
+			movementDirection))
 			return;
 
 		// Check if not at limit already
@@ -80,8 +77,7 @@ public class MechanicalPistonTileEntity extends LinearActuatorTileEntity {
 
 		BlockPos startPos = BlockPos.ZERO.offset(direction, contraption.initialExtensionProgress);
 		contraption.removeBlocksFromWorld(world, startPos);
-		movedContraption = ContraptionEntity.createStationary(getWorld(), contraption)
-			.controlledBy(this);
+		movedContraption = ControlledContraptionEntity.create(getWorld(), this, contraption);
 		applyContraptionPosition();
 		forceMove = true;
 		world.addEntity(movedContraption);
@@ -147,8 +143,7 @@ public class MechanicalPistonTileEntity extends LinearActuatorTileEntity {
 	protected Vec3d toPosition(float offset) {
 		Vec3d position = new Vec3d(getBlockState().get(BlockStateProperties.FACING)
 			.getDirectionVec()).scale(offset);
-		return position.add(new Vec3d(movedContraption.getContraption()
-			.getAnchor()));
+		return position.add(new Vec3d(movedContraption.getContraption().anchor));
 	}
 
 	@Override

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/piston/PistonContraption.java

@@ -15,16 +15,14 @@ import org.apache.commons.lang3.tuple.Pair;
 
 import com.simibubi.create.content.contraptions.components.structureMovement.AllContraptionTypes;
 import com.simibubi.create.content.contraptions.components.structureMovement.BlockMovementTraits;
-import com.simibubi.create.content.contraptions.components.structureMovement.Contraption;
+import com.simibubi.create.content.contraptions.components.structureMovement.TranslatingContraption;
 import com.simibubi.create.content.contraptions.components.structureMovement.piston.MechanicalPistonBlock.PistonState;
 import com.simibubi.create.foundation.config.AllConfigs;
-import com.simibubi.create.foundation.utility.NBTHelper;
 import com.simibubi.create.foundation.utility.VecHelper;
 
 import net.minecraft.block.BlockState;
 import net.minecraft.block.CarpetBlock;
 import net.minecraft.nbt.CompoundNBT;
-import net.minecraft.nbt.ListNBT;
 import net.minecraft.state.properties.BlockStateProperties;
 import net.minecraft.state.properties.PistonType;
 import net.minecraft.tileentity.TileEntity;
@@ -35,28 +33,36 @@ import net.minecraft.world.IWorld;
 import net.minecraft.world.World;
 import net.minecraft.world.gen.feature.template.Template.BlockInfo;
 
-public class PistonContraption extends Contraption {
-
-	protected AxisAlignedBB pistonExtensionCollisionBox;
+public class PistonContraption extends TranslatingContraption {
 
 	protected int extensionLength;
 	protected int initialExtensionProgress;
 	protected Direction orientation;
 
+	private AxisAlignedBB pistonExtensionCollisionBox;
+	private boolean retract;
+
 	@Override
 	protected AllContraptionTypes getType() {
 		return AllContraptionTypes.PISTON;
 	}
 
-	public static PistonContraption movePistonAt(World world, BlockPos pos, Direction direction, boolean retract) {
-		PistonContraption construct = new PistonContraption();
-		construct.orientation = direction;
-		if (!construct.collectExtensions(world, pos, direction))
-			return null;
-		if (!construct.searchMovedStructure(world, construct.anchor, retract ? direction.getOpposite() : direction))
-			return null;
-		construct.initActors(world);
-		return construct;
+	public PistonContraption() {}
+
+	public PistonContraption(Direction direction, boolean retract) {
+		orientation = direction;
+		this.retract = retract;
+	}
+
+	@Override
+	public boolean assemble(World world, BlockPos pos) {
+		if (!collectExtensions(world, pos, orientation))
+			return false;
+		if (!searchMovedStructure(world, anchor, retract ? orientation.getOpposite() : orientation))
+			return false;
+		bounds = bounds.union(pistonExtensionCollisionBox);
+		startMoving(world);
+		return true;
 	}
 
 	private boolean collectExtensions(World world, BlockPos pos, Direction direction) {
@@ -123,7 +129,7 @@ public class PistonContraption extends Contraption {
 		for (BlockInfo pole : poles) {
 			BlockPos relPos = pole.pos.offset(direction, -extensionsInFront);
 			BlockPos localPos = relPos.subtract(anchor);
-			blocks.put(localPos, new BlockInfo(localPos, pole.state, null));
+			getBlocks().put(localPos, new BlockInfo(localPos, pole.state, null));
 			pistonExtensionCollisionBox = pistonExtensionCollisionBox.union(new AxisAlignedBB(localPos));
 		}
 
@@ -165,8 +171,8 @@ public class PistonContraption extends Contraption {
 	}
 
 	@Override
-	public void add(BlockPos pos, Pair<BlockInfo, TileEntity> capture) {
-		super.add(pos.offset(orientation, -initialExtensionProgress), capture);
+	public void addBlock(BlockPos pos, Pair<BlockInfo, TileEntity> capture) {
+		super.addBlock(pos.offset(orientation, -initialExtensionProgress), capture);
 	}
 
 	@Override
@@ -205,30 +211,18 @@ public class PistonContraption extends Contraption {
 	@Override
 	public void readNBT(World world, CompoundNBT nbt) {
 		super.readNBT(world, nbt);
-		extensionLength = nbt.getInt("ExtensionLength");
 		initialExtensionProgress = nbt.getInt("InitialLength");
+		extensionLength = nbt.getInt("ExtensionLength");
 		orientation = Direction.byIndex(nbt.getInt("Orientation"));
-		if (nbt.contains("BoundsBack"))
-			pistonExtensionCollisionBox = NBTHelper.readAABB(nbt.getList("BoundsBack", 5));
 	}
 
 	@Override
 	public CompoundNBT writeNBT() {
 		CompoundNBT nbt = super.writeNBT();
-
-		if (pistonExtensionCollisionBox != null) {
-			ListNBT bb = NBTHelper.writeAABB(pistonExtensionCollisionBox);
-			nbt.put("BoundsBack", bb);
-		}
 		nbt.putInt("InitialLength", initialExtensionProgress);
 		nbt.putInt("ExtensionLength", extensionLength);
 		nbt.putInt("Orientation", orientation.getIndex());
-
 		return nbt;
 	}
 
-	@Override
-	public AxisAlignedBB getBoundingBox() {
-		return super.getBoundingBox().union(pistonExtensionCollisionBox);
-	}
 }

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/pulley/PulleyContraption.java

@@ -1,13 +1,13 @@
 package com.simibubi.create.content.contraptions.components.structureMovement.pulley;
 
 import com.simibubi.create.content.contraptions.components.structureMovement.AllContraptionTypes;
-import com.simibubi.create.content.contraptions.components.structureMovement.Contraption;
+import com.simibubi.create.content.contraptions.components.structureMovement.TranslatingContraption;
 
 import net.minecraft.nbt.CompoundNBT;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
-public class PulleyContraption extends Contraption {
+public class PulleyContraption extends TranslatingContraption {
 
 	int initialOffset;
 
@@ -16,13 +16,18 @@ public class PulleyContraption extends Contraption {
 		return AllContraptionTypes.PULLEY;
 	}
 
-	public static PulleyContraption assemblePulleyAt(World world, BlockPos pos, int initialOffset) {
-		PulleyContraption construct = new PulleyContraption();
-		construct.initialOffset = initialOffset;
-		if (!construct.searchMovedStructure(world, pos, null))
-			return null;
-		construct.initActors(world);
-		return construct;
+	public PulleyContraption() {}
+
+	public PulleyContraption(int initialOffset) {
+		this.initialOffset = initialOffset;
+	}
+
+	@Override
+	public boolean assemble(World world, BlockPos pos) {
+		if (!searchMovedStructure(world, pos, null))
+			return false;
+		startMoving(world);
+		return true;
 	}
 
 	@Override

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/pulley/PulleyRenderer.java

@@ -4,7 +4,7 @@ import com.simibubi.create.AllBlockPartials;
 import com.simibubi.create.AllBlocks;
 import com.simibubi.create.CreateClient;
 import com.simibubi.create.content.contraptions.base.KineticTileEntity;
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
 import com.simibubi.create.foundation.utility.SuperByteBuffer;
 
 import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher;
@@ -19,7 +19,8 @@ public class PulleyRenderer extends AbstractPulleyRenderer {
 
 	@Override
 	protected Axis getShaftAxis(KineticTileEntity te) {
-		return te.getBlockState().get(PulleyBlock.HORIZONTAL_AXIS);
+		return te.getBlockState()
+			.get(PulleyBlock.HORIZONTAL_AXIS);
 	}
 
 	@Override
@@ -45,11 +46,10 @@ public class PulleyRenderer extends AbstractPulleyRenderer {
 		float offset = pulley.getInterpolatedOffset(moving ? partialTicks : 0.5f);
 
 		if (pulley.movedContraption != null) {
-			ContraptionEntity e = pulley.movedContraption;
+			AbstractContraptionEntity e = pulley.movedContraption;
 			PulleyContraption c = (PulleyContraption) pulley.movedContraption.getContraption();
 			double entityPos = MathHelper.lerp(partialTicks, e.lastTickPosY, e.getY());
-			offset = (float) -(entityPos - c.getAnchor()
-				.getY() - c.initialOffset);
+			offset = (float) -(entityPos - c.anchor.getY() - c.initialOffset);
 		}
 
 		return offset;

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/pulley/PulleyTileEntity.java

@@ -3,7 +3,7 @@ package com.simibubi.create.content.contraptions.components.structureMovement.pu
 import com.simibubi.create.AllBlocks;
 import com.simibubi.create.content.contraptions.components.structureMovement.BlockMovementTraits;
 import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionCollider;
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.ControlledContraptionEntity;
 import com.simibubi.create.content.contraptions.components.structureMovement.piston.LinearActuatorTileEntity;
 import com.simibubi.create.foundation.config.AllConfigs;
 import com.simibubi.create.foundation.tileEntity.behaviour.CenteredSideValueBoxTransform;
@@ -20,184 +20,191 @@ import net.minecraft.tileentity.TileEntityType;
 import net.minecraft.util.Direction;
 import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.Vec3d;
 
 public class PulleyTileEntity extends LinearActuatorTileEntity {
 
-    protected int initialOffset;
+	protected int initialOffset;
 
-    public PulleyTileEntity(TileEntityType<? extends PulleyTileEntity> type) {
-        super(type);
-    }
+	public PulleyTileEntity(TileEntityType<? extends PulleyTileEntity> type) {
+		super(type);
+	}
 
-    @Override
-    public AxisAlignedBB getRenderBoundingBox() {
-        return super.getRenderBoundingBox().expand(0, -offset, 0);
-    }
+	@Override
+	public AxisAlignedBB getRenderBoundingBox() {
+		return super.getRenderBoundingBox().expand(0, -offset, 0);
+	}
 
-    @Override
-    public double getMaxRenderDistanceSquared() {
-        return super.getMaxRenderDistanceSquared() + offset * offset;
-    }
+	@Override
+	public double getMaxRenderDistanceSquared() {
+		return super.getMaxRenderDistanceSquared() + offset * offset;
+	}
 
-    @Override
-    protected void assemble() {
-        if (!(world.getBlockState(pos)
-                .getBlock() instanceof PulleyBlock))
-            return;
-        if (speed == 0)
-            return;
-        if (offset >= getExtensionRange() && getSpeed() > 0)
-            return;
-        if (offset <= 0 && getSpeed() < 0)
-            return;
+	@Override
+	protected void assemble() {
+		if (!(world.getBlockState(pos)
+			.getBlock() instanceof PulleyBlock))
+			return;
+		if (speed == 0)
+			return;
+		if (offset >= getExtensionRange() && getSpeed() > 0)
+			return;
+		if (offset <= 0 && getSpeed() < 0)
+			return;
 
-        // Collect Construct
-        if (!world.isRemote) {
-            BlockPos anchor = pos.down((int) (offset + 1));
-            initialOffset = (int) (offset);
-            PulleyContraption contraption = PulleyContraption.assemblePulleyAt(world, anchor, (int) offset);
+		// Collect Construct
+		if (!world.isRemote) {
+			BlockPos anchor = pos.down(MathHelper.floor(offset + 1));
+			initialOffset = MathHelper.floor(offset);
+			PulleyContraption contraption = new PulleyContraption(initialOffset);
+			boolean canAssembleStructure = contraption.assemble(world, anchor);
 
-            if (contraption != null) {
-                Direction movementDirection = getSpeed() > 0 ? Direction.DOWN : Direction.UP;
-                if (ContraptionCollider.isCollidingWithWorld(world, contraption, anchor.offset(movementDirection),
-                        movementDirection))
-                    contraption = null;
-            }
+			if (canAssembleStructure) {
+				Direction movementDirection = getSpeed() > 0 ? Direction.DOWN : Direction.UP;
+				if (ContraptionCollider.isCollidingWithWorld(world, contraption, anchor.offset(movementDirection),
+					movementDirection))
+					canAssembleStructure = false;
+			}
 
-            if (contraption == null && getSpeed() > 0)
-                return;
+			if (!canAssembleStructure && getSpeed() > 0)
+				return;
 
-            for (int i = ((int) offset); i > 0; i--) {
-                BlockPos offset = pos.down(i);
-                BlockState oldState = world.getBlockState(offset);
-                if (oldState.getBlock() instanceof IWaterLoggable && oldState.has(BlockStateProperties.WATERLOGGED) && oldState.get(BlockStateProperties.WATERLOGGED)) {
-                    world.setBlockState(offset, Blocks.WATER.getDefaultState(), 66);
-                    continue;
-                }
-                world.setBlockState(offset, Blocks.AIR.getDefaultState(), 66);
-            }
+			for (int i = ((int) offset); i > 0; i--) {
+				BlockPos offset = pos.down(i);
+				BlockState oldState = world.getBlockState(offset);
+				if (oldState.getBlock() instanceof IWaterLoggable && oldState.has(BlockStateProperties.WATERLOGGED)
+					&& oldState.get(BlockStateProperties.WATERLOGGED)) {
+					world.setBlockState(offset, Blocks.WATER.getDefaultState(), 66);
+					continue;
+				}
+				world.setBlockState(offset, Blocks.AIR.getDefaultState(), 66);
+			}
 
-            if (contraption != null && !contraption.blocks.isEmpty()) {
-                contraption.removeBlocksFromWorld(world, BlockPos.ZERO);
-                movedContraption = ContraptionEntity.createStationary(world, contraption)
-                        .controlledBy(this);
-                movedContraption.setPosition(anchor.getX(), anchor.getY(), anchor.getZ());
-                world.addEntity(movedContraption);
-                forceMove = true;
-            }
-        }
+			if (contraption != null && !contraption.getBlocks()
+				.isEmpty()) {
+				contraption.removeBlocksFromWorld(world, BlockPos.ZERO);
+				movedContraption = ControlledContraptionEntity.create(world, this, contraption);
+				movedContraption.setPosition(anchor.getX(), anchor.getY(), anchor.getZ());
+				world.addEntity(movedContraption);
+				forceMove = true;
+			}
+		}
 
-        clientOffsetDiff = 0;
-        running = true;
-        sendData();
-    }
+		clientOffsetDiff = 0;
+		running = true;
+		sendData();
+	}
 
-    @Override
-    public void disassemble() {
-        if (!running && movedContraption == null)
-            return;
-        offset = getGridOffset(offset);
-        if (movedContraption != null)
-            applyContraptionPosition();
+	@Override
+	public void disassemble() {
+		if (!running && movedContraption == null)
+			return;
+		offset = getGridOffset(offset);
+		if (movedContraption != null)
+			applyContraptionPosition();
 
-        if (!world.isRemote) {
-            if (!removed) {
-                if (offset > 0) {
-                    BlockPos magnetPos = pos.down((int) offset);
-                    IFluidState ifluidstate = world.getFluidState(magnetPos);
-                    world.destroyBlock(magnetPos, world.getBlockState(magnetPos)
-                            .getCollisionShape(world, magnetPos)
-                            .isEmpty());
-                    world.setBlockState(magnetPos, AllBlocks.PULLEY_MAGNET.getDefaultState().with(BlockStateProperties.WATERLOGGED, Boolean.valueOf(ifluidstate.getFluid() == Fluids.WATER)), 66);
-                }
+		if (!world.isRemote) {
+			if (!removed) {
+				if (offset > 0) {
+					BlockPos magnetPos = pos.down((int) offset);
+					IFluidState ifluidstate = world.getFluidState(magnetPos);
+					world.destroyBlock(magnetPos, world.getBlockState(magnetPos)
+						.getCollisionShape(world, magnetPos)
+						.isEmpty());
+					world.setBlockState(magnetPos, AllBlocks.PULLEY_MAGNET.getDefaultState()
+						.with(BlockStateProperties.WATERLOGGED,
+							Boolean.valueOf(ifluidstate.getFluid() == Fluids.WATER)),
+						66);
+				}
 
-                boolean[] waterlog = new boolean[(int) offset];
+				boolean[] waterlog = new boolean[(int) offset];
 
-                for (int i = 1; i <= ((int) offset) - 1; i++) {
-                    BlockPos ropePos = pos.down(i);
-                    IFluidState ifluidstate = world.getFluidState(ropePos);
-                    waterlog[i] = ifluidstate.getFluid() == Fluids.WATER;
-                    world.destroyBlock(ropePos, world.getBlockState(ropePos)
-                            .getCollisionShape(world, ropePos)
-                            .isEmpty());
-                }
-                for (int i = 1; i <= ((int) offset) - 1; i++)
-                    world.setBlockState(pos.down(i), AllBlocks.ROPE.getDefaultState().with(BlockStateProperties.WATERLOGGED, waterlog[i]), 66);
-            }
+				for (int i = 1; i <= ((int) offset) - 1; i++) {
+					BlockPos ropePos = pos.down(i);
+					IFluidState ifluidstate = world.getFluidState(ropePos);
+					waterlog[i] = ifluidstate.getFluid() == Fluids.WATER;
+					world.destroyBlock(ropePos, world.getBlockState(ropePos)
+						.getCollisionShape(world, ropePos)
+						.isEmpty());
+				}
+				for (int i = 1; i <= ((int) offset) - 1; i++)
+					world.setBlockState(pos.down(i), AllBlocks.ROPE.getDefaultState()
+						.with(BlockStateProperties.WATERLOGGED, waterlog[i]), 66);
+			}
 
-            if (movedContraption != null)
-                movedContraption.disassemble();
-        }
+			if (movedContraption != null)
+				movedContraption.disassemble();
+		}
 
-        if (movedContraption != null)
-            movedContraption.remove();
-        movedContraption = null;
-        initialOffset = 0;
-        running = false;
-        sendData();
-    }
+		if (movedContraption != null)
+			movedContraption.remove();
+		movedContraption = null;
+		initialOffset = 0;
+		running = false;
+		sendData();
+	}
 
-    @Override
-    protected Vec3d toPosition(float offset) {
-        if (movedContraption.getContraption() instanceof PulleyContraption) {
-            PulleyContraption contraption = (PulleyContraption) movedContraption.getContraption();
-            return new Vec3d(contraption.getAnchor()).add(0, contraption.initialOffset - offset, 0);
+	@Override
+	protected Vec3d toPosition(float offset) {
+		if (movedContraption.getContraption() instanceof PulleyContraption) {
+			PulleyContraption contraption = (PulleyContraption) movedContraption.getContraption();
+			return new Vec3d(contraption.anchor).add(0, contraption.initialOffset - offset, 0);
 
-        }
-        return Vec3d.ZERO;
-    }
+		}
+		return Vec3d.ZERO;
+	}
 
-    @Override
-    protected void visitNewPosition() {
-        super.visitNewPosition();
-        if (world.isRemote)
-            return;
-        if (movedContraption != null)
-            return;
-        if (getSpeed() <= 0)
-            return;
+	@Override
+	protected void visitNewPosition() {
+		super.visitNewPosition();
+		if (world.isRemote)
+			return;
+		if (movedContraption != null)
+			return;
+		if (getSpeed() <= 0)
+			return;
 
-        BlockPos posBelow = pos.down((int) (offset + getMovementSpeed()) + 1);
-        if (!BlockMovementTraits.movementNecessary(world, posBelow))
-            return;
-        if (BlockMovementTraits.isBrittle(world.getBlockState(posBelow)))
-            return;
+		BlockPos posBelow = pos.down((int) (offset + getMovementSpeed()) + 1);
+		if (!BlockMovementTraits.movementNecessary(world, posBelow))
+			return;
+		if (BlockMovementTraits.isBrittle(world.getBlockState(posBelow)))
+			return;
 
-        disassemble();
-        assembleNextTick = true;
-    }
+		disassemble();
+		assembleNextTick = true;
+	}
 
-    @Override
-    protected void read(CompoundNBT compound, boolean clientPacket) {
-        initialOffset = compound.getInt("InitialOffset");
-        super.read(compound, clientPacket);
-    }
+	@Override
+	protected void read(CompoundNBT compound, boolean clientPacket) {
+		initialOffset = compound.getInt("InitialOffset");
+		super.read(compound, clientPacket);
+	}
 
-    @Override
-    public void write(CompoundNBT compound, boolean clientPacket) {
-        compound.putInt("InitialOffset", initialOffset);
-        super.write(compound, clientPacket);
-    }
+	@Override
+	public void write(CompoundNBT compound, boolean clientPacket) {
+		compound.putInt("InitialOffset", initialOffset);
+		super.write(compound, clientPacket);
+	}
 
-    @Override
-    protected int getExtensionRange() {
-        return Math.max(0, Math.min(AllConfigs.SERVER.kinetics.maxRopeLength.get(), pos.getY() - 1));
-    }
+	@Override
+	protected int getExtensionRange() {
+		return Math.max(0, Math.min(AllConfigs.SERVER.kinetics.maxRopeLength.get(), pos.getY() - 1));
+	}
 
-    @Override
-    protected int getInitialOffset() {
-        return initialOffset;
-    }
+	@Override
+	protected int getInitialOffset() {
+		return initialOffset;
+	}
 
-    @Override
-    protected Vec3d toMotionVector(float speed) {
-        return new Vec3d(0, -speed, 0);
-    }
+	@Override
+	protected Vec3d toMotionVector(float speed) {
+		return new Vec3d(0, -speed, 0);
+	}
 
-    @Override
-    protected ValueBoxTransform getMovementModeSlot() {
-        return new CenteredSideValueBoxTransform((state, d) -> d == Direction.UP);
-    }
+	@Override
+	protected ValueBoxTransform getMovementModeSlot() {
+		return new CenteredSideValueBoxTransform((state, d) -> d == Direction.UP);
+	}
 
 }

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/sync/ContraptionInteractionPacket.java

@@ -2,7 +2,7 @@ package com.simibubi.create.content.contraptions.components.structureMovement.sy
 
 import java.util.function.Supplier;
 
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
 import com.simibubi.create.foundation.networking.SimplePacketBase;
 
 import net.minecraft.entity.Entity;
@@ -20,7 +20,7 @@ public class ContraptionInteractionPacket extends SimplePacketBase {
 	private BlockPos localPos;
 	private Direction face;
 
-	public ContraptionInteractionPacket(ContraptionEntity target, Hand hand, BlockPos localPos, Direction side) {
+	public ContraptionInteractionPacket(AbstractContraptionEntity target, Hand hand, BlockPos localPos, Direction side) {
 		this.interactionHand = hand;
 		this.localPos = localPos;
 		this.target = target.getEntityId();
@@ -53,9 +53,9 @@ public class ContraptionInteractionPacket extends SimplePacketBase {
 					return;
 				Entity entityByID = sender.getServerWorld()
 					.getEntityByID(target);
-				if (!(entityByID instanceof ContraptionEntity))
+				if (!(entityByID instanceof AbstractContraptionEntity))
 					return;
-				ContraptionEntity contraptionEntity = (ContraptionEntity) entityByID;
+				AbstractContraptionEntity contraptionEntity = (AbstractContraptionEntity) entityByID;
 				if (contraptionEntity.handlePlayerInteraction(sender, localPos, face, interactionHand))
 					sender.swingHand(interactionHand, true);
 			});

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/sync/ContraptionSeatMappingPacket.java

@@ -5,7 +5,7 @@ import java.util.Map;
 import java.util.UUID;
 import java.util.function.Supplier;
 
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
 import com.simibubi.create.foundation.networking.SimplePacketBase;
 
 import net.minecraft.client.Minecraft;
@@ -46,9 +46,9 @@ public class ContraptionSeatMappingPacket extends SimplePacketBase {
 		context.get()
 			.enqueueWork(() -> {
 				Entity entityByID = Minecraft.getInstance().world.getEntityByID(entityID);
-				if (!(entityByID instanceof ContraptionEntity))
+				if (!(entityByID instanceof AbstractContraptionEntity))
 					return;
-				ContraptionEntity contraptionEntity = (ContraptionEntity) entityByID;
+				AbstractContraptionEntity contraptionEntity = (AbstractContraptionEntity) entityByID;
 				contraptionEntity.getContraption()
 					.setSeatMapping(mapping);
 			});

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/train/CouplingHandler.java

@@ -8,7 +8,7 @@ import javax.annotation.Nullable;
 
 import com.simibubi.create.AllItems;
 import com.simibubi.create.Create;
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
 import com.simibubi.create.content.contraptions.components.structureMovement.train.capability.CapabilityMinecartController;
 import com.simibubi.create.content.contraptions.components.structureMovement.train.capability.MinecartController;
 import com.simibubi.create.foundation.config.AllConfigs;
@@ -38,7 +38,7 @@ public class CouplingHandler {
 		LazyOptional<MinecartController> optional = e.getCapability(CapabilityMinecartController.MINECART_CONTROLLER_CAPABILITY);
 		if (!optional.isPresent())
 			return;
-		if (event.getEntityMounting() instanceof ContraptionEntity)
+		if (event.getEntityMounting() instanceof AbstractContraptionEntity)
 			return;
 		MinecartController controller = optional.orElse(null);
 		if (controller.isCoupledThroughContraption()) {

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/train/capability/MinecartController.java

@@ -11,7 +11,8 @@ import javax.annotation.Nullable;
 import org.apache.commons.lang3.mutable.MutableBoolean;
 
 import com.simibubi.create.Create;
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.OrientedContraptionEntity;
 import com.simibubi.create.content.contraptions.components.structureMovement.train.CouplingHandler;
 import com.simibubi.create.foundation.networking.AllPackets;
 import com.simibubi.create.foundation.utility.Couple;
@@ -131,8 +132,8 @@ public class MinecartController implements INBTSerializable<CompoundNBT> {
 			List<Entity> passengers = cart().getPassengers();
 			if (!passengers.isEmpty()) {
 				Entity entity = passengers.get(0);
-				if (entity instanceof ContraptionEntity) 
-					((ContraptionEntity) entity).disassemble();
+				if (entity instanceof AbstractContraptionEntity) 
+					((AbstractContraptionEntity) entity).disassemble();
 			}
 		}
 		
@@ -172,9 +173,9 @@ public class MinecartController implements INBTSerializable<CompoundNBT> {
 					if (passengers.isEmpty())
 						return;
 					Entity entity = passengers.get(0);
-					if (!(entity instanceof ContraptionEntity))
+					if (!(entity instanceof OrientedContraptionEntity))
 						return;
-					ContraptionEntity contraption = (ContraptionEntity) entity;
+					OrientedContraptionEntity contraption = (OrientedContraptionEntity) entity;
 					UUID couplingId = contraption.getCouplingId();
 					if (couplingId == cd.mainCartID) {
 						contraption.setCouplingId(cd.connectedCartID);

src/main/java/com/simibubi/create/content/contraptions/components/structureMovement/train/capability/MinecartControllerUpdatePacket.java

@@ -32,7 +32,7 @@ public class MinecartControllerUpdatePacket extends SimplePacketBase {
 
 	@Override
 	public void write(PacketBuffer buffer) {
-		buffer.writeInt(entityID);
+ 		buffer.writeInt(entityID);
 		buffer.writeCompoundTag(nbt);
 	}
 

src/main/java/com/simibubi/create/content/contraptions/processing/BasinMovementBehaviour.java

@@ -51,7 +51,7 @@ public class BasinMovementBehaviour extends MovementBehaviour {
 			}
 			context.tileData.put(key, itemStackHandler.serializeNBT());
 		});
-		context.contraption.customRenderTEs.stream()
+		context.contraption.renderedTileEntities.stream()
 			.filter(te -> te.getPos()
 				.equals(context.localPos) && te instanceof BasinTileEntity)
 			.forEach(te -> ((BasinTileEntity) te).readOnlyItems(context.tileData));

src/main/java/com/simibubi/create/content/contraptions/relays/belt/transport/BeltMovementHandler.java

@@ -7,7 +7,7 @@ import static net.minecraft.util.Direction.AxisDirection.POSITIVE;
 import java.util.List;
 
 import com.simibubi.create.AllBlocks;
-import com.simibubi.create.content.contraptions.components.structureMovement.ContraptionEntity;
+import com.simibubi.create.content.contraptions.components.structureMovement.AbstractContraptionEntity;
 import com.simibubi.create.content.contraptions.relays.belt.BeltBlock;
 import com.simibubi.create.content.contraptions.relays.belt.BeltPart;
 import com.simibubi.create.content.contraptions.relays.belt.BeltSlope;
@@ -184,7 +184,7 @@ public class BeltMovementHandler {
 	}
 
 	public static boolean shouldIgnoreBlocking(Entity me, Entity other) {
-		if (other instanceof ContraptionEntity)
+		if (other instanceof AbstractContraptionEntity)
 			return true;
 		if (other instanceof HangingEntity)
 			return true;

src/main/java/com/simibubi/create/foundation/block/ITE.java

@@ -1,5 +1,6 @@
 package com.simibubi.create.foundation.block;
 
+import java.util.Optional;
 import java.util.function.Consumer;
 
 import com.simibubi.create.Create;
@@ -23,6 +24,13 @@ public interface ITE<T extends TileEntity> {
 		} catch (TileEntityException e) {}
 	}
 	
+	default Optional<T> getTileEntityOptional(IBlockReader world, BlockPos pos) {
+		try {
+			return Optional.of(getTileEntity(world, pos));
+		} catch (TileEntityException e) {}
+		return Optional.empty();
+	}
+
 	@SuppressWarnings("unchecked")
 	default T getTileEntity(IBlockReader worldIn, BlockPos pos) throws TileEntityException {
 		TileEntity tileEntity = worldIn.getTileEntity(pos);

src/main/java/com/simibubi/create/foundation/entity/CreateDataSerializers.java

@@ -0,0 +1,34 @@
+package com.simibubi.create.foundation.entity;
+
+import java.util.Optional;
+
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.network.datasync.DataSerializers;
+import net.minecraft.network.datasync.IDataSerializer;
+import net.minecraft.util.Direction;
+
+public class CreateDataSerializers {
+
+	public static final IDataSerializer<Optional<Direction>> OPTIONAL_DIRECTION =
+		new IDataSerializer<Optional<Direction>>() {
+
+			public void write(PacketBuffer buffer, Optional<Direction> opt) {
+				buffer.writeVarInt(opt.map(Direction::ordinal)
+					.orElse(-1) + 1);
+			}
+
+			public Optional<Direction> read(PacketBuffer buffer) {
+				int i = buffer.readVarInt();
+				return i == 0 ? Optional.empty() : Optional.of(Direction.values()[i - 1]);
+			}
+
+			public Optional<Direction> copyValue(Optional<Direction> opt) {
+				return Optional.ofNullable(opt.orElse(null));
+			}
+		};
+
+	static {
+		DataSerializers.registerSerializer(OPTIONAL_DIRECTION);
+	}
+	
+}

src/main/java/com/simibubi/create/foundation/utility/MatrixStacker.java

@@ -3,6 +3,7 @@ package com.simibubi.create.foundation.utility;
 import com.mojang.blaze3d.matrix.MatrixStack;
 
 import net.minecraft.client.renderer.Vector3f;
+import net.minecraft.util.Direction.Axis;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.util.math.Vec3i;
@@ -21,6 +22,12 @@ public class MatrixStacker {
 		return instance;
 	}
 
+	public MatrixStacker rotate(double angle, Axis axis) {
+		Vector3f vec =
+			axis == Axis.X ? Vector3f.POSITIVE_X : axis == Axis.Y ? Vector3f.POSITIVE_Y : Vector3f.POSITIVE_Z;
+		return multiply(vec, angle);
+	}
+
 	public MatrixStacker rotateX(double angle) {
 		return multiply(Vector3f.POSITIVE_X, angle);
 	}