Merge `development` into `plugin-auth`

src/main/java/emu/grasscutter/game/quest/GameMainQuest.java

+package emu.grasscutter.game.quest;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import emu.grasscutter.server.packet.send.PacketCodexDataUpdateNotify;
+import org.bson.types.ObjectId;
+
+import dev.morphia.annotations.Entity;
+import dev.morphia.annotations.Id;
+import dev.morphia.annotations.Indexed;
+import dev.morphia.annotations.Transient;
+import emu.grasscutter.data.GameData;
+import emu.grasscutter.database.DatabaseHelper;
+import emu.grasscutter.game.player.Player;
+import emu.grasscutter.game.quest.enums.ParentQuestState;
+import emu.grasscutter.game.quest.enums.QuestState;
+import emu.grasscutter.net.proto.ChildQuestOuterClass.ChildQuest;
+import emu.grasscutter.net.proto.ParentQuestOuterClass.ParentQuest;
+import emu.grasscutter.net.proto.QuestOuterClass.Quest;
+import emu.grasscutter.server.packet.send.PacketFinishedParentQuestUpdateNotify;
+import emu.grasscutter.server.packet.send.PacketQuestListUpdateNotify;
+import emu.grasscutter.server.packet.send.PacketQuestProgressUpdateNotify;
+import emu.grasscutter.utils.Utils;
+import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+
+@Entity(value = "quests", useDiscriminator = false)
+public class GameMainQuest {
+	@Id private ObjectId id;
+	
+	@Indexed private int ownerUid;
+	@Transient private Player owner;
+	
+	private Map<Integer, GameQuest> childQuests;
+	
+	private int parentQuestId;
+	private int[] questVars;
+	private ParentQuestState state;
+	private boolean isFinished;
+	
+	@Deprecated // Morphia only. Do not use.
+	public GameMainQuest() {}
+	
+	public GameMainQuest(Player player, int parentQuestId) {
+		this.owner = player;
+		this.ownerUid = player.getUid();
+		this.parentQuestId = parentQuestId;
+		this.childQuests = new HashMap<>();
+		this.questVars = new int[5];
+		this.state = ParentQuestState.PARENT_QUEST_STATE_NONE;
+	}
+
+	public int getParentQuestId() {
+		return parentQuestId;
+	}
+	
+	public int getOwnerUid() {
+		return ownerUid;
+	}
+
+	public Player getOwner() {
+		return owner;
+	}
+
+	public void setOwner(Player player) {
+		if (player.getUid() != this.getOwnerUid()) return;
+		this.owner = player;
+	}
+
+	public Map<Integer, GameQuest> getChildQuests() {
+		return childQuests;
+	}
+	
+	public GameQuest getChildQuestById(int id) {
+		return this.getChildQuests().get(id);
+	}
+
+	public int[] getQuestVars() {
+		return questVars;
+	}
+
+	public ParentQuestState getState() {
+		return state;
+	}
+
+	public boolean isFinished() {
+		return isFinished;
+	}
+
+	public void finish() {
+		this.isFinished = true;
+		this.state = ParentQuestState.PARENT_QUEST_STATE_FINISHED;
+		this.getOwner().getSession().send(new PacketFinishedParentQuestUpdateNotify(this));
+		this.getOwner().getSession().send(new PacketCodexDataUpdateNotify(this));
+		this.save();
+	}
+
+	public void save() {
+		DatabaseHelper.saveQuest(this);
+	}
+
+	public ParentQuest toProto() {
+		ParentQuest.Builder proto = ParentQuest.newBuilder()
+				.setParentQuestId(getParentQuestId())
+				.setIsFinished(isFinished())
+				.setParentQuestState(getState().getValue());
+		
+		for (GameQuest quest : this.getChildQuests().values()) {
+			ChildQuest childQuest = ChildQuest.newBuilder()
+					.setQuestId(quest.getQuestId())
+					.setState(quest.getState().getValue())
+					.build();
+			
+			proto.addChildQuestList(childQuest);
+		}
+		
+		if (getQuestVars() != null) {
+			for (int i : getQuestVars()) {
+				proto.addQuestVar(i);
+			}
+		}
+
+		return proto.build();
+	}
+}

src/main/java/emu/grasscutter/game/quest/GameQuest.java

+package emu.grasscutter.game.quest;
+
+import dev.morphia.annotations.Entity;
+import dev.morphia.annotations.Transient;
+import emu.grasscutter.data.GameData;
+import emu.grasscutter.data.custom.MainQuestData;
+import emu.grasscutter.data.custom.MainQuestData.SubQuestData;
+import emu.grasscutter.data.def.QuestData;
+import emu.grasscutter.data.def.QuestData.QuestCondition;
+import emu.grasscutter.game.player.Player;
+import emu.grasscutter.game.quest.enums.LogicType;
+import emu.grasscutter.game.quest.enums.QuestState;
+import emu.grasscutter.net.proto.QuestOuterClass.Quest;
+import emu.grasscutter.server.packet.send.PacketCodexDataUpdateNotify;
+import emu.grasscutter.server.packet.send.PacketQuestListUpdateNotify;
+import emu.grasscutter.server.packet.send.PacketQuestProgressUpdateNotify;
+import emu.grasscutter.utils.Utils;
+
+@Entity
+public class GameQuest {
+	@Transient private GameMainQuest mainQuest;
+	@Transient private QuestData questData;
+	
+	private int questId;
+	private int mainQuestId;
+	private QuestState state;
+	
+	private int startTime;
+	private int acceptTime;
+	private int finishTime;
+	
+	private int[] finishProgressList;
+	private int[] failProgressList;
+	
+	@Deprecated // Morphia only. Do not use.
+	public GameQuest() {}
+	
+	public GameQuest(GameMainQuest mainQuest, QuestData questData) {
+		this.mainQuest = mainQuest;
+		this.questId = questData.getId();
+		this.mainQuestId = questData.getMainId();
+		this.questData = questData;
+		this.acceptTime = Utils.getCurrentSeconds();
+		this.startTime = this.acceptTime;
+		this.state = QuestState.QUEST_STATE_UNFINISHED;
+		
+		if (questData.getFinishCond()!= null) {
+			this.finishProgressList = new int[questData.getFinishCond().length];
+		}
+		
+		if (questData.getFailCond() != null) {
+			this.failProgressList = new int[questData.getFailCond().length];
+		}
+		
+		this.mainQuest.getChildQuests().put(this.questId, this);
+	}
+	
+	public GameMainQuest getMainQuest() {
+		return mainQuest;
+	}
+
+	public void setMainQuest(GameMainQuest mainQuest) {
+		this.mainQuest = mainQuest;
+	}
+	
+	public Player getOwner() {
+		return getMainQuest().getOwner();
+	}
+
+	public int getQuestId() {
+		return questId;
+	}
+
+	public int getMainQuestId() {
+		return mainQuestId;
+	}
+
+	public QuestData getData() {
+		return questData;
+	}
+
+	public void setConfig(QuestData config) {
+		if (this.getQuestId() != config.getId()) return;
+		this.questData = config;
+	}
+
+	public QuestState getState() {
+		return state;
+	}
+
+	public void setState(QuestState state) {
+		this.state = state;
+	}
+
+	public int getStartTime() {
+		return startTime;
+	}
+
+	public void setStartTime(int startTime) {
+		this.startTime = startTime;
+	}
+
+	public int getAcceptTime() {
+		return acceptTime;
+	}
+
+	public void setAcceptTime(int acceptTime) {
+		this.acceptTime = acceptTime;
+	}
+
+	public int getFinishTime() {
+		return finishTime;
+	}
+
+	public void setFinishTime(int finishTime) {
+		this.finishTime = finishTime;
+	}
+	
+	public int[] getFinishProgressList() {
+		return finishProgressList;
+	}
+	
+	public void setFinishProgress(int index, int value) {
+		finishProgressList[index] = value;
+	}
+
+	public int[] getFailProgressList() {
+		return failProgressList;
+	}
+	
+	public void setFailProgress(int index, int value) {
+		failProgressList[index] = value;
+	}
+
+	public void finish() {
+		this.state = QuestState.QUEST_STATE_FINISHED;
+		this.finishTime = Utils.getCurrentSeconds();
+		
+		if (this.getFinishProgressList() != null) {
+			for (int i = 0 ; i < getFinishProgressList().length; i++) {
+				getFinishProgressList()[i] = 1;
+			}
+		}
+		
+		this.getOwner().getSession().send(new PacketQuestProgressUpdateNotify(this));
+		this.getOwner().getSession().send(new PacketQuestListUpdateNotify(this));
+		
+		if (this.getData().finishParent()) {
+			// This quest finishes the questline - the main quest will also save the quest to db so we dont have to call save() here
+			this.getMainQuest().finish();
+		} else {
+			// Try and accept other quests if possible
+			this.tryAcceptQuestLine();
+			this.save();
+		}
+	}
+	
+	public boolean tryAcceptQuestLine() {
+		try {
+			MainQuestData questConfig = GameData.getMainQuestDataMap().get(this.getMainQuestId());
+			
+			for (SubQuestData subQuest : questConfig.getSubQuests()) {
+				GameQuest quest = getMainQuest().getChildQuestById(subQuest.getSubId());
+				
+				if (quest == null) {
+					QuestData questData = GameData.getQuestDataMap().get(subQuest.getSubId());
+					
+					if (questData == null || questData.getAcceptCond() == null) {
+						continue;
+					}
+					
+					int[] accept = new int[questData.getAcceptCond().length];
+							
+					// TODO
+					for (int i = 0; i < questData.getAcceptCond().length; i++) {
+						QuestCondition condition = questData.getAcceptCond()[i];
+						boolean result = getOwner().getServer().getQuestHandler().triggerCondition(this, condition, condition.getParam());
+						
+						accept[i] = result ? 1 : 0;
+					}
+					
+					boolean shouldAccept = LogicType.calculate(questData.getAcceptCondComb(), accept);
+					
+					if (shouldAccept) {
+						this.getOwner().getQuestManager().addQuest(questData.getId());
+					}
+				}
+			}
+		} catch (Exception e) {
+			
+		}
+
+		return false;
+	}
+	
+	public void save() {
+		getMainQuest().save();
+	}
+	
+	public Quest toProto() {
+		Quest.Builder proto = Quest.newBuilder()
+				.setQuestId(this.getQuestId())
+				.setState(this.getState().getValue())
+				.setParentQuestId(this.getMainQuestId())
+				.setStartTime(this.getStartTime())
+				.setStartGameTime(438)
+				.setAcceptTime(this.getAcceptTime());
+		
+		if (this.getFinishProgressList() != null) {
+			for (int i : this.getFinishProgressList()) {
+				proto.addFinishProgressList(i);
+			}
+		}
+		
+		if (this.getFailProgressList() != null) {
+			for (int i : this.getFailProgressList()) {
+				proto.addFailProgressList(i);
+			}
+		}
+		
+		return proto.build();
+	}
+}

src/main/java/emu/grasscutter/game/quest/QuestManager.java

+package emu.grasscutter.game.quest;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import emu.grasscutter.data.GameData;
+import emu.grasscutter.data.def.QuestData;
+import emu.grasscutter.data.def.QuestData.QuestCondition;
+import emu.grasscutter.database.DatabaseHelper;
+import emu.grasscutter.game.player.Player;
+import emu.grasscutter.game.quest.enums.QuestTrigger;
+import emu.grasscutter.game.quest.enums.LogicType;
+import emu.grasscutter.game.quest.enums.QuestState;
+import emu.grasscutter.server.packet.send.PacketFinishedParentQuestUpdateNotify;
+import emu.grasscutter.server.packet.send.PacketQuestListUpdateNotify;
+import emu.grasscutter.server.packet.send.PacketQuestProgressUpdateNotify;
+import emu.grasscutter.server.packet.send.PacketServerCondMeetQuestListUpdateNotify;
+import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+
+public class QuestManager {
+	private final Player player;
+	private final Int2ObjectMap<GameMainQuest> quests;
+	
+	public QuestManager(Player player) {
+		this.player = player;
+		this.quests = new Int2ObjectOpenHashMap<>();
+	}
+
+	public Player getPlayer() {
+		return player;
+	}
+
+	public Int2ObjectMap<GameMainQuest> getQuests() {
+		return quests;
+	}
+	
+	public GameMainQuest getMainQuestById(int mainQuestId) {
+		return getQuests().get(mainQuestId);
+	}
+	
+	public GameQuest getQuestById(int questId) {
+		QuestData questConfig = GameData.getQuestDataMap().get(questId);
+		if (questConfig == null) {
+			return null;
+		}
+		
+		GameMainQuest mainQuest = getQuests().get(questConfig.getMainId());
+		
+		if (mainQuest == null) {
+			return null;
+		}
+		
+		return mainQuest.getChildQuests().get(questId);
+	}
+	
+	public void forEachQuest(Consumer<GameQuest> callback) {
+		for (GameMainQuest mainQuest : getQuests().values()) {
+			for (GameQuest quest : mainQuest.getChildQuests().values()) {
+				callback.accept(quest);
+			}
+		}
+	}
+
+	public void forEachMainQuest(Consumer<GameMainQuest> callback) {
+		for (GameMainQuest mainQuest : getQuests().values()) {
+			callback.accept(mainQuest);
+		}
+	}
+	
+	// TODO
+	public void forEachActiveQuest(Consumer<GameQuest> callback) {
+		for (GameMainQuest mainQuest : getQuests().values()) {
+			for (GameQuest quest : mainQuest.getChildQuests().values()) {
+				if (quest.getState() != QuestState.QUEST_STATE_FINISHED) {
+					callback.accept(quest);
+				}
+			}
+		}
+	}
+	
+	public GameMainQuest addMainQuest(QuestData questConfig) {
+		GameMainQuest mainQuest = new GameMainQuest(getPlayer(), questConfig.getMainId());
+		getQuests().put(mainQuest.getParentQuestId(), mainQuest);
+
+		getPlayer().sendPacket(new PacketFinishedParentQuestUpdateNotify(mainQuest));
+		
+		return mainQuest;
+	}
+	
+	public GameQuest addQuest(int questId) {
+		QuestData questConfig = GameData.getQuestDataMap().get(questId);
+		if (questConfig == null) {
+			return null;
+		}
+		
+		// Main quest
+		GameMainQuest mainQuest = this.getMainQuestById(questConfig.getMainId());
+		
+		// Create main quest if it doesnt exist
+		if (mainQuest == null) {
+			mainQuest = addMainQuest(questConfig);
+		}
+		
+		// Sub quest
+		GameQuest quest = mainQuest.getChildQuestById(questId);
+		
+		if (quest != null) {
+			return null;
+		}
+
+		// Create
+		quest = new GameQuest(mainQuest, questConfig);
+
+		// Save main quest
+		mainQuest.save();
+
+		// Send packet
+		getPlayer().sendPacket(new PacketServerCondMeetQuestListUpdateNotify(quest));
+		getPlayer().sendPacket(new PacketQuestListUpdateNotify(quest));
+
+		return quest;
+	}
+	
+	public void triggerEvent(QuestTrigger condType, int... params) {
+		Set<GameQuest> changedQuests = new HashSet<>();
+		
+		this.forEachActiveQuest(quest -> {
+			QuestData data = quest.getData();
+			
+			for (int i = 0; i < data.getFinishCond().length; i++) {
+				if (quest.getFinishProgressList() == null || quest.getFinishProgressList()[i] == 1) {
+					continue;
+				}
+				
+				QuestCondition condition = data.getFinishCond()[i];
+				
+				if (condition.getType() != condType) {
+					continue;
+				}
+				
+				boolean result = getPlayer().getServer().getQuestHandler().triggerContent(quest, condition, params);
+				
+				if (result) {
+					quest.getFinishProgressList()[i] = 1;
+					
+					changedQuests.add(quest);
+				}
+			}
+		});
+		
+		for (GameQuest quest : changedQuests) {
+			LogicType logicType = quest.getData().getFailCondComb();
+			int[] progress = quest.getFinishProgressList();
+			
+			// Handle logical comb
+			boolean finish = LogicType.calculate(logicType, progress);
+
+			// Finish
+			if (finish) {
+				quest.finish();
+			} else {
+				getPlayer().sendPacket(new PacketQuestProgressUpdateNotify(quest));
+				quest.save();
+			}
+		}
+	}
+
+	public void loadFromDatabase() {
+		List<GameMainQuest> quests = DatabaseHelper.getAllQuests(getPlayer());
+		
+		for (GameMainQuest mainQuest : quests) {
+			mainQuest.setOwner(this.getPlayer());
+			
+			for (GameQuest quest : mainQuest.getChildQuests().values()) {
+				quest.setMainQuest(mainQuest);
+				quest.setConfig(GameData.getQuestDataMap().get(quest.getQuestId()));
+			}
+			
+			this.getQuests().put(mainQuest.getParentQuestId(), mainQuest);
+		}
+	}
+}

src/main/java/emu/grasscutter/game/quest/QuestValue.java

+package emu.grasscutter.game.quest;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import emu.grasscutter.game.quest.enums.QuestTrigger;
+
+@Retention(RetentionPolicy.RUNTIME) 
+public @interface QuestValue {
+	QuestTrigger value();
+}

src/main/java/emu/grasscutter/game/quest/ServerQuestHandler.java

+package emu.grasscutter.game.quest;
+
+import java.util.Set;
+
+import org.reflections.Reflections;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.data.def.QuestData.QuestCondition;
+import emu.grasscutter.game.quest.handlers.QuestBaseHandler;
+import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+
+@SuppressWarnings("unchecked")
+public class ServerQuestHandler {
+	private final Int2ObjectMap<QuestBaseHandler> condHandlers;
+	private final Int2ObjectMap<QuestBaseHandler> contHandlers;
+	private final Int2ObjectMap<QuestBaseHandler> execHandlers;
+	
+	public ServerQuestHandler() {
+		this.condHandlers = new Int2ObjectOpenHashMap<>(); 
+		this.contHandlers = new Int2ObjectOpenHashMap<>();
+		this.execHandlers = new Int2ObjectOpenHashMap<>();
+		
+		this.registerHandlers();
+	}
+
+	public void registerHandlers() {
+		this.registerHandlers(this.condHandlers, "emu.grasscutter.game.quest.conditions");
+		this.registerHandlers(this.contHandlers, "emu.grasscutter.game.quest.content");
+		this.registerHandlers(this.execHandlers, "emu.grasscutter.game.quest.exec");
+	}
+	
+	public void registerHandlers(Int2ObjectMap<QuestBaseHandler> map, String packageName) {
+		Reflections reflections = new Reflections(packageName);
+		Set<?> handlerClasses = reflections.getSubTypesOf(QuestBaseHandler.class);
+		
+		for (Object obj : handlerClasses) {
+			this.registerPacketHandler(map, (Class<? extends QuestBaseHandler>) obj);
+		}
+	}
+
+	public void registerPacketHandler(Int2ObjectMap<QuestBaseHandler> map, Class<? extends QuestBaseHandler> handlerClass) {
+		try {
+			QuestValue opcode = handlerClass.getAnnotation(QuestValue.class);
+
+			if (opcode == null || opcode.value().getValue() <= 0) {
+				return;
+			}
+
+			QuestBaseHandler packetHandler = (QuestBaseHandler) handlerClass.newInstance();
+
+			map.put(opcode.value().getValue(), packetHandler);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+	
+	// TODO make cleaner
+	
+	public boolean triggerCondition(GameQuest quest, QuestCondition condition, int... params) {
+		QuestBaseHandler handler = condHandlers.get(condition.getType().getValue());
+
+		if (handler == null || quest.getData() == null) {
+			return false;
+		}
+		
+		return handler.execute(quest, condition, params);
+	}
+	
+	public boolean triggerContent(GameQuest quest, QuestCondition condition, int... params) {
+		QuestBaseHandler handler = contHandlers.get(condition.getType().getValue());
+
+		if (handler == null || quest.getData() == null) {
+			return false;
+		}
+		
+		return handler.execute(quest, condition, params);
+	}
+	
+	public boolean triggerExec(GameQuest quest, QuestCondition condition, int... params) {
+		QuestBaseHandler handler = execHandlers.get(condition.getType().getValue());
+
+		if (handler == null || quest.getData() == null) {
+			return false;
+		}
+		
+		return handler.execute(quest, condition, params);
+	}
+}

src/main/java/emu/grasscutter/game/quest/conditions/BaseCondition.java

+package emu.grasscutter.game.quest.conditions;
+
+import emu.grasscutter.data.def.QuestData.QuestCondition;
+import emu.grasscutter.game.quest.QuestValue;
+import emu.grasscutter.game.quest.GameQuest;
+import emu.grasscutter.game.quest.enums.QuestTrigger;
+import emu.grasscutter.game.quest.handlers.QuestBaseHandler;
+
+@QuestValue(QuestTrigger.QUEST_CONTENT_NONE)
+public class BaseCondition extends QuestBaseHandler {
+
+	@Override
+	public boolean execute(GameQuest quest, QuestCondition condition, int... params) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+	
+}

src/main/java/emu/grasscutter/game/quest/conditions/ConditionPlayerLevelEqualGreater.java

+package emu.grasscutter.game.quest.conditions;
+
+import emu.grasscutter.data.def.QuestData.QuestCondition;
+import emu.grasscutter.game.quest.QuestValue;
+import emu.grasscutter.game.quest.GameQuest;
+import emu.grasscutter.game.quest.enums.QuestTrigger;
+import emu.grasscutter.game.quest.handlers.QuestBaseHandler;
+
+@QuestValue(QuestTrigger.QUEST_COND_PLAYER_LEVEL_EQUAL_GREATER)
+public class ConditionPlayerLevelEqualGreater extends QuestBaseHandler {
+
+	@Override
+	public boolean execute(GameQuest quest, QuestCondition condition, int... params) {
+		return quest.getOwner().getLevel() >= params[0];
+	}
+	
+}

src/main/java/emu/grasscutter/game/quest/conditions/ConditionStateEqual.java

+package emu.grasscutter.game.quest.conditions;
+
+import emu.grasscutter.data.def.QuestData.QuestCondition;
+import emu.grasscutter.game.quest.QuestValue;
+import emu.grasscutter.game.quest.GameQuest;
+import emu.grasscutter.game.quest.enums.QuestTrigger;
+import emu.grasscutter.game.quest.handlers.QuestBaseHandler;
+
+@QuestValue(QuestTrigger.QUEST_COND_STATE_EQUAL)
+public class ConditionStateEqual extends QuestBaseHandler {
+
+	@Override
+	public boolean execute(GameQuest quest, QuestCondition condition, int... params) {
+		GameQuest checkQuest = quest.getOwner().getQuestManager().getQuestById(params[0]);
+		
+		if (checkQuest != null) {
+			return checkQuest.getState().getValue() == params[1];
+		}
+		
+		return false; 
+	}
+	
+}

src/main/java/emu/grasscutter/game/quest/content/BaseContent.java

+package emu.grasscutter.game.quest.content;
+
+import emu.grasscutter.data.def.QuestData.QuestCondition;
+import emu.grasscutter.game.quest.QuestValue;
+import emu.grasscutter.game.quest.GameQuest;
+import emu.grasscutter.game.quest.enums.QuestTrigger;
+import emu.grasscutter.game.quest.handlers.QuestBaseHandler;
+
+@QuestValue(QuestTrigger.QUEST_CONTENT_NONE)
+public class BaseContent extends QuestBaseHandler {
+
+	@Override
+	public boolean execute(GameQuest quest, QuestCondition condition, int... params) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+	
+}

src/main/java/emu/grasscutter/game/quest/content/ContentCompleteTalk.java

+package emu.grasscutter.game.quest.content;
+
+import emu.grasscutter.data.def.QuestData.QuestCondition;
+import emu.grasscutter.game.quest.QuestValue;
+import emu.grasscutter.game.quest.GameQuest;
+import emu.grasscutter.game.quest.enums.QuestTrigger;
+import emu.grasscutter.game.quest.handlers.QuestBaseHandler;
+
+@QuestValue(QuestTrigger.QUEST_CONTENT_COMPLETE_TALK)
+public class ContentCompleteTalk extends QuestBaseHandler {
+
+	@Override
+	public boolean execute(GameQuest quest, QuestCondition condition, int... params) {
+		return condition.getParam()[0] == params[0];
+	}
+	
+}

src/main/java/emu/grasscutter/game/quest/content/ContentEnterDungeon.java

+package emu.grasscutter.game.quest.content;
+
+import emu.grasscutter.data.def.QuestData.QuestCondition;
+import emu.grasscutter.game.quest.QuestValue;
+import emu.grasscutter.game.quest.GameQuest;
+import emu.grasscutter.game.quest.enums.QuestTrigger;
+import emu.grasscutter.game.quest.handlers.QuestBaseHandler;
+
+@QuestValue(QuestTrigger.QUEST_CONTENT_ENTER_DUNGEON)
+public class ContentEnterDungeon extends QuestBaseHandler {
+
+	@Override
+	public boolean execute(GameQuest quest, QuestCondition condition, int... params) {
+		return condition.getParam()[0] == params[0];
+	}
+	
+}

src/main/java/emu/grasscutter/game/quest/content/ContentFinishPlot.java

+package emu.grasscutter.game.quest.content;
+
+import emu.grasscutter.data.def.QuestData.QuestCondition;
+import emu.grasscutter.game.quest.QuestValue;
+import emu.grasscutter.game.quest.GameQuest;
+import emu.grasscutter.game.quest.enums.QuestTrigger;
+import emu.grasscutter.game.quest.handlers.QuestBaseHandler;
+
+@QuestValue(QuestTrigger.QUEST_CONTENT_FINISH_PLOT)
+public class ContentFinishPlot extends QuestBaseHandler {
+
+	@Override
+	public boolean execute(GameQuest quest, QuestCondition condition, int... params) {
+		return condition.getParam()[0] == params[0];
+	}
+	
+}

src/main/java/emu/grasscutter/game/quest/enums/LogicType.java

+package emu.grasscutter.game.quest.enums;
+
+import java.util.Arrays;
+
+public enum LogicType {
+	LOGIC_NONE (0),
+	LOGIC_AND (1),
+	LOGIC_OR (2),
+	LOGIC_NOT (3),
+	LOGIC_A_AND_ETCOR (4),
+	LOGIC_A_AND_B_AND_ETCOR (5),
+	LOGIC_A_OR_ETCAND (6),
+	LOGIC_A_OR_B_OR_ETCAND (7),
+	LOGIC_A_AND_B_OR_ETCAND (8);
+	
+	private final int value;
+	
+	LogicType(int id) {
+		this.value = id;
+	}
+
+	public int getValue() {
+		return value;
+	}
+	
+	public static boolean calculate(LogicType logicType, int[] progress) {
+		if (logicType == null) {
+			return progress[0] == 1;
+		}
+		
+		switch (logicType) {
+		case LOGIC_AND -> {
+			return Arrays.stream(progress).allMatch(i -> i == 1);
+		}
+		case LOGIC_OR -> {
+			return Arrays.stream(progress).anyMatch(i -> i == 1);
+		}
+		default	-> {
+			return Arrays.stream(progress).anyMatch(i -> i == 1);
+		}
+	}
+	}
+}

src/main/java/emu/grasscutter/game/quest/enums/ParentQuestState.java

+package emu.grasscutter.game.quest.enums;
+
+public enum ParentQuestState {
+	PARENT_QUEST_STATE_NONE (0),
+	PARENT_QUEST_STATE_FINISHED (1),
+	PARENT_QUEST_STATE_FAILED (2),
+	PARENT_QUEST_STATE_CANCELED (3);
+	
+	private final int value;
+	
+	ParentQuestState(int id) {
+		this.value = id;
+	}
+
+	public int getValue() {
+		return value;
+	}
+}

src/main/java/emu/grasscutter/game/quest/enums/QuestGuideType.java

+package emu.grasscutter.game.quest.enums;
+
+public enum QuestGuideType {
+	QUEST_GUIDE_NONE (0),
+	QUEST_GUIDE_LOCATION (1),
+	QUEST_GUIDE_NPC (2);
+	
+	private final int value;
+	
+	QuestGuideType(int id) {
+		this.value = id;
+	}
+
+	public int getValue() {
+		return value;
+	}
+}

src/main/java/emu/grasscutter/game/quest/enums/QuestShowType.java

+package emu.grasscutter.game.quest.enums;
+
+public enum QuestShowType {
+	QUEST_SHOW (0),
+	QUEST_HIDDEN (1);
+	
+	private final int value;
+	
+	QuestShowType(int id) {
+		this.value = id;
+	}
+
+	public int getValue() {
+		return value;
+	}
+}

src/main/java/emu/grasscutter/game/quest/enums/QuestState.java

+package emu.grasscutter.game.quest.enums;
+
+public enum QuestState {
+	QUEST_STATE_NONE (0),
+	QUEST_STATE_UNSTARTED (1),
+	QUEST_STATE_UNFINISHED (2),
+	QUEST_STATE_FINISHED (3),
+	QUEST_STATE_FAILED (4);
+	
+	private final int value;
+	
+	QuestState(int id) {
+		this.value = id;
+	}
+
+	public int getValue() {
+		return value;
+	}
+}

src/main/java/emu/grasscutter/game/quest/enums/QuestTrigger.java

+package emu.grasscutter.game.quest.enums;
+
+public enum QuestTrigger {
+	QUEST_COND_NONE (0),
+	QUEST_COND_STATE_EQUAL (1),
+	QUEST_COND_STATE_NOT_EQUAL (2),
+	QUEST_COND_PACK_HAVE_ITEM (3),
+	QUEST_COND_AVATAR_ELEMENT_EQUAL (4),
+	QUEST_COND_AVATAR_ELEMENT_NOT_EQUAL (5),
+	QUEST_COND_AVATAR_CAN_CHANGE_ELEMENT (6),
+	QUEST_COND_CITY_LEVEL_EQUAL_GREATER (7),
+	QUEST_COND_ITEM_NUM_LESS_THAN (8),
+	QUEST_COND_DAILY_TASK_START (9),
+	QUEST_COND_OPEN_STATE_EQUAL (10),
+	QUEST_COND_DAILY_TASK_OPEN (11),
+	QUEST_COND_DAILY_TASK_REWARD_CAN_GET (12),
+	QUEST_COND_DAILY_TASK_REWARD_RECEIVED (13),
+	QUEST_COND_PLAYER_LEVEL_REWARD_CAN_GET (14),
+	QUEST_COND_EXPLORATION_REWARD_CAN_GET (15),
+	QUEST_COND_IS_WORLD_OWNER (16),
+	QUEST_COND_PLAYER_LEVEL_EQUAL_GREATER (17),
+	QUEST_COND_SCENE_AREA_UNLOCKED (18),
+	QUEST_COND_ITEM_GIVING_ACTIVED (19),
+	QUEST_COND_ITEM_GIVING_FINISHED (20),
+	QUEST_COND_IS_DAYTIME (21),
+	QUEST_COND_CURRENT_AVATAR (22),
+	QUEST_COND_CURRENT_AREA (23),
+	QUEST_COND_QUEST_VAR_EQUAL (24),
+	QUEST_COND_QUEST_VAR_GREATER (25),
+	QUEST_COND_QUEST_VAR_LESS (26),
+	QUEST_COND_FORGE_HAVE_FINISH (27),
+	QUEST_COND_DAILY_TASK_IN_PROGRESS (28),
+	QUEST_COND_DAILY_TASK_FINISHED (29),
+	QUEST_COND_ACTIVITY_COND (30),
+	QUEST_COND_ACTIVITY_OPEN (31),
+	QUEST_COND_DAILY_TASK_VAR_GT (32),
+	QUEST_COND_DAILY_TASK_VAR_EQ (33),
+	QUEST_COND_DAILY_TASK_VAR_LT (34),
+	QUEST_COND_BARGAIN_ITEM_GT (35),
+	QUEST_COND_BARGAIN_ITEM_EQ (36),
+	QUEST_COND_BARGAIN_ITEM_LT (37),
+	QUEST_COND_COMPLETE_TALK (38),
+	QUEST_COND_NOT_HAVE_BLOSSOM_TALK (39),
+	QUEST_COND_IS_CUR_BLOSSOM_TALK (40),
+	QUEST_COND_QUEST_NOT_RECEIVE (41),
+	QUEST_COND_QUEST_SERVER_COND_VALID (42),
+	QUEST_COND_ACTIVITY_CLIENT_COND (43),
+	QUEST_COND_QUEST_GLOBAL_VAR_EQUAL (44),
+	QUEST_COND_QUEST_GLOBAL_VAR_GREATER (45),
+	QUEST_COND_QUEST_GLOBAL_VAR_LESS (46),
+	QUEST_COND_PERSONAL_LINE_UNLOCK (47),
+	QUEST_COND_CITY_REPUTATION_REQUEST (48),
+	QUEST_COND_MAIN_COOP_START (49),
+	QUEST_COND_MAIN_COOP_ENTER_SAVE_POINT (50),
+	QUEST_COND_CITY_REPUTATION_LEVEL (51),
+	QUEST_COND_CITY_REPUTATION_UNLOCK (52),
+	QUEST_COND_LUA_NOTIFY (53),
+	QUEST_COND_CUR_CLIMATE (54),
+	QUEST_COND_ACTIVITY_END (55),
+	QUEST_COND_COOP_POINT_RUNNING (56),
+	QUEST_COND_GADGET_TALK_STATE_EQUAL (57),
+	QUEST_COND_AVATAR_FETTER_GT (58),
+	QUEST_COND_AVATAR_FETTER_EQ (59),
+	QUEST_COND_AVATAR_FETTER_LT (60),
+	QUEST_COND_NEW_HOMEWORLD_MOUDLE_UNLOCK (61),
+	QUEST_COND_NEW_HOMEWORLD_LEVEL_REWARD (62),
+	QUEST_COND_NEW_HOMEWORLD_MAKE_FINISH (63),
+	QUEST_COND_HOMEWORLD_NPC_EVENT (64),
+	QUEST_COND_TIME_VAR_GT_EQ (65),
+	QUEST_COND_TIME_VAR_PASS_DAY (66),
+	QUEST_COND_HOMEWORLD_NPC_NEW_TALK (67),
+	QUEST_COND_PLAYER_CHOOSE_MALE (68),
+	QUEST_COND_HISTORY_GOT_ANY_ITEM (69),
+	QUEST_COND_LEARNED_RECIPE (70),
+	QUEST_COND_LUNARITE_REGION_UNLOCKED (71),
+	QUEST_COND_LUNARITE_HAS_REGION_HINT_COUNT (72),
+	QUEST_COND_LUNARITE_COLLECT_FINISH (73),
+	QUEST_COND_LUNARITE_MARK_ALL_FINISH (74),
+	QUEST_COND_NEW_HOMEWORLD_SHOP_ITEM (75),
+	QUEST_COND_SCENE_POINT_UNLOCK (76),
+	QUEST_COND_SCENE_LEVEL_TAG_EQ (77),
+	
+	QUEST_CONTENT_NONE (0),
+	QUEST_CONTENT_KILL_MONSTER (1),
+	QUEST_CONTENT_COMPLETE_TALK (2),
+	QUEST_CONTENT_MONSTER_DIE (3),
+	QUEST_CONTENT_FINISH_PLOT (4),
+	QUEST_CONTENT_OBTAIN_ITEM (5),
+	QUEST_CONTENT_TRIGGER_FIRE (6),
+	QUEST_CONTENT_CLEAR_GROUP_MONSTER (7),
+	QUEST_CONTENT_NOT_FINISH_PLOT (8),
+	QUEST_CONTENT_ENTER_DUNGEON (9),
+	QUEST_CONTENT_ENTER_MY_WORLD (10),
+	QUEST_CONTENT_FINISH_DUNGEON (11),
+	QUEST_CONTENT_DESTROY_GADGET (12),
+	QUEST_CONTENT_OBTAIN_MATERIAL_WITH_SUBTYPE (13),
+	QUEST_CONTENT_NICK_NAME (14),
+	QUEST_CONTENT_WORKTOP_SELECT (15),
+	QUEST_CONTENT_SEAL_BATTLE_RESULT (16),
+	QUEST_CONTENT_ENTER_ROOM (17),
+	QUEST_CONTENT_GAME_TIME_TICK (18),
+	QUEST_CONTENT_FAIL_DUNGEON (19),
+	QUEST_CONTENT_LUA_NOTIFY (20),
+	QUEST_CONTENT_TEAM_DEAD (21),
+	QUEST_CONTENT_COMPLETE_ANY_TALK (22),
+	QUEST_CONTENT_UNLOCK_TRANS_POINT (23),
+	QUEST_CONTENT_ADD_QUEST_PROGRESS (24),
+	QUEST_CONTENT_INTERACT_GADGET (25),
+	QUEST_CONTENT_DAILY_TASK_COMP_FINISH (26),
+	QUEST_CONTENT_FINISH_ITEM_GIVING (27),
+	QUEST_CONTENT_SKILL (107),
+	QUEST_CONTENT_CITY_LEVEL_UP (109),
+	QUEST_CONTENT_PATTERN_GROUP_CLEAR_MONSTER (110),
+	QUEST_CONTENT_ITEM_LESS_THAN (111),
+	QUEST_CONTENT_PLAYER_LEVEL_UP (112),
+	QUEST_CONTENT_DUNGEON_OPEN_STATUE (113),
+	QUEST_CONTENT_UNLOCK_AREA (114),
+	QUEST_CONTENT_OPEN_CHEST_WITH_GADGET_ID (115),
+	QUEST_CONTENT_UNLOCK_TRANS_POINT_WITH_TYPE (116),
+	QUEST_CONTENT_FINISH_DAILY_DUNGEON (117),
+	QUEST_CONTENT_FINISH_WEEKLY_DUNGEON (118),
+	QUEST_CONTENT_QUEST_VAR_EQUAL (119),
+	QUEST_CONTENT_QUEST_VAR_GREATER (120),
+	QUEST_CONTENT_QUEST_VAR_LESS (121),
+	QUEST_CONTENT_OBTAIN_VARIOUS_ITEM (122),
+	QUEST_CONTENT_FINISH_TOWER_LEVEL (123),
+	QUEST_CONTENT_BARGAIN_SUCC (124),
+	QUEST_CONTENT_BARGAIN_FAIL (125),
+	QUEST_CONTENT_ITEM_LESS_THAN_BARGAIN (126),
+	QUEST_CONTENT_ACTIVITY_TRIGGER_FAILED (127),
+	QUEST_CONTENT_MAIN_COOP_ENTER_SAVE_POINT (128),
+	QUEST_CONTENT_ANY_MANUAL_TRANSPORT (129),
+	QUEST_CONTENT_USE_ITEM (130),
+	QUEST_CONTENT_MAIN_COOP_ENTER_ANY_SAVE_POINT (131),
+	QUEST_CONTENT_ENTER_MY_HOME_WORLD (132),
+	QUEST_CONTENT_ENTER_MY_WORLD_SCENE (133),
+	QUEST_CONTENT_TIME_VAR_GT_EQ (134),
+	QUEST_CONTENT_TIME_VAR_PASS_DAY (135),
+	QUEST_CONTENT_QUEST_STATE_EQUAL (136),
+	QUEST_CONTENT_QUEST_STATE_NOT_EQUAL (137),
+	QUEST_CONTENT_UNLOCKED_RECIPE (138),
+	QUEST_CONTENT_NOT_UNLOCKED_RECIPE (139),
+	QUEST_CONTENT_FISHING_SUCC (140),
+	QUEST_CONTENT_ENTER_ROGUE_DUNGEON (141),
+	QUEST_CONTENT_USE_WIDGET (142),
+	QUEST_CONTENT_CAPTURE_SUCC (143),
+	QUEST_CONTENT_CAPTURE_USE_CAPTURETAG_LIST (144),
+	QUEST_CONTENT_CAPTURE_USE_MATERIAL_LIST (145),
+	QUEST_CONTENT_ENTER_VEHICLE (147),
+	QUEST_CONTENT_SCENE_LEVEL_TAG_EQ (148),
+	QUEST_CONTENT_LEAVE_SCENE (149),
+	QUEST_CONTENT_LEAVE_SCENE_RANGE (150),
+	QUEST_CONTENT_IRODORI_FINISH_FLOWER_COMBINATION (151),
+	QUEST_CONTENT_IRODORI_POETRY_REACH_MIN_PROGRESS (152),
+	QUEST_CONTENT_IRODORI_POETRY_FINISH_FILL_POETRY (153),
+	
+	QUEST_EXEC_NONE (0),
+	QUEST_EXEC_DEL_PACK_ITEM (1),
+	QUEST_EXEC_UNLOCK_POINT (2),
+	QUEST_EXEC_UNLOCK_AREA (3),
+	QUEST_EXEC_UNLOCK_FORCE (4),
+	QUEST_EXEC_LOCK_FORCE (5),
+	QUEST_EXEC_CHANGE_AVATAR_ELEMET (6),
+	QUEST_EXEC_REFRESH_GROUP_MONSTER (7),
+	QUEST_EXEC_SET_IS_FLYABLE (8),
+	QUEST_EXEC_SET_IS_WEATHER_LOCKED (9),
+	QUEST_EXEC_SET_IS_GAME_TIME_LOCKED (10),
+	QUEST_EXEC_SET_IS_TRANSFERABLE (11),
+	QUEST_EXEC_GRANT_TRIAL_AVATAR (12),
+	QUEST_EXEC_OPEN_BORED (13),
+	QUEST_EXEC_ROLLBACK_QUEST (14),
+	QUEST_EXEC_NOTIFY_GROUP_LUA (15),
+	QUEST_EXEC_SET_OPEN_STATE (16),
+	QUEST_EXEC_LOCK_POINT (17),
+	QUEST_EXEC_DEL_PACK_ITEM_BATCH (18),
+	QUEST_EXEC_REFRESH_GROUP_SUITE (19),
+	QUEST_EXEC_REMOVE_TRIAL_AVATAR (20),
+	QUEST_EXEC_SET_GAME_TIME (21),
+	QUEST_EXEC_SET_WEATHER_GADGET (22),
+	QUEST_EXEC_ADD_QUEST_PROGRESS (23),
+	QUEST_EXEC_NOTIFY_DAILY_TASK (24),
+	QUEST_EXEC_CREATE_PATTERN_GROUP (25),
+	QUEST_EXEC_REMOVE_PATTERN_GROUP (26),
+	QUEST_EXEC_REFRESH_GROUP_SUITE_RANDOM (27),
+	QUEST_EXEC_ACTIVE_ITEM_GIVING (28),
+	QUEST_EXEC_DEL_ALL_SPECIFIC_PACK_ITEM (29),
+	QUEST_EXEC_ROLLBACK_PARENT_QUEST (30),
+	QUEST_EXEC_LOCK_AVATAR_TEAM (31),
+	QUEST_EXEC_UNLOCK_AVATAR_TEAM (32),
+	QUEST_EXEC_UPDATE_PARENT_QUEST_REWARD_INDEX (33),
+	QUEST_EXEC_SET_DAILY_TASK_VAR (34),
+	QUEST_EXEC_INC_DAILY_TASK_VAR (35),
+	QUEST_EXEC_DEC_DAILY_TASK_VAR (36),
+	QUEST_EXEC_ACTIVE_ACTIVITY_COND_STATE (37),
+	QUEST_EXEC_INACTIVE_ACTIVITY_COND_STATE (38),
+	QUEST_EXEC_ADD_CUR_AVATAR_ENERGY (39),
+	QUEST_EXEC_START_BARGAIN (41),
+	QUEST_EXEC_STOP_BARGAIN (42),
+	QUEST_EXEC_SET_QUEST_GLOBAL_VAR (43),
+	QUEST_EXEC_INC_QUEST_GLOBAL_VAR (44),
+	QUEST_EXEC_DEC_QUEST_GLOBAL_VAR (45),
+	QUEST_EXEC_REGISTER_DYNAMIC_GROUP (46),
+	QUEST_EXEC_UNREGISTER_DYNAMIC_GROUP (47),
+	QUEST_EXEC_SET_QUEST_VAR (48),
+	QUEST_EXEC_INC_QUEST_VAR (49),
+	QUEST_EXEC_DEC_QUEST_VAR (50),
+	QUEST_EXEC_RANDOM_QUEST_VAR (51),
+	QUEST_EXEC_ACTIVATE_SCANNING_PIC (52),
+	QUEST_EXEC_RELOAD_SCENE_TAG (53),
+	QUEST_EXEC_REGISTER_DYNAMIC_GROUP_ONLY (54),
+	QUEST_EXEC_CHANGE_SKILL_DEPOT (55),
+	QUEST_EXEC_ADD_SCENE_TAG (56),
+	QUEST_EXEC_DEL_SCENE_TAG (57),
+	QUEST_EXEC_INIT_TIME_VAR (58),
+	QUEST_EXEC_CLEAR_TIME_VAR (59),
+	QUEST_EXEC_MODIFY_CLIMATE_AREA (60),
+	QUEST_EXEC_GRANT_TRIAL_AVATAR_AND_LOCK_TEAM (61),
+	QUEST_EXEC_CHANGE_MAP_AREA_STATE (62),
+	QUEST_EXEC_DEACTIVE_ITEM_GIVING (63),
+	QUEST_EXEC_CHANGE_SCENE_LEVEL_TAG (64),
+	QUEST_EXEC_UNLOCK_PLAYER_WORLD_SCENE (65),
+	QUEST_EXEC_LOCK_PLAYER_WORLD_SCENE (66),
+	QUEST_EXEC_FAIL_MAINCOOP (67),
+	QUEST_EXEC_MODIFY_WEATHER_AREA (68);
+	
+	private final int value;
+	
+	QuestTrigger(int id) {
+		this.value = id;
+	}
+
+	public int getValue() {
+		return value;
+	}
+}

src/main/java/emu/grasscutter/game/quest/enums/QuestType.java

+package emu.grasscutter.game.quest.enums;
+
+public enum QuestType {
+	AQ (0),
+	FQ (1),
+	LQ (2),
+	EQ (3),
+	DQ (4),
+	IQ (5),
+	VQ (6),
+	WQ (7);
+	
+	private final int value;
+	
+	QuestType(int id) {
+		this.value = id;
+	}
+
+	public int getValue() {
+		return value;
+	}
+}

src/main/java/emu/grasscutter/game/quest/enums/ShowQuestGuideType.java

+package emu.grasscutter.game.quest.enums;
+
+public enum ShowQuestGuideType {
+	QUEST_GUIDE_ITEM_ENABLE (0),
+	QUEST_GUIDE_ITEM_DISABLE (1),
+	QUEST_GUIDE_ITEM_MOVE_HIDE (2);
+	
+	private final int value;
+	
+	ShowQuestGuideType(int id) {
+		this.value = id;
+	}
+
+	public int getValue() {
+		return value;
+	}
+}