Fix the check for the blueprints placed mid air

Author: remmintan

src/main/java/org/minefortress/blueprints/manager/BaseClientStructureManager.java

@@ -54,17 +54,18 @@ public void tick() {
 
         // For upgrading logic
         if (this instanceof ClientBlueprintManager clientBlueprintManager && clientBlueprintManager.isUpgrading()) {
-            checkIntersectUpgradingBuilding(); // This might set cantBuild = true (via intersectsUpgradingBuilding)
-            if (!intersectsUpgradingBuilding) {
+            checkIntersectUpgradingBuilding(); // This sets the 'intersectsUpgradingBuilding' field
+            if (!intersectsUpgradingBuilding) { // If checkIntersectUpgradingBuilding resulted in false for an upgrade
                 cantBuild = true;
             }
-            if (cantBuild) return; // Early exit if upgrade intersection fails
+            if (cantBuild) return; // Early exit if upgrade intersection fails or other reasons
         } else {
-            intersectsUpgradingBuilding = true; // Default to true if not upgrading
+            // If not upgrading, intersectsUpgradingBuilding is generally true (no failure due to intersection).
+            // This prevents "doesn't intersect" warnings/logic when not in upgrade mode.
+            intersectsUpgradingBuilding = true;
         }
 
-
-        checkPlacementValidity(); // Combined check for leaves, surface collision, and sub-floor validity
+        checkPlacementValidity(); // Combined check for leaves, surface collision, sub-floor validity, and air under floor
     }
     protected BlockPos getStructureBuildPos() {
         return structureBuildPos;
@@ -91,96 +92,147 @@ private void checkNotEnoughResources() {
     }
 
     private void checkPlacementValidity() {
-        if (cantBuild) return; // If already marked as can't build (e.g. due to resources), skip further checks
+        if (cantBuild) return; // If already marked as can't build (e.g., due to resources), skip further checks
+        if (this.client.world == null || structureBuildPos == null) { // Essential objects check
+            cantBuild = true;
+            return;
+        }
 
         final IStructureBlockData blockData = getBlockData();
-        final Set<BlockPos> blueprintDataPositions = blockData.getLayer(BlueprintDataLayer.GENERAL)
+        final BlueprintMetadata selectedStructure = getSelectedStructure();
+        if (selectedStructure == null) { // Should be caught by isSelecting or resource check, but for safety
+            cantBuild = true;
+            return;
+        }
+
+        // Get all non-air block positions from the blueprint in its local coordinate system
+        final Set<BlockPos> blueprintNonAirLocalPositions = blockData.getLayer(BlueprintDataLayer.GENERAL)
                 .entrySet()
                 .stream()
-                .filter(entry -> !entry.getValue().isAir()) // Only consider non-air blocks from the blueprint
+                .filter(entry -> !entry.getValue().isAir())
                 .map(Map.Entry::getKey)
                 .collect(Collectors.toSet());
 
-        final int floorLevel = getSelectedStructure().getFloorLevel();
-        final Vec3i size = blockData.getSize(); // For leaves check
+        final int floorLevel = selectedStructure.getFloorLevel();
+        final Vec3i blueprintSize = blockData.getSize();
 
         // 1. Check for leaves directly under the blueprint's entire footprint
-        final int groundYInWorld = structureBuildPos.getY() - floorLevel - 1;
-        for (int dx = 0; dx < size.getX(); dx++) {
-            for (int dz = 0; dz < size.getZ(); dz++) {
-                BlockPos currentGroundPos = new BlockPos(
+        // The footprint ground level is 1 Y-level below the blueprint's origin (Y=0).
+        // World Y for blueprint's Y=0 is structureBuildPos.getY() - floorLevel.
+        // So, ground check Y is structureBuildPos.getY() - floorLevel - 1.
+        final int groundYInWorldForLeavesCheck = structureBuildPos.getY() - floorLevel - 1;
+        // Iterate over the footprint of the blueprint in world coordinates
+        for (int dx = 0; dx < blueprintSize.getX(); dx++) {
+            for (int dz = 0; dz < blueprintSize.getZ(); dz++) {
+                // structureBuildPos.getX/Z() is minX/Z of structure in world.
+                BlockPos currentPosUnderFootprint = new BlockPos(
                         structureBuildPos.getX() + dx,
-                        groundYInWorld,
+                        groundYInWorldForLeavesCheck,
                         structureBuildPos.getZ() + dz
                 );
-                if (this.client.world != null) {
-                    BlockState stateBeneath = this.client.world.getBlockState(currentGroundPos);
-                    if (stateBeneath.isIn(BlockTags.LEAVES)) {
-                        cantBuild = true;
-                        return;
-                    }
+                // client.world.getBlockState handles out-of-bounds Y by returning air/void_air, which are not leaves.
+                BlockState stateBeneath = this.client.world.getBlockState(currentPosUnderFootprint);
+                if (stateBeneath.isIn(BlockTags.LEAVES)) {
+                    cantBuild = true;
+                    return;
                 }
             }
         }
 
-        // 2. Check blocks AT OR ABOVE the blueprint's floor level
+        // 2. NEW: Check for air directly under the blueprint's "floor" blocks.
+        // "Floor" blocks are non-air blueprint blocks at localY == floorLevel.
+        // Their world position is structureBuildPos.add(localX, 0, localZ)
+        // because structureBuildPos.getY() is already the world Y-level of the floor.
+        final boolean airUnderneathFloorBlocks = blueprintNonAirLocalPositions.stream()
+                .filter(bpLocalPos -> bpLocalPos.getY() == floorLevel) // Filter for blueprint's floor surface blocks
+                .map(bpFloorLocalPos -> {
+                    // Calculate world position of this blueprint floor block
+                    BlockPos worldFloorBlockPos = structureBuildPos.add(
+                            bpFloorLocalPos.getX(),
+                            0, // Y-offset is 0 because structureBuildPos.getY() is the world Y for floorLevel
+                            bpFloorLocalPos.getZ()
+                    );
+                    return worldFloorBlockPos.down(); // Get the position directly under it in the world
+                })
+                .anyMatch(posUnderFloor -> {
+                    // client.world.getBlockState handles Y bounds (returns AIR or VOID_AIR, both .isAir())
+                    return BuildingHelper.canPlaceBlock(this.client.world, posUnderFloor);
+                });
+
+        if (airUnderneathFloorBlocks) {
+            cantBuild = true;
+            return;
+        }
+
+        // 3. Check blocks AT OR ABOVE the blueprint's floor level for collisions
         final boolean isUpgrading = (this instanceof ClientBlueprintManager cbm) && cbm.isUpgrading();
         final BlockBox upgradingBox = isUpgrading ? ((ClientBlueprintManager) this).getUpgradingBuildingBox() : null;
 
-        final boolean partAtOrAboveFloorCollides = blueprintDataPositions.stream()
-                .filter(bpLocalPos -> bpLocalPos.getY() >= floorLevel)
-                .map(bpLocalPos -> structureBuildPos.add(bpLocalPos.getX(), bpLocalPos.getY() - floorLevel, bpLocalPos.getZ()))
+        final boolean partAtOrAboveFloorCollides = blueprintNonAirLocalPositions.stream()
+                .filter(bpLocalPos -> bpLocalPos.getY() >= floorLevel) // Consider blueprint blocks at or above its floor
+                .map(bpLocalPos -> structureBuildPos.add(bpLocalPos.getX(), bpLocalPos.getY() - floorLevel, bpLocalPos.getZ())) // Map to world pos
                 .anyMatch(worldPos -> {
-                    boolean currentCanBuild = BuildingHelper.canPlaceBlock(client.world, worldPos);
-                    if (isUpgrading && upgradingBox != null) {
-                        currentCanBuild = currentCanBuild || upgradingBox.contains(worldPos);
+                    boolean currentCanPlace = BuildingHelper.canPlaceBlock(client.world, worldPos);
+                    if (isUpgrading && upgradingBox != null && upgradingBox.contains(worldPos)) {
+                        // If upgrading, and this block is part of the existing structure, it's "placeable" in context.
+                        currentCanPlace = true;
                     }
-                    return !currentCanBuild; // if !canPlace (and not part of upgrade), then it collides
+                    return !currentCanPlace; // Collision if cannot place (and not an allowed overlap during upgrade)
                 });
 
         if (partAtOrAboveFloorCollides) {
             cantBuild = true;
             return;
         }
 
-        // 3. Check blocks BELOW the blueprint's floor level
-        final boolean partBelowFloorInvalid = blueprintDataPositions.stream()
-                .filter(bpLocalPos -> bpLocalPos.getY() < floorLevel)
-                .map(bpLocalPos -> structureBuildPos.add(bpLocalPos.getX(), bpLocalPos.getY() - floorLevel, bpLocalPos.getZ()))
-                .anyMatch(worldPos -> BuildingHelper.canPlaceBlock(client.world, worldPos));
+        // 4. Check blocks BELOW the blueprint's floor level (foundation/sub-structure parts)
+        // Original logic: These parts must NOT be placeable into air/replaceable blocks,
+        // i.e., they must be placed into solid, non-replaceable ground.
+        final boolean partBelowFloorInvalid = blueprintNonAirLocalPositions.stream()
+                .filter(bpLocalPos -> bpLocalPos.getY() < floorLevel) // Consider blueprint blocks below its floor
+                .map(bpLocalPos -> structureBuildPos.add(bpLocalPos.getX(), bpLocalPos.getY() - floorLevel, bpLocalPos.getZ())) // Map to world pos
+                .anyMatch(worldPos -> BuildingHelper.canPlaceBlock(client.world, worldPos)); // Invalid if it *can* be placed (i.e., targets air/replaceable)
 
         if (partBelowFloorInvalid) {
             cantBuild = true;
-            // No return here, as we've already checked other conditions that might set cantBuild
+            // Original code does not return here, allowing cantBuild to be set and fall through.
+            // This is fine as canBuild() will reflect the final state of cantBuild.
         }
     }
 
 
-    private void checkIntersectUpgradingBuilding() { // This method is only relevant if isUpgrading is true
+    private void checkIntersectUpgradingBuilding() {
         if (!(this instanceof ClientBlueprintManager cbm) || !cbm.isUpgrading()) {
-            intersectsUpgradingBuilding = true; // Not upgrading, so no intersection issue by default
+            intersectsUpgradingBuilding = true;
             return;
         }
 
-        if (!enoughResources) { // If not enough resources, intersection check is moot for buildability
-            intersectsUpgradingBuilding = false;
+        if (!enoughResources) {
+            intersectsUpgradingBuilding = false; // As per original logic, if not enough resources, it's marked as not intersecting for UI/logic consistency.
             return;
         }
 
         final IStructureBlockData blockData = getBlockData();
+        final BlueprintMetadata selectedStructure = getSelectedStructure();
+        if (selectedStructure == null) { // Safety check
+            intersectsUpgradingBuilding = false;
+            return;
+        }
         final Set<BlockPos> blueprintDataPositions = blockData.getLayer(BlueprintDataLayer.GENERAL)
                 .entrySet()
                 .stream()
                 .filter(entry -> !entry.getValue().isAir())
                 .map(Map.Entry::getKey)
                 .collect(Collectors.toSet());
-        final int floorLevel = getSelectedStructure().getFloorLevel();
+        final int floorLevel = selectedStructure.getFloorLevel();
         final BlockBox upgradingBuildingBox = cbm.getUpgradingBuildingBox();
+        if (upgradingBuildingBox == null) { // Should ideally not happen if cbm.isUpgrading() is true and a valid building is targeted
+            intersectsUpgradingBuilding = false;
+            return;
+        }
 
-        // An upgrade is valid if at least one block of the new blueprint (at or above its floor)
-        // intersects with the existing building's box.
         intersectsUpgradingBuilding = blueprintDataPositions.stream()
-                .filter(bpLocalPos -> bpLocalPos.getY() >= floorLevel) // Consider blocks at or above the blueprint's designated floor for intersection
+                .filter(bpLocalPos -> bpLocalPos.getY() >= floorLevel)
                 .map(bpLocalPos -> structureBuildPos.add(bpLocalPos.getX(), bpLocalPos.getY() - floorLevel, bpLocalPos.getZ()))
                 .anyMatch(upgradingBuildingBox::contains);
     }
@@ -198,18 +250,17 @@ private IStructureBlockData getBlockData() {
     private BlockPos getSelectedPos() {
         if (client.crosshairTarget instanceof final BlockHitResult crosshairTarget && this instanceof ClientBlueprintManager cbm) {
             final BlockPos originalPos = crosshairTarget.getBlockPos();
-            if (client.world == null || originalPos == null) return null; // Ensure world is not null
+            if (client.world == null || originalPos == null) return null;
 
             final BlockState blockState = client.world.getBlockState(originalPos);
-            if (blockState.isAir() && !cbm.isUpgrading()) return null; // Can't start placement on air unless upgrading
+            if (blockState.isAir() && !cbm.isUpgrading()) return null;
 
             var movedPos = originalPos;
-            final BlockBox upgradingBuildingBox = cbm.getUpgradingBuildingBox(); // Can be null if not upgrading
+            final BlockBox upgradingBuildingBox = cbm.isUpgrading() ? cbm.getUpgradingBuildingBox() : null;
             final boolean intersectingWithTheBuilding = cbm.isUpgrading() && upgradingBuildingBox != null &&
                     (upgradingBuildingBox.contains(originalPos) || blockState.isOf(FortressBlocks.FORTRESS_BUILDING));
 
             if (intersectingWithTheBuilding) {
-                // Align Y with the bottom of the existing building box if upgrading
                 movedPos = new BlockPos(movedPos.getX(), upgradingBuildingBox.getMinY(), movedPos.getZ());
             }
 
@@ -240,6 +291,8 @@ public final Optional<BlockPos> getStructureRenderPos() {
         final var selected = getSelectedStructure();
         if (selected == null) return Optional.empty();
         final var floorLevel = selected.getFloorLevel();
+        // structureBuildPos.getY() is world Y for blueprint's floorLevel.
+        // structureBuildPos.down(floorLevel) results in world Y for blueprint's Y=0.
         return Optional.ofNullable(structureBuildPos).map(it -> it.down(floorLevel));
     }