♻️ Refactor jobs

src/Command/WaveFunctionCollapseCommand.php

@@ -69,34 +69,36 @@ protected function execute(InputInterface $input, OutputInterface $output): int
         $io->writeln(sprintf('Grid size: %dx%d', $width, $height));
         $io->writeln(sprintf('Dataset: %s', $dataSet->value));
 
-        $board = new Board($width, $height);
-        $board->reset($dataSet);
+        $flow = Flow::do(function () use ($io, $imagine, $dataSet) {
+            yield static function ($data) {
+                [$width, $height, $dataSet] = $data;
 
-        $flow = Flow::do(function () use ($io, $imagine, $board, $dataSet) {
-            yield new YFlow(function ($collapseLoop) use ($imagine, $board, $dataSet) {
-                return function ($data) use ($collapseLoop, $imagine, $board, $dataSet) {
-                    [$grid, $images] = $data;
+                $board = new Board($width, $height);
+                $board->reset($dataSet);
+
+                return [$board, []];
+            };
+            yield new YFlow(function ($collapseLoop) use ($imagine, $dataSet) {
+                return function ($data) use ($collapseLoop, $imagine, $dataSet) {
+                    [$board, $images] = $data;
 
                     $images[] = (new ImgJob(
                         $imagine,
                         $this->assetsDir,
-                        $board->tiles,
-                        $board->width,
-                        $board->height,
                         $dataSet,
                         256
-                    ))($grid);
-                    $nextGrid = (new CollapseJob($board->tiles, $board->width, $board->height))($grid);
+                    ))($board);
+                    $nextBoard = (new CollapseJob())($board);
 
-                    if ($nextGrid === null) {
-                        return [$grid, $images];
+                    if ($nextBoard === null) {
+                        return [$board, $images];
                     }
 
-                    return $collapseLoop([$nextGrid, $images]);
+                    return $collapseLoop([$nextBoard, $images]);
                 };
             });
             yield function ($data) {
-                [$grid, $images] = $data;
+                [$board, $images] = $data;
 
                 return (new Mp4Job($this->cacheDir))($images);
             };
@@ -105,7 +107,7 @@ protected function execute(InputInterface $input, OutputInterface $output): int
             };
         });
 
-        $flow(new Ip([$board->grid, []]));
+        $flow(new Ip([$width, $height, $dataSet]));
 
         $flow->await();
 

src/Job/WaveFunctionCollapse/CollapseJob.php

@@ -4,30 +4,23 @@
 
 namespace App\Job\WaveFunctionCollapse;
 
+use App\Model\WaveFunctionCollapse\Board;
 use App\Model\WaveFunctionCollapse\Cell;
-use App\Model\WaveFunctionCollapse\Tile;
 use Flow\JobInterface;
 
 use function count;
 use function in_array;
 
 /**
- * @implements JobInterface<Cell[], Cell[]|null>
+ * @implements JobInterface<Board, Board|null>
  */
 class CollapseJob implements JobInterface
 {
-    public function __construct(
-        /** @var Tile[] */
-        public array $tiles,
-        public int $width,
-        public int $height,
-    ) {}
-
-    public function __invoke($grid): mixed
+    public function __invoke($board): mixed
     {
         // Pick cell with least entropy
-        $gridNoOptions = array_filter($grid, static fn (Cell $a) => empty($a->getOptions()));
-        $gridCopy = array_filter($grid, static fn (Cell $a) => !$a->isCollapsed());
+        $gridNoOptions = array_filter($board->grid, static fn (Cell $a) => empty($a->getOptions()));
+        $gridCopy = array_filter($board->grid, static fn (Cell $a) => !$a->isCollapsed());
         if (!empty($gridNoOptions) || empty($gridCopy)) {
             return null;
         }
@@ -58,50 +51,50 @@ public function __invoke($grid): mixed
         $cell->setOptions([$pick]);
 
         $nextGrid = [];
-        for ($j = 0; $j < $this->height; $j++) {
-            for ($i = 0; $i < $this->width; $i++) {
-                $index = $i + $j * $this->height;
-                if ($grid[$index]->isCollapsed()) {
-                    $nextGrid[$index] = $grid[$index];
+        for ($j = 0; $j < $board->height; $j++) {
+            for ($i = 0; $i < $board->width; $i++) {
+                $index = $i + $j * $board->height;
+                if ($board->grid[$index]->isCollapsed()) {
+                    $nextGrid[$index] = $board->grid[$index];
                 } else {
-                    $options = range(0, count($this->tiles) - 1);
+                    $options = range(0, count($board->tiles) - 1);
 
                     // Look up
                     if ($j > 0) {
-                        $up = $grid[$i + ($j - 1) * $this->height];
+                        $up = $board->grid[$i + ($j - 1) * $board->height];
                         $validOptions = [];
                         foreach ($up->getOptions() as $option) {
-                            $valid = $this->tiles[$option]->down;
+                            $valid = $board->tiles[$option]->down;
                             $validOptions = array_merge($validOptions, $valid);
                         }
                         $this->checkValid($options, $validOptions);
                     }
                     // Look right
-                    if ($i < $this->width - 1) {
-                        $right = $grid[$i + 1 + $j * $this->height];
+                    if ($i < $board->width - 1) {
+                        $right = $board->grid[$i + 1 + $j * $board->height];
                         $validOptions = [];
                         foreach ($right->getOptions() as $option) {
-                            $valid = $this->tiles[$option]->left;
+                            $valid = $board->tiles[$option]->left;
                             $validOptions = array_merge($validOptions, $valid);
                         }
                         $this->checkValid($options, $validOptions);
                     }
                     // Look down
-                    if ($j < $this->height - 1) {
-                        $down = $grid[$i + ($j + 1) * $this->height];
+                    if ($j < $board->height - 1) {
+                        $down = $board->grid[$i + ($j + 1) * $board->height];
                         $validOptions = [];
                         foreach ($down->getOptions() as $option) {
-                            $valid = $this->tiles[$option]->up;
+                            $valid = $board->tiles[$option]->up;
                             $validOptions = array_merge($validOptions, $valid);
                         }
                         $this->checkValid($options, $validOptions);
                     }
                     // Look left
                     if ($i > 0) {
-                        $left = $grid[$i - 1 + $j * $this->height];
+                        $left = $board->grid[$i - 1 + $j * $board->height];
                         $validOptions = [];
                         foreach ($left->getOptions() as $option) {
-                            $valid = $this->tiles[$option]->right;
+                            $valid = $board->tiles[$option]->right;
                             $validOptions = array_merge($validOptions, $valid);
                         }
                         $this->checkValid($options, $validOptions);
@@ -111,8 +104,9 @@ public function __invoke($grid): mixed
                 }
             }
         }
+        $board->grid = $nextGrid;
 
-        return $nextGrid;
+        return $board;
     }
 
     /**

src/Job/WaveFunctionCollapse/ImgJob.php

@@ -5,7 +5,7 @@
 namespace App\Job\WaveFunctionCollapse;
 
 use App\EnumType\WaveFunctionCollapse\DataSetEnumType;
-use App\Model\WaveFunctionCollapse\Cell;
+use App\Model\WaveFunctionCollapse\Board;
 use App\Model\WaveFunctionCollapse\Tile;
 use Flow\JobInterface;
 use Imagine\Image\Box;
@@ -16,31 +16,27 @@
 use function sprintf;
 
 /**
- * @implements JobInterface<Cell[], ImageInterface>
+ * @implements JobInterface<Board, ImageInterface>
  */
 class ImgJob implements JobInterface
 {
     public function __construct(
         private ImagineInterface $imagine,
         private string $assetsDir,
-        /** @var Tile[] */
-        public array $tiles,
-        public int $width,
-        public int $height,
         public DataSetEnumType $dataSet,
         public int $tileSize = 32,
     ) {}
 
-    public function __invoke($grid): ImageInterface
+    public function __invoke($board): ImageInterface
     {
-        $image = $this->imagine->create(new Box($this->width * $this->tileSize, $this->height * $this->tileSize));
+        $image = $this->imagine->create(new Box($board->width * $this->tileSize, $board->height * $this->tileSize));
 
-        for ($j = 0; $j < $this->height; $j++) {
-            for ($i = 0; $i < $this->width; $i++) {
-                $index = $i + $j * $this->height;
-                $cell = $grid[$index];
+        for ($j = 0; $j < $board->height; $j++) {
+            for ($i = 0; $i < $board->width; $i++) {
+                $index = $i + $j * $board->height;
+                $cell = $board->grid[$index];
                 if ($cell->isCollapsed()) {
-                    $tile = $this->tiles[$cell->options[0]];
+                    $tile = $board->tiles[$cell->options[0]];
                     $tileImagePath = sprintf(
                         '%s/images/wave-function-collapse/%s/%d.png',
                         $this->assetsDir,

src/Twig/Components/WaveFunctionCollapse/Ui.php

@@ -44,17 +44,17 @@ public function reset(): void
     public function collapse(): void
     {
         $flow = Flow::do(function () {
-            yield new CollapseJob($this->board->tiles, $this->board->width, $this->board->height);
-            yield function ($nextGrid) {
-                if ($nextGrid === null) {
+            yield new CollapseJob();
+            yield function ($nextBoard) {
+                if ($nextBoard === null) {
                     $this->board->startOver();
                 } else {
-                    $this->board->grid = $nextGrid;
+                    $this->board = $nextBoard;
                 }
             };
         });
 
-        $flow(new Ip($this->board->grid));
+        $flow(new Ip($this->board));
         $flow->await();
     }