 /*
This file is part of the OdinMS Maple Story Server
Copyright (C) 2008 Patrick Huy <patrick.huy@frz.cc>
	       Matthias Butz <matze@odinms.de>
	       Jan Christian Meyer <vimes@odinms.de>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation version 3 as published by
the Free Software Foundation. You may not use, modify or distribute
this program under any other version of the GNU Affero General Public
License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
package org.gms.net.server.channel.handlers;

import org.gms.client.Client;
import org.gms.client.inventory.Item;
import org.gms.constants.inventory.ItemConstants;
import org.gms.net.AbstractPacketHandler;
import org.gms.net.packet.InPacket;
import org.gms.scripting.item.ItemScriptManager;
import org.gms.server.ItemInformationProvider;
import org.gms.server.ItemInformationProvider.ScriptedItem;

      /**
     * @author Jay Estrella
 */
public final class ScriptedItemHandler extends AbstractPacketHandler {
@Override
public final void handlePacket(InPacket p, Client c) {
    p.readInt(); // trash stamp, thanks RMZero213
    short itemSlot = p.readShort(); // item slot, thanks RMZero213
    int itemId = p.readInt();

    ItemInformationProvider ii = ItemInformationProvider.getInstance();
    ScriptedItem info = ii.getScriptedItemInfo(itemId);
    if (info == null) {
        return;
    }

    Item item = c.getPlayer().getInventory(ItemConstants.getInventoryType(itemId)).getItem(itemSlot);
    if (item == null || item.getItemId() != itemId || item.getQuantity() < 1) {
        return;
    }

    ItemScriptManager ism = ItemScriptManager.getInstance();
    ism.runItemScript(c, info);
}

}
由于这个类里没有正确的处理客户端回传的数据，导致卡门等问题，现在把这段全部换成，下面的逻辑：

package org.gms.net.server.channel.handlers;
import org.gms.client.Character;
import org.gms.client.Client;
import org.gms.client.inventory.InventoryType;
import org.gms.client.inventory.Item;
import org.gms.constants.inventory.ItemConstants;
import org.gms.net.AbstractPacketHandler;
import org.gms.net.packet.InPacket;
import org.gms.scripting.item.ItemScriptManager;
import org.gms.server.ItemInformationProvider;
import org.gms.server.ItemInformationProvider.ScriptedItem;
import org.gms.util.PacketCreator;

/**
 * @author Jay Estrella
 */
public final class ScriptedItemHandler extends AbstractPacketHandler {
@Override
public final void handlePacket(InPacket p, Client c) {
    Character chr = c.getPlayer();
    if (chr == null || !chr.isAlive()) {
        c.sendPacket(PacketCreator.enableActions());
        return;
    }

    p.readInt(); // trash stamp, thanks RMZero213
    short itemSlot = p.readShort(); // item slot, thanks RMZero213
    int clientItemId = p.readInt();

    InventoryType type = ItemConstants.getInventoryType(clientItemId);
    if (type == null || type == InventoryType.UNDEFINED) {
        c.sendPacket(PacketCreator.enableActions());
        return;
    }

    Item item = chr.getInventory(type).getItem(itemSlot);
    if (item == null || item.getQuantity() < 1) {
        c.sendPacket(PacketCreator.enableActions());
        return;
    }

    int realItemId = item.getItemId();
    if (realItemId != clientItemId) {
        c.sendPacket(PacketCreator.enableActions());
        return;
    }

    if (org.gms.service.RandomItemBoxService.use(chr, realItemId)) {
        return;
    }

    ItemInformationProvider ii = ItemInformationProvider.getInstance();
    ScriptedItem info = ii.getScriptedItemInfo(realItemId);
    if (info == null) {
        c.sendPacket(PacketCreator.enableActions());
        return;
    }

    ItemScriptManager ism = ItemScriptManager.getInstance();
    ism.runItemScript(c, info);
}
}

QuestActionManager现在的 QuestActionManager.dispose() 只做了：普通 NPC 脚本的 NPCConversationManager.dispose() 会解锁，而Quest 脚本没有做解锁的处理，所以把这个文件替换成下面这个：

package org.gms.scripting.quest;

import org.gms.client.Client;
import org.gms.scripting.npc.NPCConversationManager;
import org.gms.server.ItemInformationProvider;
import org.gms.server.quest.Quest;
import org.gms.server.quest.actions.ExpAction;
import org.gms.server.quest.actions.MesoAction;

/**
 * @author RMZero213
 */
public class QuestActionManager extends NPCConversationManager {
private final boolean start; // this is if the script in question is start or end
private final int quest;

public QuestActionManager(Client c, int quest, int npc, boolean start) {
    super(c, npc, null);
    this.quest = quest;
    this.start = start;
}

public int getQuest() {
    return quest;
}

public boolean isStart() {
    return start;
}

@Override
public void dispose() {
    QuestScriptManager.getInstance().dispose(this, getClient(), true);
}

public boolean forceStartQuest() {
    return forceStartQuest(quest);
}

public boolean forceCompleteQuest() {
    return forceCompleteQuest(quest);
}

// For compatibility with some older scripts...
public void startQuest() {
    forceStartQuest();
}

// For compatibility with some older scripts...
public void completeQuest() {
    forceCompleteQuest();
}

@Override
public void gainExp(int gain) {
    ExpAction.runAction(getPlayer(), gain);
}

@Override
public void gainMeso(int gain) {
    MesoAction.runAction(getPlayer(), gain);
}

public String getMedalName() {  // usable only for medal quests (id 299XX)
    Quest q = Quest.getInstance(quest);
    return ItemInformationProvider.getInstance().getName(q.getMedalRequirement());
}
}

QuestScriptManager这个最严重early return / catch / dispose 机制都不统一也替换成下面这个Quest 脚本结束时会明确解锁，脚本异常时会明确解锁
脚本重复进入节流失败引擎空脚本时也会明确解锁：

package org.gms.scripting.quest;

import org.gms.client.Client;
import org.gms.client.QuestStatus;
import org.gms.constants.game.GameConstants;    
import org.gms.scripting.AbstractScriptManager;
import org.gms.server.quest.Quest;
import org.gms.util.PacketCreator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptException;
import java.util.HashMap;
import java.util.Map;

/**
 * @author RMZero213
 */
public class QuestScriptManager extends AbstractScriptManager {
private static final Logger log = LoggerFactory.getLogger(QuestScriptManager.class);
private static final QuestScriptManager instance = new QuestScriptManager();

private final Map<Client, QuestActionManager> qms = new HashMap<>();
private final Map<Client, Invocable> scripts = new HashMap<>();

public static QuestScriptManager getInstance() {
    return instance;
}

private ScriptEngine getQuestScriptEngine(Client c, short questid) {
    ScriptEngine engine = getInvocableScriptEngine("quest/" + questid + ".js", c);
    if (engine == null && GameConstants.isMedalQuest(questid)) {
        engine = getInvocableScriptEngine("quest/medalQuest.js", c);   // start generic medal quest
    }

    return engine;
}

public void start(Client c, short questid, int npc) {
    try {
        QuestActionManager qm = new QuestActionManager(c, questid, npc, true);
        if (qms.containsKey(c)) {
            dispose(c, true);
        }
        if (!c.canClickNPC()) {
            c.sendPacket(PacketCreator.enableActions());
            return;
        }

        qms.put(c, qm);

        ScriptEngine engine = getQuestScriptEngine(c, questid);
        if (engine == null) {
            log.warn("START Quest {} is uncoded.", questid);
            dispose(c, true);
            return;
        }

        engine.put("qm", qm);

        Invocable iv = (Invocable) engine;
        scripts.put(c, iv);
        c.setClickedNPC();
        iv.invokeFunction("start", (byte) 1, (byte) 0, 0);
    } catch (final Throwable t) {
        log.error("Error starting quest script: {}", questid, t);
        dispose(c, true);
    }
}

public void start(Client c, byte mode, byte type, int selection) {
    Invocable iv = scripts.get(c);
    if (iv != null) {
        try {
            c.setClickedNPC();
            iv.invokeFunction("start", mode, type, selection);
        } catch (final Exception e) {
            QuestActionManager qm = getQM(c);
            log.error("Error starting quest script: {}", qm != null ? qm.getQuest() : "?", e);
            dispose(c, true);
        }
    } else {
        c.sendPacket(PacketCreator.enableActions());
    }
}

public void end(Client c, short questid, int npc) {
    Quest quest = Quest.getInstance(questid);
    if (!c.getPlayer().getQuest(quest).getStatus().equals(QuestStatus.Status.STARTED)
            || (!c.getPlayer().getMap().containsNPC(npc) && !quest.isAutoComplete())) {
        dispose(c, true);
        return;
    }
    try {
        QuestActionManager qm = new QuestActionManager(c, questid, npc, false);
        if (qms.containsKey(c)) {
            dispose(c, true);
        }
        if (!c.canClickNPC()) {
            c.sendPacket(PacketCreator.enableActions());
            return;
        }

        qms.put(c, qm);

        ScriptEngine engine = getQuestScriptEngine(c, questid);
        if (engine == null) {
            log.warn("END Quest {} is uncoded.", questid);
            dispose(c, true);
            return;
        }

        engine.put("qm", qm);

        Invocable iv = (Invocable) engine;
        scripts.put(c, iv);
        c.setClickedNPC();
        iv.invokeFunction("end", (byte) 1, (byte) 0, 0);
    } catch (final Throwable t) {
        log.error("Error ending quest script: {}", questid, t);
        dispose(c, true);
    }
}

public void end(Client c, byte mode, byte type, int selection) {
    Invocable iv = scripts.get(c);
    if (iv != null) {
        try {
            c.setClickedNPC();
            iv.invokeFunction("end", mode, type, selection);
        } catch (final Exception e) {
            QuestActionManager qm = getQM(c);
            log.error("Error ending quest script: {}", qm != null ? qm.getQuest() : "?", e);
            dispose(c, true);
        }
    } else {
        c.sendPacket(PacketCreator.enableActions());
    }
}

public void raiseOpen(Client c, short questid, int npc) {
    try {
        QuestActionManager qm = new QuestActionManager(c, questid, npc, true);
        if (qms.containsKey(c)) {
            dispose(c, true);
        }
        if (!c.canClickNPC()) {
            c.sendPacket(PacketCreator.enableActions());
            return;
        }

        qms.put(c, qm);

        ScriptEngine engine = getQuestScriptEngine(c, questid);
        if (engine == null) {
            dispose(c, true);
            return;
        }

        engine.put("qm", qm);

        Invocable iv = (Invocable) engine;
        scripts.put(c, iv);
        c.setClickedNPC();
        iv.invokeFunction("raiseOpen");
    } catch (final Throwable t) {
        log.error("Error during quest script raiseOpen for quest: {}", questid, t);
        dispose(c, true);
    }
}

public void dispose(QuestActionManager qm, Client c) {
    dispose(qm, c, false);
}

public void dispose(QuestActionManager qm, Client c, boolean action) {
    qms.remove(c);
    scripts.remove(c);
    c.getPlayer().setNpcCooldown(System.currentTimeMillis());
    resetContext("quest/" + qm.getQuest() + ".js", c);
    c.getPlayer().flushDelayedUpdateQuests();

    if (action) {
        c.removeClickedNPC();
        c.sendPacket(PacketCreator.enableActions());
    }
}

public void dispose(Client c) {
    dispose(c, false);
}

public void dispose(Client c, boolean action) {
    QuestActionManager qm = qms.get(c);
    if (qm != null) {
        dispose(qm, c, action);
    } else if (action) {
        c.removeClickedNPC();
        c.sendPacket(PacketCreator.enableActions());
    }
}

public QuestActionManager getQM(Client c) {
    return qms.get(c);
}

public void reloadQuestScripts() {
    scripts.clear();
    qms.clear();
}

public boolean checkFunctionExists(Client c, short questid, int npc, String functionName) {
    ScriptEngine engine = getQuestScriptEngine(c, questid);
    if (engine == null) {
        return false;
    }
    try {
        QuestActionManager qm = new QuestActionManager(c, questid, npc, false);
        engine.put("qm", qm);
        String script = "function checkFunction(funcName) { return typeof this[funcName] === 'function'; }";
        engine.eval(script);

        Invocable invocable = (Invocable) engine;
        boolean exists = (Boolean) invocable.invokeFunction("checkFunction", functionName);

        qm.dispose();
        return exists;
    } catch (ScriptException | NoSuchMethodException e) {
        log.error("Error checking quest script function: {}", questid, e);
        dispose(c, true);
    }
    return false;
}
}