[sync] Update embedded LibCustom from standalone

Author: ImperaZim

src/imperazim/custom/CustomManager.php

@@ -36,13 +36,14 @@
 
 final class CustomManager implements Listener {
 
-  private static Experiments $experiments;
+  /** @internal accessed by packet handlers */
+  public static Experiments $experiments;
 
-  /** @var ItemTypeEntry[] */
-  private static array $cachedItemTable = [];
+  /** @var ItemTypeEntry[] @internal */
+  public static array $cachedItemTable = [];
 
-  /** @var BlockPaletteEntry[] */
-  private static array $cachedBlockPalette = [];
+  /** @var BlockPaletteEntry[] @internal */
+  public static array $cachedBlockPalette = [];
 
   public static function init(PluginBase $plugin): void {
     self::$experiments = new Experiments(['data_driven_items' => true], true);

src/imperazim/custom/block/CustomBlockFactory.php

@@ -30,9 +30,11 @@
 use pocketmine\Server;
 use pocketmine\utils\SingletonTrait;
 use pocketmine\world\format\io\GlobalBlockStateHandlers;
+use function array_fill;
 use function array_map;
 use function array_reverse;
 use function hash;
+use function max;
 use function strcmp;
 use function usort;
 
@@ -53,13 +55,53 @@ final class CustomBlockFactory {
 
   /**
    * Adds a worker initialize hook to the async pool to sync the BlockFactory for every thread worker.
+   * Serializes block data to a cache file so it can be loaded on worker threads without closures.
    */
   public function addWorkerInitHook(string $cachePath): void {
+    if (empty($this->blockFuncs)) {
+      return;
+    }
+
+    $cacheFile = $cachePath . DIRECTORY_SEPARATOR . 'block_cache.bin';
+    @mkdir($cachePath, 0777, true);
+
+    // Build serializable cache: for each block, store the igbinary-serialized Block object
+    // and the list of state entries (identifier + state count).
+    $cache = [];
+    foreach ($this->blockFuncs as $identifier => [$blockFunc, $serializer, $deserializer]) {
+      try {
+        $block = $blockFunc();
+        $blockData = igbinary_serialize($block);
+        if ($blockData === null) {
+          continue;
+        }
+        // Count how many states this block has in the palette.
+        $stateCount = 0;
+        foreach ($this->blockPaletteEntries as $entry) {
+          if ($entry->getName() === $identifier) {
+            $stateCount++;
+          }
+        }
+        $cache[$identifier] = [
+          'blockData' => $blockData,
+          'states' => array_fill(0, max(1, $stateCount), ['name' => $identifier]),
+        ];
+      } catch (\Throwable) {
+        // Block cannot be serialized (e.g. anonymous class) — skip gracefully.
+        // The block will appear as INFO_UPDATE on async-encoded chunks.
+      }
+    }
+
+    if (empty($cache)) {
+      return;
+    }
+
+    file_put_contents($cacheFile, igbinary_serialize($cache));
+
     $server = Server::getInstance();
-    $blocks = $this->blockFuncs;
     $server->getAsyncPool()->addWorkerStartHook(
-      static function (int $worker) use ($cachePath, $server, $blocks): void {
-        $server->getAsyncPool()->submitTaskToWorker(new AsyncBlockRegistrationTask($blocks), $worker);
+      static function (int $worker) use ($cacheFile, $server): void {
+        $server->getAsyncPool()->submitTaskToWorker(new AsyncBlockRegistrationTask($cacheFile), $worker);
       }
     );
   }

src/imperazim/custom/task/AsyncBlockRegistrationTask.php

@@ -3,27 +3,76 @@
 
 namespace imperazim\custom\task;
 
-use imperazim\custom\block\CustomBlockFactory;
-use pmmp\thread\ThreadSafeArray;
+use pocketmine\block\Block;
+use pocketmine\block\RuntimeBlockStateRegistry;
+use pocketmine\data\bedrock\block\BlockStateData;
+use pocketmine\data\bedrock\block\convert\BlockStateReader;
+use pocketmine\data\bedrock\block\convert\BlockStateWriter;
 use pocketmine\scheduler\AsyncTask;
+use pocketmine\world\format\io\GlobalBlockStateHandlers;
 
 final class AsyncBlockRegistrationTask extends AsyncTask {
 
-  private ThreadSafeArray $blockFuncs;
+  private string $cachePath;
 
-  /**
-   * @param Closure[] $blockFuncs
-   */
-  public function __construct(array $blockFuncs) {
-    $this->blockFuncs = new ThreadSafeArray();
-    foreach ($blockFuncs as $key => $func) {
-      $this->blockFuncs[$key] = $func;
-    }
+  public function __construct(string $cachePath) {
+    $this->cachePath = $cachePath;
   }
 
   public function onRun(): void {
-    foreach ($this->blockFuncs as $func) {
-      $func();
+    $raw = @file_get_contents($this->cachePath);
+    if ($raw === false) {
+      return;
+    }
+    /** @var array<string, array{blockData: string, states: list<array{name: string, statesNbt: string}>}> $cache */
+    $cache = igbinary_unserialize($raw);
+    if (!is_array($cache)) {
+      return;
+    }
+
+    $serializer = GlobalBlockStateHandlers::getSerializer();
+    $deserializer = GlobalBlockStateHandlers::getDeserializer();
+    $registry = RuntimeBlockStateRegistry::getInstance();
+
+    foreach ($cache as $identifier => $entry) {
+      /** @var Block|null $block */
+      $block = igbinary_unserialize($entry['blockData']);
+      if (!$block instanceof Block) {
+        continue;
+      }
+
+      // Register the block in RuntimeBlockStateRegistry on this worker thread.
+      try {
+        $registry->register($block);
+      } catch (\InvalidArgumentException) {
+        // Already registered (shouldn't happen on fresh worker, but be safe).
+      }
+
+      // Register the serializer — maps Block typeId to BlockStateData.
+      if (!$serializer->isRegistered($block)) {
+        if (count($entry['states']) === 1) {
+          // Simple block, no permutations.
+          $serializer->map($block, BlockStateData::current($identifier, []));
+        } else {
+          // Block with permutations — register a closure that builds state from block.
+          $serializer->map($block, static function (Block $b) use ($identifier): BlockStateWriter {
+            $writer = BlockStateWriter::create($identifier);
+            if ($b instanceof \imperazim\custom\block\permutation\Permutable) {
+              $b->serializeState($writer);
+            }
+            return $writer;
+          });
+        }
+      }
+
+      // Register the deserializer — maps identifier string to Block factory.
+      $deserializer->map($identifier, static function (BlockStateReader $in) use ($block, $identifier): Block {
+        $b = clone $block;
+        if ($b instanceof \imperazim\custom\block\permutation\Permutable) {
+          $b->deserializeState($in);
+        }
+        return $b;
+      });
     }
   }
 }