build static method

Implementation

static Future<RustSetonixPlugin> build(
  RustPlugin Function(PluginCallback) builder,
  PluginServerInterface server, {
  void Function(String)? onPrint,
  ItemLocation? location,
}) async {
  final processEventController = StreamController<(String, bool?)>();

  final callback = PluginCallback(
    onPrint: onPrint ?? (s) {},
    processEvent: (eventSerizalized, force) async {
      processEventController.add((eventSerizalized, force));
    },
    sendEvent: (eventSerizalized, target) {
      try {
        final event = PlayableWorldEventMapper.fromJson(eventSerizalized);
        server.sendEvent(event, target: target ?? kAnyChannel);
      } catch (e) {
        print("Error sending event from plugin: $e");
      }
    },
    stateFieldAccess: (field) {
      final state = server.state;
      return switch (field) {
        StateFieldAccess.info => state.info.toJson(),
        StateFieldAccess.tables => jsonEncode(
          state.data.getTables().toList(),
        ),
        StateFieldAccess.tableName => jsonEncode(state.tableName),
        StateFieldAccess.players => jsonEncode(server.players),
        StateFieldAccess.teamMembers => jsonEncode(state.teamMembers),
        StateFieldAccess.game => jsonEncode(location?.namespace ?? 'unknown'),
        StateFieldAccess.namespace => jsonEncode(
          location?.namespace ?? 'unknown',
        ),
      };
    },
    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 {
    final result = await instance.plugin.runEvent(
      eventType: e.clientEvent.runtimeType.toString(),
      event: e.clientEvent.toJson(),
      serverEvent: e.serverEvent.toJson(),
      target: e.target,
      source: e.source,
      cancelled: e.cancelled,
    );
    e.cancelled = result.cancelled;
    e.needsUpdate = result.needsUpdate;
    final serverEvent = result.serverEvent;
    if (serverEvent != null) {
      e.serverEvent = ServerWorldEventMapper.fromJson(serverEvent);
    }
  });
  await instance.plugin.run();
  return instance;
}