← Back to path Download .md

🧠 Center Village (Free)

Teen 19 lessons · ~152 min · Generated 2026-07-04

The REAL AweShucks Town UEFN island needs: TERRAIN/BUILD — central town plaza (CTF arena footprint with two flag bases), island market street, map-room building (Hall of Badges wall inside), Jitterbean coffee shop, five themed portal booths ringing the plaza (flamingo/bear/dragon

Learning Outcomes

Lesson 1: Town Plaza Wiring: the Trigger Device is Your Event Glue

Objectives

Student can wire device-to-device events in the editor and Subscribe to TriggeredEvent in Verse to react to anything happening in the world.

🔁 Builds on: south-shores: OnBegin + Subscribe pattern from the first-device lessons

🧩 Your capstone piece: Plaza gate triggers that arm each portal booth and fire the hub event bus

Quiz

  1. What type does the trigger_device's TriggeredEvent hand to your subscribed handler?
    • A. agent
    • B. ?agent (an optional agent)
    • C. player
    • D. fort_character
  2. Why must you declare the trigger as an @editable field inside your creative_device class?
    • A. To make it run faster
    • B. So you can bind it to the placed device and call its methods; a bare Device.Method() fails
    • C. Because TriggeredEvent only works on editable fields
    • D. It is optional and only for readability
  3. What value passed to SetMaxTriggerCount means 'no limit'?
    • A. 20
    • B. -1
    • C. 0
    • D. 100
  4. What does GetTriggerCountRemaining() return when the device's max trigger count is unlimited?
    • A. The number of players in the game
    • B. 20
    • C. 0
    • D. An error
  5. Which call fires the device's TriggeredEvent from code while attaching a specific player?
    • A. Trigger()
    • B. Trigger(Agent)
    • C. Enable()
    • D. SetTransmitDelay(Agent)
Answer key
  1. B — TriggeredEvent is listenable(?agent) because the device can also be fired from code with no agent, so you must unwrap the option before using it.
  2. B — Calling a method on a placed device requires an @editable field you point at the device in the Details panel; otherwise you get 'Unknown identifier'.
  3. C — 0 indicates unlimited triggers. The argument is clamped between 0 and 20.
  4. C — Per the API, it returns 0 when GetMaxTriggerCount is unlimited, so don't treat 0 as 'empty' in that configuration.
  5. B — Trigger(Agent:agent) fires the event and passes that agent along; the agentless Trigger() fires with no agent.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — Plaza gate triggers that arm each portal booth and fire the hub event bus

Sources

Lesson 2: Booth Buttons: Bridging Device Interactions into Verse

Objectives

Student can subscribe to button InteractedWithEvent, read the interacting agent, and route it into their own functions.

🔁 Builds on: south-shores: one-responsibility-per-function (clean handler functions)

🧩 Your capstone piece: The interact button at each of the 5 zone-portal booths

Quiz

  1. Which method subscribes a handler to a Button device interaction?
    • A. Button.InteractedWithEvent.Subscribe(Handler)
    • B. Button.InteractedWithEvent().Subscribe(Handler)
    • C. Button.OnInteract(Handler)
    • D. Subscribe(Button.InteractedWithEvent, Handler)
  2. Why must `GetPlayerUI[InPlayer]` be called inside an `if` condition?
    • A. It is slow
    • B. It is a <decides> (fallible) call using [] brackets, which are only legal in a failure context
    • C. It returns a string
    • D. It requires <suspends>
  3. Why can't you pass the `agent` directly to `GetPlayerUI`?
    • A. Agents don't exist in Verse
    • B. GetPlayerUI is deprecated
    • C. An agent may be AI; UI only exists for players, so you must cast with player[Agent] first
    • D. Agents are strings
  4. What is the correct comparison operator for equality in Verse?
    • A. ==
    • B. =
    • C. ===
    • D. .equals
  5. How do you reassign a value to a `var` in Verse?
    • A. Count = Count + 1
    • B. set Count = Count + 1
    • C. Count += 1
    • D. let Count = Count + 1
Answer key
  1. A — Device events are accessed as fields and subscribed to with `.Subscribe` directly — no parentheses on the event name.
  2. B — The [] brackets mark a fallible <decides> call, which may only appear in a failure context such as an `if`.
  3. C — Agents can be players or AI. UI is per-player, so you cast the agent to a player before requesting UI.
  4. B — Verse uses `=` for comparison and `<>` for inequality; `==` and `!=` are not Verse.
  5. B — Mutable variables are reassigned with the `set` keyword; `+=` and `++` do not exist in Verse.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — The interact button at each of the 5 zone-portal booths

Sources

Lesson 3: Professor AweShucks Speaks: HUD Messages for Player Guidance

Objectives

Student can show timed, targeted HUD messages from Verse to guide players through the hub.

🔁 Builds on: south-shores: string interpolation lesson for dynamic message text

🧩 Your capstone piece: Welcome sequence + per-booth travel prompts narrated by Professor AweShucks

Quiz

  1. You want to show a HUD message to every player at once. Which method do you call?
    • A. Show()
    • B. Show(Agent)
    • C. SetText()
    • D. ClearAllMessages()
  2. What does passing `DisplayTime := 0.0` to `Show(Agent, Message, ?DisplayTime := 0.0)` do?
    • A. Hides the message immediately
    • B. Uses the device's default display time
    • C. Displays the message persistently until manually hidden
    • D. Causes a compile error — 0.0 is invalid
  3. A `trigger_device.TriggeredEvent` handler receives `(Agent : ?agent)`. You want to call `MyHUD.Show(Agent)`. What must you do first?
    • A. Cast Agent to agent using `agent(Agent)`
    • B. Unwrap the option with `if (A := Agent?):` and pass `A`
    • C. Nothing — ?agent and agent are interchangeable
    • D. Call `Show()` instead since the agent is optional
  4. Which of the following correctly passes text to `SetText`?
    • A. MyHUD.SetText("Vault Opened!")
    • B. MyHUD.SetText(StringToMessage("Vault Opened!"))
    • C. MyHUD.SetText(VaultMsg("Vault Opened!")) where VaultMsg<localizes>(S:string):message = "{S}"
    • D. MyHUD.SetText(message{"Vault Opened!"})
  5. You call `Show()` while a message is already visible. What happens?
    • A. The new message is queued and plays after the current one finishes
    • B. The new message replaces the currently active message immediately
    • C. A compile error is thrown
    • D. The call is silently ignored
Answer key
  1. A — `Show()` (no arguments) broadcasts the currently set message to all players affected by the device. `Show(Agent)` targets a single player, `SetText` only sets the text without displaying it, and `ClearAllMessages` removes messages.
  2. C — A `DisplayTime` of `0.0` means the message stays on screen indefinitely. You must call `Hide()`, `Hide(Agent)`, or `ClearAllMessages()` to remove it.
  3. B — `Show(Agent:agent)` requires a non-optional `agent`. You must unwrap the `?agent` with `if (A := Agent?):` before passing it. Passing `?agent` directly is a compile error.
  4. C — `SetText` expects a `message` type. You must declare a `<localizes>` function to convert a string into a `message`. There is no `StringToMessage` function, and raw string literals are not `message` values.
  5. B — According to the API, `Show()` 'will replace any previously active message.' If you need sequential messages, sleep between calls or track timing with `GetDisplayTime()`.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — Welcome sequence + per-booth travel prompts narrated by Professor AweShucks

Sources

Lesson 4: Island Market Ambience: Song Sync and Musical Stings

Objectives

Student can drive the song_sync_device from Verse to layer district ambience and fire a sting on game events.

🔁 Builds on: south-shores: Patchwork/audio device patterns (drum, omega-synth)

🧩 Your capstone piece: Market ambience loop + portal-unlock sting + round-start music cue

Quiz

  1. Which two methods does the song_sync_device expose to Verse?
    • A. Play and Stop
    • B. Enable and Disable
    • C. Start and Restart
    • D. Show and Hide
  2. Why must you declare the device as an @editable field instead of calling song_sync_device{}.Enable() directly?
    • A. Because Enable is private
    • B. Because a bare literal isn't linked to the placed device in the level
    • C. Because Verse forbids literals
    • D. Because Enable needs an agent parameter
  3. What is the correct handler signature for a trigger_device's TriggeredEvent?
    • A. (Agent : agent)
    • B. (Agent : ?agent)
    • C. (Player : player)
    • D. ()
  4. How would you cleanly restart the synchronized timeline from a known point?
    • A. Call Enable() twice
    • B. Call Disable() then Enable()
    • C. Call Restart()
    • D. Re-subscribe the event
  5. Where should you put the code that subscribes event handlers to a button or plate?
    • A. In a top-level function
    • B. In OnBegin<override>()<suspends>:void
    • C. In the class field list
    • D. In the handler method itself
Answer key
  1. B — song_sync_device inherits only Enable() and Disable() from its patchwork_device base — these turn the shared timeline on and off.
  2. B — An @editable field lets you assign the actual placed device in the Details panel; a bare literal points to nothing in the world.
  3. B — TriggeredEvent hands an optional agent, so the handler takes (Agent : ?agent) and you unwrap it with if (P := Agent?):.
  4. B — There is no Restart method; calling Disable() then Enable() stops and re-starts the shared timeline.
  5. B — Subscriptions are wired up in OnBegin, where the device is live and the event handler methods exist at class scope.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — Market ambience loop + portal-unlock sting + round-start music cue

Sources

Lesson 5: Map Room Guards: AI Patrol Paths and NPC Routes

Objectives

Student can lay patrol path nodes, assign an NPC guard, and start/stop/redirect patrols from Verse.

🔁 Builds on: verse-npc-guard-patrol (compile-passed companion script, re-zoned here)

🧩 Your capstone piece: Town guards patrolling the plaza and market; guards pause when the hub round launches

Quiz

  1. What signature does a handler for NodeReachedEvent need?
    • A. (Agent : agent) — the event is listenable(agent)
    • B. (MaybeAgent : ?agent) — you must unwrap it
    • C. () — patrol events pass no data
    • D. (Node : ai_patrol_path_device)
  2. Which method commands an already-patrolling guard onto its alternate route?
    • A. Enable()
    • B. Assign(Patroller)
    • C. GoToNextPatrolGroup(Patroller)
    • D. Disable()
  3. Why must you declare the patrol device as an @editable field?
    • A. To localize its messages
    • B. Because a bare Device.Method() call fails with 'Unknown identifier' — you can only call methods on a placed device instance held in a field
    • C. To make events fire faster
    • D. It is optional; you can call methods globally
  4. What agent should you pass to Assign(Patroller)?
    • A. Any player agent
    • B. A guard agent produced by the guard_spawner_device (e.g. from SpawnedEvent or GetAgents())
    • C. The creative_device itself
    • D. A vector3 location
  5. In the walkthrough, what happens right after GuardSpawner.SpawnedEvent fires?
    • A. The node calls Disable() immediately
    • B. OnGuardSpawned assigns the guard to GatePatrolNode, then calls GoToNextPatrolGroup on it
    • C. ArrivalLight.Begin() fires before anything else
    • D. The guard is teleported to the gate node
Answer key
  1. A — Patrol path events are listenable(agent), so the handler receives a non-optional agent directly — no ? unwrap needed.
  2. C — GoToNextPatrolGroup tells the patroller to follow the Next Patrol Path Group instead of the default group.
  3. B — Placed devices must be referenced through an @editable field of a creative_device; otherwise the identifier is unknown.
  4. B — Assign expects an AI agent created by the guard spawner; player agents won't patrol.
  5. B — OnGuardSpawned calls GatePatrolNode.Assign(Guard) then GatePatrolNode.GoToNextPatrolGroup(Guard) to push the fresh guard onto its alert route.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — Town guards patrolling the plaza and market; guards pause when the hub round launches

Sources

Lesson 6: Score and Time: Wiring score_manager and timer from Verse

Objectives

Student can award score via score_manager_device and start/pause/reset a timer_device from Verse as one cooperating system.

🧩 Your capstone piece: Lobby countdown timer + town-coin score used by the quest and the CTF event

Quiz

  1. Which method actually grants points to a player?
    • A. SetScoreAward
    • B. Increment
    • C. Activate
    • D. GetScoreAward
  2. How does a handler for the score manager's ScoreOutputEvent receive the player?
    • A. As a ?agent that must be unwrapped with Agent?
    • B. As a plain agent, no unwrap needed
    • C. As a player_ui
    • D. As a string
  3. When should you call the agent overloads like Activate(Player) instead of Activate()?
    • A. Never; they are deprecated
    • B. Only in OnBegin
    • C. When the device's Activating Team option targets a specific team, so the agent's team is checked
    • D. Only when reading scores
  4. What does GetScoreAward() return?
    • A. The player's total lifetime score
    • B. The number of points the next activation will award
    • C. An optional agent
    • D. Nothing; it has void return
  5. Why must Scorer be declared as an @editable field?
    • A. So it prints to the log
    • B. So it can be localized
    • C. So Verse can reference the placed device in the level and call its methods
    • D. So it auto-converts int to float
Answer key
  1. C — SetScoreAward/Increment/Decrement/SetToAgentScore only configure the pending amount; Activate (or Activate(Agent)) is what pays it out.
  2. B — ScoreOutputEvent is listenable(agent), so the handler gets a plain agent. Only optional listenable(?agent) events (like a trigger's TriggeredEvent) require unwrapping.
  3. C — With a specific Activating Team set, the agent's team determines whether they may affect the device, so the agent overloads are required.
  4. B — GetScoreAward()<transacts>:int returns the score the next Activate will grant. GetCurrentScore(Agent) returns a player's running total.
  5. C — Device methods can only be called through an @editable field bound to a placed device; a bare constructor instance references nothing in the level.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — Lobby countdown timer + town-coin score used by the quest and the CTF event

Sources

Lesson 7: The Hub Heartbeat: Custom Round Logic in Verse

Objectives

Student can orchestrate a start/play/win/reset game loop in Verse that coordinates score, timer, and spawns.

🔁 Builds on: south-shores: enum-with-data-pattern game-phase state machine module

🧩 Your capstone piece: The hub lobby loop: WAITING -> READY -> LAUNCH -> RESET state machine

Quiz

  1. Why is `LoserFlags` keyed on `session` rather than being a plain `var` on the device?
    • A. Plain device vars are wiped on round reset; a session-keyed weak_map persists across rounds in the same match
    • B. Session keys are faster to look up
    • C. Plain vars cannot store logic values
    • D. It is the only way to store a map in Verse
  2. Why must `LoserFlags[Session]` appear inside an `if`/`for` or a `<decides>` body?
    • A. Because it returns a logic that must be negated
    • B. Because `[]` is a fallible index operation that may only run in a failure context
    • C. Because weak_maps are asynchronous
    • D. Because Session is optional
  3. What is the correct Verse boolean type used for the loser flag?
    • A. bool
    • B. boolean
    • C. logic
    • D. flag
  4. How do you test a `logic` value named `Flag`?
    • A. if (Flag == true):
    • B. if (Flag?):
    • C. if (Flag = true):
    • D. if (not Flag):
  5. Which real player-UI calls actually put the warning on screen?
    • A. GetSession() and AddWidget
    • B. GetPlayerUI[] to get the UI, then AddWidget with a canvas
    • C. Print and Sleep
    • D. Subscribe and Cancel
Answer key
  1. A — State on the device is unreliable across a round reset; keying a weak_map on the session lets the flag survive between rounds of the same match.
  2. B — Square-bracket index access is fallible and can only be used where failure is handled — a condition or a <decides> function body.
  3. C — Verse has no `bool`; its boolean type is `logic` with values `true`/`false`, tested with `?`.
  4. B — You interrogate a logic with `?`: `if (Flag?):` succeeds when it is true. `==` is not Verse and `= true` is wrong.
  5. B — `GetPlayerUI[Player]` returns the player's UI; you build a canvas (containing a text_block) and call `AddWidget` to display it.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — The hub lobby loop: WAITING -> READY -> LAUNCH -> RESET state machine

Sources

Lesson 8: Teams and Classes: Organizing a Multiplayer Town

Objectives

Student can configure teams and classes, use class_selector devices, and read a player's team from Verse.

🧩 Your capstone piece: Red/Blue plaza teams + Explorer/Builder classes for the town CTF event

Quiz

  1. How do you reach the object that tracks all teams from a Verse device?
    • A. GetPlayspace().GetTeamCollection()
    • B. GetTeams().Collection()
    • C. GetWorld().Teams()
    • D. GetPlayspace().TeamList()
  2. Why is GetTeam[Player] called with square brackets inside an if?
    • A. Because it returns an array
    • B. Because it is fallible and may fail to find a team
    • C. Because it is a suspends function
    • D. Because square brackets speed it up
  3. Which operator does Verse use to compare two values for equality?
    • A. ==
    • B. =
    • C. ===
    • D. eq
  4. What does GetTeams() return?
    • A. A single team
    • B. The number of teams as an int
    • C. An array of all teams
    • D. A map of players to teams
  5. Which event fires when a new player enters the playspace?
    • A. PlayerAddedEvent()
    • B. SpawnedEvent
    • C. OnPlayerJoin
    • D. PlayerEnteredEvent
Answer key
  1. A — GetPlayspace() returns the fort_playspace, and GetTeamCollection() returns its fort_team_collection.
  2. B — GetTeam[] is a fallible (<decides>) call, so it must appear in a failure context like an if condition using [] brackets.
  3. B — Verse uses a single = for equality comparison; == is not valid Verse.
  4. C — GetTeams() returns an array of teams; you can read .Length or loop over it.
  5. A — PlayerAddedEvent() is a listenable(player) that signals when a human player joins the fort_playspace.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — Red/Blue plaza teams + Explorer/Builder classes for the town CTF event

Sources

Lesson 9: Lobby Spawns and Loadouts: player_spawner + team_settings_and_inventory

Objectives

Student can place per-team spawn pads and grant team loadouts/inventory rules so players always spawn correctly equipped.

🔁 Builds on: the-deeps reference: team-settings-and-inventory-device (compile-passed, reused here)

🧩 Your capstone piece: Team spawn pads flanking the plaza + starter loadout for the CTF event

Quiz

  1. What is the correct way to reference a placed `player_spawner_device` in your Verse class so you can call its methods?
    • A. Declare it as an `@editable` field and wire it up in the UEFN Details panel
    • B. Call `player_spawner_device{}` inline wherever you need it
    • C. Import it with `using { /Fortnite.com/Devices/player_spawner_device }`
    • D. Use `GetDevice[player_spawner_device]` at runtime
  2. What type does `SpawnedEvent` send to its subscriber handler?
    • A. `?agent` — an optional agent that must be unwrapped
    • B. `player` — the specific player who spawned
    • C. `agent` — a non-optional agent
    • D. `fort_character` — the character that was spawned
  3. You call `ArenaSpawner.SpawnPlayer(Player)` but the player doesn't move. The spawner is enabled and valid for their team. What is the most likely cause?
    • A. You forgot to call `ArenaSpawner.Spawn()` first
    • B. The device's `ShouldRespawnAlivePlayers` setting is false and the player is currently alive
    • C. `SpawnPlayer` only works inside a `<suspends>` function
    • D. You must subscribe to `SpawnedEvent` before calling `SpawnPlayer`
  4. Which of the following correctly disables a spawner, waits 10 seconds, then re-enables it?
    • A. `MySpawner.Disable() Sleep(10.0) MySpawner.Enable()` in a plain (non-suspends) method
    • B. `MySpawner.Disable()` then `MySpawner.Enable()` with `Sleep(10.0)` between them inside an `OnBegin<override>()<suspends>` body
    • C. `MySpawner.SetEnabled(false)` then `MySpawner.SetEnabled(true)` after a timer
    • D. `Disable(MySpawner)` then `Enable(MySpawner)` after `Wait(10)`
  5. You want to grant a weapon to every player the moment they spawn from a pad. Which approach is correct?
    • A. Poll `GetPlayspace().GetPlayers()` every frame and check their location
    • B. Subscribe to `SpawnedEvent` on the spawner and call your granter logic inside the handler
    • C. Override `OnPlayerSpawn` in your creative_device class
    • D. Call `SpawnPlayer` and pass a callback lambda as the second argument
Answer key
  1. A — Verse devices must be declared as `@editable` fields inside your `creative_device` class and assigned in the UEFN Details panel. A bare `player_spawner_device{}` creates a disconnected default instance that has no placed counterpart and cannot affect the game world.
  2. C — `SpawnedEvent` is typed `listenable(agent)`, so its handler receives a plain `agent` value — no optional unwrap needed. If you need player-specific APIs, cast with `if (P := player[SpawnedAgent]):`.
  3. B — When `ShouldRespawnAlivePlayers` is false (the default), `SpawnPlayer` has no effect on a living player — it only takes effect on their next death. Enable the setting in the device's Details panel to force-move alive players immediately.
  4. B — `Sleep` is a suspending call and can only be used in a `<suspends>` context like `OnBegin`. The correct API calls are `MySpawner.Disable()` and `MySpawner.Enable()` — there is no `SetEnabled` or free-function `Disable`/`Enable`.
  5. B — `SpawnedEvent` fires every time an agent spawns from that device and delivers the agent to your handler. This is the idiomatic, event-driven way to react to spawns — no polling or overrides required, and `SpawnPlayer` takes only a `player` argument with no callback.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — Team spawn pads flanking the plaza + starter loadout for the CTF event

Sources

Lesson 10: Tour the Town: Quests with the Tracker Device

Objectives

Student can define a tracked quest (visit all 5 portal booths), update progress from Verse, and grant a completion reward.

🔁 Builds on: north-jungle: verse-maps lesson pattern for per-player visited-booth map

🧩 Your capstone piece: 'Tour the Town' onboarding quest that walks new players past every zone booth

Quiz

  1. Which method fires automatically when a tracked value reaches the target, and what type does its handler receive?
    • A. CompleteEvent, which sends a plain `agent`
    • B. CompleteEvent, which sends `?agent`
    • C. TriggeredEvent, which sends a plain `agent`
    • D. OnComplete, which sends `int`
  2. You want to display 'Collect Crystals' as the tracker's HUD title. Which call is correct?
    • A. ObjectiveTracker.SetTitleText("Collect Crystals")
    • B. ObjectiveTracker.SetTitleText(MyTitle("Collect Crystals")) where MyTitle<localizes>(S:string):message = "{S}"
    • C. ObjectiveTracker.SetTitleText(StringToMessage("Collect Crystals"))
    • D. ObjectiveTracker.SetTitle("Collect Crystals")
  3. What must be true for `Save(Agent)`, `Load(Agent)`, and `ClearPersistence(Agent)` to have any effect?
    • A. The tracker must be assigned to the agent before calling them
    • B. The tracker's **Use Persistence** property must be set to **Use** in the device's editor settings
    • C. You must call `LoadForAll()` first
    • D. The agent must have reached the target value
  4. How do you correctly check whether an agent currently has the tracker active?
    • A. if (ObjectiveTracker.IsActive(A) = true):
    • B. if (ObjectiveTracker.IsActive[A]):
    • C. ObjectiveTracker.IsActive(A)
    • D. if (ObjectiveTracker.IsActive(A)?):
  5. A player joins mid-game after `AssignToAll()` was already called. What must you do to give them the tracker?
    • A. Nothing — `AssignToAll` automatically covers future joiners
    • B. Call `AssignToAll()` again to refresh all assignments
    • C. Subscribe to a join event and call `Assign(Agent)` for the new player
    • D. Call `LoadForAll()` which implicitly assigns the tracker
Answer key
  1. A — `CompleteEvent : listenable(agent)` sends a plain, already-unwrapped `agent` to its handler — no optional unwrapping needed, unlike `trigger_device.TriggeredEvent` which sends `?agent`.
  2. B — `SetTitleText` requires a `message` value. There is no `StringToMessage` function in Verse. You must declare a localizer helper with `<localizes>` and pass its result.
  3. B — Persistence methods are silently no-ops unless the tracker's **Use Persistence** option is enabled in the UEFN device panel. The Verse calls alone are not sufficient.
  4. B — `IsActive` carries `<decides>`, making it a failable expression. It must be called with bracket syntax inside an `if` expression: `if (ObjectiveTracker.IsActive[A]):`. Calling it outside an `if` is a compile error.
  5. C — `AssignToAll()` only covers agents present at the moment it is called. For late joiners you must detect the join (e.g., via a player_spawner_device event) and explicitly call `Assign(Agent)` for each new player.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — 'Tour the Town' onboarding quest that walks new players past every zone booth

Sources

Lesson 11: Plaza Skirmish: a Capture-the-Flag Mini-Mode

Objectives

Student can assemble teams, classes, spawns, score, timer, and round logic into one playable CTF event.

🔁 Builds on: lessons 6-9 of this zone + south-shores Shell-Hunt project structure

🧩 Your capstone piece: The while-you-wait plaza minigame that runs between hub launches

Quiz

  1. In classic CTF rules, why can't a whole team just blindly rush the enemy flag?
    • A. The enemy flag is too heavy to carry with a full team
    • B. A capture only counts if YOUR own flag is home, so someone must defend
    • C. Rushing disables your respawns
    • D. The map physically locks until both flags are dropped
  2. Which device IS the flag in a UEFN Capture the Flag build?
    • A. Item Granter Device
    • B. Capture Area Device
    • C. Capture Item Spawner Device
    • D. Trigger Device
  3. How does the Verse device decide which TEAM to credit for a capture?
    • A. It reads a team number stored on the flag device
    • B. It calls GetPlayspace().GetTeamCollection().GetTeam[Scorer] on the capturing agent
    • C. It checks which spawn pad the player last used
    • D. Teams aren't tracked in Verse; only the device options know
  4. Why is the map-set written as `if (set Scores[ScoringTeam] = NewScore) {}`?
    • A. To run the assignment on a background thread
    • B. Because setting a map entry is a failable expression and must be handled
    • C. To delay scoring by one frame
    • D. It's a stylistic choice with no functional reason
  5. What type is `Scores` declared as in `capture_the_flag_device`?
    • A. var Scores : [agent]int = map{}
    • B. var Scores : [team]int = map{}
    • C. var Scores : []int = array{}
    • D. var Scores : [string]int = map{}
Answer key
  1. B — Classic rules require your flag to be at base for a capture to score, which forces a defense/offense split and creates the tug-of-war.
  2. C — capture_item_spawner_device spawns the carryable flag and fires the pickup/capture/drop/return events. A Capture Area is for zones, not carryables.
  3. B — The team collection's GetTeam[] resolves an agent to its team — the canonical team-mode lookup. It's failable, so it's guarded with if.
  4. B — Mutating a map entry is failable in Verse, so it's wrapped in an if (...) {} to satisfy the failure context.
  5. B — Scores is keyed directly by the team object (`[team]int`), avoiding magic numbers or string keys.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — The while-you-wait plaza minigame that runs between hub launches

Sources

Lesson 12: The Hall of Badges: Cross-Zone Persistence with [player] Maps

Objectives

Student can store per-player progress in a weak_map([player], int) marked <persistable>, version it, and read zone badges earned on OTHER islands.

🔁 Builds on: east-volcano: persisting-a-tycoon-state-with-persistable pattern (compile-passed grounding)

🧩 Your capstone piece: The IslandProgress badge profile that gates paid-zone portals and lights the Hall of Badges

Quiz

  1. A returning player joins with a save stamped Version = 1 while CurrentSaveVersion = 2. What does the EnsureProfile / MigrateProgress pair do with their badges?
    • A. EnsureProfile detects Version < CurrentSaveVersion and rebuilds the record via MigrateProgress: the new Version is stamped, v2-specific changes are applied (retroactive TownCoins), and every badge is preserved through the copy-constructor.
    • B. The old record is discarded and replaced with a fresh island_progress{}, so the player starts over with zero badges.
    • C. Nothing — the engine automatically rewrites the Version field, so no migration code is ever needed.
    • D. The save fails to load at all, because a persistable class can only ever be read at the exact version it was written.
  2. Why is the island_progress class declared class<final><persistable> rather than just class<persistable>?
    • A. <final> is required on a persistable class — the engine must know the exact concrete shape it is saving, so persistable classes cannot be subclassed.
    • B. <final> makes the class immutable at runtime, which is what makes persistence possible.
    • C. <final> is optional and only added for performance.
    • D. <final> marks the class as the last version of the schema, disabling future migrations.
  3. To add 50 TownCoins to a stored profile, why does the code build a whole new island_progress with the copy-constructor instead of writing set Profile.TownCoins += 50?
    • A. Stored persistable records cannot be mutated field-by-field — you replace the map entry with a fresh record, overriding the changed field and copying the rest via the <constructor> so no other field is silently reset.
    • B. It is purely a style choice; in-place mutation works the same way.
    • C. Because TownCoins is declared <final> and can never change after creation.
    • D. Because weak_map entries are read-only once the engine has saved them.
  4. Why do EnsureProfile and GrantBadge carry <decides><transacts>, forcing callers to invoke them as EnsureProfile[Player]?
    • A. weak_map reads and writes are failable — the key may be absent — so the accessors run in a failure context and callers must handle success/failure with [] inside an if.
    • B. <decides> makes the function run asynchronously so saves never block the game thread.
    • C. It is required for any function that takes a player parameter.
    • D. The specifiers make the weak_map automatically persistable.
  5. Which declaration correctly fills the blank so island_progress can be saved by the engine? island_progress := class<final>____: Version:int = 0 ShellBadge:logic = false
    • A. <persistable>
    • B. <unique>
    • C. <concrete>
    • D. <transacts>
Answer key
  1. A — Migration is opt-in code YOU write: EnsureProfile compares the stored Version against CurrentSaveVersion and, when it is older, replaces the record with MigrateProgress(Existing) — a fresh record that stamps the new Version, applies any semantic changes, and copies every surviving field through MakeIslandProgress<constructor>. Old badges are never lost because the constructor copies them.
  2. A — Verse requires <final> on persistable classes: the saved layout must be a fixed, concrete shape, so subclassing is forbidden. Every field must also itself be a persistable type.
  3. A — The persistence idiom is copy-on-write: set IslandProgressMap[Player] = island_progress: TownCoins := Src.TownCoins + 50, then MakeIslandProgress<constructor>(Src) fills in every other field. Skipping the constructor (or forgetting a field inside it) is how updates silently zero unrelated progress.
  4. A — IslandProgressMap[Player] and set IslandProgressMap[Player] = ... can both fail (missing key, invalid player), so the accessors are <decides><transacts> and the whole body is one transactional failure context. Callers write if (EnsureProfile[Player]): — a failed lookup rolls back cleanly instead of crashing.
  5. A — The class must be marked <persistable> (alongside <final>) for the engine to save it per player in a weak_map. <unique>, <concrete>, and <transacts> are not what makes a class savable.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — The IslandProgress badge profile that gates paid-zone portals and lights the Hall of Badges

Sources

Lesson 13: Badge-Gated Doors: Conditional Buttons and Unlock Logic

Objectives

Student can gate interactions with conditional_button_device and a Verse gatekeeper module that checks the persistence profile.

🔁 Builds on: north-jungle: verse-modules / shared-helper-module (import the gatekeeper as a module)

🧩 Your capstone piece: portal_gatekeeper module: free booths always open, paid-zone booths require the previous badge

Quiz

  1. A booth charges 5 town coins AND requires the Shell Hunt badge. Which check belongs in the conditional_button_device and which belongs in Verse — and why?
    • A. Coins in the device (it counts key items natively and fires NotEnoughItemsEvent); badge in Verse (badges live in a persistable weak_map profile the device cannot read).
    • B. Both in the device — conditional buttons can be configured to check any saved value.
    • C. Both in Verse — devices should never perform gameplay checks.
    • D. Badge in the device (badges are items); coins in Verse (currency needs code).
  2. Why does `CanEnter[Player, RequiredBadge]` always succeed for a free booth?
    • A. Free booths pass RequiredBadge = 0, so the `if (RequiredBadge > 0)` body never runs and no failable check executes.
    • B. Because EnsureProfile grants every badge to new players.
    • C. Because the conditional button is disabled at free booths.
    • D. It doesn't — free booths must call a separate CanEnterFree function.
  3. In GrantBadge, why rebuild the profile with `MakeIslandProgress<constructor>(Src)` instead of mutating the stored record's Badges field directly?
    • A. Persistable records in a weak_map cannot be mutated in place — you store a fresh record that overrides the changed field and copies the rest via the constructor, so no other field is silently reset.
    • B. The constructor is faster than direct mutation.
    • C. weak_map entries are read-only after the first write.
    • D. It is purely stylistic; `set Src.Badges += array{Badge}` would compile fine.
  4. The gatekeeper lives in its own file. What must each booth script write to use it?
    • A. using { PortalGatekeeper } — importing the module by name, the same technique as importing CodewoodKit in the North Jungle.
    • B. include "PortalGatekeeper.verse" at the top of the file.
    • C. Nothing — all Verse files automatically share every declaration.
    • D. @import(PortalGatekeeper) above the class declaration.
  5. In `portal_booth_device.OnBegin`, which two events does `BoothButton` subscribe to, and what does each one represent?
    • A. ActivatedEvent (the device's own item check passed) and NotEnoughItemsEvent (the item check failed).
    • B. ActivatedEvent (the badge check passed) and NotEnoughItemsEvent (the badge check failed).
    • C. TriggeredEvent and ActivatedEvent, both fired only after the Verse badge check.
    • D. OnBeginEvent and NotEnoughItemsEvent.
Answer key
  1. A — The device's native job is counting key items in the player's inventory right now — it verifies the coin fee and fires NotEnoughItemsEvent for free. The badge is account-level progress stored in a persistable weak_map profile; no device panel can read that, so the badge lookup must be Verse. Each check sits where its data lives.
  2. A — CanEnter only delegates to the failable HasBadge when RequiredBadge is positive. With RequiredBadge = 0 the guard is skipped, nothing can fail, and the decides function succeeds — which is exactly the 'free booths always open' rule expressed in one line.
  3. A — You can't mutate a field of a stored persistable record. The copy-constructor idiom builds a new island_progress overriding only Badges while the constructor copies every other field (like Version) — the standard pattern that keeps a one-field update from zeroing the rest of the save.
  4. A — Verse modules are imported with a using expression naming the module: `using { PortalGatekeeper }`. After that its public members (CanEnter, GrantBadge, the badge ids) are available — the exact skill built in the North Jungle module lessons, now powering the hub.
  5. A — OnBegin subscribes OnBoothActivated to ActivatedEvent and OnMissingItems to NotEnoughItemsEvent. ActivatedEvent fires only after the device's own item check already passed — that's the moment Verse layers the badge check on top. NotEnoughItemsEvent fires when the item check failed, giving the 'can't afford the fee' case for free.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — portal_gatekeeper module: free booths always open, paid-zone booths require the previous badge

Sources

Lesson 14: Building the Portal Gate: Scene Graph Entities and Prefabs

Objectives

Student can build the portal gate as an entity hierarchy with mesh components and save it as a reusable prefab stamped at all 5 booths.

🔁 Builds on: verse-scene-graph-intro + hierarchy-transforms (compile-passed set)

🧩 Your capstone piece: The portal-gate prefab reused at every zone booth

Quiz

  1. Why is GetComponent written with square brackets (GetComponent[mesh_component]) and placed inside an if:?
    • A. Because square brackets are required syntax for every method call in Verse
    • B. Because it returns an array of components that must be looped over
    • C. Because getting a component can fail — the entity might not have one of that kind — so it must be guarded
    • D. Because it modifies the entity, and modifications always need square brackets
  2. You want a custom component to run an ongoing loop that waits and repeats forever. Which lifetime method should hold that logic?
    • A. OnSimulate, because it is <suspends> and is where loops and waits live
    • B. OnBeginSimulation, because it runs first at startup
    • C. OnAddedToScene, because the component is freshly in the scene
    • D. OnEndSimulation, because the loop should keep going until shutdown
  3. When you build a new component in code, why must you write Entity := Entity (telling it which entity it belongs to)?
    • A. It is optional naming; Verse picks the nearest entity if you omit it
    • B. It tells the component to copy itself onto every child entity
    • C. It links the component to the simulation entity at the root
    • D. A component is born attached to exactly one entity for life — components cannot be moved between parents
  4. To make an entity's shape vanish temporarily without deleting it, the example calls Mesh.Disable(). What's the advantage of disabling over deleting?
    • A. Disabling frees more memory than deleting the entity
    • B. The mesh can be turned back on later with Enable(), so the thing can reappear
    • C. Deleting a mesh_component is not allowed in Verse
    • D. Disabling automatically removes the entity from the tree
  5. Fill in the blank: to define a component you can bolt onto an entity, you write my_component := class<____>(component):. What goes in the blank?
    • A. final_super
    • B. suspends
    • C. override
    • D. editable
Answer key
  1. C — Square brackets mark a verb that might fail (the <decides> effect); an entity may lack that component type. The if: safely skips when there's no match. Brackets are not a universal call syntax — round brackets mark calls that can't fail.
  2. A — OnSimulate is the <suspends> main-logic method built for loops, waits, and ongoing behavior. OnBeginSimulation is for instant must-finish-now setup, not for suspending loops.
  3. D — The lesson notes components cannot be moved between parents, so each is born attached to one entity for life — hence you must specify its entity at construction. Verse does not auto-pick or copy it across children.
  4. B — Disable()/Enable() flip a component off and on without destroying it, so the object can reappear later — the basis of the blink-on/off loop. Deleting would be permanent and removing it from the tree is unrelated.
  5. A — <final_super> is the required tag every time you make a component intended for an entity — it promises the class sits directly on top of component. <suspends> and <override> are effects/specifiers for methods, and @editable is an attribute for vars, not a class tag.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — The portal-gate prefab reused at every zone booth

Sources

Lesson 15: The Portal Beacon: a Custom Verse Component

Objectives

Student can write a custom component (portal_beacon_component) attached to the gate prefab that animates/glows when the player's badge unlocks that zone.

🔁 Builds on: lesson 12 IslandProgress module + south-shores MoveTo/ease animation arc

🧩 Your capstone piece: portal_beacon_component: per-player unlock glow + idle pulse animation on each gate

Quiz

  1. Why must a call like `Entity.GetComponent[light_component]` be wrapped in an `if` (or used with `or`)?
    • A. Because GetComponent is a failable lookup that may not find the component
    • B. Because light_component is a device
    • C. Because GetComponent runs asynchronously
    • D. Because Verse forbids square brackets outside loops
  2. What does a `light_component` depend on to know where it shines?
    • A. A trigger_device on the same entity
    • B. A transform_component on the entity
    • C. The creative_device's OnBegin
    • D. A material asset
  3. How do you reference a placed Scene Graph entity so Verse can act on it?
    • A. Call entity{} directly in OnBegin
    • B. Declare an @editable entity field on a creative_device and assign it in the Details panel
    • C. Use StringToMessage to name it
    • D. It happens automatically for every entity in the level
  4. Which method returns the direct child entities of an entity?
    • A. GetComponents()
    • B. GetLocalTransform()
    • C. GetEntities()
    • D. Enable()
  5. Why do the transform examples write `20.0` and `100.0` instead of `20` and `100`?
    • A. Style preference only
    • B. Verse does not auto-convert int to float, and translation vectors are float
    • C. Integers are not allowed in Scene Graph at all
    • D. Because SetLocalTransform rejects positive numbers
Answer key
  1. A — The `[]` form is a failable query — the entity might not have that component — so it must appear in a failure context like an `if`.
  2. B — The API notes that a transform_component on the entity positions the light.
  3. B — Like any placed thing, an entity must be held in an @editable field on a creative_device to be referenced from Verse.
  4. C — GetEntities() returns the []entity direct children; GetComponents() returns the []component on the entity itself.
  5. B — Vector translations are float components; Verse won't implicitly convert an int, so float literals are required.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — portal_beacon_component: per-player unlock glow + idle pulse animation on each gate

Sources

Lesson 16: The Gateway: Matchmaking Portal Device

Objectives

Student can configure a matchmaking_portal_device with a linked island code, enable/disable it from Verse, and send players to another published island.

🔁 Builds on: lesson 13 portal_gatekeeper module

🧩 Your capstone piece: The five live portals — one per zone capstone island — enabled by the gatekeeper

Quiz

  1. Which two methods does `matchmaking_portal_device` expose in its Verse API?
    • A. Enable() and Disable()
    • B. Open() and Close()
    • C. Activate() and Deactivate()
    • D. Start() and Stop()
  2. You want to call `Sleep(20.0)` inside a method triggered by a `trigger_device` event. What must you do?
    • A. Mark the event handler itself as `<suspends>`
    • B. Use `spawn { }` to launch a `<suspends>` coroutine from the handler
    • C. Call `Sleep` directly — event handlers support suspending automatically
    • D. Replace `Sleep` with a `timer_device`; Verse Sleep cannot be used here
  3. Where do you configure which island the Matchmaking Portal sends players to?
    • A. By calling a `SetDestination()` method in Verse at runtime
    • B. In the device's Details panel in the UEFN editor — it cannot be changed via Verse
    • C. By passing a string island ID to `Enable()`
    • D. Through a linked `island_selector_device` referenced in Verse
  4. You declare `@editable EscapePortal : matchmaking_portal_device = matchmaking_portal_device{}` but forget to assign the placed device in the UEFN Details panel. What happens when `EscapePortal.Enable()` is called?
    • A. A compile error is thrown because the field has no real device
    • B. The call targets the default placeholder instance and the in-world portal is unaffected
    • C. UEFN automatically finds the nearest portal in the level
    • D. A runtime exception crashes the Verse device
  5. Which of the following correctly subscribes to a `trigger_device` event and handles the optional agent parameter?
    • A. `Plate.TriggeredEvent.Subscribe(OnStep)` with handler `OnStep(Agent : agent) : void`
    • B. `Plate.TriggeredEvent.Subscribe(OnStep)` with handler `OnStep(Agent : ?agent) : void`
    • C. `Plate.TriggeredEvent.Await()` inside `OnBegin` with no handler method
    • D. `Plate.OnTriggered.Subscribe(OnStep)` with handler `OnStep() : void`
Answer key
  1. A — The device's full API surface is `Enable():void` and `Disable():void`. There are no Open/Close or Activate/Deactivate methods.
  2. B — Event handler callbacks cannot be `<suspends>`. You must `spawn` a separate coroutine that is marked `<suspends>` and contains the `Sleep` call.
  3. B — The destination island is an editor-only property set in the Details panel. The Verse API only controls whether the portal is enabled or disabled — there is no runtime destination API.
  4. B — The default value `matchmaking_portal_device{}` is a valid compile-time placeholder. Calls succeed but target that placeholder, not the placed device — so the in-world portal never opens or closes.
  5. B — `trigger_device.TriggeredEvent` is a `listenable(?agent)`, so the handler must accept `(Agent : ?agent)`. Using `agent` instead of `?agent` causes a type mismatch compile error.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — The five live portals — one per zone capstone island — enabled by the gatekeeper

Sources

Lesson 17: Ship It: Island Settings, Matchmaking Queues, and Publishing

Objectives

Student can configure island settings, set matchmaking queue controls, and publish through Creator Portal so their hub is a real joinable Fortnite island.

🔁 Builds on: grounding: configure-the-island-settings, matchmaking-portal-device, using-creator-portal (crawled Epic docs)

🧩 Your capstone piece: The published AweShucks Town island code that all portals and the site link to

Quiz

  1. Pre-publish checklist: your published hub's queue never fills and matchmaking seems dead. Which island settings, left at careless values, are the usual culprits?
    • A. Island Matchmaking Privacy set to Private, Teams = Custom with Team Size at Dynamic, Minimum Players set too high, Overtime Player Target unreachable, and over-long Queue durations
    • B. Spawn Immunity Time, Respawn Type, Fall Damage, Glider Redeploy, and Starting Health
    • C. Only Max Players — no other island setting can affect matchmaking
    • D. The island's thumbnail and description, which matchmaking uses to rank islands
  2. What happens during the Queue Overtime Duration phase of matchmaking?
    • A. The queue stops trying for Max Players and instead tries to start the game once the Overtime Player Target is reached
    • B. Players already in the match get overtime bonus points
    • C. The queue doubles Max Players to fill the island faster
    • D. The game extends the current round by the overtime duration
  3. You call RoundSettings.EnableMatchmaking() in Verse but nothing changes in your playtest session. What is the most likely reason?
    • A. EnableMatchmaking only applies to published games that have matchmaking turned on in the Island Settings
    • B. EnableMatchmaking must be called before OnBegin runs
    • C. The round_settings_device must be hidden before matchmaking calls work
    • D. EnableMatchmaking requires an agent parameter to identify the host
  4. In the Creator Portal publishing flow, what is a private version code for?
    • A. Playtesting your island yourself across platforms — it is unmoderated and only you can use it; a Public Release is created from it later
    • B. Sharing the island publicly with a select group of up to 100 players
    • C. A backup code Epic uses to restore your island if the release fails review
    • D. The final island code players use once the island passes moderation
  5. What is the recommended Teams setting for a social hub like AweShucks Town, and why?
    • A. Free for All, because a social hub has no sides
    • B. Custom with Team Size set to Dynamic, for flexible parties
    • C. Squads, so friends always land together
    • D. Solo, to prevent any player interaction
Answer key
  1. A — Privacy = Private restricts joins to the host's party; Teams = Custom with Team Size left at Dynamic disables matchmaking outright per Epic's island settings docs; an unreachable Minimum Players cancels queues; and bad Overtime Player Target / queue duration values leave players stuck waiting. Cosmetic and combat settings never block matchmaking.
  2. A — The queue runs in two phases: during Queue Main Duration it attempts a full match at Max Players; when that expires, the overtime phase tries to reach the Overtime Player Target instead. If even Minimum Players cannot be met, the queue cancels.
  3. A — The digest documents this directly: EnableMatchmaking/DisableMatchmaking 'only applies to published games that have matchmaking turned on in the Island settings.' Verse controls when the gate opens, but Island Settings decide whether the gate exists — and it only matters on a published island.
  4. A — Clicking PUBLISH in UEFN creates a private version code — not moderated, usable only by you, ideal for validating queue settings on different platforms. In the Creator Portal you then Create New Release, select that private version, pass ratings and review, and only then does the public island code go live.
  5. A — The Island Settings table recommends Free for All for a hub-safe value, noting a hub has no sides. Teams = Custom with Team Size at Dynamic actually disables matchmaking entirely.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — The published AweShucks Town island code that all portals and the site link to

Sources

Lesson 18: Capstone: AweShucks Town — the Hub That Wires the Island Together

Objectives

Student assembles every lesson into the full hub island: lobby loop, CTF event, quest, badge persistence, gated scene-graph portals, and live matchmaking portals — then publishes it.

🔁 Builds on: south-shores game_phase enum module + SpawnProp helper; north-jungle shared_helpers module + custom event bus; IslandProgress persistence schema shared island-wide

🧩 Your capstone piece: The whole capstone — final integration and publish walkthrough

Quiz

  1. FINAL BOSS: a bug report says 'a paid portal opens for a badge-less player.' Which module and function do you inspect first?
    • A. portal_gatekeeper.CheckAccess — every booth's open-or-refuse decision flows through this one function
    • B. ShellHuntKit.PhaseLabel — it controls which portals are visible in each phase
    • C. CodewoodKit.ScoreLine — it formats the badge total shown at the booth
    • D. IslandProgress.AddCoins — coins are what unlock paid portals
  2. Why does OnBegin call Disable() on every matchmaking_portal_device before anything else?
    • A. Enable/Disable is device-wide, so portals must start closed and only open after the gatekeeper verifies an interacting player
    • B. Matchmaking portals crash if they are enabled before OnBegin finishes
    • C. Disable() clears the portal's matchmaking queue from the previous session
    • D. It is required before Subscribe can be called on the booth buttons
  3. In IslandProgress.AddCoins, why is a whole new island_badges instance built instead of writing `set Badges.TownCoins += Amount`?
    • A. Persistable class values are immutable snapshots — you persist a change by writing a NEW instance into the weak_map
    • B. Verse forbids the += operator on int fields
    • C. Rebuilding is faster than mutating a field in place
    • D. weak_map entries can only be written once per session
  4. OnSouthBooth passes `false` where OnJungleBooth passes `option{IslandProgress.zone_badge.ShellHunt}`. What does that express?
    • A. South Shores is a free booth (empty option = no badge required), while the jungle booth requires the Shell Hunt badge
    • B. The south portal is disabled while the jungle portal is enabled
    • C. `false` makes CheckAccess always refuse entry to South Shores
    • D. It selects which team is allowed to use each portal
  5. What is RunLobbyRound's phase order, driven by ShellHuntKit.game_phase?
    • A. Waiting -> Ready -> Launch -> Reset
    • B. Ready -> Waiting -> Launch -> Reset
    • C. Waiting -> Launch -> Ready -> Reset
    • D. Launch -> Ready -> Waiting -> Reset
Answer key
  1. A — The hub's design rule is that NO booth decides its own access: TryOpenPortal always asks portal_gatekeeper.CheckAccess(Player, Required). If a paid portal opened without a badge, either CheckAccess's logic regressed or the booth passed `false` (no requirement) instead of `option{zone_badge...}` — both live in that one call path.
  2. A — The digest surface for matchmaking_portal_device is just Enable()/Disable() — there is no per-player variant. Starting every portal closed and opening only after portal_gatekeeper.CheckAccess passes is what makes the gate real; leave one enabled at start and badge-less players walk straight through.
  3. A — Persistence follows the weak_map write: BadgeMap[Player] holds an immutable persistable value, so the update pattern is read the old snapshot, rebuild it with the changed field, and `set BadgeMap[Player] = NewValue`. That successful set IS the save.
  4. A — TryOpenPortal takes `?IslandProgress.zone_badge`. The empty option (`false`) means 'no requirement' and CheckAccess returns true for everyone — the free on-ramp. A filled option names the badge CheckAccess must find in the player's persistent island_badges profile.
  5. A — RunLobbyRound calls SetPhase(Waiting) while it waits for MinPlayers, then SetPhase(Ready) while the LobbyTimer counts down, then SetPhase(Launch) to run the CTF round, and finally SetPhase(Reset) before looping again — matching the enum's declared order.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — The whole capstone — final integration and publish walkthrough

Sources

Lesson 19: Reuse Your Modules Across Islands (What Epic Doesn't Teach)

Objectives

Student can package the UI kit / save system / helper modules built in earlier zones and reuse them in a DIFFERENT island project — building more advanced games from proven parts.

🔁 Builds on: south-shores ShellHuntKit; north-jungle CodewoodKit + UI widgets; east-volcano persistence save module

🧩 Your capstone piece: The hub island itself imports every zone kit — proof the whole curriculum compounds

Quiz

  1. What must be true about a module's access specifiers for another island project to import it cleanly?
    • A. The module itself AND every member the importing code calls must be marked <public>; anything without it stays internal and is invisible to the importer.
    • B. Only the module declaration needs <public>; its members are exported automatically.
    • C. Access specifiers only matter within one file — a copied module is always fully visible.
    • D. Every member must be marked <override> so the new project can replace it.
  2. Why must a portable module NEVER contain @editable device fields?
    • A. Modules are not placed devices — they have no Details panel to wire, so device references must enter as function parameters supplied by the importing island.
    • B. @editable is a paid UEFN feature that not all projects have enabled.
    • C. @editable fields are automatically deleted when a file is copied between projects.
    • D. Modules can hold @editable fields as long as they are also marked <public>.
  3. You copied ShellHuntKit.verse into a new project. Which single line brings its exports into scope in another Verse file there?
    • A. using { ShellHuntKit }
    • B. import ShellHuntKit from "ShellHuntKit.verse"
    • C. include <ShellHuntKit>
    • D. module { ShellHuntKit }
  4. VolcanoSaveKit stores zone_save records in a weak_map(player, zone_save). How do you update ONE field of a player's persistable record?
    • A. Rebuild a whole new record carrying the unchanged fields plus the new value, then write it back into the map — persistable values are snapshots.
    • B. Assign directly to the field: SaveMap[Player].BestScore = Score.
    • C. Call SaveMap.Update(Player, Score) — weak_map has a built-in field updater.
    • D. Delete the player's entry and let the engine regenerate it with the new value.
  5. Why does CodewoodKit include its own `using { /Verse.org/Simulation }` line instead of relying on the host device file's imports?
    • A. A module must carry its own dependencies — the article warns never to assume the host file already imported what the module body needs.
    • B. using lines are only valid inside module blocks, never at file scope.
    • C. It is purely stylistic; the import would resolve fine even if removed.
    • D. Simulation must be imported twice per file or the compiler throws a duplicate-symbol warning.
Answer key
  1. A — Access specifiers are checked per declaration. A `<public>` module with a non-public member compiles fine at home, but the importing island gets a compile error the moment it calls the hidden member. Export the module and each member it exposes.
  2. A — Only classes that are actually placed in a level (creative_device subclasses) surface @editable in the editor. A module has no instance in the level, so a device reference inside it can never be wired. Pass the device in as a parameter — the new island supplies its own hardware.
  3. A — `using { ShellHuntKit }` imports the module by name — the same syntax you use for Epic's own modules like /Fortnite.com/Devices. After that line, its public members are callable unqualified (or fully qualified as ShellHuntKit.Member).
  4. A — Persistable class values are immutable snapshots. RecordScore reads the existing record, constructs a fresh zone_save copying Version and applying the new BestScore, and writes the whole record back with `set SaveMap[Player] = ...` inside a failure context.
  5. A — Rule 4 of the export checklist: if the module body calls Print or touches player, the module imports its own dependencies. The next island that carries the file may not import Simulation at all in its host file, so the kit cannot lean on it.

Recap

One step closer to AweShucks Town Hub — the Island That Launches the Island — The hub island itself imports every zone kit — proof the whole curriculum compounds

Sources

Generated by Verse Island on 2026-07-04.