.github/workflows/backport-prs.yml

@@ -1,39 +0,0 @@
-name: Backport merged pull request
-on:
-  pull_request_target:
-    types: [closed]
-  issue_comment:
-    types: [created]
-permissions:
-  contents: write # so it can comment
-  pull-requests: write # so it can create pull requests
-jobs:
-  backport:
-    name: Backport pull request
-    runs-on: ubuntu-latest
-
-    # Only run when pull request is merged
-    # or when a comment starting with `/backport` is created by someone other than the
-    # https://github.com/backport-action bot user (user id: 97796249). Note that if you use your
-    # own PAT as `github_token`, that you should replace this id with yours.
-    if: >
-      (
-        github.event_name == 'pull_request_target' &&
-        github.event.pull_request.merged
-      ) || (
-        github.event_name == 'issue_comment' &&
-        github.event.issue.pull_request &&
-        github.event.comment.user.id != 97796249 &&
-        startsWith(github.event.comment.body, '/backport')
-      )
-    steps:
-      - uses: actions/checkout@v6
-      - name: Create backport pull requests
-        uses: korthout/backport-action@v4
-        with:
-          github_token: ${{ secrets.TOKEN }}
-          pull_description: |
-            Backport of #${pull_number} to `${target_branch}`.
-
-            ### Description
-            ${pull_description}

.github/workflows/build.yml

@@ -16,25 +16,25 @@ jobs:
 
     steps:
       - name: Checkout Repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Validate Gradle Wrapper
-        uses: gradle/actions/wrapper-validation@v6
+        uses: gradle/actions/wrapper-validation@v4
 
       - name: Set up JDK 17
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v4
         with:
           java-version: '17'
           distribution: 'temurin'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v6
+        uses: gradle/actions/setup-gradle@v4
 
       - name: Build with Gradle
         run: ./gradlew build
 
       - name: Build Artifact
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: Player_Sync
           path: |

.vscode/settings.json

@@ -1,10 +0,0 @@
-{
-    "java.compile.nullAnalysis.mode": "automatic",
-    "java.completion.importOrder": [
-        "",
-        "javax",
-        "java",
-        "#"
-    ],
-    "java.sources.organizeImports.starThreshold": 5
-}

build.gradle

@@ -29,7 +29,6 @@ repositories {
             includeGroup "curse.maven"
         }
     }
-    maven { url 'https://modmaven.dev/' }
 }
 
 base {
@@ -137,16 +136,8 @@ dependencies {
     // We add the full version to localRuntime, not runtimeOnly, so that we do not publish a dependency on it
     // modLocalRuntime "mezz.jei:jei-${mc_version}-neoforge:${jei_version}"
     compileOnly "curse.maven:curios-309927:5266541"
-    compileOnly "curse.maven:sophisticated-backpacks-422301:7169843"
-    compileOnly "curse.maven:sophisticated-core-618298:7169400"
-//    compileOnly "mekanism:Mekanism:${mekanism_version}:api"
-
-    // If you want to test/use Mekanism & its modules during `runClient` invocation, use the following
-    modCompileOnly ("mekanism:Mekanism:${mekanism_version}")// core
-//    modcompileOnly ("mekanism:Mekanism:${mekanism_version}:additions")// Mekanism: Additions
-//    modcompileOnly ("mekanism:Mekanism:${mekanism_version}:generators")// Mekanism: Generators
-//    modcompileOnly ("mekanism:Mekanism:${mekanism_version}:tools")// Mekanism: Tools
-
+    compileOnly "curse.maven:sophisticated-backpacks-422301:6303388"
+    compileOnly "curse.maven:sophisticated-core-618298:6317048"
 
     // Example mod dependency using a mod jar from ./libs with a flat dir repository
     // This maps to ./libs/coolmod-${mc_version}-${coolmod_version}.jar

docs/code-analysis.md

@@ -1,406 +0,0 @@
-# PlayerSync — Code Analysis
-
-## 1. Project Overview
-
-**PlayerSync** is a **Minecraft Forge 1.20.1 server-side mod** that synchronizes player data across multiple Forge servers sharing a centralized MySQL database. It is designed for **Forge 群组服 (Forge group server)** architectures where players can move between different physical sub-servers and their inventory, equipment, advancements, effects, and other data must follow them seamlessly.
-
-| Property | Value |
-|---|---|
-| Mod ID | `playersync` |
-| Minecraft | 1.20.1 |
-| Forge | 47.4.0+ |
-| Java | 17 |
-| License | GPL-3.0 |
-| Author | mlus |
-| DB | MySQL (via JDBC `mysql-connector-j`) |
-
----
-
-## 2. Project File Structure
-
-```
-src/main/java/vip/fubuki/playersync/
-├── PlayerSync.java              # Main mod class, DB initialization
-├── CommandInit.java             # `/playersync` command registration
-├── config/
-│   └── JdbcConfig.java          # All mod configuration (ForgeConfigSpec)
-├── sync/
-│   ├── VanillaSync.java         # Core player data sync (inventory, effects, advancements, etc.)
-│   ├── ChatSync.java            # Cross-server chat sync orchestrator
-│   ├── chat/
-│   │   ├── ChatSyncServer.java  # TCP chat server (one designated server)
-│   │   └── ChatSyncClient.java  # TCP chat client (all servers)
-│   └── addons/
-│       ├── ModsSupport.java     # Curios, Sophisticated Backpacks & Mekanism integration
-│       ├── CuriosCache.java     # Death-safe Curios data caching
-│       └── MekanismSupport.java # Mekanism personal chest inventory sync
-└── util/
-    ├── JDBCsetUp.java           # MySQL JDBC connection & query helper
-    ├── LocalJsonUtil.java       # Lightweight map⇔string parser
-    └── PSThreadPoolFactory.java # Named thread factory for async DB operations
-
-src/main/resources/
-└── assets/playersync/lang/
-    ├── en_us.json               # English translations
-    └── zh_cn.json               # Chinese translations
-
-src/main/templates/
-├── META-INF/mods.toml           # Mod metadata template
-└── pack.mcmeta                  # Resource pack metadata
-```
-
----
-
-## 3. Architecture
-
-### 3.1 Deployment Topology
-
-```
-┌──────────────┐   ┌──────────────┐   ┌──────────────┐
-│  Server A    │   │  Server B    │   │  Server C    │
-│ (forge-1)    │   │ (forge-2)    │   │ (forge-3)    │
-│ PlayerSync   │   │ PlayerSync   │   │ PlayerSync   │
-└──────┬───────┘   └──────┬───────┘   └──────┬───────┘
-       │                  │                  │
-       └──────────────────┼──────────────────┘
-                          │
-                   ┌──────▼──────┐       ┌──────────────┐
-                   │   MySQL DB  │◄──────│  Chat Server │
-                   │  playersync │       │  (TCP:7900)  │
-                   └─────────────┘       └──────────────┘
-```
-
-- **All sub-servers** read/write player data to the same MySQL database.
-- **One designated server** runs the chat sync server (TCP). All servers connect to it as clients to broadcast chat messages across servers.
-- Each server gets a **unique `server_id`** (randomly generated on first config load).
-
-### 3.2 Data Flow Summary
-
-```
-Player Login:
-  1. PlayerNegotiationEvent → doPlayerConnect()     [check if already online on another server]
-  2. OnDatapackSyncEvent  → restore advancements     [write JSON to disk]
-  3. PlayerLoggedInEvent  → doPlayerJoin()           [restore all data from DB]
-                             └─ ModsSupport.doCuriosRestore()
-                             └─ ModsSupport.doBackPackRestore()
-                             └─ MekanismSupport.restorePersonalChestData()
-
-Player Playing:
-  4. PlayerEvent.SaveToFile → doPlayerSaveToFile()   [periodic save]
-  5. TickEvent.ServerTick   → auto-save every 1200t  [~1 min]
-  6. ServerChatEvent        → ChatSyncClient → TCP   [chat broadcast]
-
-Player Death (with keepInventory):
-  6. LivingDeathEvent → CuriosCache.tryStoreCuriosToCache()  [snapshot curios]
-
-Player Logout:
-  7. PlayerLoggedOutEvent → onPlayerLeave() → store() + curios save
-                              └─ if dead: use CuriosCache, else normal save
-
-Server Shutdown:
-  8. ServerStoppedEvent → mark server disabled in DB
-```
-
----
-
-## 4. Core Module Analysis
-
-### 4.1 `PlayerSync.java` — Main Mod Class
-
-**Path:** `src/main/java/vip/fubuki/playersync/PlayerSync.java`
-
-The entry point and lifecycle controller.
-
-| Method | Trigger | Responsibility |
-|---|---|---|
-| `PlayerSync()` | Mod construction | Register config, event bus |
-| `commonSetup()` | `FMLCommonSetupEvent` | Register JDBC driver, init VanillaSync, conditionally init ChatSync |
-| `onServerStarting()` | `ServerStartingEvent` | Create DB, create/alter tables, register server heartbeat, mark players offline |
-| `onServerStopping()` | `ServerStoppingEvent` | Shutdown ChatSync |
-
-**Database tables created on server start:**
-
-| Table | Purpose |
-|---|---|
-| `player_data` | Core player state (inv, armor, enderchest, advancements, effects, XP, health, food, score, left_hand, cursors, online flag, last_server) |
-| `server_info` | Server heartbeat (id, enable, data_version, last_update) |
-| `curios` | Curios inventory (only if Curios mod loaded) |
-| `backpack_data` | Sophisticated Backpacks NBT data (only if mod loaded) |
-| `mekanism_personal_chest` | Mekanism personal chest inventory data (only if Mekanism loaded) |
-
-The mod runs **automatic schema migration** — it checks column counts and data types on startup and alters tables as needed.
-
----
-
-### 4.2 `VanillaSync.java` — Core Sync Engine
-
-**Path:** `src/main/java/vip/fubuki/playersync/sync/VanillaSync.java`
-
-The largest and most critical class. All methods are `static` and registered via `@Mod.EventBusSubscriber`.
-
-#### Thread Pool
-
-```
-CORE: 2 threads, MAX: 8 threads, QUEUE: 256 (LinkedBlockingQueue)
-Rejection policy: CallerRunsPolicy (backpressure)
-```
-
-All DB operations run via `executorService.submit(...)` to avoid blocking the server thread. The bounded thread pool with `CallerRunsPolicy` was a fix for #169 — previously an unbounded `CachedThreadPool` could spawn 25000+ threads under load.
-
-#### Event Handlers
-
-| Event | Method | Behavior |
-|---|---|---|
-| `OnDatapackSyncEvent` | `onDataPackSyncEvent()` | Restore advancements JSON from DB to disk, then reload |
-| `PlayerNegotiationEvent` | `onPlayerConnect()` | Pre-login check: kick if player is already online on another active server (5-minute heartbeat window) |
-| `PlayerLoggedInEvent` | `onPlayerJoin()` | Full data restore: health, food, XP, score, inventory, armor, ender chest, effects, left hand, cursor. Returns generic placeholders for unknown modded items. |
-| `PlayerEvent.SaveToFile` | `onPlayerSaveToFile()` | Save current state to DB (skipped if player not yet synced) |
-| `PlayerLoggedOutEvent` | `onPlayerLogout()` | Mark offline in DB, save data, handle dead/dying edge cases |
-| `LivingDeathEvent` | `onPlayerDeath()` | Cache Curios data (for keepInventory worlds) |
-| `TickEvent.LevelTick` | `onUpdate()` | Server heartbeat: update `last_update` every 1800 ticks (~90s) |
-| `TickEvent.ServerTick` | `onServerTick()` | Auto-save all online players every 1200 ticks (~1 min); clean expired Curios cache every 36000 ticks (~30 min) |
-| `ServerStoppedEvent` | `onServerShutdown()` | Mark server as disabled in DB |
-
-#### Serialization
-
-- **New format (default):** Base64 with `B64:` prefix (`B64:<base64-nbt-string>`)
-- **Legacy format:** Custom character replacement (`|`, `^`, `<`, `>`, `~` for `,`, `"`, `{`, `}`, `'`)
-- The mod **reads both formats** but writes using the configured format (`use_legacy_serialization` config flag)
-- NBT is always tagged with the current data version for forward compatibility
-
-#### Placeholder Items
-
-When an item from one server's mod set doesn't exist on another, it becomes a **paper item** with:
-- Red italic name: "Item Voucher" (customizable)
-- Lore showing the original item ID and stack count
-- Stored `playersync:original_item_nbt` tag for later restoration
-- Unique UUID to prevent stacking
-
-#### XP Calculation
-
-- `getTotalExperience()` — converts level+progress to absolute XP using Minecraft's level curve formulas (different for levels 0-15, 16-30, 31+)
-- `setXpForPlayer()` — inverse: distributes absolute XP into level+progress, bypassing `giveExperience()` side effects (events, packets, score)
-
-#### Dead/Dying Player Edge Case
-
-When a player dies during login (`isDeadOrDying()`), the mod:
-1. Clears the `player_synced` tag
-2. Teleports to respawn point
-3. Sets health to 1
-4. Updates online status
-5. Disconnects player with a reconnect message
-
-This avoids saving corrupted "dead" state as the player's synced data.
-
----
-
-### 4.3 `ChatSync.java` — Chat Sync Orchestrator
-
-**Path:** `src/main/java/vip/fubuki/playersync/sync/ChatSync.java`
-
-Starts both the **TCP server** (if configured as chat server) and **TCP client** on separate threads.
-
-- `ChatSyncServer` (port 7900 default) — accepts client connections, broadcasts received messages to all other connected clients
-- `ChatSyncClient` — connects to the chat server, relays `ServerChatEvent` messages, receives and broadcasts messages from the server to local players
-- Uses exponential backoff for reconnect (5s base, up to 60s, max 10 attempts)
-
----
-
-### 4.4 `JdbcConfig.java` — Configuration
-
-**Path:** `src/main/java/vip/fubuki/playersync/config/JdbcConfig.java`
-
-All configuration is done via Forge's `ForgeConfigSpec` system (TOML file on server). Key entries:
-
-| Config Key | Default | Description |
-|---|---|---|
-| `host` | `localhost` | MySQL host |
-| `db_port` | `3306` | MySQL port |
-| `use_ssl` | `false` | SSL for DB connection |
-| `user_name` | `playersync` | DB username |
-| `password` | `pleaseChangeThisPassword` | DB password |
-| `db_name` | `playersync` | Database name |
-| `Server_id` | random int | Unique server identifier |
-| `sync_world` | `[]` | World names for advancements (empty = auto-detect) |
-| `sync_advancements` | `true` | Enable advancement sync |
-| `sync_chat` | `false` | Enable cross-server chat |
-| `IsChatServer` | `false` | This server acts as chat relay host |
-| `ChatServerIP` | `127.0.0.1` | Chat server address |
-| `ChatServerPort` | `7900` | Chat server port |
-| `kick_when_already_online` | `true` | Prevent multi-server login |
-| `use_legacy_serialization` | `false` | Use old serialization format |
-| `item_placeholder_title_override` | `""` | Custom placeholder title |
-| `item_placeholder_description_override` | `""` | Custom placeholder description |
-| `sync_mekanism_personal_chest` | `false` | Sync Mekanism personal chest inventories |
-
----
-
-### 4.5 `JDBCsetUp.java` — Database Utility
-
-**Path:** `src/main/java/vip/fubuki/playersync/util/JDBCsetUp.java`
-
-Encapsulates all MySQL operations:
-
-| Method | Purpose |
-|---|---|
-| `getConnection(selectDatabase)` | Create JDBC connection; `selectDatabase=false` for DDL statements |
-| `executeQuery()` | Run SELECT, returns `QueryResult` record |
-| `executeUpdate()` | Run INSERT/UPDATE/DELETE/DDL with database |
-| `executeUpdateWithoutDatabase()` | Run DDL without default database |
-| `update()` | Parameterized update (anti-SQL-injection) |
-
-The `QueryResult` record (`Connection`, `PreparedStatement`, `ResultSet`) implements `AutoCloseable` for try-with-resources support.
-
-**Note:** SQL queries in `VanillaSync` use **string concatenation** for UUID values rather than parameterized queries — this is a potential SQL injection risk if UUIDs could be attacker-controlled (though Minecraft UUIDs are generally safe). The `JDBCsetUp.update()` method does provide parameterized queries but is not used for the main sync queries.
-
----
-
-### 4.6 `LocalJsonUtil.java` — Lightweight Map Parser
-
-**Path:** `src/main/java/vip/fubuki/playersync/util/LocalJsonUtil.java`
-
-A minimal parser that converts Java `Map.toString()` output back into `Map<String, String>` or `Map<Integer, String>`. Used because the item/effect data is stored as `{0=..., 1=..., 2=...}` format (Java map string representation), not standard JSON.
-
-Uses `=` as key-value separator (not `:`), matching Java's `Map.toString()` format.
-
----
-
-### 4.7 `PSThreadPoolFactory.java` — Named Thread Factory
-
-**Path:** `src/main/java/vip/fubuki/playersync/util/PSThreadPoolFactory.java`
-
-Simple `ThreadFactory` implementation producing threads named `PlayerSync-thread-N` for easier debugging.
-
----
-
-### 4.8 `CommandInit.java` — Command Registration
-
-**Path:** `src/main/java/vip/fubuki/playersync/CommandInit.java`
-
-Registers the `/playersync` command (permission level 2 required). Currently has a `reconnect` subcommand that is a stub (returns 0, implementation commented out).
-
----
-
-### 4.9 Addon Support (`ModsSupport.java` & `CuriosCache.java`)
-
-#### Curios Integration
-- **Save:** Serializes all Curios slot items as `{slotType:index=serializedNbt, ...}` map, stored in `curios` table
-- **Restore:** Clears all Curios slots, reads DB data, deserializes with placeholder support
-- **Death handling:** `CuriosCache` snapshots Curios inventory on death (keepInventory worlds only), used on logout to prevent empty-save bug from the "Title Screen" disconnect case
-- Cache entries expire after 1 hour
-
-#### Sophisticated Backpacks Integration
-- **Save:** Iterates backpack items via `PlayerInventoryProvider.runOnBackpacks()`, extracts `contentsUuid` via `NBTHelper`, stores NBT in `backpack_data` table using `REPLACE INTO`
-- **Restore:** On player join, reads backpack NBT from DB and calls `BackpackStorage.get().setBackpackContents()` to inject it
-
-#### Mekanism Integration
-
-**Jetpack Mode (already synced):** The jetpack mode (`NORMAL`/`HOVER`/`DISABLED`) is stored in the ItemStack NBT at path `mekData.mode`. PlayerSync's existing `serializeNBT()` → Base64 pipeline preserves all ItemStack NBT including `mekData.*`, so jetpack state is automatically synced without any additional code. The `PlayerState.activeJetpacks` set is purely runtime memory (used for sound/particle effects) and is cleared by Mekanism on player logout — it does not need persistence.
-
-**Personal Chest (new sync):** Personal chest inventories are stored in Mekanism's world-level `SavedData` files (`<world>/data/mekanism_personal_storage/<uuid>`), NOT on the ItemStack. The ItemStack only carries a UUID reference (`mekData.personalStorageId`). When a player moves between servers, the ItemStack is restored but the target server's `SavedData` has no inventory for that UUID — the chest appears empty.
-
-`MekanismSupport.java` solves this by:
-
-- **Save:** Iterates the player's inventory + ender chest, finds every item with a `mekData.personalStorageId` tag. Uses reflection to call `PersonalStorageManager.getInventoryIfPresent(stack)`, then serializes all 54 `IInventorySlot` entries via `slot.serializeNBT()` into a single NBT `CompoundTag`, which is Base64-encoded and stored in the `mekanism_personal_chest` table keyed by `storage_id`.
-
-- **Restore:** After inventory is restored (in `doPlayerJoin()`), iterates the player's items again to find personal chests. For each, queries the DB for saved inventory data. Uses reflection to call `PersonalStorageManager.getInventoryFor(stack)` to create/retrieve the `SavedData` entry on the target server, then calls `slot.deserializeNBT()` on each of the 54 slots.
-
-- **Reflection:** `PersonalStorageManager` and `PersonalStorageData` are in Mekanism's implementation JAR (not the API JAR), so access is via `Class.forName()` + `Method.invoke()`. The `IInventorySlot` interface IS in the API JAR and is used directly at compile time.
-
-- **Config:** Controlled by `sync_mekanism_personal_chest` (default `false`).
-
-| Method | Purpose |
-|---|---|
-| `collectPersonalChestItems(player)` | Scan inventory + ender chest for personal chest items, return map of storageId → ItemStack |
-| `savePersonalChestData(player)` | Serialize each chest's 54 slots, write to DB via `REPLACE INTO` |
-| `restorePersonalChestData(player)` | Read from DB, call `getInventoryFor()`, deserialize slots into target world's `SavedData` |
-| `getInventoryIfPresent(stack)` | Reflection wrapper for `PersonalStorageManager.getInventoryIfPresent()` |
-| `getInventoryFor(stack)` | Reflection wrapper for `PersonalStorageManager.getInventoryFor()` |
-| `getInventorySlots(inventory)` | Reflection wrapper for `AbstractPersonalStorageItemInventory.getInventorySlots(null)` |
-| `getPersonalStorageId(stack)` | Extract `personalStorageId` UUID from ItemStack NBT `mekData` |
-
-## 5. Synchronized Data
-
-| Data | Storage Column | Type | Format |
-|---|---|---|---|
-| Inventory (36 slots) | `inventory` | MEDIUMBLOB | `{0=B64:..., 1=B64:..., ...}` |
-| Armor (4 slots) | `armor` | BLOB | `{0=B64:..., ...}` |
-| Off-hand | `left_hand` | BLOB | Base64 NBT string |
-| Cursor (carried) | `cursors` | BLOB | Base64 NBT string |
-| Ender Chest (27 slots) | `enderchest` | MEDIUMBLOB | `{0=B64:..., ...}` |
-| Advancements | `advancements` | MEDIUMBLOB | Raw JSON bytes |
-| Active Effects | `effects` | BLOB | `{effectId=B64:nbt, ...}` |
-| XP | `xp` | INT | Absolute XP value |
-| Health | `health` | INT | HP as integer |
-| Food Level | `food_level` | INT | 0-20 |
-| Score | `score` | INT | Display score |
-| Online Status | `online` | TINYINT | 0 or 1 |
-| Last Server | `last_server` | INT | Server ID |
-| Curios | `curios_item` (separate table) | BLOB | `{slotType:index=B64:..., ...}` |
-| Backpacks | `backpack_nbt` (separate table) | MEDIUMBLOB | Base64 NBT string |
-| Mekanism Personal Chest | `inventory_data` (separate table) | MEDIUMBLOB | Base64 NBT of 54 slots (via `IInventorySlot.serializeNBT()`) |
-
----
-
-## 6. Lifecycle Events Summary
-
-```
-Server Starting
-├── commonSetup: register JDBC driver, register VanillaSync, (optionally) ChatSync
-└── onServerStarting:
-    ├── CREATE DATABASE IF NOT EXISTS
-    ├── CREATE/ALTER player_data table
-    ├── CREATE/ALTER server_info table
-    ├── CREATE curios table (if Curios loaded)
-    ├── CREATE backpack_data table (if SophisticatedBackpacks loaded)
-    ├── CREATE mekanism_personal_chest table (if Mekanism loaded)
-    ├── INSERT/UPDATE server_info (heartbeat)
-    └── Reset stale online flags
-
-Player Connecting
-├── onPlayerConnect: check already-online, kick if needed
-├── onDataPackSyncEvent: write advancements JSON to disk
-└── onPlayerJoin:
-    ├── Restore: health, food, XP, score
-    ├── Restore: left_hand, cursors, armor, inventory, enderchest, effects
-    ├── Restore: Curios items (ModsSupport)
-    ├── Restore: Backpack data (ModsSupport)
-    └── Restore: Mekanism personal chest data (MekanismSupport)
-
-Player Playing
-├── onPlayerSaveToFile: save() to DB (per save event)
-├── onServerTick: auto-save all players every ~1 min
-├── onUpdate: heartbeat every ~90s
-└── ServerChatEvent → ChatSyncClient → TCP
-
-Player Logging Out
-├── onPlayerDeath: cache Curios (if keepInventory)
-└── onPlayerLogout:
-    ├── Dead/dying: use CuriosCache, don't save new data
-    ├── Sync incomplete: skip save (safety)
-    └── Normal: store() + ModsSupport.onPlayerLeave()
-
-Server Shutting Down
-├── onServerShutdown: mark server disabled
-└── onServerStopping: shutdown ChatSync
-```
-
----
-
-## 7. Key Design Decisions
-
-1. **Thread pool bounded with CallerRunsPolicy** — Fix for #169. Prevents thread explosion under concurrent player load by limiting to 8 threads + 256 queue, with natural backpressure.
-
-2. **Base64 NBT serialization** — Replaced legacy character-replacement format. Backward-compatible read of both formats; config flag to force legacy writes.
-
-3. **Placeholder items for missing mods** — When a modded item's registry entry doesn't exist on the current server (e.g., player moved from Mekanism server to vanilla), a paper voucher preserves the original NBT so the item can be restored when the player returns.
-
-4. **Dead/dying player handling** — Special case for players who die during the login process or disconnect via "Title Screen" while dead. Uses `CuriosCache` to snapshot Curios data on death so it's not lost on logout.
-
-5. **Advancement sync via filesystem** — Rather than direct NBT manipulation, advancements are synced by writing the JSON file to the world's advancements directory and calling `reload()`. This leverages Minecraft's built-in advancement loading.
-
-6. **Schema auto-migration** — The mod checks column existence and data types on startup and alters tables as needed, supporting upgrades without manual SQL.
-
-7. **Server heartbeat system** — Each server writes `last_update` every ~90s. Other servers check this to determine if a player is genuinely online elsewhere (5-minute window) before kicking.
-
-8. **Reflection-based mod addon support** — Third-party mod data whose storage classes are not in the public API JAR (like Mekanism's `PersonalStorageManager`) are accessed via `Class.forName()` + `Method.invoke()`. This avoids hard-compile-dependencies on implementation JARs while still enabling deep data sync at runtime. The compile-time dependency stays on the API JAR only (`IInventorySlot`, `NBTConstants`).

gradle.properties

@@ -34,7 +34,7 @@ mod_name=PlayerSync
 # The license of the mod. Review your options at https://choosealicense.com/. All Rights Reserved is the default.
 mod_license=GPL-3.0 license
 # The mod version. See https://semver.org/
-mod_version=2.1.6
+mod_version=2.1.3
 # The group ID for the mod. It is only important when publishing as an artifact to a Maven repository.
 # This should match the base package used for the mod sources.
 # See https://maven.apache.org/guides/mini/guide-naming-conventions.html
@@ -47,7 +47,3 @@ mod_description=make multiserver players' data sync
  # JDBC driver version
  # see https://dev.mysql.com/doc/relnotes/connector-j/en/ for latest version
  jdbc_version=9.3.0
-
-# Mek Version
-# see https://modmaven.dev/mekanism/Mekanism/ for latest version
-mekanism_version=1.20.1-10.4.9.61

src/main/java/vip/fubuki/playersync/CommandInit.java

@@ -6,6 +6,7 @@ import net.minecraft.commands.Commands;
 import net.minecraftforge.event.RegisterCommandsEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.common.Mod;
+import vip.fubuki.playersync.sync.chat.ChatSyncClient;
 
 @Mod.EventBusSubscriber()
 public class CommandInit {
@@ -17,6 +18,7 @@ public class CommandInit {
                 .requires(cs->cs.hasPermission(2))
                 .then(Commands.literal("reconnect")
                         .executes(context -> {
+                            new ChatSyncClient().run();
 //                                  context.getSource().sendSuccess(()->MutableComponent.create(new TranslatableContents("playersync.command.reconnect")),true);
                                     return 0;
                                 }

src/main/java/vip/fubuki/playersync/PlayerSync.java

@@ -1,11 +1,8 @@
 package vip.fubuki.playersync;
 
 import com.mojang.logging.LogUtils;
-import com.mysql.cj.jdbc.Driver;
-import net.minecraft.SharedConstants;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.event.server.ServerStartingEvent;
-import net.minecraftforge.event.server.ServerStoppingEvent;
 import net.minecraftforge.eventbus.api.IEventBus;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.ModList;
@@ -19,7 +16,12 @@ import vip.fubuki.playersync.sync.ChatSync;
 import vip.fubuki.playersync.sync.VanillaSync;
 import vip.fubuki.playersync.util.JDBCsetUp;
 
-import java.sql.*;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import com.mysql.cj.jdbc.Driver;
 
 @Mod(PlayerSync.MODID)
 public class PlayerSync {
@@ -58,12 +60,12 @@ public class PlayerSync {
         String dbName = JdbcConfig.DATABASE_NAME.get();
 
         // Step 1: Create the database using a connection that does not select a database.
-        JDBCsetUp.executeUpdateWithoutDatabase("CREATE DATABASE IF NOT EXISTS `" + dbName + "`");
+        JDBCsetUp.executeUpdate("CREATE DATABASE IF NOT EXISTS " + dbName, 1);
 
         // Step 2: Explicitly select the database on a connection obtained without default database.
         try (Connection conn = JDBCsetUp.getConnection(false);
              Statement st = conn.createStatement()) {
-            st.execute("USE `" + dbName + "`");
+            st.execute("USE " + dbName);
         } catch (SQLException e) {
             LOGGER.error("Error selecting database " + dbName, e);
             throw e;
@@ -72,7 +74,7 @@ public class PlayerSync {
         // Step 3: Create and alter tables using fully qualified names.
         // Create player_data table
         JDBCsetUp.executeUpdate(
-                "CREATE TABLE IF NOT EXISTS `" + dbName + "`.`player_data` (" +
+                "CREATE TABLE IF NOT EXISTS " + dbName + ".`player_data` (" +
                         "`uuid` char(36) NOT NULL," +
                         "`inventory` mediumblob," +
                         "`armor` blob," +
@@ -105,7 +107,7 @@ public class PlayerSync {
         }
         if (columnCount < 14) {
             JDBCsetUp.executeUpdate(
-                    "ALTER TABLE `" + dbName + "`.`player_data` " +
+                    "ALTER TABLE " + dbName + ".player_data " +
                             "ADD COLUMN left_hand blob, " +
                             "ADD COLUMN cursors blob;"
             );
@@ -113,50 +115,29 @@ public class PlayerSync {
 
         // Create server_info table
         JDBCsetUp.executeUpdate(
-                "CREATE TABLE IF NOT EXISTS `" + dbName + "`.`server_info` (" +
+                "CREATE TABLE IF NOT EXISTS " + dbName + ".server_info (" +
                         "`id` INT NOT NULL," +
                         "`enable` boolean NOT NULL," +
                         "`last_update` BIGINT NOT NULL," +
                         "PRIMARY KEY (`id`)" +
                         ");"
         );
-        // do not modify the create table statement to make sure this code is compatible with older database versions
-        addColumnIfNotExists("server_info", "data_version", "INT NOT NULL DEFAULT 0");
-
         long current = System.currentTimeMillis();
-        int data_version = SharedConstants.getCurrentVersion().getDataVersion().getVersion();
-        JDBCsetUp.executeUpdate("""
-                INSERT INTO `%s`.`server_info`
-                (
-                    id,
-                    enable,
-                    data_version,
-                    last_update
-                )
-                VALUES (
-                    %d,
-                    true,
-                    %d,
-                    %d
-                )
-                ON DUPLICATE KEY UPDATE
-                    id = %d,
-                    enable = true,
-                    data_version = %d,
-                    last_update = %d;
-                """,
-                dbName,
-                JdbcConfig.SERVER_ID.get(),
-                data_version,
-                current,
-                JdbcConfig.SERVER_ID.get(),
-                data_version,
-                current);
+        JDBCsetUp.executeUpdate(
+                "INSERT INTO " + dbName + ".server_info(id,enable,last_update) " +
+                        "VALUES(" + JdbcConfig.SERVER_ID.get() + ",true," + current + ") " +
+                        "ON DUPLICATE KEY UPDATE id= " + JdbcConfig.SERVER_ID.get() + ",enable = 1," +
+                        "last_update=" + current + ";"
+        );
+        JDBCsetUp.executeUpdate(
+                "UPDATE " + dbName + ".server_info SET last_update=" + System.currentTimeMillis() +
+                        " WHERE id='" + JdbcConfig.SERVER_ID.get() + "'"
+        );
 
         // Create curios table if the Curios mod is loaded
         if (ModList.get().isLoaded("curios")) {
             JDBCsetUp.executeUpdate(
-                    "CREATE TABLE IF NOT EXISTS `" + dbName + "`.`curios` (" +
+                    "CREATE TABLE IF NOT EXISTS " + dbName + ".curios (" +
                             "uuid CHAR(36) NOT NULL, curios_item BLOB, PRIMARY KEY (uuid)" +
                             ")"
             );
@@ -164,26 +145,28 @@ public class PlayerSync {
 
         // Create backpack_data table
         if (ModList.get().isLoaded("sophisticatedbackpacks")) {
-            JDBCsetUp.executeUpdateWithoutDatabase(
-                    "CREATE TABLE IF NOT EXISTS `" + dbName + "`.`backpack_data` (" +
-                            "uuid CHAR(36) NOT NULL, backpack_nbt MEDIUMBLOB, PRIMARY KEY (uuid)" +
-                            ");"
-            );
-            // Check if backpack_data table has the 'uuid' column
-            addColumnIfNotExists("backpack_data", "uuid", "CHAR(36) NOT NULL", true);
-        }
-
-        // Create mekanism_personal_chest table if Mekanism is loaded
-        if (ModList.get().isLoaded("mekanism")) {
             JDBCsetUp.executeUpdate(
-                    "CREATE TABLE IF NOT EXISTS `" + dbName + "`.`mekanism_personal_chest` (" +
-                            "player_uuid CHAR(36) NOT NULL," +
-                            "storage_id CHAR(36) NOT NULL," +
-                            "inventory_data MEDIUMBLOB," +
-                            "PRIMARY KEY (storage_id)," +
-                            "INDEX idx_player_uuid (player_uuid)" +
-                            ");"
+                    "CREATE TABLE IF NOT EXISTS " + dbName + ".backpack_data (" +
+                            "uuid CHAR(36) NOT NULL, backpack_nbt MEDIUMBLOB, PRIMARY KEY (uuid)" +
+                            ");", 1
             );
+
+            // Check if backpack_data table has the 'uuid' column
+            JDBCsetUp.QueryResult backpackColCheck = JDBCsetUp.executeQuery(
+                    "SELECT COUNT(*) AS colCount FROM INFORMATION_SCHEMA.COLUMNS " +
+                            "WHERE TABLE_SCHEMA = '" + dbName + "' " +
+                            "AND TABLE_NAME = 'backpack_data' " +
+                            "AND COLUMN_NAME = 'uuid';"
+            );
+            ResultSet rsBackpackCol = backpackColCheck.resultSet();
+            if (rsBackpackCol.next() && rsBackpackCol.getInt("colCount") == 0) {
+                LOGGER.info("Altering backpack_data table to add missing 'uuid' column.");
+                // Add the missing column and set it as primary key.
+                JDBCsetUp.executeUpdate("ALTER TABLE " + dbName + ".backpack_data ADD COLUMN uuid CHAR(36) NOT NULL", 1);
+                JDBCsetUp.executeUpdate("ALTER TABLE " + dbName + ".backpack_data ADD PRIMARY KEY (uuid)", 1);
+            }
+            rsBackpackCol.close();
+            backpackColCheck.connection().close();
         }
 
         // Check and alter the 'advancements' column in player_data if necessary
@@ -197,64 +180,14 @@ public class PlayerSync {
         if (rsAdvCol.next()) {
             String dataType = rsAdvCol.getString("DATA_TYPE");
             if (!"mediumblob".equalsIgnoreCase(dataType)) {
-                LOGGER.info("Altering player_data table to modify 'advancements' column from {} to MEDIUMBLOB.", dataType);
-                JDBCsetUp.executeUpdateWithoutDatabase("ALTER TABLE `" + dbName + "`.`player_data` MODIFY COLUMN advancements MEDIUMBLOB");
+                LOGGER.info("Altering player_data table to modify 'advancements' column to MEDIUMBLOB.");
+                JDBCsetUp.executeUpdate("ALTER TABLE " + dbName + ".player_data MODIFY COLUMN advancements MEDIUMBLOB", 1);
             }
         }
         rsAdvCol.close();
         // ----- END NEW BLOCK -----
 
-        try {
-            JDBCsetUp.executeUpdate("UPDATE player_data SET online=0 WHERE last_server=" + JdbcConfig.SERVER_ID.get() +" AND online=1 LIMIT 1000");
-        } catch (Exception e) {
-            LOGGER.error("An exception occurred while trying change wrong player-status\n" + e.getMessage());
-        }
         LOGGER.info("PlayerSync is ready!");
     }
 
-    @SubscribeEvent
-    public void onServerStopping(ServerStoppingEvent event){
-        ChatSync.shutdown();
-    }
-
-    private static void addColumnIfNotExists(String tableName, String columnName, String dataTypeDefaultNullness,
-            boolean makePrimaryKey) throws SQLException {
-
-        // Making use of the AutoCloseable QueryResult here
-        try (JDBCsetUp.QueryResult backpackColCheck = JDBCsetUp.executeQuery(
-                "SELECT COUNT(*) AS colCount FROM INFORMATION_SCHEMA.COLUMNS " +
-                        "WHERE TABLE_SCHEMA = DATABASE()" +
-                        "AND TABLE_NAME = '" + tableName + "' " +
-                        "AND COLUMN_NAME = '" + columnName + "';")) {
-            ResultSet rsBackpackCol = backpackColCheck.resultSet();
-
-            if (!rsBackpackCol.next()) {
-                LOGGER.warn("Warning: Unable to check existence of colum {} in table {}.", columnName, tableName);
-                return;
-            }
-
-            if (rsBackpackCol.getInt("colCount") > 0) {
-                LOGGER.debug("Column {} already exists. Skipping creation.", columnName);
-                return;
-            }
-        }
-
-        LOGGER.info("ALTER {} table to add missing {} column.", tableName, columnName);
-        // Add the missing column and set it as primary key.
-        JDBCsetUp.executeUpdate(
-                "ALTER TABLE %s ADD COLUMN %s %s",
-                tableName, columnName, dataTypeDefaultNullness);
-
-        if (makePrimaryKey) {
-            LOGGER.info("Altering {} table to add primary key on {}.", tableName, columnName);
-            JDBCsetUp.executeUpdate(
-                    "ALTER TABLE %s ADD PRIMARY KEY (%s)",
-                    tableName, columnName);
-        }
-    }
-
-    private static void addColumnIfNotExists(String tableName, String columnName,
-            String dataTypeDefaultNullness) throws SQLException {
-        addColumnIfNotExists(tableName, columnName, dataTypeDefaultNullness, false);
-    }
 }

src/main/java/vip/fubuki/playersync/config/JdbcConfig.java

@@ -9,26 +9,24 @@ import java.util.Random;
 
 
 public class JdbcConfig {
-    public static final ForgeConfigSpec COMMON_CONFIG;
-    public static final ForgeConfigSpec.ConfigValue<String> HOST;
-    public static final ForgeConfigSpec.IntValue PORT;
-    public static final ForgeConfigSpec.ConfigValue<String> USERNAME;
-    public static final ForgeConfigSpec.ConfigValue<String> PASSWORD;
-    public static final ForgeConfigSpec.ConfigValue<String> DATABASE_NAME;
-    public static final ForgeConfigSpec.ConfigValue<List<String>> SYNC_WORLD;
-    public static final ForgeConfigSpec.BooleanValue SYNC_ADVANCEMENTS;
-    public static final ForgeConfigSpec.BooleanValue USE_SSL;
-    public static final ForgeConfigSpec.BooleanValue SYNC_CHAT;
-    public static final ForgeConfigSpec.BooleanValue IS_CHAT_SERVER;
+    public static ForgeConfigSpec COMMON_CONFIG;
+    public static ForgeConfigSpec.ConfigValue<String> HOST;
+    public static ForgeConfigSpec.IntValue PORT;
+    public static ForgeConfigSpec.ConfigValue<String> USERNAME;
+    public static ForgeConfigSpec.ConfigValue<String> PASSWORD;
+    public static ForgeConfigSpec.ConfigValue<String> DATABASE_NAME;
+    public static ForgeConfigSpec.ConfigValue<List<String>> SYNC_WORLD;
+    public static ForgeConfigSpec.BooleanValue SYNC_ADVANCEMENTS;
+    public static ForgeConfigSpec.BooleanValue USE_SSL;
+    public static ForgeConfigSpec.BooleanValue SYNC_CHAT;
+    public static ForgeConfigSpec.BooleanValue IS_CHAT_SERVER;
     public static final ForgeConfigSpec.ConfigValue<String> ITEM_PLACEHOLDER_TITLE_OVERRIDE;
     public static final ForgeConfigSpec.ConfigValue<String> ITEM_PLACEHOLDER_DESCRIPTION_OVERRIDE;
-    public static final ForgeConfigSpec.BooleanValue KICK_WHEN_ALREADY_ONLINE;
-    public static final ForgeConfigSpec.ConfigValue<String> CHAT_SERVER_IP;
-    public static final ForgeConfigSpec.IntValue CHAT_SERVER_PORT;
-    public static final ForgeConfigSpec.BooleanValue USE_LEGACY_SERIALIZATION;
-    public static final ForgeConfigSpec.BooleanValue SYNC_MEKANISM_PERSONAL_CHEST;
+    public static ForgeConfigSpec.ConfigValue<String> CHAT_SERVER_IP;
+    public static ForgeConfigSpec.IntValue CHAT_SERVER_PORT;
+    public static ForgeConfigSpec.BooleanValue USE_LEGACY_SERIALIZATION;
 
-    public static final ForgeConfigSpec.ConfigValue<Integer> SERVER_ID;
+    public static ForgeConfigSpec.ConfigValue<Integer> SERVER_ID;
 
 
     static {
@@ -46,8 +44,6 @@ public class JdbcConfig {
                 .define("sync_advancements", true);
         SYNC_CHAT = COMMON_BUILDER.comment("Whether synchronize chat").define("sync_chat", false);
         IS_CHAT_SERVER = COMMON_BUILDER.comment("Whether recieve messages from other servers as host").define("IsChatServer",false);
-        KICK_WHEN_ALREADY_ONLINE = COMMON_BUILDER.comment("Whether to kick player when already online on another server")
-                .define("kick_when_already_online", true);
         CHAT_SERVER_IP = COMMON_BUILDER.define("ChatServerIP","127.0.0.1");
         CHAT_SERVER_PORT = COMMON_BUILDER.defineInRange("ChatServerPort",7900,0,65535);
         USE_LEGACY_SERIALIZATION = COMMON_BUILDER.comment(
@@ -62,9 +58,6 @@ public class JdbcConfig {
         ITEM_PLACEHOLDER_DESCRIPTION_OVERRIDE = COMMON_BUILDER
                 .comment("Override the description of placeholder items which are unavailable on the current server.")
                 .define("item_placeholder_description_override", "");
-        SYNC_MEKANISM_PERSONAL_CHEST = COMMON_BUILDER
-                .comment("Whether to sync Mekanism personal chest inventories across servers.")
-                .define("sync_mekanism_personal_chest", false);
 
         COMMON_BUILDER.pop();
         COMMON_CONFIG = COMMON_BUILDER.build();

src/main/java/vip/fubuki/playersync/sync/ChatSync.java

@@ -11,45 +11,28 @@ import java.io.IOException;
 
 public class ChatSync {
     public static final Logger LOGGER = LogUtils.getLogger();
-    private static ChatSyncServer chatSyncServer;
-    private static ChatSyncClient chatSyncClient;
 
     public static void register(){
         if(JdbcConfig.IS_CHAT_SERVER.get()) {
             LOGGER.info("Trying to setup chat server at port " + JdbcConfig.CHAT_SERVER_PORT.get());
             new Thread(()->{
-                chatSyncServer = new ChatSyncServer();
+                ChatSyncServer chatSyncServer = new ChatSyncServer();
                 try {
                     chatSyncServer.run();
                 } catch (IOException e) {
                     LOGGER.error("Unable to start chat server", e);
                 }
-            }, "ChatSync-Server").start();
+            }).start();
         }
 
         new Thread(()->{
-            try {
-                Thread.sleep(2000);
-            } catch (InterruptedException e) {
-                Thread.currentThread().interrupt();
-            }
-
             LOGGER.info("Trying to connect to chat server "
                     + JdbcConfig.CHAT_SERVER_IP.get()
                     + ":"
                     + JdbcConfig.CHAT_SERVER_PORT.get());
-            chatSyncClient = new ChatSyncClient();
+            ChatSyncClient chatSyncClient = new ChatSyncClient();
             chatSyncClient.run();
-        }, "ChatSync-Client").start();
+        }).start();
         MinecraftForge.EVENT_BUS.register(ChatSyncClient.class);
     }
-
-    public static void shutdown() {
-        if (chatSyncServer != null) {
-            chatSyncServer.shutdown();
-        }
-        if (chatSyncClient != null) {
-            chatSyncClient.shutdown();
-        }
-    }
 }

src/main/java/vip/fubuki/playersync/sync/ModsSupport.java

@@ -1,4 +1,4 @@
-package vip.fubuki.playersync.sync.addons;
+package vip.fubuki.playersync.sync;
 
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import net.minecraft.nbt.CompoundTag;
@@ -7,12 +7,7 @@ import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.common.util.LazyOptional;
 import net.minecraftforge.fml.ModList;
-import top.theillusivec4.curios.api.CuriosApi;
-import top.theillusivec4.curios.api.type.capability.ICuriosItemHandler;
-import top.theillusivec4.curios.api.type.inventory.ICurioStacksHandler;
-import top.theillusivec4.curios.api.type.inventory.IDynamicStackHandler;
 import vip.fubuki.playersync.PlayerSync;
-import vip.fubuki.playersync.sync.VanillaSync;
 import vip.fubuki.playersync.util.JDBCsetUp;
 import vip.fubuki.playersync.util.LocalJsonUtil;
 
@@ -20,12 +15,87 @@ import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.HashMap;
 import java.util.Map;
+
+import top.theillusivec4.curios.api.CuriosApi;
+import top.theillusivec4.curios.api.type.capability.ICuriosItemHandler;
+import top.theillusivec4.curios.api.type.inventory.ICurioStacksHandler;
+import top.theillusivec4.curios.api.type.inventory.IDynamicStackHandler;
 import java.util.Optional;
 import java.util.UUID;
 
+import static vip.fubuki.playersync.sync.VanillaSync.deserializeString;
+
 
 public class ModsSupport {
-    public void doBackPackRestore(Player player) {
+
+    /**
+     * Restores the Curios inventory for a player.
+     * The saved data is stored as a flat map with composite keys ("slotType:index").
+     */
+    public void onPlayerJoin(net.minecraft.world.entity.player.Player player) throws SQLException {
+        if (ModList.get().isLoaded("curios")) {
+            // Obtain the handler from the API.
+            LazyOptional<ICuriosItemHandler> handlerOpt = CuriosApi.getCuriosInventory(player);
+            JDBCsetUp.QueryResult qr = JDBCsetUp.executeQuery("SELECT curios_item FROM curios WHERE uuid = '" + player.getUUID() + "'");
+            ResultSet rs = qr.resultSet();
+            if (rs.next()) {
+                String curiosData = rs.getString("curios_item");
+                if (curiosData.length() <= 2) {
+                    rs.close();
+                    qr.connection().close();
+                    return;
+                }
+                // Parse the stored data (assumes a simple Map.toString() format: "{key=value, key2=value2, ...}")
+                Map<String, String> storedMap = LocalJsonUtil.StringToMap(curiosData);
+
+                // Clear current Curios slots to avoid conflicts.
+                handlerOpt.ifPresent(handler -> handler.getCurios().forEach((slotType, stacksHandler) -> {
+                    // Use the dynamic stack handler to clear slots.
+                    IDynamicStackHandler dynStacks = stacksHandler.getStacks();
+                    for (int i = 0; i < dynStacks.getSlots(); i++) {
+                        dynStacks.setStackInSlot(i, ItemStack.EMPTY);
+                    }
+                }));
+
+                // Restore each saved item.
+                handlerOpt.ifPresent(handler -> {
+                    for (Map.Entry<String, String> entry : storedMap.entrySet()) {
+                        String compositeKey = entry.getKey(); // Expected format: "slotType:index"
+                        String[] parts = compositeKey.split(":");
+                        if (parts.length != 2) {
+                            continue;
+                        }
+                        String slotType = parts[0];
+                        int slotIndex;
+                        try {
+                            slotIndex = Integer.parseInt(parts[1]);
+                        } catch (NumberFormatException ex) {
+                            continue;
+                        }
+                        String serialized = entry.getValue();
+                        try {
+                            String nbtString = VanillaSync.deserializeString(serialized);
+                            CompoundTag tag = NbtUtils.snbtToStructure(nbtString);
+                            ItemStack stack = ItemStack.of(tag);
+                            if (handler.getCurios().containsKey(slotType)) {
+                                ICurioStacksHandler stacksHandler = handler.getCurios().get(slotType);
+                                IDynamicStackHandler dynStacks = stacksHandler.getStacks();
+                                if (slotIndex < dynStacks.getSlots()) {
+                                    dynStacks.setStackInSlot(slotIndex, stack);
+                                }
+                            }
+                        } catch (CommandSyntaxException e) {
+                            throw new RuntimeException("Error deserializing Curio data for key " + compositeKey, e);
+                        }
+                    }
+                });
+                rs.close();
+                qr.connection().close();
+            } else {
+                // No stored data; perform an initial save.
+                StoreCurios(player, true);
+            }
+        }
         if(ModList.get().isLoaded("sophisticatedbackpacks")){
             // --- Begin Backpack Data Restore ---
             PlayerSync.LOGGER.info("Restoring backpack data for player " + player.getUUID());
@@ -41,7 +111,7 @@ public class ModsSupport {
                                     ResultSet rsBackpack = qrBackpack.resultSet();
                                     if (rsBackpack.next()) {
                                         String serialized = rsBackpack.getString("backpack_nbt");
-                                        String nbtString = VanillaSync.deserializeString(serialized);
+                                        String nbtString = deserializeString(serialized);
                                         CompoundTag backpackNbt = NbtUtils.snbtToStructure(nbtString);
                                         // Update BackpackStorage with the retrieved NBT
                                         net.p3pp3rf1y.sophisticatedbackpacks.backpack.BackpackStorage.get().setBackpackContents(contentsUuid, backpackNbt);
@@ -64,104 +134,13 @@ public class ModsSupport {
         }
     }
 
-    /**
-     * Restores the Curios inventory for a player.
-     * The saved data is stored as a flat map with composite keys ("slotType:index").
-     */
-    public void doCuriosRestore(Player player) throws SQLException {
-        if (ModList.get().isLoaded("curios")) {
-            // Obtain the handler from the API.
-            LazyOptional<ICuriosItemHandler> handlerOpt = CuriosApi.getCuriosInventory(player);
-            JDBCsetUp.QueryResult qr = JDBCsetUp.executeQuery("SELECT curios_item FROM curios WHERE uuid = '" + player.getUUID() + "'");
-            ResultSet rs = qr.resultSet();
-            if (rs.next()) {
-                String curiosData = rs.getString("curios_item");
-                // Parse the stored data (assumes a simple Map.toString() format: "{key=value, key2=value2, ...}")
-                Map<String, String> storedMap = LocalJsonUtil.StringToMap(curiosData);
-                // Clear current Curios slots to avoid conflicts.
-                handlerOpt.ifPresent(handler -> handler.getCurios().forEach((slotType, stacksHandler) -> {
-                    // Use the dynamic stack handler to clear slots.
-                    IDynamicStackHandler dynStacks = stacksHandler.getStacks();
-                    for (int i = 0; i < dynStacks.getSlots(); i++) {
-                        dynStacks.setStackInSlot(i, ItemStack.EMPTY);
-                    }
-                }));
-
-                if (curiosData.length() <= 2) {
-                    rs.close();
-                    qr.connection().close();
-                    return;
-                }
-
-                // Restore each saved item.
-                handlerOpt.ifPresent(handler -> {
-                    for (Map.Entry<String, String> entry : storedMap.entrySet()) {
-                        String compositeKey = entry.getKey(); // Expected format: "slotType:index"
-                        String[] parts = compositeKey.split(":");
-                        if (parts.length != 2) {
-                            continue;
-                        }
-                        String slotType = parts[0];
-                        int slotIndex;
-                        try {
-                            slotIndex = Integer.parseInt(parts[1]);
-                        } catch (NumberFormatException ex) {
-                            continue;
-                        }
-                        String serialized = entry.getValue();
-                        try {
-                            ItemStack stack = VanillaSync.deserializeAndCreatePlaceholderIfNeeded(serialized);
-                            if (handler.getCurios().containsKey(slotType)) {
-                                ICurioStacksHandler stacksHandler = handler.getCurios().get(slotType);
-                                IDynamicStackHandler dynStacks = stacksHandler.getStacks();
-                                if (slotIndex < dynStacks.getSlots()) {
-                                    dynStacks.setStackInSlot(slotIndex, stack);
-                                }
-                            }
-                        } catch (CommandSyntaxException e) {
-                            throw new RuntimeException("Error deserializing Curio data for key " + compositeKey, e);
-                        }
-                    }
-                });
-                rs.close();
-                qr.connection().close();
-            } else {
-                // No stored data; perform an initial save.
-                StoreCurios(player, true);
-            }
-        }
-    }
-
     /**
      * Saves the current Curios inventory for a player.
      * It builds a flat map keyed by "slotType:index" using the dynamic stack handler.
      */
     public void onPlayerLeave(net.minecraft.world.entity.player.Player player) throws SQLException {
         if (ModList.get().isLoaded("curios")) {
-            if (player.isDeadOrDying()) {
-                if (!CuriosCache.curiosCache.isEmpty()) {
-                    UUID playerUuid = player.getUUID();
-                    if (CuriosCache.curiosCache.get(playerUuid) != null) {
-                        CuriosCache.CuriosCacheEntry cacheEntry = CuriosCache.curiosCache.get(playerUuid);
-                        String serializedData = cacheEntry.serializedData;
-                        JDBCsetUp.executeUpdate("UPDATE curios SET curios_item = '" + serializedData + "' WHERE uuid = '" + player.getUUID() + "'");
-                        CuriosCache.curiosCache.remove(playerUuid);
-                        PlayerSync.LOGGER.info("Saving curios data for a dead-or-dying player {} Successfully", player.getStringUUID());
-                    } else {
-                        PlayerSync.LOGGER.error("Failed to find the cache of the logged out dead-or-dying player");
-                        PlayerSync.LOGGER.error("The dead-or-dying player uuid is" + player.getStringUUID());
-                        PlayerSync.LOGGER.error("Using default data...");
-                        StoreCurios(player, false);
-                    }
-                } else {
-                    PlayerSync.LOGGER.warn("No curios cache found while executing a dead-or-dying player logout event.you can ignore this warning if keep-inventory is false");
-                    PlayerSync.LOGGER.warn("The dead-or-dying player uuid is" + player.getStringUUID());
-                    PlayerSync.LOGGER.warn("Using default data...");
-                    StoreCurios(player, false);
-                }
-            } else {
-                StoreCurios(player, false);
-            }
+            StoreCurios(player, false);
         }
     }
 
@@ -176,7 +155,7 @@ public class ModsSupport {
                 for (int i = 0; i < dynStacks.getSlots(); i++) {
                     ItemStack stack = dynStacks.getStackInSlot(i);
                     if (!stack.isEmpty()) {
-                        String serialized = VanillaSync.serialize(VanillaSync.serializeNBT(stack).toString());
+                        String serialized = VanillaSync.serialize(stack.serializeNBT().toString());
                         flatMap.put(slotType + ":" + i, serialized);
                     }
                 }

src/main/java/vip/fubuki/playersync/sync/VanillaSync.java

@@ -1,21 +1,19 @@
 package vip.fubuki.playersync.sync;
 
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
-import com.mojang.serialization.Dynamic;
+
 import net.minecraft.ChatFormatting;
-import net.minecraft.SharedConstants;
-import net.minecraft.core.BlockPos;
-import net.minecraft.nbt.*;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.nbt.NbtUtils;
+import net.minecraft.nbt.StringTag;
+import net.minecraft.nbt.Tag;
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.chat.Style;
-import net.minecraft.resources.ResourceKey;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.PlayerAdvancements;
-import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.util.datafix.DataFixers;
-import net.minecraft.util.datafix.fixes.References;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.effect.MobEffect;
 import net.minecraft.world.effect.MobEffectInstance;
@@ -23,13 +21,10 @@ import net.minecraft.world.entity.player.Inventory;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.Items;
-import net.minecraft.world.level.Level;
 import net.minecraft.world.level.storage.WorldData;
 import net.minecraftforge.event.OnDatapackSyncEvent;
 import net.minecraftforge.event.TickEvent;
-import net.minecraftforge.event.entity.living.LivingDeathEvent;
 import net.minecraftforge.event.entity.player.PlayerEvent;
-import net.minecraftforge.event.entity.player.PlayerNegotiationEvent;
 import net.minecraftforge.event.server.ServerStoppedEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.ModList;
@@ -38,9 +33,6 @@ import net.minecraftforge.registries.ForgeRegistries;
 import net.minecraftforge.server.ServerLifecycleHooks;
 import vip.fubuki.playersync.PlayerSync;
 import vip.fubuki.playersync.config.JdbcConfig;
-import vip.fubuki.playersync.sync.addons.CuriosCache;
-import vip.fubuki.playersync.sync.addons.MekanismSupport;
-import vip.fubuki.playersync.sync.addons.ModsSupport;
 import vip.fubuki.playersync.util.JDBCsetUp;
 import vip.fubuki.playersync.util.LocalJsonUtil;
 import vip.fubuki.playersync.util.PSThreadPoolFactory;
@@ -51,29 +43,20 @@ import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.util.*;
-import java.util.concurrent.*;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 @Mod.EventBusSubscriber
 public class VanillaSync {
 
-    public static void register() {
-    }
+    public static void register() {}
 
-    // FIX: Replace unbounded CachedThreadPool with a bounded ThreadPoolExecutor.
-    // CachedThreadPool creates unlimited threads — with many players and slow DB queries,
-    // thread count can explode to 25000+ causing memory leaks and server crashes.
-    // Bounded pool: 2 core threads, max 8 threads, 30s keepalive, 256-task queue.
-    // If the queue is full, tasks run on the calling thread (CallerRunsPolicy) which
-    // provides natural backpressure instead of creating more threads.
-    static ExecutorService executorService = new ThreadPoolExecutor(
-            2,                          // core pool size
-            8,                          // maximum pool size
-            30L, TimeUnit.SECONDS,      // idle thread keepalive
-            new LinkedBlockingQueue<>(256),  // bounded work queue
-            new PSThreadPoolFactory("PlayerSync"),
-            new ThreadPoolExecutor.CallerRunsPolicy()  // backpressure: run on caller thread if queue full
-    );
+    static ExecutorService executorService = Executors.newCachedThreadPool(new PSThreadPoolFactory("PlayerSync"));
 
     @SubscribeEvent
     public static void onDataPackSyncEvent(OnDatapackSyncEvent event) throws SQLException, IOException {
@@ -159,212 +142,106 @@ public class VanillaSync {
         }
     }
 
-    public static void doPlayerConnect(PlayerNegotiationEvent event) {
-        try {
-            String player_uuid = event.getProfile().getId().toString();
-            PlayerSync.LOGGER.info("Detected connection from player" + player_uuid + ",starting checking");
-            boolean online;
-            int lastServer;
+    public static void doPlayerJoin(PlayerEvent.PlayerLoggedInEvent event) throws SQLException, CommandSyntaxException, IOException {
+        String player_uuid = event.getEntity().getUUID().toString();
+        PlayerSync.LOGGER.info("Starting synchronization for player " + player_uuid);
 
-            // First query: check basic player data and check whether player can join into server.
-            JDBCsetUp.QueryResult qr1 = JDBCsetUp.executeQuery("SELECT online, last_server FROM player_data WHERE uuid='" + player_uuid + "'");
-
-            try (ResultSet rs1 = qr1.resultSet()) {
-                if (!rs1.next()) {
-                    PlayerSync.LOGGER.info("A new-player connection detected");
-                    qr1.connection().close();
-                    return;
-                }
-                online = rs1.getBoolean("online");
-                lastServer = rs1.getInt("last_server");
-                qr1.connection().close();
-            }
-
-            // Second query: Check if player is already online on another server
-            if (JdbcConfig.KICK_WHEN_ALREADY_ONLINE.get() && online && lastServer != JdbcConfig.SERVER_ID.get()) {
-                JDBCsetUp.QueryResult qr2 = JDBCsetUp.executeQuery("SELECT last_update,enable FROM server_info WHERE id='" + lastServer + "'");
-                try (ResultSet rs2 = qr2.resultSet()) {
-                    if (rs2.next()) {
-                        long last_update = rs2.getLong("last_update");
-                        boolean enable = rs2.getBoolean("enable");
-                        if (enable && System.currentTimeMillis() < last_update + 300000.0) {
-                            event.getConnection().disconnect(Component.translatableWithFallback("playersync.already_online","You can't join more than one synchronization server at the same time."));
-                            qr2.connection().close();
-                            return;
-                        }
-                        JDBCsetUp.executeUpdate("UPDATE server_info SET enable= '0' WHERE id=" + lastServer);
-                    }
-                    qr2.connection().close();
-                }
-            }
-        } catch (Exception e) {
-            PlayerSync.LOGGER.error("SqlException detected!", e);
-            event.getConnection().disconnect(Component.translatableWithFallback("playersync.sqlexception","SqlException detected!Connection lost,please contact with your admin."));
-        }
-    }
-
-    // Use string uuid as key
-    public static Set<String> deadPlayerWhileLogging = ConcurrentHashMap.newKeySet();
-    public static Set<String> syncNotCompletedPlayer = ConcurrentHashMap.newKeySet();
-
-    public static void doPlayerJoin(PlayerEvent.PlayerLoggedInEvent event) {
-        ServerPlayer joinedPlayer = (ServerPlayer) event.getEntity();
-        String player_uuid = joinedPlayer.getUUID().toString();
-        if (joinedPlayer.isDeadOrDying()) {
-            deadPlayerWhileLogging.add(player_uuid);
-            joinedPlayer.removeTag("player_synced");
-
-            // Simulate normal death behavior
-            MinecraftServer server = joinedPlayer.getServer();
-            if (server != null) {
-                ResourceKey<Level> respawnLevel = joinedPlayer.getRespawnDimension();
-                BlockPos respawnPos = joinedPlayer.getRespawnPosition();
-                double respawnX;
-                double respawnY;
-                double respawnZ;
-                if (respawnPos != null && respawnLevel != null) {
-                    ServerLevel level = server.getLevel(respawnLevel);
-                    respawnX = respawnPos.getX();
-                    respawnY = respawnPos.getY();
-                    respawnZ = respawnPos.getZ();
-                    if (level != null) {
-                        joinedPlayer.teleportTo(level, respawnX, respawnY + 1, respawnZ, 0, 0);
-                    }
-                } else {
-                    PlayerSync.LOGGER.debug("Player " + player_uuid + " has no respawn point");
-                }
-            } else {
-                PlayerSync.LOGGER.warn("Trying to get server,but got a null");
-            }
-
-            joinedPlayer.setHealth(1);
-            try {
-                JDBCsetUp.executeUpdate("UPDATE server_info SET last_update=" + System.currentTimeMillis() + " WHERE id=" + JdbcConfig.SERVER_ID.get());
-                JDBCsetUp.executeUpdate("UPDATE player_data SET online= '1',last_server=" + JdbcConfig.SERVER_ID.get() + " WHERE uuid='" + player_uuid + "'");
-            } catch (SQLException e) {
-                PlayerSync.LOGGER.error("An error occurred while trying to execute a dead or dying player" + e.getMessage());
-            }
-            joinedPlayer.connection.disconnect(Component.translatableWithFallback("playersync.wrong_entity_status","An error occurred while creating playerEntity in the world,please login again."));
+        // First query: check basic player data
+        JDBCsetUp.QueryResult qr1 = JDBCsetUp.executeQuery("SELECT online, last_server FROM player_data WHERE uuid='" + player_uuid + "'");
+        ResultSet rs1 = qr1.resultSet();
+        ServerPlayer serverPlayer = (ServerPlayer) event.getEntity();
+        if (!rs1.next()){
+            store(event.getEntity(), true);
             return;
         }
+        boolean online = rs1.getBoolean("online");
+        int lastServer = rs1.getInt("last_server");
 
-        try {
-            PlayerSync.LOGGER.info("Starting synchronization for player " + player_uuid);
+        // Second query: retrieve full player data
+        JDBCsetUp.QueryResult qr2 = JDBCsetUp.executeQuery("SELECT * FROM player_data WHERE uuid='" + player_uuid + "'");
+        ResultSet rs2 = qr2.resultSet();
 
-            // First query: check basic player data
-            syncNotCompletedPlayer.add(player_uuid);
-            JDBCsetUp.QueryResult qr1 = JDBCsetUp.executeQuery("SELECT online, last_server FROM player_data WHERE uuid='" + player_uuid + "'");
-            ResultSet rs1 = qr1.resultSet();
-            ServerPlayer serverPlayer = (ServerPlayer) event.getEntity();
-
-            // Mod support
-            ModsSupport modsSupport = new ModsSupport();
-            modsSupport.doCuriosRestore(serverPlayer);
-
-            if (!rs1.next()) {
-                store(event.getEntity(), true);
-                JDBCsetUp.executeUpdate("UPDATE server_info SET last_update=" + System.currentTimeMillis() + " WHERE id=" + JdbcConfig.SERVER_ID.get());
-                JDBCsetUp.executeUpdate("UPDATE player_data SET online= '1',last_server=" + JdbcConfig.SERVER_ID.get() + " WHERE uuid='" + player_uuid + "'");
-                rs1.close();
-                qr1.close();
-                PlayerSync.LOGGER.info("New player detected,init completed.");
-                syncNotCompletedPlayer.remove(player_uuid);
-                return;
+        // Check if player is already online on another server
+        if (online && lastServer != JdbcConfig.SERVER_ID.get()) {
+            JDBCsetUp.QueryResult qr3 = JDBCsetUp.executeQuery("SELECT last_update,enable FROM server_info WHERE id='" + lastServer + "'");
+            ResultSet rs3 = qr3.resultSet();
+            if (rs3.next()){
+                long last_update = rs3.getLong("last_update");
+                boolean enable = rs3.getBoolean("enable");
+                if (enable && System.currentTimeMillis() < last_update + 300000.0){
+                    event.getEntity().removeTag("player_synced");
+                    serverPlayer.connection.disconnect(Component.translatable("playersync.already_online"));
+                    return;
+                }
+                JDBCsetUp.executeUpdate("UPDATE server_info SET enable= '0' WHERE id=" + lastServer);
             }
-
-            // Second query: retrieve full player data
-            JDBCsetUp.QueryResult qr2 = JDBCsetUp.executeQuery("SELECT * FROM player_data WHERE uuid='" + player_uuid + "'");
-            ResultSet rs2 = qr2.resultSet();
-
-            JDBCsetUp.executeUpdate("UPDATE server_info SET last_update=" + System.currentTimeMillis() + " WHERE id=" + JdbcConfig.SERVER_ID.get());
-            JDBCsetUp.executeUpdate("UPDATE player_data SET online= '1',last_server=" + JdbcConfig.SERVER_ID.get() + " WHERE uuid='" + player_uuid + "'");
-
-            if (rs2.next()) {
-                // Restore basic attributes
-                int health = rs2.getInt("health");
-                if (health <= 0) {
-                    serverPlayer.setHealth(1);
-                } else {
-                    serverPlayer.setHealth(health);
-                }
-                serverPlayer.getFoodData().setFoodLevel(rs2.getInt("food_level"));
-
-                setXpForPlayer(serverPlayer, rs2.getInt("xp"));
-                serverPlayer.setScore(rs2.getInt("score"));
-
-                // Restore left-hand item
-                String leftHandEncoded = rs2.getString("left_hand");
-                serverPlayer.setItemInHand(InteractionHand.OFF_HAND,
-                        deserializeAndCreatePlaceholderIfNeeded(leftHandEncoded));
-
-                // Restore cursor item
-                String cursorsEncoded = rs2.getString("cursors");
-                serverPlayer.containerMenu.setCarried(
-                        deserializeAndCreatePlaceholderIfNeeded(cursorsEncoded));
-
-                // Restore armor
-                String armor_data = rs2.getString("armor");
-                if (armor_data.length() > 2) {
-                    Map<Integer, String> equipment = LocalJsonUtil.StringToEntryMap(armor_data);
-                    for (Map.Entry<Integer, String> entry : equipment.entrySet()) {
-                        serverPlayer.getInventory().armor.set(entry.getKey(), deserializeAndCreatePlaceholderIfNeeded(entry.getValue()));
-                    }
-                }
-
-                // Restore inventory
-                Map<Integer, String> inventory = LocalJsonUtil.StringToEntryMap(rs2.getString("inventory"));
-                for (Map.Entry<Integer, String> entry : inventory.entrySet()) {
-                    serverPlayer.getInventory().setItem(entry.getKey(), deserializeAndCreatePlaceholderIfNeeded(entry.getValue()));
-                }
-
-                // Restore Ender Chest
-                Map<Integer, String> ender_chest = LocalJsonUtil.StringToEntryMap(rs2.getString("enderchest"));
-                for (Map.Entry<Integer, String> entry : ender_chest.entrySet()) {
-                    serverPlayer.getEnderChestInventory().setItem(entry.getKey(), deserializeAndCreatePlaceholderIfNeeded(entry.getValue()));
-                }
-
-                // Restore Effects
-                String effectData = rs2.getString("effects");
-                if (effectData.length() > 2) {
-                    serverPlayer.removeAllEffects();
-                    Map<Integer, String> effects = LocalJsonUtil.StringToEntryMap(effectData);
-                    for (Map.Entry<Integer, String> entry : effects.entrySet()) {
-                        CompoundTag effectTag = NbtUtils.snbtToStructure(deserializeString(entry.getValue()));
-                        MobEffectInstance mobEffectInstance = MobEffectInstance.load(effectTag);
-                        if (mobEffectInstance != null) {
-                            serverPlayer.addEffect(mobEffectInstance);
-                        }
-                    }
-                }
-            }
-
-            modsSupport.doBackPackRestore(serverPlayer);
-
-            MekanismSupport.restorePersonalChestData(serverPlayer);
-
-            serverPlayer.addTag("player_synced");
-
-            rs2.close();
-            qr2.close();
-            rs1.close();
-            qr1.close();
-            PlayerSync.LOGGER.info("Sync data for player {} completed.", player_uuid);
-            syncNotCompletedPlayer.remove(player_uuid);
-        } catch (Exception e) {
-            PlayerSync.LOGGER.error("Internal Exception detected!", e);
-            syncNotCompletedPlayer.remove(player_uuid);
+            rs3.close();
         }
-    }
+        JDBCsetUp.executeUpdate("UPDATE server_info SET last_update=" + System.currentTimeMillis() + " WHERE id=" + JdbcConfig.SERVER_ID.get());
+        JDBCsetUp.executeUpdate("UPDATE player_data SET online= '1',last_server=" + JdbcConfig.SERVER_ID.get() + " WHERE uuid='" + player_uuid + "'");
 
-    @SubscribeEvent
-    public static void onPlayerConnect(PlayerNegotiationEvent event) {
-        executorService.submit(() -> {
-            try {
-                doPlayerConnect(event);
-            } catch (Exception e) {
-                e.printStackTrace();
+        if (rs2.next()) {
+            // Restore basic attributes
+            serverPlayer.setHealth(rs2.getInt("health"));
+            serverPlayer.getFoodData().setFoodLevel(rs2.getInt("food_level"));
+            serverPlayer.totalExperience = 0;
+            serverPlayer.experienceLevel = 0;
+            serverPlayer.experienceProgress = 0;
+            serverPlayer.giveExperiencePoints(rs2.getInt("xp"));
+            serverPlayer.setScore(rs2.getInt("score"));
+
+            // Restore left-hand item
+            String leftHandEncoded = rs2.getString("left_hand");
+            serverPlayer.setItemInHand(InteractionHand.OFF_HAND,
+                    deserializeAndCreatePlaceholderIfNeeded(leftHandEncoded));
+
+            // Restore cursor item
+            String cursorsEncoded = rs2.getString("cursors");
+            serverPlayer.containerMenu.setCarried(
+                    deserializeAndCreatePlaceholderIfNeeded(cursorsEncoded));
+
+            // Restore armor
+            String armor_data = rs2.getString("armor");
+            if (armor_data.length() > 2) {
+                Map<Integer, String> equipment = LocalJsonUtil.StringToEntryMap(armor_data);
+                for (Map.Entry<Integer, String> entry : equipment.entrySet()) {
+                    serverPlayer.getInventory().armor.set(entry.getKey(), deserializeAndCreatePlaceholderIfNeeded(entry.getValue()));
+                }
             }
-        });
+
+            // Restore inventory
+            Map<Integer, String> inventory = LocalJsonUtil.StringToEntryMap(rs2.getString("inventory"));
+            for (Map.Entry<Integer, String> entry : inventory.entrySet()) {
+                serverPlayer.getInventory().setItem(entry.getKey(), deserializeAndCreatePlaceholderIfNeeded(entry.getValue()));
+            }
+
+            // Restore Ender Chest
+            Map<Integer, String> ender_chest = LocalJsonUtil.StringToEntryMap(rs2.getString("enderchest"));
+            for (Map.Entry<Integer, String> entry : ender_chest.entrySet()) {
+                serverPlayer.getEnderChestInventory().setItem(entry.getKey(), deserializeAndCreatePlaceholderIfNeeded(entry.getValue()));
+            }
+
+            // Restore Effects
+            String effectData = rs2.getString("effects");
+            if (effectData.length() > 2) {
+                serverPlayer.removeAllEffects();
+                Map<Integer, String> effects = LocalJsonUtil.StringToEntryMap(effectData);
+                for (Map.Entry<Integer, String> entry : effects.entrySet()) {
+                    CompoundTag effectTag = NbtUtils.snbtToStructure(deserializeString(entry.getValue()));
+                    MobEffectInstance mobEffectInstance = MobEffectInstance.load(effectTag);
+                    if (mobEffectInstance != null) {
+                        serverPlayer.addEffect(mobEffectInstance);
+                    }
+                }
+            }
+        }
+
+        // Mod support
+        ModsSupport modsSupport = new ModsSupport();
+        modsSupport.onPlayerJoin(serverPlayer);
+        serverPlayer.addTag("player_synced");
+
+        rs2.close();
     }
 
     @SubscribeEvent
@@ -379,7 +256,7 @@ public class VanillaSync {
     }
 
     // deserialize item and potentially create placeholders
-    public static ItemStack deserializeAndCreatePlaceholderIfNeeded(String serializedNbt)
+    private static ItemStack deserializeAndCreatePlaceholderIfNeeded(String serializedNbt)
             throws CommandSyntaxException {
         if (serializedNbt == null || serializedNbt.isEmpty() || serializedNbt.equals("B64:e30=")) {
             // Check for empty NBT (Base64 encoded '{}')
@@ -387,7 +264,7 @@ public class VanillaSync {
         }
 
         String nbtString = deserializeString(serializedNbt);
-        CompoundTag compoundTag = snbtToFixedCompoundTag(nbtString);
+        CompoundTag compoundTag = NbtUtils.snbtToStructure(nbtString);
 
         if (compoundTag == null || compoundTag.isEmpty() || !compoundTag.contains("id", Tag.TAG_STRING)) {
             return ItemStack.EMPTY; // Invalid or empty tag
@@ -466,7 +343,7 @@ public class VanillaSync {
         loreList.add(StringTag.valueOf(Component.Serializer.toJson(Component.literal(""))));
 
         String placeholderItemDescriptionOverride = JdbcConfig.ITEM_PLACEHOLDER_DESCRIPTION_OVERRIDE.get();
-        String placeholderItemDescriptionLines = placeholderItemDescriptionOverride != null && !placeholderItemDescriptionOverride.isBlank()
+        String placeholderItemDescriptionLines = placeholderItemDescriptionOverride != null && ! placeholderItemDescriptionOverride.isBlank()
                 ? placeholderItemDescriptionOverride
                 : Component.translatable("playersync.item_placeholder_description").getString();
 
@@ -480,26 +357,9 @@ public class VanillaSync {
         return placeholder;
     }
 
-    public static CompoundTag snbtToFixedCompoundTag(String nbtString) throws CommandSyntaxException {
-        CompoundTag parsedTag = TagParser.parseTag(nbtString);
-
-        int currentDataVersion = SharedConstants.getCurrentVersion().getDataVersion().getVersion();
-        int snbtDataVersion = NbtUtils.getDataVersion(parsedTag, 500);
-
-        Dynamic<Tag> dynamicTagInput = new Dynamic<>(NbtOps.INSTANCE, parsedTag);
-
-        Dynamic<Tag> updatedDynamicTag = DataFixers.getDataFixer().update(
-                References.ITEM_STACK,
-                dynamicTagInput,
-                snbtDataVersion,
-                currentDataVersion);
-        return (CompoundTag) updatedDynamicTag.getValue();
-    }
-
     /**
      * Deserializes a string from the database back into an NBT string.
      * Handles both the new Base64 format (prefixed with "B64:") and the old custom format.
-     *
      * @param encoded The string retrieved from the database.
      * @return The deserialized NBT string.
      */
@@ -525,7 +385,6 @@ public class VanillaSync {
      * Serializes an NBT string for database storage.
      * Uses Base64 encoding by default (prefixed with "B64:").
      * If USE_LEGACY_SERIALIZATION config is true, uses the old custom replacement format.
-     *
      * @param object The NBT string to serialize.
      * @return The serialized string.
      */
@@ -534,10 +393,10 @@ public class VanillaSync {
         if (JdbcConfig.USE_LEGACY_SERIALIZATION.get()) {
             // Use old custom replacement logic
             return object.replace(",", "|")
-                    .replace("\"", "^")
-                    .replace("{", "<")
-                    .replace("}", ">")
-                    .replace("'", "~");
+                         .replace("\"", "^")
+                         .replace("{", "<")
+                         .replace("}", ">")
+                         .replace("'", "~");
         }
 
         // Base64 encode with a "B64:" marker for new data
@@ -574,27 +433,16 @@ public class VanillaSync {
 
     @SubscribeEvent
     public static void onPlayerLogout(PlayerEvent.PlayerLoggedOutEvent event) throws SQLException {
-        String player_uuid = event.getEntity().getUUID().toString();
-        if (deadPlayerWhileLogging.contains(player_uuid)) {
-            PlayerSync.LOGGER.warn("A dead or dying player was kicked,which uuid is:{}", player_uuid);
-            JDBCsetUp.executeUpdate("UPDATE player_data SET online= '0' WHERE uuid='" + player_uuid + "'");
-            deadPlayerWhileLogging.remove(player_uuid);
-        } else if (syncNotCompletedPlayer.contains(player_uuid)) {
-            PlayerSync.LOGGER.warn("A player logged out with uncompleted sync data,which uuid is:{}.For the safety,the new data won't be saved", player_uuid);
-            JDBCsetUp.executeUpdate("UPDATE player_data SET online= '0' WHERE uuid='" + player_uuid + "'");
-            syncNotCompletedPlayer.remove(player_uuid);
-        } else {
-            // Mod support
-            ModsSupport modsSupport = new ModsSupport();
-            modsSupport.onPlayerLeave(event.getEntity());
-            executorService.submit(() -> {
-                try {
-                    doPlayerLogout(event);
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-            });
-        }
+        // Mod support
+        ModsSupport modsSupport = new ModsSupport();
+        modsSupport.onPlayerLeave(event.getEntity());
+        executorService.submit(() -> {
+            try {
+                doPlayerLogout(event);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        });
     }
 
     // Helper function to get the NBT string to be saved
@@ -605,28 +453,16 @@ public class VanillaSync {
             return itemStack.getTag().getString("playersync:original_item_nbt");
         } else {
             // It's a normal item or empty, serialize its current NBT
-            return serialize(serializeNBT(itemStack).toString());
+            return serialize(itemStack.serializeNBT().toString());
         }
     }
 
-    public static CompoundTag serializeNBT(ItemStack itemStack) {
-        if (itemStack == null || itemStack.isEmpty()) {
-            return new CompoundTag();
-        }
-        // Serialize the ItemStack to NBT
-        CompoundTag compoundTag = new CompoundTag();
-        itemStack.save(compoundTag);
-        // Adding data version to allow newer version of Minecraft to properly update the itemstack from the db
-        NbtUtils.addCurrentDataVersion(compoundTag);
-        return compoundTag;
-    }
-
     public static void store(Player player, boolean init) throws SQLException, IOException {
         String player_uuid = player.getUUID().toString();
         PlayerSync.LOGGER.info("Storing data for player " + player_uuid + " (init=" + init + ")");
 
         // Basic Attributes
-        int XP = getTotalExperience(player);
+        int XP = player.totalExperience;
         int score = player.getScore();
         int food_level = player.getFoodData().getFoodLevel();
         int health = (int) player.getHealth();
@@ -654,12 +490,10 @@ public class VanillaSync {
             ender_chest.put(i, getNbtForStorage(player.getEnderChestInventory().getItem(i)));
         }
 
-        if (ModList.get().isLoaded("sophisticatedbackpacks")) {
+        if(ModList.get().isLoaded("sophisticatedbackpacks")){
             ModsSupport.storeSophisticatedBackpacks(player);
         }
 
-        MekanismSupport.savePersonalChestData(player);
-
         // Effects
         Map<MobEffect, MobEffectInstance> effects = player.getActiveEffectsMap();
         Map<Integer, String> effectMap = new HashMap<>();
@@ -674,7 +508,7 @@ public class VanillaSync {
         if (JdbcConfig.SYNC_ADVANCEMENTS.get()) {
             File gameDir = Objects.requireNonNull(player.getServer()).getServerDirectory();
             final MinecraftServer server = ServerLifecycleHooks.getCurrentServer();
-            if (server != null && server.isDedicatedServer()) {
+            if (server != null && server.isDedicatedServer() ) {
                 PlayerSync.LOGGER.trace("Reading dedicated server advancements");
                 advancements = new File(gameDir, getSyncWorldForServer() + "/advancements" + "/" + player_uuid + ".json");
             } else {
@@ -705,7 +539,7 @@ public class VanillaSync {
 
         // SQL Operation for player data
         if (init) {
-            JDBCsetUp.executeUpdate("INSERT INTO player_data (uuid,armor,inventory,enderchest,advancements,effects,xp,food_level,health,score,left_hand,cursors,online) VALUES ('" + player_uuid + "','" + equipment + "','" + inventoryMap + "','" + ender_chest + "','" + json + "','" + effectMap + "','" + XP + "','" + food_level + "','" + health + "','" + score + "','" + left_hand + "','" + cursors + "',online=true)");
+            JDBCsetUp.executeUpdate("INSERT INTO player_data (uuid,armor,inventory,enderchest,advancements,effects,xp,food_level,health,score,left_hand,cursors,online) VALUES ('" + player_uuid + "','" + equipment + "','" + inventoryMap + "','" + ender_chest + "','" + advancements + "','" + effectMap + "','" + XP + "','" + food_level + "','" + health + "','" + score + "','" + left_hand + "','" + cursors + "',online=true)");
         } else {
             JDBCsetUp.executeUpdate("UPDATE player_data SET inventory = '" + inventoryMap + "',armor='" + equipment + "' ,xp='" + XP + "',effects='" + effectMap + "',enderchest='" + ender_chest + "',score='" + score + "',food_level='" + food_level + "',health='" + health + "',advancements='" + json + "',left_hand='" + left_hand + "',cursors='" + cursors + "' WHERE uuid = '" + player_uuid + "'");
         }
@@ -756,8 +590,6 @@ public class VanillaSync {
     // New fields for auto-save
     private static int autoSaveTickCounter = 0;
     private static final int AUTO_SAVE_INTERVAL_TICKS = 1200; // Every Minute
-    private static int autoCleanCuriosCacheTickCounter = 0;
-    private static final int AUTO_CLEAN_CURIOS_CACHE_INTERVAL_TICKS = 36000; // Every 30 min
 
     //AutoSave
     @SubscribeEvent
@@ -765,7 +597,6 @@ public class VanillaSync {
         // Run at the end phase to avoid interfering with game logic
         if (event.phase == TickEvent.Phase.END) {
             autoSaveTickCounter++;
-            autoCleanCuriosCacheTickCounter++;
             if (autoSaveTickCounter >= AUTO_SAVE_INTERVAL_TICKS) {
                 autoSaveTickCounter = 0;
                 // Retrieve the current server instance
@@ -788,82 +619,10 @@ public class VanillaSync {
                                 PlayerSync.LOGGER.error("Error auto-saving Curios data for player " + player.getUUID(), e);
                             }
                         });
-                        executorService.submit(() -> {
-                            try {
-                                MekanismSupport.savePersonalChestData(player);
-                            } catch (Exception e) {
-                                PlayerSync.LOGGER.error("Error auto-saving Mekanism data for player " + player.getUUID(), e);
-                            }
-                        });
+
                     }
                 }
             }
-            if (autoCleanCuriosCacheTickCounter >= AUTO_CLEAN_CURIOS_CACHE_INTERVAL_TICKS) {
-                autoCleanCuriosCacheTickCounter = 0;
-                executorService.submit(() -> {
-                    try {
-                        CuriosCache.RemoveExpiredCuriosCache();
-                    } catch (Exception e) {
-                        PlayerSync.LOGGER.error("An error occurred while cleaning curios cache:" + e.getMessage());
-                    }
-                });
-            }
-        }
-    }
-
-    private static void setXpForPlayer(ServerPlayer serverPlayer, int databaseXp) {
-        // Don't use giveExperience() as it has several side-effects:
-        // triggers an event, sends network packets, increases the score, ...
-        serverPlayer.totalExperience = databaseXp;
-        serverPlayer.experienceLevel = 0;
-        serverPlayer.experienceProgress = 0;
-
-        int xpForLevel;
-
-        while (databaseXp >= (xpForLevel = serverPlayer.getXpNeededForNextLevel())) {
-            databaseXp -= xpForLevel;
-            serverPlayer.experienceLevel++;
-        }
-
-        serverPlayer.experienceProgress = serverPlayer.experienceLevel > 0
-                ? (float) databaseXp / serverPlayer.getXpNeededForNextLevel()
-                : 0f;
-
-        PlayerSync.LOGGER.debug("Giving player "
-                + serverPlayer.experienceLevel + " levels and "
-                + serverPlayer.experienceProgress * 100 + "% experience progress, calculated from "
-                + serverPlayer.totalExperience + " XP.");
-    }
-
-    private static int getTotalExperience(final Player player) {
-        int level = player.experienceLevel;
-        int totalXp = 0;
-
-        // Calculate total XP for completed levels
-        if (level > 30) {
-            totalXp = (int) (4.5 * Math.pow(level, 2) - 162.5 * level + 2220);
-        } else if (level > 15) {
-            totalXp = (int) (2.5 * Math.pow(level, 2) - 40.5 * level + 360);
-        } else {
-            totalXp = level * level + 6 * level;
-        }
-
-        // Add partial level progress
-        totalXp += Math.round(player.getXpNeededForNextLevel() * player.experienceProgress);
-
-        PlayerSync.LOGGER.debug("Experience calcuation for "
-                + player.experienceLevel + " levels and "
-                + player.experienceProgress * 100 + "% experience progress yields "
-                + totalXp + " XP.");
-
-        return totalXp;
-    }
-
-    @SubscribeEvent
-    //Don't know what will happen if a fake player is killed,need more test.
-    public static void onPlayerDeath(LivingDeathEvent event) {
-        if (event.getEntity() instanceof ServerPlayer player && !deadPlayerWhileLogging.contains(event.getEntity().getUUID().toString())) {
-            CuriosCache.tryStoreCuriosToCache(player);
         }
     }
 }

src/main/java/vip/fubuki/playersync/sync/addons/CuriosCache.java

@@ -1,122 +0,0 @@
-package vip.fubuki.playersync.sync.addons;
-
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.GameRules;
-import net.minecraftforge.common.util.LazyOptional;
-import net.minecraftforge.fml.ModList;
-import top.theillusivec4.curios.api.CuriosApi;
-import top.theillusivec4.curios.api.type.capability.ICuriosItemHandler;
-import top.theillusivec4.curios.api.type.inventory.IDynamicStackHandler;
-import vip.fubuki.playersync.PlayerSync;
-import vip.fubuki.playersync.sync.VanillaSync;
-
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-
-public class CuriosCache {
-    private static final long CACHE_EXPIRY_MS = 3600000;
-    public static final ConcurrentHashMap<UUID, CuriosCacheEntry> curiosCache = new ConcurrentHashMap<>();
-
-    public static class CuriosCacheEntry {
-        final long timeStamp;
-        final String serializedData;
-
-        CuriosCacheEntry(String data) {
-            this.timeStamp = System.currentTimeMillis();
-            this.serializedData = data;
-        }
-
-        boolean isExpired() {
-            return System.currentTimeMillis() - timeStamp > CACHE_EXPIRY_MS;
-        }
-    }
-
-    //If player logged out by "Title Screen" button,you will not be able to get the handlerOpt,and it will make the curios inventory sync failed.
-    //Create a method to store temporary curios data when player is dead.
-    //Then check player status in the logged out event,and take a normal sync if player is alive.
-    //If player is dead or dying,the cache will be used to prevent the empty data from the failure of getting handlerOpt.
-    public static void tryStoreCuriosToCache(net.minecraft.world.entity.player.Player player) {
-        if (!ModList.get().isLoaded("curios") || !CuriosCache.isKeepInventoryActive(player)) {
-            return;
-        }
-
-        try {
-            LazyOptional<ICuriosItemHandler> handlerOpt = CuriosApi.getCuriosInventory(player);
-            if (!handlerOpt.isPresent() || handlerOpt.resolve().isEmpty()) {
-                PlayerSync.LOGGER.error("Obtain the curios api failed,cannot create the cache.");
-                return;
-            }
-
-            ICuriosItemHandler handler = handlerOpt.resolve().get();
-            String serializedData = serializeCuriosInventory(handler);
-
-            if (serializedData.startsWith("{}")) {
-                PlayerSync.LOGGER.debug("No curios data found,skipping the step of creating cache");
-                return;
-            }
-
-            UUID playerUuid = player.getUUID();
-            curiosCache.put(playerUuid, new CuriosCacheEntry(serializedData));
-        } catch (Exception e) {
-            PlayerSync.LOGGER.error("An error occurred while creating curios cache:" + e.getMessage());
-        }
-    }
-
-    private static String serializeCuriosInventory(ICuriosItemHandler handler) {
-        Map<String, String> flatMap = new HashMap<>();
-        try {
-            handler.getCurios().forEach((slotType, stacksHandler) -> {
-                IDynamicStackHandler dynStacks = stacksHandler.getStacks();
-                for (int i = 0; i < dynStacks.getSlots(); i++) {
-                    ItemStack stack = dynStacks.getStackInSlot(i);
-                    if (!stack.isEmpty()) {
-                        String serialized = VanillaSync.serialize(VanillaSync.serializeNBT(stack).toString());
-                        flatMap.put(slotType + ":" + i, serialized);
-                    }
-                }
-            });
-        } catch (Exception e) {
-            PlayerSync.LOGGER.error("Failed to serialize curios data:" + e.getMessage());
-        }
-        return flatMap.isEmpty() ? "{}" : flatMap.toString();
-    }
-
-    public static boolean isKeepInventoryActive(Player player) {
-        MinecraftServer server = player.getServer();
-        if (server == null) {
-            PlayerSync.LOGGER.error("Trying to get the gamerule(KeepInventory),but server is null");
-            return false;
-        }
-        return server.getGameRules().getBoolean(GameRules.RULE_KEEPINVENTORY);
-    }
-
-    public static void RemoveExpiredCuriosCache() {
-        long startMs = System.currentTimeMillis();
-        int cacheSize = curiosCache.size();
-
-        if (cacheSize == 0) {
-            PlayerSync.LOGGER.debug("No curios caches,skipping cleaning");
-            return;
-        }
-
-        int removed = 0;
-        Iterator<Map.Entry<UUID, CuriosCacheEntry>> iterator = curiosCache.entrySet().iterator();
-
-        while (iterator.hasNext()) {
-            if (iterator.next().getValue().isExpired()) {
-                iterator.remove();;
-                removed ++;
-            }
-        }
-
-        if (removed > 0) {
-            PlayerSync.LOGGER.info("Cleaned {} curios cache(s),{} left,took {} Ms",
-                    removed, curiosCache.size(), System.currentTimeMillis() - startMs);
-        }
-    }
-}

src/main/java/vip/fubuki/playersync/sync/addons/MekanismSupport.java

@@ -1,221 +0,0 @@
-package vip.fubuki.playersync.sync.addons;
-
-import mekanism.api.inventory.IInventorySlot;
-import mekanism.common.lib.inventory.personalstorage.AbstractPersonalStorageItemInventory;
-import mekanism.common.lib.inventory.personalstorage.PersonalStorageManager;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.ListTag;
-import net.minecraft.nbt.Tag;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.fml.ModList;
-import vip.fubuki.playersync.PlayerSync;
-import vip.fubuki.playersync.config.JdbcConfig;
-import vip.fubuki.playersync.util.JDBCsetUp;
-
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.*;
-
-public class MekanismSupport {
-
-    private static final String MEK_DATA = "mekData";
-    private static final String PERSONAL_STORAGE_ID = "personalStorageId";
-
-    /**
-     * Call PersonalStorageManager.getInventoryIfPresent(stack) directly.
-     */
-    static Optional<AbstractPersonalStorageItemInventory> getInventoryIfPresent(ItemStack stack) {
-        try {
-            return PersonalStorageManager.getInventoryIfPresent(stack);
-        } catch (Exception e) {
-            PlayerSync.LOGGER.error("Error calling PersonalStorageManager.getInventoryIfPresent", e);
-            return Optional.empty();
-        }
-    }
-
-    static Optional<AbstractPersonalStorageItemInventory> getInventoryFor(ItemStack stack) {
-        try {
-            return PersonalStorageManager.getInventoryFor(stack);
-        } catch (Exception e) {
-            PlayerSync.LOGGER.error("Error calling PersonalStorageManager.getInventoryFor", e);
-            return Optional.empty();
-        }
-    }
-
-    /**
-     * Get inventory slots directly from PersonalStorageInventory.
-     */
-    static List<IInventorySlot> getInventorySlots(AbstractPersonalStorageItemInventory inventory) {
-        try {
-            return inventory.getInventorySlots(null);
-        } catch (Exception e) {
-            PlayerSync.LOGGER.error("Error calling getInventorySlots", e);
-            return Collections.emptyList();
-        }
-    }
-
-    /**
-     * Collect all personal chest ItemStacks from a player's inventory + ender chest.
-     * Returns map: personalStorageId UUID string → ItemStack
-     */
-    public static Map<String, ItemStack> collectPersonalChestItems(Player player) {
-        Map<String, ItemStack> result = new LinkedHashMap<>();
-        List<ItemStack> allItems = new ArrayList<>();
-
-        // Main inventory
-        for (int i = 0; i < player.getInventory().items.size(); i++) {
-            allItems.add(player.getInventory().items.get(i));
-        }
-        // Armor
-        for (int i = 0; i < player.getInventory().armor.size(); i++) {
-            allItems.add(player.getInventory().armor.get(i));
-        }
-        // Off-hand
-        allItems.add(player.getInventory().offhand.get(0));
-        // Ender chest
-        for (int i = 0; i < player.getEnderChestInventory().getContainerSize(); i++) {
-            allItems.add(player.getEnderChestInventory().getItem(i));
-        }
-
-        for (ItemStack stack : allItems) {
-            String storageId = getPersonalStorageId(stack);
-            if (storageId != null) {
-                result.put(storageId, stack);
-            }
-        }
-        return result;
-    }
-
-    /**
-     * Extract the personalStorageId UUID from an ItemStack's mekData NBT.
-     */
-    public static String getPersonalStorageId(ItemStack stack) {
-        if (stack.isEmpty())
-            return null;
-        CompoundTag tag = stack.getTag();
-        if (tag == null || !tag.contains(MEK_DATA, Tag.TAG_COMPOUND))
-            return null;
-        CompoundTag mekData = tag.getCompound(MEK_DATA);
-        if (mekData.contains(PERSONAL_STORAGE_ID)) {
-            return mekData.getString(PERSONAL_STORAGE_ID);
-        }
-        return null;
-    }
-
-    /**
-     * Save all personal chest inventory data to the database.
-     */
-    public static void savePersonalChestData(Player player) throws SQLException {
-        if (!ModList.get().isLoaded("mekanism") || !JdbcConfig.SYNC_MEKANISM_PERSONAL_CHEST.get())
-            return;
-
-        Map<String, ItemStack> chestItems = collectPersonalChestItems(player);
-        if (chestItems.isEmpty())
-            return;
-
-        for (Map.Entry<String, ItemStack> entry : chestItems.entrySet()) {
-            String storageId = entry.getKey();
-            ItemStack stack = entry.getValue();
-
-            Optional<AbstractPersonalStorageItemInventory> invOpt = getInventoryIfPresent(stack);
-            if (invOpt.isEmpty())
-                continue;
-
-            AbstractPersonalStorageItemInventory inventory = invOpt.get();
-            List<IInventorySlot> slots = getInventorySlots(inventory);
-
-            // Serialize all slots into a CompoundTag
-            CompoundTag rootTag = new CompoundTag();
-            ListTag slotList = new ListTag();
-            for (int i = 0; i < slots.size(); i++) {
-                IInventorySlot slot = slots.get(i);
-                CompoundTag slotTag = slot.serializeNBT();
-                slotTag.putInt("SlotIndex", i);
-                slotList.add(slotTag);
-            }
-            rootTag.put("Slots", slotList);
-            rootTag.putInt("SlotCount", slots.size());
-
-            String serialized = vip.fubuki.playersync.sync.VanillaSync.serialize(rootTag.toString());
-
-            JDBCsetUp.executeUpdate(
-                    "REPLACE INTO mekanism_personal_chest (player_uuid, storage_id, inventory_data) VALUES ('%s', '%s', '%s')",
-                    player.getUUID().toString(),
-                    storageId,
-                    serialized);
-        }
-        PlayerSync.LOGGER.debug("Saved {} personal chest(s) for player {}",
-                chestItems.size(), player.getUUID());
-    }
-
-    /**
-     * Restore personal chest inventory data from the database.
-     * Should be called AFTER inventory/enderchest items are restored.
-     */
-    public static void restorePersonalChestData(Player player) throws SQLException {
-        if (!ModList.get().isLoaded("mekanism") || !JdbcConfig.SYNC_MEKANISM_PERSONAL_CHEST.get())
-            return;
-
-        Map<String, ItemStack> chestItems = collectPersonalChestItems(player);
-        if (chestItems.isEmpty())
-            return;
-
-        int restored = 0;
-        for (Map.Entry<String, ItemStack> entry : chestItems.entrySet()) {
-            String storageId = entry.getKey();
-            ItemStack stack = entry.getValue();
-
-            // Query saved data from DB
-            JDBCsetUp.QueryResult qr = JDBCsetUp.executeQuery(
-                    "SELECT inventory_data FROM mekanism_personal_chest WHERE storage_id = '%s'",
-                    storageId);
-            ResultSet rs = qr.resultSet();
-            if (!rs.next()) {
-                rs.close();
-                qr.connection().close();
-                continue;
-            }
-
-            String serialized = rs.getString("inventory_data");
-            rs.close();
-            qr.connection().close();
-
-            if (serialized == null || serialized.isEmpty())
-                continue;
-
-            // Deserialize
-            String nbtString = vip.fubuki.playersync.sync.VanillaSync.deserializeString(serialized);
-            CompoundTag rootTag;
-            try {
-                rootTag = net.minecraft.nbt.TagParser.parseTag(nbtString);
-            } catch (Exception e) {
-                PlayerSync.LOGGER.error("Failed to parse personal chest NBT for storage {}", storageId, e);
-                continue;
-            }
-
-            // Ensure inventory exists in target world's SavedData
-            Optional<AbstractPersonalStorageItemInventory> invOpt = getInventoryFor(stack);
-            if (invOpt.isEmpty())
-                continue;
-
-            AbstractPersonalStorageItemInventory inventory = invOpt.get();
-            List<IInventorySlot> slots = getInventorySlots(inventory);
-            ListTag slotList = rootTag.getList("Slots", Tag.TAG_COMPOUND);
-
-            for (int i = 0; i < slotList.size(); i++) {
-                CompoundTag slotTag = slotList.getCompound(i);
-                int slotIndex = slotTag.getInt("SlotIndex");
-                slotTag.remove("SlotIndex");
-                if (slotIndex >= 0 && slotIndex < slots.size()) {
-                    slots.get(slotIndex).deserializeNBT(slotTag);
-                }
-            }
-            restored++;
-        }
-        if (restored > 0) {
-            PlayerSync.LOGGER.info("Restored {} personal chest(s) for player {}",
-                    restored, player.getUUID());
-        }
-    }
-}

src/main/java/vip/fubuki/playersync/sync/chat/ChatSyncClient.java

@@ -6,12 +6,13 @@ import net.minecraftforge.event.entity.player.PlayerEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import vip.fubuki.playersync.PlayerSync;
 import vip.fubuki.playersync.config.JdbcConfig;
+import vip.fubuki.playersync.sync.ChatSync;
 
-import java.io.*;
-import java.net.ConnectException;
-import java.net.InetSocketAddress;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
 import java.net.Socket;
-import java.net.SocketTimeoutException;
 import java.util.Objects;
 
 public class ChatSyncClient {
@@ -19,98 +20,31 @@ public class ChatSyncClient {
     static Socket clientSocket;
     static PrintWriter out;
 
-    private static volatile boolean running = true;
-    private static final int RECONNECT_DELAY = 5000;
-    private static final int MAX_RECONNECT_ATTEMPTS = 10;
-
     public void run() {
-        int reconnectAttempts = 0;
-
-        while (running && reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
-            try {
-                PlayerSync.LOGGER.info("Connecting to chat server {}:{}",
-                        JdbcConfig.CHAT_SERVER_IP.get(),
-                        JdbcConfig.CHAT_SERVER_PORT.get());
-
-                clientSocket = new Socket();
-                clientSocket.setReuseAddress(true);
-                clientSocket.setKeepAlive(true);
-                clientSocket.setTcpNoDelay(true);
-
-                clientSocket.connect(
-                        new InetSocketAddress(
-                                JdbcConfig.CHAT_SERVER_IP.get(),
-                                JdbcConfig.CHAT_SERVER_PORT.get()
-                        ),
-                        15000
-                );
-
-                clientSocket.setSoTimeout(0);
-
-                out = new PrintWriter(new BufferedWriter(
-                        new OutputStreamWriter(clientSocket.getOutputStream())), true);
-
-                PlayerSync.LOGGER.info("Successfully connected to chat server");
-                reconnectAttempts = 0;
-
-                BufferedReader in = new BufferedReader(
-                        new InputStreamReader(clientSocket.getInputStream()));
-
-                String serverMessage;
-                while (running && (serverMessage = in.readLine()) != null) {
-                    Component textComponents = Component.nullToEmpty(serverMessage);
-                    if(playerList != null){
-                        playerList.getServer().execute(() ->
-                                playerList.broadcastSystemMessage(textComponents, false));
-                    }else {
-                        PlayerSync.LOGGER.info("Received message from chat server: " + serverMessage);
-                    }
-                }
-
-            } catch (SocketTimeoutException e) {
-                PlayerSync.LOGGER.warn("Chat server read timeout, reconnecting...");
-            } catch (ConnectException e) {
-                PlayerSync.LOGGER.warn("Cannot connect to chat server: {}", e.getMessage());
-            } catch (IOException e) {
-                PlayerSync.LOGGER.error("Chat client connection error: {}", e.getMessage());
-            } finally {
-                closeConnection();
-            }
-
-            if (running && reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
-                reconnectAttempts++;
-                PlayerSync.LOGGER.warn("Attempting to reconnect to chat server ({}/{})",
-                        reconnectAttempts, MAX_RECONNECT_ATTEMPTS);
-
-                try {
-                    long delay = Math.min(RECONNECT_DELAY * (long)Math.pow(2, reconnectAttempts-1), 60000);
-                    Thread.sleep(delay);
-                } catch (InterruptedException e) {
-                    Thread.currentThread().interrupt();
-                    break;
-                }
-            }
-        }
-    }
-
-    private void closeConnection() {
         try {
-            if (out != null) {
-                out.close();
-                out = null;
-            }
-            if (clientSocket != null && !clientSocket.isClosed()) {
-                clientSocket.close();
-                clientSocket = null;
+            clientSocket = new Socket(JdbcConfig.CHAT_SERVER_IP.get(), JdbcConfig.CHAT_SERVER_PORT.get());
+            out = new PrintWriter(clientSocket.getOutputStream(),true);
+
+            BufferedReader in = new BufferedReader(
+                    new InputStreamReader(clientSocket.getInputStream()));
+
+            String serverMessage;
+            while ((serverMessage = in.readLine()) != null) {
+                PlayerSync.LOGGER.info("Received message from chat server: " + serverMessage);
+                Component textComponents = Component.nullToEmpty(serverMessage);
+                if(playerList!=null){
+                    playerList.broadcastSystemMessage(textComponents,false);
+                }
             }
         } catch (IOException e) {
-            PlayerSync.LOGGER.error("Error closing connection: {}", e.getMessage());
+            e.printStackTrace();
+            reconnectClient();
         }
     }
 
-    public void shutdown() {
-        running = false;
-        closeConnection();
+    private void reconnectClient() {
+        ChatSync.LOGGER.warn("TODO: implement reconnectClient()");
+        //TODO
     }
 
     @SubscribeEvent

src/main/java/vip/fubuki/playersync/sync/chat/ChatSyncServer.java

@@ -1,130 +1,63 @@
 package vip.fubuki.playersync.sync.chat;
 
-import vip.fubuki.playersync.PlayerSync;
 import vip.fubuki.playersync.config.JdbcConfig;
 
-import java.io.BufferedReader;
 import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.PrintWriter;
+import java.io.InputStream;
+import java.io.OutputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
-import java.net.SocketTimeoutException;
-import java.util.Iterator;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
 
 public class ChatSyncServer {
     static ServerSocket serverSocket;
     static final Set<Socket> SocketList = ConcurrentHashMap.newKeySet();
     static final ExecutorService executorService = Executors.newCachedThreadPool();
-    private volatile boolean running = true;
 
     public void run() throws IOException {
-        try {
-            serverSocket = new ServerSocket(JdbcConfig.CHAT_SERVER_PORT.get());
-            serverSocket.setReuseAddress(true);
-            PlayerSync.LOGGER.info("Chat server started successfully on port {}", JdbcConfig.CHAT_SERVER_PORT.get());
-
-            while (running && !Thread.currentThread().isInterrupted()) {
-                try {
-                    Socket newSocket = serverSocket.accept();
-                    newSocket.setSoTimeout(0);
-                    SocketList.add(newSocket);
-                    executorService.submit(() -> handleClient(newSocket));
-                    PlayerSync.LOGGER.info("New client connected, total clients: {}", SocketList.size());
-                } catch (IOException e) {
-                    if (running) {
-                        PlayerSync.LOGGER.error("Error accepting client connection: {}", e.getMessage());
-                    }
-                }
-            }
-        } finally {
-            shutdown();
+        serverSocket = new ServerSocket(JdbcConfig.CHAT_SERVER_PORT.get());
+        while (!Thread.currentThread().isInterrupted()) {
+            Socket newSocket = serverSocket.accept();
+            SocketList.add(newSocket);
+            executorService.submit(() -> handleClient(newSocket));
         }
+        serverSocket.close();
     }
 
     private void handleClient(Socket socket) {
-        String clientInfo = socket.getInetAddress() + ":" + socket.getPort();
-
-        try (BufferedReader reader = new BufferedReader(
-                new InputStreamReader(socket.getInputStream()))) {
-
-            String message;
-            while (running && (message = reader.readLine()) != null) {
+        try (InputStream inputStream = socket.getInputStream()) {
+            byte[] buffer = new byte[1024];
+            int bytesRead;
+            while ((bytesRead = inputStream.read(buffer)) != -1) {
+                String message = new String(buffer, 0, bytesRead);
                 broadcastMessage(socket, message);
             }
-
-        } catch (SocketTimeoutException e) {
-            PlayerSync.LOGGER.warn("Client {} timeout", clientInfo);
         } catch (IOException e) {
-            PlayerSync.LOGGER.error("Error handling client {}: {}", clientInfo, e.getMessage());
+            e.printStackTrace();
         } finally {
             SocketList.remove(socket);
             try {
-                if (!socket.isClosed()) {
-                    socket.close();
-                }
+                socket.close();
             } catch (IOException e) {
-                PlayerSync.LOGGER.error("Error closing client socket: {}", e.getMessage());
+                e.printStackTrace();
             }
-            PlayerSync.LOGGER.info("Client disconnected, remaining clients: {}", SocketList.size());
         }
     }
 
     private void broadcastMessage(Socket sender, String message) {
-        Iterator<Socket> iterator = SocketList.iterator();
-        while (iterator.hasNext()) {
-            Socket socket = iterator.next();
-            if (!socket.equals(sender) && !socket.isClosed()) {
-                try {
-                    PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
-                    writer.println(message);
-                } catch (IOException e) {
-                    PlayerSync.LOGGER.error("Error broadcasting to client, removing: {}", e.getMessage());
-                    iterator.remove();
-                    try {
-                        socket.close();
-                    } catch (IOException ex) {
-                        // Ignore
-                    }
-                }
-            }
-        }
-    }
-
-    public void shutdown() {
-        running = false;
-        try {
-            if (serverSocket != null && !serverSocket.isClosed()) {
-                serverSocket.close();
-            }
-        } catch (IOException e) {
-            PlayerSync.LOGGER.error("Error closing server socket: {}", e.getMessage());
-        }
-
         for (Socket socket : SocketList) {
-            try {
-                if (!socket.isClosed()) {
-                    socket.close();
+            if (!socket.equals(sender)) {
+                try {
+                    OutputStream outputStream = socket.getOutputStream();
+                    outputStream.write(message.getBytes());
+                    outputStream.flush();
+                } catch (IOException e) {
+                    e.printStackTrace();
                 }
-            } catch (IOException e) {
-                // Ignore
             }
         }
-        SocketList.clear();
-
-        executorService.shutdown();
-        try {
-            if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
-                executorService.shutdownNow();
-            }
-        } catch (InterruptedException e) {
-            executorService.shutdownNow();
-            Thread.currentThread().interrupt();
-        }
     }
 }

src/main/java/vip/fubuki/playersync/util/JDBCsetUp.java

@@ -1,11 +1,13 @@
 package vip.fubuki.playersync.util;
 
-import com.mojang.logging.LogUtils;
-import org.slf4j.Logger;
 import vip.fubuki.playersync.config.JdbcConfig;
 
 import java.sql.*;
 
+import org.slf4j.Logger;
+
+import com.mojang.logging.LogUtils;
+
 public class JDBCsetUp {
 
     private static final Logger LOGGER = LogUtils.getLogger();
@@ -29,7 +31,7 @@ public class JDBCsetUp {
         // Ensure that the connection uses the desired database by explicitly issuing "USE dbName"
         if (selectDatabase && dbName != null && !dbName.isEmpty()) {
             try (Statement st = conn.createStatement()) {
-                st.execute("USE `" + dbName + "`");
+                st.execute("USE " + dbName);
             }
         }
         return conn;
@@ -43,41 +45,37 @@ public class JDBCsetUp {
     /**
      * Executes a query using a connection that includes the database.
      */
-    public static QueryResult executeQuery(String sqlFormatString, Object... args) throws SQLException {
-        String sql = String.format(sqlFormatString, args);
+    public static QueryResult executeQuery(String sql) throws SQLException {
         LOGGER.trace(sql);
         Connection connection = getConnection();  // With database selected (and "USE" already run)
         PreparedStatement queryStatement = connection.prepareStatement(sql);
         ResultSet resultSet = queryStatement.executeQuery();
-        return new QueryResult(connection, queryStatement, resultSet);
+        return new QueryResult(connection, resultSet);
     }
 
     /**
-     * Executes an update using a connection with or without the database within the JDBC URL
+     * Executes an update using a connection that includes the database.
      */
-    private static void executeUpdate(boolean selectDatabase, String sqlFormatString, Object... args) throws SQLException {
-        String sql = String.format(sqlFormatString, args);
+    public static void executeUpdate(String sql) throws SQLException {
         LOGGER.trace(sql);
-        try (Connection connection = getConnection(selectDatabase)) {
+        try (Connection connection = getConnection()) {  // With database selected
             try (PreparedStatement updateStatement = connection.prepareStatement(sql)) {
                 updateStatement.executeUpdate();
             }
         }
     }
 
-    /**
-     * Executes an update using a connection that includes the database in the JDBC URL
-     */
-    public static void executeUpdate(String sqlFormatString, Object... args) throws SQLException {
-        executeUpdate(true, sqlFormatString, args);
-    }
-
     /**
      * Executes an update using a connection that does NOT include a default database.
      * This method is used for commands like "CREATE DATABASE IF NOT EXISTS ..."
      */
-    public static void executeUpdateWithoutDatabase(String sqlFormatString, Object... args) throws SQLException {
-        executeUpdate(false, sqlFormatString, args);
+    public static void executeUpdate(String sql, int dummy) throws SQLException {
+        LOGGER.trace(sql);
+        try (Connection connection = getConnection(false)) {  // Without default database
+            try (PreparedStatement updateStatement = connection.prepareStatement(sql)) {
+                updateStatement.executeUpdate();
+            }
+        }
     }
 
     /**
@@ -94,32 +92,6 @@ public class JDBCsetUp {
         }
     }
 
-    public record QueryResult(Connection connection,PreparedStatement preparedStatement, ResultSet resultSet) implements AutoCloseable {
-        @Override
-        public void close() {
-            if (resultSet != null) {
-                try {
-                    resultSet.close();
-                } catch (SQLException e) {
-                    LOGGER.error("Error closing ResultSet", e);
-                }
-            }
-
-            if (preparedStatement != null) {
-                try {
-                    preparedStatement.close();
-                } catch (SQLException e) {
-                    LOGGER.error("Error closing PreparedStatement", e);
-                }
-            }
-
-            if (connection != null) {
-                try {
-                    connection.close();
-                } catch (SQLException e) {
-                    LOGGER.error("Error closing Connection", e);
-                }
-            }
-        }
+    public record QueryResult(Connection connection, ResultSet resultSet) {
     }
 }

src/main/java/vip/fubuki/playersync/util/LocalJsonUtil.java

@@ -2,44 +2,31 @@ package vip.fubuki.playersync.util;
 
 import java.util.HashMap;
 import java.util.Map;
-import java.util.function.Function;
 
 public class LocalJsonUtil {
-    private static <K> Map<K, String> stringToGenericMap(String param, Function<String, K> keyParser) {
-        Map<K, String> map = new HashMap<>();
-
-        // check if string is at least minimal json
-        if (param == null || param.length() < 2 || param.equals("{}")) {
-            return map;
-        }
-
-        // extract string within outermost json brackets {}
-        String s1 = param.substring(param.indexOf('{')+1, param.lastIndexOf('}')).trim();
-        if (s1.isEmpty()) {
-            return map;
-        }
-
-        // split all json elements
-        for (String split : s1.split(",")) {
-            String trim = split.trim();
-
-            // only check for the first "=" as the values also contain additional "="
-            int equalIndex = trim.indexOf('=');
-            if (equalIndex < 0)
-                continue;
-
-            String key = trim.substring(0, equalIndex);
-            String value = trim.substring(equalIndex + 1);
-            map.put(keyParser.apply(key), value);
+    public static Map<String,String> StringToMap(String param) {
+        Map<String,String> map = new HashMap<>();
+        String s1 = param.substring(1,param.length()-1);
+        String s2 = s1.trim();
+        String[] split = s2.split(",");
+        for (int i = split.length - 1; i >= 0; i--) {
+            String trim = split[i].trim();
+            String[] split1 = trim.split("=");
+            map.put(split1[0],split1[1]);
         }
         return map;
     }
 
-    public static Map<String, String> StringToMap(String param) {
-        return stringToGenericMap(param, Function.identity());
-    }
-
-    public static Map<Integer, String> StringToEntryMap(String param) {
-        return stringToGenericMap(param, Integer::parseInt);
+    public static Map<Integer,String> StringToEntryMap(String param) {
+        Map<Integer,String> map = new HashMap<>();
+        String s1 = param.substring(1,param.length()-1);
+        String s2 = s1.trim();
+        String[] split = s2.split(",");
+        for (int i = split.length - 1; i >= 0; i--) {
+            String trim = split[i].trim();
+            String[] split1 = trim.split("=");
+            map.put(Integer.parseInt(split1[0]),split1[1]);
+        }
+        return map;
     }
 }

src/main/resources/assets/playersync/lang/en_us.json

@@ -1,8 +1,5 @@
 {
   "playersync.item_placeholder_description": "Item is unknown on this server. This can either\nbe a modded item, an added, or a removed vanilla\nitem.\nThis voucher will automatically be replaced with\nthe corresponding item when joining a server\nwhere the item is known.",
-  "playersync.placeholder_titel_override": "Item Voucher",
   "playersync.item_placeholder_title": "Item Voucher",
-  "playersync.already_online": "You can't join more than one synchronization server at the same time.",
-  "playersync.sqlexception": "SqlException detected!Connection lost,please contact with your admin.",
-  "playersync.wrong_entity_status": "An error occurred while creating playerEntity in the world,please login again."
+  "playersync.already_online": "You can't join more than one synchronization server at the same time."
 }

src/main/resources/assets/playersync/lang/zh_cn.json

@@ -1,8 +1,5 @@
 {
-  "playersync.item_placeholder_description": "在这个服务器上,该物品是未知的\n它可能曾是一个其他已被移除的mod的物品,或者被移除的原版物品\n这一凭证将在加入拥有该物品的服务器时自动转换为对应物品",
-  "playersync.placeholder_titel_override": "未知物品凭证",
-  "playersync.item_placeholder_title": "未知物品凭证",
-  "playersync.already_online": "你不能同时加入多个在线的数据互通的服务器",
-  "playersync.sqlexception": "检测到Sql异常!连接已中断,请联系管理员",
-  "playersync.wrong_entity_status": "在世界中尝试创建玩家实体时发生了错误,请尝试重新进入"
-}
+  "playersync.item_placeholder_description": "物品在此服务器未知。这可能是一个模组物品,或是不同版本的原版物品。\n这张券将会在加入可识别此物品的服务器后自动替换为对应物品。",
+  "playersync.item_placeholder_title": "物品券",
+  "playersync.already_online": "你不能同时加入多个同步的服务器。"
+}