Repo-Mirror/SakuraMC
9
0
Fork 0
mirror of https://github.com/Samsuik/Sakura.git synced 2025-12-21 15:59:26 +00:00
Code Issues Releases Activity
Files
9ec82c34eaea892325c6ec9fceeb89797bdebff7
SakuraMC/patches/server/0016-Merge-Cannon-Entities.patch
Samsuik 9ec82c34ea Begin backporting to 1.18.2
2025-03-14 18:45:24 +00:00

640 lines
26 KiB
Diff
Raw Blame History

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Samsuik <40902469+Samsuik@users.noreply.github.com>
Date: Sat, 9 Sep 2023 18:39:15 +0100
Subject: [PATCH] Merge Cannon Entities
diff --git a/src/main/java/me/samsuik/sakura/entity/merge/MergeHistory.java b/src/main/java/me/samsuik/sakura/entity/merge/MergeHistory.java
new file mode 100644
index 0000000000000000000000000000000000000000..7d899163b308f52b48bf72a1e9cd38d565bbe05d
--- /dev/null
+++ b/src/main/java/me/samsuik/sakura/entity/merge/MergeHistory.java
@@ -0,0 +1,56 @@
+package me.samsuik.sakura.entity.merge;
+
+import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
+import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
+import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.entity.Entity;
+
+import java.util.List;
+
+public final class MergeHistory {
+
+ // packed position -> known merging information
+ private final Long2ObjectMap<SpawnPositionData> mergeDataMap = new Long2ObjectOpenHashMap<>();
+ private SpawnPositionData mergeData = null;
+
+ public SpawnPositionData retrievePositions(Entity entity) {
+ long origin = entity.getPackedOrigin();
+
+ if (mergeData != null && mergeData.isPositionKnown(origin)) {
+ return mergeData;
+ }
+
+ return mergeData = mergeDataMap.get(origin);
+ }
+
+ public void markPositions(Entity entity) {
+ List<Entity> mergeList = entity.getMergeList();
+ long origin = entity.getPackedOrigin();
+
+ // After a merged entity has been discarded store all the position data
+ SpawnPositionData data = mergeDataMap.computeIfAbsent(origin, p -> new SpawnPositionData(mergeList));
+ data.getExpiry().refresh(MinecraftServer.currentTickLong);
+
+ // Collect all merge positions
+ LongOpenHashSet positions = new LongOpenHashSet((mergeList.size() + 1) / 2);
+ positions.add(entity.getPackedOrigin());
+
+ for (Entity mergedEntity : mergeList) {
+ positions.add(mergedEntity.getPackedOrigin());
+ }
+
+ // Retain existing positions or insert new positions
+ data.retainOrInsertPositions(positions);
+ }
+
+ public void expire(long tick) {
+ mergeData = null; // clear this every tick
+
+ // only expire every 20 ticks
+ if (tick % 20 != 0) return;
+
+ mergeDataMap.values().removeIf(data -> data.getExpiry().isExpired(tick));
+ }
+
+}
diff --git a/src/main/java/me/samsuik/sakura/entity/merge/MergeThreshold.java b/src/main/java/me/samsuik/sakura/entity/merge/MergeThreshold.java
new file mode 100644
index 0000000000000000000000000000000000000000..4d08af1a7ff0ebc2b1198513c86c08087d9d6e89
--- /dev/null
+++ b/src/main/java/me/samsuik/sakura/entity/merge/MergeThreshold.java
@@ -0,0 +1,26 @@
+package me.samsuik.sakura.entity.merge;
+
+/**
+ * Threshold for AOT/on spawn merging.
+ * <p>
+ * This is determined by the amount of spawn attempts over time.
+ */
+public final class MergeThreshold {
+
+ private final long startingTick;
+ private final int thresholdAttempts;
+ private final long thresholdAge;
+ private int attempts;
+
+ public MergeThreshold(long tick, int attempts, long age) {
+ startingTick = tick;
+ thresholdAttempts = attempts;
+ thresholdAge = age;
+ }
+
+ public boolean hasPassed(long tick) {
+ return ++attempts >= thresholdAttempts
+ || tick - startingTick >= thresholdAge;
+ }
+
+}
diff --git a/src/main/java/me/samsuik/sakura/entity/merge/SpawnPositionData.java b/src/main/java/me/samsuik/sakura/entity/merge/SpawnPositionData.java
new file mode 100644
index 0000000000000000000000000000000000000000..e63935c17e213bf60571d120ad9ce311b5249d45
--- /dev/null
+++ b/src/main/java/me/samsuik/sakura/entity/merge/SpawnPositionData.java
@@ -0,0 +1,64 @@
+package me.samsuik.sakura.entity.merge;
+
+import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
+import it.unimi.dsi.fastutil.longs.LongSet;
+import me.samsuik.sakura.utils.collections.EntityTable;
+import me.samsuik.sakura.utils.objects.Expiry;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.entity.Entity;
+
+import java.util.List;
+
+/**
+ * Contains all the positions that past entities of the same origin have merged with.
+ */
+public final class SpawnPositionData {
+
+ private final LongSet knownPositions = new LongOpenHashSet();
+ private final LongSet retainedPositions = new LongOpenHashSet();
+
+ private final EntityTable table;
+ private final Expiry expiry = new Expiry(MinecraftServer.currentTickLong, 200);
+ private final MergeThreshold threshold = new MergeThreshold(MinecraftServer.currentTickLong, 12, 200);
+
+ public SpawnPositionData(List<Entity> mergeList) {
+ this.table = new EntityTable(mergeList.size());
+ }
+
+ public Expiry getExpiry() {
+ return expiry;
+ }
+
+ public void retainOrInsertPositions(LongOpenHashSet positions) {
+ if (!knownPositions.isEmpty()) {
+ retainedPositions.addAll(positions);
+ } else {
+ retainedPositions.retainAll(positions);
+ }
+
+ knownPositions.addAll(positions);
+ }
+
+ public boolean isPositionKnown(long pos) {
+ return knownPositions.contains(pos);
+ }
+
+ public boolean isPositionRetained(long pos) {
+ return retainedPositions.contains(pos);
+ }
+
+ public boolean isAbleToOnSpawnMerge() {
+ return threshold.hasPassed(MinecraftServer.currentTickLong);
+ }
+
+ public Entity findFirstEntityInSamePosition(Entity entity) {
+ Entity found = table.locate(entity);
+
+ if (found != null && found.getId() < entity.getId() && knownPositions.contains(found.getPackedOrigin()) && !found.isRemoved() && entity.compareState(found)) {
+ return found;
+ }
+
+ return null;
+ }
+
+}
diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
index 7908e2f0aef64241db1a030f8ed4dbc85930fee9..536dd6fd0317779e04f133d2ae32a251da9e4394 100644
--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
@@ -1620,6 +1620,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
worldserver.explosionDensityCache.clear(); // Paper - Optimize explosions
worldserver.localConfig().expire(currentTickLong); // Sakura
worldserver.minimalTNT.clear(); // Sakura - visibility api
+ worldserver.mergeHistory.expire(currentTickLong); // Sakura - merge cannoning entities
}
this.isIteratingOverLevels = false; // Paper
diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
index 6794accac49b876ef8e7563a11b254178aa0e3cc..451f7facb950c98b67713d6e7d012bf25bb89e31 100644
--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
@@ -651,6 +651,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
org.spigotmc.ActivationRange.activateEntities(this); // Spigot
timings.entityTick.startTiming(); // Spigot
+ Entity[] previousEntity = new Entity[1]; // Sakura
this.entityTickList.forEach((entity) -> {
if (!entity.isRemoved()) {
if (false && this.shouldDiscardEntity(entity)) { // CraftBukkit - We prevent spawning in general, so this butchering is not needed
@@ -670,6 +671,15 @@ public class ServerLevel extends Level implements WorldGenLevel {
entity.stopRiding();
}
+ // Sakura start
+ Entity previous = previousEntity[0];
+ if (entity.isMergeableType(previous) && entity.tryMergeInto(previous)) {
+ return;
+ } else {
+ previousEntity[0] = entity;
+ }
+ // Sakura end
+
gameprofilerfiller.push("tick");
this.guardEntityTick(this::tickNonPassenger, entity);
gameprofilerfiller.pop();
diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
index 7e1868bb483adefdab085f753acd71c65cb9c8c5..ff25112e1a270f32faf8b0a885166dc57848b5cf 100644
--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
@@ -452,6 +452,121 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
return to.entityState() != null && to.entityState().isCurrentState(this);
}
// Sakura end - store entity data/state
+ // Sakura start - cannon entity merging
+ // List of merged entities, should be naturally sorted (oldest -> youngest)
+ private final List<Entity> mergeList = new java.util.ArrayList<>(1);
+ private @Nullable me.samsuik.sakura.entity.merge.SpawnPositionData originData = null;
+ private me.samsuik.sakura.entity.merge.MergeLevel mergeLevel;
+ protected int stacked = 1; // default
+
+ public final me.samsuik.sakura.entity.merge.MergeLevel getMergeLevel() {
+ return this.mergeLevel;
+ }
+
+ public final void setMergeLevel(me.samsuik.sakura.entity.merge.MergeLevel level) {
+ this.mergeLevel = level;
+ }
+
+ public final int getStacked() {
+ return this.stacked;
+ }
+
+ public final void setStacked(int stack) {
+ this.stacked = stack;
+ }
+
+ public final List<Entity> getMergeList() {
+ return this.mergeList;
+ }
+
+ public final long getPackedOrigin() {
+ org.bukkit.util.Vector v = this.getOriginVector();
+ if (v == null) return Long.MIN_VALUE;
+ return BlockPos.asLong(v.getBlockX(), v.getBlockY(), v.getBlockZ());
+ }
+
+ private boolean isSafeToSpawnMerge(Entity entity) {
+ return this.tickCount == 1 && this.originData != null
+ && this.originData.isAbleToOnSpawnMerge() // on spawn safety delay has passed
+ && this.originData == entity.originData // make sure it's the same group
+ && this.originData.isPositionRetained(entity.getPackedOrigin());
+ }
+
+ public boolean isMergeableType(@Nullable Entity previous) {
+ return false;
+ }
+
+ public final boolean tryMergeInto(@Nullable Entity entity) {
+ if (this.mergeLevel.atLeast(me.samsuik.sakura.entity.merge.MergeLevel.LENIENT) && this.tickCount == 0) {
+ this.originData = this.level.mergeHistory.retrievePositions(this);
+ }
+
+ Entity mergeEntity = null;
+
+ if (entity == null || entity.getType() != getType()) {
+ return false; // First entity
+ } else if (this.mergeLevel.atLeast(me.samsuik.sakura.entity.merge.MergeLevel.SPAWN) && entity.isSafeToSpawnMerge(this)) {
+ // "SPAWN" merges entities one gametick after they have spawned. Merging is
+ // only possible after it has been established that the entity is safe to
+ // merge by collecting information on the entities that merge together over time.
+ mergeEntity = entity;
+ } else {
+ // "STRICT" merges entities with the same properties, position, momentum and OOE.
+ // This is considered safe to use, and will not break cannon mechanics.
+ if (this.mergeLevel.atLeast(me.samsuik.sakura.entity.merge.MergeLevel.STRICT) && this.compareState(entity)) {
+ mergeEntity = entity;
+ }
+
+ // "LENIENT" merges entities aggressively by tracking the entities that have
+ // previously merged. This is a hybrid of "SPAWN" and "STRICT" merging, with the
+ // visuals of "STRICT" merging and better merging potential of "SPAWN" merging.
+ if (this.mergeLevel.atLeast(me.samsuik.sakura.entity.merge.MergeLevel.LENIENT) && mergeEntity == null && this.originData != null) {
+ mergeEntity = this.originData.findFirstEntityInSamePosition(this);
+ }
+ }
+
+ if (mergeEntity != null && this.isSafeToMergeInto(mergeEntity)) {
+ this.mergeInto(mergeEntity);
+ return true;
+ }
+
+ return false;
+ }
+
+ protected boolean respawnMerged() {
+ return false;
+ }
+
+ public boolean isSafeToMergeInto(Entity entity) {
+ return false;
+ }
+
+ private void mergeInto(Entity entity) {
+ entity.mergeList.add(this);
+ entity.mergeList.addAll(this.mergeList);
+ entity.stacked += this.stacked;
+
+ for (Entity mergedEntity : this.mergeList) {
+ mergedEntity.updateEntityHandle(entity);
+ }
+
+ this.mergeList.clear(); // clear the list to stop our tracking when merging
+ this.stacked = 0; // prevent any possible duplication
+
+ this.discard();
+ this.updateEntityHandle(entity);
+ }
+
+ public final void updateEntityHandle(Entity entity) {
+ // update api handle, this is so cannondebug can function
+ //noinspection ConstantValue
+ if (this.bukkitEntity != null) {
+ this.bukkitEntity.setHandle(entity);
+ } else {
+ this.bukkitEntity = entity.getBukkitEntity();
+ }
+ }
+ // Sakura end - cannon entity merging
// Paper start
/**
@@ -548,6 +663,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
this.getEntityData().registrationLocked = true; // Spigot
this.setPos(0.0D, 0.0D, 0.0D);
this.eyeHeight = this.getEyeHeight(net.minecraft.world.entity.Pose.STANDING, this.dimensions);
+ this.mergeLevel = this.level.sakuraConfig.mergeLevel; // Sakura
}
public boolean isColliding(BlockPos pos, BlockState state) {
@@ -2194,6 +2310,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
nbt.putBoolean("Paper.FreezeLock", true);
}
// Paper end
+ // Sakura start
+ if (stacked > 0) {
+ nbt.putInt("Sakura.Stacked", stacked);
+ }
+ // Sakura end
return nbt;
} catch (Throwable throwable) {
CrashReport crashreport = CrashReport.forThrowable(throwable, "Saving entity NBT");
@@ -2359,6 +2480,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
freezeLocked = nbt.getBoolean("Paper.FreezeLock");
}
// Paper end
+ // Sakura start
+ if (nbt.contains("Sakura.Stacked")) {
+ stacked = nbt.getInt("Sakura.Stacked");
+ }
+ // Sakura end
} catch (Throwable throwable) {
CrashReport crashreport = CrashReport.forThrowable(throwable, "Loading entity NBT");
@@ -4306,6 +4432,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
@Override
public final void setRemoved(Entity.RemovalReason reason) {
+ // Sakura start
+ if (reason == RemovalReason.DISCARDED && !mergeList.isEmpty()) {
+ level.mergeHistory.markPositions(this);
+ }
+ // Sakura end
if (this.removalReason == null) {
this.removalReason = reason;
}
diff --git a/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java b/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
index 39b27750df3c93c3b6481d1663b854750ee646db..229477058eb28798edf684dffe3640aab87bc189 100644
--- a/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
+++ b/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
@@ -127,6 +127,60 @@ public class FallingBlockEntity extends Entity {
return !this.isRemoved();
}
+ // Sakura start - cannon entity merging
+ @Override
+ public boolean isMergeableType(@Nullable Entity previous) {
+ return previous == null || !isRemoved() && !previous.isRemoved();
+ }
+
+ @Override
+ public boolean isSafeToMergeInto(Entity entity) {
+ return entity instanceof FallingBlockEntity fbe
+ && fbe.blockState.equals(blockState)
+ && fbe.time - 1 == time; // todo: special case in case on spawn isn't used
+ }
+
+ @Override
+ protected boolean respawnMerged() {
+ if (stacked <= 1) return false;
+
+ while (stacked-- >= 1) {
+ // Unlike PrimedTnt we have to try respawn each stacked entity
+ FallingBlockEntity fallingBlock = new FallingBlockEntity(EntityType.FALLING_BLOCK, this.level);
+
+ // Try to stack the falling block
+ this.entityState().apply(fallingBlock);
+ fallingBlock.blockState = blockState;
+ fallingBlock.spawnReason = spawnReason;
+ fallingBlock.time = time - 1;
+ fallingBlock.tick();
+
+ // If you horizontal stack into a moving piston block this condition will be met.
+ if (!fallingBlock.isRemoved()) {
+ stacked++;
+ fallingBlock.storeEntityState();
+ fallingBlock.entityState().apply(this);
+ break;
+ } else if (stacked == 0) {
+ this.discard();
+ }
+ }
+
+ return true;
+ }
+
+ @Nullable
+ public ItemEntity spawnAtLocation(ItemLike item) {
+ ItemEntity itemEntity = null;
+
+ while (stacked-- >= 1) {
+ itemEntity = super.spawnAtLocation(item);
+ }
+
+ return itemEntity;
+ }
+ // Sakura end
+
@Override
public void tick() {
// Paper start - fix sand duping
@@ -206,6 +260,7 @@ public class FallingBlockEntity extends Entity {
return;
}
// CraftBukkit end
+ if (this.respawnMerged()) return; // Sakura
if (this.level.setBlock(blockposition, this.blockState, 3)) {
((ServerLevel) this.level).getChunkSource().chunkMap.broadcast(this, new ClientboundBlockUpdatePacket(blockposition, this.level.getBlockState(blockposition)));
this.discard();
diff --git a/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java b/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java
index 6a97e77b81359a6722293837088c01b6618a0976..0c75fe840119040898a10a931dcb9b3e51c8cdcf 100644
--- a/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java
+++ b/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java
@@ -62,6 +62,44 @@ public class PrimedTnt extends Entity {
return !this.isRemoved();
}
+ // Sakura start - cannon entity merging
+ @Override
+ public boolean isMergeableType(@Nullable Entity previous) {
+ return previous == null || !isRemoved() && !previous.isRemoved();
+ }
+
+ @Override
+ public boolean isSafeToMergeInto(Entity entity) {
+ return entity instanceof PrimedTnt tnt
+ && tnt.getFuse() + 1 == getFuse()
+ // required to prevent issues with powdered snow
+ && (tnt.entityState().fallDistance() == fallDistance
+ || tnt.entityState().fallDistance() > 2.5f && fallDistance > 2.5f);
+ }
+
+ @Override
+ protected boolean respawnMerged() {
+ if (stacked <= 1) return false;
+
+ PrimedTnt tnt = new PrimedTnt(EntityType.TNT, this.level);
+
+ while (stacked-- > 1) {
+ this.setFuse(100); // Prevent unwanted explosions while ticking
+
+ // Cause an explosion to affect this entity
+ tnt.setPos(this.position());
+ tnt.setDeltaMovement(this.getDeltaMovement());
+ this.entityState().apply(this);
+ tnt.explode();
+ this.storeEntityState();
+
+ this.tick();
+ }
+
+ return true;
+ }
+ // Sakura end
+
@Override
public void tick() {
if (level.spigotConfig.maxTntTicksPerTick > 0 && ++level.spigotConfig.currentPrimedTnt > level.spigotConfig.maxTntTicksPerTick) {
@@ -89,6 +127,7 @@ public class PrimedTnt extends Entity {
if (i <= 0) {
// CraftBukkit start - Need to reverse the order of the explosion and the entity death so we have a location for the event
// this.discard();
+ this.respawnMerged(); // Sakura
if (!this.level.isClientSide) {
this.explode();
}
diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
index ff6c4664c22aca6a7be44e3ccb7bff543c6a2a1b..894d920305302127b5cf9ee2bfba239475e76144 100644
--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
@@ -266,6 +266,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
}
// Sakura end
public final it.unimi.dsi.fastutil.longs.Long2IntMap minimalTNT = new it.unimi.dsi.fastutil.longs.Long2IntOpenHashMap(); // Sakura - visibility api
+ public final me.samsuik.sakura.entity.merge.MergeHistory mergeHistory = new me.samsuik.sakura.entity.merge.MergeHistory(); // Sakura - cannon entity merging
public abstract ResourceKey<LevelStem> getTypeKey();
diff --git a/src/main/java/net/minecraft/world/level/block/BasePressurePlateBlock.java b/src/main/java/net/minecraft/world/level/block/BasePressurePlateBlock.java
index 9d1d59fe26eff0640906037aba93e73dda433d0d..f44d79ed9f3b93712ce8b40c020955d19ec8fb9d 100644
--- a/src/main/java/net/minecraft/world/level/block/BasePressurePlateBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/BasePressurePlateBlock.java
@@ -79,7 +79,7 @@ public abstract class BasePressurePlateBlock extends Block {
}
protected void checkPressed(@Nullable Entity entity, Level world, BlockPos pos, BlockState state, int output) {
- int j = this.getSignalStrength(world, pos);
+ int j = this.getSignalStrength(world, pos, output == 0); // Sakura - cannon entity merging
boolean flag = output > 0;
boolean flag1 = j > 0;
@@ -170,6 +170,12 @@ public abstract class BasePressurePlateBlock extends Block {
return PushReaction.DESTROY;
}
+ // Sakura start - cannon entity merging
+ protected int getSignalStrength(Level world, BlockPos pos, boolean entityInside) {
+ return this.getSignalStrength(world, pos);
+ }
+ // Sakura end - cannon entity merging
+
protected abstract int getSignalStrength(Level world, BlockPos pos);
protected abstract int getSignalForState(BlockState state);
diff --git a/src/main/java/net/minecraft/world/level/block/WeightedPressurePlateBlock.java b/src/main/java/net/minecraft/world/level/block/WeightedPressurePlateBlock.java
index fe343966b9e30ff3487579b46d4b005be3d76b63..6bac29219028a91fa49a79b9bb5513b50d896770 100644
--- a/src/main/java/net/minecraft/world/level/block/WeightedPressurePlateBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/WeightedPressurePlateBlock.java
@@ -28,6 +28,11 @@ public class WeightedPressurePlateBlock extends BasePressurePlateBlock {
@Override
protected int getSignalStrength(Level world, BlockPos pos) {
+ // Sakura start - cannon entity merging
+ return this.getSignalStrength(world, pos, false);
+ }
+ protected final int getSignalStrength(Level world, BlockPos pos, boolean entityInside) {
+ // Sakura end - cannon entity merging
// CraftBukkit start
// int i = Math.min(world.getEntitiesOfClass(Entity.class, BlockPressurePlateWeighted.TOUCH_AABB.move(blockposition)).size(), this.maxWeight);
int i = 0;
@@ -47,7 +52,7 @@ public class WeightedPressurePlateBlock extends BasePressurePlateBlock {
// We only want to block turning the plate on if all events are cancelled
if (!cancellable.isCancelled()) {
- i++;
+ i += !entityInside ? entity.getStacked() : 1; // Sakura - cannon entity merging
}
}
diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftFallingBlock.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftFallingBlock.java
index 87c413c2f3b59ae9ef36e5becc10b29a81348022..65bac64214112ebd9e067202fe13293abe10559d 100644
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftFallingBlock.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftFallingBlock.java
@@ -14,6 +14,28 @@ public class CraftFallingBlock extends CraftEntity implements FallingBlock {
super(server, entity);
}
+ // Sakura start
+ @Override
+ public @org.jetbrains.annotations.NotNull me.samsuik.sakura.entity.merge.MergeLevel getMergeLevel() {
+ return getHandle().getMergeLevel();
+ }
+
+ @Override
+ public void setMergeLevel(@org.jetbrains.annotations.NotNull me.samsuik.sakura.entity.merge.MergeLevel level) {
+ getHandle().setMergeLevel(level);
+ }
+
+ @Override
+ public int getStacked() {
+ return getHandle().getStacked();
+ }
+
+ @Override
+ public void setStacked(int stacked) {
+ getHandle().setStacked(stacked);
+ }
+ // Sakura end
+
@Override
public FallingBlockEntity getHandle() {
return (FallingBlockEntity) entity;
diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftTNTPrimed.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftTNTPrimed.java
index 06540d3771949daff641e518219090559f363959..9b03ba0b3a7b491fafad5afae606cb6b8a6b53e6 100644
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftTNTPrimed.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftTNTPrimed.java
@@ -13,6 +13,28 @@ public class CraftTNTPrimed extends CraftEntity implements TNTPrimed {
super(server, entity);
}
+ // Sakura start
+ @Override
+ public @org.jetbrains.annotations.NotNull me.samsuik.sakura.entity.merge.MergeLevel getMergeLevel() {
+ return getHandle().getMergeLevel();
+ }
+
+ @Override
+ public void setMergeLevel(@org.jetbrains.annotations.NotNull me.samsuik.sakura.entity.merge.MergeLevel level) {
+ getHandle().setMergeLevel(level);
+ }
+
+ @Override
+ public int getStacked() {
+ return getHandle().getStacked();
+ }
+
+ @Override
+ public void setStacked(int stacked) {
+ getHandle().setStacked(stacked);
+ }
+ // Sakura end
+
@Override
public float getYield() {
return this.getHandle().yield;
Reference in New Issue View Git Blame Copy Permalink