Tag: java

I'm programming a collision detection and response system for my voxel game, and after several rewrites, I've come up with a pretty stable and reliable solution. The problem I am currently facing is that I have to distinguish between the fact that the player falls to the ground or walks on a wall. For the moment, I only have the code if the velocity is negative, then corrects upwards, but it forces the player to hang the walls when he walks against a falling one.

My first solution was to calculate the direction from which the player comes by subtracting the previous position and the block with which he is currently colliding. I "search" then in this direction blocks at the feet of the players. If I do not find one, I guess the player walks against a wall and corrects instead horizontally. If I find blocks, I guess the player is stuck in the ground and corrects up.

This is the current crash code:

                checkCollision () {) private
if (this.world! = null) {
if (this.collision) {
float length = (float) Math.sqrt (this.velocityX * this.velocityX + this.velocityY * this.velocityY + this.velocityZ * this.velocityZ);
if (length == 0.0) {
this.predictedX = this.posX;
this.predictedY = this.posY;
this.predictedZ = this.posZ;
} other {
float nVelocityX = this.velocityX / length;
float nVelocityY = this.velocityY / length;
float nVelocityZ = this.velocityZ / length;

float advancement = Math.min (1.0f, length);
float lengthLeft = Math.max (length - 1.0f, 0.0f);

a boolean collided;
this.boundingBox.setCenterXY (this.posX, this.posY, this.posZ);

loop:
while (advancement <= length) {
                        this.predictedX = this.posX + nVelocityX * advancement;
                        this.predictedY = this.posY + nVelocityY * advancement;
                        this.predictedZ = this.posZ + nVelocityZ * advancement;

                        // Update bb
                        this.prevBoundingBox.set(this.boundingBox);
                        this.boundingBox.setCenterXY(this.predictedX, this.predictedY, this.predictedZ);

                        // Loop through all blocks the bounding box could collide with from top to bottom
                        for (int y = (int) Math.floor(this.boundingBox.getMaxY()); y >= Math.floor (this.boundingBox.getMinY ()); y--) {
for (int x = (int) Math.floor (this.boundingBox.getMinX ()); x <this.boundingBox.getMaxX (); x ++) {
for (int z = (int) Math.floor (this.boundingBox.getMinZ ()); z < this.boundingBox.getMaxZ(); z++) {
                                    if (y >= 0 && y < IChunk.BLOCK_COUNT) {
                                        collided = false;
                                        IChunk chunk = this.world.getChunk(x >> ISection.BLOCK_TO_CHUNK, z >> ISection.BLOCK_TO_CHUNK, false);

Block block;
if (chunk! = null) {
block = BlockRegistry.getBlock (chunk.getBlock (x, y, z));
} other {
block = BlockRegistry.getBlock (1);
}

if (block.isSolid ()) {
RESULT.facing = null;
if (nVelocityY <0.0f) {
int minX = x;
int maxX = x;
int minZ = z;
int maxZ = z;

float distX = this.prevBoundingBox.getMinX () - x;
float distZ = this.prevBoundingBox.getMinZ () - z;

if (distX < 0.0f) {
                                                    minX -= (int) Math.floor(this.width);
                                                    maxX--;
                                                } else if (distX > 0.0f) {
minX ++;
maxX + = (int) Math.floor (this.width);
}

if (distZ < 0.0f) {
                                                    minZ -= (int) Math.floor(this.depth);
                                                    maxZ--;
                                                } else if (distZ > 0.0f) {
minZ ++;
maxZ + = (int) Math.floor (this.depth);
}

int blockY = (int) Math.floor (this.prevBoundingBox.getMinY ());
correction:
for (int blockX = minX; blockX <= maxX; blockX ++) {
for (int blockZ = minZ; blockZ <= maxZ; blockZ++) {
                                                        if (blockX == x && blockZ == z) continue;
                                                        int blockId = this.world.getBlock(blockX, blockY, blockZ);

                                                        if (blockId != -1) {
                                                            block = BlockRegistry.getBlock(blockId);

                                                            if (block.isSolid()) {
                                                                RESULT.facing = Facing.TOP;
                                                                break correction;
                                                            }
                                                        }
                                                    }
                                                }

                                            } else if (nVelocityY > 0.0f && y> Math.floor (this.posY) + this.height && (chunk! = Null &&! BlockRegistry.getBlock (chunk.getBlock (x, y - 1, z)) IsSolid ())) {
// the entity jumps against the ceiling, the downward correction takes precedence
RESULT.facing = Face.BOTTOM;
}

if (RESULT.facing == null) {
if (Math.abs (nVelocityX)> Math.abs (nVelocityZ)) {
// the speed on the x-axis is higher, the correction on the x-axis takes precedence

if (nVelocityX <0.0f)
RESULT.facing = Facing.EAST;
other
RESULT.facing = Facing.WEST;
} other {
// the speed on the z axis is greater, the correction on the z axis takes precedence

if (nVelocityZ < 0.0f)
                                                        RESULT.facing = Facing.SOUTH;
                                                    else
                                                        RESULT.facing = Facing.NORTH;
                                                }
                                            }

                                            System.out.println("Correction Facing: " + RESULT.facing.name());

                                            OTHER.setPosition(x, y, z);
                                            OTHER.setSize(1.0f, block.getHeight(), 1.0f);
                                            collided = this.boundingBox.intersects(OTHER, RESULT);
                                        }

                                        if (collided) {
                                            if (y == Math.floor(this.boundingBox.getMinY()) && RESULT.facing != Facing.TOP) {
                                                // there is only collision at the feet -> stepup
this.predictedY = Math.floor (this.predictedY) + block.getHeight ();
} other {
this.applyCorrection ();
}
break loop;
}
}
}
}
}

if (advancement> = length) {
Pause;
}

lengthLeft = Math.max (lengthLeft - 1.0f, 0.0f);
advancement = length - lengthLeft;
}
}
} other {
this.predictedX = this.posX + this.velocityX;
this.predictedY = this.posY + this.velocityY;
this.predictedZ = this.posZ + this.velocityZ;
}
}
}

To prevent the player from ghosting through the walls during brisk walking, I divide the movement into units along the speed axis until all speed is processed. The first positive collision detection will cause a correction and will cancel any subsequent checks.

If a solid block is found, a static AABB is set on the block coordinates and a collision check is performed. According to previously defined conditions, a correction for an axis is calculated and stored in the RESULT variable. Intersection & Correction itself works as expected.

I do not know why, but the player may slip into the ground once during his landing after hitting a wall, as shown in this video: https://streamable.com/ogtjk

Is there another way to detect if I'm walking against a wall or falling into the ground?