258 lines
8 KiB
GDScript
258 lines
8 KiB
GDScript
extends Control
|
|
class_name HandPreloadScreen
|
|
|
|
signal back_pressed
|
|
signal preload_visibility_changed(isvisible)
|
|
|
|
# Node references
|
|
@onready var deckGrid = $MainContainer/GridScrollContainer/GridContainer
|
|
@onready var bankContainer = $MainContainer/BankContainer/ScrollContainer/VBoxContainer
|
|
@onready var backButton = $BackButton
|
|
@onready var card_preview = $CardPreviewPanel
|
|
@onready var token_label = $TokenLabel
|
|
@onready var cost_label = $CostLabel
|
|
|
|
var handSize = 2
|
|
var deckManager = null
|
|
var player = null
|
|
var bankCards = [] # Cards available
|
|
var tokens = 0
|
|
|
|
var usedSlots = []
|
|
var currentHand = []
|
|
var current_preview_card = null
|
|
|
|
func _ready():
|
|
# Connect back button
|
|
if backButton:
|
|
backButton.connect("pressed", Callable(self, "_on_backButton_pressed"))
|
|
|
|
if card_preview:
|
|
card_preview.visible = false
|
|
if cost_label:
|
|
cost_label.visible = false
|
|
|
|
|
|
func initialize(options = null):
|
|
# Find the DeckManager instance
|
|
var board = get_node_or_null("/root/Board") as ChessGame
|
|
if board and "deckManager" in board:
|
|
deckManager = board.deckManager
|
|
print("Found deck manager:", deckManager)
|
|
else:
|
|
print("DeckManager not found on Board node")
|
|
if board and "player" in board:
|
|
player = board.player
|
|
handSize = player.hand_size
|
|
tokens = player.tokens
|
|
updateTokenLabel()
|
|
else:
|
|
print("Player not found on Board node")
|
|
|
|
# Load cards from deck and bank
|
|
loadCards()
|
|
|
|
# Set up the grid with empty card containers
|
|
setupDeckGrid()
|
|
|
|
# Populate the bank with available cards
|
|
populateBank()
|
|
|
|
|
|
func updateTokenLabel():
|
|
if token_label:
|
|
token_label.text = str(tokens) + " TOKENS"
|
|
|
|
func loadCards():
|
|
if deckManager:
|
|
currentHand.clear()
|
|
usedSlots.clear()
|
|
# Clone the deck to work with
|
|
bankCards = deckManager.deck.duplicate()
|
|
for id in deckManager.preloaded_hand_cards:
|
|
var matchCard = func matchCardId(card):
|
|
return "id" in card and card.id == id
|
|
var cardIndex = bankCards.find_custom(matchCard.bind())
|
|
if cardIndex != -1:
|
|
currentHand.append(bankCards[cardIndex].id)
|
|
usedSlots.append(true)
|
|
|
|
else:
|
|
# Fallback with empty collections if deck manager not found
|
|
currentHand = []
|
|
bankCards = []
|
|
print("Warning: DeckManager not found")
|
|
|
|
|
|
func setupDeckGrid():
|
|
# Clear existing children
|
|
for child in deckGrid.get_children():
|
|
child.queue_free()
|
|
|
|
# Calculate grid dimensions
|
|
var cols = 4 #check screen to deteremine
|
|
var rows = handSize / cols
|
|
deckGrid.columns = cols
|
|
|
|
# Create card slots
|
|
for i in range(handSize):
|
|
var card_slot = preload("res://card_slot.tscn").instantiate()
|
|
deckGrid.add_child(card_slot)
|
|
|
|
# Connect signals
|
|
card_slot.connect("card_selected", Callable(self, "_on_hand_card_selected"))
|
|
_connect_hover_signals(card_slot)
|
|
|
|
# Set card if available
|
|
if i < currentHand.size():
|
|
var matchCard = func matchCardId(card):
|
|
return "id" in card and card.id == currentHand[i]
|
|
var cardIndex = bankCards.find_custom(matchCard.bind())
|
|
if cardIndex != -1:
|
|
card_slot.set_card(bankCards[cardIndex])
|
|
else:
|
|
card_slot.clear()
|
|
|
|
func _connect_hover_signals(node):
|
|
# Add hover signals for preview functionality
|
|
if node.is_class("Control"):
|
|
node.mouse_entered.connect(Callable(self, "_on_card_mouse_entered").bind(node))
|
|
# node.mouse_exited.connect(Callable(self, "_on_card_mouse_exited").bind(node))
|
|
|
|
|
|
func populateBank():
|
|
for child in bankContainer.get_children():
|
|
child.queue_free()
|
|
|
|
# Add each bank card to the list
|
|
for card in bankCards:
|
|
var card_item = preload("res://card_bank_item.tscn").instantiate()
|
|
bankContainer.add_child(card_item)
|
|
card_item.set_card(card)
|
|
card_item.connect("card_selected", Callable(self, "_on_bank_card_selected"))
|
|
_connect_hover_signals(card_item)
|
|
|
|
|
|
static var TokenCosts = {
|
|
Card.Rank.RANK_0: 15, # Most expensive (one-time use)
|
|
Card.Rank.RANK_1: 10, # Expensive (once per match)
|
|
Card.Rank.RANK_2: 5, # Medium (multiple uses)
|
|
Card.Rank.RANK_3: 3 # Cheapest (basic cards)
|
|
}
|
|
|
|
func _on_hand_card_selected(card_slot, card):
|
|
if card:
|
|
# Remove card from deck
|
|
var index = currentHand.find(card.id)
|
|
if index >= 0:
|
|
currentHand.remove_at(index)
|
|
if index < usedSlots.size() and usedSlots[index] != true:
|
|
tokens += Utils.TokenCosts[card.rank]
|
|
usedSlots.remove_at(index)
|
|
updateTokenLabel()
|
|
|
|
|
|
# Update UI
|
|
card_slot.clear()
|
|
populateBank()
|
|
if current_preview_card == card:
|
|
hide_card_preview()
|
|
|
|
func _on_bank_card_selected(card_item, card):
|
|
print("_on_bank_card_selected ", card.id)
|
|
# Find first empty slot in deck
|
|
var empty_slot_index = -1
|
|
if card and (card.rank == Card.Rank.RANK_2 || card.rank == Card.Rank.RANK_3):
|
|
for i in range(deckGrid.get_child_count()):
|
|
var slot = deckGrid.get_child(i)
|
|
if !slot.has_card():
|
|
empty_slot_index = i
|
|
break
|
|
|
|
# print("_on_bank_card_selected ", currentHand, " ", handSize, " ", empty_slot_index, )
|
|
# print("_on_bank_card_selected ", empty_slot_index >= 0, " ", currentHand.size() < handSize, " ", currentHand.find(card.id))
|
|
if empty_slot_index >= 0 and currentHand.size() < handSize and currentHand.find(card.id) == -1 and tokens - Utils.TokenCosts[card.rank] > 0:
|
|
# print("currentHand append ", card.id)
|
|
|
|
tokens -= Utils.TokenCosts[card.rank]
|
|
updateTokenLabel()
|
|
currentHand.append(card.id)
|
|
usedSlots.append(false)
|
|
|
|
deckGrid.get_child(empty_slot_index).set_card(card)
|
|
populateBank()
|
|
|
|
func _on_card_mouse_entered(node):
|
|
var card = null
|
|
|
|
# Get the card from the node
|
|
if node.has_method("has_card") and node.has_card():
|
|
# This is a CardSlot
|
|
card = node.current_card
|
|
elif node.has_method("set_card") and node.current_card:
|
|
# This is a CardBankItem
|
|
card = node.current_card
|
|
|
|
if card:
|
|
show_card_preview(card)
|
|
|
|
# func _on_card_mouse_exited(node):
|
|
# # Add a short delay before hiding the preview
|
|
# # This prevents flickering when moving between cards
|
|
# await get_tree().create_timer(0.1).timeout
|
|
|
|
# # Only hide if we're not hovering over another card that shows the same preview
|
|
# if current_preview_card:
|
|
# hide_card_preview()
|
|
|
|
func show_card_preview(card):
|
|
if card_preview and card:
|
|
current_preview_card = card
|
|
card_preview.preview_card(card)
|
|
if cost_label:
|
|
cost_label.visible = true
|
|
cost_label.text = "Cost: " + str(Utils.TokenCosts[card.rank]) + " tokens"
|
|
|
|
func hide_card_preview():
|
|
if cost_label:
|
|
cost_label.visible = false
|
|
if card_preview:
|
|
current_preview_card = null
|
|
card_preview.hide_preview()
|
|
|
|
func savePreloadCards():
|
|
if deckManager:
|
|
# Save the current deck to the deck manager
|
|
deckManager.preloaded_hand_cards = currentHand.duplicate()
|
|
|
|
print("Preloads saved with ", currentHand.size(), " cards")
|
|
player.tokens = tokens
|
|
|
|
func _on_backButton_pressed():
|
|
# Save changes before returning
|
|
savePreloadCards()
|
|
|
|
# Emit signal to go back
|
|
emit_signal("back_pressed")
|
|
|
|
# Hide this screen
|
|
visible = false
|
|
|
|
|
|
|
|
|
|
# Notification
|
|
func _notification(what):
|
|
if what == NOTIFICATION_VISIBILITY_CHANGED:
|
|
_on_visibility_changed(visible)
|
|
|
|
func _on_visibility_changed(is_visible):
|
|
|
|
print("Preload Screen visibility changed to: ", is_visible)
|
|
if is_visible:
|
|
loadCards()
|
|
setupDeckGrid()
|
|
else:
|
|
print("Preload Screen is now invisible")
|
|
|
|
emit_signal("preload_visibility_changed", is_visible)
|