refactored tile child relationshio

Systems/CardDisplay.gd

@@ -1,95 +1,98 @@
-extends Control
-class_name CardDisplay
+class_name CardDisplay extends Control
 
-var cardDisplays = []
-var selectedCard = null
 const CARD_WIDTH = 150
 const CARD_HEIGHT = 250
 const CARD_MARGIN = 10
-@onready var container: HBoxContainer
+
+var cardDisplays = []
+var selectedCard = null
+var container: HBoxContainer
 
 func _ready():
-	container = HBoxContainer.new()
-	container.name = "Hand"
-	container.set_position(Vector2(10, 500))
-	add_child(container)
+    # Create the container first
+    container = HBoxContainer.new()
+    container.name = "Hand"
+    container.position = Vector2(10, 500)
+    add_child(container)
 
 func update_hand(hand: Array):
-	clear_cards()
-	for card in hand:
-		add_card_display(card)
+    clear_cards()
+    for card in hand:
+        add_card_display(card)
 
 func add_card_display(card):
-	var cardPanel = PanelContainer.new()
-	cardPanel.custom_minimum_size = Vector2(CARD_WIDTH, CARD_HEIGHT)
-	
-	var vbox = VBoxContainer.new()
-	vbox.set_meta("card_id", card.id)
-	cardPanel.add_child(vbox)
-	
-	var nameLabel = Label.new()
-	nameLabel.text = card.cardName
-	nameLabel.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
-	vbox.add_child(nameLabel)
-	
-	var rankLabel = Label.new()
-	rankLabel.text = "Rank " + str(card.rank)
-	rankLabel.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
-	vbox.add_child(rankLabel)
-	
-	var descLabel = Label.new()
-	descLabel.text = card.description
-	descLabel.autowrap_mode = TextServer.AUTOWRAP_WORD
-	descLabel.custom_minimum_size = Vector2(CARD_WIDTH - 10, 0)
-	vbox.add_child(descLabel)
+    var cardPanel = PanelContainer.new()
+    cardPanel.custom_minimum_size = Vector2(CARD_WIDTH, CARD_HEIGHT)
+    
+    var vbox = VBoxContainer.new()
+    vbox.set_meta("card_id", card.id)
+    cardPanel.add_child(vbox)
+    
+    var nameLabel = Label.new()
+    nameLabel.text = card.cardName
+    nameLabel.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+    vbox.add_child(nameLabel)
+    
+    var rankLabel = Label.new()
+    rankLabel.text = "Rank " + str(card.rank)
+    rankLabel.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+    vbox.add_child(rankLabel)
+    
+    var descLabel = Label.new()
+    descLabel.text = card.description
+    descLabel.autowrap_mode = TextServer.AUTOWRAP_WORD
+    descLabel.custom_minimum_size = Vector2(CARD_WIDTH - 10, 0)
+    vbox.add_child(descLabel)
+    
+    var unitWhitelistLabel = Label.new()
+    unitWhitelistLabel.text = ", ".join(card.unitWhitelist)
+    unitWhitelistLabel.autowrap_mode = TextServer.AUTOWRAP_WORD
+    unitWhitelistLabel.custom_minimum_size = Vector2(CARD_WIDTH - 10, 0)
+    vbox.add_child(unitWhitelistLabel)
 
-	var idLabel = Label.new()
-	idLabel.text = card.id.substr(card.id.length() - 8, -1)
-	idLabel.autowrap_mode = true
-	idLabel.custom_minimum_size = Vector2(CARD_WIDTH - 10, 0)
-	vbox.add_child(idLabel)
+    var idLabel = Label.new()
+    idLabel.text = card.id.substr(card.id.length() - 8, -1)
+    idLabel.autowrap_mode = true
+    idLabel.custom_minimum_size = Vector2(CARD_WIDTH - 10, 0)
+    vbox.add_child(idLabel)
 
-
-	cardPanel.gui_input.connect(func(event): _on_card_clicked(event, card))
-	
-	cardDisplays.append(cardPanel)
-	container.add_child(cardPanel)
+    cardPanel.gui_input.connect(func(event): _on_card_clicked(event, card))
+    
+    cardDisplays.append(cardPanel)
+    container.add_child(cardPanel)
 
 func _on_card_clicked(event: InputEvent, card: Card):
-	if event is InputEventMouseButton and event.pressed:
-		if selectedCard == null || selectedCard.id != card.id:
-			selectedCard = card
-			container.emit_signal("card_pressed", card)
-		elif selectedCard.id == card.id:
-			selectedCard = null
-		highlight_selectedCard(selectedCard)
-		# selectedCard = card
-		# highlight_selectedCard(card)
-		# container.emit_signal("card_pressed", card)
+    if event is InputEventMouseButton and event.pressed:
+        if selectedCard == null || selectedCard.id != card.id:
+            selectedCard = card
+            container.emit_signal("card_pressed", card)
+        elif selectedCard.id == card.id:
+            selectedCard = null
+        highlight_selectedCard(selectedCard)
 
 func highlight_selectedCard(selected: Card) -> void:
-	for display in cardDisplays:
-		var style = StyleBoxFlat.new()
-		style.bg_color = Color(0.2, 0.2, 0.2, 1)  # Default color
-		
-		var vbox = display.get_child(0)
-		if selected && vbox.get_meta("card_id") == selected.id:
-			style.bg_color = Color(0.4, 0.6, 0.4, 1)  # Selected color
+    for display in cardDisplays:
+        var style = StyleBoxFlat.new()
+        style.bg_color = Color(0.2, 0.2, 0.2, 1)  # Default color
+        
+        var vbox = display.get_child(0)
+        if selected && vbox.get_meta("card_id") == selected.id:
+            style.bg_color = Color(0.4, 0.6, 0.4, 1)  # Selected color
             
-		display.add_theme_stylebox_override("panel", style)
+        display.add_theme_stylebox_override("panel", style)
 
 func get_card_by_uuid(uuid: String) -> Card:
-	for display in cardDisplays:
-		var vbox = display.get_child(0)
-		if vbox.get_meta("card_id") == uuid:
-			return selectedCard
-	return null
+    for display in cardDisplays:
+        var vbox = display.get_child(0)
+        if vbox.get_meta("card_id") == uuid:
+            return selectedCard
+    return null
 
 func getSelectedCard() -> Card:
-	return selectedCard
+    return selectedCard
 
 func clear_cards():
-	for display in cardDisplays:
-		display.queue_free()
-	cardDisplays.clear()
-	selectedCard = null
+    for display in cardDisplays:
+        display.queue_free()
+    cardDisplays.clear()
+    selectedCard = null

Systems/Cards/Drunkdriving.gd

@@ -8,7 +8,6 @@ func _init():
     effectType = EffectType.SPECIAL_ACTION
     description = "Force peice to careen towards the enemy side, capturing all pieces in its path"
     unitWhitelist = ["Rook", "Queen"]
-    
 func apply_effect(target_piece = null, board_flow = null, game_state = null):
     if !super.apply_effect(target_piece, board_flow, game_state):
         return false
@@ -16,43 +15,44 @@ func apply_effect(target_piece = null, board_flow = null, game_state = null):
     if !target_piece or !board_flow or !game_state:
         return false
         
-        
-    var current_pos = target_piece.get_parent().name.split("-")
+    # Get current container and position
+    var current_container = target_piece.get_parent() as PieceContainer
+    var current_pos = current_container.name.split("-")
     var current_x = int(current_pos[0])
     var current_y = int(current_pos[1])
     
-    
+    # Calculate target position
     var target_y = 7 if target_piece.Item_Color == 1 else 0 
-    
-    
     var y_direction = 1 if target_y > current_y else -1
     
-    
+    # Generate tiles to check
     var tiles_to_check = []
     var y = current_y + y_direction
     while y != target_y + y_direction: 
         tiles_to_check.append(str(current_x) + "-" + str(y))
         y += y_direction
     
-    
+    # Process pieces in path
     for tile_name in tiles_to_check:
-        var tile = board_flow.get_node(tile_name)
-        if tile.get_child_count() > 0:
-            var piece_to_capture = tile.get_child(0)
+        var container = board_flow.get_node(tile_name) as PieceContainer
+        if container.has_piece():
+            var piece_to_capture = container.get_piece()
             game_state.updatePoints(piece_to_capture)
-            piece_to_capture.queue_free()
+            container.remove_piece()
     
+    # Move piece to final position
+    var final_container = board_flow.get_node(str(current_x) + "-" + str(target_y)) as PieceContainer
     
-    var final_tile = board_flow.get_node(str(current_x) + "-" + str(target_y))
-    target_piece.reparent(final_tile)
-    target_piece.position = Vector2(25, 25)
-    
+    # Important: Need to remove the piece from its current container first
+    # AND keep a reference to it
+    target_piece = current_container.get_piece()  # Get reference before removing
+    current_container.remove_piece(true)              # Remove from current container
+    final_container.set_piece(target_piece)       # Set in new container
     
     game_state.currentlyMovingPiece = target_piece
-    
     burned = true 
     
-    game_state.resolveMoveEffects();
+    game_state.resolveMoveEffects()
     game_state.stateMachine.transitionToNextState(Constants.POST_MOVE)
     
     return true

Systems/Cards/Explosiveboots.gd

@@ -42,27 +42,29 @@ func apply_effect(target_piece = null, board_flow = null, game_state = null):
                 
             tiles_to_check.append(str(target_x) + "-" + str(target_y))
     
+    
+    
+
     # Process tiles and add overlay
     for tile_name in tiles_to_check:
-        var tile = board_flow.get_node(tile_name)
+        var container = board_flow.get_node(tile_name) as PieceContainer
         
-        var existing_overlay = tile.get_node_or_null("ExplosiveBootsOverlay")
-        if existing_overlay:
-            existing_overlay.queue_free()
+        # Handle overlay through container's overlay management
+        container.remove_overlay("ExplosiveBootsOverlay")
         
         var overlay = ColorRect.new()
         overlay.name = "ExplosiveBootsOverlay"
         overlay.color = Color(1, 0, 0, 0.3)
-        overlay.size = tile.size
+        overlay.size = container.size
         overlay.mouse_filter = Control.MOUSE_FILTER_IGNORE
-        tile.add_child(overlay)
+        container.add_overlay(overlay)
         overlay.show()
         
-        if tile.get_child_count() > 1:  # > 1 because we just added the overlay
-            var piece = tile.get_child(0)  
-            if piece.Item_Color != target_piece.Item_Color:
-                game_state.updatePoints(piece)
-                piece.queue_free()
+        # Check for pieces to affect
+        var piece = container.get_piece()
+        if piece != null and piece.Item_Color != target_piece.Item_Color:
+            game_state.updatePoints(piece)
+            container.remove_piece()
     
     # Setup timer to remove overlays
     var timer = Timer.new()

Systems/Cards/Supernova.gd

@@ -1,6 +1,7 @@
 class_name SupernovaCard extends Card
 
 const CAPTURE_RADIUS = 4
+var valid = false;
 
 func _init():
     super._init()
@@ -10,14 +11,17 @@ func _init():
     duration = 5
     description = "All enemy units within 4 radius are captured"
     unitWhitelist = ["King"]
+    remaining_turns = duration
 
 func apply_effect(target_piece = null, board_flow = null, game_state = null):
-    if !super.apply_effect(target_piece, board_flow, game_state):
-        return false
-        
+    attached_piece = target_piece
     if !target_piece or !board_flow or !game_state:
+        print(cardName, " missing input param ")
         return false
-    
+    setup_persistent_effect(game_state)
+    # dont apply on card attachment
+    if !valid:
+        return true
     # Get king's position
     var king_pos = target_piece.get_parent().name.split("-")
     var king_x = int(king_pos[0])
@@ -48,47 +52,66 @@ func apply_effect(target_piece = null, board_flow = null, game_state = null):
             # Add tile to check list
             tiles_to_check.append(str(target_x) + "-" + str(target_y))
     
-    # Process each tile and capture pieces
+    # Process tiles and add overlay
     for tile_name in tiles_to_check:
-        var tile = board_flow.get_node("Flow/" + tile_name)
-        if tile.get_child_count() > 0:
-            var piece = tile.get_child(0)
-            if piece.Item_Color != target_piece.Item_Color:  # Only capture enemy pieces
-                game_state.updatePoints(piece)
-                piece.queue_free()
-    
-    # Visual feedback
-    for tile_name in tiles_to_check:
-        var tile = board_flow.get_node("Flow/" + tile_name)
-        var style = StyleBoxFlat.new()
-        style.bg_color = Color(1, 0, 0, 0.3)  # Red tint
-        tile.add_theme_stylebox_override("normal", style)
+        var container = board_flow.get_node(tile_name) as PieceContainer
         
-        # Remove highlight after delay
-        var timer = Timer.new()
-        board_flow.add_child(timer)
-        timer.wait_time = 0.5
-        timer.one_shot = true
-        timer.timeout.connect(func(): 
-            tile.remove_theme_stylebox_override("normal")
-            timer.queue_free()
-        )
-        timer.start()
+        # Handle overlay through container's overlay management
+        container.remove_overlay("SupernovaOverlay")
+        
+        var overlay = ColorRect.new()
+        overlay.name = "SupernovaOverlay"
+        overlay.color = Color(1, 0, 0, 0.3)
+        overlay.size = container.size
+        overlay.mouse_filter = Control.MOUSE_FILTER_IGNORE
+        container.add_overlay(overlay)
+        overlay.show()
+        
+        # Check for pieces to affect
+        var piece = container.get_piece()
+        if piece != null and piece.Item_Color != target_piece.Item_Color:
+            game_state.updatePoints(piece)
+            container.remove_piece()
+    
+    # Setup timer to remove overlays
+    var timer = Timer.new()
+    board_flow.add_child(timer)
+    timer.wait_time = 0.5
+    timer.one_shot = true
+    timer.timeout.connect(func(): 
+        for tile_name in tiles_to_check:
+            var tile = board_flow.get_node(tile_name)
+            var overlay = tile.get_node_or_null("SupernovaOverlay")
+            if overlay:
+                overlay.queue_free()
+        timer.queue_free()
+    )
+    timer.start()
     
-    # game_state.stateMachine.transitionToNextState(Constants.POST_MOVE)
     return true
-func setup_persistent_effect(king, game_state):
+
+
+func setup_persistent_effect(game_state):
     # Connect to the turn change signal if not already connected
     if !game_state.is_connected("turn_changed", Callable(self, "on_turn_changed")):
         game_state.connect("turn_changed", Callable(self, "on_turn_changed"))
     
 func on_turn_changed():
-    if attached_piece and remaining_turns > 0:
-        # Reapply the effect at the start of each turn
-        apply_effect(attached_piece, attached_piece.get_parent().get_parent(), attached_piece.get_parent().get_parent().owner)
-        remaining_turns -= 1
-        if remaining_turns <= 0:
-            remove_effect()
+    
+    if attached_piece.get_parent().get_parent().owner.isPlayerTurn() and attached_piece and remaining_turns > 0:
+        # print(attached_piece.get_parent().get_parent(), attached_piece.get_parent().get_parent().owner)
+        var piece = attached_piece
+        var flow = attached_piece.get_parent().get_parent()
+        var state = attached_piece.get_parent().get_parent().owner
+        
+        # print("Debug values:")
+        # print("- Piece: ", piece, " is null? ", piece == null)
+        # print("- Board Flow: ", flow, " is null? ", flow == null)
+        # print("- Game State: ", state, " is null? ", state == null)
+        
+        # Now try apply_effect with these values
+        valid = true
+        apply_effect(piece, flow, state)
 
 func remove_effect():
     if attached_piece:

Systems/Game/ChessGame.gd

@@ -1,5 +1,6 @@
 class_name ChessGame extends Control
 
+const PieceContainer = preload("res://Systems/PieceContainer.gd")
 const WHITE = "white"
 const BLACK = "black"
 signal tile_pressed(location: String)
@@ -25,6 +26,7 @@ var Turn: int = 0
 @onready var p1String: RichTextLabel = $Player1Points
 @onready var p2String: RichTextLabel = $Player2Points 
 @onready var deckManager: DeckManager
+# @onready var tileManager: TileManager
 @onready var cardDisplay: CardDisplay
 @onready var cardPreview: CardPreview
 
@@ -44,8 +46,16 @@ var highlightStyle = null
 func _ready() -> void:
     initializeGame()
     stateMachine.transitionToNextState(Constants.WHITE_TURN)
+    # initializeTiles()
 
 
+# func initializeTiles() -> void:
+#     tileManager = TileManager.new(boardContainer, self)
+#     add_child(tileManager)
+#     tileManager.setup_initial_tiles()
+
+func get_base_style(is_white: bool) -> StyleBoxFlat:
+    return lightStyle if is_white else darkStyle
 func _unhandled_input(event: InputEvent) -> void:
     stateMachine.unhandledInput(event)
 
@@ -122,7 +132,7 @@ func createBoard() -> void:
 
 func createTile(x: int, y: int, isWhite: bool) -> void:
     # print("CreateTile x ", x,  " y ", y);
-    var tile = Button.new()
+    var tile = PieceContainer.new()
     tile.set_custom_minimum_size(Vector2(tileXSize, tileYSize))
     tile.add_theme_stylebox_override("normal", lightStyle if isWhite else darkStyle)
 
@@ -209,8 +219,11 @@ func setupPieces() -> void:
 
 func placePiece(position: String, pieceName: String, color: int) -> void:
     var piece = summonPiece(pieceName, color)
-    boardContainer.get_node(position).add_child(piece)
+    # boardContainer.get_node(position).add_child(piece)
     
+    var container = boardContainer.get_node(position)
+    container.set_piece(piece)
+
     var coords = position.split("-")
     board[int(coords[1])][int(coords[0])] = piece
 
@@ -242,8 +255,8 @@ func summonPiece(pieceName: String, color: int) -> Node:
 
 func clearBoard() -> void:
    for child in boardContainer.get_children():
-       if child.get_child_count() > 0:
-           child.get_child(0).queue_free()
+       if child is PieceContainer:
+           child.remove_piece()
 
 
 # func prepareHand() -> void:
@@ -275,8 +288,9 @@ func evaluatePosition() -> Dictionary:
     return status
 
 func isValidMove(location: String) -> bool:
-    var node = get_node("Flow/" + location)
-    if node.get_child_count() == 0 || node.get_child(0).Item_Color != Turn:
+    var node = get_node("Flow/" + location) as PieceContainer
+    var piece = node.get_piece()
+    if piece == null || piece.Item_Color != Turn:
         for area in areas:
             if area == node.name:
                 return true
@@ -306,8 +320,8 @@ func getMovableAreas() -> void:
     resetHighlights()
     areas.clear()
     specialArea.clear()
-    
-    var piece = get_node("Flow/" + selectedNode).get_child(0)
+    var container = get_node("Flow/" + selectedNode) as PieceContainer
+    var piece = container.get_piece()
     var piece_id = piece.get_instance_id()
     # print("HIGHLIGHTING getMovableAreas 2")
     if deckManager.attached_cards.has(piece_id):
@@ -339,23 +353,26 @@ func highlightValidMoves() -> void:
 
 func executeMove(targetLocation: String) -> void:
     print("executeMove ", targetLocation)
-    var targetNode = get_node("Flow/" + targetLocation)
-    var piece = get_node("Flow/" + selectedNode).get_child(0)
-    # print("piece", piece)
+    var targetContainer = get_node("Flow/" + targetLocation) as PieceContainer
+    var sourceContainer = get_node("Flow/" + selectedNode) as PieceContainer
+    var piece = sourceContainer.get_piece()
+    var old_location = selectedNode
     
-    if targetNode.get_child_count() != 0:
-        var capturedPiece = targetNode.get_child(0)
+    # Handle capture if there's a piece in target location
+    if targetContainer.has_piece():
+        var capturedPiece = targetContainer.get_piece()
         if Turn == 0:
             p1Points += capturedPiece.Points
             p1String.text = str(p1Points)
         else:
             p2Points += capturedPiece.Points
             p2String.text = str(p2Points)
-        capturedPiece.free()
-        
-    piece.reparent(targetNode)
-    piece.position = Vector2(25, 25)
-    # print("piece2", piece)
+        targetContainer.remove_piece()  # This handles freeing the captured piece
+    
+    # Move piece to new location
+    sourceContainer.remove_piece(true)
+    targetContainer.set_piece(piece)
+    
     hasMoved = true
     currentlyMovingPiece = piece
     resetHighlights()

Systems/PieceContainer.gd

@@ -0,0 +1,49 @@
+class_name PieceContainer extends Button
+
+var piece: Pawn = null
+@onready var overlays: Node = $Overlays
+@onready var effects: Node = $Effects
+
+func _init() -> void:
+    # Create containers for different types of children
+    var overlays_node = Node.new()
+    overlays_node.name = "Overlays"
+    add_child(overlays_node)
+    
+    var effects_node = Node.new()
+    effects_node.name = "Effects"
+    add_child(effects_node)
+
+func set_piece(new_piece: Pawn) -> void:
+    remove_piece()  # Clean up any existing piece
+    piece = new_piece
+    if new_piece != null:
+        add_child(new_piece)
+        new_piece.position = Vector2(25, 25)
+
+func get_piece() -> Pawn:
+    return piece
+
+func remove_piece(keep_piece: bool = false) -> Pawn:
+    var old_piece = piece
+    if piece != null:
+        remove_child(piece)
+        if !keep_piece:
+            piece.queue_free()
+            old_piece = null
+    piece = null
+    return old_piece
+
+func add_overlay(overlay: Node) -> void:
+    overlays.add_child(overlay)
+
+func remove_overlay(overlay_name: String) -> void:
+    var overlay = overlays.get_node_or_null(overlay_name)
+    if overlay:
+        overlay.queue_free()
+
+func get_overlay(overlay_name: String) -> Node:
+    return overlays.get_node_or_null(overlay_name)
+
+func has_piece() -> bool:
+    return piece != null

Systems/StateMachine/GameStates/AttachCards.gd

@@ -34,12 +34,12 @@ func exit() -> void:
 
 func handleTilePressed(location: String) -> void:
     # print("HANDLING Tile PRESSED ", location)
-    var targetNode = game.get_node("Flow/" + location)
-    
-    if targetNode.get_child_count() == 0:
+    var container = game.get_node("Flow/" + location) as PieceContainer
+
+    var piece = container.get_piece()
+    if piece == null:
         return
-        
-    var piece = targetNode.get_child(0)
+
     var piece_id = piece.get_instance_id()
     var selectedCard = game.cardDisplay.getSelectedCard()
     if game.deckManager.attached_cards.has(piece_id):
@@ -70,5 +70,3 @@ func complete_attachment_phase() -> void:
     if timer.time_left > 0:
         timer.stop()
         _on_timer_timeout()
-
-

Systems/StateMachine/GameStates/Movement.gd

@@ -33,25 +33,39 @@ func handleMovement(location: String) -> void:
     # maybe once u start nmoving a peice global stat var is set
     # and any moving peice needs ot match that
     print("HANDLING MOVEMENT ", location, " | ", multiMoving, " | ", game.selectedNode)
-    var node = game.get_node("Flow/" + location)
+    var node = game.get_node("Flow/" + location) as PieceContainer
+
+    # Only try to get piece if we have a selected node
+    if game.selectedNode == "":
+        # If no node is selected, we might want to select this one if it has a piece
+        var piece = node.get_piece()
+        if piece != null && piece.Item_Color == game.Turn:
+            game.selectedNode = location
+            game.getMovableAreas()
+        return
+
+    # Now we know we have a selected node, get its piece
+    var sourceContainer = game.get_node("Flow/" + game.selectedNode) as PieceContainer
+    var piece = sourceContainer.get_piece()
+    if piece == null:
+        return
 
-    var piece = game.get_node("Flow/" + game.selectedNode).get_child(0)
     var piece_id = piece.get_instance_id()
     print(piece_id)
     var is_multi_moving = piece_id in moves_remaining and moves_remaining[piece_id] > 1
-
+    
 
     if multiMoving.length() > 0:
 
-        if node.get_child_count() > 0 and is_instance_valid(node.get_child(0)):
-            var attempting_piece = node.get_child(0)
+        if node.get_piece() != null and is_instance_valid(node.get_piece()):
+            var attempting_piece = node.get_piece()
             print("Checking Str comp ", str(attempting_piece.get_instance_id()), " ", multiMoving)
             # Only block if it's a different piece of the same color
             if str(attempting_piece.get_instance_id()) != multiMoving and attempting_piece.Item_Color == game.Turn:
                 print("early return - can't select different piece of same color during multi-move")
                 return
     if game.selectedNode == "":
-        if node.get_child_count() != 0 && node.get_child(0).Item_Color == game.Turn:
+        if node.get_piece() != null && node.get_piece().Item_Color == game.Turn:
             print("SELECTED NODE ", location)
             game.selectedNode = location
             game.getMovableAreas()
@@ -95,6 +109,7 @@ func handleMovement(location: String) -> void:
     else:
         if game.isValidMove(location):
             # executeMove(location)
+
             handleRegularMove(node, consumeMove)
             if consumeMove:
                 multiMoving = ""
@@ -118,99 +133,113 @@ func handleMovement(location: String) -> void:
 
            
 
-func isCastlingMove(node: Node, location: String) -> bool:
-    return game.selectedNode != "" && node.get_child_count() != 0 && node.get_child(0).Item_Color == game.Turn && node.get_child(0).name == "Rook"
+func isCastlingMove(node: PieceContainer, location: String) -> bool:
+    return game.selectedNode != "" && node.get_piece() != null && node.get_piece().Item_Color == game.Turn && node.get_piece().name == "Rook"
 
-func isEnPassantMove(node: Node, location: String) -> bool:
-    return game.selectedNode != "" && node.get_child_count() != 0 && node.get_child(0).Item_Color != game.Turn && \
-           node.get_child(0).name == "Pawn" && game.specialArea.size() != 0 && game.specialArea[0] == node.name && \
-           node.get_child(0).get("En_Passant") == true
+func isEnPassantMove(node: PieceContainer, location: String) -> bool:
+    return game.selectedNode != "" && node.get_piece() != null && node.get_piece().Item_Color != game.Turn && \
+           node.get_piece().name == "Pawn" && game.specialArea.size() != 0 && game.specialArea[0] == node.name && \
+           node.get_piece().get("En_Passant") == true
 
-func isReselectMove(node: Node) -> bool:
-    return game.selectedNode != "" && node.get_child_count() != 0 && node.get_child(0).Item_Color == game.Turn
+func isReselectMove(node: PieceContainer) -> bool:
+    return game.selectedNode != "" && node.get_piece() != null && node.get_piece().Item_Color == game.Turn
 
-func isCaptureMove(node: Node) -> bool:
-    return game.selectedNode != "" && node.get_child_count() != 0 && node.get_child(0).Item_Color != game.Turn
+func isCaptureMove(node: PieceContainer) -> bool:
+    return game.selectedNode != "" && node.get_piece() != null && node.get_piece().Item_Color != game.Turn
 
-func isRegularMove(node: Node) -> bool:
-    return game.selectedNode != "" && node.get_child_count() == 0
+func isRegularMove(node: PieceContainer) -> bool:
+    return game.selectedNode != "" && node.get_piece() != null
 
-func handleCastling(node: Node) -> void:
+func handleCastling(node: PieceContainer) -> void:
     print("handleCastling")
     for i in game.areas:
         if i == node.name:
-            var king = game.get_node("Flow/" + game.selectedNode).get_child(0)
-            var rook = node.get_child(0)
-            king.reparent(game.get_node("Flow/" + game.specialArea[1]))
-            rook.reparent(game.get_node("Flow/" + game.specialArea[0]))
-            king.position = Vector2(25, 25)
-            rook.position = Vector2(25, 25)
+            var kingContainer = game.get_node("Flow/" + game.selectedNode) as PieceContainer
+            var rookContainer = node as PieceContainer
+            var kingTargetContainer = game.get_node("Flow/" + game.specialArea[1]) as PieceContainer
+            var rookTargetContainer = game.get_node("Flow/" + game.specialArea[0]) as PieceContainer
+
+            var king = kingContainer.get_piece()
+            var rook = rookContainer.get_piece()
+
+            kingContainer.remove_piece(true)
+            rookContainer.remove_piece(true)
+            kingTargetContainer.set_piece(king)
+            rookTargetContainer.set_piece(rook)
+
             game.currentlyMovingPiece = king
             game.resolveMoveEffects()
 
-func handleEnPassant(node: Node) -> void:
+func handleEnPassant(node: PieceContainer) -> void:
     print("handleEnPassant")
     for i in game.specialArea:
         if i == node.name:
-            var pawn = game.get_node("Flow/" + game.selectedNode).get_child(0)
-            node.get_child(0).free()
-            pawn.reparent(game.get_node("Flow/" + game.specialArea[1]))
-            pawn.position = Vector2(25, 25)
+            var targetContainer = game.get_node("Flow/" + game.selectedNode) as PieceContainer
+            var pawn = (game.get_node("Flow/" + game.selectedNode) as PieceContainer).get_piece()
+            node.remove_piece()
+            targetContainer.set_piece(pawn)
             game.currentlyMovingPiece = pawn
             game.resolveMoveEffects()
 
-func handleCapture(node: Node) -> void:
+func handleCapture(node: PieceContainer) -> void:
     print("handleCapture")
     for i in game.areas:
         if i == node.name:
-            var piece = game.get_node("Flow/" + game.selectedNode).get_child(0)
-            var capturedPiece = node.get_child(0)
             
-            
-            piece.reparent(node)
-            piece.position = Vector2(25, 25)
-            piece.position = Vector2(25, 25)
-            game.currentlyMovingPiece = piece
-            game.resolveMoveEffects()
-            game.updatePoints(capturedPiece)
-            capturedPiece.free()
 
-func handleRegularMove(node: Node, consume: bool) -> void:
-    print("handleRegularMove", node)
+            var source_container = game.get_node("Flow/" + game.selectedNode) as PieceContainer
+            
+            
+            var moving_piece = source_container.get_piece()
+            var captured_piece = node.get_piece()
+            
+            if moving_piece && captured_piece:
+                game.updatePoints(captured_piece)
+                node.set_piece(moving_piece) 
+                game.currentlyMovingPiece = moving_piece
+                game.resolveMoveEffects()
+
+func handleRegularMove(node: PieceContainer, consume: bool) -> void:
+    print("handleRegularMove", node, game.selectedNode)
     for i in game.areas:
         if i == node.name:
-            var piece = game.get_node("Flow/" + game.selectedNode).get_child(0)
-            piece.reparent(node)
-            piece.position = Vector2(25, 25)
+            print(i)
+            var sourceContainer = game.get_node("Flow/" + game.selectedNode) as PieceContainer
+            var piece = sourceContainer.get_piece()
+            print("Removing Piece 1")
+            sourceContainer.remove_piece(true)
+            node.set_piece(piece)
+
+            game.currentlyMovingPiece = piece
             if consume:
-                game.currentlyMovingPiece = piece
                 game.resolveMoveEffects()
             else:
-                game.currentlyMovingPiece = piece
-                game.togglePieceChessEffect();
+                game.togglePieceChessEffect()
 
 
 
 
 func executeMove(targetLocation: String) -> void:
     print("executeMove ", targetLocation)
-    var targetNode = game.get_node("Flow/" + game.targetLocation)
-    var piece = game.get_node("Flow/" + game.selectedNode).get_child(0)
-    # print("piece", piece)
+    var targetContainer = game.get_node("Flow/" + targetLocation) as PieceContainer
+    var sourceContainer = game.get_node("Flow/" + game.selectedNode) as PieceContainer
+    var piece = sourceContainer.get_piece()
     
-    if targetNode.get_child_count() != 0:
-        var capturedPiece = targetNode.get_child(0)
+    # Handle capture if there's a piece in the target location
+    if targetContainer.has_piece():
+        var capturedPiece = targetContainer.get_piece()
         if game.Turn == 0:
             game.p1Points += capturedPiece.Points
             game.p1String.text = str(game.p1Points)
         else:
             game.p2Points += capturedPiece.Points
             game.p2String.text = str(game.p2Points)
-        capturedPiece.free()
+        targetContainer.remove_piece()  # This will handle freeing the captured piece
         
-    piece.reparent(targetNode)
-    piece.position = Vector2(25, 25)
-    # print("piece2", piece)
+    # Move piece to new location
+    sourceContainer.remove_piece(true)
+    targetContainer.set_piece(piece)
+    
     game.hasMoved = true
     game.currentlyMovingPiece = piece
     game.resetHighlights()

Systems/Tile.gd

@@ -0,0 +1,99 @@
+@tool
+class_name Tile
+
+enum TileType {
+    GENERAL,    # Effects apply to any piece
+    SPECIFIC,   # Effects apply to specific pieces
+    GLOBAL      # Effects apply globally while conditions are met
+}
+
+enum TileOwner {
+    PLAYER,     # White player's tiles
+    ENEMY,      # Black player's tiles
+    GAME        # Neutral game tiles
+}
+
+const TILE_COLORS = {
+    TileOwner.PLAYER: Color(0.2, 0.8, 0.2, 0.5),
+    TileOwner.ENEMY: Color(0.8, 0.2, 0.2, 0.5),
+    TileOwner.GAME: Color(0.2, 0.2, 0.8, 0.5)
+}
+
+var type: TileType
+var tile_owner: TileOwner
+var duration: int = -1  # -1 for permanent effects
+var remaining_turns: int
+var occupied_by: Pawn = null
+var active: bool = false
+var tile_name: String
+var description: String
+var id: String = Utils.generate_guid()
+var base_button: Button  # Reference to the board square button
+var base_is_white: bool  # Original color of the square
+
+func _init(button: Button, is_white: bool) -> void:
+    base_button = button
+    base_is_white = is_white
+
+func initialize(tile_type: TileType, owner_type: TileOwner, turns: int = -1) -> void:
+    print("initi Tile")
+    type = tile_type
+    tile_owner = owner_type
+    duration = turns
+    remaining_turns = duration
+    update_appearance()
+
+func update_appearance() -> void:
+    if is_effect_active() && base_button:
+        var style = StyleBoxFlat.new()
+        var tile_color = TILE_COLORS[tile_owner]
+        
+        # Mix the tile color with the base square color
+        var base_color = Color(0.8, 0.8, 0.8) if base_is_white else Color(0.2, 0.2, 0.2)
+        var mixed_color = Color(
+            (base_color.r + tile_color.r) / 2,
+            (base_color.g + tile_color.g) / 2,
+            (base_color.b + tile_color.b) / 2
+        )
+        
+        style.bg_color = mixed_color
+        style.border_width_left = 2
+        style.border_width_right = 2
+        style.border_width_top = 2
+        style.border_width_bottom = 2
+        style.border_color = tile_color
+        
+        base_button.add_theme_stylebox_override("normal", style)
+        
+        # Add hover style
+        var hover_style = style.duplicate()
+        hover_style.bg_color = tile_color.lightened(0.2)
+        base_button.add_theme_stylebox_override("hover", hover_style)
+    else:
+        restore_base_appearance()
+
+func restore_base_appearance() -> void:
+    if base_button:
+        var board = base_button.get_parent()
+        if board && board.has_method("get_base_style"):
+            var base_style = board.get_base_style(base_is_white)
+            base_button.add_theme_stylebox_override("normal", base_style)
+            base_button.add_theme_stylebox_override("hover", base_style)
+
+func is_effect_active() -> bool:
+    return active && (duration == -1 || remaining_turns > 0)
+
+func update_duration() -> bool:
+    if duration > 0:
+        remaining_turns -= 1
+        if remaining_turns <= 0:
+            restore_base_appearance()
+            return true  # Tile should be removed
+    return false
+
+# Virtual methods to be overridden by specific tile effects
+func apply_effect(piece: Pawn, board_flow = null, game_state = null) -> void:
+    pass
+
+func remove_effect(piece: Pawn, board_flow = null, game_state = null) -> void:
+    pass

Systems/TileManager.gd

@@ -0,0 +1,93 @@
+extends Node
+class_name TileManager
+const INITIAL_GAME_TILES = 3  # Number of neutral tiles to place at game start
+
+var active_tiles: Dictionary = {}  # location -> Tile
+var game_board: Node  # Reference to the game board
+var game_state: Node  # Reference to the game state
+
+const DoubleMovementTile = preload("res://Systems/Tiles/DoubleMovement.gd")
+const FireWallTile = preload("res://Systems/Tiles/FireWall.gd")
+const PawnBoostTile = preload("res://Systems/Tiles/PawnBoost.gd")
+
+# Available tile classes
+const TILE_TYPES = {
+    "double_movement": DoubleMovementTile,
+    "fire_wall": FireWallTile,
+    "pawn_boost": PawnBoostTile
+}
+
+func _init(board: Node, state: Node = null) -> void:
+    game_board = board
+    game_state = state
+
+func setup_initial_tiles() -> void:
+    var available_positions = ["4-4", "4-6", "2-4"]
+    # get_available_positions()
+    available_positions.shuffle()
+    
+    for i in range(min(INITIAL_GAME_TILES, available_positions.size())):
+        var pos = available_positions[i]
+        var tile_type = TILE_TYPES.keys()[randi() % TILE_TYPES.size()]
+        create_tile(pos, tile_type, Tile.TileOwner.GAME)
+
+func create_tile(location: String, tile_type: String, tile_owner: int, duration: int = -1) -> Tile:
+    print("CREATING TILES", location)
+    if location in active_tiles:
+        print("In Active tiles ", location)
+        var old_tile = active_tiles[location]
+        old_tile.restore_base_appearance()
+        active_tiles.erase(location)
+    
+    if !TILE_TYPES.has(tile_type):
+        push_error("Invalid tile type: " + tile_type)
+        return null
+    
+    var board_button = game_board.get_node(location)
+    if !board_button:
+        print("no Board Btn present ", location)
+        return null
+        
+    # Determine if it's a white square based on coordinates
+    var coords = location.split("-")
+    var is_white_square = (int(coords[0]) + int(coords[1])) % 2 == 0
+    
+    var tile = TILE_TYPES[tile_type].new(board_button, is_white_square)
+    print("Tile: ", tile)
+    tile.initialize(tile.type, tile_owner, duration)
+    
+    active_tiles[location] = tile
+    return tile
+
+func create_fire_wall(start_pos: String, affected_positions: Array) -> void:
+    for pos in affected_positions:
+        create_tile(pos, "fire_wall", Tile.TileOwner.PLAYER, 3)
+
+func get_available_positions() -> Array:
+    var positions = []
+    # Skip edge tiles and starting rows
+    for x in range(1, 7):
+        for y in range(2, 6):
+            var pos = str(x) + "-" + str(y)
+            if !active_tiles.has(pos):
+                positions.append(pos)
+    return positions
+
+func update_tiles() -> void:
+    var expired_tiles = []
+    for location in active_tiles:
+        var tile = active_tiles[location]
+        if tile.update_duration():
+            expired_tiles.append(location)
+    
+    for location in expired_tiles:
+        active_tiles.erase(location)
+
+func get_tile_at(location: String) -> Tile:
+    return active_tiles.get(location)
+
+func clear_tiles() -> void:
+    for location in active_tiles:
+        var tile = active_tiles[location]
+        tile.restore_base_appearance()
+    active_tiles.clear()

Systems/Tiles/DoubleMovement.gd

@@ -0,0 +1,39 @@
+class_name DoubleMovementTile
+extends Tile
+
+func _init(button: Button, is_white: bool) -> void:
+    super._init(button, is_white)
+    tile_name = "Double Movement"
+    description = "Double movement for 3 turns"
+    type = TileType.GENERAL
+
+func update_appearance() -> void:
+    print("TILE UPDATE APPR");
+    if true && base_button:
+        var style = StyleBoxFlat.new()
+        var tile_color = TILE_COLORS[tile_owner]
+        var base_color = Color(0.8, 0.8, 0.8) if base_is_white else Color(0.2, 0.2, 0.2)
+        
+        # Brighten the color slightly for double movement
+        tile_color = tile_color.lightened(0.2)
+        
+        style.bg_color = Color(
+            (base_color.r + tile_color.r) / 2,
+            (base_color.g + tile_color.g) / 2,
+            (base_color.b + tile_color.b) / 2
+        )
+        
+        # Add distinctive border pattern
+        style.border_width_left = 4
+        style.border_width_right = 4
+        style.border_width_top = 4
+        style.border_width_bottom = 4
+        style.border_color = tile_color
+        
+        base_button.add_theme_stylebox_override("normal", style)
+        
+        var hover_style = style.duplicate()
+        hover_style.bg_color = tile_color.lightened(0.2)
+        base_button.add_theme_stylebox_override("hover", hover_style)
+    else:
+        restore_base_appearance()

Systems/Tiles/FireWall.gd

@@ -0,0 +1,34 @@
+class_name FireWallTile
+extends Tile
+func _init(button: Button, is_white: bool) -> void:
+    super._init(button, is_white)
+    tile_name = "Fire Wall"
+    description = "Captures any piece that moves through"
+    type = TileType.GENERAL
+
+func update_appearance() -> void:
+    if is_effect_active() && base_button:
+        var style = StyleBoxFlat.new()
+        var tile_color = Color(1, 0.4, 0)  # Orange for fire
+        var base_color = Color(0.8, 0.8, 0.8) if base_is_white else Color(0.2, 0.2, 0.2)
+        
+        style.bg_color = Color(
+            (base_color.r + tile_color.r) / 2,
+            (base_color.g + tile_color.g) / 2,
+            (base_color.b + tile_color.b) / 2
+        )
+        
+        # Thick border for danger
+        style.border_width_left = 5
+        style.border_width_right = 5
+        style.border_width_top = 5
+        style.border_width_bottom = 5
+        style.border_color = tile_color
+        
+        base_button.add_theme_stylebox_override("normal", style)
+        
+        var hover_style = style.duplicate()
+        hover_style.bg_color = tile_color.lightened(0.2)
+        base_button.add_theme_stylebox_override("hover", hover_style)
+    else:
+        restore_base_appearance()

Systems/Tiles/PawnBoost.gd

@@ -0,0 +1,35 @@
+class_name PawnBoostTile
+extends Tile
+
+func _init(button: Button, is_white: bool) -> void:
+    super._init(button, is_white)
+    tile_name = "Fire Wall"
+    description = "Captures any piece that moves through"
+    type = TileType.GENERAL
+
+func update_appearance() -> void:
+    if is_effect_active() && base_button:
+        var style = StyleBoxFlat.new()
+        var tile_color = Color(1, 0.4, 0)  # Orange for fire
+        var base_color = Color(0.8, 0.8, 0.8) if base_is_white else Color(0.2, 0.2, 0.2)
+        
+        style.bg_color = Color(
+            (base_color.r + tile_color.r) / 2,
+            (base_color.g + tile_color.g) / 2,
+            (base_color.b + tile_color.b) / 2
+        )
+        
+        # Thick border for danger
+        style.border_width_left = 5
+        style.border_width_right = 5
+        style.border_width_top = 5
+        style.border_width_bottom = 5
+        style.border_color = tile_color
+        
+        base_button.add_theme_stylebox_override("normal", style)
+        
+        var hover_style = style.duplicate()
+        hover_style.bg_color = tile_color.lightened(0.2)
+        base_button.add_theme_stylebox_override("hover", hover_style)
+    else:
+        restore_base_appearance()

addons/Chess/Scripts/King.gd

@@ -61,34 +61,32 @@ func check_kingside_castle(board_flow, x: int, y: int) -> bool:
 		var check_pos = str(x + i) + "-" + str(y)
 		if !is_valid_cell(board_flow, check_pos) || !can_move_to_cell(board_flow, check_pos):
 			return false
+		var container = board_flow.get_node(check_pos) as PieceContainer
+		if container.has_piece():
+			return false
 	
-	# Check if rook is in position and hasn't moved
 	var rook_pos = str(x + 3) + "-" + str(y)
 	if !is_valid_cell(board_flow, rook_pos):
 		return false
-		
-	var rook_node = board_flow.get_node(rook_pos)
-	if rook_node.get_child_count() != 1:
-		return false
-		
-	var rook = rook_node.get_child(0)
+	var rook_container = board_flow.get_node(rook_pos) as PieceContainer
+	var rook = rook_container.get_piece()
 	return rook.name == "Rook" && rook.Castling && rook.Item_Color == self.Item_Color
-
+		
 func check_queenside_castle(board_flow, x: int, y: int) -> bool:
 	# Check if path is clear
 	for i in range(1, 4):
 		var check_pos = str(x - i) + "-" + str(y)
 		if !is_valid_cell(board_flow, check_pos) || !can_move_to_cell(board_flow, check_pos):
 			return false
+		var container = board_flow.get_node(check_pos) as PieceContainer
+		if container.has_piece():
+			return false
 	
 	# Check if rook is in position and hasn't moved
 	var rook_pos = str(x - 4) + "-" + str(y)
 	if !is_valid_cell(board_flow, rook_pos):
 		return false
 		
-	var rook_node = board_flow.get_node(rook_pos)
-	if rook_node.get_child_count() != 1:
-		return false
-		
-	var rook = rook_node.get_child(0)
+	var rook_container = board_flow.get_node(rook_pos) as PieceContainer
+	var rook = rook_container.get_piece()
 	return rook.name == "Rook" && rook.Castling && rook.Item_Color == self.Item_Color

addons/Chess/Scripts/Pawn.gd

@@ -21,110 +21,111 @@ const EFFECT_TINT_COLOR = Color(0.3, 0.8, 0.3, 0.5)  # Green tint for card effec
 var id: String = Utils.generate_guid()
 
 func _ready():
-	modulate = Color.WHITE if Item_Color == 0 else Color.BLACK
+    modulate = Color.WHITE if Item_Color == 0 else Color.BLACK
 
 func _init() -> void:
-	self.texture = load("res://addons/Chess/Textures/WPawn.svg")
-	var background_style = StyleBoxFlat.new()
-	background_style.bg_color = Color.WHITE
-	background_style.corner_radius_top_left = 2
-	background_style.corner_radius_top_right = 2
-	background_style.corner_radius_bottom_left = 2
-	background_style.corner_radius_bottom_right = 2
-	background_style.content_margin_left = 2
-	background_style.content_margin_right = 2
-	background_style.content_margin_top = 1
-	background_style.content_margin_bottom = 1
-	duration_label = Label.new()
-	duration_label.add_theme_stylebox_override("normal", background_style)
-	duration_label.add_theme_color_override("font_color", Color.BLACK)
-	duration_label.position = Vector2(-20, -20)  # Position above the piece
-	add_child(duration_label)
-	duration_label.hide()
+    self.texture = load("res://addons/Chess/Textures/WPawn.svg")
+    var background_style = StyleBoxFlat.new()
+    background_style.bg_color = Color.WHITE
+    background_style.corner_radius_top_left = 2
+    background_style.corner_radius_top_right = 2
+    background_style.corner_radius_bottom_left = 2
+    background_style.corner_radius_bottom_right = 2
+    background_style.content_margin_left = 2
+    background_style.content_margin_right = 2
+    background_style.content_margin_top = 1
+    background_style.content_margin_bottom = 1
+    duration_label = Label.new()
+    duration_label.add_theme_stylebox_override("normal", background_style)
+    duration_label.add_theme_color_override("font_color", Color.BLACK)
+    duration_label.position = Vector2(-20, -20)  # Position above the piece
+    add_child(duration_label)
+    duration_label.hide()
 
 func update_appearance() -> void:
-	# print("update_appearance")
-	if !is_instance_valid(get_tree()) || !get_tree().get_root().has_node("Board"):
-		return
-		
-	var chess_game = get_tree().get_root().get_node("Board")
-	if !chess_game.deckManager:
-		return
-		
-	var deck_manager = chess_game.deckManager
-	var has_card = deck_manager.attached_cards.has(get_instance_id())
+    # print("update_appearance")
+    if !is_instance_valid(get_tree()) || !get_tree().get_root().has_node("Board"):
+        return
+        
+    var chess_game = get_tree().get_root().get_node("Board")
+    if !chess_game.deckManager:
+        return
+        
+    var deck_manager = chess_game.deckManager
+    var has_card = deck_manager.attached_cards.has(get_instance_id())
 
-	if has_card:
-		# Apply tint while keeping the piece color
-		var base_color = Color.WHITE if Item_Color == 0 else Color.BLACK
-		modulate = base_color * EFFECT_TINT_COLOR
-		
-		# Update duration display
-		var card = deck_manager.attached_cards[get_instance_id()]
-		if is_instance_valid(duration_label):
-			duration_label.text = str(card.remaining_turns)
-			duration_label.show()
-	else:
-		# Reset to normal color
-		modulate = Color.WHITE if Item_Color == 0 else Color.BLACK
-		if is_instance_valid(duration_label):
-			duration_label.hide()
-			
+    if has_card:
+        # Apply tint while keeping the piece color
+        var base_color = Color.WHITE if Item_Color == 0 else Color.BLACK
+        modulate = base_color * EFFECT_TINT_COLOR
+        
+        # Update duration display
+        var card = deck_manager.attached_cards[get_instance_id()]
+        if is_instance_valid(duration_label):
+            duration_label.text = str(card.remaining_turns)
+            duration_label.show()
+    else:
+        # Reset to normal color
+        modulate = Color.WHITE if Item_Color == 0 else Color.BLACK
+        if is_instance_valid(duration_label):
+            duration_label.hide()
+            
 
 
 
 func on_card_effect_changed() -> void:
-	update_appearance()
+    update_appearance()
 # Movement interface method that all pieces will implement
 # In Pawn.gd
 func getValidMoves(board_flow, current_location: String) -> Dictionary:
-	var moves = {
-		"regular_moves": [],
-		"special_moves": []
-	}
+    var moves = {
+        "regular_moves": [],
+        "special_moves": []
+    }
 
-	var loc = current_location.split("-")
-	var x = int(loc[0])
-	var y = int(loc[1])
+    var loc = current_location.split("-")
+    var x = int(loc[0])
+    var y = int(loc[1])
 
-	# Movement direction based on color
-	var direction = -1 if Item_Color == 0 else 1
+    # Movement direction based on color
+    var direction = -1 if Item_Color == 0 else 1
 
-	# Forward movement
-	var forward = str(x) + "-" + str(y + direction)
-	if is_valid_cell(board_flow, forward) && can_move_to_cell(board_flow, forward):
-		moves.regular_moves.append(forward)
-		
-		# Double move on first turn
-		var double_forward = str(x) + "-" + str(y + (direction * 2))
-		if Double_Start && is_valid_cell(board_flow, double_forward) && can_move_to_cell(board_flow, double_forward):
-			moves.regular_moves.append(double_forward)
+    # Forward movement
+    var forward = str(x) + "-" + str(y + direction)
+    if is_valid_cell(board_flow, forward) && can_move_to_cell(board_flow, forward):
+        moves.regular_moves.append(forward)
+        
+        # Double move on first turn
+        var double_forward = str(x) + "-" + str(y + (direction * 2))
+        if Double_Start && is_valid_cell(board_flow, double_forward) && can_move_to_cell(board_flow, double_forward):
+            moves.regular_moves.append(double_forward)
 
-	# Diagonal captures
-	for dx in [-1, 1]:
-		var capture = str(x + dx) + "-" + str(y + direction)
-		if is_valid_cell(board_flow, capture) && can_move_to_cell(board_flow, capture, true):
-			moves.regular_moves.append(capture)
-			
-		# En Passant
-		var adjacent = str(x + dx) + "-" + str(y)
-		if is_valid_cell(board_flow, adjacent) && is_valid_cell(board_flow, capture):
-			var adjacent_cell = board_flow.get_node(adjacent)
-			if adjacent_cell.get_child_count() == 1:
-				var adjacent_piece = adjacent_cell.get_child(0)
-				if adjacent_piece.name == "Pawn" && adjacent_piece.En_Passant && adjacent_piece.Item_Color != self.Item_Color:
-					moves.special_moves.append([adjacent, capture])
+    # Diagonal captures
+    for dx in [-1, 1]:
+        var capture = str(x + dx) + "-" + str(y + direction)
+        if is_valid_cell(board_flow, capture) && can_move_to_cell(board_flow, capture, true):
+            moves.regular_moves.append(capture)
+            
+        # En Passant
+        var adjacent = str(x + dx) + "-" + str(y)
+        if is_valid_cell(board_flow, adjacent) && is_valid_cell(board_flow, capture):
+            var adjacent_cell = board_flow.get_node(adjacent) as PieceContainer
+            if adjacent_cell.get_piece() != null:
+                var adjacent_piece = adjacent_cell.get_piece()
+                if adjacent_piece.name == "Pawn" && adjacent_piece.En_Passant && adjacent_piece.Item_Color != self.Item_Color:
+                    moves.special_moves.append([adjacent, capture])
 
-	return moves
+    return moves
 
 # Helper method for all pieces
 func is_valid_cell(board_flow, location: String) -> bool:
-	var node = board_flow.get_node_or_null(location)
-	return node != null
+    var node = board_flow.get_node_or_null(location)
+    return node != null
 
 # Helper for checking if cell is empty or contains enemy
 func can_move_to_cell(board_flow, location: String, is_capture: bool = false) -> bool:
-	var node = board_flow.get_node(location)
-	if is_capture:
-		return node.get_child_count() == 1 && node.get_child(0).Item_Color != self.Item_Color
-	return node.get_child_count() == 0
+    var container = board_flow.get_node(location) as PieceContainer
+    if is_capture:
+        var piece = container.get_piece()
+        return piece != null && piece.Item_Color != self.Item_Color
+    return !container.has_piece()

addons/Chess/Scripts/Rook.gd

@@ -51,10 +51,10 @@ func getValidMoves(board_flow, current_location: String) -> Dictionary:
 		for direction in [-4, 3]:  # Check both sides for king
 			var king_pos = str(x + direction) + "-" + str(y)
 			if is_valid_cell(board_flow, king_pos):
-				var king_node = board_flow.get_node(king_pos)
-				if king_node.get_child_count() == 1:
-					var piece = king_node.get_child(0)
-					if piece.name == "King" && piece.Castling && piece.Item_Color == self.Item_Color:
-						moves.special_moves.append([king_pos, current_location])
+				var king_container = board_flow.get_node(king_pos) as PieceContainer
+				var piece = king_container.get_piece()
+				if piece != null && piece.name == "King" && piece.Castling && piece.Item_Color == self.Item_Color:
+					moves.special_moves.append([king_pos, current_location])
+
 		
 	return moves

board.tscn

@@ -76,10 +76,8 @@ layout_mode = 1
 anchors_preset = 1
 anchor_left = 1.0
 anchor_right = 1.0
-offset_left = -78.0
-offset_top = 1.0
-offset_right = 51.0
-offset_bottom = 40.0
+offset_left = -129.0
+offset_bottom = 39.0
 grow_horizontal = 0
 
 [node name="Hand" type="HBoxContainer" parent="."]