MP fense ownership and resource monitor by server

gcclinux · gcclinux · commit 06127459d756 · 2025-12-13T14:12:00.000Z
diff --git a/src/main/java/wagemaker/uk/fence/FenceBuildingManager.java b/src/main/java/wagemaker/uk/fence/FenceBuildingManager.java
@@ -77,19 +77,25 @@ public class FenceBuildingManager {
     /** Flag to disable direct mouse input when targeting system is handling input */
     private boolean disableDirectMouseInput = false;
     
+    /** Player reference for ownership tracking */
+    private final wagemaker.uk.player.Player player;
+    
     /**
      * Creates a new FenceBuildingManager with the specified dependencies.
      * 
      * @param structureManager Manager for fence structure data
      * @param validator Validator for placement operations
      * @param camera Camera for input coordinate conversion
+     * @param player The player instance for ownership tracking
      */
     public FenceBuildingManager(FenceStructureManager structureManager, 
                                FencePlacementValidator validator,
-                               OrthographicCamera camera) {
+                               OrthographicCamera camera,
+                               wagemaker.uk.player.Player player) {
         this.structureManager = structureManager;
         this.validator = validator;
         this.camera = camera;
+        this.player = player;
         this.buildingModeActive = false;
         this.selectedMaterialType = FenceMaterialType.WOOD; // Default material
         this.lastProcessedGridPos = null;
@@ -109,6 +115,15 @@ public FenceBuildingManager(FenceStructureManager structureManager,
         // Visual effects manager will be set externally since it requires ShapeRenderer
     }
     
+    /**
+     * Gets the player instance associated with this manager.
+     * 
+     * @return The player instance
+     */
+    public wagemaker.uk.player.Player getPlayer() {
+        return player;
+    }
+    
     /**
      * Updates the fence building manager, processing input and managing state.
      * Should be called every frame when the game is active.
@@ -373,9 +388,15 @@ private void processBuildingInput() {
     public boolean placeFenceSegment(int gridX, int gridY) {
         Point gridPos = new Point(gridX, gridY);
         
+        String playerId = player.getPlayerId();
+        // Fallback for single player or during initialization
+        if (playerId == null) {
+            playerId = "local_player";
+        }
+        
         // Validate placement with comprehensive error handling
         FencePlacementValidator.ValidationResult result = 
-            validator.validatePlacement(gridPos, selectedMaterialType, "local_player");
+            validator.validatePlacement(gridPos, selectedMaterialType, playerId);
         
         if (!result.isValid()) {
             // Provide detailed error feedback to the user
@@ -392,9 +413,9 @@ 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);
+            System.out.println("[FenceBuildingManager] Attempting to place fence at grid (" + gridPos.x + ", " + gridPos.y + ") with material " + selectedMaterialType + " for owner " + playerId);
             // Attempt to place the fence piece with automatic piece type selection
-            FencePiece placedPiece = structureManager.addFencePiece(gridPos, selectedMaterialType);
+            FencePiece placedPiece = structureManager.addFencePiece(gridPos, selectedMaterialType, playerId);
             
             if (placedPiece != null) {
                 System.out.println("[FenceBuildingManager] Fence piece created: " + placedPiece.getType() + " at world (" + placedPiece.getX() + ", " + placedPiece.getY() + ")");
@@ -492,9 +513,15 @@ private void displayPlacementSuccess(FencePiece placedPiece, Point gridPos) {
     public boolean removeFenceSegment(int gridX, int gridY) {
         Point gridPos = new Point(gridX, gridY);
         
+        String playerId = player.getPlayerId();
+        // Fallback for single player or during initialization
+        if (playerId == null) {
+            playerId = "local_player";
+        }
+        
         // Validate removal with comprehensive error handling
         FencePlacementValidator.ValidationResult result = 
-            validator.validateRemoval(gridPos, "local_player");
+            validator.validateRemoval(gridPos, playerId);
         
         if (!result.isValid()) {
             displayRemovalError(result.getErrorMessage(), gridPos);
diff --git a/src/main/java/wagemaker/uk/fence/FenceEnclosureData.java b/src/main/java/wagemaker/uk/fence/FenceEnclosureData.java
@@ -54,7 +54,7 @@ public FenceEnclosureData(Rectangle bounds, FenceMaterialType materialType,
         
         // Convert fence pieces to serializable data
         for (FencePiece piece : pieces) {
-            pieceData.add(new FencePieceData(piece.getX(), piece.getY(), piece.getType()));
+            pieceData.add(new FencePieceData(piece.getX(), piece.getY(), piece.getType(), piece.getOwnerId()));
         }
     }
     
@@ -68,7 +68,7 @@ public FenceEnclosure toFenceEnclosure() {
         
         // Recreate fence pieces from data
         for (FencePieceData data : pieceData) {
-            FencePiece piece = FencePieceFactory.createPiece(data.type, data.x, data.y);
+            FencePiece piece = FencePieceFactory.createPiece(data.type, data.x, data.y, data.ownerId);
             pieces.add(piece);
         }
         
@@ -121,6 +121,7 @@ public static class FencePieceData implements Serializable {
         
         public float x, y;
         public FencePieceType type;
+        public String ownerId;
         
         /**
          * Default constructor for serialization.
@@ -135,9 +136,22 @@ public FencePieceData() {}
          * @param type Fence piece type
          */
         public FencePieceData(float x, float y, FencePieceType type) {
+            this(x, y, type, null);
+        }
+
+        /**
+         * Creates fence piece data with owner.
+         * 
+         * @param x World X coordinate
+         * @param y World Y coordinate
+         * @param type Fence piece type
+         * @param ownerId Owner ID
+         */
+        public FencePieceData(float x, float y, FencePieceType type, String ownerId) {
             this.x = x;
             this.y = y;
             this.type = type;
+            this.ownerId = ownerId;
         }
         
         /**
diff --git a/src/main/java/wagemaker/uk/fence/FencePersistenceManager.java b/src/main/java/wagemaker/uk/fence/FencePersistenceManager.java
@@ -129,7 +129,7 @@ public static int deserializeFenceStructures(List<FenceEnclosureData> serialized
                     
                     // Create and place the fence piece
                     try {
-                        FencePiece piece = FencePieceFactory.createPiece(pieceData.type, pieceData.x, pieceData.y);
+                        FencePiece piece = FencePieceFactory.createPiece(pieceData.type, pieceData.x, pieceData.y, pieceData.ownerId);
                         
                         // Create the fence piece and add it for restoration
                         boolean added = structureManager.addFencePieceForRestore(gridPos, piece);
diff --git a/src/main/java/wagemaker/uk/fence/FencePiece.java b/src/main/java/wagemaker/uk/fence/FencePiece.java
@@ -18,16 +18,30 @@ public abstract class FencePiece {
     protected static final int PIECE_SIZE = 64; // 64x64 pixel pieces
     protected static final String TEXTURE_PATH = "textures/fense.png";
 
+    protected String ownerId;
+
     /**
      * Creates a new fence piece at the specified position.
      * @param x World X coordinate
      * @param y World Y coordinate
      * @param type The type of fence piece
      */
     public FencePiece(float x, float y, FencePieceType type) {
+        this(x, y, type, null);
+    }
+
+    /**
+     * Creates a new fence piece at the specified position with ownership.
+     * @param x World X coordinate
+     * @param y World Y coordinate
+     * @param type The type of fence piece
+     * @param ownerId The ID of the owner of this fence piece
+     */
+    public FencePiece(float x, float y, FencePieceType type, String ownerId) {
         this.x = x;
         this.y = y;
         this.type = type;
+        this.ownerId = ownerId;
         loadTexture();
     }
 
@@ -142,6 +156,22 @@ public Texture getTexture() {
         return texture;
     }
 
+    /**
+     * Gets the owner ID of this fence piece.
+     * @return Owner ID, or null if not set
+     */
+    public String getOwnerId() {
+        return ownerId;
+    }
+
+    /**
+     * Sets the owner ID of this fence piece.
+     * @param ownerId New owner ID
+     */
+    public void setOwnerId(String ownerId) {
+        this.ownerId = ownerId;
+    }
+
     /**
      * Disposes of the texture resources used by this fence piece.
      * Should be called when the fence piece is no longer needed.
diff --git a/src/main/java/wagemaker/uk/fence/FencePieceFactory.java b/src/main/java/wagemaker/uk/fence/FencePieceFactory.java
@@ -42,6 +42,20 @@ public static FencePiece createPiece(FencePieceType type, float x, float y) {
                 throw new IllegalArgumentException("Unknown fence piece type: " + type);
         }
     }
+
+    /**
+     * Creates a fence piece of the specified type at the given position with ownership.
+     * @param type The type of fence piece to create
+     * @param x World X coordinate
+     * @param y World Y coordinate
+     * @param ownerId The ID of the owner
+     * @return A new FencePiece instance of the specified type
+     */
+    public static FencePiece createPiece(FencePieceType type, float x, float y, String ownerId) {
+        FencePiece piece = createPiece(type, x, y);
+        piece.setOwnerId(ownerId);
+        return piece;
+    }
     
     /**
      * Gets the sequence of fence piece types needed for a rectangular enclosure.
diff --git a/src/main/java/wagemaker/uk/fence/FencePlacementValidator.java b/src/main/java/wagemaker/uk/fence/FencePlacementValidator.java
@@ -180,9 +180,17 @@ private ValidationResult validateRemovalOwnership(Point gridPos, String playerId
         }
         
         // Check if the piece belongs to the player
-        // For now, we'll allow all removals - in a full implementation,
-        // we'd check the piece's owner against the playerId
-        // This is a placeholder for future ownership tracking
+        String pieceOwner = piece.getOwnerId();
+        
+        // If piece has no owner, allow removal (or could be restricted based on game rules)
+        if (pieceOwner == null) {
+            return ValidationResult.valid();
+        }
+        
+        // Check if the requesting player is the owner
+        if (!pieceOwner.equals(playerId)) {
+            return ValidationResult.invalid("You cannot remove this fence because you do not own it");
+        }
         
         return ValidationResult.valid();
     }
diff --git a/src/main/java/wagemaker/uk/fence/FenceStructureManager.java b/src/main/java/wagemaker/uk/fence/FenceStructureManager.java
@@ -54,6 +54,16 @@ public FenceStructureManager(FenceGrid grid) {
             "manager_" + System.identityHashCode(this), this);
     }
     
+    /**
+     * Adds a fence piece at the specified grid position.
+     * Automatically determines the correct piece type based on adjacent pieces.
+     * Updates connections with adjacent pieces.
+     * 
+     * @param gridPos Grid position where to place the fence piece
+     * @param materialType Type of material to use for the fence piece
+     * @return The created FencePiece, or null if placement failed
+     * @throws IllegalArgumentException if the position is already occupied
+     */
     /**
      * Adds a fence piece at the specified grid position.
      * Automatically determines the correct piece type based on adjacent pieces.
@@ -65,6 +75,21 @@ public FenceStructureManager(FenceGrid grid) {
      * @throws IllegalArgumentException if the position is already occupied
      */
     public FencePiece addFencePiece(Point gridPos, FenceMaterialType materialType) {
+        return addFencePiece(gridPos, materialType, null);
+    }
+
+    /**
+     * Adds a fence piece at the specified grid position with ownership.
+     * Automatically determines the correct piece type based on adjacent pieces.
+     * Updates connections with adjacent pieces.
+     * 
+     * @param gridPos Grid position where to place the fence piece
+     * @param materialType Type of material to use for the fence piece
+     * @param ownerId ID of the player who owns this fence piece
+     * @return The created FencePiece, or null if placement failed
+     * @throws IllegalArgumentException if the position is already occupied
+     */
+    public FencePiece addFencePiece(Point gridPos, FenceMaterialType materialType, String ownerId) {
         if (placedFences.containsKey(gridPos)) {
             throw new IllegalArgumentException("Position " + gridPos + " is already occupied");
         }
@@ -81,7 +106,7 @@ public FencePiece addFencePiece(Point gridPos, FenceMaterialType materialType) {
         com.badlogic.gdx.math.Vector2 worldPos = grid.gridToWorld(gridPos);
         
         // Create the fence piece
-        FencePiece piece = FencePieceFactory.createPiece(pieceType, worldPos.x, worldPos.y);
+        FencePiece piece = FencePieceFactory.createPiece(pieceType, worldPos.x, worldPos.y, ownerId);
         
         // Add to our data structures
         placedFences.put(new Point(gridPos.x, gridPos.y), piece);
@@ -291,9 +316,9 @@ private void replacePieceType(Point gridPos, FencePieceType newType) {
             return; // Nothing to replace
         }
         
-        // Create new piece with the same position
+        // Create new piece with the same position and owner
         com.badlogic.gdx.math.Vector2 worldPos = grid.gridToWorld(gridPos);
-        FencePiece newPiece = FencePieceFactory.createPiece(newType, worldPos.x, worldPos.y);
+        FencePiece newPiece = FencePieceFactory.createPiece(newType, worldPos.x, worldPos.y, oldPiece.getOwnerId());
         
         // Replace in the map
         placedFences.put(gridPos, newPiece);
@@ -427,7 +452,13 @@ private void createEnclosure(Set<Point> positions, Rectangle bounds) {
             }
         }
         
-        FenceEnclosure enclosure = new FenceEnclosure(bounds, pieces, FenceMaterialType.WOOD);
+        String ownerId = null;
+        if (!pieces.isEmpty()) {
+            ownerId = pieces.get(0).getOwnerId();
+            // Verify all pieces have the same owner? Optional but good practice.
+        }
+        
+        FenceEnclosure enclosure = new FenceEnclosure(bounds, pieces, FenceMaterialType.WOOD, ownerId);
         enclosures.add(enclosure);
     }
     
diff --git a/src/main/java/wagemaker/uk/gdx/MyGdxGame.java b/src/main/java/wagemaker/uk/gdx/MyGdxGame.java
@@ -460,7 +460,7 @@ public void create() {
         FenceMaterialProvider fenceMaterialProvider = new InventoryFenceMaterialProvider(inventoryManager);
         FencePlacementValidator fencePlacementValidator = new FencePlacementValidator(fenceGrid, fenceMaterialProvider, fenceStructureManager);
         
-        fenceBuildingManager = new FenceBuildingManager(fenceStructureManager, fencePlacementValidator, camera);
+        fenceBuildingManager = new FenceBuildingManager(fenceStructureManager, fencePlacementValidator, camera, player);
         fenceWorldIntegration = new FenceWorldIntegration();
         fenceWorldIntegration.setBuildingManager(fenceBuildingManager);
         
@@ -2050,6 +2050,11 @@ public void startMultiplayerHost() throws Exception {
             gameClient.setMessageHandler(new GameMessageHandler(this));
             gameClient.connect("localhost", 25565);
             
+            // Enable fence ownership validation for multiplayer
+            if (fenceBuildingManager != null) {
+                fenceBuildingManager.getValidator().setOwnershipValidationEnabled(true);
+            }
+            
             // Set game mode to host
             gameMode = GameMode.MULTIPLAYER_HOST;
             
@@ -2137,6 +2142,11 @@ public void joinMultiplayerServer(String serverAddress, int port) throws Excepti
             gameClient.setMessageHandler(new GameMessageHandler(this));
             gameClient.connect(serverAddress, port);
             
+            // Enable fence ownership validation for multiplayer
+            if (fenceBuildingManager != null) {
+                fenceBuildingManager.getValidator().setOwnershipValidationEnabled(true);
+            }
+            
             // Set game mode to client
             gameMode = GameMode.MULTIPLAYER_CLIENT;
             
@@ -3244,8 +3254,13 @@ public void disconnectFromMultiplayer() {
             inventoryManager.setMultiplayerMode(false);
         }
         
-        // Reset world seed to 0 for singleplayer
-        worldSeed = 0;
+        // Disable fence ownership validation for single player
+    if (fenceBuildingManager != null) {
+        fenceBuildingManager.getValidator().setOwnershipValidationEnabled(false);
+    }
+    
+    // Reset world seed to 0 for singleplayer
+    worldSeed = 0;
         
         // Clear rain zones (dynamic rain manager will handle rain events)
         if (rainSystem != null) {
diff --git a/src/main/java/wagemaker/uk/network/ClientConnection.java b/src/main/java/wagemaker/uk/network/ClientConnection.java
@@ -955,6 +955,9 @@ private void handleItemPickup(ItemPickupMessage message) {
             case FRONT_FENCE:
                 playerState.setFrontFenceCount(playerState.getFrontFenceCount() + 1);
                 break;
+            case BACK_FENCE:
+                playerState.setBackFenceCount(playerState.getBackFenceCount() + 1);
+                break;
         }
         
         // Update player state in world
diff --git a/src/main/java/wagemaker/uk/targeting/FenceTargetValidator.java b/src/main/java/wagemaker/uk/targeting/FenceTargetValidator.java
@@ -47,9 +47,18 @@ public boolean isValidTarget(float targetX, float targetY) {
         // Get the selected material type
         FenceMaterialType materialType = fenceBuildingManager.getSelectedMaterialType();
         
-        // Validate the placement (use empty player ID for single player)
+        // Get player ID for ownership validation
+        String playerId = "local_player";
+        if (fenceBuildingManager.getPlayer() != null) {
+            String id = fenceBuildingManager.getPlayer().getPlayerId();
+            if (id != null) {
+                playerId = id;
+            }
+        }
+        
+        // Validate the placement
         FencePlacementValidator.ValidationResult result = 
-            validator.validatePlacement(gridPos, materialType, "");
+            validator.validatePlacement(gridPos, materialType, playerId);
         
         return result.isValid();
     }

Original file line number	Diff line number	Diff line change
`@@ -955,6 +955,9 @@ private void handleItemPickup(ItemPickupMessage message) {`
`955`	`955`	`case FRONT_FENCE:`
`956`	`956`	`playerState.setFrontFenceCount(playerState.getFrontFenceCount() + 1);`
`957`	`957`	`break;`
	`958`	`+ case BACK_FENCE:`
	`959`	`+ playerState.setBackFenceCount(playerState.getBackFenceCount() + 1);`
	`960`	`+ break;`
`958`	`961`	`}`
`959`	`962`
`960`	`963`	`// Update player state in world`