Fix inventory lost when returning to original island after creating second island

When a player transitions from single-island to multi-island mode, their
currentKey is a world-only key (e.g., "oneblock_world"). Previously, when
entering a new island, storeInventory saved to this world-only key, and
the backward-compat migration in getInventory incorrectly gave that data
to the new island instead of preserving it for the original island.

Add Store.upgradeWorldKeyToIsland() which proactively upgrades the
currentKey to an island-specific key before any save/load occurs. Called
from PlayerListener.onIslandEnter when a world-only key is detected, this
ensures storeInventory saves to the correct island-specific key and
prevents the migration from misassigning data.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: tastybento

CLAUDE.md

@@ -0,0 +1,35 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+InvSwitcher is a BentoBox addon for Minecraft (Spigot/Bukkit) that gives players separate inventories, ender chests, health, food, experience, advancements, game modes, and statistics per game-world. Nether and End dimensions are automatically grouped with their overworld.
+
+## Build Commands
+
+- **Build**: `mvn clean package`
+- **Run tests**: `mvn test -Dmaven.compiler.forceJavacCompilerUse=true`
+- **Run a single test class**: `mvn test -Dmaven.compiler.forceJavacCompilerUse=true -Dtest=StoreTest`
+- **Run a single test method**: `mvn test -Dmaven.compiler.forceJavacCompilerUse=true -Dtest=StoreTest#testMethodName`
+
+Requires Java 21. The build produces a shaded JAR in `target/`. The `-Dmaven.compiler.forceJavacCompilerUse=true` flag is needed to work around a compiler hashing bug with the current JDK.
+
+## Architecture
+
+This is a BentoBox Addon (extends `Addon`, not a standalone Bukkit plugin). Key flow:
+
+- **InvSwitcher** - Addon entry point. Loads config, resolves configured world names to `World` objects (including nether/end variants), creates the `Store`, and registers `PlayerListener`.
+- **Store** - Core logic. Maintains an in-memory `Map<UUID, InventoryStorage>` cache backed by BentoBox's `Database`. On world change: stores current player state to the old world's slot, clears the player, then loads the new world's slot. Handles XP math manually (Bukkit's `getTotalExperience()` is unreliable). Tracks per-player `currentKey` to map saves/loads to the correct storage slot.
+- **InventoryStorage** - `DataObject` (BentoBox DB entity) keyed by player UUID. All per-world data is stored as `Map<String, ...>` where the key is either the overworld name (e.g., `"oneblock_world"`) or an island-specific key (e.g., `"oneblock_world/islandId"`). Persisted via BentoBox's database abstraction (JSON, MySQL, etc. — **not** YAML, which is explicitly unsupported).
+- **PlayerListener** - Listens to `PlayerChangedWorldEvent`, `PlayerJoinEvent`, `PlayerQuitEvent`, `IslandEnterEvent`, and `PlayerRespawnEvent` to trigger store/load operations.
+- **Settings** - `ConfigObject` loaded from `config.yml`. Each switchable aspect (inventory, health, food, etc.) has a world-level boolean toggle and a per-island sub-toggle.
+
+## Key Design Details
+
+- World name normalization: nether (`_nether`) and end (`_the_end`) suffixes are stripped to map all three dimensions to the same overworld key.
+- **Per-island inventory switching**: When `islandsActive` is enabled and a player owns multiple concurrent islands, data is keyed as `"worldName/islandId"` instead of just `"worldName"`. Each data type (inventory, health, etc.) has its own per-island sub-toggle.
+- **Storage key transitions**: When a player goes from 1 island to multiple, their `currentKey` must be upgraded from a world-only key to an island-specific key. This is handled proactively in `PlayerListener.onIslandEnter` via `Store.upgradeWorldKeyToIsland()` before any save/load occurs.
+- **Backward compatibility migration**: `Store.getInventory()` migrates world-only data to island-specific keys on first load if no island-specific data exists yet.
+- Statistics saving runs asynchronously via `Bukkit.getScheduler()` except during shutdown (where scheduling is unavailable).
+- Tests use JUnit 5 + MockBukkit + Mockito. The surefire plugin requires extensive `--add-opens` flags (already configured in pom.xml).

src/main/java/com/wasteofplastic/invswitcher/Store.java

@@ -305,6 +305,23 @@ public void removeFromCache(Player player) {
         currentKey.remove(player.getUniqueId());
     }
 
+    /**
+     * Upgrade a world-only currentKey to an island-specific key when a player transitions
+     * from single-island to multi-island mode. Clears stale world-only data from the store
+     * (storeAndSave will re-save world-level types like health/food to the world key).
+     * @param player - player
+     * @param world - world
+     * @param oldIsland - the island the player was on (their original island)
+     */
+    public void upgradeWorldKeyToIsland(Player player, World world, Island oldIsland) {
+        InventoryStorage store = getInv(player);
+        String worldKey = getOverworldName(world);
+        // Clear stale world-only data; storeAndSave will re-save world-level types
+        store.clearWorldData(worldKey);
+        // Update currentKey so subsequent storeAndSave saves per-island data to the correct key
+        currentKey.put(player.getUniqueId(), worldKey + "/" + oldIsland.getUniqueId());
+    }
+
     /**
      * Get the inventory storage object for player from the database or make a new one
      * @param player - player

src/main/java/com/wasteofplastic/invswitcher/listeners/PlayerListener.java

@@ -16,7 +16,6 @@
 
 import com.wasteofplastic.invswitcher.InvSwitcher;
 
-import world.bentobox.bentobox.BentoBox;
 import world.bentobox.bentobox.api.events.island.IslandEnterEvent;
 import world.bentobox.bentobox.database.objects.Island;
 import world.bentobox.bentobox.util.Util;
@@ -68,7 +67,6 @@ public void onWorldEnter(final PlayerChangedWorldEvent event) {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onIslandEnter(IslandEnterEvent event) {
-        BentoBox.getInstance().logDebug("IslandEnterEvent triggered for player " + event.getPlayerUUID() + " on island " + event.getIsland().getUniqueId());
         if (!addon.getSettings().isIslandsActive()) {
             return;
         }
@@ -80,15 +78,13 @@ public void onIslandEnter(IslandEnterEvent event) {
 
         World world = player.getWorld();
         if (!addon.getWorlds().contains(world)) {
-            BentoBox.getInstance().logDebug("World " + world.getName() + " is not in the list of worlds to manage. Ignoring island enter event.");
             return;
         }
 
         Island island = event.getIsland();
 
         // Only switch if the player owns the island they're entering
         if (island.getOwner() == null || !island.getOwner().equals(player.getUniqueId())) {
-            BentoBox.getInstance().logDebug("Player " + player.getName() + " does not own island " + island.getUniqueId() + ". No inventory switch.");
             return;
         }
 
@@ -97,20 +93,33 @@ public void onIslandEnter(IslandEnterEvent event) {
         int count = addon.getIslands().getNumberOfConcurrentIslands(
                 player.getUniqueId(), Objects.requireNonNull(overworld));
         if (count <= 1) {
-            BentoBox.getInstance().logDebug("Player " + player.getName() + " owns only one island in world " + overworld.getName() + ". No inventory switch.");
             return;
         }
 
         // Compute new key and compare to current key
         String newKey = addon.getStore().getStorageKey(player, world, island);
         String currentKeyValue = addon.getStore().getCurrentKey(player);
         if (newKey.equals(currentKeyValue)) {
-            BentoBox.getInstance().logDebug("Player " + player.getName() + " is entering island " + island.getUniqueId() + " which has the same inventory key as their current location. No inventory switch.");
             return; // same island, no switch
         }
 
+        // If currentKey is a world-only key (no "/"), the player is transitioning from
+        // single-island to multi-island mode. Upgrade the key so storeInventory saves to
+        // the correct island-specific key instead of the world key.
+        if (currentKeyValue != null && !currentKeyValue.contains("/")) {
+            Island oldIsland = addon.getIslands().getIsland(overworld, player.getUniqueId());
+            if (oldIsland != null && !oldIsland.getUniqueId().equals(island.getUniqueId())) {
+                addon.getStore().upgradeWorldKeyToIsland(player, world, oldIsland);
+            } else {
+                // Primary island is the one being entered; find another owned island
+                addon.getIslands().getIslands(overworld, player.getUniqueId()).stream()
+                        .filter(i -> !i.getUniqueId().equals(island.getUniqueId()))
+                        .findFirst()
+                        .ifPresent(i -> addon.getStore().upgradeWorldKeyToIsland(player, world, i));
+            }
+        }
+
         // Switch: store old, load new
-        BentoBox.getInstance().logDebug("Switching inventory for player " + player.getName() + " from key " + currentKeyValue + " to new key " + newKey);
         addon.getStore().storeInventory(player, world);
         addon.getStore().getInventory(player, world, island);
     }

src/test/java/com/wasteofplastic/invswitcher/StoreTest.java

@@ -421,4 +421,95 @@ public void testRemoveFromCacheClearsCurrentKey() {
         assertNull(s.getCurrentKey(player));
     }
 
+    /**
+     * Test upgradeWorldKeyToIsland clears world data and updates currentKey.
+     */
+    @Test
+    public void testUpgradeWorldKeyToIsland() {
+        sets.setIslandsActive(true);
+        sets.setStatistics(false);
+
+        Island oldIsland = mock(Island.class);
+        when(oldIsland.getOwner()).thenReturn(playerUUID);
+        when(oldIsland.getUniqueId()).thenReturn("island-primary");
+
+        try (MockedStatic<Util> utilities = Mockito.mockStatic(Util.class);
+             MockedStatic<Bukkit> mockedBukkit = mockStatic(Bukkit.class, Mockito.RETURNS_MOCKS)) {
+            utilities.when(() -> Util.getWorld(world)).thenReturn(world);
+            when(islandsManager.getNumberOfConcurrentIslands(playerUUID, world)).thenReturn(1);
+
+            // Simulate login and play — data saved under world-only key
+            s.getInventory(player, world);
+            assertEquals("world", s.getCurrentKey(player));
+            s.storeInventory(player, world);
+            assertTrue(s.isWorldStored(player, world));
+
+            // Upgrade: transitions from world-only to island-specific key
+            s.upgradeWorldKeyToIsland(player, world, oldIsland);
+
+            // currentKey should now be island-specific
+            assertEquals("world/island-primary", s.getCurrentKey(player));
+            // World-only data should be cleared
+            assertFalse(s.isWorldStored(player, world));
+        }
+    }
+
+    /**
+     * Full scenario: player has 1 island, creates 2nd, goes to new island, returns to original.
+     * Simulates what onIslandEnter does: upgradeWorldKey, storeInventory, getInventory.
+     */
+    @Test
+    public void testFullScenarioSingleToMultipleIslands() {
+        sets.setIslandsActive(true);
+        sets.setStatistics(false);
+        sets.setHealth(false);
+        sets.setFood(false);
+        sets.setExperience(false);
+        sets.setGamemode(false);
+        sets.setAdvancements(false);
+        sets.setEnderChest(false);
+
+        Island primaryIsland = mock(Island.class);
+        when(primaryIsland.getOwner()).thenReturn(playerUUID);
+        when(primaryIsland.getUniqueId()).thenReturn("island-primary");
+
+        Island newIsland = mock(Island.class);
+        when(newIsland.getOwner()).thenReturn(playerUUID);
+        when(newIsland.getUniqueId()).thenReturn("island-new");
+
+        Location loc = mock(Location.class);
+        when(player.getLocation()).thenReturn(loc);
+
+        try (MockedStatic<Util> utilities = Mockito.mockStatic(Util.class);
+             MockedStatic<Bukkit> mockedBukkit = mockStatic(Bukkit.class, Mockito.RETURNS_MOCKS)) {
+            utilities.when(() -> Util.getWorld(world)).thenReturn(world);
+            when(islandsManager.getNumberOfConcurrentIslands(playerUUID, world)).thenReturn(1);
+
+            // Step 1: Player has 1 island. Login and play.
+            s.getInventory(player, world);
+            s.storeInventory(player, world);
+            assertTrue(s.isWorldStored(player, world));
+
+            // Step 2: Player creates 2nd island and teleports to it.
+            // onIslandEnter detects world-only key and upgrades BEFORE store/load.
+            when(islandsManager.getNumberOfConcurrentIslands(playerUUID, world)).thenReturn(2);
+            s.upgradeWorldKeyToIsland(player, world, primaryIsland);
+            assertEquals("world/island-primary", s.getCurrentKey(player));
+
+            // Now storeInventory saves to the island-specific key for the OLD island
+            s.storeInventory(player, world);
+            // Load new island — no world data to migrate, so player gets empty inventory
+            s.getInventory(player, world, newIsland);
+            assertEquals("world/island-new", s.getCurrentKey(player));
+
+            // Step 3: Player teleports back to primary island.
+            s.storeInventory(player, world);
+            s.getInventory(player, world, primaryIsland);
+            assertEquals("world/island-primary", s.getCurrentKey(player));
+
+            // Verify inventory was loaded (setContents called for the primary island load)
+            verify(player.getInventory(), atLeastOnce()).setContents(any(ItemStack[].class));
+        }
+    }
+
 }