feat(pocket-base): split hostile and passive mob spawning

src/test/java/games/dmg/spigotbase/BaseSettingsCommandTest.java

@@ -119,10 +119,23 @@ final class BaseSettingsCommandTest {
                 new String[] {"pocket", "type", "nether", "c"}
             )
         );
+        assertEquals(
+            List.of("hostile"),
+            command.onTabComplete(
+                null, null, "basesettings", new String[] {"pocket", "mobs", "h"}
+            )
+        );
+        assertEquals(
+            List.of("passive"),
+            command.onTabComplete(
+                null, null, "basesettings", new String[] {"pocket", "mobs", "p"}
+            )
+        );
         assertEquals(
             List.of("enable"),
             command.onTabComplete(
-                null, null, "basesettings", new String[] {"pocket", "mobs", "e"}
+                null, null, "basesettings",
+                new String[] {"pocket", "mobs", "hostile", "e"}
             )
         );
         for (String setting : List.of("navigation", "flight", "border", "spawnable", "bossbar")) {
@@ -296,7 +309,7 @@ final class BaseSettingsCommandTest {
     }
 
     @Test
-    void pocketOwnerCanEnableNaturalMobSpawning() throws Exception {
+    void pocketOwnerCanEnableHostileMobSpawningWithoutChangingPassive() throws Exception {
         UUID playerId = UUID.randomUUID();
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(playerId);
@@ -305,11 +318,13 @@ final class BaseSettingsCommandTest {
         when(stateManager.player(playerId, "Builder"))
             .thenReturn(PlayerState.newPlayer(playerId, "Builder"));
         PocketBaseManager pocketBases = mock(PocketBaseManager.class);
-        when(pocketBases.state(playerId)).thenReturn(
-            new PocketBaseState(playerId, 1, java.util.Optional.empty(), false)
+        PocketBaseState current = new PocketBaseState(
+            playerId, 1, java.util.Optional.empty(), java.util.Optional.empty(),
+            false, true, PocketBaseBiome.THE_VOID
         );
-        when(pocketBases.setMobSpawning(playerId, true)).thenReturn(
-            new PocketBaseState(playerId, 1, java.util.Optional.empty(), true)
+        when(pocketBases.state(playerId)).thenReturn(current);
+        when(pocketBases.setHostileMobSpawning(playerId, true)).thenReturn(
+            current.withHostileMobSpawningEnabled(true)
         );
         BaseSettingsCommand command = new BaseSettingsCommand(
             stateManager,
@@ -318,13 +333,14 @@ final class BaseSettingsCommandTest {
             pocketBases
         );
 
-        command.onCommand(
-            player, null, "basesettings", new String[] {"pocket", "mobs", "enable"}
-        );
+        command.onCommand(player, null, "basesettings", new String[] {
+            "pocket", "mobs", "hostile", "enable"
+        });
 
-        verify(pocketBases).setMobSpawning(playerId, true);
+        verify(pocketBases).setHostileMobSpawning(playerId, true);
+        verify(pocketBases, never()).setPassiveMobSpawning(playerId, true);
         verify(player).sendMessage(org.mockito.ArgumentMatchers.<String>argThat(
-            message -> message.contains("mob spawning") && message.contains("enabled")
+            message -> message.contains("hostile mob spawning") && message.contains("enabled")
         ));
     }
 
@@ -339,9 +355,9 @@ final class BaseSettingsCommandTest {
             .thenReturn(PlayerState.newPlayer(playerId, "Builder"));
         PocketBaseManager pocketBases = mock(PocketBaseManager.class);
         when(pocketBases.state(playerId)).thenReturn(
-            new PocketBaseState(playerId, 1, java.util.Optional.empty(), false)
+            new PocketBaseState(playerId, 1, java.util.Optional.empty())
         );
-        when(pocketBases.setMobSpawning(playerId, true))
+        when(pocketBases.setPassiveMobSpawning(playerId, true))
             .thenThrow(new IOException("save failed"));
         BaseSettingsCommand command = new BaseSettingsCommand(
             stateManager,
@@ -350,9 +366,9 @@ final class BaseSettingsCommandTest {
             pocketBases
         );
 
-        command.onCommand(
-            player, null, "basesettings", new String[] {"pocket", "mobs", "enable"}
-        );
+        command.onCommand(player, null, "basesettings", new String[] {
+            "pocket", "mobs", "passive", "enable"
+        });
 
         verify(player).sendMessage(org.mockito.ArgumentMatchers.<String>argThat(
             message -> message.contains("could not be changed")
@@ -380,11 +396,11 @@ final class BaseSettingsCommandTest {
             pocketBases
         );
 
-        command.onCommand(
-            player, null, "basesettings", new String[] {"pocket", "mobs", "enable"}
-        );
+        command.onCommand(player, null, "basesettings", new String[] {
+            "pocket", "mobs", "hostile", "enable"
+        });
 
-        verify(pocketBases, never()).setMobSpawning(playerId, true);
+        verify(pocketBases, never()).setHostileMobSpawning(playerId, true);
         verify(player).sendMessage(org.mockito.ArgumentMatchers.<String>argThat(
             message -> message.contains("Pocket Base I") && message.contains("locked")
         ));
@@ -429,7 +445,7 @@ final class BaseSettingsCommandTest {
     }
 
     @Test
-    void statusDisplaysPocketMobSpawningPreference() {
+    void statusDisplaysPocketMobSpawningPreferences() {
         UUID playerId = UUID.randomUUID();
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(playerId);
@@ -439,7 +455,10 @@ final class BaseSettingsCommandTest {
             .thenReturn(PlayerState.newPlayer(playerId, "Builder"));
         PocketBaseManager pocketBases = mock(PocketBaseManager.class);
         when(pocketBases.state(playerId)).thenReturn(
-            new PocketBaseState(playerId, 1, java.util.Optional.empty(), false)
+            new PocketBaseState(
+                playerId, 1, java.util.Optional.empty(), java.util.Optional.empty(),
+                true, false, PocketBaseBiome.THE_VOID
+            )
         );
         BaseSettingsCommand command = new BaseSettingsCommand(
             stateManager,
@@ -453,7 +472,8 @@ final class BaseSettingsCommandTest {
         verify(player).sendMessage(org.mockito.ArgumentMatchers.<String>argThat(
             message -> message.contains("Pocket Base 1")
                 && message.contains("type=void/the_void")
-                && message.contains("mob spawning=disabled")
+                && message.contains("hostile spawning=enabled")
+                && message.contains("passive spawning=disabled")
         ));
     }
 

src/test/java/games/dmg/spigotbase/PocketBaseManagerTest.java

@@ -25,7 +25,8 @@ final class PocketBaseManagerTest {
         PocketBaseStateManager states = mock(PocketBaseStateManager.class);
         PocketBaseWorldService worlds = mock(PocketBaseWorldService.class);
         when(states.state(ownerId)).thenReturn(new PocketBaseState(
-            ownerId, 1, Optional.empty(), Optional.of(relocated), false
+            ownerId, 1, Optional.empty(), Optional.of(relocated), false, false,
+            PocketBaseBiome.THE_VOID
         ));
         PocketBaseManager manager = new PocketBaseManager(
             states,
@@ -58,9 +59,12 @@ final class PocketBaseManagerTest {
     }
 
     @Test
-    void persistsAndAppliesMobSpawningPreference() throws Exception {
+    void persistsAndAppliesHostileMobSpawningWithoutChangingPassive() throws Exception {
         UUID ownerId = UUID.randomUUID();
-        PocketBaseState current = new PocketBaseState(ownerId, 1, Optional.empty(), false);
+        PocketBaseState current = new PocketBaseState(
+            ownerId, 1, Optional.empty(), Optional.empty(), false, true,
+            PocketBaseBiome.THE_VOID
+        );
         PocketBaseStateManager states = mock(PocketBaseStateManager.class);
         PocketBaseWorldService worlds = mock(PocketBaseWorldService.class);
         when(states.state(ownerId)).thenReturn(current);
@@ -76,10 +80,12 @@ final class PocketBaseManagerTest {
             new PluginSettingsProvider(PluginSettings.from(Map.of()))
         );
 
-        manager.setMobSpawning(ownerId, true);
+        PocketBaseState updated = manager.setHostileMobSpawning(ownerId, true);
 
+        assertEquals(true, updated.hostileMobSpawningEnabled());
+        assertEquals(true, updated.passiveMobSpawningEnabled());
         InOrder order = inOrder(worlds, states);
-        order.verify(worlds).setMobSpawning(ownerId, true);
+        order.verify(worlds).setMobSpawning(ownerId, true, true);
         order.verify(states).updateAndSave(
             org.mockito.ArgumentMatchers.eq(ownerId), org.mockito.ArgumentMatchers.any()
         );
@@ -137,9 +143,12 @@ final class PocketBaseManagerTest {
     }
 
     @Test
-    void restoresWorldSettingWhenPersistenceFails() throws Exception {
+    void restoresBothWorldSettingsWhenPersistenceFails() throws Exception {
         UUID ownerId = UUID.randomUUID();
-        PocketBaseState current = new PocketBaseState(ownerId, 1, Optional.empty(), false);
+        PocketBaseState current = new PocketBaseState(
+            ownerId, 1, Optional.empty(), Optional.empty(), true, false,
+            PocketBaseBiome.THE_VOID
+        );
         PocketBaseStateManager states = mock(PocketBaseStateManager.class);
         PocketBaseWorldService worlds = mock(PocketBaseWorldService.class);
         when(states.state(ownerId)).thenReturn(current);
@@ -151,9 +160,10 @@ final class PocketBaseManagerTest {
             new PluginSettingsProvider(PluginSettings.from(Map.of()))
         );
 
-        assertThrows(IOException.class, () -> manager.setMobSpawning(ownerId, true));
+        assertThrows(IOException.class,
+            () -> manager.setPassiveMobSpawning(ownerId, true));
 
-        verify(worlds).setMobSpawning(ownerId, true);
-        verify(worlds).setMobSpawning(ownerId, false);
+        verify(worlds).setMobSpawning(ownerId, true, true);
+        verify(worlds).setMobSpawning(ownerId, true, false);
     }
 }

src/test/java/games/dmg/spigotbase/PocketBaseWorldServiceTest.java

@@ -93,10 +93,13 @@ final class PocketBaseWorldServiceTest {
 
         service.loadExisting(Map.of(
             ownerId,
-            new PocketBaseState(ownerId, 1, Optional.empty(), true)
+            new PocketBaseState(
+                ownerId, 1, Optional.empty(), Optional.empty(), true, false,
+                PocketBaseBiome.THE_VOID
+            )
         ));
 
-        verify(world).setSpawnFlags(true, true);
+        verify(world).setSpawnFlags(true, false);
     }
 
     @Test

src/test/java/games/dmg/spigotbase/YamlPocketBaseRepositoryTest.java

@@ -30,6 +30,7 @@ final class YamlPocketBaseRepositoryTest {
                 worldId, "pocket", 20, 65, 12, PocketPortalAxis.Z
             )),
             true,
+            false,
             PocketBaseBiome.CRIMSON_FOREST
         );
         YamlPocketBaseRepository repository = new YamlPocketBaseRepository(
@@ -50,8 +51,23 @@ final class YamlPocketBaseRepositoryTest {
 
         PocketBaseState loaded = repository.load().get(ownerId);
 
-        assertFalse(loaded.mobSpawningEnabled());
+        assertFalse(loaded.hostileMobSpawningEnabled());
+        assertFalse(loaded.passiveMobSpawningEnabled());
         assertTrue(loaded.returnPortal().isEmpty());
         assertEquals(PocketBaseBiome.THE_VOID, loaded.biome());
     }
+
+    @Test
+    void migratesLegacyMobPreferenceToBothCategories() throws Exception {
+        UUID ownerId = UUID.randomUUID();
+        Path stateFile = temporaryDirectory.resolve("pocket-bases.yml");
+        Files.writeString(stateFile, "owners:\n  " + ownerId
+            + ":\n    level: 1\n    mob-spawning-enabled: true\n");
+        YamlPocketBaseRepository repository = new YamlPocketBaseRepository(stateFile);
+
+        PocketBaseState loaded = repository.load().get(ownerId);
+
+        assertTrue(loaded.hostileMobSpawningEnabled());
+        assertTrue(loaded.passiveMobSpawningEnabled());
+    }
 }