Start adding multi world support to server

Author: CodeDoctorDE

app/lib/bloc/world/bloc.dart

@@ -45,8 +45,8 @@ class WorldBloc extends Bloc<PlayableWorldEvent, ClientWorldState> {
       onProcess: (p0, p1, [force = false]) {
         process(p1);
       },
-      onSendEvent: (p0, p1) {
-        _processEvent(p1);
+      onSendEvent: (packet, worldName) {
+        _processEvent(packet);
       },
       playersGetter: () => state.multiplayer.clients.toList(),
       stateGetter: () => state.world,

docs/package.json

@@ -15,7 +15,7 @@
     "@astrojs/starlight": "^0.33.0",
     "@phosphor-icons/react": "^2.1.7",
     "@types/react": "^19.1.0",
-    "@types/react-dom": "^19.1.1",
+    "@types/react-dom": "^19.1.2",
     "astro": "^5.6.1",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",

docs/pnpm-lock.yaml

@@ -1,5 +1,5 @@
 * Add importing system for editor
-* Add launch app link for android
+* Add launch app link for android ([#37](https://github.com/LinwoodDev/Setonix/issues/37))
 * Add option for server to send link information
 * Improve multiplayer ui
 * Add swamp multiplayer support

metadata/en-US/changelogs/5.txt

@@ -6,16 +6,25 @@ import 'package:setonix_api/setonix_api.dart';
 
 part 'model.mapper.dart';
 
+const defaultWorldName = '';
+
 base class Event<T extends WorldEvent> {
   final T clientEvent;
   final Channel source;
+  final String worldName;
   ServerWorldEvent serverEvent;
   Channel target;
   bool cancelled = false;
   Set<Channel>? needsUpdate;
 
-  Event(this.serverEvent, this.target, this.clientEvent, this.source,
-      this.needsUpdate);
+  Event({
+    required this.serverEvent,
+    required this.target,
+    required this.clientEvent,
+    required this.source,
+    this.worldName = defaultWorldName,
+    this.needsUpdate,
+  });
 
   Event<C> castEvent<C extends WorldEvent>() {
     return _LinkedEvent<C>(this);
@@ -65,6 +74,9 @@ final class _LinkedEvent<T extends WorldEvent> implements Event<T> {
 
   @override
   set needsUpdate(Set<Channel>? value) => parent.needsUpdate = value;
+
+  @override
+  String get worldName => parent.worldName;
 }
 
 final class ServerPing {

plugin/lib/src/events/model.dart

@@ -10,15 +10,15 @@ import 'package:setonix_plugin/src/rust/frb_generated.dart';
 
 typedef PluginProcessCallback = void Function(String, WorldEvent, [bool force]);
 typedef PluginSendEventCallback = void Function(
-    String, NetworkerPacket<PlayableWorldEvent>);
+    NetworkerPacket<PlayableWorldEvent> packet, String? worldName);
 
 final class PluginSystem {
   final Map<
       String,
       (
         SetonixPlugin,
         StreamSubscription<ProcessMessage>,
-        StreamSubscription<NetworkerPacket<PlayableWorldEvent>>
+        StreamSubscription<SentEvent>
       )> _plugins = {};
   final PluginProcessCallback _onProcess;
   final PluginSendEventCallback _onSendEvent;
@@ -36,8 +36,8 @@ final class PluginSystem {
   void registerPlugin(String name, SetonixPlugin plugin) {
     final processSub = plugin.onProcess
         .listen((message) => _onProcess(name, message.event, message.force));
-    final sendSub =
-        plugin.onSendEvent.listen((event) => _onSendEvent(name, event));
+    final sendSub = plugin.onSendEvent
+        .listen((event) => _onSendEvent(event.event, event.worldName));
     _plugins[name] = (plugin, processSub, sendSub);
   }
 
@@ -102,22 +102,30 @@ final class ProcessMessage {
   ProcessMessage(this.event, this.force);
 }
 
+final class SentEvent {
+  final NetworkerPacket<PlayableWorldEvent> event;
+  final String? worldName;
+
+  SentEvent(this.event, [this.worldName]);
+}
+
 class SetonixPlugin {
   final EventSystem eventSystem = EventSystem();
   final StreamController<ProcessMessage> _onProcessController =
       StreamController.broadcast();
-  final StreamController<NetworkerPacket<PlayableWorldEvent>>
-      _onSendEventController = StreamController.broadcast();
+  final StreamController<SentEvent> _onSendEventController =
+      StreamController.broadcast();
 
   Stream<ProcessMessage> get onProcess => _onProcessController.stream;
-  Stream<NetworkerPacket<PlayableWorldEvent>> get onSendEvent =>
-      _onSendEventController.stream;
+  Stream<SentEvent> get onSendEvent => _onSendEventController.stream;
 
   void process(WorldEvent event, {bool force = false}) =>
       _onProcessController.add(ProcessMessage(event, force));
 
-  void sendEvent(PlayableWorldEvent event, [Channel target = kAnyChannel]) =>
-      _onSendEventController.add(NetworkerPacket(event, target));
+  void sendEvent(PlayableWorldEvent event,
+          {Channel target = kAnyChannel, String? worldName}) =>
+      _onSendEventController
+          .add(SentEvent(NetworkerPacket(event, target), worldName));
 
   void dispose() {
     eventSystem.dispose();
@@ -148,7 +156,7 @@ final class RustSetonixPlugin extends SetonixPlugin {
     });
     callback.changeSendEvent(sendEvent: (eventSerizalized, target) {
       final event = PlayableWorldEventMapper.fromJson(eventSerizalized);
-      instance.sendEvent(event, target ?? kAnyChannel);
+      instance.sendEvent(event, target: target ?? kAnyChannel);
     });
     callback.changeStateFieldAccess(stateFieldAccess: (field) {
       final state = pluginSystem.stateGetter();

plugin/lib/src/plugin.dart

@@ -4,6 +4,7 @@ library;
 export 'package:setonix_api/setonix_api.dart';
 export 'package:setonix_plugin/setonix_plugin.dart';
 export 'src/asset.dart';
+export 'src/bloc.dart';
 export 'src/main.dart';
 export 'src/server.dart';
 export 'src/programs/kick.dart';

server/lib/setonix_server.dart

@@ -0,0 +1,134 @@
+import 'dart:io';
+import 'dart:isolate';
+
+import 'package:bloc/bloc.dart';
+import 'package:bloc_concurrency/bloc_concurrency.dart';
+import 'package:consoler/consoler.dart';
+import 'package:setonix_server/setonix_server.dart';
+
+Future<ServerProcessed> _computeEvent(ServerWorldEvent event, WorldState state,
+    List<SignatureMetadata> signature) {
+  return Isolate.run(
+      () => processServerEvent(event, state, signature: signature));
+}
+
+class WorldBloc extends Bloc<PlayableWorldEvent, WorldState> {
+  final SetonixServer server;
+  final String worldName;
+
+  ServerAssetManager get assetManager => server.assetManager;
+
+  bool get autosave => server.autosave;
+
+  WorldBloc(SetonixData data, this.server, this.worldName)
+      : super(WorldState(
+          data: data,
+          table: data.getTableOrDefault(),
+          metadata: data.getMetadataOrDefault(),
+          info: data.getInfoOrDefault(),
+        )) {
+    on<ServerWorldEvent>((event, emit) async {
+      final signature = assetManager.createSignature();
+      final processed =
+          await _computeEvent(event, state, signature.values.toList());
+      final newState = processed.state;
+      processed.responses.forEach(process);
+      if (event is WorldInitialized) {
+        server.log(
+            "World initialized${(event.info?.script != null) ? " with script ${event.info?.script}" : ""}",
+            level: LogLevel.info);
+        await _loadScript((newState ?? state).info.script);
+      }
+      if (newState == null) return;
+      emit(newState);
+      return save();
+    }, transformer: sequential());
+    on<ImagesUpdated>((event, emit) {
+      emit(state.copyWith(images: event.images));
+    });
+  }
+
+  Future<void> _loadScript(String? script) async {
+    try {
+      if (script == null) return;
+      server.pluginSystem.loadLuaPlugin(assetManager, script);
+    } catch (e) {
+      server.log('Error loading script: $e', level: LogLevel.error);
+    }
+  }
+
+  Future<void> init() async {
+    await _loadScript(state.info.script);
+  }
+
+  Future<void> resetWorld([ItemLocation? mode]) async {
+    process(ModeChangeRequest(mode));
+    await stream.first;
+  }
+
+  Future<void> save({bool force = false}) async {
+    var file = File(worldName == defaultWorldName
+        ? 'world.stnx'
+        : 'worlds/$worldName.stnx');
+    if (!await file.exists()) {
+      await file.create(recursive: true);
+    }
+    if (!force && autosave) return;
+    final bytes = state.save().exportAsBytes();
+    await file.writeAsBytes(bytes);
+  }
+
+  void onClientEvent(NetworkerPacket<WorldEvent> packet,
+      {bool force = false}) async {
+    final data = packet.data;
+    ServerResponse? process;
+    try {
+      process = processClientEvent(
+        data is UserJoined ? null : data,
+        packet.channel,
+        state,
+        assetManager: assetManager,
+        allowServerEvents: packet.isServer,
+      );
+    } catch (e) {
+      server.log('Error processing event: $e', level: LogLevel.error);
+    }
+    if (process == null) return;
+    final event = Event(
+      serverEvent: process.main.data,
+      target: process.main.channel,
+      clientEvent: data,
+      source: packet.channel,
+      needsUpdate: process.needsUpdate,
+      worldName: worldName,
+    );
+    if (!force) {
+      server.eventSystem.fire(event);
+      if (event.cancelled) return;
+      server.log(
+          'Processing event by ${event.source}: ${limitOutput(event.clientEvent)}, answered with ${limitOutput(event.serverEvent)}',
+          level: LogLevel.verbose);
+    }
+    switch (packet.data) {
+      case MessageRequest data:
+        server.log("Message by ${packet.channel}: ${data.message}",
+            level: LogLevel.info);
+      default:
+    }
+    server.sendEvent(event.serverEvent,
+        target: event.target, worldName: worldName);
+    final updatePackets = process.buildUpdatePacketsFor(
+        state, server.channels, event.needsUpdate);
+    for (final packet in updatePackets) {
+      sendEvent(packet.data, target: packet.channel);
+    }
+  }
+
+  void process(WorldEvent event, [bool force = true]) {
+    onClientEvent(NetworkerPacket(event, kAuthorityChannel), force: force);
+  }
+
+  void sendEvent(PlayableWorldEvent event, {required Channel target}) {
+    server.sendEvent(event, target: target, worldName: worldName);
+  }
+}

server/lib/src/bloc.dart

@@ -41,8 +41,11 @@ ArgParser buildParser() {
         abbr: 'a', help: "Disable saving of the world automatically")
     ..addOption('max-players',
         abbr: 'm', help: "Maximum number of players", defaultsTo: '10')
-    ..addOption('room-mode',
-        abbr: 'r', help: "Enable room mode", defaultsTo: 'false');
+    ..addFlag('multi-world',
+        abbr: 'w',
+        negatable: false,
+        help: "Enable multi-world support",
+        defaultsTo: false);
 }
 
 void printUsage(ArgParser argParser) {
@@ -62,7 +65,7 @@ Future<void> runServer(List<String> arguments, [ServerLoader? onLoad]) async {
   final ArgParser argParser = buildParser();
   try {
     final ArgResults results = argParser.parse(arguments);
-    bool verbose = false, autosave = false, roomMode = false;
+    bool verbose = false, autosave = false, multiWorld = false;
     int maxPlayers = 10;
 
     // Process the parsed arguments.
@@ -80,12 +83,12 @@ Future<void> runServer(List<String> arguments, [ServerLoader? onLoad]) async {
     if (results.wasParsed('autosave')) {
       autosave = true;
     }
+    if (results.wasParsed('multi-world')) {
+      multiWorld = true;
+    }
     if (results.wasParsed('max-players')) {
       maxPlayers = int.tryParse(results['max-players'] ?? '') ?? maxPlayers;
     }
-    if (results.wasParsed('room-mode')) {
-      roomMode = true;
-    }
     String description = '';
     if (results.wasParsed('description')) {
       description = results['description'];
@@ -97,7 +100,7 @@ Future<void> runServer(List<String> arguments, [ServerLoader? onLoad]) async {
       autosave: autosave,
       description: description,
       maxPlayers: maxPlayers,
-      roomMode: roomMode,
+      multiWorld: multiWorld,
     );
     await onLoad?.call(server);
     await server.run();