module: event handlers are defined ahead of time

Signed-off-by: Stephen Gutekanst <stephen@hexops.com>

src/ecs/main.zig

@@ -40,39 +40,47 @@ test "inclusion" {
 test "example" {
     const allocator = testing.allocator;
 
-    comptime var Renderer = type;
-    comptime var Physics = type;
-    Physics = mach.Module(struct {
-        pointer: u8,
+    const root = struct {
+        pub const modules = .{ Renderer, Physics };
 
-        pub const name = .physics;
-        pub const components = struct {
-            pub const id = u32;
+        const Physics = struct {
+            pointer: u8,
+
+            pub const name = .physics;
+            pub const components = struct {
+                pub const id = u32;
+            };
+            pub const events = .{
+                .{ .global = .tick, .handler = tick },
+            };
+
+            fn tick(physics: *World(modules).Mod(Physics)) void {
+                _ = physics;
+            }
         };
 
-        pub fn tick(physics: *World(.{ Renderer, Physics }).Mod(Physics)) void {
-            _ = physics;
-        }
-    });
+        const Renderer = struct {
+            pub const name = .renderer;
+            pub const components = struct {
+                pub const id = u16;
+            };
+            pub const events = .{
+                .{ .global = .tick, .handler = tick },
+            };
 
-    Renderer = mach.Module(struct {
-        pub const name = .renderer;
-        pub const components = struct {
-            pub const id = u16;
+            fn tick(
+                physics: *World(modules).Mod(Physics),
+                renderer: *World(modules).Mod(Renderer),
+            ) void {
+                _ = renderer;
+                _ = physics;
+            }
         };
-
-        pub fn tick(
-            physics: *World(.{ Renderer, Physics }).Mod(Physics),
-            renderer: *World(.{ Renderer, Physics }).Mod(Renderer),
-        ) void {
-            _ = renderer;
-            _ = physics;
-        }
-    });
+    };
 
     //-------------------------------------------------------------------------
     // Create a world.
-    var world: World(.{ Renderer, Physics }) = undefined;
+    var world: World(root.modules) = undefined;
     try world.init(allocator);
     defer world.deinit();
 

src/ecs/systems.zig

@@ -6,6 +6,7 @@ const mach = @import("../main.zig");
 const Entities = @import("entities.zig").Entities;
 const EntityID = @import("entities.zig").EntityID;
 const comp = @import("comptime.zig");
+const Module = @import("../module.zig").Module;
 
 pub fn World(comptime mods: anytype) type {
     const StateT = NamespacedState(mods);
@@ -21,8 +22,8 @@ pub fn World(comptime mods: anytype) type {
         pub const IsInjectedArgument = void;
 
         const WorldT = @This();
-        pub fn Mod(comptime Module: anytype) type {
-            const module_tag = Module.name;
+        pub fn Mod(comptime M: anytype) type {
+            const module_tag = M.name;
             const State = @TypeOf(@field(@as(StateT, undefined), @tagName(module_tag)));
             const components = @field(ns_components, @tagName(module_tag));
             return struct {
@@ -212,6 +213,8 @@ fn NamespacedComponents(comptime modules: anytype) type {
 fn NamespacedState(comptime modules: anytype) type {
     var fields: []const std.builtin.Type.StructField = &[0]std.builtin.Type.StructField{};
     inline for (modules) |M| {
+        // TODO: can't verify module here because it would introduce a dependency loop
+        // _ = Module(M);
         const state_fields = std.meta.fields(M);
         const State = if (state_fields.len > 0) @Type(.{
             .Struct = .{