Simply implement achievement system and add achievement command (#2068)

* Implement achievement system

* Update src/main/java/emu/grasscutter/command/commands/AchievementCommand.java

Co-authored-by: Der Chien <b03902015@ntu.edu.tw>

* fix: redundant codes

* fix: redundant codes

* Update language files

---------

Co-authored-by: Der Chien <b03902015@ntu.edu.tw>

src/main/java/emu/grasscutter/command/commands/AchievementCommand.java

@@ -0,0 +1,130 @@
+package emu.grasscutter.command.commands;
+
+import emu.grasscutter.command.Command;
+import emu.grasscutter.command.CommandHandler;
+import emu.grasscutter.data.GameData;
+import emu.grasscutter.data.excels.AchievementData;
+import emu.grasscutter.game.achievement.AchievementControlReturns;
+import emu.grasscutter.game.achievement.Achievements;
+import emu.grasscutter.game.player.Player;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Command(
+    label = "achievement",
+    usage = {"(grant|revoke) <achievementId>", "progress <achievementId> <progress>", "grantall", "revokeall"},
+    aliases = {"am"},
+    permission = "player.achievement",
+    permissionTargeted = "player.achievement.others",
+    targetRequirement = Command.TargetRequirement.PLAYER,
+    threading = true)
+public class AchievementCommand implements CommandHandler {
+    @Override
+    public void execute(Player sender, Player targetPlayer, List<String> args) {
+        if (args.size() < 1) {
+            this.sendUsageMessage(sender);
+            return;
+        }
+
+        var command = args.remove(0).toLowerCase();
+        var achievements = Achievements.getByPlayer(targetPlayer);
+        switch (command) {
+            case "grant" -> this.grant(sender, targetPlayer, achievements, args);
+            case "revoke" -> this.revoke(sender, targetPlayer, achievements, args);
+            case "progress" -> this.progress(sender, targetPlayer, achievements, args);
+            case "grantall" -> grantAll(sender, targetPlayer, achievements);
+            case "revokeall" -> revokeAll(sender, targetPlayer, achievements);
+            default -> this.sendUsageMessage(sender);
+        }
+    }
+
+    private void grant(Player sender, Player targetPlayer, Achievements achievements, List<String> args) {
+        if (args.size() < 1) {
+            this.sendUsageMessage(sender);
+        }
+
+        parseInt(args.remove(0)).ifPresentOrElse(integer -> {
+            var ret = achievements.grant(integer);
+            switch (ret.getRet()) {
+                case SUCCESS -> sendSuccessMessage(sender, "grant", targetPlayer.getNickname());
+                case ACHIEVEMENT_NOT_FOUND -> CommandHandler.sendTranslatedMessage(sender, ret.getRet().getKey());
+                case ALREADY_ACHIEVED -> CommandHandler.sendTranslatedMessage(sender, ret.getRet().getKey(), targetPlayer.getNickname());
+            }
+        }, () -> this.sendUsageMessage(sender));
+    }
+
+    private void revoke(Player sender, Player targetPlayer, Achievements achievements, List<String> args) {
+        if (args.size() < 1) {
+            this.sendUsageMessage(sender);
+        }
+
+        parseInt(args.remove(0)).ifPresentOrElse(integer -> {
+            var ret = achievements.revoke(integer);
+            switch (ret.getRet()) {
+                case SUCCESS -> sendSuccessMessage(sender, "revoke", targetPlayer.getNickname());
+                case ACHIEVEMENT_NOT_FOUND -> CommandHandler.sendTranslatedMessage(sender, ret.getRet().getKey());
+                case NOT_YET_ACHIEVED -> CommandHandler.sendTranslatedMessage(sender, ret.getRet().getKey(), targetPlayer.getNickname());
+            }
+        }, () -> this.sendUsageMessage(sender));
+    }
+
+    private void progress(Player sender, Player targetPlayer, Achievements achievements, List<String> args) {
+        if (args.size() < 2) {
+            this.sendUsageMessage(sender);
+        }
+
+        parseInt(args.remove(0)).ifPresentOrElse(integer -> {
+            parseInt(args.remove(0)).ifPresentOrElse(progress -> {
+                var ret = achievements.progress(integer, progress);
+                switch (ret.getRet()) {
+                    case SUCCESS -> sendSuccessMessage(sender, "progress", targetPlayer.getNickname(), integer, progress);
+                    case ACHIEVEMENT_NOT_FOUND -> CommandHandler.sendTranslatedMessage(sender, ret.getRet().getKey());
+                }
+            }, () -> this.sendUsageMessage(sender));
+        }, () -> this.sendUsageMessage(sender));
+    }
+
+    private static void sendSuccessMessage(Player sender, String cmd, Object... args) {
+        CommandHandler.sendTranslatedMessage(sender, AchievementControlReturns.Return.SUCCESS.getKey() + cmd, args);
+    }
+
+    private static Optional<Integer> parseInt(String s) {
+        try {
+            return Optional.of(Integer.parseInt(s));
+        } catch (NumberFormatException e) {
+            return Optional.empty();
+        }
+    }
+
+    private static void grantAll(Player sender, Player targetPlayer, Achievements achievements) {
+        var counter = new AtomicInteger();
+        GameData.getAchievementDataMap().values().stream()
+            .filter(AchievementData::isUsed)
+            .filter(AchievementData::isParent)
+            .forEach(data -> {
+                var success = achievements.grant(data.getId());
+                if (success.getRet() == AchievementControlReturns.Return.SUCCESS) {
+                    counter.addAndGet(success.getChangedAchievementStatusNum());
+                }
+            });
+
+        sendSuccessMessage(sender, "grantall", counter.intValue(), targetPlayer.getNickname());
+    }
+
+    private static void revokeAll(Player sender, Player targetPlayer, Achievements achievements) {
+        var counter = new AtomicInteger();
+        GameData.getAchievementDataMap().values().stream()
+            .filter(AchievementData::isUsed)
+            .filter(AchievementData::isParent)
+            .forEach(data -> {
+                var success = achievements.revoke(data.getId());
+                if (success.getRet() == AchievementControlReturns.Return.SUCCESS) {
+                    counter.addAndGet(success.getChangedAchievementStatusNum());
+                }
+            });
+
+        sendSuccessMessage(sender, "revokeall", counter.intValue(), targetPlayer.getNickname());
+    }
+}

src/main/java/emu/grasscutter/data/GameData.java

@@ -41,6 +41,8 @@ public class GameData {
 
     // ExcelConfigs
     @Getter private static final ArrayList<CodexReliquaryData> codexReliquaryArrayList = new ArrayList<>();
+    private static final Int2ObjectMap<AchievementData> achievementDataMap = new Int2ObjectOpenHashMap<>();
+    @Getter private static final Int2ObjectMap<AchievementGoalData> achievementGoalDataMap = new Int2ObjectOpenHashMap<>();
     @Getter private static final Int2ObjectMap<ActivityData> activityDataMap = new Int2ObjectOpenHashMap<>();
     @Getter private static final Int2ObjectMap<ActivityShopData> activityShopDataMap = new Int2ObjectOpenHashMap<>();
     @Getter private static final Int2ObjectMap<ActivityWatcherData> activityWatcherDataMap = new Int2ObjectOpenHashMap<>();
@@ -233,4 +235,9 @@ public class GameData {
 
         return shopGoods;
     }
+
+    public static Int2ObjectMap<AchievementData> getAchievementDataMap() {
+        AchievementData.divideIntoGroups();
+        return achievementDataMap;
+    }
 }

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

@@ -0,0 +1,96 @@
+package emu.grasscutter.data.excels;
+
+import com.github.davidmoten.guavamini.Lists;
+import emu.grasscutter.data.GameData;
+import emu.grasscutter.data.GameResource;
+import emu.grasscutter.data.ResourceType;
+import lombok.Getter;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
+
+@Getter
+@ResourceType(name = "AchievementExcelConfigData.json")
+public class AchievementData extends GameResource {
+    private static final AtomicBoolean isDivided = new AtomicBoolean();
+    private int goalId;
+    private int preStageAchievementId;
+    private Set<Integer> groupAchievementIdList = new HashSet<>();
+    private boolean isParent;
+    private long titleTextMapHash;
+    private long descTextMapHash;
+    private int finishRewardId;
+    private boolean isDeleteWatcherAfterFinish;
+    private int id;
+    private BattlePassMissionData.TriggerConfig triggerConfig;
+    private int progress;
+    private boolean isDisuse;
+
+    public boolean hasPreStageAchievement() {
+        return this.preStageAchievementId != 0;
+    }
+
+    public boolean hasGroupAchievements() {
+        return !this.groupAchievementIdList.isEmpty();
+    }
+
+    public boolean isUsed() {
+        return !this.isDisuse;
+    }
+
+    public Set<Integer> getGroupAchievementIdList() {
+        return this.groupAchievementIdList.stream().collect(Collectors.toUnmodifiableSet());
+    }
+
+    public Set<Integer> getExcludedGroupAchievementIdList() {
+        return this.groupAchievementIdList.stream().filter(integer -> integer != this.getId()).collect(Collectors.toUnmodifiableSet());
+    }
+
+    public static void divideIntoGroups() {
+        if (isDivided.get()) {
+            return;
+        }
+
+        isDivided.set(true);
+        var map = GameData.getAchievementDataMap();
+        var achievementDataList = map.values().stream().filter(AchievementData::isUsed).toList();
+        for (var data : achievementDataList) {
+            if (!data.hasPreStageAchievement() || data.hasGroupAchievements()) {
+                continue;
+            }
+
+            List<Integer> ids = Lists.newArrayList();
+            int parentId = data.getId();
+            while (true) {
+                var next = map.get(parentId + 1);
+                if (next == null || parentId != next.getPreStageAchievementId()) {
+                    break;
+                }
+
+                parentId++;
+            }
+
+            map.get(parentId).isParent = true;
+
+            while (true) {
+                ids.add(parentId);
+                var previous = map.get(--parentId);
+                if (previous == null) {
+                    break;
+                } else if (!previous.hasPreStageAchievement()) {
+                    ids.add(parentId);
+                    break;
+                }
+            }
+
+            for (int i : ids) {
+                map.get(i).groupAchievementIdList.addAll(ids);
+            }
+        }
+
+        map.values().stream().filter(a -> !a.hasGroupAchievements() && a.isUsed()).forEach(a -> a.isParent = true);
+    }
+}

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

@@ -0,0 +1,13 @@
+package emu.grasscutter.data.excels;
+
+import emu.grasscutter.data.GameResource;
+import emu.grasscutter.data.ResourceType;
+import lombok.Getter;
+
+@Getter
+@ResourceType(name = "AchievementGoalExcelConfigData.json")
+public class AchievementGoalData extends GameResource {
+    private int id;
+    private long nameTextMapHash;
+    private int finishRewardId;
+}

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

@@ -11,6 +11,7 @@ import dev.morphia.query.experimental.filters.Filters;
 import emu.grasscutter.GameConstants;
 import emu.grasscutter.Grasscutter;
 import emu.grasscutter.game.Account;
+import emu.grasscutter.game.achievement.Achievements;
 import emu.grasscutter.game.activity.PlayerActivityData;
 import emu.grasscutter.game.activity.musicgame.MusicGameBeatmap;
 import emu.grasscutter.game.avatar.Avatar;
@@ -133,6 +134,7 @@ public final class DatabaseHelper {
         }
         int uid = player.getUid();
         // Delete data from collections
+        DatabaseManager.getGameDatabase().getCollection("achievements").deleteMany(eq("uid", uid));
         DatabaseManager.getGameDatabase().getCollection("activities").deleteMany(eq("uid", uid));
         DatabaseManager.getGameDatabase().getCollection("homes").deleteMany(eq("ownerUid", uid));
         DatabaseManager.getGameDatabase().getCollection("mail").deleteMany(eq("ownerUid", uid));
@@ -359,4 +361,14 @@ public final class DatabaseHelper {
     public static void saveMusicGameBeatmap(MusicGameBeatmap musicGameBeatmap) {
         DatabaseManager.getGameDatastore().save(musicGameBeatmap);
     }
+
+    public static Achievements getAchievementData(int uid) {
+        return DatabaseManager.getGameDatastore().find(Achievements.class)
+            .filter(Filters.and(Filters.eq("uid", uid)))
+            .first();
+    }
+
+    public static void saveAchievementData(Achievements achievements) {
+        DatabaseManager.getGameDatastore().save(achievements);
+    }
 }

src/main/java/emu/grasscutter/game/achievement/Achievement.java

@@ -0,0 +1,38 @@
+package emu.grasscutter.game.achievement;
+
+import dev.morphia.annotations.Entity;
+import emu.grasscutter.net.proto.AchievementOuterClass;
+import emu.grasscutter.net.proto.StatusOuterClass;
+import lombok.Getter;
+import lombok.Setter;
+
+@Entity
+@Getter
+public class Achievement {
+    @Setter
+    private StatusOuterClass.Status status;
+    private int id;
+    private int totalProgress;
+    @Setter
+    private int curProgress;
+    @Setter
+    private int finishTimestampSec;
+
+    public Achievement(StatusOuterClass.Status status, int id, int totalProgress, int curProgress, int finishTimestampSec) {
+        this.status = status;
+        this.id = id;
+        this.totalProgress = totalProgress;
+        this.curProgress = curProgress;
+        this.finishTimestampSec = finishTimestampSec;
+    }
+
+    public AchievementOuterClass.Achievement toProto() {
+        return AchievementOuterClass.Achievement.newBuilder()
+            .setStatus(this.getStatus())
+            .setId(this.getId())
+            .setTotalProgress(this.getTotalProgress())
+            .setCurProgress(this.getCurProgress())
+            .setFinishTimestamp(this.getFinishTimestampSec())
+            .build();
+    }
+}

src/main/java/emu/grasscutter/game/achievement/AchievementControlReturns.java

@@ -0,0 +1,48 @@
+package emu.grasscutter.game.achievement;
+
+import lombok.Getter;
+
+@Getter
+public class AchievementControlReturns {
+    private final Return ret;
+    private final int changedAchievementStatusNum;
+
+    private AchievementControlReturns(Return ret) {
+        this(ret, 0);
+    }
+
+    private AchievementControlReturns(Return ret, int changedAchievementStatusNum) {
+        this.ret = ret;
+        this.changedAchievementStatusNum = changedAchievementStatusNum;
+    }
+
+    public static AchievementControlReturns success(int changedAchievementStatusNum) {
+        return new AchievementControlReturns(Return.SUCCESS, changedAchievementStatusNum);
+    }
+
+    public static AchievementControlReturns achievementNotFound() {
+        return new AchievementControlReturns(Return.ACHIEVEMENT_NOT_FOUND);
+    }
+
+    public static AchievementControlReturns alreadyAchieved() {
+        return new AchievementControlReturns(Return.ALREADY_ACHIEVED);
+    }
+
+    public static AchievementControlReturns notYetAchieved() {
+        return new AchievementControlReturns(Return.NOT_YET_ACHIEVED);
+    }
+
+    public enum Return {
+        SUCCESS("commands.achievement.success."),
+        ACHIEVEMENT_NOT_FOUND("commands.achievement.fail.achievement_not_found"),
+        ALREADY_ACHIEVED("commands.achievement.fail.already_achieved"),
+        NOT_YET_ACHIEVED("commands.achievement.fail.not_yet_achieved");
+
+        @Getter
+        private final String key;
+
+        Return(String key) {
+            this.key = key;
+        }
+    }
+}

src/main/java/emu/grasscutter/game/achievement/Achievements.java

@@ -0,0 +1,290 @@
+package emu.grasscutter.game.achievement;
+
+import com.github.davidmoten.guavamini.Lists;
+import dev.morphia.annotations.Entity;
+import dev.morphia.annotations.Id;
+import dev.morphia.annotations.Transient;
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.data.GameData;
+import emu.grasscutter.data.excels.AchievementData;
+import emu.grasscutter.database.DatabaseHelper;
+import emu.grasscutter.game.inventory.GameItem;
+import emu.grasscutter.game.player.Player;
+import emu.grasscutter.game.props.ActionReason;
+import emu.grasscutter.net.proto.StatusOuterClass;
+import emu.grasscutter.server.packet.send.PacketAchievementAllDataNotify;
+import emu.grasscutter.server.packet.send.PacketAchievementUpdateNotify;
+import emu.grasscutter.server.packet.send.PacketTakeAchievementGoalRewardRsp;
+import emu.grasscutter.server.packet.send.PacketTakeAchievementRewardRsp;
+import lombok.Builder;
+import lombok.Data;
+import lombok.Getter;
+import org.bson.types.ObjectId;
+
+import javax.annotation.Nullable;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.IntSupplier;
+
+@Entity("achievements")
+@Data
+@Builder(builderMethodName = "of")
+public class Achievements {
+    private static final IntSupplier currentTimeSecs = () -> (int) (System.currentTimeMillis() / 1000L);
+    private static final Achievement INVALID = new Achievement(StatusOuterClass.Status.STATUS_INVALID, -1, 0, 0, 0);
+    @Id
+    private ObjectId id;
+    private int uid;
+    @Transient
+    private Player player;
+    private Map<Integer, Achievement> achievementList;
+    @Getter
+    private int finishedAchievementNum;
+    private List<Integer> takenGoalRewardIdList;
+
+    public static Achievements getByPlayer(Player player) {
+        var achievements = player.getAchievements() == null ? DatabaseHelper.getAchievementData(player.getUid()) : player.getAchievements();
+        if (achievements == null) {
+            achievements = create(player.getUid());
+        }
+        return achievements;
+    }
+
+    public static Achievements create(int uid) {
+        var newAchievement = Achievements.of()
+            .uid(uid)
+            .achievementList(init())
+            .finishedAchievementNum(0)
+            .takenGoalRewardIdList(Lists.newArrayList())
+            .build();
+        newAchievement.save();
+        return newAchievement;
+    }
+
+    private static Map<Integer, Achievement> init() {
+        Map<Integer, Achievement> map = new HashMap<>();
+        GameData.getAchievementDataMap().values().stream()
+            .filter(AchievementData::isUsed)
+            .forEach(a -> {
+                map.put(a.getId(), new Achievement(StatusOuterClass.Status.STATUS_UNFINISHED, a.getId(), a.getProgress(), 0, 0));
+            });
+        return map;
+    }
+
+    public AchievementControlReturns grant(int achievementId) {
+        var a = this.getAchievement(achievementId);
+
+        if (a == null || this.isFinished(achievementId)) {
+            return a == null ? AchievementControlReturns.achievementNotFound() : AchievementControlReturns.alreadyAchieved();
+        }
+
+        return this.progress(achievementId, a.getTotalProgress());
+    }
+
+    public AchievementControlReturns revoke(int achievementId) {
+        var a = this.getAchievement(achievementId);
+
+        if (a == null || !this.isFinished(achievementId)) {
+            return a == null ? AchievementControlReturns.achievementNotFound() : AchievementControlReturns.notYetAchieved();
+        }
+
+        return this.progress(achievementId, 0);
+    }
+
+    public AchievementControlReturns progress(int achievementId, int progress) {
+        var a = this.getAchievement(achievementId);
+        if (a == null) {
+            return AchievementControlReturns.achievementNotFound();
+        }
+
+        a.setCurProgress(progress);
+        return AchievementControlReturns.success(this.notifyOtherAchievements(a));
+    }
+
+    private int notifyOtherAchievements(Achievement a) {
+        var changedNum = new AtomicInteger();
+
+        changedNum.addAndGet(this.update(a) ? 1 : 0);
+
+        GameData.getAchievementDataMap().get(a.getId())
+            .getExcludedGroupAchievementIdList().stream()
+            .map(this::getAchievement)
+            .filter(Objects::nonNull)
+            .forEach(other -> {
+                other.setCurProgress(a.getCurProgress());
+                changedNum.addAndGet(this.update(other) ? 1 : 0);
+            });
+
+        this.computeFinishedAchievementNum();
+        this.save();
+        this.sendUpdatePacket(a);
+        return changedNum.intValue();
+    }
+
+    private boolean update(Achievement a) {
+        if (a.getStatus() == StatusOuterClass.Status.STATUS_UNFINISHED && a.getCurProgress() >= a.getTotalProgress()) {
+            a.setStatus(StatusOuterClass.Status.STATUS_FINISHED);
+            a.setFinishTimestampSec(currentTimeSecs.getAsInt());
+            return true;
+        } else if (this.isFinished(a.getId()) && a.getCurProgress() < a.getTotalProgress()) {
+            a.setStatus(StatusOuterClass.Status.STATUS_UNFINISHED);
+            a.setFinishTimestampSec(0);
+            return true;
+        }
+
+        return false;
+    }
+
+    private void computeFinishedAchievementNum() {
+        this.finishedAchievementNum = GameData.getAchievementDataMap().values().stream()
+            .filter(a -> this.isFinished(a.getId()))
+            .mapToInt(value -> 1)
+            .sum();
+    }
+
+    private void sendUpdatePacket(Achievement achievement) {
+        List<Achievement> achievements = Lists.newArrayList(achievement);
+        achievements.addAll(GameData.getAchievementDataMap().get(achievement.getId())
+            .getExcludedGroupAchievementIdList()
+            .stream().map(this::getAchievement)
+            .filter(Objects::nonNull)
+            .toList()
+        );
+
+        this.sendUpdatePacket(achievements);
+    }
+
+    private void sendUpdatePacket(List<Achievement> achievement) {
+        if (this.isPacketSendable()) {
+            this.player.sendPacket(new PacketAchievementUpdateNotify(achievement));
+        }
+    }
+
+    @Nullable
+    public Achievement getAchievement(int achievementId) {
+        if (this.isInvalid(achievementId)) {
+            return null;
+        }
+
+        return this.getAchievementList().computeIfAbsent(achievementId, id -> {
+            return new Achievement(StatusOuterClass.Status.STATUS_UNFINISHED, id, GameData.getAchievementDataMap().get(id.intValue()).getProgress(), 0, 0);
+        });
+    }
+
+    public boolean isInvalid(int achievementId) {
+        var data = GameData.getAchievementDataMap().get(achievementId);
+        return data == null || data.isDisuse();
+    }
+
+    public StatusOuterClass.Status getStatus(int achievementId) {
+        return this.getAchievementList().getOrDefault(achievementId, INVALID).getStatus();
+    }
+
+    public boolean isFinished(int achievementId) {
+        var status = this.getStatus(achievementId);
+        return status == StatusOuterClass.Status.STATUS_FINISHED || status == StatusOuterClass.Status.STATUS_REWARD_TAKEN;
+    }
+
+    public void takeReward(List<Integer> ids) {
+        List<GameItem> rewards = Lists.newArrayList();
+
+        for (int i : ids) {
+            var target = GameData.getAchievementDataMap().get(i);
+            if (target == null) {
+                Grasscutter.getLogger().warn("null returned while taking reward!");
+                return;
+            }
+
+            if (this.isRewardTaken(i)) {
+                this.player.sendPacket(new PacketTakeAchievementRewardRsp());
+                return;
+            }
+
+            var data = GameData.getRewardDataMap().get(target.getFinishRewardId());
+            if (data == null) {
+                Grasscutter.getLogger().warn("null returned while getting reward data!");
+                continue;
+            }
+
+            data.getRewardItemList().forEach(itemParamData -> {
+                var itemData = GameData.getItemDataMap().get(itemParamData.getId());
+                if (itemData == null) {
+                    Grasscutter.getLogger().warn("itemData == null!");
+                    return;
+                }
+
+                rewards.add(new GameItem(itemData, itemParamData.getCount()));
+            });
+
+            var a = this.getAchievement(i);
+            a.setStatus(StatusOuterClass.Status.STATUS_REWARD_TAKEN);
+            this.save();
+            this.sendUpdatePacket(a);
+        }
+
+        this.player.getInventory().addItems(rewards, ActionReason.AchievementReward);
+        this.player.sendPacket(new PacketTakeAchievementRewardRsp(ids, rewards.stream().map(GameItem::toItemParam).toList()));
+    }
+
+    public void takeGoalReward(List<Integer> ids) {
+        List<GameItem> rewards = Lists.newArrayList();
+
+        for (int i : ids) {
+            if (this.takenGoalRewardIdList.contains(i)) {
+                this.player.sendPacket(new PacketTakeAchievementGoalRewardRsp());
+            }
+
+            var goalData = GameData.getAchievementGoalDataMap().get(i);
+            if (goalData == null) {
+                Grasscutter.getLogger().warn("null returned while getting goal reward data!");
+                continue;
+            }
+
+            var data = GameData.getRewardDataMap().get(goalData.getFinishRewardId());
+            if (data == null) {
+                Grasscutter.getLogger().warn("null returned while getting reward data!");
+                continue;
+            }
+
+            data.getRewardItemList().forEach(itemParamData -> {
+                var itemData = GameData.getItemDataMap().get(itemParamData.getId());
+                if (itemData == null) {
+                    Grasscutter.getLogger().warn("itemData == null!");
+                    return;
+                }
+
+                rewards.add(new GameItem(itemData, itemParamData.getCount()));
+            });
+
+            this.takenGoalRewardIdList.add(i);
+            this.save();
+        }
+
+        this.player.getInventory().addItems(rewards, ActionReason.AchievementGoalReward);
+        this.player.sendPacket(new PacketTakeAchievementGoalRewardRsp(ids, rewards.stream().map(GameItem::toItemParam).toList()));
+    }
+
+    public boolean isRewardTaken(int achievementId) {
+        return this.getStatus(achievementId) == StatusOuterClass.Status.STATUS_REWARD_TAKEN;
+    }
+
+    public boolean isRewardLeft(int achievementId) {
+        return this.getStatus(achievementId) == StatusOuterClass.Status.STATUS_FINISHED;
+    }
+
+    private boolean isPacketSendable() {
+        return this.player != null;
+    }
+
+    public void save() {
+        DatabaseHelper.saveAchievementData(this);
+    }
+
+    public void onLogin(Player player) {
+        if (this.player == null) {
+            this.player = player;
+        }
+
+        this.player.sendPacket(new PacketAchievementAllDataNotify(this.player));
+    }
+}

src/main/java/emu/grasscutter/game/player/Player.java

@@ -10,6 +10,7 @@ import emu.grasscutter.database.DatabaseHelper;
 import emu.grasscutter.game.Account;
 import emu.grasscutter.game.CoopRequest;
 import emu.grasscutter.game.ability.AbilityManager;
+import emu.grasscutter.game.achievement.Achievements;
 import emu.grasscutter.game.activity.ActivityManager;
 import emu.grasscutter.game.avatar.Avatar;
 import emu.grasscutter.game.avatar.AvatarStorage;
@@ -168,6 +169,7 @@ public class Player {
     @Getter private transient SatiationManager satiationManager;
 
     // Manager data (Save-able to the database)
+    @Getter private transient Achievements achievements;
     private PlayerProfile playerProfile;  // Getter has null-check
     @Getter private TeamManager teamManager;
     private TowerData towerData;  // Getter has null-check
@@ -973,11 +975,15 @@ public class Player {
                 .setIsShowAvatar(this.isShowAvatars())
                 .addAllShowAvatarInfoList(socialShowAvatarInfoList)
                 .addAllShowNameCardIdList(this.getShowNameCardInfoList())
-                .setFinishAchievementNum(0)
+                .setFinishAchievementNum(this.getFinishedAchievementNum())
                 .setFriendEnterHomeOptionValue(this.getHome() == null ? 0 : this.getHome().getEnterHomeOption());
         return social;
     }
 
+    public int getFinishedAchievementNum() {
+        return Achievements.getByPlayer(this).getFinishedAchievementNum();
+    }
+
     public List<ShowAvatarInfoOuterClass.ShowAvatarInfo> getShowAvatarInfoList() {
         List<ShowAvatarInfoOuterClass.ShowAvatarInfo> showAvatarInfoList = new ArrayList<>();
 
@@ -1172,6 +1178,7 @@ public class Player {
         }
 
         // Load from db
+        this.achievements = Achievements.getByPlayer(this);
         this.getAvatars().loadFromDatabase();
         this.getInventory().loadFromDatabase();
         this.loadBattlePassManager(); // Call before avatar postLoad to avoid null pointer
@@ -1224,6 +1231,10 @@ public class Player {
         session.send(new PacketQuestListNotify(this));
         session.send(new PacketCodexDataFullNotify(this));
         session.send(new PacketAllWidgetDataNotify(this));
+
+        //Achievements
+        this.achievements.onLogin(this);
+
         session.send(new PacketWidgetGadgetAllDataNotify());
         session.send(new PacketCombineDataNotify(this.unlockedCombines));
         session.send(new PacketGetChatEmojiCollectionRsp(this.getChatEmojiIdList()));

src/main/java/emu/grasscutter/server/packet/recv/HandlerTakeAchievementGoalRewardReq.java

@@ -0,0 +1,16 @@
+package emu.grasscutter.server.packet.recv;
+
+import emu.grasscutter.net.packet.Opcodes;
+import emu.grasscutter.net.packet.PacketHandler;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.TakeAchievementGoalRewardReqOuterClass;
+import emu.grasscutter.server.game.GameSession;
+
+@Opcodes(PacketOpcodes.TakeAchievementGoalRewardReq)
+public class HandlerTakeAchievementGoalRewardReq extends PacketHandler {
+    @Override
+    public void handle(GameSession session, byte[] header, byte[] payload) throws Exception {
+        var req = TakeAchievementGoalRewardReqOuterClass.TakeAchievementGoalRewardReq.parseFrom(payload);
+        session.getPlayer().getAchievements().takeGoalReward(req.getIdListList());
+    }
+}

src/main/java/emu/grasscutter/server/packet/recv/HandlerTakeAchievementRewardReq.java

@@ -0,0 +1,16 @@
+package emu.grasscutter.server.packet.recv;
+
+import emu.grasscutter.net.packet.Opcodes;
+import emu.grasscutter.net.packet.PacketHandler;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.TakeAchievementRewardReqOuterClass;
+import emu.grasscutter.server.game.GameSession;
+
+@Opcodes(PacketOpcodes.TakeAchievementRewardReq)
+public class HandlerTakeAchievementRewardReq extends PacketHandler {
+    @Override
+    public void handle(GameSession session, byte[] header, byte[] payload) throws Exception {
+        var req = TakeAchievementRewardReqOuterClass.TakeAchievementRewardReq.parseFrom(payload);
+        session.getPlayer().getAchievements().takeReward(req.getIdListList());
+    }
+}

src/main/java/emu/grasscutter/server/packet/send/PacketAchievementAllDataNotify.java

@@ -0,0 +1,21 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.achievement.Achievement;
+import emu.grasscutter.game.player.Player;
+import emu.grasscutter.net.packet.BasePacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AchievementAllDataNotifyOuterClass;
+
+public class PacketAchievementAllDataNotify extends BasePacket {
+    public PacketAchievementAllDataNotify(Player player) {
+        super(PacketOpcodes.AchievementAllDataNotify);
+
+        var achievements = player.getAchievements();
+        var notify = AchievementAllDataNotifyOuterClass.AchievementAllDataNotify.newBuilder()
+            .addAllAchievementList(achievements.getAchievementList().values().stream().map(Achievement::toProto).toList())
+            .addAllRewardTakenGoalIdList(achievements.getTakenGoalRewardIdList())
+            .build();
+
+        this.setData(notify);
+    }
+}

src/main/java/emu/grasscutter/server/packet/send/PacketAchievementUpdateNotify.java

@@ -0,0 +1,20 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.achievement.Achievement;
+import emu.grasscutter.net.packet.BasePacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AchievementUpdateNotifyOuterClass;
+
+import java.util.List;
+
+public class PacketAchievementUpdateNotify extends BasePacket {
+    public PacketAchievementUpdateNotify(List<Achievement> achievements) {
+        super(PacketOpcodes.AchievementUpdateNotify);
+
+        var notify = AchievementUpdateNotifyOuterClass.AchievementUpdateNotify.newBuilder()
+            .addAllAchievementList(achievements.stream().map(Achievement::toProto).toList())
+            .build();
+
+        this.setData(notify);
+    }
+}

src/main/java/emu/grasscutter/server/packet/send/PacketTakeAchievementGoalRewardRsp.java

@@ -0,0 +1,29 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.BasePacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ItemParamOuterClass;
+import emu.grasscutter.net.proto.RetcodeOuterClass;
+import emu.grasscutter.net.proto.TakeAchievementGoalRewardRspOuterClass;
+
+import java.util.List;
+
+public class PacketTakeAchievementGoalRewardRsp extends BasePacket {
+    public PacketTakeAchievementGoalRewardRsp() {
+        super(PacketOpcodes.TakeAchievementGoalRewardRsp);
+        this.setData(TakeAchievementGoalRewardRspOuterClass.TakeAchievementGoalRewardRsp.newBuilder()
+            .setRetcode(RetcodeOuterClass.Retcode.RET_REWARD_HAS_TAKEN_VALUE)
+            .build());
+    }
+
+    public PacketTakeAchievementGoalRewardRsp(List<Integer> ids, List<ItemParamOuterClass.ItemParam> items) {
+        super(PacketOpcodes.TakeAchievementGoalRewardRsp);
+
+        var rsp = TakeAchievementGoalRewardRspOuterClass.TakeAchievementGoalRewardRsp.newBuilder()
+            .addAllIdList(ids)
+            .addAllItemList(items)
+            .build();
+
+        this.setData(rsp);
+    }
+}

src/main/java/emu/grasscutter/server/packet/send/PacketTakeAchievementRewardRsp.java

@@ -0,0 +1,29 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.BasePacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ItemParamOuterClass;
+import emu.grasscutter.net.proto.RetcodeOuterClass;
+import emu.grasscutter.net.proto.TakeAchievementRewardRspOuterClass;
+
+import java.util.List;
+
+public class PacketTakeAchievementRewardRsp extends BasePacket {
+    public PacketTakeAchievementRewardRsp() {
+        super(PacketOpcodes.TakeAchievementRewardRsp);
+        this.setData(TakeAchievementRewardRspOuterClass.TakeAchievementRewardRsp.newBuilder()
+            .setRetcode(RetcodeOuterClass.Retcode.RET_REWARD_HAS_TAKEN_VALUE)
+            .build());
+    }
+
+    public PacketTakeAchievementRewardRsp(List<Integer> idList, List<ItemParamOuterClass.ItemParam> items) {
+        super(PacketOpcodes.TakeAchievementRewardRsp);
+
+        var rsp = TakeAchievementRewardRspOuterClass.TakeAchievementRewardRsp.newBuilder()
+            .addAllIdList(idList)
+            .addAllItemList(items)
+            .build();
+
+        this.setData(rsp);
+    }
+}

src/main/java/emu/grasscutter/tools/Tools.java

@@ -22,6 +22,7 @@ import emu.grasscutter.command.CommandHandler;
 import emu.grasscutter.command.CommandMap;
 import emu.grasscutter.data.GameData;
 import emu.grasscutter.data.ResourceLoader;
+import emu.grasscutter.data.excels.AchievementData;
 import emu.grasscutter.data.excels.AvatarData;
 import emu.grasscutter.data.excels.ItemData;
 import emu.grasscutter.utils.Language;
@@ -59,6 +60,7 @@ public final class Tools {
         val monsterDataMap = new Int2ObjectRBTreeMap<>(GameData.getMonsterDataMap());
         val sceneDataMap = new Int2ObjectRBTreeMap<>(GameData.getSceneDataMap());
         val questDataMap = new Int2ObjectRBTreeMap<>(GameData.getQuestDataMap());
+        val achievementDataMap = new Int2ObjectRBTreeMap<>(GameData.getAchievementDataMap());
 
         Function<SortedMap<?, ?>, String> getPad = m -> "%" + m.lastKey().toString().length() + "s : ";
 
@@ -145,6 +147,14 @@ public final class Tools {
             padQuestId.formatted(id) + "{0} - {1}",
             mainQuestTitles.get(data.getMainId()),
             data.getDescTextMapHash()));
+        // Achievements
+        h.newSection("Achievements");
+        val padAchievementId = getPad.apply(achievementDataMap);
+        achievementDataMap.values().stream()
+            .filter(AchievementData::isUsed)
+            .forEach(data -> {
+                h.newTranslatedLine(padAchievementId.formatted(data.getId()) + "{0} - {1}", data.getTitleTextMapHash(), data.getDescTextMapHash());
+            });
 
         // Write txt files
         for (int i = 0; i < TextStrings.NUM_LANGUAGES; i++) {

src/main/java/emu/grasscutter/utils/Language.java

@@ -5,6 +5,7 @@ import com.google.gson.JsonObject;
 import emu.grasscutter.Grasscutter;
 import emu.grasscutter.data.GameData;
 import emu.grasscutter.data.ResourceLoader;
+import emu.grasscutter.data.excels.AchievementData;
 import emu.grasscutter.game.player.Player;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
@@ -429,6 +430,12 @@ public final class Language {
         Grasscutter.getLogger().info("Generating TextMaps cache");
         ResourceLoader.loadAll();
         IntSet usedHashes = new IntOpenHashSet();
+        GameData.getAchievementDataMap().values().stream()
+            .filter(AchievementData::isUsed)
+            .forEach(a -> {
+                usedHashes.add((int) a.getTitleTextMapHash());
+                usedHashes.add((int) a.getDescTextMapHash());
+            });
         GameData.getAvatarDataMap().forEach((k, v) -> usedHashes.add((int) v.getNameTextMapHash()));
         GameData.getAvatarSkillDataMap().forEach((k, v) -> {
             usedHashes.add((int) v.getNameTextMapHash());