458 lines
19 KiB
GDScript
458 lines
19 KiB
GDScript
extends Node
|
|
class_name TutorialManager
|
|
|
|
var overlay
|
|
var main_scene: Node
|
|
var local_player: Node
|
|
|
|
func _ready() -> void:
|
|
process_mode = Node.PROCESS_MODE_ALWAYS
|
|
|
|
# Wait for gridmap, Player, and UI to spawn fully
|
|
await get_tree().create_timer(1.0).timeout
|
|
|
|
main_scene = get_tree().root.get_node_or_null("Main")
|
|
if not main_scene: return
|
|
|
|
# Wait for the client to gain character control
|
|
var max_wait = 5.0
|
|
var elapsed = 0.0
|
|
while not local_player and elapsed < max_wait:
|
|
for p in get_tree().get_nodes_in_group("Players"):
|
|
if p.is_multiplayer_authority():
|
|
local_player = p
|
|
break
|
|
await get_tree().process_frame
|
|
elapsed += get_process_delta_time()
|
|
|
|
# Pause match timer during tutorial
|
|
if main_scene and main_scene.get("goals_cycle_manager"):
|
|
main_scene.goals_cycle_manager.set_process(false)
|
|
|
|
if not local_player:
|
|
print("Tutorial Error: Local player not found.")
|
|
return
|
|
|
|
# Freeze bots while teaching
|
|
_set_bots_enabled(false)
|
|
|
|
# Make sure the UI overlay exists — instantiate as a full scene
|
|
var overlay_scene = load("res://scenes/tutorial/tutorial_overlay.tscn")
|
|
if overlay_scene:
|
|
overlay = overlay_scene.instantiate()
|
|
add_child(overlay)
|
|
_run_tutorial()
|
|
else:
|
|
print("Tutorial Error: tutorial_overlay.tscn not found.")
|
|
|
|
func _set_bots_enabled(enabled: bool) -> void:
|
|
for p in get_tree().get_nodes_in_group("Bots"):
|
|
var bc = p.get_node_or_null("BotController")
|
|
if bc:
|
|
bc.set_process(enabled)
|
|
bc.set_physics_process(enabled)
|
|
p.set("is_frozen", not enabled)
|
|
|
|
func _get_ui_rect(path: String) -> Rect2:
|
|
var node = main_scene.get_node_or_null(path)
|
|
if node and node is Control:
|
|
# get_global_rect() returns coords in the node's canvas layer space.
|
|
# We need to apply the viewport canvas transform so they line up with
|
|
# the TutorialOverlay CanvasLayer (which renders in viewport space).
|
|
var rect = node.get_global_rect()
|
|
return rect
|
|
return Rect2()
|
|
|
|
func _run_tutorial() -> void:
|
|
get_tree().paused = true
|
|
|
|
# Intro
|
|
await overlay.display_text("Welcome to the Arena. I'm Commander Copper. Let me walk you through the basics of Free Mode.", true)
|
|
|
|
# Playerboard Highlight
|
|
overlay.highlight_zone("PlayerBoard")
|
|
await overlay.display_text("This is your [color=green]Playerboard[/color]. Your main objective is to fill these empty slots.", true)
|
|
|
|
# Goal / Timer Highlight
|
|
overlay.highlight_zone("GoalsTimer")
|
|
await overlay.display_text("These are your [color=gold]Goals[/color]. You must match these exact tiles specifically to score points.", true)
|
|
|
|
# (AP system removed — no longer in use)
|
|
|
|
# Grid Highlight
|
|
overlay.clear_highlight()
|
|
await overlay.display_text("Look at the board! You will see [color=gold]Normal Tiles[/color] and shiny [color=cyan]Holo Tiles[/color].", true)
|
|
# ==============================================================================
|
|
# --- INTERACTIVE 1: NORMAL TILE ---
|
|
# ==============================================================================
|
|
var normal_pos = _find_closest_tile(local_player.current_position, [7, 8, 9, 10], 4)
|
|
if normal_pos != Vector2i(-1, -1):
|
|
_highlight_floor_cell(normal_pos, Color(1.0, 1.0, 0.0)) # Yellow box
|
|
overlay.display_text("I've highlighted a [color=gold]Normal Tile[/color] with a yellow box. Walk over to it and press [color=red]SPACE[/color] to Grab it!", false)
|
|
else:
|
|
overlay.display_text("Walk up to any Normal Tile and press [color=red]SPACE[/color] to Grab it!", false)
|
|
|
|
overlay.set_objective("Walk to a [color=gold]Normal Tile[/color] and press [color=red]SPACE[/color] to grab it.")
|
|
overlay.hide_overlay()
|
|
get_tree().paused = false
|
|
|
|
# Wait strictly until the specific tile is grabbed, or any tile if no specific one was found
|
|
var initial_items = local_player.playerboard.count(-1)
|
|
while true:
|
|
if normal_pos != Vector2i(-1, -1) and local_player.get("enhanced_gridmap"):
|
|
if local_player.enhanced_gridmap.get_cell_item(Vector3i(normal_pos.x, 1, normal_pos.y)) == -1:
|
|
break
|
|
elif local_player.playerboard.count(-1) < initial_items:
|
|
break
|
|
await get_tree().process_frame
|
|
|
|
overlay.hide_objective()
|
|
_clear_floor_highlights()
|
|
get_tree().paused = true
|
|
overlay.show_overlay()
|
|
|
|
await overlay.display_text("Outstanding! You secured a tile.", true)
|
|
# ==============================================================================
|
|
# --- SCORE AND GOALS SECTION ---
|
|
# ==============================================================================
|
|
overlay.highlight_zone("Leaderboard")
|
|
await overlay.display_text("Your main objective is to climb the [color=gold]Leaderboard[/color] on the right by scoring points.", true)
|
|
|
|
overlay.highlight_zone("PlayerBoard")
|
|
await overlay.display_text("You earn points by collecting tiles, but the real score comes from completing your [color=gold]Playerboard Goals[/color]!", true)
|
|
await overlay.display_text("Fill your entire board shape to complete a goal. This grants massive points, clears the board, and ranks you up!", true)
|
|
|
|
# ==============================================================================
|
|
# --- POWER UP SECTION ---
|
|
# ==============================================================================
|
|
await overlay.display_text("Now, let's talk about [color=cyan]Holo Tiles[/color]. They grant you special Power-Ups!", true)
|
|
|
|
overlay.clear_highlight()
|
|
await overlay.display_text("There are [color=cyan]4 types of Power-Ups[/color] from Holo Tiles. Let me walk you through each one, one by one.", true)
|
|
|
|
var powerup_ids = [11, 12, 13, 14]
|
|
var powerup_names = {
|
|
11: "[color=gold]Speed Boost[/color] (Make you run fast)",
|
|
12: "[color=aqua]Area Freeze[/color] (Slows nearby opponents)",
|
|
13: "[color=gray]Iron Wall[/color] (Blocks opponent path)",
|
|
14: "[color=white]Ghost Mode[/color] (Invisibility and ram immunity)"
|
|
}
|
|
var powerup_enums = {11: 0, 12: 1, 13: 2, 14: 3}
|
|
var gridmap = local_player.get("enhanced_gridmap")
|
|
|
|
for pid in powerup_ids:
|
|
overlay.clear_highlight()
|
|
overlay.show_powerup_card(pid)
|
|
await overlay.display_text("Next is %s. I will drop this Holo Tile near you." % powerup_names[pid], true)
|
|
overlay.hide_powerup_card()
|
|
|
|
var ppos = local_player.current_position + Vector2i(0, 1)
|
|
if gridmap:
|
|
gridmap.set_cell_item(Vector3i(ppos.x, 1, ppos.y), pid)
|
|
_highlight_floor_cell(ppos, Color(0.0, 1.0, 1.0))
|
|
|
|
overlay.display_text("Grab the tile, press [color=yellow]'F'[/color] to use it, and for some skills press it again or Click to confirm!", false)
|
|
|
|
overlay.set_objective("Grab the [color=cyan]Holo Tile[/color] and press [color=yellow]'F'[/color] to use %s." % powerup_names[pid])
|
|
overlay.hide_overlay()
|
|
get_tree().paused = false
|
|
|
|
# Wait for it to be grabbed
|
|
while gridmap and gridmap.get_cell_item(Vector3i(ppos.x, 1, ppos.y)) == pid:
|
|
await get_tree().process_frame
|
|
|
|
# Highlight the Power-Up item slot now that they picked it up
|
|
overlay.highlight_zone("PowerUpItem")
|
|
|
|
# Wait for it to be used
|
|
var effect_enum = powerup_enums[pid]
|
|
while local_player.get("special_tiles_manager") and local_player.special_tiles_manager.inventory.get(effect_enum, false) == true:
|
|
await get_tree().process_frame
|
|
|
|
overlay.clear_highlight()
|
|
|
|
overlay.hide_objective()
|
|
_clear_floor_highlights()
|
|
get_tree().paused = true
|
|
overlay.show_overlay()
|
|
await overlay.display_text("Excellent! You used %s." % powerup_names[pid], true)
|
|
|
|
# ==============================================================================
|
|
# --- TEKTONS SECTION ---
|
|
# ==============================================================================
|
|
overlay.clear_highlight()
|
|
# --- DYNAMIC TEKTON FOCUS ---
|
|
var dynamic_tektons = get_tree().get_nodes_in_group("Tektons")
|
|
var cam_mgr = main_scene.get("camera_context_manager") if main_scene else null
|
|
if dynamic_tektons.size() > 0 and cam_mgr:
|
|
# Find nearest dynamic tekton
|
|
var nearest = null
|
|
var nearest_dist = 999999
|
|
for tk in dynamic_tektons:
|
|
if tk.get("is_static_turret") == false:
|
|
var dist = local_player.global_position.distance_to(tk.global_position)
|
|
if dist < nearest_dist:
|
|
nearest_dist = dist
|
|
nearest = tk
|
|
|
|
if nearest:
|
|
cam_mgr.process_mode = Node.PROCESS_MODE_ALWAYS
|
|
cam_mgr.set_player(nearest)
|
|
await get_tree().create_timer(1.2, true).timeout
|
|
|
|
var cam = main_scene.get_node_or_null("Camera3D200")
|
|
if cam and cam is Camera3D:
|
|
var screen_pos = cam.unproject_position(nearest.global_position)
|
|
overlay.highlight_rect(Rect2(screen_pos.x - 75, screen_pos.y - 75, 150, 150))
|
|
|
|
await overlay.display_text("Now, what about those little creatures running around the map? Those are [color=cyan]Tektons[/color]!", true)
|
|
|
|
if cam_mgr:
|
|
cam_mgr.set_player(local_player)
|
|
cam_mgr.process_mode = Node.PROCESS_MODE_INHERIT
|
|
overlay.clear_highlight()
|
|
await get_tree().create_timer(0.8, true).timeout
|
|
# ----------------------------
|
|
|
|
await overlay.display_text("Grabbing a dynamic Tekton gives you [color=gold]PASSIVE score points[/color] over time and spawns bonus tiles for you while you carry it.", true)
|
|
await overlay.display_text("Hold onto them as long as you can... but watch out, opponents will try to RAM you and steal them!", true)
|
|
|
|
await overlay.display_text("Go and catch one of the Tektons running around!", false)
|
|
overlay.set_objective("Walk into a [color=cyan]Tekton[/color] or press [color=red]G[/color] near one to grab it.")
|
|
overlay.hide_overlay()
|
|
get_tree().paused = false
|
|
|
|
while not local_player.is_carrying_tekton:
|
|
await get_tree().process_frame
|
|
|
|
overlay.hide_objective()
|
|
get_tree().paused = true
|
|
overlay.show_overlay()
|
|
await overlay.display_text("Great job! Notice your score passively increasing.", true)
|
|
|
|
await overlay.display_text("But you won't hold it forever! The Tekton runs away when your carry timer reaches 0, or you can manually throw it by pressing [color=red]G[/color].", false)
|
|
overlay.set_objective("Wait for the [color=cyan]Tekton[/color] to escape, or press [color=red]G[/color] to throw it!")
|
|
overlay.hide_overlay()
|
|
get_tree().paused = false
|
|
|
|
while local_player.is_carrying_tekton:
|
|
await get_tree().process_frame
|
|
|
|
overlay.hide_objective()
|
|
get_tree().paused = true
|
|
overlay.show_overlay()
|
|
await overlay.display_text("Oops, it got away! But don't worry, you can always catch another one.", true)
|
|
|
|
# ==============================================================================
|
|
# --- STATIC TEKTON FOCUS ---
|
|
# ==============================================================================
|
|
var static_stands = get_tree().get_nodes_in_group("StaticTektonStands")
|
|
cam_mgr = main_scene.get("camera_context_manager") if main_scene else null
|
|
|
|
if static_stands.size() > 0 and cam_mgr:
|
|
var target_stand = static_stands[0]
|
|
cam_mgr.process_mode = Node.PROCESS_MODE_ALWAYS # Allow camera to slide while paused
|
|
cam_mgr.set_player(target_stand)
|
|
|
|
# Give it time to pan over
|
|
await get_tree().create_timer(1.2, true).timeout
|
|
|
|
# Dim the screen around it
|
|
var cam = main_scene.get_node_or_null("Camera3D200")
|
|
if cam and cam is Camera3D:
|
|
var screen_pos = cam.unproject_position(target_stand.global_position)
|
|
overlay.highlight_rect(Rect2(screen_pos.x - 100, screen_pos.y - 120, 200, 200))
|
|
|
|
await overlay.display_text("Also keep an eye on [color=gray]Static Tektons[/color] standing on podiums. They periodically throw new free tiles onto the board for you to collect!", true)
|
|
|
|
if cam_mgr:
|
|
cam_mgr.set_player(local_player)
|
|
cam_mgr.process_mode = Node.PROCESS_MODE_INHERIT
|
|
overlay.clear_highlight()
|
|
|
|
# Let it pan back briefly
|
|
await get_tree().create_timer(0.8, true).timeout
|
|
# ==============================================================================
|
|
# --- BATTERY GAUGE & RAMMING SECTION ---
|
|
# ==============================================================================
|
|
# Switch to highlight Power Bar / Battery Gauge
|
|
overlay.highlight_zone("PowerBar")
|
|
await overlay.display_text("Next, look at your [color=cyan]Battery Gauge[/color] — it [color=yellow]fills up automatically over time[/color]. You don't need to do anything to charge it.", true)
|
|
await overlay.display_text("When the Battery Gauge is [color=red]FULL[/color], you'll see the [color=red]ATTACK MODE READY[/color] notification.", true)
|
|
|
|
overlay.clear_highlight()
|
|
|
|
# Ramming explanation and practice
|
|
await overlay.display_text("What is Attack Mode? It lets you [color=red]RAM[/color] other players!", true)
|
|
await overlay.display_text("Press [color=yellow]'Q'[/color] to enter [color=red]ATTACK MODE[/color]. While active, walk directly into an opponent to [color=red]RAM[/color] them!", true)
|
|
await overlay.display_text("Ramming pushes them back and forces them to drop their tile. Each hit drains your Battery Gauge.", true)
|
|
|
|
var spawned_bot = null
|
|
for p in get_tree().get_nodes_in_group("Bots"):
|
|
spawned_bot = p
|
|
break
|
|
|
|
# Force spawn a dummy bot if the lobby settings disabled them
|
|
if not spawned_bot and get_node_or_null("/root/PlayerManager"):
|
|
spawned_bot = get_node("/root/PlayerManager").create_bot(99)
|
|
get_parent().add_child(spawned_bot)
|
|
spawned_bot.add_to_group("Players", true)
|
|
spawned_bot.add_to_group("Bots", true)
|
|
await get_tree().create_timer(0.2).timeout
|
|
|
|
var bc = spawned_bot.get_node_or_null("BotController")
|
|
if bc:
|
|
bc.set_process(true)
|
|
bc.set_physics_process(true)
|
|
|
|
if spawned_bot:
|
|
# Always unfreeze in case it was caught in the earlier Area Freeze blast
|
|
spawned_bot.set("is_frozen", false)
|
|
var target_bc = spawned_bot.get_node_or_null("BotController")
|
|
if target_bc:
|
|
target_bc.set_process(true)
|
|
target_bc.set_physics_process(true)
|
|
|
|
await overlay.display_text("Let's try it. There is a Bot roaming the map right now. I will fill your Battery Gauge to max.", true)
|
|
|
|
# --- CAMERA PAN TO BOT ---
|
|
cam_mgr = main_scene.get("camera_context_manager") if main_scene else null
|
|
if cam_mgr:
|
|
cam_mgr.process_mode = Node.PROCESS_MODE_ALWAYS
|
|
cam_mgr.set_player(spawned_bot)
|
|
await get_tree().create_timer(1.2, true).timeout
|
|
|
|
var cam = main_scene.get_node_or_null("Camera3D200")
|
|
if cam and cam is Camera3D:
|
|
var screen_pos = cam.unproject_position(spawned_bot.global_position)
|
|
overlay.highlight_rect(Rect2(screen_pos.x - 75, screen_pos.y - 100, 150, 150))
|
|
|
|
await overlay.display_text("Behold, your opponent! Their AI is active so you will have to hunt them down.", true)
|
|
|
|
if cam_mgr:
|
|
cam_mgr.set_player(local_player)
|
|
cam_mgr.process_mode = Node.PROCESS_MODE_INHERIT
|
|
overlay.clear_highlight()
|
|
await get_tree().create_timer(0.8, true).timeout
|
|
# ------------------------
|
|
|
|
# Instantly grant FULL BOOST
|
|
if local_player.get("powerup_manager"):
|
|
local_player.powerup_manager.acquire_smash_bonus()
|
|
local_player.powerup_manager.acquire_smash_bonus()
|
|
local_player.powerup_manager.acquire_smash_bonus()
|
|
local_player.powerup_manager.acquire_smash_bonus()
|
|
|
|
overlay.display_text("Press 'Q' to enter Attack Mode, then chase the Bot down to RAM it!", false)
|
|
|
|
overlay.set_objective("Press [color=yellow]'Q'[/color] to enter [color=red]ATTACK MODE[/color], then chase and RAM the bot!")
|
|
overlay.hide_overlay()
|
|
get_tree().paused = false
|
|
|
|
# Wait for the player to push the bot
|
|
while true:
|
|
if spawned_bot.get("is_knock_mode") == true:
|
|
break
|
|
|
|
# Fallback: if player's attack mode deactivated early despite having timer left, they likely successfully rammed
|
|
var t = local_player.get("attack_mode_timer")
|
|
if local_player.get("is_attack_mode") == false and t != null and t > 0.0 and t < 3.0:
|
|
break
|
|
|
|
await get_tree().process_frame
|
|
|
|
overlay.hide_objective()
|
|
get_tree().paused = true
|
|
overlay.show_overlay()
|
|
await overlay.display_text("Smashing! You pushed it away. Notice your Battery Gauge was consumed.", true)
|
|
|
|
await overlay.display_text("Beware! Your opponents can RAM you to steal your tiles too. Get ready to defend yourself against the Bots!", true)
|
|
|
|
await overlay.display_text("Tutorial Complete! Returning to the Main Menu.", true)
|
|
|
|
overlay.hide_overlay()
|
|
get_tree().paused = false
|
|
|
|
if main_scene and main_scene.get("goals_cycle_manager"):
|
|
main_scene.goals_cycle_manager.set_process(true)
|
|
|
|
LobbyManager.is_tutorial_mode = false
|
|
LobbyManager.leave_room()
|
|
get_tree().change_scene_to_file("res://scenes/lobby.tscn")
|
|
|
|
# ==============================================================================
|
|
# Helper Floor Highlighting and Tile Detection Logic
|
|
# ==============================================================================
|
|
|
|
var _floor_highlights: Array[Node] = []
|
|
|
|
func _find_closest_tile(start_pos: Vector2i, types: Array, min_dist: int = 0) -> Vector2i:
|
|
var gridmap = local_player.get("enhanced_gridmap")
|
|
if not gridmap: return Vector2i(-1, -1)
|
|
|
|
var best_pos = Vector2i(-1, -1)
|
|
var best_dist = 999999
|
|
|
|
for x in range(gridmap.columns):
|
|
for z in range(gridmap.rows):
|
|
var item = gridmap.get_cell_item(Vector3i(x, 1, z))
|
|
if item in types:
|
|
var dist = abs(start_pos.x - x) + abs(start_pos.y - z)
|
|
if dist >= min_dist and dist < best_dist:
|
|
best_dist = dist
|
|
best_pos = Vector2i(x, z)
|
|
return best_pos
|
|
|
|
func _highlight_floor_cell(grid_pos: Vector2i, color: Color):
|
|
var gridmap = local_player.get("enhanced_gridmap")
|
|
if not gridmap: return
|
|
|
|
var cs: Vector3 = gridmap.cell_size
|
|
# Sit slightly above the floor grid (using layer 2 height approximation)
|
|
var y := 2.0 * cs.y + 0.09
|
|
const T := 0.09 # Outline thickness
|
|
const H := 0.045 # Outline height
|
|
|
|
var mat := StandardMaterial3D.new()
|
|
mat.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA
|
|
mat.albedo_color = Color(color.r, color.g, color.b, 0.6)
|
|
mat.emission_enabled = true
|
|
mat.emission = color
|
|
mat.emission_energy_multiplier = 2.0
|
|
mat.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
|
|
mat.cull_mode = BaseMaterial3D.CULL_DISABLED
|
|
|
|
var container := Node3D.new()
|
|
gridmap.add_child(container)
|
|
_floor_highlights.append(container)
|
|
|
|
var cell_cx = grid_pos.x * cs.x + cs.x * 0.5
|
|
var cell_cz = grid_pos.y * cs.z + cs.z * 0.5
|
|
|
|
var edges = [
|
|
{"pos": Vector3(cell_cx, y, grid_pos.y * cs.z), "size": Vector3(cs.x, H, T)},
|
|
{"pos": Vector3(cell_cx, y, grid_pos.y * cs.z + cs.z), "size": Vector3(cs.x, H, T)},
|
|
{"pos": Vector3(grid_pos.x * cs.x, y, cell_cz), "size": Vector3(T, H, cs.z)},
|
|
{"pos": Vector3(grid_pos.x * cs.x + cs.x, y, cell_cz), "size": Vector3(T, H, cs.z)}
|
|
]
|
|
|
|
for edge in edges:
|
|
var mi := MeshInstance3D.new()
|
|
var box := BoxMesh.new()
|
|
box.size = edge.size
|
|
box.material = mat
|
|
mi.mesh = box
|
|
mi.position = edge.pos
|
|
container.add_child(mi)
|
|
|
|
# Subtly pulse the highlight
|
|
var tween = create_tween().set_loops()
|
|
tween.tween_method(func(a: float): if is_instance_valid(mat): mat.albedo_color.a = a, 0.7, 0.2, 0.6).set_ease(Tween.EASE_OUT)
|
|
tween.tween_method(func(a: float): if is_instance_valid(mat): mat.albedo_color.a = a, 0.2, 0.7, 0.6).set_ease(Tween.EASE_IN)
|
|
|
|
func _clear_floor_highlights():
|
|
for h in _floor_highlights:
|
|
if is_instance_valid(h):
|
|
h.queue_free()
|
|
_floor_highlights.clear()
|