From ff873687f3ad653c40258bf894a93dd9fe0f409c Mon Sep 17 00:00:00 2001 From: 2ManyProjects Date: Mon, 3 Feb 2025 23:36:09 -0600 Subject: [PATCH] refactored tile child relationshio --- Systems/CardDisplay.gd | 152 +++++++++--------- Systems/Cards/Drunkdriving.gd | 36 ++--- Systems/Cards/Explosiveboots.gd | 24 +-- Systems/Cards/Supernova.gd | 21 ++- Systems/Game/ChessGame.gd | 45 +++--- Systems/PieceContainer.gd | 49 ++++++ .../StateMachine/GameStates/AttachCards.gd | 12 +- Systems/StateMachine/GameStates/Movement.gd | 145 ++++++++++------- addons/Chess/Scripts/King.gd | 24 ++- addons/Chess/Scripts/Pawn.gd | 13 +- addons/Chess/Scripts/Rook.gd | 10 +- board.tscn | 6 +- 12 files changed, 307 insertions(+), 230 deletions(-) create mode 100644 Systems/PieceContainer.gd diff --git a/Systems/CardDisplay.gd b/Systems/CardDisplay.gd index fff86fb..5cac4ff 100644 --- a/Systems/CardDisplay.gd +++ b/Systems/CardDisplay.gd @@ -1,100 +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 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 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 \ No newline at end of file + for display in cardDisplays: + display.queue_free() + cardDisplays.clear() + selectedCard = null \ No newline at end of file diff --git a/Systems/Cards/Drunkdriving.gd b/Systems/Cards/Drunkdriving.gd index 6bcbbb6..1a55a35 100644 --- a/Systems/Cards/Drunkdriving.gd +++ b/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 \ No newline at end of file diff --git a/Systems/Cards/Explosiveboots.gd b/Systems/Cards/Explosiveboots.gd index e20a2a8..c34cf2f 100644 --- a/Systems/Cards/Explosiveboots.gd +++ b/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 target_piece && 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() diff --git a/Systems/Cards/Supernova.gd b/Systems/Cards/Supernova.gd index 303a6da..0080084 100644 --- a/Systems/Cards/Supernova.gd +++ b/Systems/Cards/Supernova.gd @@ -54,25 +54,24 @@ func apply_effect(target_piece = null, board_flow = null, game_state = null): # 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("SupernovaOverlay") - if existing_overlay: - existing_overlay.queue_free() + # 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 = 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() diff --git a/Systems/Game/ChessGame.gd b/Systems/Game/ChessGame.gd index 3d9058b..47b972a 100644 --- a/Systems/Game/ChessGame.gd +++ b/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) @@ -131,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) @@ -218,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 @@ -251,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: @@ -284,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 @@ -315,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): @@ -348,28 +353,28 @@ 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) + 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 - # print("piece", piece) - # tileManager.process_tile_effect(old_location, piece, false) # Exiting old tile - 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 - # tileManager.process_tile_effect(targetLocation, piece, true) # Entering new tile resetHighlights() func togglePieceChessEffect() -> void: diff --git a/Systems/PieceContainer.gd b/Systems/PieceContainer.gd new file mode 100644 index 0000000..518748d --- /dev/null +++ b/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 \ No newline at end of file diff --git a/Systems/StateMachine/GameStates/AttachCards.gd b/Systems/StateMachine/GameStates/AttachCards.gd index be68525..772c454 100644 --- a/Systems/StateMachine/GameStates/AttachCards.gd +++ b/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() - - diff --git a/Systems/StateMachine/GameStates/Movement.gd b/Systems/StateMachine/GameStates/Movement.gd index fb6dbe8..b65fcef 100644 --- a/Systems/StateMachine/GameStates/Movement.gd +++ b/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() diff --git a/addons/Chess/Scripts/King.gd b/addons/Chess/Scripts/King.gd index f0bdd0f..069fe16 100644 --- a/addons/Chess/Scripts/King.gd +++ b/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 diff --git a/addons/Chess/Scripts/Pawn.gd b/addons/Chess/Scripts/Pawn.gd index f937b79..845fc45 100644 --- a/addons/Chess/Scripts/Pawn.gd +++ b/addons/Chess/Scripts/Pawn.gd @@ -109,9 +109,9 @@ func getValidMoves(board_flow, current_location: String) -> Dictionary: # 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) + 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]) @@ -124,7 +124,8 @@ func is_valid_cell(board_flow, location: String) -> bool: # 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) + var container = board_flow.get_node(location) as PieceContainer 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 piece = container.get_piece() + return piece != null && piece.Item_Color != self.Item_Color + return !container.has_piece() \ No newline at end of file diff --git a/addons/Chess/Scripts/Rook.gd b/addons/Chess/Scripts/Rook.gd index cc1549e..66fb2f1 100644 --- a/addons/Chess/Scripts/Rook.gd +++ b/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 diff --git a/board.tscn b/board.tscn index 2655b94..30ec2ba 100644 --- a/board.tscn +++ b/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="."]