250 lines
7 KiB
GDScript
250 lines
7 KiB
GDScript
extends Control
|
|
class_name ProgressionScreen
|
|
|
|
signal save_pressed
|
|
signal deck_manager_visibility_changed(isvisible)
|
|
|
|
@onready var deckGrid = $MainContainer/GridScrollContainer/GridContainer
|
|
@onready var bankContainer = $MainContainer/BankContainer/ScrollContainer/VBoxContainer
|
|
@onready var saveButton = $SaveButton
|
|
@onready var card_preview = $CardPreviewPanel
|
|
|
|
var maxDeckSize = 10
|
|
var deckManager = null
|
|
var game = null
|
|
var bankCards = [] # All Users card
|
|
|
|
# The current deck
|
|
var currentDeck = []
|
|
var current_preview_card = null
|
|
|
|
func _ready():
|
|
# Connect back button
|
|
if saveButton:
|
|
saveButton.connect("pressed", Callable(self, "_on_save_button_pressed"))
|
|
|
|
if card_preview:
|
|
card_preview.visible = false
|
|
|
|
|
|
func initialize(options = null):
|
|
if options:
|
|
if options.has("max_deck_size") and options.max_deck_size is int:
|
|
maxDeckSize = options.max_deck_size
|
|
|
|
|
|
# Find the DeckManager instance
|
|
var board = get_node_or_null("/root/Board") as ChessGame
|
|
game = board
|
|
if board and "deckManager" in board:
|
|
deckManager = board.deckManager
|
|
print("Found deck manager:", deckManager)
|
|
# if(!deckManager.deck):
|
|
# deckManager.initializeStartingDeck()
|
|
else:
|
|
print("DeckManager not found on Board node")
|
|
print("DECK MANAGER")
|
|
|
|
# Load cards from deck and bank
|
|
loadCards()
|
|
|
|
# Set up the grid with empty card containers
|
|
setupDeckGrid()
|
|
|
|
# Populate the bank with available cards
|
|
populateBank()
|
|
|
|
func loadCards():
|
|
var board = get_node_or_null("/root/Board") as ChessGame
|
|
if board and "deckManager" in board:
|
|
deckManager = board.deckManager
|
|
print("Found deck manager:", deckManager)
|
|
if deckManager:
|
|
# Clone the deck to work with
|
|
currentDeck = []
|
|
bankCards = deckManager.bank.duplicate()
|
|
bankCards.append_array(deckManager.deck.duplicate())
|
|
else:
|
|
# Fallback with empty collections if deck manager not found
|
|
currentDeck = []
|
|
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 = maxDeckSize / cols
|
|
deckGrid.columns = cols
|
|
|
|
# Create card slots
|
|
for i in range(maxDeckSize):
|
|
var card_slot = preload("res://card_slot.tscn").instantiate()
|
|
deckGrid.add_child(card_slot)
|
|
|
|
# Connect signals
|
|
card_slot.connect("card_selected", Callable(self, "_on_deck_card_selected"))
|
|
_connect_hover_signals(card_slot)
|
|
|
|
# Set card if available
|
|
if i < currentDeck.size():
|
|
card_slot.set_card(currentDeck[i])
|
|
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():
|
|
# Clear existing children
|
|
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)
|
|
|
|
func _on_deck_card_selected(card_slot, card):
|
|
if card:
|
|
# Remove card from deck
|
|
var index = currentDeck.find(card)
|
|
if index >= 0:
|
|
currentDeck.remove_at(index)
|
|
|
|
# Add to bank
|
|
bankCards.append(card)
|
|
|
|
# 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")
|
|
# Find first empty slot in deck
|
|
var empty_slot_index = -1
|
|
for i in range(deckGrid.get_child_count()):
|
|
var slot = deckGrid.get_child(i)
|
|
if !slot.has_card():
|
|
empty_slot_index = i
|
|
break
|
|
|
|
if empty_slot_index >= 0 and currentDeck.size() < maxDeckSize:
|
|
# Remove from bank
|
|
var bank_index = bankCards.find(card)
|
|
if bank_index >= 0:
|
|
bankCards.remove_at(bank_index)
|
|
|
|
# Add to deck
|
|
currentDeck.append(card)
|
|
|
|
# Update UI
|
|
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)
|
|
|
|
func hide_card_preview():
|
|
if card_preview:
|
|
current_preview_card = null
|
|
card_preview.hide_preview()
|
|
|
|
func save_deck():
|
|
sell_remaining_cards()
|
|
if deckManager:
|
|
# Save the current deck to the deck manager
|
|
deckManager.deck = currentDeck.duplicate()
|
|
deckManager.bank = []
|
|
|
|
print("Deck saved with ", currentDeck.size(), " cards")
|
|
if game.player:
|
|
game.player.increment_runs()
|
|
|
|
func sell_remaining_cards():
|
|
for card in bankCards:
|
|
sell_selected_card(card)
|
|
bankCards.clear()
|
|
|
|
func get_card_price(card):
|
|
if not card:
|
|
return 0
|
|
if card.rank in Utils.CardPrices:
|
|
return Utils.CardPrices[card.rank]
|
|
return 50
|
|
|
|
|
|
func sell_selected_card(selected_card):
|
|
|
|
var price = get_card_price(selected_card)
|
|
|
|
game.player.add_gold(price)
|
|
|
|
return true
|
|
|
|
func _on_save_button_pressed():
|
|
# Save changes before returning
|
|
save_deck()
|
|
|
|
# Emit signal to go back
|
|
emit_signal("save_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("Progression Screen visibility changed to: ", is_visible)
|
|
if is_visible:
|
|
loadCards()
|
|
setupDeckGrid()
|
|
else:
|
|
print("Progression Screen is now invisible")
|
|
|
|
emit_signal("progression_screen_visibility_changed", is_visible)
|