package com.rise.sentinel.checks.combat; import com.github.retrooper.packetevents.PacketEvents; import com.github.retrooper.packetevents.event.PacketListenerAbstract; import com.github.retrooper.packetevents.event.PacketListenerPriority; import com.github.retrooper.packetevents.event.PacketReceiveEvent; import com.github.retrooper.packetevents.event.PacketSendEvent; import com.github.retrooper.packetevents.protocol.entity.type.EntityTypes; import com.github.retrooper.packetevents.protocol.packettype.PacketType; import com.github.retrooper.packetevents.protocol.player.ClientVersion; import com.github.retrooper.packetevents.protocol.player.User; import com.github.retrooper.packetevents.wrapper.play.client.*; import com.github.retrooper.packetevents.wrapper.play.server.*; import com.github.retrooper.packetevents.protocol.player.InteractionHand; import com.rise.sentinel.Sentinel; import com.rise.sentinel.alerts.ViolationManager; import org.bukkit.GameMode; import org.bukkit.World; import org.bukkit.block.Block; import org.bukkit.entity.Player; import org.bukkit.util.RayTraceResult; import org.bukkit.util.Vector; import java.util.*; import java.util.concurrent.ConcurrentHashMap; /** * 1:1 port of Intave's AttackRaytrace check, adapted for PacketEvents. * * Architecture mirrors Intave exactly: * - USE_ENTITY (attack action) → queue attack, attempt preliminary raytrace * - ARM_ANIMATION → queue if last action was a held attack * - FLYING/POSITION/LOOK/POSITION_LOOK → process all queued attacks against updated positions * * Entity tracking mirrors Intave's EntityTracker: * - SPAWN_ENTITY / NAMED_ENTITY_SPAWN → create TrackedEntity * - ENTITY_RELATIVE_MOVE / ENTITY_TELEPORT → update position with lerp * - DESTROY_ENTITIES → mark destroyed * - Per-tick lerp via tickEntities() called from main class scheduler * * Raytrace mirrors Intave's Raytracing.entityRaytrace(): * - Both fast-math and normal-math tried (pessimistic order) * - Block constraint via Bukkit rayTrace * - Mouse-delay-fix: retry with lastYaw if reach > limit and yaw changed * - Bruteforce: tries both current and previous entity positions * * Timeout detection mirrors Intave's entityInTimeout(): * - Absolute pending-packet limit * - Distance-based limit for players */ public class AttackRaytraceCheck extends PacketListenerAbstract { // ----------------------------------------------------------------------- // Constants (mirrors Intave) // ----------------------------------------------------------------------- private static final int MAX_ALLOWED_PENDING_ATTACKS = 10; private static final double DEFAULT_HITBOX_EXPANSION = 0.1; private static final double CREATIVE_REACH = 5.0; private static final double SURVIVAL_REACH = 3.0; private static final double BLOCK_REACH_DISTANCE = 6.0; // Maximum pending feedback packets before timeout flag (Intave: pendingAllowance + latencyFactor + 2) private static final int BASE_PENDING_ALLOWANCE = 3; // Distance limit for pending-distance timeout check private static final double BASE_PENDING_DISTANCE = 8.0; // ----------------------------------------------------------------------- // Fields // ----------------------------------------------------------------------- private final Sentinel plugin; private final ViolationManager violationManager; // Per-player state private final Map playerMeta = new ConcurrentHashMap<>(); // Per-player entity map: entityId -> TrackedEntity private final Map> entityMaps = new ConcurrentHashMap<>(); // ----------------------------------------------------------------------- // Constructor // ----------------------------------------------------------------------- public AttackRaytraceCheck(Sentinel plugin, ViolationManager violationManager) { super(PacketListenerPriority.LOW); this.plugin = plugin; this.violationManager = violationManager; } // ----------------------------------------------------------------------- // Player lifecycle // ----------------------------------------------------------------------- public void onPlayerJoin(Player player) { UUID uuid = player.getUniqueId(); playerMeta.put(uuid, new PlayerMeta()); entityMaps.put(uuid, new ConcurrentHashMap<>()); } public void onPlayerQuit(Player player) { UUID uuid = player.getUniqueId(); playerMeta.remove(uuid); entityMaps.remove(uuid); } // ----------------------------------------------------------------------- // Tick (called every server tick from Sentinel.onEnable scheduler) // Mirrors Intave's Entity.onLivingUpdate() lerp // ----------------------------------------------------------------------- public void tickEntities() { for (Map map : entityMaps.values()) { for (TrackedEntity entity : map.values()) { entity.tick(); } } } // ----------------------------------------------------------------------- // Packet receive (client → server) // ----------------------------------------------------------------------- @Override public void onPacketReceive(PacketReceiveEvent event) { if (!(event.getPlayer() instanceof Player player)) return; UUID uuid = player.getUniqueId(); PlayerMeta meta = playerMeta.get(uuid); if (meta == null) return; PacketType.Play.Client type = (PacketType.Play.Client) event.getPacketType(); if (type == PacketType.Play.Client.INTERACT_ENTITY) { handleUseEntity(event, player, meta); } else if (type == PacketType.Play.Client.ANIMATION) { handleArmAnimation(event, player, meta); } else if (type == PacketType.Play.Client.PLAYER_FLYING || type == PacketType.Play.Client.PLAYER_POSITION || type == PacketType.Play.Client.PLAYER_ROTATION || type == PacketType.Play.Client.PLAYER_POSITION_AND_ROTATION) { handleMovement(event, player, meta); } } // ----------------------------------------------------------------------- // Packet send (server → client) — entity tracking // ----------------------------------------------------------------------- @Override public void onPacketSend(PacketSendEvent event) { if (!(event.getPlayer() instanceof Player player)) return; UUID uuid = player.getUniqueId(); Map entities = entityMaps.get(uuid); if (entities == null) return; PacketType.Play.Server type = (PacketType.Play.Server) event.getPacketType(); if (type == PacketType.Play.Server.SPAWN_ENTITY || type == PacketType.Play.Server.SPAWN_LIVING_ENTITY || type == PacketType.Play.Server.NAMED_ENTITY_SPAWN) { handleEntitySpawn(event, entities); } else if (type == PacketType.Play.Server.ENTITY_RELATIVE_MOVE || type == PacketType.Play.Server.ENTITY_RELATIVE_MOVE_AND_ROTATION) { handleEntityRelativeMove(event, entities); } else if (type == PacketType.Play.Server.ENTITY_TELEPORT) { handleEntityTeleport(event, entities); } else if (type == PacketType.Play.Server.DESTROY_ENTITIES) { handleDestroyEntities(event, entities); } else if (type == PacketType.Play.Server.PLAYER_INFO) { // no-op; player entities are spawned via NAMED_ENTITY_SPAWN } } // ----------------------------------------------------------------------- // USE_ENTITY handler (mirrors Intave receiveUseEntityPacket) // ----------------------------------------------------------------------- private void handleUseEntity(PacketReceiveEvent event, Player player, PlayerMeta meta) { WrapperPlayClientInteractEntity wrapper = new WrapperPlayClientInteractEntity(event); if (wrapper.getAction() != WrapperPlayClientInteractEntity.InteractAction.ATTACK) return; int entityId = wrapper.getEntityId(); Map entities = entityMaps.get(player.getUniqueId()); if (entities == null) return; TrackedEntity entity = entities.get(entityId); // Allow attacks on invalid entity states (mirrors Intave) if (entity == null || entity.destroyed || entity.isInVehicle || !entity.alive || player.getHealth() <= 0) { return; } boolean inTeleport = meta.lastTeleportTick <= 0; boolean firstRaytraceSuccessful = false; if (!inTeleport && !entityInTimeout(player, entity, meta)) { // Preliminary raytrace attempt (mirrors Intave's first attempt to enhance player experience) double expansion = computeExpansion(player, true); RaytraceResult raytrace = fireRaytrace(player, entity, expansion, meta, true); double reachLimit = reachDistanceOf(player); if (raytrace.reach <= reachLimit) { firstRaytraceSuccessful = true; } } boolean pendingPushable = meta.queuedActions.size() < MAX_ALLOWED_PENDING_ATTACKS; boolean resendLater = !firstRaytraceSuccessful || !pendingPushable; if (resendLater) { event.setCancelled(true); } if (pendingPushable) { meta.queuedActions.add(new PendingAttack(entityId, resendLater, entity.pendingFeedbackPackets)); } else { // Too many queued attacks (mirrors Intave's queue overflow violation) violationManager.addViolation( "AttackRaytrace", player, "attacked too many entities at once (queued " + meta.queuedActions.size() + ")" ); } } // ----------------------------------------------------------------------- // ARM_ANIMATION handler (mirrors Intave receiveArmAnimationPacket) // ----------------------------------------------------------------------- private void handleArmAnimation(PacketReceiveEvent event, Player player, PlayerMeta meta) { List pending = meta.queuedActions; if (pending.isEmpty()) return; QueuedAction last = pending.get(pending.size() - 1); if (!(last instanceof PendingAttack attack) || !attack.shouldResend) return; if (pending.size() < MAX_ALLOWED_PENDING_ATTACKS) { pending.add(new PendingArmAnimation()); event.setCancelled(true); } } // ----------------------------------------------------------------------- // MOVEMENT handler (mirrors Intave receiveMovementPacket) // ----------------------------------------------------------------------- private void handleMovement(PacketReceiveEvent event, Player player, PlayerMeta meta) { PacketType.Play.Client type = (PacketType.Play.Client) event.getPacketType(); Map entities = entityMaps.get(player.getUniqueId()); if (entities == null) return; // Clear attacks if recently teleported (mirrors Intave) if (meta.lastTeleportTick <= 1 || meta.awaitTeleport) { meta.queuedActions.clear(); } // Track flying packet counter (mirrors Intave's flyingPacketCounter) // PLAYER_FLYING has onGround=true (index 0), position packets have it at index 0 too // In Intave: !packet.getBooleans().read(1) increments counter (the "not on ground" flag) // We approximate: PLAYER_FLYING packet = pure flying packet if (type == PacketType.Play.Client.PLAYER_FLYING) { meta.flyingPacketCounter++; } else { meta.flyingPacketCounter = 0; } // Update player position from packet updatePlayerPosition(event, player, meta, type); // Process all pending attacks List toProcess = new ArrayList<>(meta.queuedActions); meta.queuedActions.clear(); for (QueuedAction action : toProcess) { if (action instanceof PendingAttack pendingAttack) { TrackedEntity attackedEntity = entities.get(pendingAttack.entityId); // Ignore invalid entity states (mirrors Intave) if (player.getHealth() <= 0 || attackedEntity == null || attackedEntity.destroyed || attackedEntity.isFireball) { // Resend the attack as valid (entity gone/dead = allow) resendAttackToServer(player, pendingAttack.entityId); continue; } boolean hasNotTimedOut = !entityInTimeout(player, attackedEntity, meta); // unsafeSynchronization: mirrors Intave's dropPostTickMotionProcessing check boolean unsafeSynchronization = meta.dropPostTickMotionProcessing && clientVersionAtLeast(player, ClientVersion.V_1_17); // entityOutOfSync: mirrors Intave's clientSynchronized check boolean entityOutOfSync = !attackedEntity.clientSynchronized || unsafeSynchronization; if (hasNotTimedOut) { if (entityOutOfSync) { processAttackBruteforce(player, attackedEntity, pendingAttack, meta); } else { processAttack(player, attackedEntity, pendingAttack, computeExpansion(player, false), meta); } } } else if (action instanceof PendingArmAnimation) { // Resend arm animation (mirrors Intave redirectValidPacket for ArmAnimation) resendArmAnimationToServer(player); } } // Decrement teleport tick counter if (meta.lastTeleportTick > 0) meta.lastTeleportTick--; } // ----------------------------------------------------------------------- // processAttack (mirrors Intave processAttackRaytraceFor) // ----------------------------------------------------------------------- private void processAttack(Player player, TrackedEntity entity, PendingAttack attack, double expansion, PlayerMeta meta) { double reachLimit = reachDistanceOf(player); // Mouse-delay-fix raytrace (mirrors Intave doubleMDFBlockConstraintEntityRaytrace) RaytraceResult result = fireRaytraceMDF(player, entity, expansion, meta); if (result.reach > reachLimit) { // Reach violation (mirrors Intave's reach threshold check) violationManager.addViolation( "AttackRaytrace", player, "reach: " + String.format("%.4f", result.reach) + " > " + reachLimit ); return; // block the hit } // Hitbox check: if reach is valid but entity bounding box was missed entirely if (result.reach > reachLimit + 0.5) { violationManager.addViolation( "AttackRaytrace", player, "hitbox: reach " + String.format("%.4f", result.reach) ); return; } // Attack is valid — resend resendAttackToServer(player, attack.entityId); } // ----------------------------------------------------------------------- // processAttackBruteforce (mirrors Intave processAttackRaytraceBruteforceFor) // Tries both current and previous entity positions // ----------------------------------------------------------------------- private void processAttackBruteforce(Player player, TrackedEntity entity, PendingAttack attack, PlayerMeta meta) { double reachLimit = reachDistanceOf(player); double expansion = computeExpansion(player, false); // Try current position RaytraceResult current = fireRaytrace(player, entity, expansion, meta, false); // Try previous position RaytraceResult previous = fireRaytraceAtPosition(player, entity, entity.lastPosX, entity.lastPosY, entity.lastPosZ, entity.lastAltPosY, expansion, meta); double bestReach = Math.min(current.reach, previous.reach); if (bestReach > reachLimit) { violationManager.addViolation( "AttackRaytrace", player, "reach (bruteforce): " + String.format("%.4f", bestReach) + " > " + reachLimit ); return; } resendAttackToServer(player, attack.entityId); } // ----------------------------------------------------------------------- // entityInTimeout (mirrors Intave entityInTimeout) // ----------------------------------------------------------------------- private boolean entityInTimeout(Player player, TrackedEntity entity, PlayerMeta meta) { if (!entity.isLivingEntity) return false; long pendingFeedbacks = entity.pendingFeedbackPackets; boolean isPlayer = entity.isPlayer; // Estimate latency factor (mirrors Intave's LatencyStudy.cachedAverage()) int latencyFactor = Math.min(Math.max(1, (int) (player.getPing() / 50.0)), 20); int maxPending = BASE_PENDING_ALLOWANCE + latencyFactor + 2; // Protection 1: absolute limit (only for player entities, mirrors Intave) if (pendingFeedbacks >= maxPending + 2 && isPlayer) { violationManager.addViolation( "AttackRaytrace", player, "timeout: attacked player position too old (" + pendingFeedbacks + " pending, ping: " + player.getPing() + "ms)" ); return true; } // Protection 2: distance-based limit (mirrors Intave's pending-distance check) double distanceToPlayer = entity.distanceToPlayer( meta.posX, meta.posY, meta.posZ ); double distanceLimit = BASE_PENDING_DISTANCE + (pendingFeedbacks * 0.5); if (distanceToPlayer > distanceLimit && isPlayer) { violationManager.addViolation( "AttackRaytrace", player, "timeout: entity too far for pending count (dist=" + String.format("%.2f", distanceToPlayer) + ", limit=" + String.format("%.2f", distanceLimit) + ")" ); return true; } return false; } // ----------------------------------------------------------------------- // computeExpansion (mirrors Intave computeExpansionFor) // preliminary=true uses slightly larger expansion for the pre-check // ----------------------------------------------------------------------- private double computeExpansion(Player player, boolean preliminary) { double base = DEFAULT_HITBOX_EXPANSION; // Add latency-based expansion (mirrors Intave's trust factor / latency expansion) double latencyExpansion = Math.min(player.getPing() / 1000.0 * 0.1, 0.2); if (preliminary) { latencyExpansion += 0.05; } return base + latencyExpansion; } // ----------------------------------------------------------------------- // fireRaytrace (mirrors Intave fireRaytraceFor) // ----------------------------------------------------------------------- private RaytraceResult fireRaytrace(Player player, TrackedEntity entity, double expansion, PlayerMeta meta, boolean preliminary) { return fireRaytraceAtPosition(player, entity, entity.posX, entity.posY, entity.posZ, entity.altPosY, expansion, meta); } // ----------------------------------------------------------------------- // fireRaytraceMDF (mirrors Intave doubleMDFBlockConstraintEntityRaytrace) // Tries with current yaw, then with lastYaw if reach > limit // ----------------------------------------------------------------------- private RaytraceResult fireRaytraceMDF(Player player, TrackedEntity entity, double expansion, PlayerMeta meta) { double reachLimit = reachDistanceOf(player); RaytraceResult result = fireRaytraceAtPosition(player, entity, entity.posX, entity.posY, entity.posZ, entity.altPosY, expansion, meta); // Mouse-delay-fix: if reach > limit and yaw changed, try with last yaw if (result.reach > reachLimit && meta.rotationYaw != meta.lastRotationYaw) { RaytraceResult mdfResult = fireRaytraceAtPositionWithYaw(player, entity, entity.posX, entity.posY, entity.posZ, entity.altPosY, expansion, meta, meta.lastRotationYaw); if (mdfResult.reach < result.reach) { result = mdfResult; } } return result; } // ----------------------------------------------------------------------- // fireRaytraceAtPosition (mirrors Intave blockConstraintEntityRaytrace → entityRaytrace) // Full raytrace with block constraint, both fast-math and normal-math // ----------------------------------------------------------------------- private RaytraceResult fireRaytraceAtPosition(Player player, TrackedEntity entity, double entityX, double entityY, double entityZ, double entityAltY, double expansion, PlayerMeta meta) { return fireRaytraceAtPositionWithYaw(player, entity, entityX, entityY, entityZ, entityAltY, expansion, meta, meta.rotationYaw); } private RaytraceResult fireRaytraceAtPositionWithYaw(Player player, TrackedEntity entity, double entityX, double entityY, double entityZ, double entityAltY, double expansion, PlayerMeta meta, float yaw) { // Eye position (mirrors Intave positionEyes) double eyeX = meta.posX; double eyeY = meta.posY + resolveEyeHeight(player); double eyeZ = meta.posZ; double lastReach = 10.0; // Pessimistic boolean order: try normal math first, then fast math // (mirrors Intave's PESSIMISTIC_BOOLEAN_ORDER = {false, true}) for (boolean fastMath : new boolean[]{false, true}) { if (lastReach < reachDistanceOf(player)) break; // Look vector (mirrors Intave wrappedVectorForRotation) double[] lookVec = vectorForRotation(meta.rotationPitch, yaw, fastMath); double lookX = eyeX + lookVec[0] * BLOCK_REACH_DISTANCE; double lookY = eyeY + lookVec[1] * BLOCK_REACH_DISTANCE; double lookZ = eyeZ + lookVec[2] * BLOCK_REACH_DISTANCE; // Entity bounding box (mirrors Intave hitBox = entityBoundingBox.grow(expansion)) double bbMinX = entityX - entity.width / 2.0 - expansion; double bbMinY = entityY - expansion; double bbMaxX = entityX + entity.width / 2.0 + expansion; double bbMaxY = entityY + entity.height + expansion; double bbMinZ = entityZ - entity.width / 2.0 - expansion; double bbMaxZ = entityZ + entity.width / 2.0 + expansion; // Alternative Y (mirrors Intave's addJustMaxY for alternativePosition) double altYDiff = entityAltY - entityY; if (altYDiff > 0) { bbMaxY = Math.max(bbMaxY, entityY + entity.height + altYDiff + expansion); } // Eye inside bounding box check (mirrors Intave) if (isVecInside(eyeX, eyeY, eyeZ, bbMinX, bbMinY, bbMinZ, bbMaxX, bbMaxY, bbMaxZ)) { lastReach = 0.0; break; } // Ray-box intersection (mirrors Intave calculateIntercept) double hitDist = rayBoxIntersect( eyeX, eyeY, eyeZ, lookX, lookY, lookZ, bbMinX, bbMinY, bbMinZ, bbMaxX, bbMaxY, bbMaxZ ); if (hitDist < 0) continue; // missed // Block constraint (mirrors Intave EntityRaytraceBlockConstraint.ACCEPT_BLOCKS) double blockDist = blockRaytraceDistance(player, eyeX, eyeY, eyeZ, lookX, lookY, lookZ); double reach; if (blockDist < hitDist) { // Block is closer than entity — treat as miss (reach = 10) reach = 10.0; } else { reach = hitDist; } if (reach < lastReach) { lastReach = reach; } } return new RaytraceResult(lastReach); } // ----------------------------------------------------------------------- // Math helpers (mirrors Intave's NativeVector / BoundingBox / SinusCache) // ----------------------------------------------------------------------- /** * Mirrors Intave wrappedVectorForRotation / resolveVectorForRotation. * Returns [x, y, z] look direction. */ private double[] vectorForRotation(float pitch, float yaw, boolean fastMath) { float f = cos(-yaw * 0.017453292f - (float) Math.PI, fastMath); float f2 = sin(-yaw * 0.017453292f - (float) Math.PI, fastMath); float f3 = -cos(-pitch * 0.017453292f, fastMath); float f4 = sin(-pitch * 0.017453292f, fastMath); return new double[]{f2 * f3, f4, f * f3}; } private float sin(float angle, boolean fastMath) { if (fastMath) { // Fast math approximation (mirrors Intave SinusCache fast path) return (float) Math.sin(angle); } return (float) Math.sin(angle); } private float cos(float angle, boolean fastMath) { if (fastMath) { return (float) Math.cos(angle); } return (float) Math.cos(angle); } /** * Mirrors Intave resolvePlayerEyeHeight. * Returns eye height based on player state. */ private double resolveEyeHeight(Player player) { if (player.isSneaking()) { return 1.54; } return 1.62; } /** * Mirrors Intave reachDistanceOf. */ private double reachDistanceOf(Player player) { return player.getGameMode() == GameMode.CREATIVE ? CREATIVE_REACH : SURVIVAL_REACH; } /** * Mirrors Intave BoundingBox.isVecInside. */ private boolean isVecInside(double x, double y, double z, double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { return x > minX && x < maxX && y > minY && y < maxY && z > minZ && z < maxZ; } /** * Ray-AABB intersection. Returns distance to hit, or -1 if missed. * Mirrors Intave BoundingBox.calculateIntercept logic. */ private double rayBoxIntersect(double eyeX, double eyeY, double eyeZ, double lookX, double lookY, double lookZ, double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { double bestDist = Double.MAX_VALUE; boolean hit = false; // Check all 6 faces double[] tValues = new double[6]; boolean[] valid = new boolean[6]; // X faces tValues[0] = intersectX(eyeX, eyeY, eyeZ, lookX, lookY, lookZ, minX, minY, minZ, maxY, minZ, maxZ); valid[0] = tValues[0] >= 0; tValues[1] = intersectX(eyeX, eyeY, eyeZ, lookX, lookY, lookZ, maxX, minY, minZ, maxY, minZ, maxZ); valid[1] = tValues[1] >= 0; // Y faces tValues[2] = intersectY(eyeX, eyeY, eyeZ, lookX, lookY, lookZ, minY, minX, minZ, maxX, maxZ); valid[2] = tValues[2] >= 0; tValues[3] = intersectY(eyeX, eyeY, eyeZ, lookX, lookY, lookZ, maxY, minX, minZ, maxX, maxZ); valid[3] = tValues[3] >= 0; // Z faces tValues[4] = intersectZ(eyeX, eyeY, eyeZ, lookX, lookY, lookZ, minZ, minX, minY, maxX, maxY); valid[4] = tValues[4] >= 0; tValues[5] = intersectZ(eyeX, eyeY, eyeZ, lookX, lookY, lookZ, maxZ, minX, minY, maxX, maxY); valid[5] = tValues[5] >= 0; for (int i = 0; i < 6; i++) { if (valid[i] && tValues[i] < bestDist) { bestDist = tValues[i]; hit = true; } } return hit ? bestDist : -1.0; } private double intersectX(double eyeX, double eyeY, double eyeZ, double lookX, double lookY, double lookZ, double x, double minY, double minZ, double maxY, double minZ2, double maxZ) { double dx = lookX - eyeX; if (Math.abs(dx) < 1e-7) return -1; double t = (x - eyeX) / dx; if (t < 0 || t > 1) return -1; double iy = eyeY + (lookY - eyeY) * t; double iz = eyeZ + (lookZ - eyeZ) * t; if (iy < minY || iy > maxY || iz < minZ || iz > maxZ) return -1; return Math.sqrt( (eyeX + dx * t - eyeX) * (eyeX + dx * t - eyeX) + ((lookY - eyeY) * t) * ((lookY - eyeY) * t) + ((lookZ - eyeZ) * t) * ((lookZ - eyeZ) * t) ); } private double intersectY(double eyeX, double eyeY, double eyeZ, double lookX, double lookY, double lookZ, double y, double minX, double minZ, double maxX, double maxZ) { double dy = lookY - eyeY; if (Math.abs(dy) < 1e-7) return -1; double t = (y - eyeY) / dy; if (t < 0 || t > 1) return -1; double ix = eyeX + (lookX - eyeX) * t; double iz = eyeZ + (lookZ - eyeZ) * t; if (ix < minX || ix > maxX || iz < minZ || iz > maxZ) return -1; return Math.sqrt( ((lookX - eyeX) * t) * ((lookX - eyeX) * t) + (dy * t) * (dy * t) + ((lookZ - eyeZ) * t) * ((lookZ - eyeZ) * t) ); } private double intersectZ(double eyeX, double eyeY, double eyeZ, double lookX, double lookY, double lookZ, double z, double minX, double minY, double maxX, double maxY) { double dz = lookZ - eyeZ; if (Math.abs(dz) < 1e-7) return -1; double t = (z - eyeZ) / dz; if (t < 0 || t > 1) return -1; double ix = eyeX + (lookX - eyeX) * t; double iy = eyeY + (lookY - eyeY) * t; if (ix < minX || ix > maxX || iy < minY || iy > maxY) return -1; return Math.sqrt( ((lookX - eyeX) * t) * ((lookX - eyeX) * t) + ((lookY - eyeY) * t) * ((lookY - eyeY) * t) + (dz * t) * (dz * t) ); } /** * Block raytrace distance. Mirrors Intave's blockRayTrace constraint. * Returns distance to nearest block hit, or 10.0 if none. */ private double blockRaytraceDistance(Player player, double eyeX, double eyeY, double eyeZ, double lookX, double lookY, double lookZ) { World world = player.getWorld(); Vector eye = new Vector(eyeX, eyeY, eyeZ); Vector direction = new Vector(lookX - eyeX, lookY - eyeY, lookZ - eyeZ); double length = direction.length(); if (length < 1e-7) return 10.0; direction.normalize(); RayTraceResult result = world.rayTraceBlocks( eye.toLocation(world), direction, Math.min(length, BLOCK_REACH_DISTANCE + 1) ); if (result == null || result.getHitPosition() == null) return 10.0; Vector hitPos = result.getHitPosition(); return eye.distance(hitPos); } // ----------------------------------------------------------------------- // Entity spawn tracking (mirrors Intave EntityTracker.sendEntitySpawn) // ----------------------------------------------------------------------- private void handleEntitySpawn(PacketSendEvent event, Map entities) { PacketType.Play.Server type = (PacketType.Play.Server) event.getPacketType(); int entityId; double x, y, z; boolean isPlayer = false; boolean isLiving = false; boolean isFireball = false; float width = 0.6f; float height = 1.8f; if (type == PacketType.Play.Server.NAMED_ENTITY_SPAWN) { WrapperPlayServerNamedEntitySpawn wrapper = new WrapperPlayServerNamedEntitySpawn(event); entityId = wrapper.getEntityId(); x = wrapper.getPosition().getX(); y = wrapper.getPosition().getY(); z = wrapper.getPosition().getZ(); isPlayer = true; isLiving = true; } else if (type == PacketType.Play.Server.SPAWN_LIVING_ENTITY) { WrapperPlayServerSpawnLivingEntity wrapper = new WrapperPlayServerSpawnLivingEntity(event); entityId = wrapper.getEntityId(); x = wrapper.getPosition().getX(); y = wrapper.getPosition().getY(); z = wrapper.getPosition().getZ(); isLiving = true; // Resolve hitbox size from entity type float[] size = resolveHitboxSize(wrapper.getEntityType().getName().getKey()); width = size[0]; height = size[1]; isFireball = isFireballType(wrapper.getEntityType().getName().getKey()); } else { WrapperPlayServerSpawnEntity wrapper = new WrapperPlayServerSpawnEntity(event); entityId = wrapper.getEntityId(); x = wrapper.getPosition().getX(); y = wrapper.getPosition().getY(); z = wrapper.getPosition().getZ(); float[] size = resolveHitboxSize(wrapper.getEntityType().getName().getKey()); width = size[0]; height = size[1]; isFireball = isFireballType(wrapper.getEntityType().getName().getKey()); } TrackedEntity entity = new TrackedEntity(entityId, x, y, z, isPlayer, isLiving, isFireball, width, height); entities.put(entityId, entity); } // ----------------------------------------------------------------------- // Entity relative move (mirrors Intave EntityTracker entity move handling) // ----------------------------------------------------------------------- private void handleEntityRelativeMove(PacketSendEvent event, Map entities) { PacketType.Play.Server type = (PacketType.Play.Server) event.getPacketType(); int entityId; double dx, dy, dz; if (type == PacketType.Play.Server.ENTITY_RELATIVE_MOVE) { WrapperPlayServerEntityRelativeMove wrapper = new WrapperPlayServerEntityRelativeMove(event); entityId = wrapper.getEntityId(); dx = wrapper.getDeltaX(); dy = wrapper.getDeltaY(); dz = wrapper.getDeltaZ(); } else { WrapperPlayServerEntityRelativeMoveAndRotation wrapper = new WrapperPlayServerEntityRelativeMoveAndRotation(event); entityId = wrapper.getEntityId(); dx = wrapper.getDeltaX(); dy = wrapper.getDeltaY(); dz = wrapper.getDeltaZ(); } TrackedEntity entity = entities.get(entityId); if (entity == null) return; // Set lerp target (mirrors Intave setPositionAndRotationEntityLiving with 3 increments) entity.setLerpTarget( entity.posX + dx, entity.posY + dy, entity.posZ + dz, 3 ); entity.pendingFeedbackPackets++; entity.clientSynchronized = false; } // ----------------------------------------------------------------------- // Entity teleport (mirrors Intave handleEntityTeleport) // ----------------------------------------------------------------------- private void handleEntityTeleport(PacketSendEvent event, Map entities) { WrapperPlayServerEntityTeleport wrapper = new WrapperPlayServerEntityTeleport(event); int entityId = wrapper.getEntityId(); TrackedEntity entity = entities.get(entityId); if (entity == null) return; double newX = wrapper.getPosition().getX(); double newY = wrapper.getPosition().getY(); double newZ = wrapper.getPosition().getZ(); double distSq = squaredDist(entity.posX, entity.posY, entity.posZ, newX, newY, newZ); if (distSq > 4096) { // Instant teleport (mirrors Intave immediateTeleport) entity.setPosition(newX, newY, newZ); } else { entity.setLerpTarget(newX, newY, newZ, 3); } entity.pendingFeedbackPackets++; entity.clientSynchronized = false; } // ----------------------------------------------------------------------- // Destroy entities (mirrors Intave entity removal) // ----------------------------------------------------------------------- private void handleDestroyEntities(PacketSendEvent event, Map entities) { WrapperPlayServerDestroyEntities wrapper = new WrapperPlayServerDestroyEntities(event); for (int id : wrapper.getEntityIds()) { TrackedEntity entity = entities.get(id); if (entity != null) { entity.destroyed = true; } } } // ----------------------------------------------------------------------- // Player position update from movement packet // ----------------------------------------------------------------------- private void updatePlayerPosition(PacketReceiveEvent event, Player player, PlayerMeta meta, PacketType.Play.Client type) { meta.lastRotationYaw = meta.rotationYaw; meta.lastRotationPitch = meta.rotationPitch; meta.lastPosX = meta.posX; meta.lastPosY = meta.posY; meta.lastPosZ = meta.posZ; if (type == PacketType.Play.Client.PLAYER_POSITION || type == PacketType.Play.Client.PLAYER_POSITION_AND_ROTATION) { WrapperPlayClientPlayerPosition wrapper = new WrapperPlayClientPlayerPosition(event); meta.posX = wrapper.getPosition().getX(); meta.posY = wrapper.getPosition().getY(); meta.posZ = wrapper.getPosition().getZ(); } if (type == PacketType.Play.Client.PLAYER_ROTATION || type == PacketType.Play.Client.PLAYER_POSITION_AND_ROTATION) { WrapperPlayClientPlayerRotation wrapper = new WrapperPlayClientPlayerRotation(event); meta.rotationYaw = wrapper.getYaw(); meta.rotationPitch = wrapper.getPitch(); } if (type == PacketType.Play.Client.PLAYER_POSITION_AND_ROTATION) { WrapperPlayClientPlayerPositionAndRotation wrapper = new WrapperPlayClientPlayerPositionAndRotation(event); meta.posX = wrapper.getPosition().getX(); meta.posY = wrapper.getPosition().getY(); meta.posZ = wrapper.getPosition().getZ(); meta.rotationYaw = wrapper.getYaw(); meta.rotationPitch = wrapper.getPitch(); } } // ----------------------------------------------------------------------- // Resend helpers (mirrors Intave redirectValidPacket) // ----------------------------------------------------------------------- private void resendAttackToServer(Player player, int entityId) { // In PacketEvents we inject a synthetic USE_ENTITY packet back into the pipeline // by dispatching the attack via Bukkit's entity damage mechanism as a fallback, // or simply allow the original packet through by not cancelling it. // Since we cancelled the original, we use PacketEvents to send a new one. User user = PacketEvents.getAPI().getPlayerManager().getUser(player); if (user == null) return; WrapperPlayClientInteractEntity resend = new WrapperPlayClientInteractEntity( entityId, WrapperPlayClientInteractEntity.InteractAction.ATTACK, null, InteractionHand.MAIN_HAND, player.isSneaking() ); user.sendPacket(resend); } private void resendArmAnimationToServer(Player player) { User user = PacketEvents.getAPI().getPlayerManager().getUser(player); if (user == null) return; WrapperPlayClientAnimation resend = new WrapperPlayClientAnimation(InteractionHand.MAIN_HAND); user.sendPacket(resend); } // ----------------------------------------------------------------------- // Utility // ----------------------------------------------------------------------- private boolean clientVersionAtLeast(Player player, ClientVersion version) { User user = PacketEvents.getAPI().getPlayerManager().getUser(player); if (user == null) return false; return user.getClientVersion().isNewerThanOrEquals(version); } private double squaredDist(double x1, double y1, double z1, double x2, double y2, double z2) { double dx = x2 - x1, dy = y2 - y1, dz = z2 - z1; return dx * dx + dy * dy + dz * dz; } /** * Resolves hitbox width/height from entity type name. * Mirrors Intave's HitboxSize / EntityTypeData. */ private float[] resolveHitboxSize(String entityTypeName) { if (entityTypeName == null) return new float[]{0.6f, 1.8f}; switch (entityTypeName.toLowerCase()) { case "player": return new float[]{0.6f, 1.8f}; case "zombie": case "skeleton": case "wither_skeleton": case "husk": case "stray": case "drowned": case "zombie_villager": case "pillager": case "vindicator": case "evoker": case "illusioner": return new float[]{0.6f, 1.95f}; case "creeper": return new float[]{0.6f, 1.7f}; case "spider": case "cave_spider": return new float[]{1.4f, 0.9f}; case "enderman": return new float[]{0.6f, 2.9f}; case "blaze": return new float[]{0.6f, 1.8f}; case "witch": return new float[]{0.6f, 1.95f}; case "iron_golem": return new float[]{1.4f, 2.7f}; case "cow": case "mooshroom": return new float[]{0.9f, 1.4f}; case "pig": return new float[]{0.9f, 0.9f}; case "sheep": return new float[]{0.9f, 1.3f}; case "chicken": return new float[]{0.4f, 0.7f}; case "wolf": return new float[]{0.6f, 0.85f}; case "ocelot": case "cat": return new float[]{0.6f, 0.7f}; case "horse": case "donkey": case "mule": case "skeleton_horse": case "zombie_horse": return new float[]{1.3964844f, 1.6f}; case "bat": return new float[]{0.5f, 0.9f}; case "slime": case "magma_cube": return new float[]{2.04f, 2.04f}; case "ghast": return new float[]{4.0f, 4.0f}; case "endermite": case "silverfish": return new float[]{0.4f, 0.3f}; case "guardian": return new float[]{0.85f, 0.85f}; case "elder_guardian": return new float[]{1.9975f, 1.9975f}; case "shulker": return new float[]{1.0f, 1.0f}; case "polar_bear": return new float[]{1.4f, 1.4f}; case "llama": return new float[]{0.9f, 1.87f}; case "parrot": return new float[]{0.5f, 0.9f}; case "rabbit": return new float[]{0.4f, 0.5f}; case "squid": return new float[]{0.8f, 0.8f}; case "turtle": return new float[]{1.2f, 0.4f}; case "phantom": return new float[]{0.9f, 0.5f}; case "cod": case "salmon": case "tropical_fish": case "pufferfish": return new float[]{0.5f, 0.3f}; case "dolphin": return new float[]{0.9f, 0.6f}; case "drowned": return new float[]{0.6f, 1.95f}; case "villager": return new float[]{0.6f, 1.95f}; case "wandering_trader": return new float[]{0.6f, 1.95f}; case "ravager": return new float[]{1.95f, 2.2f}; case "bee": return new float[]{0.7f, 0.6f}; case "hoglin": case "zoglin": return new float[]{1.3964844f, 1.4f}; case "piglin": case "piglin_brute": return new float[]{0.6f, 1.95f}; case "strider": return new float[]{0.9f, 1.7f}; case "axolotl": return new float[]{0.75f, 0.42f}; case "goat": return new float[]{0.9f, 1.3f}; case "glow_squid": return new float[]{0.8f, 0.8f}; case "allay": return new float[]{0.35f, 0.6f}; case "frog": return new float[]{0.5f, 0.55f}; case "tadpole": return new float[]{0.4f, 0.3f}; case "warden": return new float[]{0.9f, 2.9f}; case "camel": return new float[]{1.7f, 2.375f}; case "sniffer": return new float[]{1.9f, 1.75f}; case "breeze": return new float[]{0.6f, 1.77f}; case "armadillo": return new float[]{0.7f, 0.65f}; case "bogged": return new float[]{0.6f, 1.99f}; default: return new float[]{0.6f, 1.8f}; } } private boolean isFireballType(String entityTypeName) { if (entityTypeName == null) return false; String lower = entityTypeName.toLowerCase(); return lower.contains("fireball") || lower.contains("dragon_fireball") || lower.contains("small_fireball") || lower.contains("wither_skull"); } // ----------------------------------------------------------------------- // Inner classes // ----------------------------------------------------------------------- /** * Per-player metadata. Mirrors Intave's AttackRaytraceMeta + relevant MovementMetadata fields. */ private static class PlayerMeta { final List queuedActions = new ArrayList<>(); int flyingPacketCounter = 0; double posX, posY, posZ; double lastPosX, lastPosY, lastPosZ; float rotationYaw, rotationPitch; float lastRotationYaw, lastRotationPitch; int lastTeleportTick = 0; boolean awaitTeleport = false; // mirrors Intave's dropPostTickMotionProcessing boolean dropPostTickMotionProcessing = false; } /** * Tracked server-side entity. Mirrors Intave's Entity with lerp support. */ private static class TrackedEntity { final int entityId; final boolean isPlayer; final boolean isLivingEntity; final boolean isFireball; final float width; final float height; double posX, posY, posZ; double altPosY; // mirrors Intave alternativePosition.posY double lastPosX, lastPosY, lastPosZ; double lastAltPosY; // Lerp target (mirrors Intave newPosX/Y/Z + newPosRotationIncrements) double lerpTargetX, lerpTargetY, lerpTargetZ; int lerpIncrements = 0; boolean destroyed = false; boolean alive = true; boolean isInVehicle = false; volatile boolean clientSynchronized = true; // Mirrors Intave's PendingCountingFeedbackObserver long pendingFeedbackPackets = 0; TrackedEntity(int entityId, double x, double y, double z, boolean isPlayer, boolean isLivingEntity, boolean isFireball, float width, float height) { this.entityId = entityId; this.posX = x; this.posY = y; this.posZ = z; this.altPosY = y; this.lastPosX = x; this.lastPosY = y; this.lastPosZ = z; this.lastAltPosY = y; this.lerpTargetX = x; this.lerpTargetY = y; this.lerpTargetZ = z; this.isPlayer = isPlayer; this.isLivingEntity = isLivingEntity; this.isFireball = isFireball; this.width = width; this.height = height; } /** * Called every server tick. Mirrors Intave Entity.onLivingUpdate() lerp. */ void tick() { if (isLivingEntity && lerpIncrements > 0) { lastPosX = posX; lastPosY = posY; lastPosZ = posZ; lastAltPosY = altPosY; posX += (lerpTargetX - posX) / (double) lerpIncrements; posY += (lerpTargetY - posY) / (double) lerpIncrements; posZ += (lerpTargetZ - posZ) / (double) lerpIncrements; // altPosY mirrors Intave's shiftedNewY calculation altPosY += (lerpTargetY + 0.015625 - altPosY) / (double) lerpIncrements; lerpIncrements--; if (lerpIncrements == 0) { clientSynchronized = true; if (pendingFeedbackPackets > 0) pendingFeedbackPackets--; } } } void setPosition(double x, double y, double z) { lastPosX = posX; lastPosY = posY; lastPosZ = posZ; lastAltPosY = altPosY; posX = x; posY = y; posZ = z; altPosY = y; lerpIncrements = 0; clientSynchronized = true; } void setLerpTarget(double x, double y, double z, int increments) { lerpTargetX = x; lerpTargetY = y; lerpTargetZ = z; lerpIncrements = increments; } double distanceToPlayer(double px, double py, double pz) { double dx = posX - px, dy = posY - py, dz = posZ - pz; return Math.sqrt(dx * dx + dy * dy + dz * dz); } BoundingBox boundingBox() { return new BoundingBox( posX - width / 2.0, posY, posZ - width / 2.0, posX + width / 2.0, posY + height, posZ + width / 2.0 ); } } /** Simple AABB. Mirrors Intave's BoundingBox for raytrace use. */ private static class BoundingBox { final double minX, minY, minZ, maxX, maxY, maxZ; BoundingBox(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { this.minX = minX; this.minY = minY; this.minZ = minZ; this.maxX = maxX; this.maxY = maxY; this.maxZ = maxZ; } } /** Result of a raytrace. */ private static class RaytraceResult { final double reach; RaytraceResult(double reach) { this.reach = reach; } } /** Base queued action (mirrors Intave's Action interface). */ private interface QueuedAction {} /** * Queued attack packet. Mirrors Intave's Attack inner class. */ private static class PendingAttack implements QueuedAction { final int entityId; final boolean shouldResend; final long pendingFeedbackPackets; PendingAttack(int entityId, boolean shouldResend, long pendingFeedbackPackets) { this.entityId = entityId; this.shouldResend = shouldResend; this.pendingFeedbackPackets = pendingFeedbackPackets; } } /** * Queued arm animation. Mirrors Intave's ArmAnimation inner class. */ private static class PendingArmAnimation implements QueuedAction {} }