GeyserMC-Mirror/Geyser
1
0
Fork 0
mirror of https://github.com/GeyserMC/Geyser.git synced 2026-01-06 15:41:50 +00:00
Code Issues Releases Activity

Avoid loop.

Browse Source
This commit is contained in:
oryxel1
2025-09-05 21:49:04 +07:00
parent ccc4faeb59
commit 141461b342
9 changed files with 65 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
core/src/main/java/org/geysermc/geyser/translator/collision/BlockCollision.java
View File

@@ -83,11 +83,16 @@ public class BlockCollision {
boundingBox.pushOutOfBoundingBox(playerCollision, Direction.UP, pushAwayTolerance);
boundingBox.pushOutOfBoundingBox(playerCollision, Direction.DOWN, pushAwayTolerance);
correctPosition(session, x, y, z, boundingBox, playerCollision);
// Revert back to the old collision size.
playerCollision.expand(-collisionExpansion, 0, -collisionExpansion);
}
}
protected void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox blockCollision, BoundingBox playerCollision) {
}
public boolean checkIntersection(double x, double y, double z, BoundingBox playerCollision) {
for (BoundingBox b : boundingBoxes) {
if (b.checkIntersection(x, y, z, playerCollision)) {

18
core/src/main/java/org/geysermc/geyser/translator/collision/fixes/BellCollision.java
View File

@@ -38,6 +38,8 @@ import org.geysermc.geyser.translator.collision.CollisionRemapper;
@EqualsAndHashCode(callSuper = true)
@CollisionRemapper(regex = "^bell$", passDefaultBoxes = true)
public class BellCollision extends BlockCollision {
private final static double MAX_PUSH_DISTANCE = 0.1875 + CollisionManager.COLLISION_TOLERANCE * 1.01;
private final boolean standing;
public BellCollision(BlockState state, BoundingBox[] boxes) {
@@ -47,24 +49,12 @@ public class BellCollision extends BlockCollision {
}
@Override
public void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox playerCollision) {
super.correctPosition(session, x, y, z, playerCollision);
protected void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox blockCollision, BoundingBox playerCollision) {
if (!this.standing) {
return;
}
final double maxPushDistance = 0.1875F + CollisionManager.COLLISION_TOLERANCE * 1.01F;
// Check for bell collision bug (bell on Java is 0.1875 block higher than Bedrock)
for (BoundingBox boundingBox : this.boundingBoxes) {
if (!boundingBox.checkIntersection(x, y, z, playerCollision)) {
continue;
}
boundingBox = boundingBox.clone();
boundingBox.translate(x, y, z);
boundingBox.pushOutOfBoundingBox(playerCollision, Direction.UP, maxPushDistance);
}
blockCollision.pushOutOfBoundingBox(playerCollision, Direction.UP, MAX_PUSH_DISTANCE);
}
}

19
core/src/main/java/org/geysermc/geyser/translator/collision/fixes/ConduitCollision.java
View File

@@ -37,26 +37,15 @@ import org.geysermc.geyser.translator.collision.CollisionRemapper;
@EqualsAndHashCode(callSuper = true)
@CollisionRemapper(regex = "^conduit$", passDefaultBoxes = true)
public class ConduitCollision extends BlockCollision {
private final static double MAX_PUSH_DISTANCE = 0.1875 + CollisionManager.COLLISION_TOLERANCE * 1.01;
public ConduitCollision(BlockState state, BoundingBox[] boxes) {
super(boxes);
}
@Override
public void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox playerCollision) {
super.correctPosition(session, x, y, z, playerCollision);
final double maxPushDistance = 0.1875F + CollisionManager.COLLISION_TOLERANCE * 1.01F;
protected void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox blockCollision, BoundingBox playerCollision) {
// Check for conduit bug (conduit is lifted from the ground on Java unlike Bedrock where conduit is placed on the ground)
for (BoundingBox boundingBox : this.boundingBoxes) {
if (!boundingBox.checkIntersection(x, y, z, playerCollision)) {
continue;
}
boundingBox = boundingBox.clone();
boundingBox.translate(x, y, z);
boundingBox.pushOutOfBoundingBox(playerCollision, Direction.UP, maxPushDistance);
}
blockCollision.pushOutOfBoundingBox(playerCollision, Direction.UP, MAX_PUSH_DISTANCE);
}
}

26
core/src/main/java/org/geysermc/geyser/translator/collision/fixes/DoorCollision.java
View File

@@ -38,6 +38,8 @@ import org.geysermc.geyser.translator.collision.CollisionRemapper;
@EqualsAndHashCode(callSuper = true)
@CollisionRemapper(regex = "_door$", usesParams = true, passDefaultBoxes = true)
public class DoorCollision extends BlockCollision {
private final static double MAX_PUSH_DISTANCE = 0.005 + CollisionManager.COLLISION_TOLERANCE * 1.01;
/**
* 1 = north
* 2 = east
@@ -63,25 +65,13 @@ public class DoorCollision extends BlockCollision {
}
@Override
public void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox playerCollision) {
super.correctPosition(session, x, y, z, playerCollision);
final double maxPushDistance = 0.005 + CollisionManager.COLLISION_TOLERANCE * 1.01F;
protected void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox blockCollision, BoundingBox playerCollision) {
// Check for door bug (doors are 0.1875 blocks thick on Java but 0.1825 blocks thick on Bedrock)
for (BoundingBox boundingBox : this.boundingBoxes) {
if (!boundingBox.checkIntersection(x, y, z, playerCollision)) {
continue;
}
boundingBox = boundingBox.clone();
boundingBox.translate(x, y, z);
switch (this.facing) {
case 1 -> boundingBox.pushOutOfBoundingBox(playerCollision, Direction.NORTH, maxPushDistance);
case 2 -> boundingBox.pushOutOfBoundingBox(playerCollision, Direction.EAST, maxPushDistance);
case 3 -> boundingBox.pushOutOfBoundingBox(playerCollision, Direction.SOUTH, maxPushDistance);
case 4 -> boundingBox.pushOutOfBoundingBox(playerCollision, Direction.WEST, maxPushDistance);
}
switch (this.facing) {
case 1 -> blockCollision.pushOutOfBoundingBox(playerCollision, Direction.NORTH, MAX_PUSH_DISTANCE);
case 2 -> blockCollision.pushOutOfBoundingBox(playerCollision, Direction.EAST, MAX_PUSH_DISTANCE);
case 3 -> blockCollision.pushOutOfBoundingBox(playerCollision, Direction.SOUTH, MAX_PUSH_DISTANCE);
case 4 -> blockCollision.pushOutOfBoundingBox(playerCollision, Direction.WEST, MAX_PUSH_DISTANCE);
}
}
}

18
core/src/main/java/org/geysermc/geyser/translator/collision/fixes/EndPortalCollision.java
View File

@@ -38,6 +38,8 @@ import org.geysermc.geyser.translator.collision.CollisionRemapper;
@EqualsAndHashCode(callSuper = true)
@CollisionRemapper(regex = "^end_portal_frame$", passDefaultBoxes = true)
public class EndPortalCollision extends BlockCollision {
private final static double MAX_PUSH_DISTANCE = 0.1875 + CollisionManager.COLLISION_TOLERANCE * 1.01;
private final boolean eye;
public EndPortalCollision(BlockState state, BoundingBox[] boxes) {
@@ -47,24 +49,12 @@ public class EndPortalCollision extends BlockCollision {
}
@Override
public void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox playerCollision) {
super.correctPosition(session, x, y, z, playerCollision);
protected void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox blockCollision, BoundingBox playerCollision) {
if (!this.eye) {
return;
}
final double maxPushDistance = 0.1875F + CollisionManager.COLLISION_TOLERANCE * 1.01F;
// Check for end portal frame bug (BE don't have the eye collision when the end portal frame contain an eye unlike JE)
for (BoundingBox boundingBox : this.boundingBoxes) {
if (!boundingBox.checkIntersection(x, y, z, playerCollision)) {
continue;
}
boundingBox = boundingBox.clone();
boundingBox.translate(x, y, z);
boundingBox.pushOutOfBoundingBox(playerCollision, Direction.UP, maxPushDistance);
}
blockCollision.pushOutOfBoundingBox(playerCollision, Direction.UP, MAX_PUSH_DISTANCE);
}
}

41
core/src/main/java/org/geysermc/geyser/translator/collision/fixes/GlassPaneAndIronBarsCollision.java
View File

@@ -38,6 +38,8 @@ import org.geysermc.geyser.translator.collision.CollisionRemapper;
@EqualsAndHashCode(callSuper = true)
@CollisionRemapper(regex = "glass_pane$|iron_bars$", usesParams = true, passDefaultBoxes = true)
public class GlassPaneAndIronBarsCollision extends BlockCollision {
private final static double MAX_PUSH_DISTANCE = 0.0625 + CollisionManager.COLLISION_TOLERANCE * 1.01;
/**
* 1 = north
* 2 = east
@@ -72,36 +74,23 @@ public class GlassPaneAndIronBarsCollision extends BlockCollision {
}
@Override
public void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox playerCollision) {
super.correctPosition(session, x, y, z, playerCollision);
final double maxPushDistance = 0.0625 + CollisionManager.COLLISION_TOLERANCE * 1.01F;
protected void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox blockCollision, BoundingBox playerCollision) {
// Check for glass pane/iron bars bug (pane/iron bars is 0.5 blocks thick on Bedrock but 0.5625 on Java when only 1 side is connected).
for (BoundingBox boundingBox : this.boundingBoxes) {
if (!boundingBox.checkIntersection(x, y, z, playerCollision)) {
continue;
}
// Also, we want to flip the direction since the direction here is indicating the block side the glass is connected to.
if (this.facing == 2 || this.facing == 6 || this.facing == 5) { // East
blockCollision.pushOutOfBoundingBox(playerCollision, Direction.WEST, MAX_PUSH_DISTANCE);
}
boundingBox = boundingBox.clone();
boundingBox.translate(x, y, z);
if (this.facing == 1 || this.facing == 5 || this.facing == 8) { // North.
blockCollision.pushOutOfBoundingBox(playerCollision, Direction.SOUTH, MAX_PUSH_DISTANCE);
}
// Also we want to flip the direction since the direction here is indicating the block side the glass is connected to.
if (this.facing == 2 || this.facing == 6 || this.facing == 5) { // East
boundingBox.pushOutOfBoundingBox(playerCollision, Direction.WEST, maxPushDistance);
}
if (this.facing == 3 || this.facing == 6 || this.facing == 7) { // South
blockCollision.pushOutOfBoundingBox(playerCollision, Direction.NORTH, MAX_PUSH_DISTANCE);
}
if (this.facing == 1 || this.facing == 5 || this.facing == 8) { // North.
boundingBox.pushOutOfBoundingBox(playerCollision, Direction.SOUTH, maxPushDistance);
}
if (this.facing == 3 || this.facing == 6 || this.facing == 7) { // South
boundingBox.pushOutOfBoundingBox(playerCollision, Direction.NORTH, maxPushDistance);
}
if (this.facing == 4 || this.facing == 7 || this.facing == 8) { // West
boundingBox.pushOutOfBoundingBox(playerCollision, Direction.EAST, maxPushDistance);
}
if (this.facing == 4 || this.facing == 7 || this.facing == 8) { // West
blockCollision.pushOutOfBoundingBox(playerCollision, Direction.EAST, MAX_PUSH_DISTANCE);
}
}
}

18
core/src/main/java/org/geysermc/geyser/translator/collision/fixes/LanternCollision.java
View File

@@ -38,6 +38,8 @@ import org.geysermc.geyser.translator.collision.CollisionRemapper;
@EqualsAndHashCode(callSuper = true)
@CollisionRemapper(regex = "^lantern$|^soul_lantern$", usesParams = true, passDefaultBoxes = true)
public class LanternCollision extends BlockCollision {
private final static double MAX_PUSH_DISTANCE = 0.0625 + CollisionManager.COLLISION_TOLERANCE * 1.01;
private final boolean hanging;
public LanternCollision(BlockState state, BoundingBox[] boxes) {
@@ -46,6 +48,16 @@ public class LanternCollision extends BlockCollision {
this.hanging = state.getValue(Properties.HANGING);
}
@Override
protected void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox blockCollision, BoundingBox playerCollision) {
// Check for lantern collision (lantern is 0.0625 block higher on Java)
if (this.hanging) {
blockCollision.pushOutOfBoundingBox(playerCollision, Direction.DOWN, MAX_PUSH_DISTANCE);
} else {
blockCollision.pushOutOfBoundingBox(playerCollision, Direction.UP, MAX_PUSH_DISTANCE);
}
}
@Override
public void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox playerCollision) {
super.correctPosition(session, x, y, z, playerCollision);
@@ -60,11 +72,7 @@ public class LanternCollision extends BlockCollision {
boundingBox = boundingBox.clone();
boundingBox.translate(x, y, z);
if (this.hanging) {
boundingBox.pushOutOfBoundingBox(playerCollision, Direction.DOWN, maxPushDistance);
} else {
boundingBox.pushOutOfBoundingBox(playerCollision, Direction.UP, maxPushDistance);
}
}
}
}

9
core/src/main/java/org/geysermc/geyser/translator/collision/fixes/SeaPickleCollision.java
View File

@@ -42,6 +42,14 @@ public class SeaPickleCollision extends BlockCollision {
super(boxes);
}
@Override
protected void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox blockCollision, BoundingBox playerCollision) {
// Check for sea pickle bug (sea pickle have no collision on Bedrock but does on Java).
double maxY = blockCollision.getMax(Axis.Y) - y;
System.out.println(maxY);
blockCollision.pushOutOfBoundingBox(playerCollision, Direction.UP, maxY + CollisionManager.COLLISION_TOLERANCE * 1.01F);
}
@Override
public void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox playerCollision) {
super.correctPosition(session, x, y, z, playerCollision);
@@ -56,7 +64,6 @@ public class SeaPickleCollision extends BlockCollision {
boundingBox = boundingBox.clone();
boundingBox.translate(x, y, z);
// Check for sea pickle bug (sea pickle have no collision on Bedrock but does on Java).
boundingBox.pushOutOfBoundingBox(playerCollision, Direction.UP, maxY + CollisionManager.COLLISION_TOLERANCE * 1.01F);
}
}

18
core/src/main/java/org/geysermc/geyser/translator/collision/fixes/TrapdoorCollision.java
View File

@@ -38,6 +38,8 @@ import org.geysermc.geyser.translator.collision.CollisionRemapper;
@EqualsAndHashCode(callSuper = true)
@CollisionRemapper(regex = "_trapdoor$", usesParams = true, passDefaultBoxes = true)
public class TrapdoorCollision extends BlockCollision {
private final static double MAX_PUSH_DISTANCE = 0.005 + CollisionManager.COLLISION_TOLERANCE * 1.01;
private final Direction facing;
public TrapdoorCollision(BlockState state, BoundingBox[] defaultBoxes) {
@@ -54,20 +56,8 @@ public class TrapdoorCollision extends BlockCollision {
}
@Override
public void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox playerCollision) {
super.correctPosition(session, x, y, z, playerCollision);
final double maxPushDistance = 0.005 + CollisionManager.COLLISION_TOLERANCE * 1.01F;
protected void correctPosition(GeyserSession session, int x, int y, int z, BoundingBox blockCollision, BoundingBox playerCollision) {
// Check for trapdoor bug (trapdoors are 0.1875 blocks thick on Java but 0.1825 blocks thick on Bedrock)
for (BoundingBox boundingBox : this.boundingBoxes) {
if (!boundingBox.checkIntersection(x, y, z, playerCollision)) {
continue;
}
boundingBox = boundingBox.clone();
boundingBox.translate(x, y, z);
boundingBox.pushOutOfBoundingBox(playerCollision, facing, maxPushDistance);
}
blockCollision.pushOutOfBoundingBox(playerCollision, facing, MAX_PUSH_DISTANCE);
}
}