Unpack collections inside command loops

Author: dsrw

src/controllers/script_controllers/host_bridge.nim

@@ -154,21 +154,35 @@ proc reset_level(self: Worker) =
     state.config_value.value:
       level_dir = current_level
 
+template query(
+    T: type Unit, key: string, ctx: ScriptCtx, body: untyped
+): untyped =
+  var result: T
+  if key in ctx.query_results:
+    result = T(ctx.query_results[key][^1])
+  else:
+    let results = body
+    if ?results:
+      result = results[^1]
+      ctx.query_results[key] = cast[seq[Unit]](results)
+  result
+
 proc ensure_unit(self: Worker, unit: Unit) =
   if unit notin self.node_map:
     var node = self.node_map[self.active_unit].copy_tree
     self.map_unit(unit, node)
 
-proc current_collider(self: Unit, kind: string): Unit =
-  var collider: Unit
-  state.units.value.walk_tree proc(unit: Unit) =
-    if self.collisions.value.any_it(it.id == unit.id):
-      if kind == "Unit" or kind == "Player" and unit of Player or
-          kind == "Bot" and unit of Bot or kind == "Build" and unit of Build or
-          kind == "Sign" and unit of Sign:
-        collider = unit
-        return
-  result = collider
+proc current_collider(self: Worker, unit: Unit, kind: string): Unit =
+  Unit.query(kind & "-collider", unit.script_ctx):
+    var colliders: seq[Unit]
+    state.units.value.walk_tree proc(other: Unit) =
+      if unit.collisions.value.any_it(it.id == other.id):
+        if kind == "Unit" or kind == "Player" and other of Player or
+            kind == "Bot" and other of Bot or kind == "Build" and other of Build or
+            kind == "Sign" and other of Sign:
+          colliders.add(other)
+          self.ensure_unit(other)
+    colliders
 
 proc world_name(): string =
   state.config.world
@@ -219,11 +233,57 @@ proc sleep_impl(self: Worker, ctx: ScriptCtx, seconds: float) =
   ctx.last_ran = MonoTime.default
   self.pause_script()
 
+proc loop_finished(self: Worker, ctx: ScriptCtx) =
+  if ?ctx.query_results:
+    let key = ctx.query_results.first_key
+    let res = ctx.query_results[key].pop
+    if not ?ctx.query_results[key]:
+      ctx.query_results.del key
+      if not ?ctx.query_results:
+        self.sleep_impl(ctx, 0.0)
+  else:
+    self.sleep_impl(ctx, 0.0)
+
 proc hit(unit_a: Unit, unit_b: Unit): Vector3 =
   for collision in unit_a.collisions:
     if collision.id == unit_b.id:
       return collision.normal.snapped(vec3(1, 1, 1))
 
+proc find_all[T: Unit](worker: Worker, _: type T): seq[T] =
+  var units: seq[T]
+  state.units.value.walk_tree proc(unit: Unit) =
+    if unit of T:
+      worker.ensure_unit(unit)
+      units.add T(unit)
+  units
+
+proc all_players(ctx: ScriptCtx, worker: Worker): Player =
+  Player.query("all-players", ctx):
+    worker.find_all(Player)
+
+proc all_bots(ctx: ScriptCtx, worker: Worker): Bot =
+  Bot.query("all-bots", ctx):
+    worker.find_all(Bot)
+
+proc all_builds(ctx: ScriptCtx, worker: Worker): Build =
+  Build.query("all-builds", ctx):
+    worker.find_all(Build)
+
+proc all_signs(ctx: ScriptCtx, worker: Worker): Sign =
+  Sign.query("all-builds", ctx):
+    worker.find_all(Sign)
+
+proc all_units(ctx: ScriptCtx, worker: Worker): Unit =
+  Unit.query("all-builds", ctx):
+    worker.find_all(Unit)
+
+proc added*(_: type Player, ctx: ScriptCtx, worker: Worker): Player =
+  Player.query("players-added", ctx):
+    collect:
+      for player in worker.find_all(Player):
+        if player.frame_created == state.frame_count:
+          player
+
 proc echo_console(msg: string) =
   logger("info", msg & "\n")
   state.push_flag ConsoleVisible
@@ -596,7 +656,8 @@ proc bridge_to_vm*(worker: Worker) =
     active_unit, color, `color=`, sees, start_position, wake, frame_count,
     write_stack_trace, show, `show=`, frame_created, lock, `lock=`, reset,
     press_action, load_level, level_name, world_name, reset_level,
-    current_collider
+    current_collider, added, all_players, all_builds, all_bots, all_signs,
+    all_units, loop_finished
 
   result.bridged_from_vm "base_bridge_private",
     link_dependency, action_running, `action_running=`, yield_script,

src/controllers/script_controllers/host_bridge_utils.nim

@@ -64,6 +64,8 @@ proc await_future[T](future: Future[T], a: VmArgs) =
   future.add_callback proc(future: Future[T]) =
     set_result(a, to_result(future.read))
 
+const unit_types = ["Unit", "Bot", "Build", "Sign", "Player"]
+
 macro bridged_from_vm(
     self: Worker, module_name: string, proc_refs: varargs[untyped]
 ): untyped =
@@ -76,8 +78,7 @@ macro bridged_from_vm(
     let
       symbol = bind_sym($proc_ref)
       proc_impl = (if symbol.kind == nnkSym: symbol
-      else: symbol[0]
-      ).get_impl
+      else: symbol[0]).get_impl
       proc_name = proc_impl[0].str_val
       proc_impl_name = proc_name.replace("=", "_set") & "_impl"
       return_node = proc_impl[3][0]
@@ -87,28 +88,31 @@ macro bridged_from_vm(
       block:
         var pos = -1
         for ident_def in arg_nodes:
-          let typ = ident_def[1].str_val
+          let typ = ident_def[1].repr
           if typ == $Worker.type:
             ident"script_engine"
           elif typ == "VmArgs":
             ident"a"
           elif typ == "ScriptCtx":
             quote:
               script_engine.active_unit.script_ctx
-          elif typ in ["Unit", "Bot", "Build", "Sign"]:
+          elif typ in unit_types:
             let getter = "get_" & typ
             pos.inc
             new_call(
               bind_sym(getter), ident"script_engine", ident"a", new_lit(pos)
             )
+          elif typ in unit_types.map_it(\"type {it}"):
+            let type_name = typ.split(" ")[1]
+            ident(type_name)
           else:
             let getter = "get_" & typ
             pos.inc
             new_call(bind_sym(getter), ident"a", new_lit(pos))
 
     var call = new_call(proc_ref, args)
     if return_node.kind == nnk_sym:
-      if return_node.str_val in ["Unit", "Bot", "Build", "Sign"]:
+      if return_node.str_val in unit_types:
         call = new_call(
           bind_sym"set_result",
           ident"a",

src/controllers/script_controllers/scripting.nim

@@ -131,6 +131,7 @@ proc init_interpreter*[T](self: Worker, _: T) {.gcsafe.} =
 
 proc load_script*(self: Worker, unit: Unit, timeout = script_timeout) =
   let ctx = unit.script_ctx
+  ctx.query_results.clear
   try:
     self.active_unit = unit
     unit.errors.clear

src/core.nim

@@ -346,3 +346,13 @@ const environments* = {
 template `?=`*[T](a: var T, b: T) =
   if not ?a:
     a = b
+
+template `?`*[T](self: seq[T]): bool =
+  self.len > 0
+
+template `?`*(self: Table): bool =
+  self.len > 0
+
+proc first_key*[K, V](self: Table[K, V]): K =
+  for key in self.keys:
+    return key

src/models/players.nim

@@ -3,15 +3,20 @@ import godotapi/spatial
 import core, models/units
 
 proc init*(_: type Player): Player =
-  result = Player(
+  let self = Player(
     id: \"player-{Zen.thread_ctx.id}",
     rotation_value: ~0.0,
     start_transform: Transform.init(origin = vec3(0, 1, 0)),
     input_direction_value: ~Vector3,
     cursor_position_value: ~((0, 0)),
   )
-  result.init_unit(shared = false)
-  result.global_flags += Global
+  self.init_unit(shared = false)
+  self.global_flags += Global
+
+  state.local_flags.changes:
+    if ResettingVM.added:
+      self.frame_created = state.frame_count
+  result = self
 
 method on_begin_turn*(
     self: Player, direction: Vector3, degrees: float, lean: bool, move_mode: int

src/types.nim

@@ -281,6 +281,7 @@ type
     pass_context*: PContext
     last_ran*: MonoTime
     file_index*: int
+    query_results*: Table[string, seq[Unit]]
 
   VMError* = object of CatchableError
   QuitKind* = enum
@@ -303,12 +304,12 @@ type
     retry_failures*: bool
     interpreter*: Interpreter
     module_names*: HashSet[string]
-    watch_active*: bool
     active_unit*: Unit
     unit_map*: Table[PNode, Unit]
     node_map*: Table[Unit, PNode]
     failed*: seq[tuple[unit: Unit, e: ref VMQuit]]
     last_exception*: ref Exception
+    player_cache*: Table[string, Player]
 
   NodeController* = ref object
 

vmlib/enu/base_api.nim

@@ -17,6 +17,9 @@ proc `position=`*(self: Unit, position: Vector3) =
 proc `position=`*(self: Unit, unit: Unit) =
   self.position_set(unit.position)
 
+proc go*(self: Unit, position: Unit | Vector3) =
+  self.position = position
+
 proc link_dependency*(dep: Unit) =
   if not dep.is_nil:
     link_dependency_impl(dep)

vmlib/enu/base_bridge.nim

@@ -50,6 +50,7 @@ bridged_to_host:
   proc level_name*(): string
   proc world_name*(): string
   proc current_collider*(self: Unit, name: string): Unit
+  proc added*[T: Unit](kind: type T): T
 
   # TODO: These should be in base_bridge_private, but are currently needed outside of base_api.
   proc echo_console*(msg: string)
@@ -59,3 +60,4 @@ bridged_to_host:
   proc wake*(self: Unit)
   proc create_new*(self: Unit)
   proc frame_count*(): int
+  proc loop_finished*()

vmlib/enu/base_bridge_private.nim

@@ -7,9 +7,7 @@ bridged_to_host:
   proc action_running*(self: Unit): bool
   proc `action_running=`*(self: Unit, value: bool)
   proc yield_script*(self: Unit)
-  proc begin_move*(
-    self: Unit, direction: Vector3, steps: float, move_mode: int
-  )
+  proc begin_move*(self: Unit, direction: Vector3, steps: float, move_mode: int)
 
   proc begin_turn*(
     self: Unit, axis: Vector3, steps: float, lean: bool, move_mode: int

vmlib/enu/bots.nim

@@ -2,10 +2,10 @@ import std/[strutils, math]
 import types, base_api, vm_bridge_utils
 
 bridged_to_host:
-  proc all_bots(): seq[Bot]
+  proc all_bots(): Bot
   proc play*(self: Bot, animation_name: string)
 
-proc all*(_: type Bot): seq[Bot] =
+proc all*(_: type Bot): Bot =
   all_bots()
 
 proc walk*(self: Bot) =

vmlib/enu/builds.nim

@@ -5,18 +5,18 @@ bridged_to_host:
   proc drawing*(self: Build): bool
   proc `drawing=`*(self: Build, drawing: bool)
   proc initial_position(self: Build): Vector3
-  proc all_builds(): seq[Build]
   proc save*(self: Build, name = "default")
   proc restore*(self: Build, name = "default")
   proc draw_position*(self: Build): Vector3
   proc `draw_position=`*(self: Build, value: Vector3)
+  proc all_builds(): Build
+
+proc all*(_: type Build): Build =
+  all_builds()
 
 proc `draw_position=`*(self: Build, unit: Unit) =
   self.draw_position = unit.position
 
-proc all*(_: type Build): seq[Build] =
-  all_builds()
-
 proc go_home*(self: Build) =
   self.rotation = 0
   self.scale = 1

vmlib/enu/players.nim

@@ -1,20 +1,21 @@
 import types, base_api, vm_bridge_utils
 
-let player* = PlayerType()
-register_active(player)
-
 bridged_to_host:
-  proc tool*(self: PlayerType): Tools
-  proc `tool=`*(self: PlayerType, value: Tools)
-  proc playing*(self: PlayerType): bool
-  proc `playing=`*(self: PlayerType, value: bool)
-  proc flying*(self: PlayerType): bool
-  proc `flying=`*(self: PlayerType, value: bool)
-  proc running*(self: PlayerType): bool
-  proc `running=`*(self: PlayerType, value: bool)
-  proc god*(self: PlayerType): bool
-  proc `god=`*(self: PlayerType, value: bool)
-  proc coding*(self: PlayerType): Unit
-  proc `coding=`*(self: PlayerType, value: Unit)
-  proc open_sign*(self: PlayerType): Sign
-  proc `open_sign=`*(self: PlayerType, value: Sign)
+  proc tool*(self: Player): Tools
+  proc `tool=`*(self: Player, value: Tools)
+  proc playing*(self: Player): bool
+  proc `playing=`*(self: Player, value: bool)
+  proc flying*(self: Player): bool
+  proc `flying=`*(self: Player, value: bool)
+  proc running*(self: Player): bool
+  proc `running=`*(self: Player, value: bool)
+  proc god*(self: Player): bool
+  proc `god=`*(self: Player, value: bool)
+  proc coding*(self: Player): Unit
+  proc `coding=`*(self: Player, value: Unit)
+  proc open_sign*(self: Player): Sign
+  proc `open_sign=`*(self: Player, value: Sign)
+  proc all_players(): Player
+
+proc all*(_: type Player): Player =
+  all_players()