Merge branch 'development' into stable

src/main/java/emu/grasscutter/data/def/ReliquarySetData.java → src/main/java/emu/grasscutter/data/excels/ReliquarySetData.java

-package emu.grasscutter.data.def;
+package emu.grasscutter.data.excels;
 
 import emu.grasscutter.data.GameResource;
 import emu.grasscutter.data.ResourceType;
 
 @ResourceType(name = "ReliquarySetExcelConfigData.json")
 public class ReliquarySetData extends GameResource {
-	private int SetId;
-    private int[] SetNeedNum;
+	private int setId;
+    private int[] setNeedNum;
     private int EquipAffixId;
-    private int DisableFilter;
-    private int[] ContainsList;
+    private int disableFilter;
+    private int[] containsList;
 	
 	@Override
 	public int getId() {
-		return SetId;
+		return setId;
 	}
 	
 	public int[] getSetNeedNum() {
-		return SetNeedNum;
+		return setNeedNum;
 	}
 
 	public int getEquipAffixId() {
@@ -25,11 +25,11 @@ public class ReliquarySetData extends GameResource {
 	}
 
 	public int getDisableFilter() {
-		return DisableFilter;
+		return disableFilter;
 	}
 
 	public int[] getContainsList() {
-		return ContainsList;
+		return containsList;
 	}
 
 	@Override

src/main/java/emu/grasscutter/data/def/RewardData.java → src/main/java/emu/grasscutter/data/excels/RewardData.java

-package emu.grasscutter.data.def;
-
-import java.util.List;
-
-import emu.grasscutter.data.GameResource;
-import emu.grasscutter.data.ResourceType;
-import emu.grasscutter.data.common.RewardItemData;
-
-@ResourceType(name = "RewardExcelConfigData.json")
-public class RewardData extends GameResource {
-    public int RewardId;
-    public List<RewardItemData> RewardItemList;
-
-    @Override
-	public int getId() {
-		return RewardId;
-	}
-
-    public List<RewardItemData> getRewardItemList() {
-        return RewardItemList;
-    }
-
-    @Override
-    public void onLoad() {
-
-    }
-}
+package emu.grasscutter.data.excels;
+
+import java.util.List;
+
+import emu.grasscutter.data.GameResource;
+import emu.grasscutter.data.ResourceType;
+import emu.grasscutter.data.common.ItemParamData;
+
+@ResourceType(name = "RewardExcelConfigData.json")
+public class RewardData extends GameResource {
+    public int rewardId;
+    public List<ItemParamData> rewardItemList;
+
+    @Override
+	public int getId() {
+		return rewardId;
+	}
+
+    public List<ItemParamData> getRewardItemList() {
+        return rewardItemList;
+    }
+
+    @Override
+    public void onLoad() {
+    	rewardItemList = rewardItemList.stream().filter(i -> i.getId() > 0).toList();
+    }
+}

src/main/java/emu/grasscutter/data/def/RewardPreviewData.java → src/main/java/emu/grasscutter/data/excels/RewardPreviewData.java

-package emu.grasscutter.data.def;
+package emu.grasscutter.data.excels;
 
 import java.util.Arrays;
 import java.util.List;
@@ -16,28 +16,28 @@ import emu.grasscutter.data.common.ItemParamStringData;
 
 @ResourceType(name = "RewardPreviewExcelConfigData.json", loadPriority = LoadPriority.HIGH)
 public class RewardPreviewData extends GameResource {
-	private int Id;
-	private ItemParamStringData[] PreviewItems;
-	private ItemParamData[] PreviewItemsArray;
+	private int id;
+	private ItemParamStringData[] previewItems;
+	private ItemParamData[] previewItemsArray;
 	
 	@Override
 	public int getId() {
-		return this.Id;
+		return this.id;
 	}
 
 	public ItemParamData[] getPreviewItems() {
-		return PreviewItemsArray;
+		return previewItemsArray;
 	}
 
 	@Override
 	public void onLoad() {
-		if (this.PreviewItems != null && this.PreviewItems.length > 0) {
-			this.PreviewItemsArray = Arrays.stream(this.PreviewItems)
+		if (this.previewItems != null && this.previewItems.length > 0) {
+			this.previewItemsArray = Arrays.stream(this.previewItems)
 					.filter(d -> d.getId() > 0 && d.getCount() != null && !d.getCount().isEmpty())
 					.map(ItemParamStringData::toItemParamData)
 					.toArray(size -> new ItemParamData[size]);
 		} else {
-			this.PreviewItemsArray = new ItemParamData[0];
+			this.previewItemsArray = new ItemParamData[0];
 		}
 	}
 }

src/main/java/emu/grasscutter/data/def/SceneData.java → src/main/java/emu/grasscutter/data/excels/SceneData.java

-package emu.grasscutter.data.def;
+package emu.grasscutter.data.excels;
 
 import emu.grasscutter.data.GameData;
 import emu.grasscutter.data.GameResource;
@@ -8,22 +8,21 @@ import emu.grasscutter.game.props.SceneType;
 
 @ResourceType(name = "SceneExcelConfigData.json")
 public class SceneData extends GameResource {
-	private int Id;
-	private SceneType Type;
-	private String ScriptData;
+	private int id;
+	private SceneType type;
+	private String scriptData;
 
-	    
 	@Override
 	public int getId() {
-		return this.Id;
+		return this.id;
 	}
 
 	public SceneType getSceneType() {
-		return Type;
+		return type;
 	}
 
 	public String getScriptData() {
-		return ScriptData;
+		return scriptData;
 	}
 
 	@Override

src/main/java/emu/grasscutter/data/def/ShopGoodsData.java → src/main/java/emu/grasscutter/data/excels/ShopGoodsData.java

-package emu.grasscutter.data.def;
+package emu.grasscutter.data.excels;
 
 import emu.grasscutter.data.GameResource;
 import emu.grasscutter.data.ResourceType;
@@ -9,34 +9,34 @@ import java.util.List;
 
 @ResourceType(name = "ShopGoodsExcelConfigData.json")
 public class ShopGoodsData extends GameResource {
-    private int GoodsId;
-    private int ShopType;
-    private int ItemId;
+    private int goodsId;
+    private int shopType;
+    private int itemId;
 
-    private int ItemCount;
+    private int itemCount;
 
-    private int CostScoin;
-    private int CostHcoin;
-    private int CostMcoin;
+    private int costScoin;
+    private int costHcoin;
+    private int costMcoin;
 
-    private List<ItemParamData> CostItems;
-    private int MinPlayerLevel;
-    private int MaxPlayerLevel;
+    private List<ItemParamData> costItems;
+    private int minPlayerLevel;
+    private int maxPlayerLevel;
 
-    private int BuyLimit;
-    private int SubTabId;
+    private int buyLimit;
+    private int subTabId;
 
-    private String RefreshType;
-    private transient ShopInfo.ShopRefreshType RefreshTypeEnum;
+    private String refreshType;
+    private transient ShopInfo.ShopRefreshType refreshTypeEnum;
     
-    private int RefreshParam;
+    private int refreshParam;
 
     @Override
     public void onLoad() {
-       if (this.RefreshType == null)
-           this.RefreshTypeEnum = ShopInfo.ShopRefreshType.NONE;
+       if (this.refreshType == null)
+           this.refreshTypeEnum = ShopInfo.ShopRefreshType.NONE;
        else {
-           this.RefreshTypeEnum = switch (this.RefreshType) {
+           this.refreshTypeEnum = switch (this.refreshType) {
                case "SHOP_REFRESH_DAILY" -> ShopInfo.ShopRefreshType.SHOP_REFRESH_DAILY;
                case "SHOP_REFRESH_WEEKLY" -> ShopInfo.ShopRefreshType.SHOP_REFRESH_WEEKLY;
                case "SHOP_REFRESH_MONTHLY" -> ShopInfo.ShopRefreshType.SHOP_REFRESH_MONTHLY;
@@ -51,58 +51,58 @@ public class ShopGoodsData extends GameResource {
     }
 
     public int getGoodsId() {
-        return GoodsId;
+        return goodsId;
     }
 
     public int getShopType() {
-        return ShopType;
+        return shopType;
     }
 
     public int getItemId() {
-        return ItemId;
+        return itemId;
     }
 
     public int getItemCount() {
-        return ItemCount;
+        return itemCount;
     }
 
     public int getCostScoin() {
-        return CostScoin;
+        return costScoin;
     }
 
     public int getCostHcoin() {
-        return CostHcoin;
+        return costHcoin;
     }
 
     public int getCostMcoin() {
-        return CostMcoin;
+        return costMcoin;
     }
 
     public List<ItemParamData> getCostItems() {
-        return CostItems;
+        return costItems;
     }
 
     public int getMinPlayerLevel() {
-        return MinPlayerLevel;
+        return minPlayerLevel;
     }
 
     public int getMaxPlayerLevel() {
-        return MaxPlayerLevel;
+        return maxPlayerLevel;
     }
 
     public int getBuyLimit() {
-        return BuyLimit;
+        return buyLimit;
     }
 
     public int getSubTabId() {
-        return SubTabId;
+        return subTabId;
     }
 
     public ShopInfo.ShopRefreshType getRefreshType() {
-        return RefreshTypeEnum;
+        return refreshTypeEnum;
     }
 
     public int getRefreshParam() {
-        return RefreshParam;
+        return refreshParam;
     }
 }

src/main/java/emu/grasscutter/data/def/TowerFloorData.java → src/main/java/emu/grasscutter/data/excels/TowerFloorData.java

-package emu.grasscutter.data.def;
+package emu.grasscutter.data.excels;
 
 import emu.grasscutter.data.GameResource;
 import emu.grasscutter.data.ResourceType;
@@ -6,16 +6,16 @@ import emu.grasscutter.data.ResourceType;
 @ResourceType(name = "TowerFloorExcelConfigData.json")
 public class TowerFloorData extends GameResource {
 
-    private int FloorId;
-    private int FloorIndex;
-    private int LevelId;
-    private int OverrideMonsterLevel;
-    private int TeamNum;
-    private int FloorLevelConfigId;
+    private int floorId;
+    private int floorIndex;
+    private int levelGroupId;
+    private int overrideMonsterLevel;
+    private int teamNum;
+    private int floorLevelConfigId;
 
     @Override
     public int getId() {
-        return this.FloorId;
+        return this.floorId;
     }
 
     @Override
@@ -24,50 +24,26 @@ public class TowerFloorData extends GameResource {
     }
 
     public int getFloorId() {
-        return FloorId;
-    }
-
-    public void setFloorId(int floorId) {
-        FloorId = floorId;
+        return floorId;
     }
 
     public int getFloorIndex() {
-        return FloorIndex;
-    }
-
-    public void setFloorIndex(int floorIndex) {
-        FloorIndex = floorIndex;
-    }
-
-    public int getLevelId() {
-        return LevelId;
+        return floorIndex;
     }
 
-    public void setLevelId(int levelId) {
-        LevelId = levelId;
+    public int getLevelGroupId() {
+        return levelGroupId;
     }
 
     public int getOverrideMonsterLevel() {
-        return OverrideMonsterLevel;
-    }
-
-    public void setOverrideMonsterLevel(int overrideMonsterLevel) {
-        OverrideMonsterLevel = overrideMonsterLevel;
+        return overrideMonsterLevel;
     }
 
     public int getTeamNum() {
-        return TeamNum;
-    }
-
-    public void setTeamNum(int teamNum) {
-        TeamNum = teamNum;
+        return teamNum;
     }
 
     public int getFloorLevelConfigId() {
-        return FloorLevelConfigId;
-    }
-
-    public void setFloorLevelConfigId(int floorLevelConfigId) {
-        FloorLevelConfigId = floorLevelConfigId;
+        return floorLevelConfigId;
     }
 }

src/main/java/emu/grasscutter/data/def/TowerLevelData.java → src/main/java/emu/grasscutter/data/excels/TowerLevelData.java

-package emu.grasscutter.data.def;
+package emu.grasscutter.data.excels;
 
 import emu.grasscutter.data.GameResource;
 import emu.grasscutter.data.ResourceType;
 
 @ResourceType(name = "TowerLevelExcelConfigData.json")
 public class TowerLevelData extends GameResource {
-
-    private int ID;
-    private int LevelId;
-    private int LevelIndex;
-    private int DungeonId;
+	
+    private int levelId;
+    private int levelIndex;
+    private int levelGroupId;
+    private int dungeonId;
 
     @Override
     public int getId() {
-        return this.ID;
-    }
-
-    @Override
-    public void onLoad() {
-        super.onLoad();
-    }
-
-    public int getID() {
-        return ID;
-    }
-
-    public void setID(int ID) {
-        this.ID = ID;
+        return this.getLevelId();
     }
 
     public int getLevelId() {
-        return LevelId;
+        return levelId;
     }
 
-    public void setLevelId(int levelId) {
-        LevelId = levelId;
+    public int getLevelGroupId() {
+        return levelGroupId;
     }
 
     public int getLevelIndex() {
-        return LevelIndex;
-    }
-
-    public void setLevelIndex(int levelIndex) {
-        LevelIndex = levelIndex;
+        return levelIndex;
     }
 
     public int getDungeonId() {
-        return DungeonId;
-    }
-
-    public void setDungeonId(int dungeonId) {
-        DungeonId = dungeonId;
+        return dungeonId;
     }
 }

src/main/java/emu/grasscutter/data/excels/TowerScheduleData.java

+package emu.grasscutter.data.excels;
+
+import emu.grasscutter.data.GameResource;
+import emu.grasscutter.data.ResourceType;
+
+import java.util.List;
+
+@ResourceType(name = "TowerScheduleExcelConfigData.json")
+public class TowerScheduleData extends GameResource {
+    private int scheduleId;
+    private List<Integer> entranceFloorId;
+    private List<ScheduleDetail> schedules;
+    private int monthlyLevelConfigId;
+    
+    @Override
+    public int getId() {
+        return scheduleId;
+    }
+
+    @Override
+    public void onLoad() {
+        super.onLoad();
+        this.schedules = this.schedules.stream()
+                .filter(item -> item.getFloorList().size() > 0)
+                .toList();
+    }
+
+    public int getScheduleId() {
+        return scheduleId;
+    }
+
+    public List<Integer> getEntranceFloorId() {
+        return entranceFloorId;
+    }
+
+    public List<ScheduleDetail> getSchedules() {
+        return schedules;
+    }
+    
+    public int getMonthlyLevelConfigId() {
+        return monthlyLevelConfigId;
+    }
+
+    public static class ScheduleDetail{
+        private List<Integer> floorList;
+
+        public List<Integer> getFloorList() {
+            return floorList;
+        }
+    }
+}

src/main/java/emu/grasscutter/data/def/WeaponCurveData.java → src/main/java/emu/grasscutter/data/excels/WeaponCurveData.java

-package emu.grasscutter.data.def;
+package emu.grasscutter.data.excels;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -10,23 +10,23 @@ import emu.grasscutter.data.common.CurveInfo;
 
 @ResourceType(name = "WeaponCurveExcelConfigData.json")
 public class WeaponCurveData extends GameResource {
-	private int Level;
-    private CurveInfo[] CurveInfos;
+	private int level;
+    private CurveInfo[] curveInfos;
     
-    private Map<String, Float> curveInfos;
+    private Map<String, Float> curveInfosMap;
 	
 	@Override
 	public int getId() {
-		return Level;
+		return level;
 	}
 	
 	public float getMultByProp(String fightProp) {
-		return curveInfos.getOrDefault(fightProp, 1f);
+		return curveInfosMap.getOrDefault(fightProp, 1f);
 	}
 
 	@Override
 	public void onLoad() {
-		this.curveInfos = new HashMap<>();
-		Stream.of(this.CurveInfos).forEach(info -> this.curveInfos.put(info.getType(), info.getValue()));
+		this.curveInfosMap = new HashMap<>();
+		Stream.of(this.curveInfos).forEach(info -> this.curveInfosMap.put(info.getType(), info.getValue()));
 	}
 }

src/main/java/emu/grasscutter/data/def/WeaponLevelData.java → src/main/java/emu/grasscutter/data/excels/WeaponLevelData.java

-package emu.grasscutter.data.def;
+package emu.grasscutter.data.excels;
 
 import emu.grasscutter.data.GameResource;
 import emu.grasscutter.data.ResourceType;
 
 @ResourceType(name = "WeaponLevelExcelConfigData.json")
 public class WeaponLevelData extends GameResource {
-	private int Level;
-	private int[] RequiredExps;
+	private int level;
+	private int[] requiredExps;
 	
 	@Override
 	public int getId() {
-		return this.Level;
+		return this.level;
 	}
 	
 	public int getLevel() {
-		return Level;
+		return level;
 	}
 	
 	public int[] getRequiredExps() {
-		return RequiredExps;
+		return requiredExps;
 	}
 }

src/main/java/emu/grasscutter/data/def/WeaponPromoteData.java → src/main/java/emu/grasscutter/data/excels/WeaponPromoteData.java

-package emu.grasscutter.data.def;
+package emu.grasscutter.data.excels;
 
 import java.util.ArrayList;
 import emu.grasscutter.data.GameResource;
@@ -9,45 +9,45 @@ import emu.grasscutter.data.common.ItemParamData;
 @ResourceType(name = "WeaponPromoteExcelConfigData.json")
 public class WeaponPromoteData extends GameResource {
 	
-	private int WeaponPromoteId;
-    private int PromoteLevel;
-    private ItemParamData[] CostItems;
-    private int CoinCost;
-    private FightPropData[] AddProps;
-    private int UnlockMaxLevel;
-    private int RequiredPlayerLevel;
+	private int weaponPromoteId;
+    private int promoteLevel;
+    private ItemParamData[] costItems;
+    private int coinCost;
+    private FightPropData[] addProps;
+    private int unlockMaxLevel;
+    private int requiredPlayerLevel;
 	
 	@Override
 	public int getId() {
-		return (WeaponPromoteId << 8) + PromoteLevel;
+		return (weaponPromoteId << 8) + promoteLevel;
 	}
 
 	public int getWeaponPromoteId() {
-		return WeaponPromoteId;
+		return weaponPromoteId;
 	}
 
 	public int getPromoteLevel() {
-		return PromoteLevel;
+		return promoteLevel;
 	}
 
 	public ItemParamData[] getCostItems() {
-		return CostItems;
+		return costItems;
 	}
 
 	public int getCoinCost() {
-		return CoinCost;
+		return coinCost;
 	}
 
 	public FightPropData[] getAddProps() {
-		return AddProps;
+		return addProps;
 	}
 
 	public int getUnlockMaxLevel() {
-		return UnlockMaxLevel;
+		return unlockMaxLevel;
 	}
 
 	public int getRequiredPlayerLevel() {
-		return RequiredPlayerLevel;
+		return requiredPlayerLevel;
 	}
 
 	@Override
@@ -60,7 +60,7 @@ public class WeaponPromoteData extends GameResource {
 			}
 			trim.add(itemParam);
 		}
-		this.CostItems = trim.toArray(new ItemParamData[trim.size()]);
+		this.costItems = trim.toArray(new ItemParamData[trim.size()]);
 		// Trim fight prop data
 		ArrayList<FightPropData> parsed = new ArrayList<>(getAddProps().length);
 		for (FightPropData prop : getAddProps()) {
@@ -69,6 +69,6 @@ public class WeaponPromoteData extends GameResource {
 				parsed.add(prop);
 			}
 		}
-		this.AddProps = parsed.toArray(new FightPropData[parsed.size()]);
+		this.addProps = parsed.toArray(new FightPropData[parsed.size()]);
 	}
 }

src/main/java/emu/grasscutter/data/def/WorldLevelData.java → src/main/java/emu/grasscutter/data/excels/WorldLevelData.java

-package emu.grasscutter.data.def;
+package emu.grasscutter.data.excels;
 
 import emu.grasscutter.data.GameResource;
 import emu.grasscutter.data.ResourceType;
 
 @ResourceType(name = "WorldLevelExcelConfigData.json")
 public class WorldLevelData extends GameResource {
-	private int Level;
-	private int MonsterLevel;
+	private int level;
+	private int monsterLevel;
 	    
 	@Override
 	public int getId() {
-		return this.Level;
+		return this.level;
 	}
 
 	public int getMonsterLevel() {
-		return MonsterLevel;
+		return monsterLevel;
 	}
 
 	@Override

src/main/java/emu/grasscutter/database/DatabaseHelper.java

@@ -3,10 +3,12 @@ package emu.grasscutter.database;
 import java.util.List;
 
 import com.mongodb.client.result.DeleteResult;
+
 import dev.morphia.query.FindOptions;
 import dev.morphia.query.Sort;
 import dev.morphia.query.experimental.filters.Filters;
 import emu.grasscutter.GameConstants;
+import emu.grasscutter.Grasscutter;
 import emu.grasscutter.game.Account;
 import emu.grasscutter.game.avatar.Avatar;
 import emu.grasscutter.game.friends.Friendship;
@@ -14,27 +16,34 @@ import emu.grasscutter.game.gacha.GachaRecord;
 import emu.grasscutter.game.inventory.GameItem;
 import emu.grasscutter.game.mail.Mail;
 import emu.grasscutter.game.player.Player;
+import emu.grasscutter.game.quest.GameMainQuest;
+
+import static com.mongodb.client.model.Filters.eq;
 
 public final class DatabaseHelper {
 	public static Account createAccount(String username) {
-		return createAccountWithId(username, 0);
+		return createAccountWithUid(username, 0);
 	}
 
-	public static Account createAccountWithId(String username, int reservedId) {
+	public static Account createAccountWithUid(String username, int reservedUid) {
 		// Unique names only
-		Account exists = DatabaseHelper.getAccountByName(username);
-		if (exists != null) {
+		if (DatabaseHelper.checkIfAccountExists(username)) {
 			return null;
 		}
 
 		// Make sure there are no id collisions
-		if (reservedId > 0) {
+		if (reservedUid > 0) {
 			// Cannot make account with the same uid as the server console
-			if (reservedId == GameConstants.SERVER_CONSOLE_UID) {
+			if (reservedUid == GameConstants.SERVER_CONSOLE_UID) {
+				return null;
+			}
+			
+			if (DatabaseHelper.checkIfAccountExists(reservedUid)) {
 				return null;
 			}
-			exists = DatabaseHelper.getAccountByPlayerId(reservedId);
-			if (exists != null) {
+			
+			// Make sure no existing player already has this id.
+			if (DatabaseHelper.checkIfPlayerExists(reservedUid)) {
 				return null;
 			}
 		}
@@ -44,8 +53,8 @@ public final class DatabaseHelper {
 		account.setUsername(username);
 		account.setId(Integer.toString(DatabaseManager.getNextId(account)));
 
-		if (reservedId > 0) {
-			account.setPlayerId(reservedId);
+		if (reservedUid > 0) {
+			account.setReservedPlayerUid(reservedUid);
 		}
 
 		DatabaseHelper.saveAccount(account);
@@ -74,118 +83,158 @@ public final class DatabaseHelper {
 	}
 
 	public static Account getAccountByName(String username) {
-		return DatabaseManager.getDatastore().find(Account.class).filter(Filters.eq("username", username)).first();
+		return DatabaseManager.getGameDatastore().find(Account.class).filter(Filters.eq("username", username)).first();
 	}
 
 	public static Account getAccountByToken(String token) {
 		if(token == null) return null;
-		return DatabaseManager.getDatastore().find(Account.class).filter(Filters.eq("token", token)).first();
+		return DatabaseManager.getGameDatastore().find(Account.class).filter(Filters.eq("token", token)).first();
 	}
 
 	public static Account getAccountBySessionKey(String sessionKey) {
 		if(sessionKey == null) return null;
-		return DatabaseManager.getDatastore().find(Account.class).filter(Filters.eq("sessionKey", sessionKey)).first();
+		return DatabaseManager.getGameDatastore().find(Account.class).filter(Filters.eq("sessionKey", sessionKey)).first();
 	}
 
 	public static Account getAccountById(String uid) {
-		return DatabaseManager.getDatastore().find(Account.class).filter(Filters.eq("_id", uid)).first();
+		return DatabaseManager.getGameDatastore().find(Account.class).filter(Filters.eq("_id", uid)).first();
 	}
 
 	public static Account getAccountByPlayerId(int playerId) {
-		return DatabaseManager.getDatastore().find(Account.class).filter(Filters.eq("playerId", playerId)).first();
+		return DatabaseManager.getGameDatastore().find(Account.class).filter(Filters.eq("reservedPlayerId", playerId)).first();
 	}
-
-	public static boolean deleteAccount(String username) {
-		return DatabaseManager.getDatastore().find(Account.class).filter(Filters.eq("username", username)).delete().getDeletedCount() > 0;
+	
+	public static boolean checkIfAccountExists(String name) {
+		return DatabaseManager.getGameDatastore().find(Account.class).filter(Filters.eq("username", name)).count() > 0;
+	}
+	
+	public static boolean checkIfAccountExists(int reservedUid) {
+		return DatabaseManager.getGameDatastore().find(Account.class).filter(Filters.eq("reservedPlayerId", reservedUid)).count() > 0;
+	}
+
+	public static void deleteAccount(Account target) {
+		// To delete an account, we need to also delete all the other documents in the database that reference the account.
+		// This should optimally be wrapped inside a transaction, to make sure an error thrown mid-way does not leave the
+		// database in an inconsistent state, but unfortunately Mongo only supports that when we have a replica set ...
+
+		Player player = Grasscutter.getGameServer().getPlayerByAccountId(target.getId());
+		
+        if (player != null) {
+        	// Close session first
+            player.getSession().close();
+            
+            // Delete data from collections
+    		DatabaseManager.getGameDatabase().getCollection("mail").deleteMany(eq("ownerUid", player.getUid()));
+    		DatabaseManager.getGameDatabase().getCollection("avatars").deleteMany(eq("ownerId", player.getUid()));
+    		DatabaseManager.getGameDatabase().getCollection("gachas").deleteMany(eq("ownerId", player.getUid()));
+    		DatabaseManager.getGameDatabase().getCollection("items").deleteMany(eq("ownerId", player.getUid()));
+    		DatabaseManager.getGameDatabase().getCollection("quests").deleteMany(eq("ownerUid", player.getUid()));
+
+    		// Delete friendships.
+    		// Here, we need to make sure to not only delete the deleted account's friendships,
+    		// but also all friendship entries for that account's friends.
+    		DatabaseManager.getGameDatabase().getCollection("friendships").deleteMany(eq("ownerId", player.getUid()));
+    		DatabaseManager.getGameDatabase().getCollection("friendships").deleteMany(eq("friendId", player.getUid()));
+
+    		// Delete the player last.
+    		DatabaseManager.getGameDatastore().find(Player.class).filter(Filters.eq("id", player.getUid())).delete();
+        }
+
+		// Finally, delete the account itself.
+		DatabaseManager.getGameDatastore().find(Account.class).filter(Filters.eq("id", target.getId())).delete();
 	}
 
 	public static List<Player> getAllPlayers() {
-		return DatabaseManager.getDatastore().find(Player.class).stream().toList();
+		return DatabaseManager.getGameDatastore().find(Player.class).stream().toList();
 	}
 
-	public static Player getPlayerById(int id) {
-		return DatabaseManager.getDatastore().find(Player.class).filter(Filters.eq("_id", id)).first();
+	public static Player getPlayerByUid(int id) {
+		return DatabaseManager.getGameDatastore().find(Player.class).filter(Filters.eq("_id", id)).first();
 	}
-
-	public static boolean checkPlayerExists(int id) {
-		return DatabaseManager.getDatastore().find(Player.class).filter(Filters.eq("_id", id)).first() != null;
+	
+	public static Player getPlayerByAccount(Account account) {
+		return DatabaseManager.getGameDatastore().find(Player.class).filter(Filters.eq("accountId", account.getId())).first();
+	}
+	
+	public static boolean checkIfPlayerExists(int uid) {
+		return DatabaseManager.getGameDatastore().find(Player.class).filter(Filters.eq("_id", uid)).count() > 0;
 	}
 
-	public static synchronized Player createPlayer(Player character, int reservedId) {
+	public static synchronized Player generatePlayerUid(Player character, int reservedId) {
 		// Check if reserved id
 		int id;
-		if (reservedId > 0 && !checkPlayerExists(reservedId)) {
+		if (reservedId > 0 && !checkIfPlayerExists(reservedId)) {
 			id = reservedId;
 			character.setUid(id);
 		} else {
 			do {
 				id = DatabaseManager.getNextId(character);
 			}
-			while (checkPlayerExists(id));
+			while (checkIfPlayerExists(id));
 			character.setUid(id);
 		}
 		// Save to database
-		DatabaseManager.getDatastore().save(character);
+		DatabaseManager.getGameDatastore().save(character);
 		return character;
 	}
 
 	public static synchronized int getNextPlayerId(int reservedId) {
 		// Check if reserved id
 		int id;
-		if (reservedId > 0 && !checkPlayerExists(reservedId)) {
+		if (reservedId > 0 && !checkIfPlayerExists(reservedId)) {
 			id = reservedId;
 		} else {
 			do {
 				id = DatabaseManager.getNextId(Player.class);
 			}
-			while (checkPlayerExists(id));
+			while (checkIfPlayerExists(id));
 		}
 		return id;
 	}
 
 	public static void savePlayer(Player character) {
-		DatabaseManager.getDatastore().save(character);
+		DatabaseManager.getGameDatastore().save(character);
 	}
 
 	public static void saveAvatar(Avatar avatar) {
-		DatabaseManager.getDatastore().save(avatar);
+		DatabaseManager.getGameDatastore().save(avatar);
 	}
 
 	public static List<Avatar> getAvatars(Player player) {
-		return DatabaseManager.getDatastore().find(Avatar.class).filter(Filters.eq("ownerId", player.getUid())).stream().toList();
+		return DatabaseManager.getGameDatastore().find(Avatar.class).filter(Filters.eq("ownerId", player.getUid())).stream().toList();
 	}
 
 	public static void saveItem(GameItem item) {
-		DatabaseManager.getDatastore().save(item);
+		DatabaseManager.getGameDatastore().save(item);
 	}
 
 	public static boolean deleteItem(GameItem item) {
-		DeleteResult result = DatabaseManager.getDatastore().delete(item);
+		DeleteResult result = DatabaseManager.getGameDatastore().delete(item);
 		return result.wasAcknowledged();
 	}
 
 	public static List<GameItem> getInventoryItems(Player player) {
-		return DatabaseManager.getDatastore().find(GameItem.class).filter(Filters.eq("ownerId", player.getUid())).stream().toList();
+		return DatabaseManager.getGameDatastore().find(GameItem.class).filter(Filters.eq("ownerId", player.getUid())).stream().toList();
 	}
 	
 	public static List<Friendship> getFriends(Player player) {
-		return DatabaseManager.getDatastore().find(Friendship.class).filter(Filters.eq("ownerId", player.getUid())).stream().toList();
+		return DatabaseManager.getGameDatastore().find(Friendship.class).filter(Filters.eq("ownerId", player.getUid())).stream().toList();
 	}
 
 	public static List<Friendship> getReverseFriends(Player player) {
-		return DatabaseManager.getDatastore().find(Friendship.class).filter(Filters.eq("friendId", player.getUid())).stream().toList();
+		return DatabaseManager.getGameDatastore().find(Friendship.class).filter(Filters.eq("friendId", player.getUid())).stream().toList();
 	}
 
 	public static void saveFriendship(Friendship friendship) {
-		DatabaseManager.getDatastore().save(friendship);
+		DatabaseManager.getGameDatastore().save(friendship);
 	}
 
 	public static void deleteFriendship(Friendship friendship) {
-		DatabaseManager.getDatastore().delete(friendship);
+		DatabaseManager.getGameDatastore().delete(friendship);
 	}
 
 	public static Friendship getReverseFriendship(Friendship friendship) {
-		return DatabaseManager.getDatastore().find(Friendship.class).filter(Filters.and(
+		return DatabaseManager.getGameDatastore().find(Friendship.class).filter(Filters.and(
 				Filters.eq("ownerId", friendship.getFriendId()),
 				Filters.eq("friendId", friendship.getOwnerId())
 		)).first();
@@ -196,7 +245,7 @@ public final class DatabaseHelper {
 	}
 
 	public static List<GachaRecord> getGachaRecords(int ownerId, int page, int gachaType, int pageSize){
-		return DatabaseManager.getDatastore().find(GachaRecord.class).filter(
+		return DatabaseManager.getGameDatastore().find(GachaRecord.class).filter(
 			Filters.eq("ownerId", ownerId),
 			Filters.eq("gachaType", gachaType)
 		).iterator(new FindOptions()
@@ -211,7 +260,7 @@ public final class DatabaseHelper {
 	}
 
 	public static long getGachaRecordsMaxPage(int ownerId, int page, int gachaType, int pageSize){
-		long count = DatabaseManager.getDatastore().find(GachaRecord.class).filter(
+		long count = DatabaseManager.getGameDatastore().find(GachaRecord.class).filter(
 			Filters.eq("ownerId", ownerId),
 			Filters.eq("gachaType", gachaType)
 		).count();
@@ -219,19 +268,31 @@ public final class DatabaseHelper {
 	}
 
 	public static void saveGachaRecord(GachaRecord gachaRecord){
-		DatabaseManager.getDatastore().save(gachaRecord);
+		DatabaseManager.getGameDatastore().save(gachaRecord);
 	}
 	
 	public static List<Mail> getAllMail(Player player) {
-		return DatabaseManager.getDatastore().find(Mail.class).filter(Filters.eq("ownerUid", player.getUid())).stream().toList();
+		return DatabaseManager.getGameDatastore().find(Mail.class).filter(Filters.eq("ownerUid", player.getUid())).stream().toList();
 	}
 	
 	public static void saveMail(Mail mail) {
-		DatabaseManager.getDatastore().save(mail);
+		DatabaseManager.getGameDatastore().save(mail);
 	}
 	
 	public static boolean deleteMail(Mail mail) {
-		DeleteResult result = DatabaseManager.getDatastore().delete(mail);
+		DeleteResult result = DatabaseManager.getGameDatastore().delete(mail);
 		return result.wasAcknowledged();
 	}
+	
+	public static List<GameMainQuest> getAllQuests(Player player) {
+		return DatabaseManager.getGameDatastore().find(GameMainQuest.class).filter(Filters.eq("ownerUid", player.getUid())).stream().toList();
+	}
+	
+	public static void saveQuest(GameMainQuest quest) {
+		DatabaseManager.getGameDatastore().save(quest);
+	}
+	
+	public static boolean deleteQuest(GameMainQuest quest) {
+		return DatabaseManager.getGameDatastore().delete(quest).wasAcknowledged();
+	}
 }

src/main/java/emu/grasscutter/database/DatabaseManager.java

 package emu.grasscutter.database;
 
-import com.mongodb.MongoClientURI;
 import com.mongodb.MongoCommandException;
 import com.mongodb.client.MongoClient;
 import com.mongodb.client.MongoClients;
@@ -20,69 +19,70 @@ import emu.grasscutter.game.gacha.GachaRecord;
 import emu.grasscutter.game.inventory.GameItem;
 import emu.grasscutter.game.mail.Mail;
 import emu.grasscutter.game.player.Player;
+import emu.grasscutter.game.quest.GameMainQuest;
+import emu.grasscutter.game.quest.GameQuest;
 
-public final class DatabaseManager {
-
-	private static MongoClient mongoClient;
-	private static MongoClient dispatchMongoClient;
+import static emu.grasscutter.Configuration.*;
 
-	private static Datastore datastore;
+public final class DatabaseManager {
+	private static Datastore gameDatastore;
 	private static Datastore dispatchDatastore;
 	
 	private static final Class<?>[] mappedClasses = new Class<?>[] {
-		DatabaseCounter.class, Account.class, Player.class, Avatar.class, GameItem.class, Friendship.class, GachaRecord.class, Mail.class
+		DatabaseCounter.class, Account.class, Player.class, Avatar.class, GameItem.class, Friendship.class, 
+		GachaRecord.class, Mail.class, GameMainQuest.class
 	};
     
-    public static Datastore getDatastore() {
-    	return datastore;
+    public static Datastore getGameDatastore() {
+    	return gameDatastore;
     }
     
-    public static MongoDatabase getDatabase() {
-    	return getDatastore().getDatabase();
+    public static MongoDatabase getGameDatabase() {
+    	return getGameDatastore().getDatabase();
     }
 
 	// Yes. I very dislike this method. However, this will be good for now.
 	// TODO: Add dispatch routes for player account management
 	public static Datastore getAccountDatastore() {
-		if(Grasscutter.getConfig().RunMode == ServerRunMode.GAME_ONLY) {
+		if(SERVER.runMode == ServerRunMode.GAME_ONLY) {
 			return dispatchDatastore;
 		} else {
-			return datastore;
+			return gameDatastore;
 		}
 	}
 	
 	public static void initialize() {
 		// Initialize
-		MongoClient mongoClient = MongoClients.create(Grasscutter.getConfig().DatabaseUrl);
+		MongoClient gameMongoClient = MongoClients.create(DATABASE.game.connectionUri);
 		
 		// Set mapper options.
 		MapperOptions mapperOptions = MapperOptions.builder()
 				.storeEmpties(true).storeNulls(false).build();
 		// Create data store.
-		datastore = Morphia.createDatastore(mongoClient, Grasscutter.getConfig().DatabaseCollection, mapperOptions);
+		gameDatastore = Morphia.createDatastore(gameMongoClient, DATABASE.game.collection, mapperOptions);
 		// Map classes.
-		datastore.getMapper().map(mappedClasses);
+		gameDatastore.getMapper().map(mappedClasses);
 		
 		// Ensure indexes
 		try {
-			datastore.ensureIndexes();
+			gameDatastore.ensureIndexes();
 		} catch (MongoCommandException exception) {
 			Grasscutter.getLogger().info("Mongo index error: ", exception);
 			// Duplicate index error
 			if (exception.getCode() == 85) {
 				// Drop all indexes and re add them
-				MongoIterable<String> collections = datastore.getDatabase().listCollectionNames();
+				MongoIterable<String> collections = gameDatastore.getDatabase().listCollectionNames();
 				for (String name : collections) {
-					datastore.getDatabase().getCollection(name).dropIndexes();
+					gameDatastore.getDatabase().getCollection(name).dropIndexes();
 				}
 				// Add back indexes
-				datastore.ensureIndexes();
+				gameDatastore.ensureIndexes();
 			}
 		}
 
-		if(Grasscutter.getConfig().RunMode == ServerRunMode.GAME_ONLY) {
-			dispatchMongoClient = MongoClients.create(Grasscutter.getConfig().getGameServerOptions().DispatchServerDatabaseUrl);
-			dispatchDatastore = Morphia.createDatastore(dispatchMongoClient, Grasscutter.getConfig().getGameServerOptions().DispatchServerDatabaseCollection);
+		if(SERVER.runMode == ServerRunMode.GAME_ONLY) {
+			MongoClient dispatchMongoClient = MongoClients.create(DATABASE.server.connectionUri);
+			dispatchDatastore = Morphia.createDatastore(dispatchMongoClient, DATABASE.server.collection);
 
 			// Ensure indexes for dispatch server
 			try {
@@ -104,14 +104,14 @@ public final class DatabaseManager {
 	}
 
 	public static synchronized int getNextId(Class<?> c) {
-		DatabaseCounter counter = getDatastore().find(DatabaseCounter.class).filter(Filters.eq("_id", c.getSimpleName())).first();
+		DatabaseCounter counter = getGameDatastore().find(DatabaseCounter.class).filter(Filters.eq("_id", c.getSimpleName())).first();
 		if (counter == null) {
 			counter = new DatabaseCounter(c.getSimpleName());
 		}
 		try {
 			return counter.getNextId();
 		} finally {
-			getDatastore().save(counter);
+			getGameDatastore().save(counter);
 		}
 	}
 

src/main/java/emu/grasscutter/game/Account.java

@@ -5,12 +5,12 @@ import emu.grasscutter.database.DatabaseHelper;
 import emu.grasscutter.utils.Crypto;
 import emu.grasscutter.utils.Utils;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
+import java.util.stream.Stream;
 
 import org.bson.Document;
 
-import com.mongodb.DBObject;
+import static emu.grasscutter.Configuration.*;
 
 @Entity(value = "accounts", useDiscriminator = false)
 public class Account {
@@ -21,16 +21,18 @@ public class Account {
 	private String username;
 	private String password; // Unused for now
 	
-	@AlsoLoad("playerUid") private int playerId;
+	private int reservedPlayerId;
 	private String email;
 	
 	private String token;
 	private String sessionKey; // Session token for dispatch server
 	private List<String> permissions;
+    private Locale locale;
 	
 	@Deprecated
 	public Account() {
 		this.permissions = new ArrayList<>();
+        this.locale = LANGUAGE;
 	}
 
 	public String getId() {
@@ -65,12 +67,12 @@ public class Account {
 		this.token = token;
 	}
 
-	public int getPlayerUid() {
-		return this.playerId;
+	public int getReservedPlayerUid() {
+		return this.reservedPlayerId;
 	}
 
-	public void setPlayerId(int playerId) {
-		this.playerId = playerId;
+	public void setReservedPlayerUid(int playerId) {
+		this.reservedPlayerId = playerId;
 	}
 	
 	public String getEmail() {
@@ -95,6 +97,14 @@ public class Account {
 		return this.sessionKey;
 	}
 
+    public Locale getLocale() {
+        return locale;
+    }
+
+    public void setLocale(Locale locale) {
+        this.locale = locale;
+    }
+
 	/**
 	 * The collection of a player's permissions.
 	 */
@@ -107,13 +117,49 @@ public class Account {
 		this.permissions.add(permission); return true;
 	}
 
+	public static boolean permissionMatchesWildcard(String wildcard, String[] permissionParts) {
+		String[] wildcardParts = wildcard.split("\\.");
+		if (permissionParts.length < wildcardParts.length) {  // A longer wildcard can never match a shorter permission
+			return false;
+		}
+		for (int i=0; i<wildcardParts.length; i++) {
+			switch (wildcardParts[i]) {
+				case "**":  // Recursing match
+					return true;
+				case "*":  // Match only one layer
+					if (i >= (permissionParts.length-1)) {
+						return true;
+					}
+					break;
+				default:  // This layer isn't a wildcard, it needs to match exactly
+					if (!wildcardParts[i].equals(permissionParts[i])) {
+						return false;
+					}
+			}
+		}
+		// At this point the wildcard will have matched every layer, but if it is shorter then the permission then this is not a match at this point (no **).
+		return (wildcardParts.length == permissionParts.length);
+	}
+
 	public boolean hasPermission(String permission) {
-		return this.permissions.contains(permission) ||
-                this.permissions.contains("*") ||
-                (this.permissions.contains("player") || this.permissions.contains("player.*")) && permission.startsWith("player.") ||
-                (this.permissions.contains("server") || this.permissions.contains("server.*")) && permission.startsWith("server.");
+		if(this.permissions.contains("*") && this.permissions.size() == 1) return true;
+
+		// Add default permissions if it doesn't exist
+		List<String> permissions = Stream.of(this.permissions, Arrays.asList(ACCOUNT.defaultPermissions))
+				.flatMap(Collection::stream)
+				.distinct().toList();
+
+		if (permissions.contains(permission)) return true;
+
+		String[] permissionParts = permission.split("\\.");
+		for (String p : permissions) {
+			if (p.startsWith("-") && permissionMatchesWildcard(p.substring(1), permissionParts)) return false;
+			if (permissionMatchesWildcard(p, permissionParts)) return true;
+		}
+
+		return permissions.contains("*");
 	}
-	
+
 	public boolean removePermission(String permission) {
 		return this.permissions.remove(permission);
 	}
@@ -135,5 +181,10 @@ public class Account {
 		if (!document.containsKey("permissions")) {
 			this.addPermission("*");
 		}
+
+        // Set account default language as server default language
+        if (!document.containsKey("locale")) {
+            this.locale = LANGUAGE;
+        }
 	}
 }

src/main/java/emu/grasscutter/game/ability/AbilityManager.java

+package emu.grasscutter.game.ability;
+
+import java.util.Optional;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+
+import emu.grasscutter.Grasscutter;
+
+import emu.grasscutter.data.GameData;
+import emu.grasscutter.data.binout.AbilityModifierEntry;
+import emu.grasscutter.data.binout.AbilityModifier.AbilityModifierAction;
+import emu.grasscutter.data.excels.AvatarSkillDepotData;
+import emu.grasscutter.data.excels.ItemData;
+import emu.grasscutter.game.avatar.Avatar;
+import emu.grasscutter.game.entity.EntityAvatar;
+import emu.grasscutter.game.entity.EntityClientGadget;
+import emu.grasscutter.game.entity.EntityItem;
+import emu.grasscutter.game.entity.GameEntity;
+import emu.grasscutter.game.player.Player;
+import emu.grasscutter.game.props.ElementType;
+import emu.grasscutter.net.proto.AbilityActionGenerateElemBallOuterClass.AbilityActionGenerateElemBall;
+import emu.grasscutter.net.proto.AbilityInvokeEntryHeadOuterClass.AbilityInvokeEntryHead;
+import emu.grasscutter.net.proto.AbilityInvokeEntryOuterClass.AbilityInvokeEntry;
+import emu.grasscutter.net.proto.AbilityMetaModifierChangeOuterClass.AbilityMetaModifierChange;
+import emu.grasscutter.net.proto.AbilityMetaReInitOverrideMapOuterClass.AbilityMetaReInitOverrideMap;
+import emu.grasscutter.net.proto.AbilityMixinCostStaminaOuterClass.AbilityMixinCostStamina;
+import emu.grasscutter.net.proto.AbilityScalarValueEntryOuterClass.AbilityScalarValueEntry;
+import emu.grasscutter.net.proto.ModifierActionOuterClass.ModifierAction;
+import emu.grasscutter.utils.Position;
+import emu.grasscutter.utils.Utils;
+
+public class AbilityManager {
+	private Player player;
+	
+	public AbilityManager(Player player) {
+		this.player = player;
+	}
+	
+	public Player getPlayer() {
+		return this.player;
+	}
+
+	public void onAbilityInvoke(AbilityInvokeEntry invoke) throws Exception {
+		// Grasscutter.getLogger().info(invoke.getArgumentType() + " (" + invoke.getArgumentTypeValue() + "): " + Utils.bytesToHex(invoke.toByteArray()));
+		switch (invoke.getArgumentType()) {
+			case ABILITY_INVOKE_ARGUMENT_META_OVERRIDE_PARAM:
+				handleOverrideParam(invoke);
+				break;
+			case ABILITY_INVOKE_ARGUMENT_META_REINIT_OVERRIDEMAP:
+				handleReinitOverrideMap(invoke);
+				break;
+			case ABILITY_INVOKE_ARGUMENT_META_MODIFIER_CHANGE:
+				handleModifierChange(invoke);
+				break;
+			case ABILITY_INVOKE_ARGUMENT_MIXIN_COST_STAMINA:
+				handleMixinCostStamina(invoke);
+				break;
+			case ABILITY_INVOKE_ARGUMENT_ACTION_GENERATE_ELEM_BALL:
+				handleGenerateElemBall(invoke);
+				break;
+			default:
+				break;
+		}
+	}
+
+	private void handleOverrideParam(AbilityInvokeEntry invoke) throws Exception {
+		GameEntity entity = player.getScene().getEntityById(invoke.getEntityId());
+		
+		if (entity == null) {
+			return;
+		}
+		
+		AbilityScalarValueEntry entry = AbilityScalarValueEntry.parseFrom(invoke.getAbilityData());
+		
+		entity.getMetaOverrideMap().put(entry.getKey().getStr(), entry.getFloatValue());
+	}
+
+	private void handleReinitOverrideMap(AbilityInvokeEntry invoke) throws Exception {
+		GameEntity entity = player.getScene().getEntityById(invoke.getEntityId());
+		
+		if (entity == null) {
+			return;
+		}
+		
+		AbilityMetaReInitOverrideMap map = AbilityMetaReInitOverrideMap.parseFrom(invoke.getAbilityData());
+		
+		for (AbilityScalarValueEntry entry : map.getOverrideMapList()) {
+			entity.getMetaOverrideMap().put(entry.getKey().getStr(), entry.getFloatValue());
+		}
+	}
+	
+	private void handleModifierChange(AbilityInvokeEntry invoke) throws Exception {
+		GameEntity target = player.getScene().getEntityById(invoke.getEntityId());
+		if (target == null) {
+			return;
+		}
+		
+		AbilityInvokeEntryHead head = invoke.getHead();
+		if (head == null) {
+			return;
+		}
+		
+		AbilityMetaModifierChange data = AbilityMetaModifierChange.parseFrom(invoke.getAbilityData());
+		if (data == null) {
+			return;
+		}
+		
+		GameEntity sourceEntity = player.getScene().getEntityById(data.getApplyEntityId());
+		if (sourceEntity == null) {
+			return;
+		}
+		
+		// This is not how it works but we will keep it for now since healing abilities dont work properly anyways
+		if (data.getAction() == ModifierAction.ADDED && data.getParentAbilityName() != null) {
+			// Handle add modifier here
+			String modifierString = data.getParentAbilityName().getStr();
+			AbilityModifierEntry modifier = GameData.getAbilityModifiers().get(modifierString);
+			
+			if (modifier != null && modifier.getOnAdded().size() > 0) {
+				for (AbilityModifierAction action : modifier.getOnAdded()) {
+					invokeAction(action, target, sourceEntity);
+				}
+			}
+			
+			// Add to meta modifier list
+			target.getMetaModifiers().put(head.getInstancedModifierId(), modifierString);
+		} else if (data.getAction() == ModifierAction.REMOVED) {
+			String modifierString = target.getMetaModifiers().get(head.getInstancedModifierId());
+			
+			if (modifierString != null) {
+				// Get modifier and call on remove event
+				AbilityModifierEntry modifier = GameData.getAbilityModifiers().get(modifierString);
+				
+				if (modifier != null && modifier.getOnRemoved().size() > 0) {
+					for (AbilityModifierAction action : modifier.getOnRemoved()) {
+						invokeAction(action, target, sourceEntity);
+					}
+				}
+				
+				// Remove from meta modifiers
+				target.getMetaModifiers().remove(head.getInstancedModifierId());
+			}
+		}
+	}
+	
+	private void handleMixinCostStamina(AbilityInvokeEntry invoke) throws InvalidProtocolBufferException {
+		AbilityMixinCostStamina costStamina = AbilityMixinCostStamina.parseFrom((invoke.getAbilityData()));
+		getPlayer().getStaminaManager().handleMixinCostStamina(costStamina.getIsSwim());
+	}
+
+	private void handleGenerateElemBall(AbilityInvokeEntry invoke) throws InvalidProtocolBufferException {
+		this.player.getEnergyManager().handleGenerateElemBall(invoke);
+	}
+	
+	private void invokeAction(AbilityModifierAction action, GameEntity target, GameEntity sourceEntity) {
+		switch (action.type) {
+			case HealHP -> {
+				if (action.amount == null) {
+					return;
+				}
+				
+				float healAmount = 0;
+				
+				if (action.amount.isDynamic && action.amount.dynamicKey != null) {
+					healAmount = sourceEntity.getMetaOverrideMap().getOrDefault(action.amount.dynamicKey, 0f);
+				}
+				
+				if (healAmount > 0) {
+					target.heal(healAmount);
+				}
+			}
+			case LoseHP -> {
+				if (action.amountByTargetCurrentHPRatio == null) {
+					return;
+				}
+				
+				float damageAmount = 0;
+				
+				if (action.amount.isDynamic && action.amount.dynamicKey != null) {
+					damageAmount = sourceEntity.getMetaOverrideMap().getOrDefault(action.amount.dynamicKey, 0f);
+				}
+				
+				if (damageAmount > 0) {
+					target.damage(damageAmount);
+				}
+			}
+		}
+	}
+}
+

src/main/java/emu/grasscutter/game/avatar/Avatar.java

@@ -17,24 +17,24 @@ import dev.morphia.annotations.PostLoad;
 import dev.morphia.annotations.PrePersist;
 import dev.morphia.annotations.Transient;
 import emu.grasscutter.data.GameData;
+import emu.grasscutter.data.binout.OpenConfigEntry;
+import emu.grasscutter.data.binout.OpenConfigEntry.SkillPointModifier;
 import emu.grasscutter.data.common.FightPropData;
-import emu.grasscutter.data.custom.OpenConfigEntry;
-import emu.grasscutter.data.custom.OpenConfigEntry.SkillPointModifier;
-import emu.grasscutter.data.def.AvatarData;
-import emu.grasscutter.data.def.AvatarPromoteData;
-import emu.grasscutter.data.def.AvatarSkillData;
-import emu.grasscutter.data.def.AvatarSkillDepotData;
-import emu.grasscutter.data.def.AvatarSkillDepotData.InherentProudSkillOpens;
-import emu.grasscutter.data.def.AvatarTalentData;
-import emu.grasscutter.data.def.EquipAffixData;
-import emu.grasscutter.data.def.ItemData.WeaponProperty;
-import emu.grasscutter.data.def.ProudSkillData;
-import emu.grasscutter.data.def.ReliquaryAffixData;
-import emu.grasscutter.data.def.ReliquaryLevelData;
-import emu.grasscutter.data.def.ReliquaryMainPropData;
-import emu.grasscutter.data.def.ReliquarySetData;
-import emu.grasscutter.data.def.WeaponCurveData;
-import emu.grasscutter.data.def.WeaponPromoteData;
+import emu.grasscutter.data.excels.AvatarData;
+import emu.grasscutter.data.excels.AvatarPromoteData;
+import emu.grasscutter.data.excels.AvatarSkillData;
+import emu.grasscutter.data.excels.AvatarSkillDepotData;
+import emu.grasscutter.data.excels.AvatarTalentData;
+import emu.grasscutter.data.excels.EquipAffixData;
+import emu.grasscutter.data.excels.ProudSkillData;
+import emu.grasscutter.data.excels.ReliquaryAffixData;
+import emu.grasscutter.data.excels.ReliquaryLevelData;
+import emu.grasscutter.data.excels.ReliquaryMainPropData;
+import emu.grasscutter.data.excels.ReliquarySetData;
+import emu.grasscutter.data.excels.WeaponCurveData;
+import emu.grasscutter.data.excels.WeaponPromoteData;
+import emu.grasscutter.data.excels.AvatarSkillDepotData.InherentProudSkillOpens;
+import emu.grasscutter.data.excels.ItemData.WeaponProperty;
 import emu.grasscutter.database.DatabaseHelper;
 import emu.grasscutter.game.entity.EntityAvatar;
 import emu.grasscutter.game.inventory.EquipType;
@@ -62,6 +62,8 @@ import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 
+import static emu.grasscutter.Configuration.GAME_OPTIONS;
+
 @Entity(value = "avatars", useDiscriminator = false)
 public class Avatar {
 	@Id private ObjectId id;
@@ -69,6 +71,7 @@ public class Avatar {
 	
 	@Transient private Player owner;
 	@Transient private AvatarData data;
+	@Transient private AvatarSkillDepotData skillDepot;
 	@Transient private long guid;	// Player unique id
 	private int avatarId;			// Id of avatar
 	
@@ -78,6 +81,7 @@ public class Avatar {
 	private int satiation; // ?
 	private int satiationPenalty; // ?
 	private float currentHp;
+	private float currentEnergy;
 	
 	@Transient private final Int2ObjectMap<GameItem> equips;
 	@Transient private final Int2FloatOpenHashMap fightProp;
@@ -103,8 +107,8 @@ public class Avatar {
 	private int nameCardRewardId;
 	private int nameCardId;
 	
+	@Deprecated // Do not use. Morhpia only!
 	public Avatar() {
-		// Morhpia only!
 		this.equips = new Int2ObjectOpenHashMap<>();
 		this.fightProp = new Int2FloatOpenHashMap();
 		this.extraAbilityEmbryos = new HashSet<>();
@@ -140,13 +144,13 @@ public class Avatar {
 		}
 		
 		// Skill depot
-		this.setSkillDepot(getAvatarData().getSkillDepot());
+		this.setSkillDepotData(getAvatarData().getSkillDepot());
 		
 		// Set stats
 		this.recalcStats();
 		this.currentHp = getFightProperty(FightProperty.FIGHT_PROP_MAX_HP);
 		setFightProperty(FightProperty.FIGHT_PROP_CUR_HP, this.currentHp);
-		
+		this.currentEnergy = 0f;
 		// Load handler
 		this.onLoad();
 	}
@@ -164,7 +168,8 @@ public class Avatar {
 	}
 
 	protected void setAvatarData(AvatarData data) {
-		this.data = data;
+		if (this.data != null) return;
+		this.data = data; // Used while loading this from the database
 	}
 
 	public int getOwnerId() {
@@ -257,9 +262,19 @@ public class Avatar {
 		return skillDepotId;
 	}
 
-	public void setSkillDepot(AvatarSkillDepotData skillDepot) {
-		// Set id
+	public AvatarSkillDepotData getSkillDepot() {
+		return skillDepot;
+	}
+	
+	protected void setSkillDepot(AvatarSkillDepotData skillDepot) {
+		if (this.skillDepot != null) return;
+		this.skillDepot = skillDepot; // Used while loading this from the database
+	}
+
+	public void setSkillDepotData(AvatarSkillDepotData skillDepot) {
+		// Set id and depot
 		this.skillDepotId = skillDepot.getId();
+		this.skillDepot = skillDepot;
 		// Clear, then add skills
 		getSkillLevelMap().clear();
 		if (skillDepot.getEnergySkill() > 0) {
@@ -344,6 +359,34 @@ public class Avatar {
 		this.currentHp = currentHp;
 	}
 
+	public void setCurrentEnergy() {
+		if (GAME_OPTIONS.energyUsage) {
+			this.setCurrentEnergy(this.currentEnergy);
+		}
+	}
+	
+	public void setCurrentEnergy(float currentEnergy) {
+		if (this.getSkillDepot() != null && this.getSkillDepot().getEnergySkillData() != null) {
+			ElementType element = this.getSkillDepot().getElementType();
+			this.setFightProperty(element.getMaxEnergyProp(), this.getSkillDepot().getEnergySkillData().getCostElemVal());
+			
+			if (GAME_OPTIONS.energyUsage) {
+				this.setFightProperty(element.getCurEnergyProp(), currentEnergy);
+			}
+			else {
+				this.setFightProperty(element.getCurEnergyProp(), this.getSkillDepot().getEnergySkillData().getCostElemVal());
+			}
+		}		
+	}
+
+	public void setCurrentEnergy(FightProperty curEnergyProp, float currentEnergy) {
+		if (GAME_OPTIONS.energyUsage) {
+			this.setFightProperty(curEnergyProp, currentEnergy);
+			this.currentEnergy = currentEnergy;
+			this.save();
+		}
+	}
+
 	public Int2FloatOpenHashMap getFightProperties() {
 		return fightProp;
 	}
@@ -481,6 +524,9 @@ public class Avatar {
 		// Get hp percent, set to 100% if none
 		float hpPercent = this.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP) <= 0 ? 1f : this.getFightProperty(FightProperty.FIGHT_PROP_CUR_HP) / this.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP);
 		
+		// Store current energy value for later
+		float currentEnergy = (this.getSkillDepot() != null) ? this.getFightProperty(this.getSkillDepot().getElementType().getCurEnergyProp()) : 0f;
+
 		// Clear properties
 		this.getFightProperties().clear();
 		
@@ -499,11 +545,7 @@ public class Avatar {
 		}
 		
 		// Set energy usage
-		if (data.getSkillDepot() != null && data.getSkillDepot().getEnergySkillData() != null) {
-			ElementType element = data.getSkillDepot().getElementType();
-			this.setFightProperty(element.getEnergyProperty(), data.getSkillDepot().getEnergySkillData().getCostElemVal());
-			this.setFightProperty((element.getEnergyProperty().getId() % 70) + 1000, data.getSkillDepot().getEnergySkillData().getCostElemVal());
-		}
+		setCurrentEnergy(currentEnergy);
 		
 		// Artifacts
 		for (int slotId = 1; slotId <= 5; slotId++) {

src/main/java/emu/grasscutter/game/avatar/AvatarStorage.java

@@ -4,7 +4,8 @@ import java.util.Iterator;
 import java.util.List;
 
 import emu.grasscutter.data.GameData;
-import emu.grasscutter.data.def.AvatarData;
+import emu.grasscutter.data.excels.AvatarData;
+import emu.grasscutter.data.excels.AvatarSkillDepotData;
 import emu.grasscutter.database.DatabaseHelper;
 import emu.grasscutter.game.entity.EntityAvatar;
 import emu.grasscutter.game.inventory.GameItem;
@@ -139,12 +140,14 @@ public class AvatarStorage implements Iterable<Avatar> {
 			}
 			
 			AvatarData avatarData = GameData.getAvatarDataMap().get(avatar.getAvatarId());
-			if (avatarData == null) {
+			AvatarSkillDepotData skillDepot = GameData.getAvatarSkillDepotDataMap().get(avatar.getSkillDepotId());
+			if (avatarData == null || skillDepot == null) {
 				continue;
 			}
 			
 			// Set ownerships
 			avatar.setAvatarData(avatarData);
+			avatar.setSkillDepot(skillDepot);
 			avatar.setOwner(getPlayer());
 			
 			// Force recalc of const boosted skills

src/main/java/emu/grasscutter/game/combine/CombineManger.java

 package emu.grasscutter.game.combine;
 
 import emu.grasscutter.data.GameData;
-import emu.grasscutter.data.def.CombineData;
+import emu.grasscutter.data.common.ItemParamData;
+import emu.grasscutter.data.excels.CombineData;
 import emu.grasscutter.game.inventory.ItemType;
 import emu.grasscutter.game.player.Player;
 import emu.grasscutter.net.proto.RetcodeOuterClass;
@@ -71,7 +72,7 @@ public class CombineManger {
 
         CombineResult result = new CombineResult();
         result.setMaterial(List.of());
-        result.setResult(List.of(new CombineData.CombineItemPair(combineData.getResultItemId(),
+        result.setResult(List.of(new ItemParamData(combineData.getResultItemId(),
                 combineData.getResultItemCount() * count)));
         // TODO lucky characters
         result.setExtra(List.of());

src/main/java/emu/grasscutter/game/combine/CombineResult.java

 package emu.grasscutter.game.combine;
 
-import emu.grasscutter.data.def.CombineData;
-
 import java.util.List;
 
+import emu.grasscutter.data.common.ItemParamData;
+import emu.grasscutter.data.excels.CombineData;
+
 public class CombineResult {
-    private List<CombineData.CombineItemPair> material;
-    private List<CombineData.CombineItemPair> result;
-    private List<CombineData.CombineItemPair> extra;
-    private List<CombineData.CombineItemPair> back;
+    private List<ItemParamData> material;
+    private List<ItemParamData> result;
+    private List<ItemParamData> extra;
+    private List<ItemParamData> back;
 
-    public List<CombineData.CombineItemPair> getMaterial() {
+    public List<ItemParamData> getMaterial() {
         return material;
     }
 
-    public void setMaterial(List<CombineData.CombineItemPair> material) {
+    public void setMaterial(List<ItemParamData> material) {
         this.material = material;
     }
 
-    public List<CombineData.CombineItemPair> getResult() {
+    public List<ItemParamData> getResult() {
         return result;
     }
 
-    public void setResult(List<CombineData.CombineItemPair> result) {
+    public void setResult(List<ItemParamData> result) {
         this.result = result;
     }
 
-    public List<CombineData.CombineItemPair> getExtra() {
+    public List<ItemParamData> getExtra() {
         return extra;
     }
 
-    public void setExtra(List<CombineData.CombineItemPair> extra) {
+    public void setExtra(List<ItemParamData> extra) {
         this.extra = extra;
     }
 
-    public List<CombineData.CombineItemPair> getBack() {
+    public List<ItemParamData> getBack() {
         return back;
     }
 
-    public void setBack(List<CombineData.CombineItemPair> back) {
+    public void setBack(List<ItemParamData> back) {
         this.back = back;
     }