Games

Development Platform:
Java

CommandProcessor.java：Code Content
							//zREhYms
package net.sf.odinms.client.messages;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import net.sf.odinms.client.MapleCharacter;
import net.sf.odinms.client.MapleClient;
import net.sf.odinms.client.SkillFactory;
import net.sf.odinms.server.life.MapleLifeFactory;
import net.sf.odinms.database.DatabaseConnection;
import net.sf.odinms.server.life.MapleMonster;
import net.sf.odinms.net.channel.ChannelServer;
import net.sf.odinms.net.channel.handler.GeneralchatHandler;
import net.sf.odinms.server.TimerManager;
import net.sf.odinms.scripting.npc.NPCScriptManager;
import net.sf.odinms.server.maps.MapleMap;
import net.sf.odinms.server.MapleShop;
import net.sf.odinms.server.MapleShopFactory;
import net.sf.odinms.tools.ClassFinder;
import net.sf.odinms.tools.MockIOSession;
import net.sf.odinms.tools.Pair;
import net.sf.odinms.tools.StringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CommandProcessor implements CommandProcessorMBean {
    private static final Logger log = LoggerFactory.getLogger(GeneralchatHandler.class);
    private static List<Pair<MapleCharacter, String>> gmlog = new LinkedList<Pair<MapleCharacter, String>>();
    private Map<String, DefinitionCommandPair> commands = new LinkedHashMap<String, DefinitionCommandPair>();
    private static CommandProcessor instance = new CommandProcessor();
    private static Runnable persister;
    static {
        persister = new PersistingTask();
        TimerManager.getInstance().register(persister, 62000);
    }
    private CommandProcessor() {
        instance = this; // hackydihack
        reloadCommands();
    }
    public static class PersistingTask implements Runnable {
        @Override
        public void run() {
            synchronized (gmlog) {
                Connection con = DatabaseConnection.getConnection();
                try {
                    PreparedStatement ps = con.prepareStatement("INSERT INTO gmlog (cid, command) VALUES (?, ?)");
                    for (Pair<MapleCharacter, String> logentry : gmlog) {
                        ps.setInt(1, logentry.getLeft().getId());
                        ps.setString(2, logentry.getRight());
                        ps.executeUpdate();
                    }
                    ps.close();
                } catch (SQLException e) {
                    log.error("错误的GM命令文档！", e);
                }
                gmlog.clear();
            }
        }
    }
    public static boolean makeCustomSummon(MapleClient c, String type, int monsterid, int quantity, int gmlvl) {
        if (c.getPlayer().gmLevel() >= gmlvl) {
            if (type.equals("spawn")) {
                for (int i = 0; i < quantity; i++) {
                    MapleMonster mob = MapleLifeFactory.getMonster(monsterid);
                    c.getPlayer().getMap().spawnMonsterOnGroudBelow(mob, c.getPlayer().getPosition());
                }
            } else if (type.equals("npc")) {
                NPCScriptManager npc = NPCScriptManager.getInstance();
                npc.start(c, monsterid, null, null);
            } else if (type.equals("shop")) {
                MapleShopFactory s = MapleShopFactory.getInstance();
                MapleShop shop = s.getShop(monsterid);
                shop.sendShop(c);
            } else {
                c.getPlayer().dropMessage("Custom Command failed");
                return false;
            }
        } else {
            c.getPlayer().dropMessage("Your GM level isn't high enough.");
        }
        return true;
    }
    public static void registerMBean() {
        MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
        try {
            mBeanServer.registerMBean(instance, new ObjectName("net.sf.odinms.client.messages:name=CommandProcessor"));
        } catch (Exception e) {
            log.error("错误的命令试图载入数据库表，为防止数据库混乱，已被阻止，载入失败！");
        }
    }
    public static String joinAfterString(String splitted[], String str) {
        for (int i = 1; i < splitted.length; i++) {
            if (splitted[i].equalsIgnoreCase(str) && i + 1 < splitted.length) {
                return StringUtil.joinStringFrom(splitted, i + 1);
            }
        }
        return null;
    }
    public static int getOptionalIntArg(String splitted[], int position, int def) {
        if (splitted.length > position) {
            try {
                return Integer.parseInt(splitted[position]);
            } catch (NumberFormatException nfe) {
                return def;
            }
        }
        return def;
    }
    public static String getNamedArg(String splitted[], int startpos, String name) {
        for (int i = startpos; i < splitted.length; i++) {
            if (splitted[i].equalsIgnoreCase(name) && i + 1 < splitted.length) {
                return splitted[i + 1];
            }
        }
        return null;
    }
    public static Integer getNamedIntArg(String splitted[], int startpos, String name) {
        String arg = getNamedArg(splitted, startpos, name);
        if (arg != null) {
            try {
                return Integer.parseInt(arg);
            } catch (NumberFormatException nfe) {
            }
        }
        return null;
    }
    public static int getNamedIntArg(String splitted[], int startpos, String name, int def) {
        Integer ret = getNamedIntArg(splitted, startpos, name);
        if (ret == null) {
            return def;
        }
        return ret.intValue();
    }
    public static Double getNamedDoubleArg(String splitted[], int startpos, String name) {
        String arg = getNamedArg(splitted, startpos, name);
        if (arg != null) {
            try {
                return Double.parseDouble(arg);
            } catch (NumberFormatException nfe) {
            }
        }
        return null;
    }
    public String processCommandJMX(int cserver, int mapid, String command) {
        ChannelServer cserv = ChannelServer.getInstance(cserver);
        if (cserv == null) {
            return "指定的区域不存在这个服务器进程，无法关闭！";
        }
        MapleClient c = new MapleClient(null, null, new MockIOSession());
        MapleCharacter chr = MapleCharacter.getDefault(c, 26023);
        c.setPlayer(chr);
        MapleMap map = cserv.getMapFactory().getMap(mapid);
        if (map != null) {
            chr.setMap(map);
            SkillFactory.getSkill(9101004).getEffect(1).applyTo(chr);
            map.addPlayer(chr);
        }
        cserv.addPlayer(chr);
        MessageCallback mc = new StringMessageCallback();
        try {
            processCommandInternal(c, mc, command);
        } finally {
            if (map != null) {
                map.removePlayer(chr);
            }
            cserv.removePlayer(chr);
        }
        return mc.toString();
    }
    public boolean processCommand(MapleClient c, String line) {
        return instance.processCommandInternal(c, new ServernoticeMapleClientMessageCallback(c), line);
    }
    public static void forcePersisting() {
        persister.run();
    }
    public static CommandProcessor getInstance() {
        return instance;
    }
    public void reloadCommands() {
        commands.clear();
        try {
            ClassFinder classFinder = new ClassFinder();
            String[] classes = classFinder.listClasses("net.sf.odinms.client.messages.commands", true);
            for (String clazz : classes) {
                Class<?> clasz = Class.forName(clazz);
                if (Command.class.isAssignableFrom(clasz)) {
                    try {
                        Command newInstance = (Command) clasz.newInstance();
                        registerCommand(newInstance);
                    } catch (Exception e) {
                        log.error("错误的GM命令！", e);
                    }
                }
            }
        } catch (ClassNotFoundException e) {
            log.error("注入：", e);
        }
    }
    private void registerCommand(Command command) {
        CommandDefinition[] definition = command.getDefinition();
        for (CommandDefinition def : definition) {
            commands.put(def.getCommand().toLowerCase(), new DefinitionCommandPair(command, def));
        }
    }
    public void dropHelp(MapleCharacter chr, MessageCallback mc, int page) {
        List<DefinitionCommandPair> allCommands = new ArrayList<DefinitionCommandPair>(commands.values());
        int startEntry = (page - 1) * 20;
        mc.dropMessage("命令页码: " + page);
        for (int i = startEntry; i < startEntry + 20 && i < allCommands.size(); i++) {
            CommandDefinition commandDefinition = allCommands.get(i).getDefinition();
            if (chr.getGMLevel() == commandDefinition.getRequiredLevel()) {
                dropHelpForDefinition(mc, commandDefinition);
            }
        }
    }
    public void writeCommandList() {
        try {
            List<DefinitionCommandPair> allCommands = new ArrayList<DefinitionCommandPair>(commands.values());
            FileWriter fw = new FileWriter(new File("Commands.txt"));
            String lineSeparator = System.getProperty("line.separator");
            fw.flush();
            for (int x = 4; x >= 0; x--) {
                fw.write("---------------------------------");
                fw.write(lineSeparator);
                fw.write("       等级为： " + x + " C的GM命令文档！.");
                fw.write(lineSeparator);
                fw.write("---------------------------------");
                fw.write(lineSeparator);
                fw.write(lineSeparator);
                for (int i = 0; i < allCommands.size(); i++) {
                    if (allCommands.get(i).getDefinition().getRequiredLevel() == x) {
                        fw.write(allCommands.get(i).getDefinition().getCommand());
                        fw.write(lineSeparator);
                    }
                }
            }
            fw.close();
        } catch (IOException e) {
            log.error("注入：", e);
        }
    }
    private void dropHelpForDefinition(MessageCallback mc, CommandDefinition commandDefinition) {
        mc.dropMessage(commandDefinition.getCommand());
    }
    private boolean processCommandInternal(MapleClient c, MessageCallback mc, String line) {
        switch (line.charAt(0)) {
           case '!': // GM commands
            case '@': // Player commands
            case '#': // Interns
            case '$': // VIP?
                String[] splitted = line.split(" ");
                if (splitted.length > 0) {
                    DefinitionCommandPair definitionCommandPair = commands.get(splitted[0].toLowerCase().substring(1));
                    if (definitionCommandPair != null && c.getPlayer().getGMLevel() >= definitionCommandPair.getDefinition().getRequiredLevel()) {
                        if (definitionCommandPair.getDefinition().getRequiredLevel() >= 3) {
                            gmlog.add(new Pair<MapleCharacter, String>(c.getPlayer(), line));
                            log.warn("{} 使用命令: {}", c.getPlayer().getName(), line);
                        }
                        try {
                            definitionCommandPair.getCommand().execute(c, mc, splitted);
                        } catch (Exception e) {
                            System.err.println("【警告】：出现错误命令！！为了服务器的稳定，请进入游戏检查！");
                        }
                        return true;
                    }
                }
        }
        return false;
    }
}
class DefinitionCommandPair {
    private Command command;
    private CommandDefinition definition;
    public DefinitionCommandPair(Command command, CommandDefinition definition) {
        super();
        this.command = command;
        this.definition = definition;
    }
    public Command getCommand() {
        return command;
    }
    public CommandDefinition getDefinition() {
        return definition;
    }
}

						