SyncController OVERHAUL PHASE #2:

- Created SyncRegistry and SyncHandler
- Extracted all 14 SyncType family handling to their own SyncHandler
- Rewritten SyncController to accomodate the new framework
This commit is contained in:
bigguy345 committed 2026-03-31 21:44:23 +02:00
1 parent 48281c8d34
commit 6d0655ad7d
34 files changed
+2743 -746

No files matched your search

@@ -5,51 +5,26 @@ import cpw.mods.fml.relauncher.SideOnly;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import kamkeel.npcs.addon.DBCAddon;
import kamkeel.npcs.controllers.data.ability.Ability;
import kamkeel.npcs.controllers.data.ability.data.ChainedAbility;
import kamkeel.npcs.controllers.sync.SyncHandler;
import kamkeel.npcs.controllers.sync.SyncRegistry;
import kamkeel.npcs.controllers.sync.handlers.*;
import kamkeel.npcs.network.LargeAbstractPacket;
import kamkeel.npcs.network.PacketHandler;
import kamkeel.npcs.network.enums.EnumSyncAction;
import kamkeel.npcs.network.enums.SyncType;
import kamkeel.npcs.network.packets.data.LoginPacket;
import kamkeel.npcs.network.packets.data.ProfileSharedQuestPacket;
import kamkeel.npcs.network.packets.data.ability.AbilityCooldownSyncPacket;
import kamkeel.npcs.network.packets.data.ability.AbilityHotbarSyncPacket;
import kamkeel.npcs.network.packets.data.ability.PlayerAbilitySyncPacket;
import kamkeel.npcs.network.packets.data.large.SyncEffectPacket;
import kamkeel.npcs.network.packets.data.large.SyncPacket;
import kamkeel.npcs.network.packets.request.party.PartyInfoPacket;
import kamkeel.npcs.util.ByteBufUtils;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.server.MinecraftServer;
import noppes.npcs.client.ClientCacheHandler;
import noppes.npcs.controllers.CustomEffectController;
import noppes.npcs.controllers.DialogController;
import noppes.npcs.controllers.FactionController;
import noppes.npcs.controllers.MagicController;
import noppes.npcs.controllers.QuestController;
import noppes.npcs.controllers.RecipeController;
import noppes.npcs.controllers.data.CustomEffect;
import noppes.npcs.controllers.data.Dialog;
import noppes.npcs.controllers.data.DialogCategory;
import noppes.npcs.controllers.data.EffectKey;
import noppes.npcs.controllers.data.Faction;
import noppes.npcs.controllers.data.Magic;
import noppes.npcs.controllers.data.MagicCycle;
import noppes.npcs.controllers.data.PlayerData;
import noppes.npcs.controllers.data.PlayerEffect;
import noppes.npcs.controllers.data.Quest;
import noppes.npcs.controllers.data.QuestCategory;
import noppes.npcs.controllers.data.RecipeAnvil;
import noppes.npcs.controllers.data.RecipeCarpentry;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
@@ -57,6 +32,31 @@ import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Supplier;
/**
* Central sync backend for CNPC+.
*
* <p>This controller manages two distinct sync lanes:</p>
* <ul>
* <li><b>Global cached registry families</b> — registered via {@link SyncRegistry}
* with concrete {@link SyncHandler} implementations. These families use
* cached serialized payloads, revision-based delta sync on reconnect,
* and chunked delivery. All family-specific RELOAD/UPDATE/REMOVE logic
* lives in the handler implementations, not here.</li>
* <li><b>Direct per-player sync helpers</b> — for transient per-player state
* like effects, ability hotbars, and cooldowns. These bypass the cached
* registry system and are sent as direct packets. Owned by
* {@link PlayerEffectSyncHelper} and {@link PlayerAbilitySyncHelper}.</li>
* </ul>
*
* <p>This class retains ownership of:</p>
* <ul>
* <li>Cache entry storage and lazy rebuild ({@link SyncCacheEntry})</li>
* <li>Cached payload byte[] + precomputed chunks ({@link CachedSyncPayload})</li>
* <li>Per-player revision tracking ({@link PlayerSyncState})</li>
* <li>Login handshake and post-login packet sequencing</li>
* <li>Generic sync dispatch helpers (syncAll, syncUpdate, syncRemove)</li>
* </ul>
*/
public class SyncController {
public static boolean DEBUG_SYNC_LOGGING = false;
@@ -71,45 +71,65 @@ public class SyncController {
}
}
private static final SyncType[] LOGIN_SYNC_TYPES = new SyncType[]{
SyncType.FACTION,
SyncType.DIALOG_CATEGORY,
SyncType.QUEST_CATEGORY,
SyncType.WORKBENCH_RECIPES,
SyncType.CARPENTRY_RECIPES,
SyncType.ANVIL_RECIPES,
SyncType.CUSTOM_EFFECTS,
SyncType.MAGIC,
SyncType.MAGIC_CYCLE,
SyncType.CUSTOM_ABILITY,
SyncType.CHAINED_ABILITY
};
// ═══════════════════════════════════════════════════════════════════════
// Lifecycle — handler registration and cache initialization
// ═══════════════════════════════════════════════════════════════════════
/**
* Registers all core CNPC+ sync handlers in deterministic order.
* Called on server start. The registration order determines login
* sync ordering via {@link SyncRegistry#getLoginTypes()}.
*
* <p>Handler registration order matches the original hard-coded
* LOGIN_SYNC_TYPES array for behavioral parity.</p>
*/
public static void load() {
cacheEntries.clear();
playerSyncState.clear();
SyncRegistry.clear();
registerCache(SyncType.FACTION, SyncController::factionsNBT);
registerCache(SyncType.DIALOG_CATEGORY, SyncController::dialogCategoriesNBT);
registerCache(SyncType.QUEST_CATEGORY, SyncController::questCategoriesNBT);
registerCache(SyncType.WORKBENCH_RECIPES, SyncController::workbenchNBT);
registerCache(SyncType.CARPENTRY_RECIPES, SyncController::carpentryNBT);
registerCache(SyncType.ANVIL_RECIPES, SyncController::anvilNBT);
registerCache(SyncType.CUSTOM_EFFECTS, SyncController::customEffectsNBT);
registerCache(SyncType.MAGIC, SyncController::magicsNBT);
registerCache(SyncType.MAGIC_CYCLE, SyncController::magicCyclesNBT);
registerCache(SyncType.CUSTOM_ABILITY, SyncController::customAbilitiesNBT);
registerCache(SyncType.CHAINED_ABILITY, SyncController::chainedAbilitiesNBT);
// Register all core handlers in deterministic order
// Order matches original LOGIN_SYNC_TYPES for login sync ordering
SyncRegistry.register(SyncType.FACTION, new FactionSyncHandler());
SyncRegistry.register(SyncType.DIALOG, new DialogSyncHandler());
SyncRegistry.register(SyncType.DIALOG_CATEGORY, new DialogCategorySyncHandler());
SyncRegistry.register(SyncType.QUEST, new QuestSyncHandler());
SyncRegistry.register(SyncType.QUEST_CATEGORY, new QuestCategorySyncHandler());
SyncRegistry.register(SyncType.PLAYERDATA, new PlayerDataSyncHandler());
SyncRegistry.register(SyncType.WORKBENCH_RECIPES, new WorkbenchRecipeSyncHandler());
SyncRegistry.register(SyncType.CARPENTRY_RECIPES, new CarpentryRecipeSyncHandler());
SyncRegistry.register(SyncType.ANVIL_RECIPES, new AnvilRecipeSyncHandler());
SyncRegistry.register(SyncType.CUSTOM_EFFECTS, new CustomEffectSyncHandler());
SyncRegistry.register(SyncType.MAGIC, new MagicSyncHandler());
SyncRegistry.register(SyncType.MAGIC_CYCLE, new MagicCycleSyncHandler());
SyncRegistry.register(SyncType.CUSTOM_ABILITY, new CustomAbilitySyncHandler());
SyncRegistry.register(SyncType.CHAINED_ABILITY, new ChainedAbilitySyncHandler());
// Register caches for all cached (login-sync) types
// The cache supplier delegates to the handler's serializeAll()
for (SyncType type : SyncRegistry.getLoginTypes()) {
SyncHandler handler = SyncRegistry.getHandler(type);
if (handler != null)
registerCache(type, handler::serializeAll);
}
SyncRegistry.validateRegistrations();
SyncRegistry.freeze();
}
// ═══════════════════════════════════════════════════════════════════════
// Login sync and revision handshake
// ═══════════════════════════════════════════════════════════════════════
public static void syncPlayer(EntityPlayerMP player) {
SyncController.syncPlayerInternal(player, true);
SyncController.syncPlayer(player, true);
}
private static void syncPlayerInternal(EntityPlayerMP player, boolean includePostPackets) {
private static void syncPlayer(EntityPlayerMP player, boolean includePostPackets) {
PlayerSyncState state = playerSyncState.computeIfAbsent(player.getUniqueID(), PlayerSyncState::new);
for (SyncType type : LOGIN_SYNC_TYPES) {
// Registry-driven login iteration: iterate only cached types
for (SyncType type : SyncRegistry.getLoginTypes()) {
SyncCacheEntry entry = cacheEntries.get(type);
if (entry == null) {
continue;
@@ -117,14 +137,12 @@ public class SyncController {
int currentRevision = entry.getRevisionValue();
int lastRevision = state.getRevision(type);
if (lastRevision == currentRevision) {
if (lastRevision == currentRevision)
continue;
}
CachedSyncPayload payload = entry.getPayload(type);
if (payload == null) {
if (payload == null)
continue;
}
if (lastRevision != payload.getRevision()) {
debug("Sending %s data to %s", type, player.getCommandSenderName());
@@ -184,7 +202,7 @@ public class SyncController {
private static void sendPostLoginPackets(EntityPlayerMP player) {
DBCAddon.instance.syncPlayer(player);
syncPlayerData(player, false);
PlayerDataSyncHandler.getInstance().syncPlayerData(player, false);
PartyInfoPacket.sendPartyData(player);
ProfileSharedQuestPacket.sendToPlayer(player);
@@ -198,12 +216,13 @@ public class SyncController {
}
private static Map<SyncType, Integer> getServerRevisionSnapshot() {
// Registry-driven: iterate login types from registry
Map<SyncType, Integer> snapshot = new LinkedHashMap<>();
for (SyncType type : LOGIN_SYNC_TYPES) {
for (SyncType type : SyncRegistry.getLoginTypes()) {
SyncCacheEntry entry = cacheEntries.get(type);
if (entry != null) {
if (entry != null)
snapshot.put(type, entry.getRevisionValue());
}
}
return snapshot;
}
@@ -228,634 +247,75 @@ public class SyncController {
return entry == null ? -1 : entry.getRevisionValue();
}
public static NBTTagCompound workbenchNBT() {
RecipeController controller = RecipeController.Instance;
NBTTagList list = new NBTTagList();
NBTTagCompound compound = new NBTTagCompound();
for (RecipeCarpentry recipe : controller.globalRecipes.values()) {
list.appendTag(recipe.writeNBT(false));
}
compound.setTag("recipes", list);
return compound;
}
// ═══════════════════════════════════════════════════════════════════════
// Generic sync dispatch — registry-driven, no family-specific logic
// ═══════════════════════════════════════════════════════════════════════
public static NBTTagCompound carpentryNBT() {
RecipeController controller = RecipeController.Instance;
NBTTagList list = new NBTTagList();
NBTTagCompound compound = new NBTTagCompound();
for (RecipeCarpentry recipe : controller.carpentryRecipes.values()) {
list.appendTag(recipe.writeNBT(false));
}
compound.setTag("recipes", list);
return compound;
}
public static NBTTagCompound anvilNBT() {
RecipeController controller = RecipeController.Instance;
NBTTagList list = new NBTTagList();
NBTTagCompound compound = new NBTTagCompound();
for (RecipeAnvil recipe : controller.anvilRecipes.values()) {
list.appendTag(recipe.writeNBT(false));
}
compound.setTag("recipes", list);
return compound;
}
public static NBTTagCompound factionsNBT() {
NBTTagList list = new NBTTagList();
NBTTagCompound compound = new NBTTagCompound();
for (Faction faction : FactionController.getInstance().factions.values()) {
NBTTagCompound factioNBT = new NBTTagCompound();
faction.writeNBT(factioNBT);
list.appendTag(factioNBT);
}
compound.setTag("Factions", list);
return compound;
}
public static NBTTagCompound dialogCategoriesNBT() {
NBTTagCompound compound = new NBTTagCompound();
NBTTagList categoryList = new NBTTagList();
for (DialogCategory category : DialogController.Instance.categories.values()) {
NBTTagCompound questCompound = new NBTTagCompound();
NBTTagList dialogList = new NBTTagList();
for (int dialogID : category.dialogs.keySet()) {
Dialog quest = category.dialogs.get(dialogID);
dialogList.appendTag(quest.writeToNBT(new NBTTagCompound()));
}
questCompound.setTag("Data", dialogList);
questCompound.setTag("CatNBT", category.writeSmallNBT(new NBTTagCompound()));
categoryList.appendTag(questCompound);
}
compound.setTag("DialogCategories", categoryList);
return compound;
}
public static NBTTagCompound questCategoriesNBT() {
NBTTagCompound compound = new NBTTagCompound();
NBTTagList categoryList = new NBTTagList();
for (QuestCategory category : QuestController.Instance.categories.values()) {
NBTTagCompound questCompound = new NBTTagCompound();
;
NBTTagList questList = new NBTTagList();
for (int questID : category.quests.keySet()) {
Quest quest = category.quests.get(questID);
questList.appendTag(quest.writeToNBT(new NBTTagCompound()));
}
questCompound.setTag("Data", questList);
questCompound.setTag("CatNBT", category.writeSmallNBT(new NBTTagCompound()));
categoryList.appendTag(questCompound);
}
compound.setTag("QuestCategories", categoryList);
return compound;
}
public static NBTTagCompound customEffectsNBT() {
NBTTagList list = new NBTTagList();
NBTTagCompound compound = new NBTTagCompound();
for (CustomEffect effect : CustomEffectController.getInstance().getCustomEffects().values()) {
list.appendTag(effect.writeToNBT(false));
}
compound.setTag("Data", list);
return compound;
}
public static NBTTagCompound magicsNBT() {
NBTTagList list = new NBTTagList();
NBTTagCompound compound = new NBTTagCompound();
for (Magic magic : MagicController.getInstance().magics.values()) {
NBTTagCompound magicCompound = new NBTTagCompound();
magic.writeNBT(magicCompound);
list.appendTag(magicCompound);
}
compound.setTag("Data", list);
return compound;
}
public static NBTTagCompound magicCyclesNBT() {
NBTTagList list = new NBTTagList();
NBTTagCompound compound = new NBTTagCompound();
for (MagicCycle cycle : MagicController.getInstance().cycles.values()) {
NBTTagCompound cycleCompound = new NBTTagCompound();
cycle.writeNBT(cycleCompound);
list.appendTag(cycleCompound);
}
compound.setTag("Data", list);
return compound;
}
public static NBTTagCompound customAbilitiesNBT() {
NBTTagList list = new NBTTagList();
NBTTagCompound compound = new NBTTagCompound();
for (Map.Entry<String, Ability> entry : AbilityController.Instance.getCustomAbilities().entrySet()) {
NBTTagCompound abilityNBT = entry.getValue().writeNBT(false);
abilityNBT.setString("CustomAbilityId", entry.getKey());
list.appendTag(abilityNBT);
}
compound.setTag("Data", list);
return compound;
}
public static void syncAllCustomAbilities() {
CachedSyncPayload payload = rebuildNow(SyncType.CUSTOM_ABILITY);
/**
* Generic full-broadcast helper. Rebuilds the cache for the given type
* and sends to all connected players.
*/
public static void syncAll(SyncType type) {
CachedSyncPayload payload = rebuildNow(type);
if (payload == null) {
return;
}
PacketHandler.Instance.sendToAll(new SyncPacket(SyncType.CUSTOM_ABILITY, payload));
updateAllPlayerRevisions(SyncType.CUSTOM_ABILITY, payload.getRevision());
PacketHandler.Instance.sendToAll(new SyncPacket(type, payload));
updateAllPlayerRevisions(type, payload.getRevision());
}
public static NBTTagCompound chainedAbilitiesNBT() {
NBTTagList list = new NBTTagList();
NBTTagCompound compound = new NBTTagCompound();
for (Map.Entry<String, ChainedAbility> entry : AbilityController.Instance.getChainedAbilities().entrySet()) {
NBTTagCompound chainNBT = entry.getValue().writeNBT(false);
chainNBT.setString("ChainedAbilityId", entry.getKey());
list.appendTag(chainNBT);
}
compound.setTag("Data", list);
return compound;
}
public static void syncAllChainedAbilities() {
CachedSyncPayload payload = rebuildNow(SyncType.CHAINED_ABILITY);
if (payload == null) {
return;
}
PacketHandler.Instance.sendToAll(new SyncPacket(SyncType.CHAINED_ABILITY, payload));
updateAllPlayerRevisions(SyncType.CHAINED_ABILITY, payload.getRevision());
}
public static void syncPlayerData(EntityPlayerMP player, boolean update) {
PlayerData data = PlayerData.get(player);
if (data != null) {
if (update) {
PacketHandler.Instance.sendToPlayer(new SyncPacket(
SyncType.PLAYERDATA,
EnumSyncAction.UPDATE,
-1,
data.getSyncNBT())
, player);
} else {
PacketHandler.Instance.sendToPlayer(new SyncPacket(
SyncType.PLAYERDATA,
EnumSyncAction.RELOAD,
-1,
data.getSyncNBTFull()), player);
}
}
}
// ═══════════════════════════════════════════════════════════════════════
// UPDATE and REMOVE dispatch — generic, registry-driven
// ═══════════════════════════════════════════════════════════════════════
public static void syncRemove(SyncType syncType, int id) {
Map<SyncType, Integer> revisions = invalidateCaches(syncType);
int revision = revisions.getOrDefault(syncType, getCurrentRevision(syncType));
PacketHandler.Instance.sendToAll(new SyncPacket(
syncType,
EnumSyncAction.REMOVE,
id,
revision,
new NBTTagCompound()
));
PacketHandler.Instance.sendToAll(new SyncPacket(syncType, EnumSyncAction.REMOVE, id, revision, new NBTTagCompound()));
updateAllPlayerRevisions(revisions);
}
public static void syncAllDialogs() {
CachedSyncPayload payload = rebuildNow(SyncType.DIALOG_CATEGORY);
if (payload == null) {
return;
}
PacketHandler.Instance.sendToAll(new SyncPacket(SyncType.DIALOG_CATEGORY, payload));
updateAllPlayerRevisions(SyncType.DIALOG_CATEGORY, payload.getRevision());
}
public static void syncAllQuests() {
CachedSyncPayload payload = rebuildNow(SyncType.QUEST_CATEGORY);
if (payload == null) {
return;
}
PacketHandler.Instance.sendToAll(new SyncPacket(SyncType.QUEST_CATEGORY, payload));
updateAllPlayerRevisions(SyncType.QUEST_CATEGORY, payload.getRevision());
}
public static void syncAllWorkbenchRecipes() {
CachedSyncPayload payload = rebuildNow(SyncType.WORKBENCH_RECIPES);
if (payload == null) {
return;
}
PacketHandler.Instance.sendToAll(new SyncPacket(SyncType.WORKBENCH_RECIPES, payload));
updateAllPlayerRevisions(SyncType.WORKBENCH_RECIPES, payload.getRevision());
}
public static void syncAllCarpentryRecipes() {
CachedSyncPayload payload = rebuildNow(SyncType.CARPENTRY_RECIPES);
if (payload == null) {
return;
}
PacketHandler.Instance.sendToAll(new SyncPacket(SyncType.CARPENTRY_RECIPES, payload));
updateAllPlayerRevisions(SyncType.CARPENTRY_RECIPES, payload.getRevision());
}
public static void syncAllAnvilRecipes() {
CachedSyncPayload payload = rebuildNow(SyncType.ANVIL_RECIPES);
if (payload == null) {
return;
}
PacketHandler.Instance.sendToAll(new SyncPacket(SyncType.ANVIL_RECIPES, payload));
updateAllPlayerRevisions(SyncType.ANVIL_RECIPES, payload.getRevision());
}
public static void syncAllCustomEffects() {
CachedSyncPayload payload = rebuildNow(SyncType.CUSTOM_EFFECTS);
if (payload == null) {
return;
}
PacketHandler.Instance.sendToAll(new SyncPacket(SyncType.CUSTOM_EFFECTS, payload));
updateAllPlayerRevisions(SyncType.CUSTOM_EFFECTS, payload.getRevision());
}
@SideOnly(Side.CLIENT)
public static void clientSync(SyncType syncType, int revision, NBTTagCompound fullCompound) {
if (syncType == SyncType.FACTION) {
NBTTagList list = fullCompound.getTagList("Factions", 10);
for (int i = 0; i < list.tagCount(); i++) {
Faction faction = new Faction();
faction.readNBT(list.getCompoundTagAt(i));
FactionController.getInstance().factionsSync.put(faction.id, faction);
}
FactionController.getInstance().factions = FactionController.getInstance().factionsSync;
FactionController.getInstance().factionsSync = new HashMap<Integer, Faction>();
} else if (syncType == SyncType.DIALOG_CATEGORY) {
if (!fullCompound.hasNoTags()) {
NBTTagList categories = fullCompound.getTagList("DialogCategories", 10);
for (int j = 0; j < fullCompound.getTagList("DialogCategories", 10).tagCount(); j++) {
NBTTagCompound categoryCompound = categories.getCompoundTagAt(j);
if (categoryCompound.hasNoTags())
continue;
DialogCategory category = new DialogCategory();
category.readSmallNBT(categoryCompound.getCompoundTag("CatNBT"));
NBTTagList dialogList = categoryCompound.getTagList("Data", 10);
if (DialogController.Instance.categoriesSync.containsKey(category.id)) {
category = DialogController.Instance.categoriesSync.get(category.id);
category.readSmallNBT(categoryCompound.getCompoundTag("CatNBT"));
}
for (int i = 0; i < dialogList.tagCount(); i++) {
Dialog dialog = new Dialog();
dialog.readNBT(dialogList.getCompoundTagAt(i));
dialog.category = category;
category.dialogs.put(dialog.id, dialog);
}
DialogController.Instance.categoriesSync.put(category.id, category);
}
}
HashMap<Integer, Dialog> dialogs = new HashMap<Integer, Dialog>();
for (DialogCategory category : DialogController.Instance.categoriesSync.values()) {
for (Dialog dialog : category.dialogs.values()) {
dialogs.put(dialog.id, dialog);
}
}
DialogController.Instance.categories = DialogController.Instance.categoriesSync;
DialogController.Instance.dialogs = dialogs;
DialogController.Instance.categoriesSync = new HashMap<Integer, DialogCategory>();
} else if (syncType == SyncType.QUEST_CATEGORY) {
if (!fullCompound.hasNoTags()) {
NBTTagList categories = fullCompound.getTagList("QuestCategories", 10);
for (int j = 0; j < fullCompound.getTagList("QuestCategories", 10).tagCount(); j++) {
NBTTagCompound categoryCompound = categories.getCompoundTagAt(j);
if (categoryCompound.hasNoTags())
continue;
QuestCategory category = new QuestCategory();
category.readSmallNBT(categoryCompound.getCompoundTag("CatNBT"));
NBTTagList questList = categoryCompound.getTagList("Data", 10);
if (QuestController.Instance.categoriesSync.containsKey(category.id)) {
category = QuestController.Instance.categoriesSync.get(category.id);
category.readSmallNBT(categoryCompound.getCompoundTag("CatNBT"));
}
for (int i = 0; i < questList.tagCount(); i++) {
Quest quest = new Quest();
quest.readNBT(questList.getCompoundTagAt(i));
quest.category = category;
category.quests.put(quest.id, quest);
}
QuestController.Instance.categoriesSync.put(category.id, category);
}
}
HashMap<Integer, Quest> quests = new HashMap<Integer, Quest>();
for (QuestCategory category : QuestController.Instance.categoriesSync.values()) {
for (Quest quest : category.quests.values()) {
quests.put(quest.id, quest);
}
}
QuestController.Instance.categories = QuestController.Instance.categoriesSync;
QuestController.Instance.quests = quests;
QuestController.Instance.categoriesSync = new HashMap<Integer, QuestCategory>();
} else if (syncType == SyncType.PLAYERDATA) {
ClientCacheHandler.playerData.setSyncNBTFull(fullCompound);
} else if (syncType == SyncType.MAGIC) {
NBTTagList list = fullCompound.getTagList("Data", 10);
MagicController mc = MagicController.getInstance();
mc.magicSync.clear();
for (int i = 0; i < list.tagCount(); i++) {
Magic magic = new Magic();
magic.readNBT(list.getCompoundTagAt(i));
mc.magicSync.put(magic.id, magic);
}
mc.magics.clear();
mc.magics.putAll(mc.magicSync);
mc.magicSync.clear();
} else if (syncType == SyncType.MAGIC_CYCLE) {
NBTTagList list = fullCompound.getTagList("Data", 10);
MagicController mc = MagicController.getInstance();
mc.cyclesSync.clear();
for (int i = 0; i < list.tagCount(); i++) {
MagicCycle cycle = new MagicCycle();
cycle.readNBT(list.getCompoundTagAt(i));
mc.cyclesSync.put(cycle.id, cycle);
}
mc.cycles.clear();
mc.cycles.putAll(mc.cyclesSync);
mc.cyclesSync.clear();
} else if (syncType == SyncType.WORKBENCH_RECIPES) {
NBTTagList list = fullCompound.getTagList("recipes", 10);
if (list == null)
return;
for (int i = 0; i < list.tagCount(); i++) {
NBTTagCompound recipeCompound = list.getCompoundTagAt(i);
RecipeCarpentry recipe = RecipeCarpentry.create(recipeCompound);
recipe.readNBT(recipeCompound);
RecipeController.syncRecipes.put(recipe.id, recipe);
}
RecipeController.reloadGlobalRecipes(RecipeController.syncRecipes);
RecipeController.syncRecipes = new HashMap<Integer, RecipeCarpentry>();
} else if (syncType == SyncType.CARPENTRY_RECIPES) {
NBTTagList list = fullCompound.getTagList("recipes", 10);
if (list == null)
return;
for (int i = 0; i < list.tagCount(); i++) {
NBTTagCompound recipeCompound = list.getCompoundTagAt(i);
RecipeCarpentry recipe = RecipeCarpentry.create(recipeCompound);
recipe.readNBT(recipeCompound);
RecipeController.syncRecipes.put(recipe.id, recipe);
}
RecipeController.Instance.carpentryRecipes = RecipeController.syncRecipes;
RecipeController.syncRecipes = new HashMap<Integer, RecipeCarpentry>();
} else if (syncType == SyncType.ANVIL_RECIPES) {
NBTTagList list = fullCompound.getTagList("recipes", 10);
if (list == null)
return;
for (int i = 0; i < list.tagCount(); i++) {
RecipeAnvil recipe = new RecipeAnvil();
recipe.readNBT(list.getCompoundTagAt(i));
RecipeController.syncAnvilRecipes.put(recipe.id, recipe);
}
RecipeController.Instance.anvilRecipes = RecipeController.syncAnvilRecipes;
RecipeController.syncAnvilRecipes = new HashMap<Integer, RecipeAnvil>();
} else if (syncType == SyncType.CUSTOM_EFFECTS) {
NBTTagList list = fullCompound.getTagList("Data", 10);
CustomEffectController ce = CustomEffectController.getInstance();
ce.customEffectsSync.clear();
for (int i = 0; i < list.tagCount(); i++) {
CustomEffect effect = new CustomEffect();
effect.readFromNBT(list.getCompoundTagAt(i));
ClientCacheHandler.getImageData(effect.icon);
ce.customEffectsSync.put(effect.id, effect);
}
ce.getCustomEffects().clear();
ce.getCustomEffects().putAll(ce.customEffectsSync);
ce.customEffectsSync.clear();
} else if (syncType == SyncType.CUSTOM_ABILITY) {
NBTTagList list = fullCompound.getTagList("Data", 10);
LinkedHashMap<String, Ability> sync = new LinkedHashMap<>();
for (int i = 0; i < list.tagCount(); i++) {
NBTTagCompound nbt = list.getCompoundTagAt(i);
String name = nbt.getString("CustomAbilityId");
Ability ability = AbilityController.Instance.fromNBT(nbt);
if (ability != null) {
ability.setName(name);
sync.put(name, ability);
}
}
AbilityController.Instance.setCustomAbilities(sync);
} else if (syncType == SyncType.CHAINED_ABILITY) {
NBTTagList list = fullCompound.getTagList("Data", 10);
LinkedHashMap<String, ChainedAbility> sync = new LinkedHashMap<>();
for (int i = 0; i < list.tagCount(); i++) {
NBTTagCompound nbt = list.getCompoundTagAt(i);
String id = nbt.getString("ChainedAbilityId");
ChainedAbility chain = new ChainedAbility();
chain.readNBT(nbt);
chain.setName(id);
sync.put(id, chain);
}
AbilityController.Instance.setChainedAbilities(sync);
}
ClientCacheHandler.updateClientRevision(syncType, revision);
}
@SideOnly(Side.CLIENT)
public static void clientUpdate(SyncType syncType, int category_id, int revision, NBTTagCompound compound) {
if (syncType == SyncType.FACTION) {
Faction faction = new Faction();
faction.readNBT(compound);
FactionController.getInstance().factions.put(faction.id, faction);
} else if (syncType == SyncType.DIALOG) {
DialogCategory category = DialogController.Instance.categories.get(category_id);
Dialog dialog = new Dialog();
dialog.category = category;
dialog.readNBT(compound);
DialogController.Instance.dialogs.put(dialog.id, dialog);
category.dialogs.put(dialog.id, dialog);
} else if (syncType == SyncType.QUEST) {
QuestCategory category = QuestController.Instance.categories.get(category_id);
Quest quest = new Quest();
quest.category = category;
quest.readNBT(compound);
QuestController.Instance.quests.put(quest.id, quest);
category.quests.put(quest.id, quest);
} else if (syncType == SyncType.QUEST_CATEGORY) {
QuestCategory category = new QuestCategory();
category.readSmallNBT(compound.getCompoundTag("CatNBT"));
NBTTagList list = compound.getTagList("Data", 10);
if (QuestController.Instance.categoriesSync.containsKey(category.id)) {
category = QuestController.Instance.categoriesSync.get(category.id);
category.readSmallNBT(compound.getCompoundTag("CatNBT"));
}
for (int i = 0; i < list.tagCount(); i++) {
Quest quest = new Quest();
quest.readNBT(list.getCompoundTagAt(i));
quest.category = category;
category.quests.put(quest.id, quest);
}
QuestController.Instance.categories.put(category.id, category);
} else if (syncType == SyncType.DIALOG_CATEGORY) {
DialogCategory category = new DialogCategory();
category.readSmallNBT(compound.getCompoundTag("CatNBT"));
NBTTagList list = compound.getTagList("Data", 10);
if (DialogController.Instance.categoriesSync.containsKey(category.id)) {
category = DialogController.Instance.categoriesSync.get(category.id);
category.readSmallNBT(compound.getCompoundTag("CatNBT"));
}
for (int i = 0; i < list.tagCount(); i++) {
Dialog dialog = new Dialog();
dialog.readNBT(list.getCompoundTagAt(i));
dialog.category = category;
category.dialogs.put(dialog.id, dialog);
}
DialogController.Instance.categories.put(category.id, category);
} else if (syncType == SyncType.MAGIC_CYCLE) {
MagicCycle cycle = new MagicCycle();
cycle.readNBT(compound);
MagicController.getInstance().cycles.put(cycle.id, cycle);
} else if (syncType == SyncType.MAGIC) {
Magic magic = new Magic();
magic.readNBT(compound);
MagicController.getInstance().magics.put(magic.id, magic);
} else if (syncType == SyncType.PLAYERDATA) {
ClientCacheHandler.playerData.setSyncNBT(compound);
} else if (syncType == SyncType.CUSTOM_EFFECTS) {
CustomEffect effect = new CustomEffect();
effect.readFromNBT(compound);
ClientCacheHandler.getImageData(effect.icon);
CustomEffectController.Instance.getCustomEffects().put(effect.id, effect);
}
ClientCacheHandler.updateClientRevision(syncType, revision);
}
public static void syncUpdate(SyncType type, int cat, NBTTagCompound compound) {
Map<SyncType, Integer> revisions = invalidateCaches(type);
int revision = revisions.getOrDefault(type, getCurrentRevision(type));
PacketHandler.Instance.sendToAll(new SyncPacket(
type,
EnumSyncAction.UPDATE,
cat,
revision,
compound
));
PacketHandler.Instance.sendToAll(new SyncPacket(type, EnumSyncAction.UPDATE, cat, revision, compound));
updateAllPlayerRevisions(revisions);
}
// ═══════════════════════════════════════════════════════════════════════
// Client-side dispatch — registry-driven handler delegation
// ═══════════════════════════════════════════════════════════════════════
public static NBTTagCompound updateQuestCat(QuestCategory questCategory) {
NBTTagCompound questCompound = new NBTTagCompound();
NBTTagList questList = new NBTTagList();
for (int questID : questCategory.quests.keySet()) {
Quest quest = questCategory.quests.get(questID);
questList.appendTag(quest.writeToNBT(new NBTTagCompound()));
}
questCompound.setTag("Data", questList);
questCompound.setTag("CatNBT", questCategory.writeSmallNBT(new NBTTagCompound()));
return questCompound;
@SideOnly(Side.CLIENT)
public static void clientSync(SyncType syncType, int revision, NBTTagCompound fullCompound) {
SyncHandler handler = SyncRegistry.getHandler(syncType);
if (handler != null)
handler.clientHandleReload(fullCompound);
ClientCacheHandler.updateClientRevision(syncType, revision);
}
public static NBTTagCompound updateDialogCat(DialogCategory dialogCategory) {
NBTTagCompound dialogCompound = new NBTTagCompound();
NBTTagList dialogList = new NBTTagList();
for (int questID : dialogCategory.dialogs.keySet()) {
Dialog dialog = dialogCategory.dialogs.get(questID);
dialogList.appendTag(dialog.writeToNBT(new NBTTagCompound()));
}
dialogCompound.setTag("Data", dialogList);
dialogCompound.setTag("CatNBT", dialogCategory.writeSmallNBT(new NBTTagCompound()));
return dialogCompound;
@SideOnly(Side.CLIENT)
public static void clientUpdate(SyncType syncType, int category_id, int revision, NBTTagCompound compound) {
SyncHandler handler = SyncRegistry.getHandler(syncType);
if (handler != null)
handler.clientHandleUpdate(compound, category_id);
ClientCacheHandler.updateClientRevision(syncType, revision);
}
@SideOnly(Side.CLIENT)
public static void clientSyncRemove(SyncType syncType, int id, int revision) {
if (syncType == SyncType.FACTION) {
FactionController.getInstance().factions.remove(id);
} else if (syncType == SyncType.DIALOG) {
Dialog dialog = DialogController.Instance.dialogs.remove(id);
if (dialog != null) {
dialog.category.dialogs.remove(id);
}
} else if (syncType == SyncType.DIALOG_CATEGORY) {
DialogCategory dialogCategory = DialogController.Instance.categories.remove(id);
if (dialogCategory != null) {
DialogController.Instance.dialogs.keySet().removeAll(dialogCategory.dialogs.keySet());
}
} else if (syncType == SyncType.QUEST) {
Quest quest = QuestController.Instance.quests.remove(id);
if (quest != null) {
quest.category.quests.remove(id);
}
} else if (syncType == SyncType.QUEST_CATEGORY) {
QuestCategory questCategory = QuestController.Instance.categories.remove(id);
if (questCategory != null) {
QuestController.Instance.quests.keySet().removeAll(questCategory.quests.keySet());
}
} else if (syncType == SyncType.MAGIC) {
for (MagicCycle cycle : MagicController.getInstance().cycles.values()) {
cycle.associations.remove(id);
}
MagicController.getInstance().cycles.remove(id);
} else if (syncType == SyncType.MAGIC_CYCLE) {
MagicController.getInstance().cycles.remove(id);
} else if (syncType == SyncType.CUSTOM_EFFECTS) {
CustomEffectController.Instance.getCustomEffects().remove(id);
}
SyncHandler handler = SyncRegistry.getHandler(syncType);
if (handler != null)
handler.clientHandleRemove(id);
ClientCacheHandler.updateClientRevision(syncType, revision);
}
public static void syncEffects(EntityPlayerMP playerMP) {
ConcurrentHashMap<EffectKey, PlayerEffect> playerEffects = CustomEffectController.getInstance().getPlayerEffects(playerMP);
PlayerData playerData = PlayerData.get(playerMP);
playerData.effectData.setEffects(playerEffects);
NBTTagCompound compound = playerData.getPlayerEffects();
PacketHandler.Instance.sendToPlayer(new SyncEffectPacket(compound), playerMP);
}
/**
* Full sync of all player ability state to the client: unlocked abilities,
* selection, toggles, hotbar layout, and cooldowns.
* Used for entity reconstruction and other full-refresh scenarios.
*/
public static void syncAbilities(EntityPlayerMP playerMP) {
PlayerData playerData = PlayerData.get(playerMP);
if (playerData == null) return;
PlayerAbilitySyncPacket.sendToPlayer(playerMP);
AbilityHotbarSyncPacket.sendToPlayer(playerMP);
AbilityCooldownSyncPacket.sendToPlayer(playerMP);
}
/**
* Lightweight sync of cooldown state only (global + per-ability).
* Called periodically (every 10 ticks) to keep the client's cooldown
* display accurate. Cooldowns are transient and not part of NBT sync.
*/
public static void syncAbilityCooldowns(EntityPlayerMP playerMP) {
PlayerData playerData = PlayerData.get(playerMP);
if (playerData == null) return;
AbilityCooldownSyncPacket.sendToPlayer(playerMP);
}
@SideOnly(Side.CLIENT)
public static void clientSyncEffects(NBTTagCompound compound) {
PlayerData playerData = PlayerData.get(Minecraft.getMinecraft().thePlayer);
if (playerData != null) {
playerData.setPlayerEffects(compound);
}
}
// ═══════════════════════════════════════════════════════════════════════
// Cache and revision internals
// ═══════════════════════════════════════════════════════════════════════
private static void registerCache(SyncType type, Supplier<NBTTagCompound> supplier) {
cacheEntries.put(type, new SyncCacheEntry(supplier));
@@ -863,15 +323,19 @@ public class SyncController {
private static CachedSyncPayload rebuildNow(SyncType type) {
SyncCacheEntry entry = cacheEntries.get(type);
if (entry == null) {
if (entry == null)
return null;
}
entry.invalidate();
return entry.getPayload(type);
}
/**
* Registry-driven invalidation: delegates to handler-owned
* invalidation targets via {@link SyncRegistry#getInvalidationTargets}.
*/
public static Map<SyncType, Integer> invalidateCaches(SyncType type) {
Set<SyncType> targets = getInvalidationTargets(type);
Set<SyncType> targets = SyncRegistry.getInvalidationTargets(type);
Map<SyncType, Integer> revisions = new LinkedHashMap<>();
for (SyncType target : targets) {
SyncCacheEntry entry = cacheEntries.get(target);
@@ -883,55 +347,6 @@ public class SyncController {
return revisions;
}
private static Set<SyncType> getInvalidationTargets(SyncType type) {
if (type == SyncType.DIALOG || type == SyncType.DIALOG_CATEGORY) {
Set<SyncType> set = new HashSet<>();
set.add(SyncType.DIALOG_CATEGORY);
return set;
} else if (type == SyncType.QUEST || type == SyncType.QUEST_CATEGORY) {
Set<SyncType> set = new HashSet<>();
set.add(SyncType.QUEST_CATEGORY);
return set;
} else if (type == SyncType.FACTION) {
Set<SyncType> set = new HashSet<>();
set.add(SyncType.FACTION);
return set;
} else if (type == SyncType.MAGIC) {
Set<SyncType> set = new HashSet<>();
set.add(SyncType.MAGIC);
return set;
} else if (type == SyncType.MAGIC_CYCLE) {
Set<SyncType> set = new HashSet<>();
set.add(SyncType.MAGIC_CYCLE);
return set;
} else if (type == SyncType.WORKBENCH_RECIPES) {
Set<SyncType> set = new HashSet<>();
set.add(SyncType.WORKBENCH_RECIPES);
return set;
} else if (type == SyncType.CARPENTRY_RECIPES) {
Set<SyncType> set = new HashSet<>();
set.add(SyncType.CARPENTRY_RECIPES);
return set;
} else if (type == SyncType.ANVIL_RECIPES) {
Set<SyncType> set = new HashSet<>();
set.add(SyncType.ANVIL_RECIPES);
return set;
} else if (type == SyncType.CUSTOM_EFFECTS) {
Set<SyncType> set = new HashSet<>();
set.add(SyncType.CUSTOM_EFFECTS);
return set;
} else if (type == SyncType.CUSTOM_ABILITY) {
Set<SyncType> set = new HashSet<>();
set.add(SyncType.CUSTOM_ABILITY);
return set;
} else if (type == SyncType.CHAINED_ABILITY) {
Set<SyncType> set = new HashSet<>();
set.add(SyncType.CHAINED_ABILITY);
return set;
}
return Collections.emptySet();
}
private static void updateAllPlayerRevisions(SyncType type, int revision) {
if (revision < 0) {
return;
@@ -952,6 +367,10 @@ public class SyncController {
}
}
// ═══════════════════════════════════════════════════════════════════════
// Inner classes — cache payload and player revision state
// ═══════════════════════════════════════════════════════════════════════
public static final class CachedSyncPayload {
private final int revision;
private final byte[] payload;