Fix event system in lua

Author: CodeDoctorDE

app/lib/bloc/world/bloc.dart

@@ -23,18 +23,18 @@ class _WorldServerInterfaceImpl implements ServerInterface {
   _WorldServerInterfaceImpl(this.bloc);
 
   @override
-  void process(WorldEvent event, {bool force = false, required String plugin}) {
-    bloc.process(event);
-  }
+  Future<void> process(
+    WorldEvent event, {
+    bool force = false,
+    required String plugin,
+  }) => bloc.process(event);
 
   @override
-  void sendEvent(
+  Future<void> sendEvent(
     PlayableWorldEvent event, {
     Channel target = kAnyChannel,
     required String plugin,
-  }) {
-    bloc._processEvent(NetworkerPacket(event, target));
-  }
+  }) => bloc._processEvent(NetworkerPacket(event, target));
 
   @override
   void print(String message, [String? plugin]) {

app/pack/scripts/blackjack.luau

@@ -10,6 +10,56 @@ local StackPosition = {
 }
 local CurrentPlayer = 1
 local PlayerScores : {[number]: number} = {}
+local Colors = {
+  "heart",
+  "diamond",
+  "club",
+  "spade"
+}
+local Values = {
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "10",
+  "jack",
+  "queen",
+  "king",
+  "ace"
+}
+function GetVariations() : {string}
+  local variations = {}
+  for _, color in ipairs(Colors) do
+    for _, value in ipairs(Values) do
+      table.insert(variations, color.."-"..value)
+    end
+  end
+  return variations
+end
+function SpawnDeck(cell)
+  local variations = GetVariations()
+  local tableName = cell.table
+  local vector = "("..cell.x..", "..cell.y..")"
+  local objects = {}
+  for _, variation in ipairs(variations) do
+    table.insert(objects, {
+      asset=State.Namespace..":cards",
+      variation=variation,
+    })
+  end
+  Server:Process({
+    type="ObjectsSpawned",
+    table=tableName,
+    objects={
+      [vector]=objects
+    }
+  }, true)
+end
 function Reset()
   ResetWorld()
   PlayerScores = {}
@@ -18,19 +68,15 @@ function Reset()
 end
 function Setup()
   print("setup")
-  print(State.PluginId)
+  print(State.Namespace)
   Server:Process({
-    type="CellVisibilityChanged",
+    type="CellHideChanged",
     cell=DeckPosition,
-    visibility=false
+    hide=true
   }, true)
+  SpawnDeck(DeckPosition)
   Server:Process({
-    type="DeckSpawned",
-    cell=DeckPosition,
-    deck=State.PluginId..":cards"
-  }, true)
-  Server:Process({
-    type="CellShuffleRequest",
+    type="ShuffleCellRequest",
     cell=DeckPosition
   }, true)
 end
@@ -59,7 +105,7 @@ local VariationsScores : {[string]: {number}} = {
 local MaxScore = 21
 function CalculateCard(identifier) : {number}
   local splitted = string.split(identifier, ":")
-  if #splitted ~= 2 or splitted[1] ~= State.PluginId then
+  if #splitted ~= 2 or splitted[1] ~= State.Namespace then
     return {0}
   end 
   splitted = string.split(splitted[2], "-")
@@ -181,6 +227,10 @@ Events.ObjectsSpawned.Connect(function(event, details)
   details.cancelled = true
   print("Spawning objects is not allowed.")
 end)
+Events.BoardsSpawnRequest.Connect(function(event, details)
+  details.cancelled = true
+  print("Spawning boards is not allowed.")
+end)
 Events.ObjectMoved.Connect(function(event, details)
   local isFromDeck = event.from.table == DeckPosition.table and event.from.x == DeckPosition.x and event.from.y == DeckPosition.y
   local isToStack = event.to.table == StackPosition.table and event.to.x == StackPosition.x and event.to.y == StackPosition.y

plugin/definitions/setonix.d.luau

@@ -23,6 +23,8 @@ declare State: {
 	Info: JsonObject,
 	Players: { number },
 	PluginId: string,
+	Namespace: string,
+	Game: string,
 	Table: JsonObject,
 	GetTable: (self: any, name: string) -> JsonObject?
 }

plugin/example/lua.dart

@@ -1,3 +1,5 @@
+import 'dart:async';
+
 import 'package:flutter_rust_bridge/flutter_rust_bridge.dart';
 import 'package:setonix_plugin/setonix_plugin.dart';
 
@@ -13,15 +15,22 @@ end)
 ''';
 Future<void> main() async {
   await initPluginSystem();
-  final callback = await PluginCallback.default_();
-  callback.changeOnPrint(
+  final callback = PluginCallback(
     onPrint: (p0) {
-      print("SANDBOX: ${p0}");
+      print("PLUGIN: ${p0}");
     },
-  );
-  callback.changeStateFieldAccess(
     stateFieldAccess: (p0) {
-      print("FIELD: ${p0}");
+      print("FIELD ACCESS: ${p0}");
+      return '{"key": "value"}';
+    },
+    processEvent: (p0, p1) {
+      print("PROCESS EVENT: ${p0}, force: ${p1}");
+    },
+    sendEvent: (p0, p1) {
+      print("SEND EVENT: ${p0}, target: ${p1}");
+    },
+    tableAccess: (p0) {
+      print("TABLE ACCESS: ${p0}");
       return '{"key": "value"}';
     },
   );

plugin/lib/src/plugin.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
@@ -15,8 +16,12 @@ typedef PluginSendEventCallback =
     );
 
 mixin ServerInterface {
-  void process(WorldEvent event, {bool force = false, required String plugin});
-  void sendEvent(
+  Future<void> process(
+    WorldEvent event, {
+    bool force = false,
+    required String plugin,
+  });
+  Future<void> sendEvent(
     PlayableWorldEvent event, {
     Channel target = kAnyChannel,
     required String plugin,
@@ -52,7 +57,7 @@ final class PluginSystem {
         (c) => LuauPlugin(code: code, callback: c),
         pluginServer,
         onPrint: (e) => server.print(e, name),
-        pluginId: () => name,
+        location: ItemLocation.fromString(name),
       ),
     );
   }
@@ -108,8 +113,11 @@ final class PluginSystem {
 }
 
 abstract class PluginServerInterface {
-  void process(WorldEvent event, {bool force = false});
-  void sendEvent(PlayableWorldEvent event, {Channel target = kAnyChannel});
+  Future<void> process(WorldEvent event, {bool force = false});
+  Future<void> sendEvent(
+    PlayableWorldEvent event, {
+    Channel target = kAnyChannel,
+  });
   WorldState get state;
   List<int> get players;
 }
@@ -121,14 +129,14 @@ class _PluginServerInterfaceImpl implements PluginServerInterface {
   _PluginServerInterfaceImpl(this.server, this.pluginName);
 
   @override
-  void process(WorldEvent event, {bool force = false}) {
-    server.process(event, force: force, plugin: pluginName);
-  }
+  Future<void> process(WorldEvent event, {bool force = false}) =>
+      server.process(event, force: force, plugin: pluginName);
 
   @override
-  void sendEvent(PlayableWorldEvent event, {Channel target = kAnyChannel}) {
-    server.sendEvent(event, target: target, plugin: pluginName);
-  }
+  Future<void> sendEvent(
+    PlayableWorldEvent event, {
+    Channel target = kAnyChannel,
+  }) => server.sendEvent(event, target: target, plugin: pluginName);
 
   @override
   WorldState get state => server.state;
@@ -164,25 +172,23 @@ final class RustSetonixPlugin extends SetonixPlugin {
     RustPlugin Function(PluginCallback) builder,
     PluginServerInterface server, {
     void Function(String)? onPrint,
-    String Function()? pluginId,
+    ItemLocation? location,
   }) async {
-    final callback = PluginCallback.default_();
-    if (onPrint != null) {
-      callback.changeOnPrint(onPrint: onPrint);
-    }
-    callback.changeProcessEvent(
-      processEvent: (eventSerizalized, force) {
-        final event = WorldEventMapper.fromJson(eventSerizalized);
-        server.process(event, force: force ?? false);
+    final processEventController = StreamController<(String, bool?)>();
+
+    final callback = PluginCallback(
+      onPrint: onPrint ?? (s) {},
+      processEvent: (eventSerizalized, force) async {
+        processEventController.add((eventSerizalized, force));
       },
-    );
-    callback.changeSendEvent(
       sendEvent: (eventSerizalized, target) {
-        final event = PlayableWorldEventMapper.fromJson(eventSerizalized);
-        server.sendEvent(event, target: target ?? kAnyChannel);
+        try {
+          final event = PlayableWorldEventMapper.fromJson(eventSerizalized);
+          server.sendEvent(event, target: target ?? kAnyChannel);
+        } catch (e) {
+          print("Error sending event from plugin: $e");
+        }
       },
-    );
-    callback.changeStateFieldAccess(
       stateFieldAccess: (field) {
         final state = server.state;
         return switch (field) {
@@ -193,18 +199,30 @@ final class RustSetonixPlugin extends SetonixPlugin {
           StateFieldAccess.tableName => jsonEncode(state.tableName),
           StateFieldAccess.players => jsonEncode(server.players),
           StateFieldAccess.teamMembers => jsonEncode(state.teamMembers),
-          StateFieldAccess.pluginId => jsonEncode(
-            pluginId?.call() ?? 'unknown',
+          StateFieldAccess.game => jsonEncode(location?.namespace ?? 'unknown'),
+          StateFieldAccess.namespace => jsonEncode(
+            location?.namespace ?? 'unknown',
           ),
         };
       },
-    );
-    callback.changeTableAccess(
       tableAccess: (tableName) {
         final table = server.state.data.getTable(tableName ?? '');
         return table?.toJson() ?? "{}";
       },
     );
+    processEventController.stream.listen((message) async {
+      final (eventSerizalized, force) = message;
+      final smallMsg = eventSerizalized.substring(0, 20);
+      try {
+        onPrint?.call("Process event called from plugin: $smallMsg");
+        final event = WorldEventMapper.fromJson(eventSerizalized);
+        await server.process(event, force: force ?? false);
+      } catch (e) {
+        onPrint?.call("Error processing event from plugin: $e");
+      } finally {
+        onPrint?.call("Finished processing event from plugin $smallMsg");
+      }
+    });
     final plugin = builder(callback);
     final instance = RustSetonixPlugin._(server, plugin);
     instance.eventSystem.on<WorldEvent>((e) async {

plugin/lib/src/rust/api/plugin.dart

@@ -6,35 +6,25 @@
 import '../frb_generated.dart';
 import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart';
 
-// These functions are ignored because they are not marked as `pub`: `get`, `new`
-// These types are ignored because they are neither used by any `pub` functions nor (for structs and enums) marked `#[frb(unignore)]`: `StateFieldAccessIter`
+// These functions are ignored because they are not marked as `pub`: `build`, `get`, `new`
+// These types are ignored because they are neither used by any `pub` functions nor (for structs and enums) marked `#[frb(unignore)]`: `EventDetails`, `StateFieldAccessIter`
 // These function are ignored because they are on traits that is not defined in current crate (put an empty `#[frb]` on it to unignore): `clone`, `clone`, `clone`, `fmt`, `fmt`, `iter`, `len`, `next_back`, `next`, `nth`, `size_hint`
 
-// Rust type: RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<EventDetails>>
-abstract class EventDetails implements RustOpaqueInterface {}
-
 // Rust type: RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<PluginCallback>>
 abstract class PluginCallback implements RustOpaqueInterface {
-  void changeOnPrint({required FutureOr<void> Function(String) onPrint});
-
-  void changeProcessEvent({
+  factory PluginCallback({
+    required FutureOr<void> Function(String) onPrint,
     required FutureOr<void> Function(String, bool?) processEvent,
-  });
-
-  void changeSendEvent({
     required FutureOr<void> Function(String, int?) sendEvent,
-  });
-
-  void changeStateFieldAccess({
     required FutureOr<String> Function(StateFieldAccess) stateFieldAccess,
-  });
-
-  void changeTableAccess({
     required FutureOr<String> Function(String?) tableAccess,
-  });
-
-  static PluginCallback default_() =>
-      RustLib.instance.api.crateApiPluginPluginCallbackDefault();
+  }) => RustLib.instance.api.crateApiPluginPluginCallbackNew(
+    onPrint: onPrint,
+    processEvent: processEvent,
+    sendEvent: sendEvent,
+    stateFieldAccess: stateFieldAccess,
+    tableAccess: tableAccess,
+  );
 }
 
 abstract class RustPlugin {
@@ -63,14 +53,6 @@ class EventResult {
     required this.cancelled,
   });
 
-  static Future<EventResult> build({
-    required EventDetails details,
-    EventDetails? previous,
-  }) => RustLib.instance.api.crateApiPluginEventResultBuild(
-    details: details,
-    previous: previous,
-  );
-
   @override
   int get hashCode =>
       target.hashCode ^
@@ -95,5 +77,6 @@ enum StateFieldAccess {
   info,
   players,
   teamMembers,
-  pluginId,
+  namespace,
+  game,
 }