adding & deleting fence parts fixed

Author: gcclinux

docs/biome-distribution-results.txt

@@ -3,11 +3,14 @@
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.Input;
 import com.badlogic.gdx.graphics.OrthographicCamera;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
 import com.badlogic.gdx.math.Rectangle;
 import com.badlogic.gdx.math.Vector2;
 import com.badlogic.gdx.math.Vector3;
 import java.awt.Point;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Central coordinator for all fence building operations.
@@ -67,6 +70,9 @@ public class FenceBuildingManager {
     /** Flag to indicate building mode was just activated this frame */
     private boolean buildingModeJustActivated = false;
 
+    /** Flag to prevent targeting system interference after direct mouse operations */
+    private boolean suppressTargetingCallback = false;
+    
     /**
      * Creates a new FenceBuildingManager with the specified dependencies.
      * 
@@ -124,6 +130,13 @@ public void update(float deltaTime) {
             enterBuildingMode();
         }
 
+        // Handle clear all fences (C key) when in building mode
+        if (buildingModeActive && Gdx.input.isKeyJustPressed(Input.Keys.C)) {
+            clearAllFences();
+        }
+        
+
+        
         // Only process building input when in building mode and stable
         if (buildingModeActive && !buildingModeJustActivated) {
             processBuildingInput();
@@ -145,6 +158,45 @@ public void renderFences() {
         }
     }
 
+    /**
+     * Renders all fence structures using the provided SpriteBatch.
+     * This ensures proper rendering order with other game elements.
+     * 
+     * @param batch The SpriteBatch to use for rendering
+     */
+    public void renderFences(SpriteBatch batch) {
+        if (structureManager == null) {
+            return;
+        }
+        
+        Map<Point, FencePiece> allPieces = structureManager.getAllFencePieces();
+        if (allPieces.isEmpty()) {
+            return;
+        }
+        
+        // Get the texture atlas from the fence renderer
+        FenceTextureAtlas textureAtlas = null;
+        if (fenceRenderer != null) {
+            textureAtlas = fenceRenderer.getTextureAtlas();
+        }
+        
+        if (textureAtlas == null || !textureAtlas.isInitialized()) {
+            System.err.println("[FenceBuildingManager] Texture atlas not available for rendering");
+            return;
+        }
+        
+        // Render all fence pieces using the main batch
+        for (FencePiece piece : allPieces.values()) {
+            TextureRegion region = textureAtlas.getTextureRegion(piece.getType());
+            if (region != null) {
+                batch.draw(region, piece.getX(), piece.getY(), 
+                          textureAtlas.getPieceSize(), textureAtlas.getPieceSize());
+            } else {
+                System.err.println("[FenceBuildingManager] No texture region for " + piece.getType());
+            }
+        }
+    }
+    
     /**
      * Renders visual effects for fence building operations.
      * Should be called during the rendering phase.
@@ -174,6 +226,7 @@ public void toggleBuildingMode() {
      * Validates material availability before allowing entry.
      */
     private void enterBuildingMode() {
+
         // Check if player has any fence materials
         FenceMaterialProvider materialProvider = validator.getMaterialProvider();
         if (materialProvider != null) {
@@ -203,6 +256,8 @@ private void enterBuildingMode() {
 
         System.out.println("[FenceBuildingManager] Entered fence building mode - Press " + Input.Keys.toString(buildingModeToggleKey) + " to exit");
         System.out.println("[FenceBuildingManager] Left click to place fence, Right click to remove fence");
+        System.out.println("[FenceBuildingManager] Press C to clear all fences");
+
         System.out.println("[FenceBuildingManager] Current material: " + selectedMaterialType.getDisplayName());
         System.out.println("[FenceBuildingManager] State: buildingModeActive=" + buildingModeActive + 
                          ", buildingModeJustActivated=" + buildingModeJustActivated + 
@@ -245,6 +300,23 @@ private void processBuildingInput() {
         Vector3 mousePos = new Vector3(Gdx.input.getX(), Gdx.input.getY(), 0);
         camera.unproject(mousePos);
 
+        // Constrain fence placement to be within reasonable distance from camera (viewport area)
+        float maxDistance = Math.min(camera.viewportWidth, camera.viewportHeight) / 2f; // Half viewport size
+        float cameraX = camera.position.x;
+        float cameraY = camera.position.y;
+        
+        // Calculate distance from camera center
+        float dx = mousePos.x - cameraX;
+        float dy = mousePos.y - cameraY;
+        float distance = (float) Math.sqrt(dx * dx + dy * dy);
+        
+        // If click is too far from camera, clamp it to viewport area
+        if (distance > maxDistance) {
+            float ratio = maxDistance / distance;
+            mousePos.x = cameraX + dx * ratio;
+            mousePos.y = cameraY + dy * ratio;
+        }
+        
         // Convert to grid coordinates
         Point gridPos = structureManager.getGrid().worldToGrid(mousePos.x, mousePos.y);
 
@@ -255,15 +327,19 @@ private void processBuildingInput() {
 
         // Handle placement (left click)
         if (leftClicked) {
+            System.out.println("[FenceBuildingManager] Left click detected at grid (" + gridPos.x + ", " + gridPos.y + ")");
             if (placeFenceSegment(gridPos.x, gridPos.y)) {
                 lastProcessedGridPos = new Point(gridPos.x, gridPos.y);
             }
         }
 
         // Handle removal (right click)
         if (rightClicked) {
+            System.out.println("[FenceBuildingManager] Right click detected at grid (" + gridPos.x + ", " + gridPos.y + ")");
             if (removeFenceSegment(gridPos.x, gridPos.y)) {
                 lastProcessedGridPos = new Point(gridPos.x, gridPos.y);
+                // Suppress targeting system callback to prevent immediate replacement
+                suppressTargetingCallback = true;
             }
         }
 
@@ -304,10 +380,12 @@ public boolean placeFenceSegment(int gridX, int gridY) {
         }
 
         try {
+            System.out.println("[FenceBuildingManager] Attempting to place fence at grid (" + gridPos.x + ", " + gridPos.y + ") with material " + selectedMaterialType);
             // Attempt to place the fence piece with automatic piece type selection
             FencePiece placedPiece = structureManager.addFencePiece(gridPos, selectedMaterialType);
 
             if (placedPiece != null) {
+                System.out.println("[FenceBuildingManager] Fence piece created: " + placedPiece.getType() + " at world (" + placedPiece.getX() + ", " + placedPiece.getY() + ")");
                 // Consume materials from inventory
                 FenceMaterialProvider materialProvider = validator.getMaterialProvider();
                 if (materialProvider != null) {
@@ -553,6 +631,18 @@ public boolean wasBuildingModeJustActivated() {
         return buildingModeJustActivated;
     }
 
+    /**
+     * Checks if targeting system callbacks should be suppressed.
+     * Used to prevent targeting system interference after direct mouse operations.
+     * 
+     * @return true if targeting callbacks should be suppressed, false otherwise
+     */
+    public boolean shouldSuppressTargetingCallback() {
+        boolean suppress = suppressTargetingCallback;
+        suppressTargetingCallback = false; // Reset flag after checking
+        return suppress;
+    }
+    
     /**
      * Gets the currently selected material type.
      * 
@@ -733,6 +823,26 @@ private void updateCollisionBoundaries(Point gridPos, boolean placed) {
         }
     }
 
+    /**
+     * Clears all fence pieces from the world.
+     * Useful for debugging and testing.
+     */
+    public void clearAllFences() {
+        if (structureManager != null) {
+            int fenceCount = structureManager.getFencePieceCount();
+            structureManager.clear();
+            
+            // Clear collision boundaries
+            if (collisionManager != null) {
+                collisionManager.clear();
+            }
+            
+            System.out.println("[FenceBuildingManager] Cleared " + fenceCount + " fence pieces");
+        }
+    }
+    
+
+    
     /**
      * Disposes of resources used by this manager.
      */

fence_texture_grid_analysis.md docs/fence_texture_grid_analysis.mdfence_texture_grid_analysis.md renamed to docs/fence_texture_grid_analysis.md

@@ -103,6 +103,7 @@ private void updateViewportBounds() {
      */
     public void render(FenceStructureManager structureManager) {
         if (!textureAtlas.isInitialized()) {
+            System.err.println("[FenceRenderer] Texture atlas not initialized - cannot render fences");
             return;
         }
 
@@ -115,6 +116,8 @@ public void render(FenceStructureManager structureManager) {
             return;
         }
 
+        System.out.println("[FenceRenderer] Rendering " + allPieces.size() + " fence pieces");
+        
         // Begin batch rendering
         spriteBatch.begin();
 
@@ -126,8 +129,10 @@ public void render(FenceStructureManager structureManager) {
             if (isInViewport(piece)) {
                 renderPiece(piece);
                 rendered++;
+                System.out.println("[FenceRenderer] Rendered " + piece.getType() + " at (" + piece.getX() + ", " + piece.getY() + ")");
             } else {
                 culled++;
+                System.out.println("[FenceRenderer] Culled " + piece.getType() + " at (" + piece.getX() + ", " + piece.getY() + ") - outside viewport");
             }
         }
 
@@ -136,6 +141,8 @@ public void render(FenceStructureManager structureManager) {
         // Update statistics
         renderedPiecesLastFrame = rendered;
         culledPiecesLastFrame = culled;
+        
+        System.out.println("[FenceRenderer] Rendered: " + rendered + ", Culled: " + culled);
     }
 
     /**
@@ -192,12 +199,21 @@ private void renderPiece(FencePiece piece) {
      */
     private boolean isInViewport(FencePiece piece) {
         if (camera == null) {
+            System.out.println("[FenceRenderer] No camera - rendering all pieces");
             return true; // No culling if no camera
         }
 
         float pieceSize = textureAtlas.getPieceSize();
         Rectangle pieceRect = new Rectangle(piece.getX(), piece.getY(), pieceSize, pieceSize);
-        return viewportBounds.overlaps(pieceRect);
+        boolean inViewport = viewportBounds.overlaps(pieceRect);
+        
+        if (!inViewport) {
+            System.out.println("[FenceRenderer] Piece at (" + piece.getX() + ", " + piece.getY() + ") outside viewport bounds: " + 
+                             "viewport=(" + viewportBounds.x + ", " + viewportBounds.y + ", " + viewportBounds.width + ", " + viewportBounds.height + "), " +
+                             "camera=(" + camera.position.x + ", " + camera.position.y + ")");
+        }
+        
+        return inViewport;
     }
 
     /**

src/main/java/wagemaker/uk/fence/FenceBuildingManager.java

@@ -49,15 +49,15 @@ public FenceSoundManager(float volume) {
     private void loadSounds() {
         try {
             // Load placement sound
-            placementSound = Gdx.audio.newSound(Gdx.files.internal("sound/fence_place.wav"));
+            placementSound = Gdx.audio.newSound(Gdx.files.internal("sound/fence_place.mp3"));
             System.out.println("[FENCE] Placement sound loaded successfully");
 
             // Load removal sound
-            removalSound = Gdx.audio.newSound(Gdx.files.internal("sound/fence_remove.wav"));
+            removalSound = Gdx.audio.newSound(Gdx.files.internal("sound/fence_remove.mp3"));
             System.out.println("[FENCE] Removal sound loaded successfully");
 
             // Load error sound
-            errorSound = Gdx.audio.newSound(Gdx.files.internal("sound/fence_error.wav"));
+            errorSound = Gdx.audio.newSound(Gdx.files.internal("sound/fence_error.mp3"));
             System.out.println("[FENCE] Error sound loaded successfully");
 
             soundsLoaded = true;

src/main/java/wagemaker/uk/fence/FenceRenderer.java

@@ -860,9 +860,9 @@ public void render() {
         drawAppleTrees();
         drawBananaTrees();
 
-        // Render fence structures
+        // Render fence structures using main batch
         if (fenceBuildingManager != null) {
-            fenceBuildingManager.renderFences();
+            fenceBuildingManager.renderFences(batch);
         }
 
         batch.end();

src/main/java/wagemaker/uk/fence/FenceSoundManager.java

@@ -1946,6 +1946,12 @@ private void activateFenceTargeting() {
                 targetingSystem.activate(x, y, wagemaker.uk.targeting.TargetingMode.ADJACENT, new wagemaker.uk.targeting.TargetingCallback() {
                     @Override
                     public void onTargetConfirmed(float targetX, float targetY) {
+                        // Check if targeting callback should be suppressed (e.g., after direct mouse removal)
+                        wagemaker.uk.fence.FenceBuildingManager fenceBuildingManager = getFenceBuildingManager();
+                        if (fenceBuildingManager != null && fenceBuildingManager.shouldSuppressTargetingCallback()) {
+                            System.out.println("Suppressing targeting callback after direct mouse operation");
+                            return;
+                        }
                         handleFencePlacement(targetX, targetY);
                     }
 
@@ -2198,6 +2204,12 @@ private void handleTargetingInput() {
 
                 // Handle placement based on current navigation mode
                 if (fenceNavigationMode) {
+                    // Check if targeting callback should be suppressed
+                    wagemaker.uk.fence.FenceBuildingManager fenceBuildingManager = getFenceBuildingManager();
+                    if (fenceBuildingManager != null && fenceBuildingManager.shouldSuppressTargetingCallback()) {
+                        System.out.println("Suppressing fence placement after direct mouse operation");
+                        return;
+                    }
                     handleFencePlacement(coords[0], coords[1]);
                 } else {
                     handleItemPlacement(coords[0], coords[1]);
@@ -2248,6 +2260,12 @@ private void handleSpacebarPlanting() {
 
             // Handle placement based on current navigation mode
             if (fenceNavigationMode) {
+                // Check if targeting callback should be suppressed
+                wagemaker.uk.fence.FenceBuildingManager fenceBuildingManager = getFenceBuildingManager();
+                if (fenceBuildingManager != null && fenceBuildingManager.shouldSuppressTargetingCallback()) {
+                    System.out.println("Suppressing fence placement after direct mouse operation");
+                    return;
+                }
                 handleFencePlacement(coords[0], coords[1]);
             } else {
                 handleItemPlacement(coords[0], coords[1]);