root/ChessBuilder
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: root:ff873687f3ad653c40258bf894a93dd9fe0f409c
Branches Tags
root:master
root:delete_node_fish
root:Stockfish
root:tileImplmentation
root:StateMachine
..
compare: root:5d410a02fb45e1e47b9645a7f8d6b75a17a1f4a4
Branches Tags
root:master
root:delete_node_fish
root:Stockfish
root:tileImplmentation
root:StateMachine

No commits in common. "ff873687f3ad653c40258bf894a93dd9fe0f409c" and "5d410a02fb45e1e47b9645a7f8d6b75a17a1f4a4" have entirely different histories.
ff873687f3 ... 5d410a02fb

17 changed files with 328 additions and 746 deletions
Show stats Expand all files Collapse all files

25
Systems/CardDisplay.gd
View file

@ -1,18 +1,17 @@
class_name CardDisplay extends Control extends Control
class_name CardDisplay
const CARD_WIDTH = 150
const CARD_HEIGHT = 250
const CARD_MARGIN = 10
var cardDisplays = [] var cardDisplays = []
var selectedCard = null var selectedCard = null
var container: HBoxContainer const CARD_WIDTH = 150
const CARD_HEIGHT = 250
const CARD_MARGIN = 10
@onready var container: HBoxContainer
func _ready(): func _ready():
# Create the container first
container = HBoxContainer.new() container = HBoxContainer.new()
container.name = "Hand" container.name = "Hand"
container.position = Vector2(10, 500) container.set_position(Vector2(10, 500))
add_child(container) add_child(container)
func update_hand(hand: Array): func update_hand(hand: Array):
@ -44,18 +43,13 @@ func add_card_display(card):
descLabel.custom_minimum_size = Vector2(CARD_WIDTH - 10, 0) descLabel.custom_minimum_size = Vector2(CARD_WIDTH - 10, 0)
vbox.add_child(descLabel) 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() var idLabel = Label.new()
idLabel.text = card.id.substr(card.id.length() - 8, -1) idLabel.text = card.id.substr(card.id.length() - 8, -1)
idLabel.autowrap_mode = true idLabel.autowrap_mode = true
idLabel.custom_minimum_size = Vector2(CARD_WIDTH - 10, 0) idLabel.custom_minimum_size = Vector2(CARD_WIDTH - 10, 0)
vbox.add_child(idLabel) vbox.add_child(idLabel)
cardPanel.gui_input.connect(func(event): _on_card_clicked(event, card)) cardPanel.gui_input.connect(func(event): _on_card_clicked(event, card))
cardDisplays.append(cardPanel) cardDisplays.append(cardPanel)
@ -69,6 +63,9 @@ func _on_card_clicked(event: InputEvent, card: Card):
elif selectedCard.id == card.id: elif selectedCard.id == card.id:
selectedCard = null selectedCard = null
highlight_selectedCard(selectedCard) highlight_selectedCard(selectedCard)
# selectedCard = card
# highlight_selectedCard(card)
# container.emit_signal("card_pressed", card)
func highlight_selectedCard(selected: Card) -> void: func highlight_selectedCard(selected: Card) -> void:
for display in cardDisplays: for display in cardDisplays:

36
Systems/Cards/Drunkdriving.gd
View file

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

22
Systems/Cards/Explosiveboots.gd
View file

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

79
Systems/Cards/Supernova.gd
View file

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

51
Systems/Game/ChessGame.gd
View file

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

49
Systems/PieceContainer.gd
View file

@ -1,49 +0,0 @@
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

8
Systems/StateMachine/GameStates/AttachCards.gd
View file

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

139
Systems/StateMachine/GameStates/Movement.gd
View file

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

99
Systems/Tile.gd
View file

@ -1,99 +0,0 @@
@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

93
Systems/TileManager.gd
View file

@ -1,93 +0,0 @@
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()

39
Systems/Tiles/DoubleMovement.gd
View file

@ -1,39 +0,0 @@
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()

34
Systems/Tiles/FireWall.gd
View file

@ -1,34 +0,0 @@
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()

35
Systems/Tiles/PawnBoost.gd
View file

@ -1,35 +0,0 @@
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()

22
addons/Chess/Scripts/King.gd
View file

@ -61,15 +61,17 @@ func check_kingside_castle(board_flow, x: int, y: int) -> bool:
var check_pos = str(x + i) + "-" + str(y) var check_pos = str(x + i) + "-" + str(y)
if !is_valid_cell(board_flow, check_pos) || !can_move_to_cell(board_flow, check_pos): if !is_valid_cell(board_flow, check_pos) || !can_move_to_cell(board_flow, check_pos):
return false 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) var rook_pos = str(x + 3) + "-" + str(y)
if !is_valid_cell(board_flow, rook_pos): if !is_valid_cell(board_flow, rook_pos):
return false return false
var rook_container = board_flow.get_node(rook_pos) as PieceContainer
var rook = rook_container.get_piece() 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)
return rook.name == "Rook" && rook.Castling && rook.Item_Color == self.Item_Color return rook.name == "Rook" && rook.Castling && rook.Item_Color == self.Item_Color
func check_queenside_castle(board_flow, x: int, y: int) -> bool: func check_queenside_castle(board_flow, x: int, y: int) -> bool:
@ -78,15 +80,15 @@ func check_queenside_castle(board_flow, x: int, y: int) -> bool:
var check_pos = str(x - i) + "-" + str(y) var check_pos = str(x - i) + "-" + str(y)
if !is_valid_cell(board_flow, check_pos) || !can_move_to_cell(board_flow, check_pos): if !is_valid_cell(board_flow, check_pos) || !can_move_to_cell(board_flow, check_pos):
return false 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 # Check if rook is in position and hasn't moved
var rook_pos = str(x - 4) + "-" + str(y) var rook_pos = str(x - 4) + "-" + str(y)
if !is_valid_cell(board_flow, rook_pos): if !is_valid_cell(board_flow, rook_pos):
return false return false
var rook_container = board_flow.get_node(rook_pos) as PieceContainer var rook_node = board_flow.get_node(rook_pos)
var rook = rook_container.get_piece() if rook_node.get_child_count() != 1:
return false
var rook = rook_node.get_child(0)
return rook.name == "Rook" && rook.Castling && rook.Item_Color == self.Item_Color return rook.name == "Rook" && rook.Castling && rook.Item_Color == self.Item_Color

13
addons/Chess/Scripts/Pawn.gd
View file

@ -109,9 +109,9 @@ func getValidMoves(board_flow, current_location: String) -> Dictionary:
# En Passant # En Passant
var adjacent = str(x + dx) + "-" + str(y) var adjacent = str(x + dx) + "-" + str(y)
if is_valid_cell(board_flow, adjacent) && is_valid_cell(board_flow, capture): if is_valid_cell(board_flow, adjacent) && is_valid_cell(board_flow, capture):
var adjacent_cell = board_flow.get_node(adjacent) as PieceContainer var adjacent_cell = board_flow.get_node(adjacent)
if adjacent_cell.get_piece() != null: if adjacent_cell.get_child_count() == 1:
var adjacent_piece = adjacent_cell.get_piece() var adjacent_piece = adjacent_cell.get_child(0)
if adjacent_piece.name == "Pawn" && adjacent_piece.En_Passant && adjacent_piece.Item_Color != self.Item_Color: if adjacent_piece.name == "Pawn" && adjacent_piece.En_Passant && adjacent_piece.Item_Color != self.Item_Color:
moves.special_moves.append([adjacent, capture]) moves.special_moves.append([adjacent, capture])
@ -124,8 +124,7 @@ func is_valid_cell(board_flow, location: String) -> bool:
# Helper for checking if cell is empty or contains enemy # Helper for checking if cell is empty or contains enemy
func can_move_to_cell(board_flow, location: String, is_capture: bool = false) -> bool: func can_move_to_cell(board_flow, location: String, is_capture: bool = false) -> bool:
var container = board_flow.get_node(location) as PieceContainer var node = board_flow.get_node(location)
if is_capture: if is_capture:
var piece = container.get_piece() return node.get_child_count() == 1 && node.get_child(0).Item_Color != self.Item_Color
return piece != null && piece.Item_Color != self.Item_Color return node.get_child_count() == 0
return !container.has_piece()

8
addons/Chess/Scripts/Rook.gd
View file

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

6
board.tscn
View file

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