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

This commit is contained in:
simibubi 2020-11-20 16:35:26 +01:00
commit df8d2ddbee
54 changed files with 2576 additions and 1860 deletions

View file

@ -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 =

View file

@ -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);
}

View file

@ -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());
}

View file

@ -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) {

View file

@ -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) {

View file

@ -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");

View file

@ -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);
}

View file

@ -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;
}
}
}

View file

@ -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;
}
}

View file

@ -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;
}

View file

@ -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))

View file

@ -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;
}
}

View file

@ -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)

View file

@ -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;
}
}

View file

@ -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) {

View file

@ -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;

View file

@ -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);

View file

@ -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);
}

View file

@ -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;
}
}

View file

@ -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();
}
}

View file

@ -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();
}

View file

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

View file

@ -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();

View file

@ -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"))

View file

@ -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;
}
}

View file

@ -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);
}
}
}

View file

@ -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;

View file

@ -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;
}
}

View file

@ -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();
}
}

View file

@ -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;
}
}

View file

@ -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
}

View file

@ -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())

View file

@ -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()));
}
}

View file

@ -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;
}
}

View file

@ -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) {

View file

@ -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);

View file

@ -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))

View file

@ -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;
}
}

View file

@ -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

View file

@ -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);
}
}

View file

@ -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

View file

@ -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;

View file

@ -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);
}
}

View file

@ -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);
});

View file

@ -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);
});

View file

@ -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()) {

View file

@ -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);

View file

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

View file

@ -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));

View file

@ -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;

View file

@ -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);

View file

@ -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);
}
}

View file

@ -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);
}