PlayerNPC patch + Wedding ring effects + Bypassable PIN/PIC + SP cap

Fixed an issue with delayed item pickups. Fixed ClearSlot command not removing rechargeables from inventory. Fixed Resurrection and Hyper Body animation effect not working for other players. Implemented bypassable PIN/PIC, applied on accounts after a successful authentication, remaining active while activity is detected for that account. Fixed anti-multiclient system not properly registering players logged in via all-chars-view. Fixed cases where players still could gain EXP from much higher-leveled mobs if they were on an event instance. Optimized scroll result method performance. Added a server flag for SP cap limit on the player's current job (missing amount are reobtained after changing jobs). PlayerNPCs now have overridable scripts. Fixed some mapobject issues with PlayerNPCs, potencially leading to disappearing from maps in certain circumstances. Fixed SpawnAllPnpcs command not properly spawning all PlayersNPCs. Added extra info on Abdula, now stating whether a book can be obtained from questline or not. Fixed marriage ring effects. Fixed some cases where marriage rings were being able to be sent out from the character owner. Fixed Duey allowing send untradeable items. New tool: MapleWorldmapChecker. It reads Map.wz XMLs, fetching mapids not properly referenced on the worldmap nodes.
2018-10-25 07:09:35 -03:00
parent 17d3ffe1c3
commit 8f8cd815aa
87 changed files with 2040 additions and 271 deletions
@@ -379,13 +379,16 @@ public class CashShop {
    }

    public Item findByCashId(int cashId) {
-        boolean isRing = false;
+        boolean isRing;
        Equip equip = null;
        for (Item item : getInventory()) {
            if (item.getInventoryType().equals(MapleInventoryType.EQUIP)) {
                equip = (Equip) item;
                isRing = equip.getRingId() > -1;
+            } else {
+                isRing = false;
            }
+            
            if ((item.getPetId() > -1 ? item.getPetId() : isRing ? equip.getRingId() : item.getCashId()) == cashId) {
                return item;
            }
@@ -641,21 +641,12 @@ public class MapleItemInformationProvider {
        return type[cat - 30];
    }

-    private static double testYourLuck() {
-        double result = 100.0, rolled;
-        int i, j = ServerConstants.SCROLL_CHANCE_RATE;
-        
-        if(j < 1) j = 1;
-        for(i = 0; i < j; i++) {
-            rolled = Math.ceil(Math.random() * 100.0);
-            if(result > rolled) result = rolled;
-        }
-        
-        return(result);
+    private static double testYourLuck(double prop, int dices) {   // revamped testYourLuck author: David A.
+        return Math.pow(1.0 - prop, dices);
    }
    
    public static boolean rollSuccessChance(double prop) {
-        return(testYourLuck() <= prop && prop > 0.0);
+        return Math.random() > testYourLuck(prop / 100.0, ServerConstants.SCROLL_CHANCE_RATE);
    }
    
    private static short getMaximumShortMaxIfOverflow(int value1, int value2) {
@@ -0,0 +1,358 @@
+/*
+    This file is part of the HeavenMS MapleStory Server
+    Copyleft (L) 2016 - 2018 RonanLana
+
+    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 server;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import tools.DatabaseConnection;
+
+/**
+ *
+ * @author RonanLana
+ */
+public class MapleSkillbookInformationProvider {
+    private final static MapleSkillbookInformationProvider instance = new MapleSkillbookInformationProvider();
+    
+    public static MapleSkillbookInformationProvider getInstance() {
+        return instance;
+    }
+    
+    protected static Map<Integer, SkillBookEntry> foundSkillbooks = new HashMap<>();
+    
+    public enum SkillBookEntry {
+        UNAVAILABLE,
+        QUEST,
+        REACTOR,
+        SCRIPT
+    }
+    
+    static String host = "jdbc:mysql://localhost:3306/heavenms";
+    static String driver = "com.mysql.jdbc.Driver";
+    static String username = "root";
+    static String password = "";
+
+    static String wzPath = "wz";
+    static String rootDirectory = ".";
+    
+    static InputStreamReader fileReader = null;
+    static BufferedReader bufferedReader = null;
+    
+    static int initialStringLength = 50;
+    
+    static int skillbookMinItemid = 2280000;
+    static int skillbookMaxItemid = 2300000;  // exclusively
+    
+    static byte status = 0;
+    static int questId = -1;
+    static int isCompleteState = 0;
+    
+    static int currentItemid = 0;
+    static int currentCount = 0;
+    
+    static {
+        loadSkillbooks();
+    }
+
+    private static String getName(String token) {
+        int i, j;
+        char[] dest;
+        String d;
+        
+        i = token.lastIndexOf("name");
+        i = token.indexOf("\"", i) + 1; //lower bound of the string
+        j = token.indexOf("\"", i);     //upper bound
+
+        if(j < i) {           //node value containing 'name' in it's scope, cheap fix since we don't deal with strings anyway
+            System.out.println("[CRITICAL] Found this '" + token + "'");
+            return "0";
+        }
+        
+        dest = new char[initialStringLength];
+        token.getChars(i, j, dest, 0);
+
+        d = new String(dest);
+        return(d.trim());
+    }
+    
+    private static String getValue(String token) {
+        int i, j;
+        char[] dest;
+        String d;
+
+        i = token.lastIndexOf("value");
+        i = token.indexOf("\"", i) + 1; //lower bound of the string
+        j = token.indexOf("\"", i);     //upper bound
+
+        dest = new char[initialStringLength];
+        token.getChars(i, j, dest, 0);
+
+        d = new String(dest);
+        return(d.trim());
+    }
+    
+    private static void forwardCursor(int st) {
+        String line = null;
+
+        try {
+            while(status >= st && (line = bufferedReader.readLine()) != null) {
+                simpleToken(line);
+            }
+        }
+        catch(Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static void simpleToken(String token) {
+        if(token.contains("/imgdir")) {
+            status -= 1;
+        }
+        else if(token.contains("imgdir")) {
+            status += 1;
+        }
+    }
+    
+    private static void inspectQuestItemList(int st) {
+        String line = null;
+
+        try {
+            while(status >= st && (line = bufferedReader.readLine()) != null) {
+                readItemToken(line);
+            }
+        }
+        catch(Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static boolean isSkillBook(int itemid) {
+        return itemid >= skillbookMinItemid && itemid < skillbookMaxItemid;
+    }
+    
+    private static void processCurrentItem() {
+        try {
+            if(isSkillBook(currentItemid)) {
+                if(currentCount > 0) {
+                    foundSkillbooks.put(currentItemid, SkillBookEntry.QUEST);
+                }
+            }
+        } catch(Exception e) {}
+    }
+    
+    private static void readItemToken(String token) {
+        if(token.contains("/imgdir")) {
+            status -= 1;
+            
+            processCurrentItem();
+            
+            currentItemid = 0;
+            currentCount = 0;
+        }
+        else if(token.contains("imgdir")) {
+            status += 1;
+        }
+        else {
+            String d = getName(token);
+            
+            if(d.equals("id")) {
+                currentItemid = Integer.parseInt(getValue(token));
+            } else if(d.equals("count")) {
+                currentCount = Integer.parseInt(getValue(token));
+            }
+        }
+    }
+
+    private static void translateActToken(String token) {
+        String d;
+        int temp;
+
+        if(token.contains("/imgdir")) {
+            status -= 1;
+        }
+        else if(token.contains("imgdir")) {
+            if(status == 1) {           //getting QuestId
+                d = getName(token);
+                questId = Integer.parseInt(d);
+            }
+            else if(status == 2) {      //start/complete
+                d = getName(token);
+                isCompleteState = Integer.parseInt(d);
+            }
+            else if(status == 3) {
+                d = getName(token);
+
+                if(d.contains("item")) {
+                    temp = status;
+                    inspectQuestItemList(temp);
+                } else {
+                    forwardCursor(status);
+                }
+            }
+
+            status += 1;
+        }
+    }
+    
+    private static void fetchSkillbooksFromQuests() {
+        String line;
+        try {
+            fileReader = new InputStreamReader(new FileInputStream(wzPath + "/Quest.wz/Act.img.xml"), "UTF-8");
+            bufferedReader = new BufferedReader(fileReader);
+
+            while((line = bufferedReader.readLine()) != null) {
+                translateActToken(line);
+            }
+
+            bufferedReader.close();
+            fileReader.close();
+        } catch(IOException ioe) {
+            System.out.println("Failed to read Quest.wz file.");
+            ioe.printStackTrace();
+        }
+    }
+    
+    private static void fetchSkillbooksFromReactors() {
+        Connection con = null;
+        try {
+            con = DatabaseConnection.getConnection();
+            
+            PreparedStatement ps = con.prepareStatement("SELECT itemid FROM reactordrops WHERE itemid >= ? AND itemid < ?;");
+            ps.setInt(1, skillbookMinItemid);
+            ps.setInt(2, skillbookMaxItemid);
+            ResultSet rs = ps.executeQuery();
+
+            if (rs.isBeforeFirst()) {
+                while(rs.next()) {
+                    foundSkillbooks.put(rs.getInt("itemid"), SkillBookEntry.REACTOR);
+                }
+            }
+
+            rs.close();
+            ps.close();
+            
+            con.close();
+        } catch (SQLException sqle) {
+            sqle.printStackTrace();
+        }
+    }
+    
+    private static void listFiles(String directoryName, ArrayList<File> files) {
+        File directory = new File(directoryName);
+
+        // get all the files from a directory
+        File[] fList = directory.listFiles();
+        for (File file : fList) {
+            if (file.isFile()) {
+                files.add(file);
+            } else if (file.isDirectory()) {
+                listFiles(file.getAbsolutePath(), files);
+            }
+        }
+    }
+    
+    private static List<File> listFilesFromDirectoryRecursively(String directory) {
+        ArrayList<File> files = new ArrayList<>();
+        listFiles(directory, files);
+        
+        return files;
+    }
+    
+    private static void filterScriptDirectorySearchMatchingData(String path) {
+        for (File file : listFilesFromDirectoryRecursively(rootDirectory + "/" + path)) {
+            if (file.getName().endsWith(".js")) {
+                fileSearchMatchingData(file);
+            }
+        }
+    }
+    
+    private static Set<Integer> foundMatchingDataOnFile(String fileContent) {
+        Set<Integer> matches = new HashSet<>(4);
+        
+        Matcher searchM = Pattern.compile("22(8|9)[0-9]{4}").matcher(fileContent);
+        int idx = 0;
+        while (searchM.find(idx)) {
+            idx = searchM.end();
+            matches.add(Integer.valueOf(fileContent.substring(searchM.start(), idx)));
+        }
+        
+        return matches;
+    }
+    
+    static String readFileToString(File file, String encoding) throws IOException {
+        Scanner scanner = new Scanner(file, encoding);
+        String text = "";
+        try {
+            try {
+                text = scanner.useDelimiter("\\A").next();
+            } finally {
+                scanner.close();
+            }
+        } catch (NoSuchElementException e) {}
+        
+        return text;
+    }
+    
+    private static void fileSearchMatchingData(File file) {
+        try {
+            String fileContent = readFileToString(file, "UTF-8");
+            
+            Set<Integer> books = foundMatchingDataOnFile(fileContent);
+            for (Integer i : books) {
+                foundSkillbooks.put(i, SkillBookEntry.SCRIPT);
+            }
+        } catch (IOException ioe) {
+            System.out.println("Failed to read " + file.getName() + ".");
+            ioe.printStackTrace();
+        }
+    }
+    
+    private static void fetchSkillbooksFromScripts() {
+        filterScriptDirectorySearchMatchingData("scripts");
+    }
+    
+    private static void loadSkillbooks() {
+        fetchSkillbooksFromQuests();
+        fetchSkillbooksFromReactors();
+        fetchSkillbooksFromScripts();
+    }
+    
+    public SkillBookEntry getSkillbookAvailability(int itemid) {
+        SkillBookEntry sbe = foundSkillbooks.get(itemid);
+        return sbe != null ? sbe : SkillBookEntry.UNAVAILABLE;
+    }
+    
+}
@@ -753,10 +753,7 @@ public class MapleStatEffect {
        } else {
            if (isResurrection()) {
                hpchange = applyto.getCurrentMaxHp();
-                applyto.setStance(0);
-                
-                applyto.getMap().broadcastMessage(applyto, MaplePacketCreator.removePlayerFromMap(applyto.getId()), false);
-                applyto.getMap().broadcastMessage(applyto, MaplePacketCreator.spawnPlayerMapObject(applyto), false);
+                applyto.broadcastStance(applyto.isFacingLeft() ? 5 : 4);
            }
        }
        
@@ -895,9 +892,6 @@ public class MapleStatEffect {
            applyfrom.getMap().spawnMist(mist, getDuration(), mist.isPoisonMist(), false, mist.isRecoveryMist());
        } else if(isTimeLeap()) {
            applyto.removeAllCooldownsExcept(Buccaneer.TIME_LEAP, true);
-        } else if(isHyperBody() && !primary) {
-            applyto.getMap().broadcastMessage(applyto, MaplePacketCreator.removePlayerFromMap(applyto.getId()), false);
-            applyto.getMap().broadcastMessage(applyto, MaplePacketCreator.spawnPlayerMapObject(applyto), false);
        }
        
        return true;
@@ -445,8 +445,14 @@ public class MapleMonster extends AbstractLoadedMapleLife {
    }

    private int calcThresholdLevel(boolean isPqMob) {
-        if(isPqMob || !ServerConstants.USE_ENFORCE_MOB_LEVEL_RANGE) {
+        if(!ServerConstants.USE_ENFORCE_MOB_LEVEL_RANGE) {
            return 0;
+        } else if (isPqMob) {
+            double thresholdLevel = getLevel();
+            thresholdLevel /= 32.55916838;
+            thresholdLevel = Math.log(thresholdLevel) / 0.02058204546;
+            
+            return (int) Math.ceil(thresholdLevel);
        } else {
            return getLevel() - (!isBoss() ? ServerConstants.MIN_UNDERLEVEL_TO_EXP_GAIN : 2 * ServerConstants.MIN_UNDERLEVEL_TO_EXP_GAIN);
        }
@@ -613,7 +613,14 @@ public class MaplePlayerNPC extends AbstractMapleMapObject {
    
    public static void multicastSpawnPlayerNPC(int mapid, int world) {
        World wserv = Server.getInstance().getWorld(world);
-        for(MapleCharacter mc : wserv.getAllCharactersView()) {
+        if (wserv == null) return;
+        
+        MapleClient c = new MapleClient(null, null, null);  // mock client
+        c.setWorld(world);
+        c.setChannel(1);
+        
+        for(MapleCharacter mc : wserv.loadAndGetAllCharactersView()) {
+            mc.setClient(c);
            spawnPlayerNPC(mapid, mc);
        }
    }
@@ -630,14 +637,12 @@ public class MaplePlayerNPC extends AbstractMapleMapObject {
                int world = rs.getInt("world"), map = rs.getInt("map");
                if(world >= wsize) continue;
                
-                World w = Server.getInstance().getWorld(world);
-                for (Channel channel : w.getChannels()) {
+                for (Channel channel : Server.getInstance().getChannelsFromWorld(world)) {
                    MapleMap m = channel.getMapFactory().getMap(map);
                    
                    for(MapleMapObject pnpcObj : m.getMapObjectsInRange(new Point(0, 0), Double.POSITIVE_INFINITY, Arrays.asList(MapleMapObjectType.PLAYER_NPC))) {
                        MaplePlayerNPC pn = (MaplePlayerNPC) pnpcObj;
-
-                        m.removeMapObject(pn);
+                        m.removeMapObject(pnpcObj);
                        m.broadcastMessage(MaplePacketCreator.removeNPCController(pn.getObjectId()));
                        m.broadcastMessage(MaplePacketCreator.removePlayerNPC(pn.getObjectId()));
                    }
@@ -427,8 +427,9 @@ public class MapleMap {
        try {
            Integer curOid;
            
+            // clashes with playernpc on curOid >= 2147000000, developernpc uses >= 2147483000
            do {
-                if ((curOid = runningOid.incrementAndGet()) < 0) {  // clashes with playernpc on curOid >= 2147000000, developernpc uses >= 2147483000
+                if ((curOid = runningOid.incrementAndGet()) >= 2147000000) {
                    runningOid.set(curOid = 1000000001);
                }
            } while (mapobjects.containsKey(curOid));
@@ -1610,9 +1611,6 @@ public class MapleMap {
    }
    
    public boolean containsNPC(int npcid) {
-        if (npcid == 9000066) {
-            return true;
-        }
        objectRLock.lock();
        try {
            for (MapleMapObject obj : mapobjects.values()) {
@@ -2453,13 +2451,13 @@ public class MapleMap {
        chr.removeSandboxItems();
        
        if (chr.isHidden()) {
-            broadcastGMMessage(chr, MaplePacketCreator.spawnEnterPlayerMapObject(chr), false);
+            broadcastGMSpawnPlayerMapObjectMessage(chr, chr, true);
            chr.announce(MaplePacketCreator.getGMEffect(0x10, (byte) 1));

            List<Pair<MapleBuffStat, Integer>> dsstat = Collections.singletonList(new Pair<MapleBuffStat, Integer>(MapleBuffStat.DARKSIGHT, 0));
            broadcastGMMessage(chr, MaplePacketCreator.giveForeignBuff(chr.getId(), dsstat), false);
        } else {
-            broadcastMessage(chr, MaplePacketCreator.spawnEnterPlayerMapObject(chr), false);
+            broadcastSpawnPlayerMapObjectMessage(chr, chr, true);
        }

        sendObjectPlacement(chr.getClient());
@@ -2781,6 +2779,50 @@ public class MapleMap {
        }
    }
    
+    public void broadcastSpawnPlayerMapObjectMessage(MapleCharacter source, MapleCharacter player, boolean enteringField) {
+        broadcastSpawnPlayerMapObjectMessage(source, player, enteringField, false);
+    }
+            
+    public void broadcastGMSpawnPlayerMapObjectMessage(MapleCharacter source, MapleCharacter player, boolean enteringField) {
+        broadcastSpawnPlayerMapObjectMessage(source, player, enteringField, true);
+    }
+    
+    private void broadcastSpawnPlayerMapObjectMessage(MapleCharacter source, MapleCharacter player, boolean enteringField, boolean gmBroadcast) {
+        chrRLock.lock();
+        try {
+            if (gmBroadcast) {
+                for (MapleCharacter chr : characters) {
+                    if (chr.isGM()) {
+                        if (chr != source) {
+                            chr.announce(MaplePacketCreator.spawnPlayerMapObject(chr.getClient(), player, enteringField));
+                        }
+                    }
+                }
+            } else {
+                for (MapleCharacter chr : characters) {
+                    if (chr != source) {
+                        chr.announce(MaplePacketCreator.spawnPlayerMapObject(chr.getClient(), player, enteringField));
+                    }
+                }
+            }
+        } finally {
+            chrRLock.unlock();
+        }
+    }
+    
+    public void broadcastUpdateCharLookMessage(MapleCharacter source, MapleCharacter player) {
+        chrRLock.lock();
+        try {
+            for (MapleCharacter chr : characters) {
+                if (chr != source) {
+                    chr.announce(MaplePacketCreator.updateCharLook(chr.getClient(), player));
+                }
+            }
+        } finally {
+            chrRLock.unlock();
+        }
+    }
+    
    public void dropMessage(int type, String message) {
        broadcastStringMessage(type, message);
    }
@@ -71,6 +71,7 @@ public class MapleQuest {
    private boolean autoStart;
    private boolean autoPreComplete, autoComplete;
    private boolean repeatable = false;
+    private String name = "", parent = "";
    private final static MapleDataProvider questData = MapleDataProviderFactory.getDataProvider(new File(System.getProperty("wzpath") + "/Quest.wz"));
    private static MapleData questInfo;
    private static MapleData questAct;
@@ -87,6 +88,9 @@ public class MapleQuest {
        if(questInfo != null) {
            MapleData reqInfo = questInfo.getChildByPath(String.valueOf(id));
            if(reqInfo != null) {
+                name = MapleDataTool.getString("name", reqInfo, "");
+                parent = MapleDataTool.getString("parent", reqInfo, "");
+                
                timeLimit = MapleDataTool.getInt("timeLimit", reqInfo, 0);
                timeLimit2 = MapleDataTool.getInt("timeLimit2", reqInfo, 0);
                autoStart = MapleDataTool.getInt("autoStart", reqInfo, 0) == 1;
@@ -550,6 +554,27 @@ public class MapleQuest {
                }
        }
        
+        public String getName() {
+                return name;
+        }
+        
+        public String getParentName() {
+                return parent;
+        }
+        
+        public static List<MapleQuest> getMatchedQuests(String search) {
+                List<MapleQuest> ret = new LinkedList<>();
+                
+                search = search.toLowerCase();
+                for (MapleQuest mq : quests.values()) {
+                        if (mq.name.toLowerCase().contains(search) || mq.parent.toLowerCase().contains(search)) {
+                                ret.add(mq);
+                        }
+                }
+                
+                return ret;
+        }
+        
 	public static void loadAllQuest() {
 		questInfo = questData.getData("QuestInfo.img");
 		questReq = questData.getData("Check.img");