267 lines
6.7 KiB
GDScript
267 lines
6.7 KiB
GDScript
extends Node
|
|
|
|
## GameController - Top-level controller managing menu and game states
|
|
|
|
enum State {
|
|
MENU,
|
|
DECK_BUILDER,
|
|
GAME_SETUP,
|
|
PLAYING,
|
|
PAUSED
|
|
}
|
|
|
|
var current_state: State = State.MENU
|
|
|
|
# Menu window size (matches project.godot viewport)
|
|
const MENU_SIZE := Vector2i(460, 689)
|
|
# Deck builder window size
|
|
const DECK_BUILDER_SIZE := Vector2i(1600, 900)
|
|
# Game setup window size
|
|
const GAME_SETUP_SIZE := Vector2i(800, 600)
|
|
# Game window size
|
|
const GAME_SIZE := Vector2i(2160, 980)
|
|
|
|
# Scene references
|
|
var main_menu: MainMenu = null
|
|
var deck_builder: DeckBuilder = null
|
|
var game_setup_menu: GameSetupMenu = null
|
|
var game_scene: Node3D = null
|
|
var pause_menu: PauseMenu = null
|
|
|
|
# Selected decks for gameplay
|
|
var selected_deck: Deck = null
|
|
var player1_deck: Array = [] # Card IDs for player 1
|
|
var player2_deck: Array = [] # Card IDs for player 2
|
|
|
|
# Preload the main game scene script
|
|
const MainScript = preload("res://scripts/Main.gd")
|
|
|
|
func _ready() -> void:
|
|
process_mode = Node.PROCESS_MODE_ALWAYS
|
|
_show_main_menu()
|
|
|
|
func _input(event: InputEvent) -> void:
|
|
if event is InputEventKey and event.pressed:
|
|
if event.keycode == KEY_ESCAPE:
|
|
match current_state:
|
|
State.DECK_BUILDER:
|
|
_on_deck_builder_back()
|
|
State.GAME_SETUP:
|
|
_on_game_setup_back()
|
|
State.PLAYING:
|
|
_show_pause_menu()
|
|
State.PAUSED:
|
|
_hide_pause_menu()
|
|
|
|
func _show_main_menu() -> void:
|
|
# Clean up any existing game
|
|
if game_scene:
|
|
game_scene.queue_free()
|
|
game_scene = null
|
|
|
|
if pause_menu:
|
|
pause_menu.queue_free()
|
|
pause_menu = null
|
|
|
|
# Switch back to small borderless menu window
|
|
DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)
|
|
DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, true)
|
|
DisplayServer.window_set_size(MENU_SIZE)
|
|
var screen := DisplayServer.screen_get_size()
|
|
DisplayServer.window_set_position(Vector2i(
|
|
(screen.x - MENU_SIZE.x) / 2,
|
|
(screen.y - MENU_SIZE.y) / 2
|
|
))
|
|
|
|
# Reset viewport to main menu size
|
|
get_tree().root.content_scale_size = MENU_SIZE
|
|
|
|
# Clean up deck builder if exists
|
|
if deck_builder:
|
|
deck_builder.queue_free()
|
|
deck_builder = null
|
|
|
|
# Clean up game setup menu if exists
|
|
if game_setup_menu:
|
|
game_setup_menu.queue_free()
|
|
game_setup_menu = null
|
|
|
|
# Create main menu
|
|
if not main_menu:
|
|
main_menu = MainMenu.new()
|
|
add_child(main_menu)
|
|
main_menu.play_game.connect(_on_start_game)
|
|
main_menu.deck_builder.connect(_on_deck_builder)
|
|
|
|
main_menu.visible = true
|
|
current_state = State.MENU
|
|
|
|
func _on_start_game() -> void:
|
|
# Hide menu
|
|
if main_menu:
|
|
main_menu.visible = false
|
|
|
|
# Show game setup menu
|
|
_show_game_setup_menu()
|
|
|
|
|
|
func _on_deck_builder() -> void:
|
|
# Hide menu
|
|
if main_menu:
|
|
main_menu.visible = false
|
|
|
|
# Switch to deck builder window size
|
|
DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, false)
|
|
DisplayServer.window_set_size(DECK_BUILDER_SIZE)
|
|
var screen := DisplayServer.screen_get_size()
|
|
DisplayServer.window_set_position(Vector2i(
|
|
(screen.x - DECK_BUILDER_SIZE.x) / 2,
|
|
(screen.y - DECK_BUILDER_SIZE.y) / 2
|
|
))
|
|
|
|
# Set viewport to deck builder size
|
|
get_tree().root.content_scale_size = DECK_BUILDER_SIZE
|
|
|
|
# Create deck builder
|
|
if not deck_builder:
|
|
deck_builder = DeckBuilder.new()
|
|
add_child(deck_builder)
|
|
deck_builder.back_pressed.connect(_on_deck_builder_back)
|
|
deck_builder.deck_selected.connect(_on_deck_selected)
|
|
|
|
deck_builder.visible = true
|
|
current_state = State.DECK_BUILDER
|
|
|
|
|
|
func _on_deck_builder_back() -> void:
|
|
if deck_builder:
|
|
deck_builder.visible = false
|
|
_show_main_menu()
|
|
|
|
|
|
func _show_game_setup_menu() -> void:
|
|
# Switch to game setup window size (borderless like main menu)
|
|
DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, true)
|
|
DisplayServer.window_set_size(GAME_SETUP_SIZE)
|
|
var screen := DisplayServer.screen_get_size()
|
|
DisplayServer.window_set_position(Vector2i(
|
|
(screen.x - GAME_SETUP_SIZE.x) / 2,
|
|
(screen.y - GAME_SETUP_SIZE.y) / 2
|
|
))
|
|
|
|
# Resize the root viewport to match the window size to avoid letterboxing
|
|
get_tree().root.content_scale_size = GAME_SETUP_SIZE
|
|
|
|
# Create game setup menu
|
|
if not game_setup_menu:
|
|
game_setup_menu = GameSetupMenu.new()
|
|
add_child(game_setup_menu)
|
|
game_setup_menu.back_pressed.connect(_on_game_setup_back)
|
|
game_setup_menu.start_game_requested.connect(_on_game_setup_start)
|
|
|
|
game_setup_menu.visible = true
|
|
current_state = State.GAME_SETUP
|
|
|
|
|
|
func _on_game_setup_back() -> void:
|
|
if game_setup_menu:
|
|
game_setup_menu.visible = false
|
|
_show_main_menu()
|
|
|
|
|
|
func _on_game_setup_start(p1_deck: Array, p2_deck: Array) -> void:
|
|
player1_deck = p1_deck
|
|
player2_deck = p2_deck
|
|
|
|
if game_setup_menu:
|
|
game_setup_menu.visible = false
|
|
|
|
# Switch to game window size
|
|
DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, false)
|
|
DisplayServer.window_set_size(GAME_SIZE)
|
|
var screen := DisplayServer.screen_get_size()
|
|
DisplayServer.window_set_position(Vector2i(
|
|
(screen.x - GAME_SIZE.x) / 2,
|
|
(screen.y - GAME_SIZE.y) / 2
|
|
))
|
|
|
|
# Set viewport to game size
|
|
get_tree().root.content_scale_size = GAME_SIZE
|
|
|
|
_start_new_game()
|
|
|
|
|
|
func _on_deck_selected(deck: Deck) -> void:
|
|
selected_deck = deck
|
|
if deck_builder:
|
|
deck_builder.visible = false
|
|
|
|
# Switch to game window size and start game
|
|
DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, false)
|
|
DisplayServer.window_set_size(GAME_SIZE)
|
|
var screen := DisplayServer.screen_get_size()
|
|
DisplayServer.window_set_position(Vector2i(
|
|
(screen.x - GAME_SIZE.x) / 2,
|
|
(screen.y - GAME_SIZE.y) / 2
|
|
))
|
|
|
|
# Set viewport to game size
|
|
get_tree().root.content_scale_size = GAME_SIZE
|
|
|
|
_start_new_game()
|
|
|
|
func _start_new_game() -> void:
|
|
# Make sure game isn't paused
|
|
get_tree().paused = false
|
|
|
|
# Clean up existing game
|
|
if game_scene:
|
|
game_scene.queue_free()
|
|
game_scene = null
|
|
|
|
# Reset GameManager state
|
|
if GameManager:
|
|
GameManager.is_game_active = false
|
|
GameManager.game_state = null
|
|
|
|
# Create new game scene
|
|
game_scene = Node3D.new()
|
|
game_scene.set_script(MainScript)
|
|
|
|
# Pass deck configurations if available
|
|
if player1_deck.size() > 0:
|
|
game_scene.player1_deck = player1_deck
|
|
if player2_deck.size() > 0:
|
|
game_scene.player2_deck = player2_deck
|
|
|
|
add_child(game_scene)
|
|
|
|
# Create pause menu
|
|
if not pause_menu:
|
|
pause_menu = PauseMenu.new()
|
|
add_child(pause_menu)
|
|
pause_menu.resume_game.connect(_on_resume_game)
|
|
pause_menu.restart_game.connect(_on_restart_game)
|
|
pause_menu.return_to_menu.connect(_on_return_to_menu)
|
|
|
|
current_state = State.PLAYING
|
|
|
|
func _show_pause_menu() -> void:
|
|
if pause_menu:
|
|
pause_menu.show_menu()
|
|
current_state = State.PAUSED
|
|
|
|
func _hide_pause_menu() -> void:
|
|
if pause_menu:
|
|
pause_menu.hide_menu()
|
|
current_state = State.PLAYING
|
|
|
|
func _on_resume_game() -> void:
|
|
current_state = State.PLAYING
|
|
|
|
func _on_restart_game() -> void:
|
|
_start_new_game()
|
|
|
|
func _on_return_to_menu() -> void:
|
|
_show_main_menu()
|