Update README.md

Reviewed-on: #6

README.md

@@ -1,5 +1,5 @@
 # denizen-scripts
-<img src="https://sakurafalls.net/data/assets/logo/logo-bg-new-rsc2.png" width="300">
+<img src="https://sakurafalls.net/data/assets/logo/forumlogo4.png" width="180">
 <img src="https://forum.denizenscript.com/data/assets/logo/logo.png" width="160">
 
 
@@ -8,7 +8,7 @@
 This repository contains the *Denizen* `scripts` and `data` folders of SakuraFalls.  
 
 It contains the actual code used on the server at this time. You are free to explore and to
-use the scripts that our server uses! We believe that gatekeeping roleplaying servers furhter 
+use the scripts that our server uses! We believe that gatekeeping roleplaying servers further 
 only leads to less variety and creativity. We hope that the code here, although just given as 
 is without further instructions, will lead to a new generation of awesome roleplaying servers.
 

scripts/furniture/furniture_config.dsc

@@ -40,6 +40,9 @@ furniture_config:
         iron_horse_armor,7:
             represents: Clipboard
             collision: warped_trapdoor
+        iron_horse_armor,8:
+            represents: Vending Machine
+            collision: barrier
     # List of collision blocks - disables interaction without perms
     collision_blocks:
     #- skeleton_skull

scripts/guns/guns_world.dsc

@@ -20,17 +20,16 @@ guns_world_gun:
         - if !<player.item_in_hand.has_flag[guns_gun]>:
             - stop
         - ratelimit <player> 1s
-        # - playsound <player.location> custom sound:your_custom_sound
-        - playsound <player.location> sound:entity_arrow_shoot
-        - define target <player.precise_target[25]||null>
+        - playsound <player.location> custom sound:item.anaconda
+        - define target <player.precise_target[25].if_null[null]>
         - if <[target]> == null:
-            - define location <player.cursor_on[25]||null>
+            - define location <player.cursor_on[25].if_null[null]>
             - if <[location]> == null:
                 - define location <player.location.forward[25]>
             - playeffect effect:redstone at:<player.location.above[1].points_between[<[location]>].distance[0.1]> special_data:0.5|white visibility:16 quantity:6 offset:0,0,0
             - stop
         - playeffect effect:redstone at:<player.location.above[1].points_between[<[target].location.above[1]>].distance[0.1]> special_data:0.5|white visibility:16 quantity:6 offset:0,0,0
-        - if <[target].type> != player:
+        - if !<[target].is_player>:
             - stop
         - if <[target].has_flag[guns_frozen]>:
             - stop
@@ -51,13 +50,12 @@ guns_world_taser:
         - define target <player.precise_target[7]||null>
         - if <[target]> == null:
             - stop
-        - if <[target].type> != player:
+        - if !<[target].is_player>:
             - stop
         - if <[target].has_flag[guns_frozen]>:
             - stop
         - playeffect effect:redstone at:<player.location.above[1].points_between[<[target].location.above[1]>].distance[0.1]> special_data:0.5|white visibility:16 quantity:6 offset:0,0,0
-        # - playsound <player.location> custom sound:your_custom_sound
-        - playsound <player.location> sound:entity_armor_stand_hit
+        - playsound <player.location> custom sound:item.taser
         - animate <[target]> animation:sit
         - flag <[target]> guns_frozen:true
         - run guns_unfreeze path:script def:<[target]>

scripts/lib/ball.dsc

@@ -20,6 +20,13 @@ ball_create:
     - define size <[ball_collision].bounding_box.get[1].sub[<[ball_collision].location>].x.abs.add[0.01]>
     - spawn zombie[silent=true;has_ai=false;gravity=false;visible=false] <[location].with_pitch[0].with_yaw[0].below[<[size].add[1]>]> save:ball_display
     - define ball_display <entry[ball_display].spawned_entity>
+    - if <[ball_display].is_baby>:
+        - age <[ball_display]> adult lock
+    - if <[ball_display].is_inside_vehicle>:
+        # CHICKEN JOCKEEEEEEEEEEEEEEEEEEEEEEEEEY
+        - define chicken <[ball_display].vehicle>
+        - adjust <[chicken]> passengers:<list[]>
+        - remove <[chicken]>
     - adjust <[ball_display]> equipment:<map[].with[helmet].as[<[display_item]>]>
     - flag <[ball_collision]> ball:<[id]>
     - flag <[ball_collision]> ball_display:<[ball_display]>

scripts/lib/cutscene.dsc

@@ -0,0 +1,309 @@
+#
+# Cutscene - library for creating cool cutscenes similar to the Replay Mod
+#
+# Playing cutscenes can also be atomic, meaning that if the player leaves mid
+# cutscene, the cutscene may interrupt the queue that called the task in order
+# to prevent the script from continuing.
+
+# Determines the set of points passing through the given points spaced by the given distance.
+# Effectively, the points representing the lines going from p0 to p1, then p1 to p2, etc...
+# The points have to be given escaped! So <[myinput].escaped>!
+cutscene_concatenate_points_between:
+    debug: false
+    type: procedure
+    definitions: points|distance
+    script:
+    - define points <[points].unescaped>
+    - define result <list[]>
+    - repeat <[points].size.sub[1]> as:index:
+        - define result <[result].include[<[points].get[<[index]>].points_between[<[points].get[<[index].add[1]>]>].distance[<[distance]>]>]>
+    - determine <[result]>
+
+# Determines the Catmull-Rom spline passing through the given points, taking the distance
+# between the resulting equidistant points and the resolution of the computation into account.
+# Note that the efficiency of this algorithm is not amazing necessarily, so you should cache
+# the results. Higher resolutions also mean the algorithm will take longer to finish.
+# The points have to be given escaped! So <[myinput].escaped>!
+cutscene_catmull_rom_equidistant_spline:
+    debug: false
+    type: procedure
+    definitions: points|distance|resolution
+    script:
+    - define points <[points].unescaped>
+    - define distance <[distance].if_null[0.25]>
+    - define resolution <[resolution].if_null[100]>
+    - if <[points].size> < 2:
+        - determine <[points]>
+    - if <[points].size> == 2:
+        - determine <[points].get[1].points_between[<[points].get[2]>].distance[<[distance]>]>
+    - define spline_points <list[]>
+    - define cumulative_distances <list[<element[0]>]>
+    - repeat <[points].size.sub[1]> from:0 as:segment_index:
+        - if <[segment_index]> == 0:
+            - define p0 <[points].get[1].sub[<[points].get[2].sub[<[points].get[1]>]>]>
+            - define p1 <[points].get[1]>
+            - define p2 <[points].get[2]>
+            - define p3 <tern[<[points].size.is_more_than[2]>].pass[<[points].get[3]>].fail[<[points].get[2]>]>
+        - else if <[segment_index]> == <[points].size.sub[2]>:
+            - define p0 <[points].get[<[segment_index]>]>
+            - define p1 <[points].get[<[segment_index].add[1]>]>
+            - define p2 <[points].get[<[segment_index].add[2]>]>
+            - define p3 <[points].get[<[segment_index].add[2]>].add[<[points].get[<[segment_index].add[2]>].sub[<[points].get[<[segment_index].add[1]>]>]>]>
+        - else:
+            - define p0 <[points].get[<[segment_index]>]>
+            - define p1 <[points].get[<[segment_index].add[1]>]>
+            - define p2 <[points].get[<[segment_index].add[2]>]>
+            - define p3 <[points].get[<[segment_index].add[3]>]>
+        - define t 0
+        - while <[t]> < 1:
+            - define t2 <[t].mul[<[t]>]>
+            - define t3 <[t2].mul[<[t]>]>
+            - define px <element[0.5].mul[<[p1].x.mul[2].add[<[p2].x.sub[<[p0].x>].mul[<[t]>]>].add[<[p0].x.mul[2].sub[<[p1].x.mul[5]>].add[<[p2].x.mul[4]>].sub[<[p3].x>].mul[<[t2]>]>].add[<[p0].x.mul[-1].add[<[p1].x.mul[3]>].sub[<[p2].x.mul[3]>].add[<[p3].x>].mul[<[t3]>]>]>]>
+            - define py <element[0.5].mul[<[p1].y.mul[2].add[<[p2].y.sub[<[p0].y>].mul[<[t]>]>].add[<[p0].y.mul[2].sub[<[p1].y.mul[5]>].add[<[p2].y.mul[4]>].sub[<[p3].y>].mul[<[t2]>]>].add[<[p0].y.mul[-1].add[<[p1].y.mul[3]>].sub[<[p2].y.mul[3]>].add[<[p3].y>].mul[<[t3]>]>]>]>
+            - define pz <element[0.5].mul[<[p1].z.mul[2].add[<[p2].z.sub[<[p0].z>].mul[<[t]>]>].add[<[p0].z.mul[2].sub[<[p1].z.mul[5]>].add[<[p2].z.mul[4]>].sub[<[p3].z>].mul[<[t2]>]>].add[<[p0].z.mul[-1].add[<[p1].z.mul[3]>].sub[<[p2].z.mul[3]>].add[<[p3].z>].mul[<[t3]>]>]>]>
+            - define point <location[<[px]>,<[py]>,<[pz]>,<[points].get[1].world.name>]>
+            - if <[spline_points].size> > 0:
+                - define last_point <[spline_points].get[-1]>
+                - define cumulative_distance <[last_point].distance[<[point]>]>
+                - define cumulative_distances <[cumulative_distances].include[<[cumulative_distances].get[-1].add[<[cumulative_distance]>]>]>
+            - define spline_points <[spline_points].include[<[point]>]>
+            - define t <[t].add[<element[1].div[<[resolution]>]>]>
+    - define equidistant_points <list[<[spline_points].get[1]>]>
+    - define total_length <[cumulative_distances].get[-1]>
+    - define current_distance 0
+    - define current_index 1
+    - while <[current_distance]> < <[total_length]>:
+        - define target_distance <[current_distance].add[<[distance]>]>
+        - if <[target_distance]> > <[total_length]>:
+            - while stop
+        - while <[current_index]> < <[cumulative_distances].size> && <[cumulative_distances].get[<[current_index].add[1]>]> < <[target_distance]>:
+            - define current_index <[current_index].add[1]>
+        - define t1 <[cumulative_distances].get[<[current_index]>]>
+        - define t2 <[cumulative_distances].get[<[current_index].add[1]>]>
+        - define alpha <[target_distance].sub[<[t1]>].div[<[t2].sub[<[t1]>]>]>
+        - define p1 <[spline_points].get[<[current_index]>]>
+        - define p2 <[spline_points].get[<[current_index].add[1]>]>
+        - define x <[p1].x.add[<[alpha].mul[<[p2].x.sub[<[p1].x>]>]>]>
+        - define y <[p1].y.add[<[alpha].mul[<[p2].y.sub[<[p1].y>]>]>]>
+        - define z <[p1].z.add[<[alpha].mul[<[p2].z.sub[<[p1].z>]>]>]>
+        - define point <location[<[x]>,<[y]>,<[z]>,<[points].get[1].world.name>]>
+        - define equidistant_points <[equidistant_points].include[<[point]>]>
+        - define current_distance <[target_distance]>
+    - define last_control_point <[points].get[-1]>
+    - define last_generated <[equidistant_points].get[-1]>
+    - if <[last_generated].distance[<[last_control_point]>]> >= <[distance].div[2]>:
+        - define equidistant_points <[equidistant_points].include[<[last_control_point]>]>
+    - determine <[equidistant_points]>
+
+# Previews the given path for the given player, where the source definition are the points that
+# the resulting path must pass through, for the specified duration_tag. Note for the duration_tag
+# that a <duration[]> is required, and it will not work if using simple <element[]>, like '5s'.
+cutscene_preview_path:
+    debug: false
+    type: task
+    definitions: player|source|result|duration_tag
+    script:
+    - define duration_tag <[duration_tag].if_null[<duration[5s]>]>
+    - define now <util.current_time_millis>
+    - while <util.current_time_millis.sub[<[now]>]> < <[duration_tag].in_milliseconds>:
+        - if !<[player].is_online>:
+            - stop
+        - playeffect at:<[source]> targets:<[player]> effect:CLOUD offset:0,0,0 quantity:1 velocity:0,0,0 visibility:1000
+        - playeffect at:<[result]> targets:<[player]> effect:ENCHANTED_HIT offset:0,0,0 quantity:1 velocity:0,0,0 visibility:1000
+        - wait 5t
+
+# Simple linear interpolation.
+# Given as parameter to cutscene_follow_path_by_interpolation.
+cutscene_interpolate_linear:
+    debug: false
+    type: procedure
+    definitions: step
+    script:
+    - determine 0.5
+
+# Ease in interpolation.
+# Given as parameter to cutscene_follow_path_by_interpolation.
+cutscene_interpolate_ease_in:
+    debug: false
+    type: procedure
+    definitions: step
+    script:
+    - determine <[step].mul[<util.pi.div[2]>].sin>
+
+# Ease out interpolation.
+# Given as parameter to cutscene_follow_path_by_interpolation.
+cutscene_interpolate_ease_out:
+    debug: false
+    type: procedure
+    definitions: step
+    script:
+    - determine <[step].mul[<util.pi.div[2]>].add[<util.pi.div[2]>].sin>
+
+
+# Ease in-out interpolation.
+# Given as parameter to cutscene_follow_path_by_interpolation.
+cutscene_interpolate_ease_in_out:
+    debug: false
+    type: procedure
+    definitions: step
+    script:
+    - determine <[step].mul[<util.pi>].sin>
+
+# Makes the player follow the given path at the given speed, using the provided interpolation.
+# Note that the speed is an arbitrary construct, but higher numbers will make the player follow
+# the path faster.
+cutscene_follow_path_by_interpolation:
+    debug: false
+    type: task
+    definitions: player|path|look_at|speed|interpolation_procedure
+    script:
+    - if <[path].size> == 0:
+        - stop
+    - define look_at_is_list <tern[<[look_at].get[1].if_null[null].equals[null]>].pass[false].fail[true]>
+    - teleport <[player]> <[path].get[1]>
+    - define time_unit <[path].size.div[<[speed].mul[20]>]>
+    - define should_await_time 0
+    - define index 1
+    - while <[index]> < <[path].size>:
+        - define point <[path].get[<[index]>]>
+        - define step <[index].sub[1].div[<[path].size>]>
+        - define await_time <element[1].sub[<proc[<[interpolation_procedure]>].context[<[step]>]>].mul[<[time_unit]>]>
+        - define should_await_time <[should_await_time].add[<[await_time]>]>
+        - if <[should_await_time]> < 1:
+            - define index <[index].add[1]>
+            - while next
+        - wait <[should_await_time].round_down>t
+        - define should_await_time <[should_await_time].sub[<[should_await_time].round_down>]>
+        - define direction <[look_at].sub[<[point]>].normalize>
+        - define quaternion_pitch <[direction].quaternion_between_vectors[0,1,0].represented_angle.sub[<util.pi.div[2]>].to_degrees>
+        - define result_point <[point].with_pitch[<[quaternion_pitch]>].with_yaw[<[point].direction[<[look_at]>].yaw>]>
+        - if !<[player].is_online>:
+            - determine false
+        - teleport <[player]> <[result_point].add[0,-1,0]> offthread_repeat:8
+        - define index <[index].add[1]>
+    - if !<[player].is_online>:
+        - determine false
+    - teleport <[player]> <[path].get[-1]>
+    - determine true
+
+# Creates and saves a cutscene.
+# Definitions explanation:
+# - name: The name of the cutscene. Must be unique, case sensitive.
+# - points: The source points to generate the path from.
+# - look_at: The location that the player should look at throughout the entire path follow
+# - compute_spline: Whether to use straight lines for the path, or to compute a smooth spline.
+# - interpolation_procedure: A procedure to interpolate the speed of the path follower.
+#
+# If the cutscene already exists, it will not create it and silently fail.
+# Determines true if the cutscene was created, or false if it already exists.
+cutscene_create_and_save:
+    debug: false
+    type: task
+    definitions: name|points|look_at|speed|compute_spline|interpolation_procedure
+    script:
+    - if <server.flag[cutscene].if_null[<map[]>].contains[<[name]>]>:
+        - determine false
+    - if !<[compute_spline]>:
+        - define result <proc[cutscene_concatenate_points_between].context[<[points].escaped>|0.33]>
+    - else:
+        - define result <proc[cutscene_catmull_rom_equidistant_spline].context[<[points].escaped>|0.33|50]>
+    - definemap cutscene:
+        name: <[name]>
+        source: <[points]>
+        result: <[result]>
+        look_at: <[look_at]>
+        speed: <[speed]>
+        interpolation_procedure: <[interpolation_procedure]>
+    - flag server cutscene:<server.flag[cutscene].if_null[<map[]>].with[<[name]>].as[<[cutscene]>]>
+    - determine true
+
+# Destroys an existing cutscnee.
+# If the cutscene doesn't exist, it will fail silently.
+# Determines true if the cutscene was destroyed, or false if it did not yet exist.
+cutscene_destroy:
+    debug: false
+    type: task
+    definitions: name
+    script:
+    - if !<server.flag[cutscene].if_null[<map[]>].contains[<[name]>]>:
+        - determine false
+    - flag server cutscene:<server.flag[cutscene].if_null[<map[]>].exclude[<[name]>]>
+    - determine false
+
+# Previews the given path for the given player, using a saved cutscene as the source.
+# Note for the duration_tag that a <duration[]> is required, and it will not work if
+# using simple <element[]>, like '5s'.
+cutscene_preview_path_by_name:
+    debug: false
+    type: task
+    definitions: name|player|duration_tag
+    script:
+    - if !<server.flag[cutscene].if_null[<map[]>].contains[<[name]>]>:
+        - debug error "Cannot preview path by name! <[name]> @ <[player]>"
+        - stop
+    - define cutscene <server.flag[cutscene].get[<[name]>]>
+    - run cutscene_preview_path def.player:<[player]> def.source:<[cutscene].get[source]> def.result:<[cutscene].get[result]> def.duration_tag:<[duration_tag]>
+
+# Plays the given cutscene by name.
+# If the player disconnects, the cutscene will stop playing, but the queue that
+# called this task will continue. Consider cutscene_play_atomic in case you would
+# like to stop the queue that called this task.
+# Determines true if the cutscene completed, false otherwise.
+# Should be ~waited for.
+cutscene_play:
+    debug: false
+    type: task
+    definitions: name|player
+    script:
+    - run cutscene_stop def.player:<[player]>
+    - if !<server.flag[cutscene].if_null[<map[]>].contains[<[name]>]>:
+        - determine false
+    - define cutscene <server.flag[cutscene].get[<[name]>]>
+    - flag <[player]> cutscene:<map[].with[gamemode].as[<player.gamemode>].with[location].as[<player.location>]>
+    - adjust <[player]> gamemode:spectator
+    - run cutscene_follow_path_by_interpolation def.player:<[player]> def.path:<[cutscene].get[result]> def.look_at:<[cutscene].get[look_at]> def.speed:<[cutscene].get[speed]> def.interpolation_procedure:<[cutscene].get[interpolation_procedure]> save:result
+    - define queue <entry[result].created_queue>
+    - flag <[player]> cutscene_queue:<[queue]>
+    - waituntil <[queue].state.equals[running]> max:5t
+    - waituntil <[queue].state.equals[running].not>
+    - define ok <[queue].determination.get[1]>
+    - run cutscene_stop def.player:<player>
+    - determine <[ok]>
+
+# Plays the cutscene atomically.
+# See cutscene_play for an explanation.
+# Should be ~waited for.
+cutscene_play_atomic:
+    debug: false
+    type: task
+    definitions: name|player|queue
+    script:
+    - ~run cutscene_play def.name:<[name]> def.player:<[player]> save:result
+    - define result <entry[result].created_queue.determination.get[1]>
+    - if !<[result].if_null[false]>:
+        - debug log "Cancelled atomic cutscene: <[player].name> @ <[name]>"
+        - queue stop <[queue]>
+
+# Stops the currently playing cutscene from playing.
+# If no cutscene is playing, it silently fails.
+cutscene_stop:
+    debug: false
+    type: task
+    definitions: player
+    script:
+    - if !<[player].has_flag[cutscene]>:
+        - stop
+    - define save <[player].flag[cutscene]>
+    - if <[player].flag[cutscene_queue]> != null:
+        - queue stop <[player].flag[cutscene_queue]>
+    - adjust <[player]> gamemode:<[save].get[gamemode]>
+    - teleport <[player]> <[save].get[location]>
+    - flag <[player]> cutscene:!
+
+## Internal only!
+cutscene_world:
+    debug: false
+    type: world
+    events:
+        on player joins:
+        - run cutscene_stop def.player:<player>

scripts/liteprofilesutils/liteprofilesutils_world.dsc

@@ -66,6 +66,10 @@ liteprofilesutils_world:
         - narrate <[joinleavedata].get[join].parsed> targets:<[setting_enabled_players]>
         ## prevent /profile remove
         on command:
+        - if <context.source_type> != player:
+            - stop
+        - if <player.is_op>:
+            - stop
         - if <context.command.to_lowercase> == profile || <context.command.to_lowercase> == account || <context.command.to_lowercase> == pf:
             - if <context.args.get[1].to_lowercase.if_null[null]> == remove:
                 - determine cancelled passively
@@ -95,3 +99,11 @@ liteprofilesutils_world:
         - else if <[data].get[type]> == free:
             - execute as_player "profile add"
             - run liteprofilesutils_show_menu def.player:<player>
+        ## patch whitelisting
+        on player prelogin:
+        - define uuid <context.uuid>
+        - define master <proc[liteprofilesutils_get_master_uuid].context[<player[<[uuid]>]>]>
+        - if <[master]> == <[uuid]>:
+            - stop
+        - adjust <player[<[uuid]>]> whitelisted:<player[<[master]>].is_whitelisted>
+

scripts/storyboard/ch1/ch1_1_preassign.dsc

@@ -2,9 +2,11 @@ ch1_1_preassign:
     debug: false
     type: world
     events:
-        on player joins:
+        after player joins:
+        - wait 1s
         - if <proc[storyboard_player_state_get].context[<player>|preassign]> == null:
-            - run storyboard_npc_memalloc "def:<player>|marie|player|<location[-4,2,-15,world]>|Marie Ayashibayomi|true|<script[storyboard_skin_dump].data_key[marie].get[a]>"
+            - if !<proc[storyboard_npc_exists].context[<player>|marie]>:
+                - run storyboard_npc_memalloc "def:<player>|marie|player|<location[-4,2,-15,world]>|Marie Ayashibayomi|true|<script[storyboard_skin_dump].data_key[marie].get[a]>"
             - run storyboard_npc_set_assignment def.player:<player> def.name:marie def.assignment:ch1_1_marie_assign
             - run storyboard_player_state_set def.player:<player> def.key:preassign def.value:true
 
@@ -131,6 +133,7 @@ ch1_1_marie_interact:
                         - ~run textbox_write def.player:<player> def.queue:<queue> "def.line3s:* Mkay." def.avatar_unicode:<script[storyboard_avatar_dump].data_key[marie].get[upset]>
                         - wait 1s
                         - disengage player
+                        - run storyboard_player_end_atomic_sequence def.queue:<queue> def.player:<player>
                         - stop
                     - ~run textbox_write def.player:<player> def.queue:<queue> "def.line3s:* Hm. Are you now?" def.avatar_unicode:<script[storyboard_avatar_dump].data_key[marie].get[upset]>
                     - ~run textbox_write def.player:<player> def.queue:<queue> "def.line3s:* You know, that was kind of$$nlmean of you." def.avatar_unicode:<script[storyboard_avatar_dump].data_key[marie].get[upset]>

scripts/storyboard/intro/intro_interactions.dsc

@@ -69,6 +69,7 @@ intro_interact_laptop_task:
     - ~run textbox_write def.player:<player>  def.queue:<queue> "def.line3s:You should give your character$$nla cool name, right?"
     - waituntil <player.has_flag[textbox_state].not> max:5s
     - ~run textbox_flush def.player:<player>
+    - run storyboard_player_end_atomic_sequence def.queue:<queue> def.player:<player>
     - run anvil_input def.player:<player> "def.prompt:Character Name" def.callback:intro_interact_laptop_task_name_callback
 
 intro_interact_laptop_task_name_callback:
@@ -76,6 +77,7 @@ intro_interact_laptop_task_name_callback:
     type: task
     definitions: player|input
     script:
+    - run storyboard_player_begin_atomic_sequence def.queue:<queue> def.player:<player>
     - define __player <[player]>
     - define name <[input].substring[1,24]>
     - if <server.flag[character_rpnames].contains[<[name]>]>:
@@ -89,6 +91,7 @@ intro_interact_laptop_task_name_callback:
     - ~run textbox_write def.player:<player>  def.queue:<queue> "def.line3s:Let's give them a description.$$nlDescribe their physical attributes."
     - waituntil <player.has_flag[textbox_state].not> max:5s
     - ~run textbox_flush def.player:<player>
+    - run storyboard_player_end_atomic_sequence def.queue:<queue> def.player:<player>
     - run anvil_input def.player:<player> def.prompt:Description def.callback:intro_interact_laptop_task_description_callback
 
 intro_interact_laptop_task_description_callback:
@@ -96,6 +99,7 @@ intro_interact_laptop_task_description_callback:
     type: task
     definitions: player|input
     script:
+    - run storyboard_player_begin_atomic_sequence def.queue:<queue> def.player:<player>
     - define __player <[player]>
     - execute as_player player:<[player]> "setdesc <[input]>"
     - ~run textbox_write def.player:<player>  def.queue:<queue> "def.line3s:Great, your character's almost ready."
@@ -104,6 +108,7 @@ intro_interact_laptop_task_description_callback:
     - ~run textbox_write def.player:<player>  def.queue:<queue> "def.line3s:For complete beginners, we recommend$$nlstarting out as a student."
     - waituntil <player.has_flag[textbox_state].not> max:5s
     - ~run textbox_flush def.player:<player>
+    - run storyboard_player_end_atomic_sequence def.queue:<queue> def.player:<player>
     - run intro_interact_laptop_task_role_menu def.player:<player>
 
 intro_interact_laptop_task_role_menu:
@@ -133,6 +138,7 @@ intro_interact_laptop_task_role_callback:
     type: task
     definitions: player|input
     script:
+    - run storyboard_player_begin_atomic_sequence def.queue:<queue> def.player:<player>
     - inventory close player:<[player]>
     - define __player <[player]>
     - define adult <[input].to_lowercase.trim.equals[yes]>

scripts/storyboard/tasks/storyboard_npc_tasks.dsc

@@ -39,8 +39,10 @@ storyboard_npc_memalloc:
     - define npc_id npc_<[player].uuid>_<[name]>
     - if !<server.npcs[<[registry]>].if_null[<list[]>].contains[<[npc_id]>]>:
         - define npcs <[player].flag[storyboard_state].get[npcs].if_null[<map[]>]>
+        - chunkload <[at].chunk> duration:10s
         - create <[type]> <[npc_id]> <[at]> registry:<[registry]> save:npc
         - define npc <entry[npc].created_npc>
+        - playeffect at:<[npc].location.above[1]> offset:0.35,1,0.35 effect:SOUL_FIRE_FLAME quantity:20
         - define npc_state <map[]>
         - define assignment null
         - if <[npcs].contains[<[name]>]>:
@@ -83,7 +85,7 @@ storyboard_npc_memalloc:
             - adjust <[npc]> skin_blob:<[skin_blob]>
         - if <[assignment]> != null:
             - assignment set script:<[assignment]> to:<[npc]>
-        - wait 2t
+        - wait 1t
         - run storyboard_npc_internal_show_to_player def.player:<[player]> def.npc:<[npc]>
     - else:
         - define index <server.npcs[<[registry]>].find[<[npc_id]>]>
@@ -98,7 +100,7 @@ storyboard_npc_by_name:
     script:
     - define registry registry_<[player].uuid>
     - define npc_id npc_<[player].uuid>_<[name]>
-    - determine <server.npcs[<[registry]>].filter_tag[<[filter_value].name.equals[<[npc_id]>]>].get[1]>
+    - determine <server.npcs[<[registry]>].filter_tag[<[filter_value].name.equals[<[npc_id]>]>].get[1].if_null[null]>
 
 # Frees an NPC from memory, but does not destroy its state.
 #
@@ -137,6 +139,14 @@ storyboard_npc_memdestroy:
     - define npc <proc[storyboard_npc_by_name].context[<[player]>|<[name]>]>
     - remove <[npc]>
 
+# Checks if an NPC exists for the given player.
+storyboard_npc_exists:
+    debug: false
+    type: procedure
+    definitions: player|name
+    script:
+    - determine <proc[storyboard_npc_by_name].context[<[player]>|<[name]>].if_null[null].equals[null].not>
+
 # Flags the NPC by name, mapping the given key to the given value.
 storyboard_npc_state_set:
     debug: false
@@ -215,6 +225,7 @@ storyboard_npc_internal_auto_memory_management:
     type: world
     events:
         after player joins:
+        - wait 1s
         - define npcs <player.flag[storyboard_state].get[npcs].if_null[<map[]>]>
         - foreach <[npcs]> key:name as:data:
             - define allocated  <[data].get[allocated].if_null[null]>