378 lines
12 KiB
Java
378 lines
12 KiB
Java
package nl.andrewlalis.speed_carts.mixin;
|
|
|
|
import com.mojang.datafixers.util.Pair;
|
|
import net.minecraft.block.AbstractRailBlock;
|
|
import net.minecraft.block.BlockState;
|
|
import net.minecraft.block.Blocks;
|
|
import net.minecraft.block.PoweredRailBlock;
|
|
import net.minecraft.block.entity.BlockEntity;
|
|
import net.minecraft.block.entity.SignBlockEntity;
|
|
import net.minecraft.block.enums.RailShape;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.EntityType;
|
|
import net.minecraft.entity.MovementType;
|
|
import net.minecraft.entity.player.PlayerEntity;
|
|
import net.minecraft.entity.vehicle.AbstractMinecartEntity;
|
|
import net.minecraft.sound.SoundCategory;
|
|
import net.minecraft.sound.SoundEvents;
|
|
import net.minecraft.state.property.Properties;
|
|
import net.minecraft.text.Text;
|
|
import net.minecraft.util.DyeColor;
|
|
import net.minecraft.util.math.*;
|
|
import net.minecraft.world.World;
|
|
import nl.andrewlalis.speed_carts.SpeedCarts;
|
|
import org.spongepowered.asm.mixin.Mixin;
|
|
import org.spongepowered.asm.mixin.Shadow;
|
|
import org.spongepowered.asm.mixin.injection.At;
|
|
import org.spongepowered.asm.mixin.injection.Inject;
|
|
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
|
|
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.List;
|
|
import java.util.regex.Pattern;
|
|
|
|
/**
|
|
* Mixin which overrides the default minecart behavior so that we can define a
|
|
* changeable speed, and check for updates.
|
|
*/
|
|
@Mixin(AbstractMinecartEntity.class)
|
|
public abstract class AbstractMinecartMixin extends Entity {
|
|
private static final double DEFAULT_SPEED = SpeedCarts.config.getDefaultSpeed();
|
|
private static final double MIN_SPEED = SpeedCarts.config.getMinimumSpeed();
|
|
private static final double MAX_SPEED = SpeedCarts.config.getMaximumSpeed();
|
|
private static final Pattern SIGN_PATTERN = Pattern.compile(SpeedCarts.config.getSignRegex());
|
|
|
|
/**
|
|
* Time in game ticks, to wait before attempting to update the cart's speed
|
|
* from the same position, after that block/sign has already updated the
|
|
* cart's speed just before.
|
|
*/
|
|
private static final long SPEED_UPDATE_COOLDOWN = 20 * 3;
|
|
|
|
/**
|
|
* The currently-set maximum speed, in blocks per second.
|
|
*/
|
|
private double maxSpeedBps = DEFAULT_SPEED;
|
|
|
|
/**
|
|
* The last time (in game ticks) that the speed was updated.
|
|
*/
|
|
private long lastSpeedUpdate = 0;
|
|
|
|
/**
|
|
* The position of the block which was last responsible for updating the
|
|
* cart's speed.
|
|
*/
|
|
private BlockPos lastUpdatedFrom = null;
|
|
|
|
@Shadow
|
|
public abstract Vec3d snapPositionToRail(double x, double y, double z);
|
|
|
|
@Shadow
|
|
private static Pair<Vec3i, Vec3i> getAdjacentRailPositionsByShape(RailShape shape) {
|
|
return null;
|
|
}
|
|
|
|
@Shadow
|
|
protected abstract double getMaxSpeed();
|
|
|
|
@Inject(at = @At("HEAD"), method = "getMaxSpeed", cancellable = true)
|
|
public void getMaxOffRailSpeedOverwrite(CallbackInfoReturnable<Double> cir) {
|
|
cir.setReturnValue(this.maxSpeedBps / 20.0);
|
|
}
|
|
|
|
@Shadow
|
|
protected abstract void applySlowdown();
|
|
|
|
@Shadow
|
|
protected abstract boolean willHitBlockAt(BlockPos pos);
|
|
|
|
public AbstractMinecartMixin(EntityType<?> type, World world) {
|
|
super(type, world);
|
|
}
|
|
|
|
@Shadow
|
|
protected abstract void moveOnRail(BlockPos pos, BlockState state);
|
|
|
|
@Shadow public abstract Direction getMovementDirection();
|
|
|
|
@Inject(at = @At("HEAD"), method = "moveOnRail", cancellable = true)
|
|
public void moveOnRailOverwrite(BlockPos pos, BlockState state, CallbackInfo ci) {
|
|
this.updateForSpeedModifiers(pos);
|
|
this.modifiedMoveOnRail(pos, state);
|
|
ci.cancel();
|
|
}
|
|
|
|
/**
|
|
* Checks for any speed modifiers (signs, blocks, etc.) and attempts to
|
|
* apply their effects to the cart. It does this by iterating over a list of
|
|
* possible positions for blocks which are considered speed modifiers, and
|
|
* then if a valid speed modifier is found, the cart's speed is updated.
|
|
* @param pos The cart's current position.
|
|
*/
|
|
private void updateForSpeedModifiers(BlockPos pos) {
|
|
// Quit if the cart is not moving, and set its speed to default.
|
|
if (this.getVelocity().length() == 0) {
|
|
this.maxSpeedBps = DEFAULT_SPEED;
|
|
return;
|
|
}
|
|
|
|
for (BlockPos position : this.getPositionsToCheck(pos)) {
|
|
BlockEntity blockEntity = this.world.getBlockEntity(position);
|
|
if (blockEntity instanceof SignBlockEntity sign) {
|
|
if (!sign.getPos().equals(this.lastUpdatedFrom) || this.world.getTime() > this.lastSpeedUpdate + SPEED_UPDATE_COOLDOWN) {
|
|
BlockState state = this.world.getBlockState(position);
|
|
Direction dir = (Direction) state.getEntries().get(Properties.HORIZONTAL_FACING);
|
|
// Only allow free-standing signs or those facing the cart.
|
|
if (dir == null || dir.equals(this.getMovementDirection().getOpposite())) {
|
|
if (this.updateSpeedForSign(sign)) return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Attempts to update the cart's speed according to a sign.
|
|
* @param sign The sign that contains speed information.
|
|
* @return True if the cart's speed was updated, or false otherwise.
|
|
*/
|
|
private boolean updateSpeedForSign(SignBlockEntity sign) {
|
|
Text text = sign.getTextOnRow(0, false);
|
|
String s = text.getString();
|
|
if (!SIGN_PATTERN.matcher(s).matches()) {
|
|
return false;
|
|
}
|
|
try {
|
|
double speed = Double.parseDouble(s);
|
|
if (speed >= MIN_SPEED && speed <= MAX_SPEED) {
|
|
this.maxSpeedBps = speed;
|
|
this.lastSpeedUpdate = this.world.getTime();
|
|
this.lastUpdatedFrom = sign.getPos();
|
|
if (this.hasPlayerRider()) {
|
|
PlayerEntity player = (PlayerEntity) this.getFirstPassenger();
|
|
if (player != null) {
|
|
player.playSound(SoundEvents.BLOCK_NOTE_BLOCK_BELL, SoundCategory.PLAYERS, 1.0f, 1.0f);
|
|
}
|
|
}
|
|
return true;
|
|
} else {
|
|
sign.setTextOnRow(0, Text.of("Invalid speed!"));
|
|
sign.setTextOnRow(1, Text.of("Min: " + MIN_SPEED));
|
|
sign.setTextOnRow(2, Text.of("Max: " + MAX_SPEED));
|
|
sign.setGlowingText(true);
|
|
sign.setTextColor(DyeColor.RED);
|
|
}
|
|
} catch (NumberFormatException e) {
|
|
// Do nothing if no value could be parsed.
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Gathers a list of all block positions to check for signs that may affect
|
|
* the cart's speed.
|
|
* @param pos The cart's block position.
|
|
* @return A collection of positions to check.
|
|
*/
|
|
private Collection<BlockPos> getPositionsToCheck(BlockPos pos) {
|
|
// Compute the number of blocks we have to check ahead.
|
|
// This accounts for speeds greater than 1 block per tick.
|
|
int blockRange = Math.max(1, (int) Math.ceil(this.maxSpeedBps / 20));
|
|
List<BlockPos> positionsToCheck = new ArrayList<>(6 * blockRange);
|
|
for (int i = 0; i < blockRange; i++) {
|
|
positionsToCheck.add(pos.north());
|
|
positionsToCheck.add(pos.south());
|
|
positionsToCheck.add(pos.east());
|
|
positionsToCheck.add(pos.west());
|
|
positionsToCheck.add(pos.up());
|
|
positionsToCheck.add(pos.down());
|
|
pos = pos.add(this.getMovementDirection().getVector());
|
|
}
|
|
return positionsToCheck;
|
|
}
|
|
|
|
/**
|
|
* Modified version of {@link AbstractMinecartMixin#moveOnRail(BlockPos, BlockState)}
|
|
* that allows the minecart to maintain speeds above 32 m/s.
|
|
* @param pos The block position of the cart.
|
|
* @param state The state of the block the cart is in.
|
|
*/
|
|
private void modifiedMoveOnRail(BlockPos pos, BlockState state) {
|
|
this.fallDistance = 0.0F;
|
|
double d = this.getX();
|
|
double e = this.getY();
|
|
double f = this.getZ();
|
|
Vec3d vec3d = this.snapPositionToRail(d, e, f);
|
|
e = pos.getY();
|
|
boolean onPoweredRail = false;
|
|
boolean onNormalRail = false;
|
|
if (state.isOf(Blocks.POWERED_RAIL)) {
|
|
onPoweredRail = state.get(PoweredRailBlock.POWERED);
|
|
onNormalRail = !onPoweredRail;
|
|
}
|
|
|
|
double g = 0.0078125D;
|
|
if (this.isTouchingWater()) {
|
|
g *= 0.2D;
|
|
}
|
|
|
|
Vec3d velocity = this.getVelocity();
|
|
RailShape railShape = state.get(((AbstractRailBlock)state.getBlock()).getShapeProperty());
|
|
switch (railShape) {
|
|
case ASCENDING_EAST -> {
|
|
this.setVelocity(velocity.add(-g, 0.0D, 0.0D));
|
|
++e;
|
|
}
|
|
case ASCENDING_WEST -> {
|
|
this.setVelocity(velocity.add(g, 0.0D, 0.0D));
|
|
++e;
|
|
}
|
|
case ASCENDING_NORTH -> {
|
|
this.setVelocity(velocity.add(0.0D, 0.0D, g));
|
|
++e;
|
|
}
|
|
case ASCENDING_SOUTH -> {
|
|
this.setVelocity(velocity.add(0.0D, 0.0D, -g));
|
|
++e;
|
|
}
|
|
}
|
|
|
|
velocity = this.getVelocity();
|
|
Pair<Vec3i, Vec3i> adjacentRailPositions = getAdjacentRailPositionsByShape(railShape);
|
|
Vec3i vec3i = adjacentRailPositions.getFirst();
|
|
Vec3i vec3i2 = adjacentRailPositions.getSecond();
|
|
double h = vec3i2.getX() - vec3i.getX();
|
|
double i = vec3i2.getZ() - vec3i.getZ();
|
|
double j = Math.sqrt(h * h + i * i);
|
|
double k = velocity.x * h + velocity.z * i;
|
|
if (k < 0.0D) {
|
|
h = -h;
|
|
i = -i;
|
|
}
|
|
|
|
double l = Math.min(2.0D, velocity.horizontalLength());
|
|
// Only consider using Minecraft's default velocity damper logic when going at 'normal' speeds.
|
|
if (this.maxSpeedBps <= DEFAULT_SPEED) {
|
|
this.setVelocity(new Vec3d(l * h / j, velocity.y, l * i / j));
|
|
} else { // Otherwise, simply clamp to the computed max speed in blocks per tick.
|
|
double speed = this.maxSpeedBps / 20.0;
|
|
this.setVelocity(new Vec3d(
|
|
Math.max(Math.min(speed, velocity.x), -speed),
|
|
velocity.y,
|
|
Math.max(Math.min(speed, velocity.z), -speed)
|
|
));
|
|
}
|
|
|
|
Entity entity = this.getFirstPassenger();
|
|
if (entity instanceof PlayerEntity) {
|
|
Vec3d playerVelocity = entity.getVelocity();
|
|
double m = playerVelocity.horizontalLengthSquared();
|
|
double n = this.getVelocity().horizontalLengthSquared();
|
|
if (m > 1.0E-4D && n < 0.01D) {
|
|
this.setVelocity(this.getVelocity().add(playerVelocity.x * 0.1D, 0.0D, playerVelocity.z * 0.1D));
|
|
onNormalRail = false;
|
|
}
|
|
}
|
|
|
|
double p;
|
|
if (onNormalRail) {
|
|
p = this.getVelocity().horizontalLength();
|
|
if (p < 0.03D) {
|
|
this.setVelocity(Vec3d.ZERO);
|
|
} else {
|
|
this.setVelocity(this.getVelocity().multiply(0.5D, 0.0D, 0.5D));
|
|
}
|
|
}
|
|
|
|
p = (double)pos.getX() + 0.5D + (double)vec3i.getX() * 0.5D;
|
|
double q = (double)pos.getZ() + 0.5D + (double)vec3i.getZ() * 0.5D;
|
|
double r = (double)pos.getX() + 0.5D + (double)vec3i2.getX() * 0.5D;
|
|
double s = (double)pos.getZ() + 0.5D + (double)vec3i2.getZ() * 0.5D;
|
|
h = r - p;
|
|
i = s - q;
|
|
double x;
|
|
double v;
|
|
double w;
|
|
if (h == 0.0D) {
|
|
x = f - (double)pos.getZ();
|
|
} else if (i == 0.0D) {
|
|
x = d - (double)pos.getX();
|
|
} else {
|
|
v = d - p;
|
|
w = f - q;
|
|
x = (v * h + w * i) * 2.0D;
|
|
}
|
|
|
|
d = p + h * x;
|
|
f = q + i * x;
|
|
this.setPosition(d, e, f);
|
|
v = this.hasPassengers() ? 0.75D : 1.0D;
|
|
w = this.getMaxSpeed();
|
|
velocity = this.getVelocity();
|
|
Vec3d movement = new Vec3d(MathHelper.clamp(v * velocity.x, -w, w), 0.0D, MathHelper.clamp(v * velocity.z, -w, w));
|
|
this.move(MovementType.SELF, movement);
|
|
if (vec3i.getY() != 0 && MathHelper.floor(this.getX()) - pos.getX() == vec3i.getX() && MathHelper.floor(this.getZ()) - pos.getZ() == vec3i.getZ()) {
|
|
this.setPosition(this.getX(), this.getY() + (double)vec3i.getY(), this.getZ());
|
|
} else if (vec3i2.getY() != 0 && MathHelper.floor(this.getX()) - pos.getX() == vec3i2.getX() && MathHelper.floor(this.getZ()) - pos.getZ() == vec3i2.getZ()) {
|
|
this.setPosition(this.getX(), this.getY() + (double)vec3i2.getY(), this.getZ());
|
|
}
|
|
|
|
this.applySlowdown();
|
|
Vec3d vec3d4 = this.snapPositionToRail(this.getX(), this.getY(), this.getZ());
|
|
Vec3d vec3d7;
|
|
double af;
|
|
if (vec3d4 != null && vec3d != null) {
|
|
double aa = (vec3d.y - vec3d4.y) * 0.05D;
|
|
vec3d7 = this.getVelocity();
|
|
af = vec3d7.horizontalLength();
|
|
if (af > 0.0D) {
|
|
this.setVelocity(vec3d7.multiply((af + aa) / af, 1.0D, (af + aa) / af));
|
|
}
|
|
|
|
this.setPosition(this.getX(), vec3d4.y, this.getZ());
|
|
}
|
|
|
|
int ac = MathHelper.floor(this.getX());
|
|
int ad = MathHelper.floor(this.getZ());
|
|
if (ac != pos.getX() || ad != pos.getZ()) {
|
|
vec3d7 = this.getVelocity();
|
|
af = vec3d7.horizontalLength();
|
|
this.setVelocity(af * (double)(ac - pos.getX()), vec3d7.y, af * (double)(ad - pos.getZ()));
|
|
}
|
|
|
|
if (onPoweredRail) {
|
|
vec3d7 = this.getVelocity();
|
|
af = vec3d7.horizontalLength();
|
|
if (af > 0.01D) {
|
|
this.setVelocity(vec3d7.add(vec3d7.x / af * 0.06D, 0.0D, vec3d7.z / af * 0.06D));
|
|
} else {
|
|
Vec3d vec3d8 = this.getVelocity();
|
|
double ah = vec3d8.x;
|
|
double ai = vec3d8.z;
|
|
if (railShape == RailShape.EAST_WEST) {
|
|
if (this.willHitBlockAt(pos.west())) {
|
|
ah = 0.02D;
|
|
} else if (this.willHitBlockAt(pos.east())) {
|
|
ah = -0.02D;
|
|
}
|
|
} else {
|
|
if (railShape != RailShape.NORTH_SOUTH) {
|
|
return;
|
|
}
|
|
|
|
if (this.willHitBlockAt(pos.north())) {
|
|
ai = 0.02D;
|
|
} else if (this.willHitBlockAt(pos.south())) {
|
|
ai = -0.02D;
|
|
}
|
|
}
|
|
|
|
this.setVelocity(ah, vec3d8.y, ai);
|
|
}
|
|
}
|
|
}
|
|
}
|