2023-11-08 14:28:55 +11:00
|
|
|
extends Node
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
signal wave_started(wave_number: int)
|
|
|
|
signal wave_finished(wave_number: int)
|
|
|
|
signal base_took_damage(remaining_health: int)
|
2024-03-31 19:32:00 +11:00
|
|
|
signal rng_seeded
|
|
|
|
signal game_setup
|
2023-11-08 14:28:55 +11:00
|
|
|
signal game_started
|
|
|
|
signal lost_game
|
|
|
|
signal won_game
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
var level_scene: PackedScene = load("res://Worlds/GreenPlanet/Levels/first_level.tscn")
|
|
|
|
var player_scene: PackedScene = load("res://PCs/hero.tscn")
|
2024-03-23 22:36:19 +11:00
|
|
|
var main_menu_scene_path: String = "res://Scenes/Menus/MainMenu/main_menu.tscn"
|
2024-02-22 06:22:22 +11:00
|
|
|
var multiplayer_lobby_scene_path: String = "res://Scenes/Menus/multiplayer_lobby.tscn"
|
|
|
|
var singleplayer_lobby_scene_path: String = "res://Scenes/Menus/singleplayer_lobby.tscn"
|
2024-03-31 19:32:00 +11:00
|
|
|
var game_end_scene: PackedScene = load("res://Scenes/Menus/GameEndScreen/game_end_screen.tscn")
|
2024-02-22 06:22:22 +11:00
|
|
|
var connected_players_nodes: Dictionary = {}
|
|
|
|
var game_active: bool = false
|
|
|
|
var level: Level
|
|
|
|
var enemies: int = 0
|
|
|
|
var objective_health: int = 120
|
|
|
|
var wave: int = 0
|
|
|
|
var endless_mode: bool = false
|
|
|
|
var upcoming_wave: Dictionary
|
|
|
|
var pot: float
|
|
|
|
var UILayer: CanvasLayer
|
|
|
|
var chatbox: Chatbox
|
|
|
|
var wave_limit: int = 20
|
|
|
|
var starting_cash: int = 16
|
|
|
|
var shop_chance: float = 0.0
|
2024-03-31 19:32:00 +11:00
|
|
|
var stats: RoundStats
|
2024-03-29 21:58:40 +11:00
|
|
|
var rng: FastNoiseLite
|
2023-11-11 19:03:01 +11:00
|
|
|
|
2024-03-31 19:32:00 +11:00
|
|
|
#TODO: Create a reference to some generic Lobby object that wraps the multiplayer players list stuff
|
|
|
|
var connected_player_profiles: Dictionary = {}
|
|
|
|
|
2023-11-11 19:03:01 +11:00
|
|
|
|
|
|
|
func _ready() -> void:
|
|
|
|
UILayer = CanvasLayer.new()
|
|
|
|
UILayer.layer = 2
|
|
|
|
get_tree().root.add_child.call_deferred(UILayer)
|
2023-11-08 14:28:55 +11:00
|
|
|
|
|
|
|
|
2024-03-29 21:58:40 +11:00
|
|
|
@rpc("reliable", "call_local")
|
|
|
|
func set_seed(value: int) -> void:
|
|
|
|
rng = FastNoiseLite.new()
|
|
|
|
rng.noise_type = FastNoiseLite.TYPE_VALUE
|
2024-03-31 19:32:00 +11:00
|
|
|
rng.frequency = 30
|
|
|
|
rng.fractal_octaves = 2
|
|
|
|
rng.fractal_gain = 0.1
|
2024-03-29 21:58:40 +11:00
|
|
|
rng.seed = value
|
|
|
|
rng_seeded.emit()
|
|
|
|
|
|
|
|
|
2024-03-31 19:32:00 +11:00
|
|
|
func randi_in_range(sample: float, output_start: int, output_end: int) -> int:
|
|
|
|
return floori(remap(rng.get_noise_1d(sample), -1.0, 1.0, float(output_start), float(output_end + 1)))
|
|
|
|
|
|
|
|
|
|
|
|
func randf_in_range(sample: float, output_start: float, output_end: float) -> float:
|
|
|
|
return remap(rng.get_noise_1d(sample), -1.0, 1.0, output_start, output_end)
|
2024-03-29 21:58:40 +11:00
|
|
|
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
func parse_command(text: String, peer_id: int) -> void:
|
2023-11-08 14:28:55 +11:00
|
|
|
if text.substr(1, 4) == "give":
|
2024-02-22 06:22:22 +11:00
|
|
|
var gift_name: String = text.substr(6) as String
|
|
|
|
var gift: Card = Data.cards[0]
|
|
|
|
for x: Card in Data.cards:
|
2023-12-17 02:02:16 +11:00
|
|
|
if x.display_name == gift_name:
|
2023-11-08 14:28:55 +11:00
|
|
|
gift = x
|
|
|
|
connected_players_nodes[peer_id].inventory.add(gift)
|
2023-12-08 03:27:10 +11:00
|
|
|
elif text.substr(1, 2) == "tr":
|
2023-11-17 20:49:38 +11:00
|
|
|
chatbox.append_message("SERVER", Color.TOMATO, "[color=#f7a8b8]t[color=#55cdfc]r[color=#ffffff]a[color=#55cdfc]n[color=#f7a8b8]s [color=#e50000]r[color=#ff8d00]i[color=#ffee00]g[color=#028121]h[color=#004cff]t[color=#760088]s[color=white]!!")
|
2023-12-08 03:27:10 +11:00
|
|
|
elif text.substr(1, 6) == "length":
|
|
|
|
chatbox.append_message("SERVER", Color.TOMATO, str(level.a_star_graph_3d.visualized_path.curve.get_baked_length()))
|
|
|
|
elif text.substr(1, 11) == "random_maze":
|
2023-11-19 18:47:52 +11:00
|
|
|
level.a_star_graph_3d.build_random_maze(50)
|
2023-12-08 03:27:10 +11:00
|
|
|
elif text.substr(1, 13) == "random_towers":
|
2024-02-22 06:22:22 +11:00
|
|
|
level.a_star_graph_3d.place_random_towers(floori(level.a_star_graph_3d.tower_bases.size() / 3.0))
|
2023-12-08 03:27:10 +11:00
|
|
|
elif text.substr(1, 11) == "set_endless":
|
2023-11-19 18:47:52 +11:00
|
|
|
if is_multiplayer_authority():
|
|
|
|
networked_set_endless.rpc(true)
|
|
|
|
else:
|
|
|
|
chatbox.append_message("SERVER", Color.TOMATO, "Unable to edit gamemode")
|
2023-12-08 03:27:10 +11:00
|
|
|
elif text.substr(1, 12) == "set_standard":
|
2023-11-19 18:47:52 +11:00
|
|
|
if is_multiplayer_authority():
|
|
|
|
networked_set_endless.rpc(false)
|
|
|
|
else:
|
|
|
|
chatbox.append_message("SERVER", Color.TOMATO, "Unable to edit gamemode")
|
2023-12-08 03:27:10 +11:00
|
|
|
elif text.substr(1, 11) == "spawn_print":
|
2024-03-29 21:58:40 +11:00
|
|
|
level.printer._on_static_body_3d_button_interacted(0, connected_players_nodes[peer_id].inventory)
|
2023-12-08 03:27:10 +11:00
|
|
|
elif text.substr(1, 10) == "spawn_shop":
|
2023-11-20 21:20:29 +11:00
|
|
|
level.shop.randomize_cards()
|
2023-12-08 03:27:10 +11:00
|
|
|
elif text.substr(1, 7) == "prosper":
|
2024-02-22 06:22:22 +11:00
|
|
|
for id: int in connected_players_nodes:
|
2023-11-20 21:20:29 +11:00
|
|
|
connected_players_nodes[id].currency += 50
|
2023-12-08 03:27:10 +11:00
|
|
|
elif text.substr(1, 8) == "set_wave":
|
2023-11-28 16:52:15 +11:00
|
|
|
if is_multiplayer_authority():
|
|
|
|
networked_set_wave.rpc(int(text.substr(10)))
|
|
|
|
else:
|
|
|
|
chatbox.append_message("SERVER", Color.TOMATO, "Unable to set wave")
|
2024-03-29 21:58:40 +11:00
|
|
|
elif text.substr(1, 4) == "seed":
|
|
|
|
chatbox.append_message("SERVER", Color.TOMATO, str(rng.seed))
|
2023-11-17 20:49:38 +11:00
|
|
|
# if text.substr(1, 17) == "show tower ranges":
|
|
|
|
# pass
|
|
|
|
# if text.substr(1, 20) = "show gauntlet ranges":
|
|
|
|
# pass
|
2023-11-08 14:28:55 +11:00
|
|
|
|
|
|
|
|
2023-11-28 16:52:15 +11:00
|
|
|
@rpc("reliable", "call_local")
|
2024-02-22 06:22:22 +11:00
|
|
|
func networked_set_wave(wave_number: int) -> void:
|
2023-11-28 16:52:15 +11:00
|
|
|
chatbox.append_message("SERVER", Color.TOMATO, "Set to wave " + str(wave_number))
|
2024-02-22 06:22:22 +11:00
|
|
|
for player: int in connected_players_nodes:
|
2023-11-28 16:52:15 +11:00
|
|
|
connected_players_nodes[player].hud.set_wave_count(wave_number)
|
|
|
|
wave = wave_number
|
|
|
|
set_upcoming_wave()
|
|
|
|
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
func spawn_level() -> void:
|
2023-11-08 14:28:55 +11:00
|
|
|
level = level_scene.instantiate() as Level
|
2024-02-22 06:22:22 +11:00
|
|
|
for x: EnemySpawner in level.enemy_spawns:
|
2023-11-08 14:28:55 +11:00
|
|
|
#x.path = level.a_star_graph_3d.visualized_path
|
2024-02-22 06:22:22 +11:00
|
|
|
x.enemy_died_callback = enemy_died
|
|
|
|
x.enemy_reached_goal_callback = damage_goal
|
|
|
|
x.enemy_spawned.connect(increase_enemy_count)
|
2023-11-08 14:28:55 +11:00
|
|
|
add_child(level)
|
|
|
|
|
|
|
|
|
2024-03-31 19:32:00 +11:00
|
|
|
func spawn_players() -> void:
|
2024-02-22 06:22:22 +11:00
|
|
|
var p_i: int = 0
|
2024-03-31 19:32:00 +11:00
|
|
|
var player_array: Array = connected_player_profiles.keys()
|
2023-11-08 14:28:55 +11:00
|
|
|
player_array.sort()
|
2024-02-22 06:22:22 +11:00
|
|
|
for peer_id: int in player_array:
|
|
|
|
var player: Hero = player_scene.instantiate() as Hero
|
2023-11-08 14:28:55 +11:00
|
|
|
player.name = str(peer_id)
|
2024-03-31 19:32:00 +11:00
|
|
|
player.player_name_tag.text = connected_player_profiles[peer_id].display_name
|
2023-11-08 14:28:55 +11:00
|
|
|
player.position = level.player_spawns[p_i].global_position
|
2024-03-31 19:32:00 +11:00
|
|
|
player.profile = connected_player_profiles[peer_id]
|
|
|
|
player.hero_class = Data.characters[connected_player_profiles[peer_id].preferred_class]
|
2023-11-08 14:28:55 +11:00
|
|
|
player.ready_state_changed.connect(ready_player)
|
|
|
|
if peer_id == multiplayer.get_unique_id():
|
2024-03-31 19:32:00 +11:00
|
|
|
chatbox.opened.connect(player.pause)
|
|
|
|
chatbox.closed.connect(player.unpause)
|
2023-11-08 14:28:55 +11:00
|
|
|
player.set_multiplayer_authority(peer_id)
|
|
|
|
connected_players_nodes[peer_id] = player
|
|
|
|
wave_started.connect(player.exit_editing_mode)
|
|
|
|
wave_finished.connect(player.enter_editing_mode)
|
|
|
|
base_took_damage.connect(player.hud.set_lives_count)
|
|
|
|
add_child(player)
|
|
|
|
p_i += 1
|
2023-11-19 18:47:52 +11:00
|
|
|
level.cinematic_cam.does_its_thing = false
|
2023-11-08 14:28:55 +11:00
|
|
|
|
|
|
|
|
2024-03-30 00:54:41 +11:00
|
|
|
func ready_player(player_ready_true: bool) -> void:
|
|
|
|
if !player_ready_true:
|
|
|
|
return
|
|
|
|
var ready_players: int = 0
|
2024-02-22 06:22:22 +11:00
|
|
|
for key: int in connected_players_nodes:
|
2023-11-08 14:28:55 +11:00
|
|
|
if connected_players_nodes[key].ready_state == false:
|
2024-03-30 00:54:41 +11:00
|
|
|
continue
|
|
|
|
else:
|
|
|
|
ready_players += 1
|
|
|
|
if ready_players == connected_players_nodes.size():
|
|
|
|
spawn_enemy_wave()
|
2024-03-31 19:32:00 +11:00
|
|
|
#chatbox.append_message("SERVER", Color.TOMATO, "Wave Started!")
|
2024-03-30 00:54:41 +11:00
|
|
|
else:
|
|
|
|
chatbox.append_message("SERVER", Color.TOMATO, str(ready_players) + "/" + str(connected_players_nodes.size()) + " Players ready")
|
2023-11-08 14:28:55 +11:00
|
|
|
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
func spawn_enemy_wave() -> void:
|
2023-11-20 21:20:29 +11:00
|
|
|
level.shop.close()
|
2023-11-08 14:28:55 +11:00
|
|
|
wave += 1
|
|
|
|
level.a_star_graph_3d.find_path()
|
|
|
|
level.a_star_graph_3d.visualized_path.disable_visualization()
|
2023-11-28 16:52:15 +11:00
|
|
|
level.a_star_graph_3d.disable_all_tower_frames()
|
2024-02-22 06:22:22 +11:00
|
|
|
for spawn: EnemySpawner in level.enemy_spawns:
|
2023-11-08 14:28:55 +11:00
|
|
|
spawn.spawn_wave(upcoming_wave)
|
|
|
|
wave_started.emit(wave)
|
|
|
|
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
func set_upcoming_wave() -> void:
|
2023-11-13 19:36:35 +11:00
|
|
|
if is_multiplayer_authority():
|
2024-02-22 06:22:22 +11:00
|
|
|
var spawn_power: int = WaveManager.calculate_spawn_power(wave + 1, connected_players_nodes.size())
|
|
|
|
var new_wave: Dictionary = WaveManager.generate_wave(spawn_power, level.enemy_pool)
|
|
|
|
networked_set_upcoming_wave.rpc(new_wave, 6 + floori(spawn_power / 70.0))
|
2023-11-13 19:36:35 +11:00
|
|
|
|
|
|
|
|
|
|
|
@rpc("reliable", "call_local")
|
2024-02-22 06:22:22 +11:00
|
|
|
func networked_set_upcoming_wave(wave_dict: Dictionary, coins: int) -> void:
|
2023-11-13 19:36:35 +11:00
|
|
|
upcoming_wave = wave_dict
|
|
|
|
pot = coins
|
2024-02-22 06:22:22 +11:00
|
|
|
for key: int in connected_players_nodes:
|
2023-11-13 19:36:35 +11:00
|
|
|
connected_players_nodes[key].hud.set_upcoming_wave(upcoming_wave)
|
2023-11-08 14:28:55 +11:00
|
|
|
|
|
|
|
|
2023-11-19 18:47:52 +11:00
|
|
|
@rpc("reliable", "call_local")
|
2024-02-22 06:22:22 +11:00
|
|
|
func networked_set_endless(value: bool) -> void:
|
2023-11-19 18:47:52 +11:00
|
|
|
endless_mode = value
|
|
|
|
if endless_mode:
|
|
|
|
chatbox.append_message("SERVER", Color.TOMATO, "Endless mode enabled!")
|
|
|
|
else:
|
|
|
|
chatbox.append_message("SERVER", Color.TOMATO, "Endless mode disabled!")
|
|
|
|
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
func increase_enemy_count() -> void:
|
2023-11-08 14:28:55 +11:00
|
|
|
enemies += 1
|
|
|
|
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
func enemy_died(enemy: Enemy) -> void:
|
2023-11-08 14:28:55 +11:00
|
|
|
enemies -= 1
|
2024-02-22 06:22:22 +11:00
|
|
|
for key: int in connected_players_nodes:
|
2023-11-09 17:56:08 +11:00
|
|
|
connected_players_nodes[key].hud.enemy_count_down(enemy)
|
2024-02-22 06:22:22 +11:00
|
|
|
for x: EnemySpawner in level.enemy_spawns:
|
2023-11-08 14:28:55 +11:00
|
|
|
if !x.done_spawning:
|
|
|
|
return
|
|
|
|
if enemies == 0:
|
|
|
|
end_wave()
|
2023-11-19 18:47:52 +11:00
|
|
|
if !endless_mode and wave >= wave_limit:
|
2024-03-31 19:32:00 +11:00
|
|
|
end(true)
|
2023-11-08 14:28:55 +11:00
|
|
|
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
func damage_goal(enemy: Enemy, penalty: int) -> void:
|
2023-11-08 14:28:55 +11:00
|
|
|
enemies -= 1
|
2024-02-22 06:22:22 +11:00
|
|
|
stats.add_enemy_undefeated(wave, enemy)
|
|
|
|
for key: int in connected_players_nodes:
|
2023-11-09 17:56:08 +11:00
|
|
|
connected_players_nodes[key].hud.enemy_count_down(enemy)
|
2023-11-08 14:28:55 +11:00
|
|
|
objective_health -= penalty
|
|
|
|
base_took_damage.emit(objective_health)
|
|
|
|
if objective_health <= 0:
|
2024-03-31 19:32:00 +11:00
|
|
|
end(false)
|
2023-11-08 14:28:55 +11:00
|
|
|
elif enemies == 0:
|
|
|
|
end_wave()
|
2023-11-19 18:47:52 +11:00
|
|
|
if !endless_mode and wave >= wave_limit:
|
2024-03-31 19:32:00 +11:00
|
|
|
end(true)
|
2023-11-08 14:28:55 +11:00
|
|
|
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
func end_wave() -> void:
|
|
|
|
for peer_id: int in connected_players_nodes:
|
2023-11-13 19:36:35 +11:00
|
|
|
connected_players_nodes[peer_id].currency += ceili(pot / connected_players_nodes.size())
|
2024-03-30 13:55:36 +11:00
|
|
|
connected_players_nodes[peer_id].unready_self()
|
2023-11-08 14:28:55 +11:00
|
|
|
level.a_star_graph_3d.visualized_path.enable_visualization()
|
2023-11-28 16:52:15 +11:00
|
|
|
level.a_star_graph_3d.enable_non_path_tower_frames()
|
2023-11-20 21:20:29 +11:00
|
|
|
if is_multiplayer_authority():
|
2024-03-31 19:32:00 +11:00
|
|
|
if randf_in_range(23 * wave, 0.0, 1.0) <= shop_chance:
|
2023-11-20 21:20:29 +11:00
|
|
|
networked_spawn_shop.rpc()
|
|
|
|
shop_chance = 0.0
|
|
|
|
else:
|
2024-03-31 19:32:00 +11:00
|
|
|
shop_chance += 0.07
|
2023-11-08 14:28:55 +11:00
|
|
|
wave_finished.emit(wave)
|
|
|
|
set_upcoming_wave()
|
|
|
|
|
|
|
|
|
2023-11-20 21:20:29 +11:00
|
|
|
@rpc("reliable", "call_local")
|
2024-02-22 06:22:22 +11:00
|
|
|
func networked_spawn_shop() -> void:
|
2023-11-20 21:20:29 +11:00
|
|
|
level.shop.randomize_cards()
|
|
|
|
chatbox.append_message("SERVER", Color.TOMATO, "A shopkeeper has arrived!")
|
|
|
|
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
func remove_player(peer_id: int) -> void:
|
2023-11-16 00:07:41 +11:00
|
|
|
if connected_players_nodes.has(peer_id):
|
|
|
|
connected_players_nodes[peer_id].queue_free()
|
|
|
|
connected_players_nodes.erase(peer_id)
|
2023-11-08 14:28:55 +11:00
|
|
|
|
|
|
|
|
2024-03-31 19:32:00 +11:00
|
|
|
func setup() -> void:
|
|
|
|
#clean up old stuff
|
|
|
|
if level:
|
|
|
|
level.queue_free()
|
2024-02-22 06:22:22 +11:00
|
|
|
for peer_id: int in connected_players_nodes:
|
2023-11-08 14:28:55 +11:00
|
|
|
connected_players_nodes[peer_id].queue_free()
|
|
|
|
connected_players_nodes.clear()
|
2024-03-31 19:32:00 +11:00
|
|
|
|
|
|
|
#Spawn new stuff
|
|
|
|
spawn_level()
|
|
|
|
|
|
|
|
#Set starting parameters
|
|
|
|
game_active = false
|
2023-11-08 14:28:55 +11:00
|
|
|
enemies = 0
|
2023-11-16 00:07:41 +11:00
|
|
|
objective_health = 120
|
2023-11-08 14:28:55 +11:00
|
|
|
wave = 0
|
2024-02-22 06:22:22 +11:00
|
|
|
stats = RoundStats.new()
|
2024-03-31 19:32:00 +11:00
|
|
|
game_setup.emit()
|
2023-11-08 14:28:55 +11:00
|
|
|
|
|
|
|
|
2024-03-31 19:32:00 +11:00
|
|
|
func start(rng_seed: int = randi()) -> void:
|
|
|
|
if is_multiplayer_authority():
|
|
|
|
set_seed.rpc(rng_seed)
|
|
|
|
else:
|
|
|
|
await rng_seeded
|
|
|
|
|
|
|
|
#Relies on player list having been decided
|
|
|
|
spawn_players()
|
2024-02-22 06:22:22 +11:00
|
|
|
for peer_id: int in connected_players_nodes:
|
2024-03-31 19:32:00 +11:00
|
|
|
connected_players_nodes[peer_id].currency = ceili(float(starting_cash) / float(connected_players_nodes.size()))
|
|
|
|
|
|
|
|
#Relies on rng having been seeded
|
|
|
|
set_upcoming_wave()
|
|
|
|
level.a_star_graph_3d.make_grid()
|
|
|
|
level.generate_obstacles()
|
|
|
|
level.a_star_graph_3d.disable_all_tower_frames()
|
|
|
|
level.a_star_graph_3d.enable_non_path_tower_frames()
|
|
|
|
level.a_star_graph_3d.find_path()
|
|
|
|
|
|
|
|
#Start game
|
|
|
|
game_active = true
|
|
|
|
chatbox.append_message("SERVER", Color.TOMATO, "Started with seed: " + str(rng.seed))
|
|
|
|
game_started.emit()
|
2023-11-08 14:28:55 +11:00
|
|
|
|
|
|
|
|
2024-03-31 19:32:00 +11:00
|
|
|
func end(outcome: bool) -> void:
|
2023-11-08 14:28:55 +11:00
|
|
|
if game_active == false:
|
|
|
|
return
|
|
|
|
game_active = false
|
2024-03-31 19:32:00 +11:00
|
|
|
Data.save_stats.add_game_outcome(outcome)
|
2023-12-17 02:02:16 +11:00
|
|
|
Data.save_stats.save_profile_to_disk()
|
2024-03-31 19:32:00 +11:00
|
|
|
var menu: GameEndScreen = game_end_scene.instantiate() as GameEndScreen
|
|
|
|
match outcome:
|
|
|
|
false:
|
|
|
|
menu.set_outcome_message("You lost...")
|
|
|
|
lost_game.emit()
|
|
|
|
true:
|
|
|
|
menu.set_outcome_message("You win!")
|
|
|
|
won_game.emit()
|
2023-11-11 19:03:01 +11:00
|
|
|
UILayer.add_child(menu)
|
2023-11-08 14:28:55 +11:00
|
|
|
Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
|
2024-03-31 19:32:00 +11:00
|
|
|
connected_players_nodes[multiplayer.get_unique_id()].pause()
|
2023-11-08 14:28:55 +11:00
|
|
|
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
func quit_to_desktop() -> void:
|
2023-11-08 14:28:55 +11:00
|
|
|
multiplayer.multiplayer_peer.close()
|
|
|
|
multiplayer.multiplayer_peer = null
|
|
|
|
get_tree().quit()
|
|
|
|
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
func scene_switch_main_menu() -> void:
|
|
|
|
for node: Node in get_children():
|
2023-11-08 14:28:55 +11:00
|
|
|
node.queue_free()
|
2024-03-31 19:32:00 +11:00
|
|
|
level = null
|
|
|
|
connected_players_nodes.clear()
|
2023-11-09 20:37:12 +11:00
|
|
|
multiplayer.multiplayer_peer.close()
|
|
|
|
multiplayer.multiplayer_peer = null
|
2023-11-08 14:28:55 +11:00
|
|
|
get_tree().change_scene_to_file(main_menu_scene_path)
|
|
|
|
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
func scene_switch_to_multiplayer_lobby() -> void:
|
2023-11-08 14:28:55 +11:00
|
|
|
get_tree().change_scene_to_file(multiplayer_lobby_scene_path)
|
|
|
|
|
|
|
|
|
2024-02-22 06:22:22 +11:00
|
|
|
func scene_switch_to_singleplayer_lobby() -> void:
|
2023-11-08 14:28:55 +11:00
|
|
|
get_tree().change_scene_to_file(singleplayer_lobby_scene_path)
|