cleanup: replace anonymous inner class with lambda

src/main/java/client/MapleClient.java

@@ -807,12 +807,7 @@ public class MapleClient {
 
         public final void disconnect(final boolean shutdown, final boolean cashshop) {
                 if (canDisconnect()) {
-                        ThreadManager.getInstance().newTask(new Runnable() {
-                                @Override
-                                public void run() {
-                                        disconnectInternal(shutdown, cashshop);
-                                }
-                        });
+                        ThreadManager.getInstance().newTask(() -> disconnectInternal(shutdown, cashshop));
                 }
         }
         

src/main/java/client/command/commands/gm1/GotoCommand.java

@@ -65,13 +65,7 @@ public class GotoCommand extends Command {
     public static String GOTO_AREAS_INFO = "";
     
     private static void sortGotoEntries(List<Entry<String, Integer>> listEntries) {
-        Collections.sort(listEntries, new Comparator<Entry<String, Integer>>() {
-            @Override
-            public int compare(Entry<String, Integer> e1, Entry<String, Integer> e2)
-            {
-                return e1.getValue().compareTo(e2.getValue());
-            }
-        });
+        Collections.sort(listEntries, (e1, e2) -> e1.getValue().compareTo(e2.getValue()));
     }
 
     @Override

src/main/java/client/command/commands/gm2/IdCommand.java

@@ -38,34 +38,31 @@ public class IdCommand extends Command {
         }
         final String queryItem = joinStringArr(Arrays.copyOfRange(params, 1, params.length), " ");
         player.yellowMessage("Querying for entry... May take some time... Please try to refine your search.");
-        Runnable queryRunnable = new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    populateIdMap(params[0].toLowerCase());
+        Runnable queryRunnable = () -> {
+            try {
+                populateIdMap(params[0].toLowerCase());
 
-                    Map<String, String> resultList = fetchResults(itemMap.get(params[0]), queryItem);
-                    StringBuilder sb = new StringBuilder();
-                    
-                    if (resultList.size() > 0) {
-                        int count = 0;
-                        for (Map.Entry<String, String> entry: resultList.entrySet()) {
-                            sb.append(String.format("Id for %s is: #b%s#k", entry.getKey(), entry.getValue()) + "\r\n");
-                            if (++count > 100) {
-                                break;
-                            }
+                Map<String, String> resultList = fetchResults(itemMap.get(params[0]), queryItem);
+                StringBuilder sb = new StringBuilder();
+
+                if (resultList.size() > 0) {
+                    int count = 0;
+                    for (Map.Entry<String, String> entry: resultList.entrySet()) {
+                        sb.append(String.format("Id for %s is: #b%s#k", entry.getKey(), entry.getValue()) + "\r\n");
+                        if (++count > 100) {
+                            break;
                         }
-                        sb.append(String.format("Results found: #r%d#k | Returned: #b%d#k/100 | Refine search query to improve time.", resultList.size(), count) + "\r\n");
-                        
-                        player.getAbstractPlayerInteraction().npcTalk(9010000, sb.toString());
-                    } else {
-                        player.yellowMessage(String.format("Id not found for item: %s, of type: %s.", queryItem, params[0]));
                     }
-                } catch (IdTypeNotSupportedException e) {
-                    player.yellowMessage("Your query type is not supported.");
-                } catch (IOException e) {
-                    player.yellowMessage("Error reading file, please contact your administrator.");
+                    sb.append(String.format("Results found: #r%d#k | Returned: #b%d#k/100 | Refine search query to improve time.", resultList.size(), count) + "\r\n");
+
+                    player.getAbstractPlayerInteraction().npcTalk(9010000, sb.toString());
+                } else {
+                    player.yellowMessage(String.format("Id not found for item: %s, of type: %s.", queryItem, params[0]));
                 }
+            } catch (IdTypeNotSupportedException e) {
+                player.yellowMessage("Your query type is not supported.");
+            } catch (IOException e) {
+                player.yellowMessage("Error reading file, please contact your administrator.");
             }
         };
         

src/main/java/client/command/commands/gm3/BanCommand.java

@@ -75,12 +75,7 @@ public class BanCommand extends Command {
             target.yellowMessage("Reason: " + reason);
             c.announce(MaplePacketCreator.getGMEffect(4, (byte) 0));
             final MapleCharacter rip = target;
-            TimerManager.getInstance().schedule(new Runnable() {
-                @Override
-                public void run() {
-                    rip.getClient().disconnect(false, false);
-                }
-            }, 5000); //5 Seconds
+            TimerManager.getInstance().schedule(() -> rip.getClient().disconnect(false, false), 5000); //5 Seconds
             Server.getInstance().broadcastMessage(c.getWorld(), MaplePacketCreator.serverNotice(6, "[RIP]: " + ign + " has been banned."));
         } else if (MapleCharacter.ban(ign, reason, false)) {
             c.announce(MaplePacketCreator.getGMEffect(4, (byte) 0));

src/main/java/client/command/commands/gm6/ServerAddChannelCommand.java

@@ -45,23 +45,20 @@ public class ServerAddChannelCommand extends Command {
 
         final int worldid = Integer.parseInt(params[0]);
 
-        ThreadManager.getInstance().newTask(new Runnable() {
-            @Override
-            public void run() {
-                int chid = Server.getInstance().addChannel(worldid);
-                if(player.isLoggedinWorld()) {
-                    if(chid >= 0) {
-                        player.dropMessage(5, "NEW Channel " + chid + " successfully deployed on world " + worldid + ".");
+        ThreadManager.getInstance().newTask(() -> {
+            int chid = Server.getInstance().addChannel(worldid);
+            if(player.isLoggedinWorld()) {
+                if(chid >= 0) {
+                    player.dropMessage(5, "NEW Channel " + chid + " successfully deployed on world " + worldid + ".");
+                } else {
+                    if(chid == -3) {
+                        player.dropMessage(5, "Invalid worldid detected. Channel creation aborted.");
+                    } else if(chid == -2) {
+                        player.dropMessage(5, "Reached channel limit on worldid " + worldid + ". Channel creation aborted.");
+                    } else if(chid == -1) {
+                        player.dropMessage(5, "Error detected when loading the 'world.ini' file. Channel creation aborted.");
                     } else {
-                        if(chid == -3) {
-                            player.dropMessage(5, "Invalid worldid detected. Channel creation aborted.");
-                        } else if(chid == -2) {
-                            player.dropMessage(5, "Reached channel limit on worldid " + worldid + ". Channel creation aborted.");
-                        } else if(chid == -1) {
-                            player.dropMessage(5, "Error detected when loading the 'world.ini' file. Channel creation aborted.");
-                        } else {
-                            player.dropMessage(5, "NEW Channel failed to be deployed. Check if the needed port is already in use or other limitations are taking place.");
-                        }
+                        player.dropMessage(5, "NEW Channel failed to be deployed. Check if the needed port is already in use or other limitations are taking place.");
                     }
                 }
             }

src/main/java/client/command/commands/gm6/ServerAddWorldCommand.java

@@ -38,20 +38,17 @@ public class ServerAddWorldCommand extends Command {
     public void execute(MapleClient c, String[] params) {
         final MapleCharacter player = c.getPlayer();
         
-        ThreadManager.getInstance().newTask(new Runnable() {
-            @Override
-            public void run() {
-                int wid = Server.getInstance().addWorld();
+        ThreadManager.getInstance().newTask(() -> {
+            int wid = Server.getInstance().addWorld();
 
-                if(player.isLoggedinWorld()) {
-                    if(wid >= 0) {
-                        player.dropMessage(5, "NEW World " + wid + " successfully deployed.");
+            if(player.isLoggedinWorld()) {
+                if(wid >= 0) {
+                    player.dropMessage(5, "NEW World " + wid + " successfully deployed.");
+                } else {
+                    if(wid == -2) {
+                        player.dropMessage(5, "Error detected when loading the 'world.ini' file. World creation aborted.");
                     } else {
-                        if(wid == -2) {
-                            player.dropMessage(5, "Error detected when loading the 'world.ini' file. World creation aborted.");
-                        } else {
-                            player.dropMessage(5, "NEW World failed to be deployed. Check if needed ports are already in use or maximum world count has been reached.");
-                        }
+                        player.dropMessage(5, "NEW World failed to be deployed. Check if needed ports are already in use or maximum world count has been reached.");
                     }
                 }
             }

src/main/java/client/command/commands/gm6/ServerRemoveChannelCommand.java

@@ -44,17 +44,14 @@ public class ServerRemoveChannelCommand extends Command {
         }
 
         final int worldId = Integer.parseInt(params[0]);
-        ThreadManager.getInstance().newTask(new Runnable() {
-            @Override
-            public void run() {
-                if(Server.getInstance().removeChannel(worldId)) {
-                    if(player.isLoggedinWorld()) {
-                        player.dropMessage(5, "Successfully removed a channel on World " + worldId + ". Current channel count: " + Server.getInstance().getWorld(worldId).getChannelsSize() + ".");
-                    }
-                } else {
-                    if(player.isLoggedinWorld()) {
-                        player.dropMessage(5, "Failed to remove last Channel on world " + worldId + ". Check if either that world exists or there are people currently playing there.");
-                    }
+        ThreadManager.getInstance().newTask(() -> {
+            if(Server.getInstance().removeChannel(worldId)) {
+                if(player.isLoggedinWorld()) {
+                    player.dropMessage(5, "Successfully removed a channel on World " + worldId + ". Current channel count: " + Server.getInstance().getWorld(worldId).getChannelsSize() + ".");
+                }
+            } else {
+                if(player.isLoggedinWorld()) {
+                    player.dropMessage(5, "Failed to remove last Channel on world " + worldId + ". Check if either that world exists or there are people currently playing there.");
                 }
             }
         });

src/main/java/client/command/commands/gm6/ServerRemoveWorldCommand.java

@@ -44,20 +44,17 @@ public class ServerRemoveWorldCommand extends Command {
             return;
         }
 
-        ThreadManager.getInstance().newTask(new Runnable() {
-            @Override
-            public void run() {
-                if(Server.getInstance().removeWorld()) {
-                    if(player.isLoggedinWorld()) {
-                        player.dropMessage(5, "Successfully removed a world. Current world count: " + Server.getInstance().getWorldsSize() + ".");
-                    }
-                } else {
-                    if(player.isLoggedinWorld()) {
-                        if(rwid < 0) {
-                            player.dropMessage(5, "No registered worlds to remove.");
-                        } else {
-                            player.dropMessage(5, "Failed to remove world " + rwid + ". Check if there are people currently playing there.");
-                        }
+        ThreadManager.getInstance().newTask(() -> {
+            if(Server.getInstance().removeWorld()) {
+                if(player.isLoggedinWorld()) {
+                    player.dropMessage(5, "Successfully removed a world. Current world count: " + Server.getInstance().getWorldsSize() + ".");
+                }
+            } else {
+                if(player.isLoggedinWorld()) {
+                    if(rwid < 0) {
+                        player.dropMessage(5, "No registered worlds to remove.");
+                    } else {
+                        player.dropMessage(5, "Failed to remove world " + rwid + ". Check if there are people currently playing there.");
                     }
                 }
             }

src/main/java/client/inventory/MapleInventory.java

@@ -21,28 +21,20 @@
 */
 package client.inventory;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map.Entry;
-import java.util.Map;
-import java.util.concurrent.locks.Lock;
-import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
-
-import tools.Pair;
 import client.MapleCharacter;
 import client.MapleClient;
-import constants.inventory.ItemConstants;
-import server.MapleItemInformationProvider;
 import client.inventory.manipulator.MapleInventoryManipulator;
-import tools.FilePrinter;
+import constants.inventory.ItemConstants;
 import net.server.audit.locks.MonitoredLockType;
+import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
+import server.MapleItemInformationProvider;
 import server.ThreadManager;
+import tools.FilePrinter;
+import tools.Pair;
+
+import java.util.*;
+import java.util.Map.Entry;
+import java.util.concurrent.locks.Lock;
 
 /**
  *
@@ -196,12 +188,7 @@ public class MapleInventory implements Iterable<Item> {
         }
         
         if (ret.size() > 1) {
-            Collections.sort(ret, new Comparator<Item>() {
-                @Override
-                public int compare(Item i1, Item i2) {
-                    return i1.getPosition() - i2.getPosition();
-                }
-            });
+            Collections.sort(ret, (i1, i2) -> i1.getPosition() - i2.getPosition());
         }
         
         return ret;
@@ -216,12 +203,7 @@ public class MapleInventory implements Iterable<Item> {
         }
         
         if (ret.size() > 1) {
-            Collections.sort(ret, new Comparator<Item>() {
-                @Override
-                public int compare(Item i1, Item i2) {
-                    return i1.getPosition() - i2.getPosition();
-                }
-            });
+            Collections.sort(ret, (i1, i2) -> i1.getPosition() - i2.getPosition());
         }
         
         return ret;
@@ -334,12 +316,8 @@ public class MapleInventory implements Iterable<Item> {
         }
         
         if (ItemConstants.isRateCoupon(item.getItemId())) {
-            ThreadManager.getInstance().newTask(new Runnable() {    // deadlocks with coupons rates found thanks to GabrielSin & Masterrulax
-                @Override
-                public void run() {
-                    owner.updateCouponRates();
-                }
-            });
+            // deadlocks with coupons rates found thanks to GabrielSin & Masterrulax
+            ThreadManager.getInstance().newTask(() -> owner.updateCouponRates());
         }
 
         return slotId;
@@ -354,12 +332,7 @@ public class MapleInventory implements Iterable<Item> {
         }
         
         if (ItemConstants.isRateCoupon(item.getItemId())) {
-            ThreadManager.getInstance().newTask(new Runnable() {
-                @Override
-                public void run() {
-                    owner.updateCouponRates();
-                }
-            });
+            ThreadManager.getInstance().newTask(() -> owner.updateCouponRates());
         }
     }
     
@@ -373,12 +346,7 @@ public class MapleInventory implements Iterable<Item> {
         }
         
         if (item != null && ItemConstants.isRateCoupon(item.getItemId())) {
-            ThreadManager.getInstance().newTask(new Runnable() {
-                @Override
-                public void run() {
-                    owner.updateCouponRates();
-                }
-            });
+            ThreadManager.getInstance().newTask(() -> owner.updateCouponRates());
         }
     }
 

src/main/java/client/newyear/NewYearCardRecord.java

@@ -20,6 +20,10 @@
 package client.newyear;
 
 import client.MapleCharacter;
+import net.server.Server;
+import server.TimerManager;
+import tools.DatabaseConnection;
+import tools.MaplePacketCreator;
 
 import java.sql.Connection;
 import java.sql.PreparedStatement;
@@ -28,10 +32,6 @@ import java.sql.SQLException;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.concurrent.ScheduledFuture;
-import net.server.Server;
-import server.TimerManager;
-import tools.DatabaseConnection;
-import tools.MaplePacketCreator;
 
 /**
  *
@@ -244,23 +244,20 @@ public class NewYearCardRecord {
     public void startNewYearCardTask() {
         if(sendTask != null) return;
         
-        sendTask = TimerManager.getInstance().register(new Runnable() {
-            @Override
-            public void run() {
-                Server server = Server.getInstance();
-                
-                int world = server.getCharacterWorld(receiverId);
-                if(world == -1) {
-                    sendTask.cancel(false);
-                    sendTask = null;
-                    
-                    return;
-                }
-                
-                MapleCharacter target = server.getWorld(world).getPlayerStorage().getCharacterById(receiverId);
-                if(target != null && target.isLoggedinWorld()) {
-                    target.announce(MaplePacketCreator.onNewYearCardRes(target, NewYearCardRecord.this, 0xC, 0));
-                }
+        sendTask = TimerManager.getInstance().register(() -> {
+            Server server = Server.getInstance();
+
+            int world = server.getCharacterWorld(receiverId);
+            if(world == -1) {
+                sendTask.cancel(false);
+                sendTask = null;
+
+                return;
+            }
+
+            MapleCharacter target = server.getWorld(world).getPlayerStorage().getCharacterById(receiverId);
+            if(target != null && target.isLoggedinWorld()) {
+                target.announce(MaplePacketCreator.onNewYearCardRes(target, NewYearCardRecord.this, 0xC, 0));
             }
         }, 1000 * 60 * 60); //1 Hour
     }

src/main/java/net/MapleServerHandler.java

@@ -21,28 +21,19 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 package net;
 
-import java.io.IOException;
-import java.text.SimpleDateFormat;
-import java.util.Set;
-import java.util.HashSet;
-import java.util.Calendar;
-import java.util.concurrent.atomic.AtomicLong;
-
-import config.YamlConfig;
-import org.apache.mina.core.service.IoHandlerAdapter;
-import org.apache.mina.core.session.IdleStatus;
-import org.apache.mina.core.session.IoSession;
-
 import client.MapleClient;
+import config.YamlConfig;
 import constants.net.ServerConstants;
-import java.net.InetSocketAddress;
-
 import net.server.Server;
+import net.server.audit.LockCollector;
 import net.server.audit.locks.MonitoredLockType;
 import net.server.audit.locks.MonitoredReentrantLock;
 import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
 import net.server.coordinator.session.MapleSessionCoordinator;
-
+import org.apache.mina.core.service.IoHandlerAdapter;
+import org.apache.mina.core.session.IdleStatus;
+import org.apache.mina.core.session.IoSession;
+import server.TimerManager;
 import tools.FilePrinter;
 import tools.MapleAESOFB;
 import tools.MapleLogger;
@@ -50,15 +41,14 @@ import tools.MaplePacketCreator;
 import tools.data.input.ByteArrayByteStream;
 import tools.data.input.GenericSeekableLittleEndianAccessor;
 import tools.data.input.SeekableLittleEndianAccessor;
-import java.util.Arrays;
 
-import java.util.concurrent.ScheduledFuture;
-
-import java.util.HashMap;
-import java.util.Map;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.text.SimpleDateFormat;
+import java.util.*;
 import java.util.Map.Entry;
-import net.server.audit.LockCollector;
-import server.TimerManager;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.atomic.AtomicLong;
 
 public class MapleServerHandler extends IoHandlerAdapter {
     private final static Set<Short> ignoredDebugRecvPackets = new HashSet<>(Arrays.asList((short) 167, (short) 197, (short) 89, (short) 91, (short) 41, (short) 188, (short) 107));
@@ -274,12 +264,7 @@ public class MapleServerHandler extends IoHandlerAdapter {
     }
     
     private void idleManagerTask() {
-        this.idleManager = TimerManager.getInstance().register(new Runnable() {
-            @Override
-            public void run() {
-                manageIdleSessions();
-            }
-        }, 10000);
+        this.idleManager = TimerManager.getInstance().register(() -> manageIdleSessions(), 10000);
     }
     
     private void cancelIdleManagerTask() {
@@ -288,12 +273,7 @@ public class MapleServerHandler extends IoHandlerAdapter {
     }
     
     private void disposeLocks() {
-        LockCollector.getInstance().registerDisposeAction(new Runnable() {
-            @Override
-            public void run() {
-                emptyLocks();
-            }
-        });
+        LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
     }
 
     private void emptyLocks() {

src/main/java/net/server/Server.java

@@ -1856,21 +1856,11 @@ public class Server {
     }
 
     private void disconnectIdlesOnLoginTask() {
-        TimerManager.getInstance().register(new Runnable() {
-            @Override
-            public void run() {
-                disconnectIdlesOnLoginState();
-            }
-        }, 300000);
+        TimerManager.getInstance().register(() -> disconnectIdlesOnLoginState(), 300000);
     }
 
     public final Runnable shutdown(final boolean restart) {//no player should be online when trying to shutdown!
-        return new Runnable() {
-            @Override
-            public void run() {
-                shutdownInternal(restart);
-            }
-        };
+        return () -> shutdownInternal(restart);
     }
 
     private synchronized void shutdownInternal(boolean restart) {
@@ -1928,12 +1918,7 @@ public class Server {
         acceptor.unbind();
         acceptor = null;
         if (!restart) {  // shutdown hook deadlocks if System.exit() method is used within its body chores, thanks MIKE for pointing that out
-            new Thread(new Runnable() {
-                @Override
-                public void run() {
-                    System.exit(0);
-                }
-            }).start();
+            new Thread(() -> System.exit(0)).start();
         } else {
             System.out.println("\r\nRestarting the server....\r\n");
             try {

src/main/java/net/server/audit/ThreadTracker.java

@@ -19,26 +19,19 @@
 */
 package net.server.audit;
 
+import net.server.audit.locks.MonitoredLockType;
+import server.TimerManager;
+import tools.FilePrinter;
+
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.Map.Entry;
-import java.util.Set;
-import java.util.TimeZone;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 
-import net.server.audit.locks.MonitoredLockType;
-import server.TimerManager;
-import tools.FilePrinter;
-
 /**
  *
  * @author RonanLana
@@ -277,12 +270,7 @@ public class ThreadTracker {
     }
     
     public void registerThreadTrackerTask() {
-        threadTrackerSchedule = TimerManager.getInstance().register(new Runnable() {
-            @Override
-            public void run() {
-                accessThreadTracker(true, false, MonitoredLockType.UNDEFINED, -1);
-            }
-        }, 10000, 10000);
+        threadTrackerSchedule = TimerManager.getInstance().register(() -> accessThreadTracker(true, false, MonitoredLockType.UNDEFINED, -1), 10000, 10000);
     }
     
     public void cancelThreadTrackerTask() {

src/main/java/net/server/audit/locks/active/TrackerReadLock.java

@@ -20,24 +20,21 @@
 package net.server.audit.locks.active;
 
 import config.YamlConfig;
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.TimeZone;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.concurrent.ScheduledFuture;
-import server.TimerManager;
-
 import net.server.audit.ThreadTracker;
 import net.server.audit.locks.MonitoredLockType;
 import net.server.audit.locks.MonitoredReadLock;
 import net.server.audit.locks.MonitoredReentrantReadWriteLock;
 import net.server.audit.locks.empty.EmptyReadLock;
+import server.TimerManager;
 
-import tools.FilePrinter;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.TimeZone;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
 
 /**
  *
@@ -109,12 +106,7 @@ public class TrackerReadLock extends ReentrantReadWriteLock.ReadLock implements
         
             if(reentrantCount.incrementAndGet() == 1) {
                 final Thread t = Thread.currentThread();
-                timeoutSchedule = TimerManager.getInstance().schedule(new Runnable() {
-                    @Override
-                    public void run() {
-                        issueDeadlock(t);
-                    }
-                }, YamlConfig.config.server.LOCK_MONITOR_TIME);
+                timeoutSchedule = TimerManager.getInstance().schedule(() -> issueDeadlock(t), YamlConfig.config.server.LOCK_MONITOR_TIME);
             }
         } finally {
             state.unlock();

src/main/java/net/server/audit/locks/active/TrackerReentrantLock.java

@@ -19,22 +19,20 @@
 */
 package net.server.audit.locks.active;
 
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.concurrent.ScheduledFuture;
-
 import config.YamlConfig;
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.TimeZone;
-import server.TimerManager;
 import net.server.audit.ThreadTracker;
 import net.server.audit.locks.MonitoredLockType;
 import net.server.audit.locks.MonitoredReentrantLock;
 import net.server.audit.locks.empty.EmptyReentrantLock;
-import tools.FilePrinter;
+import server.TimerManager;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.TimeZone;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 /**
  *
@@ -112,12 +110,7 @@ public class TrackerReentrantLock extends ReentrantLock implements MonitoredReen
         
             if(reentrantCount.incrementAndGet() == 1) {
                 final Thread t = Thread.currentThread();
-                timeoutSchedule = TimerManager.getInstance().schedule(new Runnable() {
-                    @Override
-                    public void run() {
-                        issueDeadlock(t);
-                    }
-                }, YamlConfig.config.server.LOCK_MONITOR_TIME);
+                timeoutSchedule = TimerManager.getInstance().schedule(() -> issueDeadlock(t), YamlConfig.config.server.LOCK_MONITOR_TIME);
             }
         } finally {
             state.unlock();

src/main/java/net/server/audit/locks/active/TrackerWriteLock.java

@@ -20,22 +20,21 @@
 package net.server.audit.locks.active;
 
 import config.YamlConfig;
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.TimeZone;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.concurrent.ScheduledFuture;
-import server.TimerManager;
 import net.server.audit.ThreadTracker;
 import net.server.audit.locks.MonitoredLockType;
 import net.server.audit.locks.MonitoredReentrantReadWriteLock;
 import net.server.audit.locks.MonitoredWriteLock;
 import net.server.audit.locks.empty.EmptyWriteLock;
-import tools.FilePrinter;
+import server.TimerManager;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.TimeZone;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
 
 /**
  *
@@ -107,12 +106,7 @@ public class TrackerWriteLock extends ReentrantReadWriteLock.WriteLock implement
         
             if(reentrantCount.incrementAndGet() == 1) {
                 final Thread t = Thread.currentThread();
-                timeoutSchedule = TimerManager.getInstance().schedule(new Runnable() {
-                    @Override
-                    public void run() {
-                        issueDeadlock(t);
-                    }
-                }, YamlConfig.config.server.LOCK_MONITOR_TIME);
+                timeoutSchedule = TimerManager.getInstance().schedule(() -> issueDeadlock(t), YamlConfig.config.server.LOCK_MONITOR_TIME);
             }
         } finally {
             state.unlock();

src/main/java/net/server/channel/Channel.java

@@ -225,12 +225,7 @@ public final class Channel {
     }
     
     private void disposeLocks() {
-        LockCollector.getInstance().registerDisposeAction(new Runnable() {
-            @Override
-            public void run() {
-                emptyLocks();
-            }
-        });
+        LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
     }
     
     private void emptyLocks() {
@@ -606,29 +601,26 @@ public final class Channel {
             if (this.dojoTask[slot] != null) {
                 this.dojoTask[slot].cancel(false);
             }
-            this.dojoTask[slot] = TimerManager.getInstance().schedule(new Runnable() {
-                @Override
-                public void run() {
-                    final int delta = (dojoMapId) % 100;
-                    final int dojoBaseMap = (slot < 5) ? 925030000 : 925020000;
-                    MapleParty party = null;
+            this.dojoTask[slot] = TimerManager.getInstance().schedule(() -> {
+                final int delta = (dojoMapId) % 100;
+                final int dojoBaseMap = (slot < 5) ? 925030000 : 925020000;
+                MapleParty party = null;
 
-                    for (int i = 0; i < 5; i++) { //only 32 stages, but 38 maps
-                        if (stage + i > 38) {
-                            break;
-                        }
-
-                        MapleMap dojoExit = getMapFactory().getMap(925020002);
-                        for(MapleCharacter chr: getMapFactory().getMap(dojoBaseMap + (100 * (stage + i)) + delta).getAllPlayers()) {
-                            if(GameConstants.isDojo(chr.getMap().getId())) {
-                                chr.changeMap(dojoExit);
-                            }
-                            party = chr.getParty();
-                        }
+                for (int i = 0; i < 5; i++) { //only 32 stages, but 38 maps
+                    if (stage + i > 38) {
+                        break;
                     }
 
-                    freeDojoSlot(slot, party);
+                    MapleMap dojoExit = getMapFactory().getMap(925020002);
+                    for(MapleCharacter chr: getMapFactory().getMap(dojoBaseMap + (100 * (stage + i)) + delta).getAllPlayers()) {
+                        if(GameConstants.isDojo(chr.getMap().getId())) {
+                            chr.changeMap(dojoExit);
+                        }
+                        party = chr.getParty();
+                    }
                 }
+
+                freeDojoSlot(slot, party);
             }, clockTime + 3000);   // let the TIMES UP display for 3 seconds, then warp
         } finally {
             lock.unlock();
@@ -857,12 +849,7 @@ public final class Channel {
         
         ongoingStartTime = System.currentTimeMillis();
         if(weddingId != null) {
-            ScheduledFuture<?> weddingTask = TimerManager.getInstance().schedule(new Runnable() {
-                @Override
-                public void run() {
-                    closeOngoingWedding(cathedral);
-                }
-            }, YamlConfig.config.server.WEDDING_RESERVATION_TIMEOUT * 60 * 1000);
+            ScheduledFuture<?> weddingTask = TimerManager.getInstance().schedule(() -> closeOngoingWedding(cathedral), YamlConfig.config.server.WEDDING_RESERVATION_TIMEOUT * 60 * 1000);
             
             if(cathedral) {
                 cathedralReservationTask = weddingTask;

src/main/java/net/server/channel/handlers/AbstractDealDamageHandler.java

@@ -21,25 +21,19 @@
  */
 package net.server.channel.handlers;
 
-import java.awt.Point;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-
+import client.*;
+import client.autoban.AutobanFactory;
+import client.status.MonsterStatus;
+import client.status.MonsterStatusEffect;
 import config.YamlConfig;
+import constants.game.GameConstants;
+import constants.skills.*;
 import net.AbstractMaplePacketHandler;
+import net.server.PlayerBuffValueHolder;
+import scripting.AbstractPlayerInteraction;
 import server.MapleStatEffect;
 import server.TimerManager;
-import server.life.Element;
-import server.life.ElementalEffectiveness;
-import server.life.MapleMonster;
-import server.life.MapleMonsterInformationProvider;
-import server.life.MobSkill;
-import server.life.MobSkillFactory;
-import server.life.MonsterDropEntry;
+import server.life.*;
 import server.maps.MapleMap;
 import server.maps.MapleMapItem;
 import server.maps.MapleMapObject;
@@ -48,62 +42,10 @@ import tools.MaplePacketCreator;
 import tools.Pair;
 import tools.Randomizer;
 import tools.data.input.LittleEndianAccessor;
-import client.MapleBuffStat;
-import client.MapleCharacter;
-import client.MapleJob;
-import client.Skill;
-import client.SkillFactory;
-import client.autoban.AutobanFactory;
-import client.status.MonsterStatus;
-import client.status.MonsterStatusEffect;
-import constants.game.GameConstants;
-import constants.skills.Aran;
-import constants.skills.Assassin;
-import constants.skills.Bandit;
-import constants.skills.Beginner;
-import constants.skills.Bishop;
-import constants.skills.BlazeWizard;
-import constants.skills.Bowmaster;
-import constants.skills.Brawler;
-import constants.skills.Buccaneer;
-import constants.skills.ChiefBandit;
-import constants.skills.Cleric;
-import constants.skills.Corsair;
-import constants.skills.Crossbowman;
-import constants.skills.Crusader;
-import constants.skills.DawnWarrior;
-import constants.skills.DragonKnight;
-import constants.skills.Evan;
-import constants.skills.FPArchMage;
-import constants.skills.FPMage;
-import constants.skills.FPWizard;
-import constants.skills.Fighter;
-import constants.skills.Gunslinger;
-import constants.skills.Hermit;
-import constants.skills.Hero;
-import constants.skills.Hunter;
-import constants.skills.ILArchMage;
-import constants.skills.ILMage;
-import constants.skills.Legend;
-import constants.skills.Marauder;
-import constants.skills.Marksman;
-import constants.skills.NightLord;
-import constants.skills.NightWalker;
-import constants.skills.Noblesse;
-import constants.skills.Outlaw;
-import constants.skills.Page;
-import constants.skills.Paladin;
-import constants.skills.Ranger;
-import constants.skills.Rogue;
-import constants.skills.Shadower;
-import constants.skills.Sniper;
-import constants.skills.Spearman;
-import constants.skills.SuperGM;
-import constants.skills.ThunderBreaker;
-import constants.skills.WhiteKnight;
-import constants.skills.WindArcher;
-import net.server.PlayerBuffValueHolder;
-import scripting.AbstractPlayerInteraction;
+
+import java.awt.*;
+import java.util.List;
+import java.util.*;
 
 public abstract class AbstractDealDamageHandler extends AbstractMaplePacketHandler {
 
@@ -220,18 +162,15 @@ public abstract class AbstractDealDamageHandler extends AbstractMaplePacketHandl
                                 if (mapitem.isPickedUp()) {
                                     return;
                                 }
-                                TimerManager.getInstance().schedule(new Runnable() {
-                                    @Override
-                                    public void run() {
-                                        mapitem.lockItem();
-                                        try {
-                                            if (mapitem.isPickedUp()) {
-                                                return;
-                                            }
-                                            map.pickItemDrop(MaplePacketCreator.removeItemFromMap(mapitem.getObjectId(), 4, 0), mapitem);
-                                        } finally {
-                                            mapitem.unlockItem();
+                                TimerManager.getInstance().schedule(() -> {
+                                    mapitem.lockItem();
+                                    try {
+                                        if (mapitem.isPickedUp()) {
+                                            return;
                                         }
+                                        map.pickItemDrop(MaplePacketCreator.removeItemFromMap(mapitem.getObjectId(), 4, 0), mapitem);
+                                    } finally {
+                                        mapitem.unlockItem();
                                     }
                                 }, delay);
                                 delay += 100;
@@ -325,12 +264,7 @@ public abstract class AbstractDealDamageHandler extends AbstractMaplePacketHandl
                                     else
                                             eachdf = eachd;
 
-                                    TimerManager.getInstance().schedule(new Runnable() {
-                                        @Override
-                                        public void run() {
-                                            map.spawnMesoDrop(Math.min((int) Math.max(((double) eachdf / (double) 20000) * (double) maxmeso, (double) 1), maxmeso), new Point((int) (monster.getPosition().getX() + Randomizer.nextInt(100) - 50), (int) (monster.getPosition().getY())), monster, player, true, (byte) 2);
-                                        }
-                                    }, delay);
+                                    TimerManager.getInstance().schedule(() -> map.spawnMesoDrop(Math.min((int) Math.max(((double) eachdf / (double) 20000) * (double) maxmeso, (double) 1), maxmeso), new Point((int) (monster.getPosition().getX() + Randomizer.nextInt(100) - 50), (int) (monster.getPosition().getY())), monster, player, true, (byte) 2), delay);
                                     delay += 100;
                                 }
                             }
@@ -580,12 +514,9 @@ public abstract class AbstractDealDamageHandler extends AbstractMaplePacketHandl
         else animationTime = fixedTime;
         
         if(animationTime > 0) { // be sure to only use LIMITED ATTACKS with animation time here
-            TimerManager.getInstance().schedule(new Runnable() {
-                @Override
-                public void run() {
-                    map.broadcastMessage(MaplePacketCreator.damageMonster(monster.getObjectId(), damage), monster.getPosition());
-                    map.damageMonster(attacker, monster, damage);
-                }
+            TimerManager.getInstance().schedule(() -> {
+                map.broadcastMessage(MaplePacketCreator.damageMonster(monster.getObjectId(), damage), monster.getPosition());
+                map.damageMonster(attacker, monster, damage);
             }, animationTime);
         } else {
             map.broadcastMessage(MaplePacketCreator.damageMonster(monster.getObjectId(), damage), monster.getPosition());

src/main/java/net/server/channel/handlers/PlayerLoggedinHandler.java

@@ -451,12 +451,7 @@ public final class PlayerLoggedinHandler extends AbstractMaplePacketHandler {
             timedBuffs.add(new Pair<>(curtime - pb.usedTime, pb));
         }
         
-        Collections.sort(timedBuffs, new Comparator<Pair<Long, PlayerBuffValueHolder>>() {
-            @Override
-            public int compare(Pair<Long, PlayerBuffValueHolder> p1, Pair<Long, PlayerBuffValueHolder> p2) {
-                return p1.getLeft().compareTo(p2.getLeft());
-            }
-        });
+        Collections.sort(timedBuffs, (p1, p2) -> p1.getLeft().compareTo(p2.getLeft()));
         
         return timedBuffs;
     }

src/main/java/net/server/channel/handlers/UseCashItemHandler.java

@@ -21,49 +21,34 @@
  */
 package net.server.channel.handlers;
 
-import client.MapleCharacter;
-import client.MapleClient;
-import client.Skill;
-import client.SkillFactory;
-import client.SkillMacro;
+import client.*;
 import client.creator.veteran.*;
-import client.inventory.Equip;
+import client.inventory.*;
 import client.inventory.Equip.ScrollResult;
-import client.inventory.Item;
-import client.inventory.MapleInventory;
-import client.inventory.MapleInventoryType;
-import client.inventory.MaplePet;
-import client.inventory.ModifyInventory;
 import client.inventory.manipulator.MapleInventoryManipulator;
 import client.inventory.manipulator.MapleKarmaManipulator;
+import client.processor.npc.DueyProcessor;
 import client.processor.stat.AssignAPProcessor;
 import client.processor.stat.AssignSPProcessor;
-import client.processor.npc.DueyProcessor;
 import config.YamlConfig;
 import constants.game.GameConstants;
 import constants.inventory.ItemConstants;
-
-import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.List;
-
 import net.AbstractMaplePacketHandler;
 import net.server.Server;
 import server.MapleItemInformationProvider;
 import server.MapleShop;
 import server.MapleShopFactory;
 import server.TimerManager;
-import server.maps.AbstractMapleMapObject;
-import server.maps.FieldLimit;
-import server.maps.MaplePlayerShopItem;
-import server.maps.MapleKite;
-import server.maps.MapleMap;
-import server.maps.MapleTVEffect;
+import server.maps.*;
 import tools.MaplePacketCreator;
 import tools.Pair;
 import tools.data.input.SeekableLittleEndianAccessor;
 
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
 public final class UseCashItemHandler extends AbstractMaplePacketHandler {
 
     @Override
@@ -449,12 +434,7 @@ public final class UseCashItemHandler extends AbstractMaplePacketHandler {
             
             final int world = c.getWorld();
             Server.getInstance().broadcastMessage(world, MaplePacketCreator.getAvatarMega(player, medal, c.getChannel(), itemId, strLines, (slea.readByte() != 0)));
-            TimerManager.getInstance().schedule(new Runnable() {
-            	@Override
-            	public void run() {
-            		Server.getInstance().broadcastMessage(world, MaplePacketCreator.byeAvatarMega());
-            	}
-            }, 1000 * 10);
+            TimerManager.getInstance().schedule(() -> Server.getInstance().broadcastMessage(world, MaplePacketCreator.byeAvatarMega()), 1000 * 10);
             remove(c, position, itemId);
         } else if (itemType == 540) {
             slea.readByte();
@@ -597,26 +577,23 @@ public final class UseCashItemHandler extends AbstractMaplePacketHandler {
             remove(c, position, itemId);
             
             final MapleClient client = c;
-            TimerManager.getInstance().schedule(new Runnable() {
-            	@Override
-            	public void run() {
-                    if(!player.isLoggedin()) return;
-                    
-                    player.toggleBlockCashShop();
-                    
-                    final List<ModifyInventory> mods = new ArrayList<>();
-                    mods.add(new ModifyInventory(3, scrolled));
-                    mods.add(new ModifyInventory(0, scrolled));
-                    client.announce(MaplePacketCreator.modifyInventory(true, mods));
+            TimerManager.getInstance().schedule(() -> {
+if(!player.isLoggedin()) return;
 
-                    ScrollResult scrollResult = scrolled.getLevel() > curlevel ? ScrollResult.SUCCESS : ScrollResult.FAIL;
-                    player.getMap().broadcastMessage(MaplePacketCreator.getScrollEffect(player.getId(), scrollResult, false, false));
-                    if (eSlot < 0 && (scrollResult == ScrollResult.SUCCESS)) {
-                        player.equipChanged();
-                    }
+player.toggleBlockCashShop();
 
-                    client.announce(MaplePacketCreator.enableActions());
-            	}
+final List<ModifyInventory> mods = new ArrayList<>();
+mods.add(new ModifyInventory(3, scrolled));
+mods.add(new ModifyInventory(0, scrolled));
+client.announce(MaplePacketCreator.modifyInventory(true, mods));
+
+ScrollResult scrollResult = scrolled.getLevel() > curlevel ? ScrollResult.SUCCESS : ScrollResult.FAIL;
+player.getMap().broadcastMessage(MaplePacketCreator.getScrollEffect(player.getId(), scrollResult, false, false));
+if (eSlot < 0 && (scrollResult == ScrollResult.SUCCESS)) {
+player.equipChanged();
+}
+
+client.announce(MaplePacketCreator.enableActions());
             }, 1000 * 3);
         } else {
             System.out.println("NEW CASH ITEM: " + itemType + "\n" + slea.toString());

src/main/java/net/server/channel/handlers/UseOwlOfMinervaHandler.java

@@ -20,18 +20,17 @@
 package net.server.channel.handlers;
 
 import client.MapleClient;
+import constants.game.GameConstants;
 import net.AbstractMaplePacketHandler;
-import tools.data.input.SeekableLittleEndianAccessor;
 import tools.MaplePacketCreator;
 import tools.Pair;
+import tools.data.input.SeekableLittleEndianAccessor;
 
 import java.util.Comparator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.PriorityQueue;
 
-import constants.game.GameConstants;
-
 /**
  * @author Ronan
  */
@@ -48,12 +47,8 @@ public final class UseOwlOfMinervaHandler extends AbstractMaplePacketHandler {
                 owlLeaderboards.add(i);
             }
         } else {
-            Comparator<Pair<Integer, Integer>> comparator = new Comparator<Pair<Integer, Integer>>() {  // descending order
-                @Override
-                public int compare(Pair<Integer, Integer> p1, Pair<Integer, Integer> p2) {
-                    return p2.getRight().compareTo(p1.getRight());
-                }
-            };
+            // descending order
+            Comparator<Pair<Integer, Integer>> comparator = (p1, p2) -> p2.getRight().compareTo(p1.getRight());
             
             PriorityQueue<Pair<Integer, Integer>> queue = new PriorityQueue<>(Math.max(1, owlSearched.size()), comparator);
             for(Pair<Integer, Integer> p : owlSearched) {

src/main/java/net/server/coordinator/partysearch/PartySearchStorage.java

@@ -20,24 +20,16 @@
 package net.server.coordinator.partysearch;
 
 import client.MapleCharacter;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
 import net.server.audit.locks.MonitoredLockType;
 import net.server.audit.locks.MonitoredReadLock;
 import net.server.audit.locks.MonitoredReentrantReadWriteLock;
 import net.server.audit.locks.MonitoredWriteLock;
 import net.server.audit.locks.factory.MonitoredReadLockFactory;
 import net.server.audit.locks.factory.MonitoredWriteLockFactory;
-
 import tools.IntervalBuilder;
 
+import java.util.*;
+
 /**
  *
  * @author Ronan
@@ -90,13 +82,9 @@ public class PartySearchStorage {
             pscList.add(new PartySearchCharacter(chr));
         }
 
-        Collections.sort(pscList, new Comparator<PartySearchCharacter>() {
-            @Override
-            public int compare(PartySearchCharacter c1, PartySearchCharacter c2)
-            {
-                int levelP1 = c1.getLevel(), levelP2 = c2.getLevel();
-                return levelP1 > levelP2 ? 1 : (levelP1 == levelP2 ? 0 : -1);
-            }
+        Collections.sort(pscList, (c1, c2) -> {
+            int levelP1 = c1.getLevel(), levelP2 = c2.getLevel();
+            return levelP1 > levelP2 ? 1 : (levelP1 == levelP2 ? 0 : -1);
         });
         
         psWLock.lock();

src/main/java/net/server/coordinator/session/MapleSessionCoordinator.java

@@ -579,12 +579,7 @@ public class MapleSessionCoordinator {
     public void printSessionTrace() {
         if (!onlineClients.isEmpty()) {
             List<Entry<Integer, MapleClient>> elist = new ArrayList<>(onlineClients.entrySet());
-            Collections.sort(elist, new Comparator<Entry<Integer, MapleClient>>() {
-                @Override
-                public int compare(Entry<Integer, MapleClient> e1, Entry<Integer, MapleClient> e2) {
-                    return e1.getKey().compareTo(e2.getKey());
-                }
-            });
+            Collections.sort(elist, (e1, e2) -> e1.getKey().compareTo(e2.getKey()));
             
             System.out.println("Current online clients: ");
             for (Entry<Integer, MapleClient> e : elist) {
@@ -605,12 +600,7 @@ public class MapleSessionCoordinator {
         if (!loginRemoteHosts.isEmpty()) {
             List<Entry<String, Set<IoSession>>> elist = new ArrayList<>(loginRemoteHosts.entrySet());
             
-            Collections.sort(elist, new Comparator<Entry<String, Set<IoSession>>>() {
-                @Override
-                public int compare(Entry<String, Set<IoSession>> e1, Entry<String, Set<IoSession>> e2) {
-                    return e1.getKey().compareTo(e2.getKey());
-                }
-            });
+            Collections.sort(elist, (e1, e2) -> e1.getKey().compareTo(e2.getKey()));
             
             System.out.println("Current login sessions: ");
             for (Entry<String, Set<IoSession>> e : elist) {
@@ -624,12 +614,7 @@ public class MapleSessionCoordinator {
         
         if (!onlineClients.isEmpty()) {
             List<Entry<Integer, MapleClient>> elist = new ArrayList<>(onlineClients.entrySet());
-            Collections.sort(elist, new Comparator<Entry<Integer, MapleClient>>() {
-                @Override
-                public int compare(Entry<Integer, MapleClient> e1, Entry<Integer, MapleClient> e2) {
-                    return e1.getKey().compareTo(e2.getKey());
-                }
-            });
+            Collections.sort(elist, (e1, e2) -> e1.getKey().compareTo(e2.getKey()));
             
             str += ("Current online clients:\r\n");
             for (Entry<Integer, MapleClient> e : elist) {
@@ -650,12 +635,7 @@ public class MapleSessionCoordinator {
         if (!loginRemoteHosts.isEmpty()) {
             List<Entry<String, Set<IoSession>>> elist = new ArrayList<>(loginRemoteHosts.entrySet());
             
-            Collections.sort(elist, new Comparator<Entry<String, Set<IoSession>>>() {
-                @Override
-                public int compare(Entry<String, Set<IoSession>> e1, Entry<String, Set<IoSession>> e2) {
-                    return e1.getKey().compareTo(e2.getKey());
-                }
-            });
+            Collections.sort(elist, (e1, e2) -> e1.getKey().compareTo(e2.getKey()));
             
             str += ("Current login sessions:\r\n");
             for (Entry<String, Set<IoSession>> e : elist) {

src/main/java/net/server/coordinator/world/MapleMonsterAggroCoordinator.java

@@ -19,30 +19,22 @@
 */
 package net.server.coordinator.world;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-
-import config.YamlConfig;
 import client.MapleCharacter;
-import java.util.concurrent.ScheduledFuture;
+import config.YamlConfig;
 import net.server.Server;
 import net.server.audit.LockCollector;
-import server.life.MapleMonster;
-import server.maps.MapleMap;
 import net.server.audit.locks.MonitoredLockType;
 import net.server.audit.locks.MonitoredReentrantLock;
 import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
 import server.TimerManager;
+import server.life.MapleMonster;
+import server.maps.MapleMap;
 import tools.Pair;
 
+import java.util.*;
+import java.util.Map.Entry;
+import java.util.concurrent.ScheduledFuture;
+
 /**
  *
  * @author Ronan
@@ -95,12 +87,9 @@ public class MapleMonsterAggroCoordinator {
         try {
             if (aggroMonitor != null) return;
             
-            aggroMonitor = TimerManager.getInstance().register(new Runnable() {
-                @Override
-                public void run() {
-                    runAggroUpdate(1);
-                    runSortLeadingCharactersAggro();
-                }
+            aggroMonitor = TimerManager.getInstance().register(() -> {
+                runAggroUpdate(1);
+                runSortLeadingCharactersAggro();
             }, YamlConfig.config.server.MOB_STATUS_AGGRO_INTERVAL, YamlConfig.config.server.MOB_STATUS_AGGRO_INTERVAL);
         } finally {
             idleLock.unlock();
@@ -244,12 +233,8 @@ public class MapleMonsterAggroCoordinator {
                         }
 
                         if (!toRemoveIdx.isEmpty()) {
-                            Collections.sort(toRemoveIdx, new Comparator<Integer>() {   // last to first indexes
-                                @Override
-                                public int compare(Integer p1, Integer p2) {
-                                    return p1 < p2 ? 1 : p1.equals(p2) ? 0 : -1;
-                                }
-                            });
+                            // last to first indexes
+                            Collections.sort(toRemoveIdx, (p1, p2) -> p1 < p2 ? 1 : p1.equals(p2) ? 0 : -1);
 
                             for (int idx : toRemoveIdx) {
                                 sortedAggro.remove(idx);
@@ -387,12 +372,7 @@ public class MapleMonsterAggroCoordinator {
     }
     
     private void disposeLocks() {
-        LockCollector.getInstance().registerDisposeAction(new Runnable() {
-            @Override
-            public void run() {
-                emptyLocks();
-            }
-        });
+        LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
     }
     
     private void emptyLocks() {

src/main/java/net/server/services/BaseScheduler.java

@@ -20,14 +20,6 @@
 package net.server.services;
 
 import config.YamlConfig;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.concurrent.ScheduledFuture;
-
 import net.server.Server;
 import net.server.audit.LockCollector;
 import net.server.audit.locks.MonitoredLockType;
@@ -36,6 +28,10 @@ import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
 import server.TimerManager;
 import tools.Pair;
 
+import java.util.*;
+import java.util.Map.Entry;
+import java.util.concurrent.ScheduledFuture;
+
 /**
  *
  * @author Ronan
@@ -48,12 +44,7 @@ public abstract class BaseScheduler {
     
     private ScheduledFuture<?> schedulerTask = null;
     private MonitoredReentrantLock schedulerLock;
-    private Runnable monitorTask = new Runnable() {
-                                        @Override
-                                        public void run() {
-                                            runBaseSchedule();
-                                        }
-                                    };
+    private Runnable monitorTask = () -> runBaseSchedule();
     
     protected BaseScheduler(MonitoredLockType lockType) {
         schedulerLock = MonitoredReentrantLockFactory.createLock(lockType, true);
@@ -201,12 +192,7 @@ public abstract class BaseScheduler {
     }
     
     private void disposeLocks() {
-        LockCollector.getInstance().registerDisposeAction(new Runnable() {
-            @Override
-            public void run() {
-                emptyLocks();
-            }
-        });
+        LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
     }
     
     private void emptyLocks() {

src/main/java/net/server/services/task/channel/FaceExpressionService.java

@@ -19,18 +19,19 @@
 */
 package net.server.services.task.channel;
 
-import net.server.services.BaseService;
 import client.MapleCharacter;
 import config.YamlConfig;
-import java.util.Collections;
 import net.server.audit.LockCollector;
 import net.server.audit.locks.MonitoredLockType;
 import net.server.audit.locks.MonitoredReentrantLock;
 import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
 import net.server.services.BaseScheduler;
+import net.server.services.BaseService;
 import server.maps.MapleMap;
 import tools.MaplePacketCreator;
 
+import java.util.Collections;
+
 /**
  *
  * @author Ronan
@@ -54,12 +55,7 @@ public class FaceExpressionService extends BaseService {
     }
     
     private void disposeLocks() {
-        LockCollector.getInstance().registerDisposeAction(new Runnable() {
-            @Override
-            public void run() {
-                emptyLocks();
-            }
-        });
+        LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
     }
     
     @Override
@@ -77,12 +73,9 @@ public class FaceExpressionService extends BaseService {
     public void registerFaceExpression(final MapleMap map, final MapleCharacter chr, int emote) {
         int lockid = getChannelSchedulerIndex(map.getId());
         
-        Runnable cancelAction = new Runnable() {
-            @Override
-            public void run() {
-                if(chr.isLoggedinWorld()) {
-                    map.broadcastMessage(chr, MaplePacketCreator.facialExpression(chr, 0), false);
-                }
+        Runnable cancelAction = () -> {
+            if(chr.isLoggedinWorld()) {
+                map.broadcastMessage(chr, MaplePacketCreator.facialExpression(chr, 0), false);
             }
         };
         

src/main/java/net/server/services/task/channel/MobAnimationService.java

@@ -19,18 +19,16 @@
 */
 package net.server.services.task.channel;
 
-import net.server.services.BaseService;
 import config.YamlConfig;
-import net.server.audit.locks.MonitoredLockType;
-
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
 import net.server.audit.LockCollector;
+import net.server.audit.locks.MonitoredLockType;
 import net.server.audit.locks.MonitoredReentrantLock;
 import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
 import net.server.services.BaseScheduler;
-import net.server.services.SchedulerListener;
+import net.server.services.BaseService;
+
+import java.util.HashSet;
+import java.util.Set;
 
 /**
  *
@@ -59,11 +57,9 @@ public class MobAnimationService extends BaseService {
     public boolean registerMobOnAnimationEffect(int mapid, int mobHash, long delay) {
         return mobAnimationSchedulers[getChannelSchedulerIndex(mapid)].registerAnimationMode(mobHash, delay);
     }
-    
-    private static Runnable r = new Runnable() {
-        @Override
-        public void run() {}    // do nothing
-    };
+
+    // do nothing
+    private static Runnable r = () -> {};
     
     private class MobAnimationScheduler extends BaseScheduler {
         Set<Integer> onAnimationMobs = new HashSet<>(1000);
@@ -72,18 +68,15 @@ public class MobAnimationService extends BaseService {
         public MobAnimationScheduler() {
             super(MonitoredLockType.CHANNEL_MOBACTION);
 
-            super.addListener(new SchedulerListener() {
-                @Override
-                public void removedScheduledEntries(List<Object> toRemove, boolean update) {
-                    animationLock.lock();
-                    try {
-                        for(Object hashObj : toRemove) {
-                            Integer mobHash = (Integer) hashObj;
-                            onAnimationMobs.remove(mobHash);
-                        }
-                    } finally {
-                        animationLock.unlock();
+            super.addListener((toRemove, update) -> {
+                animationLock.lock();
+                try {
+                    for(Object hashObj : toRemove) {
+                        Integer mobHash = (Integer) hashObj;
+                        onAnimationMobs.remove(mobHash);
                     }
+                } finally {
+                    animationLock.unlock();
                 }
             });
         }
@@ -110,12 +103,7 @@ public class MobAnimationService extends BaseService {
         }
 
         private void disposeLocks() {
-            LockCollector.getInstance().registerDisposeAction(new Runnable() {
-                @Override
-                public void run() {
-                    emptyLocks();
-                }
-            });
+            LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
         }
 
         private void emptyLocks() {

src/main/java/net/server/services/task/channel/MobStatusService.java

@@ -19,19 +19,19 @@
 */
 package net.server.services.task.channel;
 
-import net.server.services.BaseService;
 import client.status.MonsterStatusEffect;
 import config.YamlConfig;
-import java.util.HashMap;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
 import net.server.audit.LockCollector;
 import net.server.audit.locks.MonitoredLockType;
 import net.server.audit.locks.MonitoredReentrantLock;
 import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
 import net.server.services.BaseScheduler;
-import net.server.services.SchedulerListener;
+import net.server.services.BaseService;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 /**
  *
@@ -97,32 +97,29 @@ public class MobStatusService extends BaseService {
         public MobStatusScheduler() {
             super(MonitoredLockType.CHANNEL_MOBSTATUS);
 
-            super.addListener(new SchedulerListener() {
-                @Override
-                public void removedScheduledEntries(List<Object> toRemove, boolean update) {
-                    List<Runnable> toRun = new ArrayList<>();
+            super.addListener((toRemove, update) -> {
+                List<Runnable> toRun = new ArrayList<>();
 
-                    overtimeStatusLock.lock();
-                    try {
-                        for(Object mseo : toRemove) {
-                            MonsterStatusEffect mse = (MonsterStatusEffect) mseo;
-                            registeredMobStatusOvertime.remove(mse);
-                        }
-
-                        if(update) {
-                            // it's probably ok to use one thread for both management & overtime actions
-                            List<MobStatusOvertimeEntry> mdoeList = new ArrayList<>(registeredMobStatusOvertime.values());
-                            for(MobStatusOvertimeEntry mdoe : mdoeList) {
-                                mdoe.update(toRun);
-                            }
-                        }
-                    } finally {
-                        overtimeStatusLock.unlock();
+                overtimeStatusLock.lock();
+                try {
+                    for(Object mseo : toRemove) {
+                        MonsterStatusEffect mse = (MonsterStatusEffect) mseo;
+                        registeredMobStatusOvertime.remove(mse);
                     }
 
-                    for(Runnable r : toRun) {
-                        r.run();
+                    if(update) {
+                        // it's probably ok to use one thread for both management & overtime actions
+                        List<MobStatusOvertimeEntry> mdoeList = new ArrayList<>(registeredMobStatusOvertime.values());
+                        for(MobStatusOvertimeEntry mdoe : mdoeList) {
+                            mdoe.update(toRun);
+                        }
                     }
+                } finally {
+                    overtimeStatusLock.unlock();
+                }
+
+                for(Runnable r : toRun) {
+                    r.run();
                 }
             });
         }
@@ -153,12 +150,7 @@ public class MobStatusService extends BaseService {
         }
 
         private void disposeLocks() {
-            LockCollector.getInstance().registerDisposeAction(new Runnable() {
-                @Override
-                public void run() {
-                    emptyLocks();
-                }
-            });
+            LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
         }
 
         private void emptyLocks() {

src/main/java/net/server/world/MapleParty.java

@@ -24,17 +24,9 @@ package net.server.world;
 import client.MapleCharacter;
 import client.MapleClient;
 import config.YamlConfig;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.HashMap;
-import java.util.Map.Entry;
-import java.util.Map;
-import java.util.Comparator;
 import net.server.audit.LockCollector;
-import net.server.audit.locks.MonitoredReentrantLock;
 import net.server.audit.locks.MonitoredLockType;
+import net.server.audit.locks.MonitoredReentrantLock;
 import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
 import net.server.coordinator.matchchecker.MapleMatchCheckerCoordinator;
 import net.server.coordinator.matchchecker.MatchCheckerListenerFactory.MatchCheckerType;
@@ -44,6 +36,9 @@ import server.maps.MapleMap;
 import server.partyquest.MonsterCarnival;
 import tools.MaplePacketCreator;
 
+import java.util.*;
+import java.util.Map.Entry;
+
 public class MapleParty {
 
     private int id;
@@ -216,12 +211,7 @@ public class MapleParty {
             lock.unlock();
         }
 
-        Collections.sort(histList, new Comparator<Entry<Integer, Integer>>() {
-            @Override
-            public int compare(Entry<Integer, Integer> o1, Entry<Integer, Integer> o2) {
-                return (o1.getValue()).compareTo(o2.getValue());
-            }
-        });
+        Collections.sort(histList, (o1, o2) -> (o1.getValue()).compareTo(o2.getValue()));
 
         List<Integer> histSort = new LinkedList<>();
         for (Entry<Integer, Integer> e : histList) {
@@ -292,12 +282,7 @@ public class MapleParty {
     }
 
     public void disposeLocks() {
-        LockCollector.getInstance().registerDisposeAction(new Runnable() {
-            @Override
-            public void run() {
-                emptyLocks();
-            }
-        });
+        LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
     }
 
     private void emptyLocks() {

src/main/java/net/server/world/World.java

@@ -461,12 +461,7 @@ public class World {
             list.add(e);
         }
         
-        Collections.sort(list, new Comparator<Entry<Integer, SortedMap<Integer, MapleCharacter>>>() {
-            @Override
-            public int compare(Entry<Integer, SortedMap<Integer, MapleCharacter>> o1, Entry<Integer, SortedMap<Integer, MapleCharacter>> o2) {
-                return o1.getKey() - o2.getKey();
-            }
-        });
+        Collections.sort(list, (o1, o2) -> o1.getKey() - o2.getKey());
         
         return list;
     }
@@ -1359,13 +1354,9 @@ public class World {
     
     private List<Integer> getMostSellerOnTab(List<Pair<Integer, Integer>> tabSellers) {
         List<Integer> tabLeaderboards;
-        
-        Comparator<Pair<Integer, Integer>> comparator = new Comparator<Pair<Integer, Integer>>() {  // descending order
-            @Override
-            public int compare(Pair<Integer, Integer> p1, Pair<Integer, Integer> p2) {
-                return p2.getRight().compareTo(p1.getRight());
-            }
-        };
+
+        // descending order
+        Comparator<Pair<Integer, Integer>> comparator = (p1, p2) -> p2.getRight().compareTo(p1.getRight());
 
         PriorityQueue<Pair<Integer, Integer>> queue = new PriorityQueue<>(Math.max(1, tabSellers.size()), comparator);
         for(Pair<Integer, Integer> p : tabSellers) {
@@ -1853,12 +1844,7 @@ public class World {
             }
         }
 
-        Collections.sort(hmsAvailable, new Comparator<Pair<MaplePlayerShopItem, AbstractMapleMapObject>>() {
-            @Override
-            public int compare(Pair<MaplePlayerShopItem, AbstractMapleMapObject> p1, Pair<MaplePlayerShopItem, AbstractMapleMapObject> p2) {
-                return p1.getLeft().getPrice() - p2.getLeft().getPrice();
-            }
-        });
+        Collections.sort(hmsAvailable, (p1, p2) -> p1.getLeft().getPrice() - p2.getLeft().getPrice());
 
         hmsAvailable.subList(0, Math.min(hmsAvailable.size(), 200));    //truncates the list to have up to 200 elements
         return hmsAvailable;
@@ -2049,12 +2035,7 @@ public class World {
     }
     
     private void disposeLocks() {
-        LockCollector.getInstance().registerDisposeAction(new Runnable() {
-            @Override
-            public void run() {
-                emptyLocks();
-            }
-        });
+        LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
     }
     
     private void emptyLocks() {

src/main/java/scripting/event/EventInstanceManager.java

@@ -21,56 +21,45 @@
  */
 package scripting.event;
 
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.Iterator;
-import java.util.Properties;
-import javax.script.ScriptException;
-
+import client.MapleCharacter;
+import client.Skill;
+import client.SkillFactory;
 import config.YamlConfig;
+import constants.inventory.ItemConstants;
+import constants.net.ServerConstants;
 import net.server.audit.LockCollector;
-import net.server.audit.locks.MonitoredLockType;
-import net.server.audit.locks.MonitoredReentrantLock;
-import net.server.audit.locks.MonitoredReadLock;
-import net.server.audit.locks.MonitoredReentrantReadWriteLock;
-import net.server.audit.locks.MonitoredWriteLock;
+import net.server.audit.locks.*;
 import net.server.audit.locks.factory.MonitoredReadLockFactory;
 import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
 import net.server.audit.locks.factory.MonitoredWriteLockFactory;
+import net.server.coordinator.world.MapleEventRecallCoordinator;
 import net.server.world.MapleParty;
 import net.server.world.MaplePartyCharacter;
-import server.maps.MaplePortal;
-import server.TimerManager;
-import server.MapleStatEffect;
-import server.expeditions.MapleExpedition;
-import server.life.MapleMonster;
-import server.maps.MapleMap;
-import server.maps.MapleMapManager;
-import server.maps.MapleReactor;
-import client.MapleCharacter;
-import client.SkillFactory;
-import client.Skill;
-import constants.inventory.ItemConstants;
-import constants.net.ServerConstants;
-import java.awt.Point;
-import java.util.concurrent.ScheduledFuture;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import net.server.coordinator.world.MapleEventRecallCoordinator;
 import scripting.AbstractPlayerInteraction;
 import scripting.event.scheduler.EventScriptScheduler;
 import server.MapleItemInformationProvider;
+import server.MapleStatEffect;
 import server.ThreadManager;
+import server.TimerManager;
+import server.expeditions.MapleExpedition;
 import server.life.MapleLifeFactory;
+import server.life.MapleMonster;
 import server.life.MapleNPC;
+import server.maps.MapleMap;
+import server.maps.MapleMapManager;
+import server.maps.MaplePortal;
+import server.maps.MapleReactor;
 import tools.MaplePacketCreator;
 import tools.Pair;
 
+import javax.script.ScriptException;
+import java.awt.*;
+import java.util.List;
+import java.util.*;
+import java.util.concurrent.ScheduledFuture;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
 /**
  *
  * @author Matze
@@ -297,16 +286,13 @@ public class EventInstanceManager {
                         chr.announce(MaplePacketCreator.getClock((int) (time / 1000)));
                 }
                 
-                event_schedule = TimerManager.getInstance().schedule(new Runnable() {
-                        @Override
-                        public void run() {
-                                dismissEventTimer();
-                                
-                                try {
-                                        invokeScriptFunction("scheduledTimeout", EventInstanceManager.this);
-                                } catch (ScriptException | NoSuchMethodException ex) {
-                                        Logger.getLogger(EventManager.class.getName()).log(Level.SEVERE, "Event '" + em.getName() + "' does not implement scheduledTimeout function.", ex);
-                                }
+                event_schedule = TimerManager.getInstance().schedule(() -> {
+                        dismissEventTimer();
+
+                        try {
+                                invokeScriptFunction("scheduledTimeout", EventInstanceManager.this);
+                        } catch (ScriptException | NoSuchMethodException ex) {
+                                Logger.getLogger(EventManager.class.getName()).log(Level.SEVERE, "Event '" + em.getName() + "' does not implement scheduledTimeout function.", ex);
                         }
                 }, time);
 	}
@@ -317,16 +303,13 @@ public class EventInstanceManager {
                                 long nextTime = getTimeLeft() + time;
                                 eventTime += time;
 
-                                event_schedule = TimerManager.getInstance().schedule(new Runnable() {
-                                        @Override
-                                        public void run() {
-                                                dismissEventTimer();
+                                event_schedule = TimerManager.getInstance().schedule(() -> {
+                                        dismissEventTimer();
 
-                                                try {
-                                                        invokeScriptFunction("scheduledTimeout", EventInstanceManager.this);
-                                                } catch (ScriptException | NoSuchMethodException ex) {
-                                                        Logger.getLogger(EventManager.class.getName()).log(Level.SEVERE, "Event '" + em.getName() + "' does not implement scheduledTimeout function.", ex);
-                                                }
+                                        try {
+                                                invokeScriptFunction("scheduledTimeout", EventInstanceManager.this);
+                                        } catch (ScriptException | NoSuchMethodException ex) {
+                                                Logger.getLogger(EventManager.class.getName()).log(Level.SEVERE, "Event '" + em.getName() + "' does not implement scheduledTimeout function.", ex);
                                         }
                                 }, nextTime);
                         }
@@ -539,13 +522,10 @@ public class EventInstanceManager {
 	}
 
 	public void playerKilled(final MapleCharacter chr) {
-                ThreadManager.getInstance().newTask(new Runnable() {
-                        @Override
-                        public void run() {
-                                try {
-                                        invokeScriptFunction("playerDead", EventInstanceManager.this, chr);
-                                } catch (ScriptException | NoSuchMethodException ex) {} // optional
-                        }
+                ThreadManager.getInstance().newTask(() -> {
+                        try {
+                                invokeScriptFunction("playerDead", EventInstanceManager.this, chr);
+                        } catch (ScriptException | NoSuchMethodException ex) {} // optional
                 });
 	}
 
@@ -660,30 +640,22 @@ public class EventInstanceManager {
                         sL.unlock();
                 }
                 
-                TimerManager.getInstance().schedule(new Runnable() {
-                        @Override
-                        public void run() {
-                                mapManager.dispose();   // issues from instantly disposing some event objects found thanks to MedicOP
-                                wL.lock();
-                                try {
-                                        mapManager = null;
-                                        em = null;
-                                } finally {
-                                        wL.unlock();
-                                }
-
-                                disposeLocks();
+                TimerManager.getInstance().schedule(() -> {
+                        mapManager.dispose();   // issues from instantly disposing some event objects found thanks to MedicOP
+                        wL.lock();
+                        try {
+                                mapManager = null;
+                                em = null;
+                        } finally {
+                                wL.unlock();
                         }
+
+                        disposeLocks();
                 }, 60 * 1000);
 	}
         
         private void disposeLocks() {
-            LockCollector.getInstance().registerDisposeAction(new Runnable() {
-                @Override
-                public void run() {
-                    emptyLocks();
-                }
-            });
+            LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
         }
         
         private void emptyLocks() {
@@ -699,14 +671,11 @@ public class EventInstanceManager {
                 rL.lock();
                 try {
                         if (ess != null) {
-                                Runnable r = new Runnable() {
-                                        @Override
-                                        public void run() {
-                                                try {
-                                                        invokeScriptFunction(methodName, EventInstanceManager.this);
-                                                } catch (ScriptException | NoSuchMethodException ex) {
-                                                        ex.printStackTrace();
-                                                }
+                                Runnable r = () -> {
+                                        try {
+                                                invokeScriptFunction(methodName, EventInstanceManager.this);
+                                        } catch (ScriptException | NoSuchMethodException ex) {
+                                                ex.printStackTrace();
                                         }
                                 };
 
@@ -1142,7 +1111,7 @@ public class EventInstanceManager {
                 
                 if(!eventCleared && leavingEventMap && !isEventTeamLeaderOn()) return true;
                 if(getPlayerCount() < minPlayers) return true;
-                
+
                 return false;
         }
         
@@ -1153,7 +1122,7 @@ public class EventInstanceManager {
                         // thanks Conrad for noticing expeditions don't need to have neither the leader nor meet the minimum requirement inside the event
                         if(getPlayerCount() <= 1) return true;
                 }
-                
+
                 return false;
         }
         
@@ -1164,7 +1133,7 @@ public class EventInstanceManager {
                         if(leavingEventMap && getLeaderId() == quitter.getId()) return true;
                         if(getPlayerCount() <= minPlayers) return true;
                 }
-                
+
                 return false;
         }
         

src/main/java/scripting/event/EventManager.java

@@ -21,50 +21,39 @@
 */
 package scripting.event;
 
+import client.MapleCharacter;
 import config.YamlConfig;
+import constants.game.GameConstants;
+import constants.net.ServerConstants;
+import jdk.nashorn.api.scripting.NashornScriptEngine;
 import jdk.nashorn.api.scripting.ScriptObjectMirror;
 import jdk.nashorn.api.scripting.ScriptUtils;
-import tools.exceptions.EventInstanceInProgressException;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Properties;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import javax.script.ScriptException;
-
-import constants.net.ServerConstants;
-import constants.game.GameConstants;
-import client.MapleCharacter;
 import net.server.Server;
-import net.server.world.World;
-import net.server.channel.Channel;
-import net.server.guild.MapleGuild;
-import net.server.world.MapleParty;
-import net.server.world.MaplePartyCharacter;
-import scripting.event.scheduler.EventScriptScheduler;
-import server.MapleMarriage;
-import server.expeditions.MapleExpedition;
-import server.maps.MapleMap;
-import server.life.MapleMonster;
-import server.life.MapleLifeFactory;
-import server.quest.MapleQuest;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Queue;
-import java.util.Set;
-import java.util.concurrent.Semaphore;
-import java.util.concurrent.TimeUnit;
-import jdk.nashorn.api.scripting.NashornScriptEngine;
 import net.server.audit.LockCollector;
 import net.server.audit.locks.MonitoredLockType;
 import net.server.audit.locks.MonitoredReentrantLock;
 import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
+import net.server.channel.Channel;
+import net.server.guild.MapleGuild;
+import net.server.world.MapleParty;
+import net.server.world.MaplePartyCharacter;
+import net.server.world.World;
+import scripting.event.scheduler.EventScriptScheduler;
+import server.MapleMarriage;
 import server.ThreadManager;
+import server.expeditions.MapleExpedition;
+import server.life.MapleLifeFactory;
+import server.life.MapleMonster;
+import server.maps.MapleMap;
+import server.quest.MapleQuest;
+import tools.exceptions.EventInstanceInProgressException;
+
+import javax.script.ScriptException;
+import java.util.*;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 //import jdk.nashorn.api.scripting.ScriptUtils;
 
 /**
@@ -154,12 +143,7 @@ public class EventManager {
     }
     
     private void disposeLocks() {
-        LockCollector.getInstance().registerDisposeAction(new Runnable() {
-            @Override
-            public void run() {
-                emptyLocks();
-            }
-        });
+        LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
     }
     
     private void emptyLocks() {
@@ -216,14 +200,11 @@ public class EventManager {
     }
 
     public EventScheduledFuture schedule(final String methodName, final EventInstanceManager eim, long delay) {
-        Runnable r = new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    iv.invokeFunction(methodName, eim);
-                } catch (ScriptException | NoSuchMethodException ex) {
-                    Logger.getLogger(EventManager.class.getName()).log(Level.SEVERE, null, ex);
-                }
+        Runnable r = () -> {
+            try {
+                iv.invokeFunction(methodName, eim);
+            } catch (ScriptException | NoSuchMethodException ex) {
+                Logger.getLogger(EventManager.class.getName()).log(Level.SEVERE, null, ex);
             }
         };
         
@@ -234,14 +215,11 @@ public class EventManager {
     }
 
     public EventScheduledFuture scheduleAtTimestamp(final String methodName, long timestamp) {
-        Runnable r = new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    iv.invokeFunction(methodName, (Object) null);
-                } catch (ScriptException | NoSuchMethodException ex) {
-                    Logger.getLogger(EventManager.class.getName()).log(Level.SEVERE, null, ex);
-                }
+        Runnable r = () -> {
+            try {
+                iv.invokeFunction(methodName, (Object) null);
+            } catch (ScriptException | NoSuchMethodException ex) {
+                Logger.getLogger(EventManager.class.getName()).log(Level.SEVERE, null, ex);
             }
         };
         
@@ -304,14 +282,11 @@ public class EventManager {
     }
 
     public void disposeInstance(final String name) {
-        ess.registerEntry(new Runnable() {
-            @Override
-            public void run() {
-                freeLobbyInstance(name);
-                
-                synchronized (instances) {
-                    instances.remove(name);
-                }
+        ess.registerEntry(() -> {
+            freeLobbyInstance(name);
+
+            synchronized (instances) {
+                instances.remove(name);
             }
         }, YamlConfig.config.server.EVENT_LOBBY_DELAY * 1000);
     }

src/main/java/scripting/event/scheduler/EventScriptScheduler.java

@@ -20,19 +20,20 @@
 package scripting.event.scheduler;
 
 import config.YamlConfig;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.concurrent.ScheduledFuture;
-import server.TimerManager;
 import net.server.Server;
 import net.server.audit.LockCollector;
 import net.server.audit.locks.MonitoredLockType;
 import net.server.audit.locks.MonitoredReentrantLock;
 import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
 import server.ThreadManager;
+import server.TimerManager;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.concurrent.ScheduledFuture;
 
 /**
  *
@@ -46,12 +47,7 @@ public class EventScriptScheduler {
 
     private ScheduledFuture<?> schedulerTask = null;
     private MonitoredReentrantLock schedulerLock;
-    private Runnable monitorTask = new Runnable() {
-        @Override
-        public void run() {
-            runBaseSchedule();
-        }
-    };
+    private Runnable monitorTask = () -> runBaseSchedule();
 
     public EventScriptScheduler() {
         schedulerLock = MonitoredReentrantLockFactory.createLock(MonitoredLockType.EM_SCHDL, true);
@@ -107,73 +103,59 @@ public class EventScriptScheduler {
 
     public void registerEntry(final Runnable scheduledAction, final long duration) {
 
-        ThreadManager.getInstance().newTask(new Runnable() {
-            @Override
-            public void run() {
-                schedulerLock.lock();
-                try {
-                    idleProcs = 0;
-                    if (schedulerTask == null) {
-                        if (disposed) {
-                            return;
-                        }
-
-                        schedulerTask = TimerManager.getInstance().register(monitorTask, YamlConfig.config.server.MOB_STATUS_MONITOR_PROC, YamlConfig.config.server.MOB_STATUS_MONITOR_PROC);
+        ThreadManager.getInstance().newTask(() -> {
+            schedulerLock.lock();
+            try {
+                idleProcs = 0;
+                if (schedulerTask == null) {
+                    if (disposed) {
+                        return;
                     }
 
-                    registeredEntries.put(scheduledAction, Server.getInstance().getCurrentTime() + duration);
-                } finally {
-                    schedulerLock.unlock();
+                    schedulerTask = TimerManager.getInstance().register(monitorTask, YamlConfig.config.server.MOB_STATUS_MONITOR_PROC, YamlConfig.config.server.MOB_STATUS_MONITOR_PROC);
                 }
+
+                registeredEntries.put(scheduledAction, Server.getInstance().getCurrentTime() + duration);
+            } finally {
+                schedulerLock.unlock();
             }
         });
     }
 
     public void cancelEntry(final Runnable scheduledAction) {
 
-        ThreadManager.getInstance().newTask(new Runnable() {
-            @Override
-            public void run() {
-                schedulerLock.lock();
-                try {
-                    registeredEntries.remove(scheduledAction);
-                } finally {
-                    schedulerLock.unlock();
-                }
+        ThreadManager.getInstance().newTask(() -> {
+            schedulerLock.lock();
+            try {
+                registeredEntries.remove(scheduledAction);
+            } finally {
+                schedulerLock.unlock();
             }
         });
     }
 
     public void dispose() {
 
-        ThreadManager.getInstance().newTask(new Runnable() {
-            @Override
-            public void run() {
-                schedulerLock.lock();
-                try {
-                    if (schedulerTask != null) {
-                        schedulerTask.cancel(false);
-                        schedulerTask = null;
-                    }
-
-                    registeredEntries.clear();
-                    disposed = true;
-                } finally {
-                    schedulerLock.unlock();
+        ThreadManager.getInstance().newTask(() -> {
+            schedulerLock.lock();
+            try {
+                if (schedulerTask != null) {
+                    schedulerTask.cancel(false);
+                    schedulerTask = null;
                 }
 
-                disposeLocks();
+                registeredEntries.clear();
+                disposed = true;
+            } finally {
+                schedulerLock.unlock();
             }
+
+            disposeLocks();
         });
     }
 
     private void disposeLocks() {
-        LockCollector.getInstance().registerDisposeAction(new Runnable() {
-            @Override
-            public void run() {
-                emptyLocks();
-            }
-        });
+        LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
     }
 
     private void emptyLocks() {

src/main/java/scripting/npc/NPCConversationManager.java

@@ -21,11 +21,17 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 package scripting.npc;
 
-import java.io.File;
-import java.sql.SQLException;
-
+import client.*;
+import client.inventory.Item;
+import client.inventory.ItemFactory;
+import client.inventory.MaplePet;
 import config.YamlConfig;
+import constants.game.GameConstants;
+import constants.inventory.ItemConstants;
+import constants.string.LanguageConstants;
 import net.server.Server;
+import net.server.channel.Channel;
+import net.server.coordinator.matchchecker.MatchCheckerListenerFactory.MatchCheckerType;
 import net.server.guild.MapleAlliance;
 import net.server.guild.MapleGuild;
 import net.server.world.MapleParty;
@@ -33,57 +39,33 @@ import net.server.world.MaplePartyCharacter;
 import provider.MapleData;
 import provider.MapleDataProviderFactory;
 import scripting.AbstractPlayerInteraction;
-import server.MapleItemInformationProvider;
-import server.MapleStatEffect;
-import server.MapleShop;
-import server.MapleShopFactory;
+import server.*;
+import server.MapleSkillbookInformationProvider.SkillBookEntry;
 import server.events.gm.MapleEvent;
+import server.expeditions.MapleExpedition;
+import server.expeditions.MapleExpeditionType;
 import server.gachapon.MapleGachapon;
 import server.gachapon.MapleGachapon.MapleGachaponItem;
+import server.life.MapleLifeFactory;
 import server.life.MaplePlayerNPC;
 import server.maps.MapleMap;
 import server.maps.MapleMapManager;
-import server.partyquest.Pyramid;
-import server.partyquest.Pyramid.PyramidMode;
-import tools.LogHelper;
-import tools.MaplePacketCreator;
-import client.MapleCharacter;
-import client.MapleClient;
-import client.MapleJob;
-import client.MapleSkinColor;
-import client.MapleStat;
-import client.Skill;
-import client.SkillFactory;
-import client.inventory.Item;
-import client.inventory.ItemFactory;
-import client.inventory.MaplePet;
-import constants.game.GameConstants;
-import constants.inventory.ItemConstants;
-import constants.string.LanguageConstants;
-import net.server.channel.Channel;
-import net.server.coordinator.matchchecker.MatchCheckerListenerFactory.MatchCheckerType;
-import server.MapleMarriage;
-import server.MapleSkillbookInformationProvider;
-import server.MapleSkillbookInformationProvider.SkillBookEntry;
-import server.TimerManager;
-import server.life.MapleLifeFactory;
 import server.maps.MapleMapObject;
 import server.maps.MapleMapObjectType;
-import server.expeditions.MapleExpedition;
-import server.expeditions.MapleExpeditionType;
 import server.partyquest.AriantColiseum;
 import server.partyquest.MonsterCarnival;
+import server.partyquest.Pyramid;
+import server.partyquest.Pyramid.PyramidMode;
+import tools.FilePrinter;
+import tools.LogHelper;
+import tools.MaplePacketCreator;
 import tools.packets.Wedding;
 
-import java.awt.Point;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
+import java.awt.*;
+import java.io.File;
+import java.sql.SQLException;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import tools.FilePrinter;
+import java.util.*;
 
 /**
  *
@@ -697,19 +679,9 @@ public class NPCConversationManager extends AbstractPlayerInteraction {
                         mc.changeMap(map, map.getPortal(0));
                         mc.announce(MaplePacketCreator.serverNotice(6, LanguageConstants.getMessage(mc, LanguageConstants.CPQEntryLobby)));
                         TimerManager tMan = TimerManager.getInstance();
-                        tMan.schedule(new Runnable() {
-                            @Override
-                            public void run() {
-                                mapClock(3 * 60);
-                            }
-                        }, 1500);
+                        tMan.schedule(() -> mapClock(3 * 60), 1500);
                         
-                        mc.setCpqTimer(TimerManager.getInstance().schedule(new Runnable() {
-                            @Override
-                            public void run() {
-                                mc.changeMap(mapExit, mapExit.getPortal(0));
-                            }
-                        }, 3 * 60 * 1000));
+                        mc.setCpqTimer(TimerManager.getInstance().schedule(() -> mc.changeMap(mapExit, mapExit.getPortal(0)), 3 * 60 * 1000));
                     }
                 }
             } catch (Exception ex) {
@@ -794,57 +766,44 @@ public class NPCConversationManager extends AbstractPlayerInteraction {
                         if (mc != null) {
                             mc.changeMap(lobbyMap, lobbyMap.getPortal(0));
                             TimerManager tMan = TimerManager.getInstance();
-                            tMan.schedule(new Runnable() {
-                                @Override
-                                public void run() {
-                                    mapClock(10);
-                                }
-                            }, 1500);
+                            tMan.schedule(() -> mapClock(10), 1500);
                         }
                     }
                     for (MaplePartyCharacter mpc : getPlayer().getParty().getMembers()) {
                         MapleCharacter mc = mpc.getPlayer();
                         if (mc != null) {
                             TimerManager tMan = TimerManager.getInstance();
-                            tMan.schedule(new Runnable() {
-                                @Override
-                                public void run() {
-                                    mapClock(10);
-                                }
-                            }, 1500);
+                            tMan.schedule(() -> mapClock(10), 1500);
                         }
                     }
                 }
                 final int mapid = c.getPlayer().getMapId() + 1;
                 TimerManager tMan = TimerManager.getInstance();
-                tMan.schedule(new Runnable() {
-                    @Override
-                    public void run() {
-                        try {
-                            for (MaplePartyCharacter mpc : getPlayer().getParty().getMembers()) {
-                                MapleCharacter mc = mpc.getPlayer();
-                                if (mc != null) {
-                                    mc.setMonsterCarnival(null);
-                                }
+                tMan.schedule(() -> {
+                    try {
+                        for (MaplePartyCharacter mpc : getPlayer().getParty().getMembers()) {
+                            MapleCharacter mc = mpc.getPlayer();
+                            if (mc != null) {
+                                mc.setMonsterCarnival(null);
                             }
-                            for (MaplePartyCharacter mpc : challenger.getParty().getMembers()) {
-                                MapleCharacter mc = mpc.getPlayer();
-                                if (mc != null) {
-                                    mc.setMonsterCarnival(null);
-                                }
+                        }
+                        for (MaplePartyCharacter mpc : challenger.getParty().getMembers()) {
+                            MapleCharacter mc = mpc.getPlayer();
+                            if (mc != null) {
+                                mc.setMonsterCarnival(null);
                             }
-                        } catch (NullPointerException npe) {
-                            warpoutCPQLobby(lobbyMap);
-                            return;
-                        }
-                        
-                        MapleParty lobbyParty = getPlayer().getParty(), challengerParty = challenger.getParty();
-                        int status = canStartCPQ(lobbyMap, lobbyParty, challengerParty);
-                        if (status == 0) {
-                            new MonsterCarnival(lobbyParty, challengerParty, mapid, true, (field / 100) % 10);
-                        } else {
-                            warpoutCPQLobby(lobbyMap);
                         }
+                    } catch (NullPointerException npe) {
+                        warpoutCPQLobby(lobbyMap);
+                        return;
+                    }
+
+                    MapleParty lobbyParty = getPlayer().getParty(), challengerParty = challenger.getParty();
+                    int status = canStartCPQ(lobbyMap, lobbyParty, challengerParty);
+                    if (status == 0) {
+                        new MonsterCarnival(lobbyParty, challengerParty, mapid, true, (field / 100) % 10);
+                    } else {
+                        warpoutCPQLobby(lobbyMap);
                     }
                 }, 11000);
             } catch (Exception e) {
@@ -872,34 +831,31 @@ public class NPCConversationManager extends AbstractPlayerInteraction {
                 }
                 final int mapid = c.getPlayer().getMapId() + 100;
                 TimerManager tMan = TimerManager.getInstance();
-                tMan.schedule(new Runnable() {
-                    @Override
-                    public void run() {
-                        try {
-                            for (MaplePartyCharacter mpc : getPlayer().getParty().getMembers()) {
-                                MapleCharacter mc = mpc.getPlayer();
-                                if (mc != null) {
-                                    mc.setMonsterCarnival(null);
-                                }
+                tMan.schedule(() -> {
+                    try {
+                        for (MaplePartyCharacter mpc : getPlayer().getParty().getMembers()) {
+                            MapleCharacter mc = mpc.getPlayer();
+                            if (mc != null) {
+                                mc.setMonsterCarnival(null);
                             }
-                            for (MaplePartyCharacter mpc : challenger.getParty().getMembers()) {
-                                MapleCharacter mc = mpc.getPlayer();
-                                if (mc != null) {
-                                    mc.setMonsterCarnival(null);
-                                }
+                        }
+                        for (MaplePartyCharacter mpc : challenger.getParty().getMembers()) {
+                            MapleCharacter mc = mpc.getPlayer();
+                            if (mc != null) {
+                                mc.setMonsterCarnival(null);
                             }
-                        } catch (NullPointerException npe) {
-                            warpoutCPQLobby(lobbyMap);
-                            return;
-                        }
-                        
-                        MapleParty lobbyParty = getPlayer().getParty(), challengerParty = challenger.getParty();
-                        int status = canStartCPQ(lobbyMap, lobbyParty, challengerParty);
-                        if (status == 0) {
-                            new MonsterCarnival(lobbyParty, challengerParty, mapid, false, (field / 1000) % 10);
-                        } else {
-                            warpoutCPQLobby(lobbyMap);
                         }
+                    } catch (NullPointerException npe) {
+                        warpoutCPQLobby(lobbyMap);
+                        return;
+                    }
+
+                    MapleParty lobbyParty = getPlayer().getParty(), challengerParty = challenger.getParty();
+                    int status = canStartCPQ(lobbyMap, lobbyParty, challengerParty);
+                    if (status == 0) {
+                        new MonsterCarnival(lobbyParty, challengerParty, mapid, false, (field / 1000) % 10);
+                    } else {
+                        warpoutCPQLobby(lobbyMap);
                     }
                 }, 10000);
             } catch (Exception e) {
@@ -972,19 +928,9 @@ public class NPCConversationManager extends AbstractPlayerInteraction {
                         mc.changeMap(map, map.getPortal(0));
                         mc.announce(MaplePacketCreator.serverNotice(6, LanguageConstants.getMessage(mc, LanguageConstants.CPQEntryLobby)));
                         TimerManager tMan = TimerManager.getInstance();
-                        tMan.schedule(new Runnable() {
-                            @Override
-                            public void run() {
-                                mapClock(3 * 60);
-                            }
-                        }, 1500);
+                        tMan.schedule(() -> mapClock(3 * 60), 1500);
                         
-                        mc.setCpqTimer(TimerManager.getInstance().schedule(new Runnable() {
-                            @Override
-                            public void run() {
-                                mc.changeMap(mapExit, mapExit.getPortal(0));
-                            }
-                        }, 3 * 60 * 1000));
+                        mc.setCpqTimer(TimerManager.getInstance().schedule(() -> mc.changeMap(mapExit, mapExit.getPortal(0)), 3 * 60 * 1000));
                     }
                 }
             } catch (Exception ex) {

src/main/java/scripting/reactor/ReactorActionManager.java

@@ -28,14 +28,6 @@ import client.inventory.Item;
 import client.inventory.MapleInventoryType;
 import config.YamlConfig;
 import constants.inventory.ItemConstants;
-import java.awt.Point;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.ScheduledFuture;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import javax.script.ScriptException;
 import jdk.nashorn.api.scripting.NashornScriptEngine;
 import scripting.AbstractPlayerInteraction;
 import scripting.event.EventInstanceManager;
@@ -52,6 +44,15 @@ import server.partyquest.MapleCarnivalFactory;
 import server.partyquest.MapleCarnivalFactory.MCSkill;
 import tools.MaplePacketCreator;
 
+import javax.script.ScriptException;
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ScheduledFuture;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
 /**
  * @author Lerk
  * @author Ronan
@@ -195,35 +196,32 @@ public class ReactorActionManager extends AbstractPlayerInteraction {
             
             dropPos.x -= (12 * items.size());
             
-            sprayTask = TimerManager.getInstance().register(new Runnable() {
-                @Override
-                public void run() {
-                    if(dropItems.isEmpty()) {
-                        sprayTask.cancel(false);
-                        return;
-                    }
-                    
-                    ReactorDropEntry d = dropItems.remove(0);
-                    if (d.itemId == 0) {
-                        int range = maxMeso - minMeso;
-                        int displayDrop = (int) (Math.random() * range) + minMeso;
-                        int mesoDrop = (displayDrop * worldMesoRate);
-                        r.getMap().spawnMesoDrop(mesoDrop, r.getMap().calcDropPos(dropPos, r.getPosition()), r, chr, false, (byte) 2);
-                    } else {
-                        Item drop;
-                        
-                        if (ItemConstants.getInventoryType(d.itemId) != MapleInventoryType.EQUIP) {
-                            drop = new Item(d.itemId, (short) 0, (short) 1);
-                        } else {
-                            MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
-                            drop = ii.randomizeStats((Equip) ii.getEquipById(d.itemId));
-                        }
-
-                        r.getMap().dropFromReactor(getPlayer(), r, drop, dropPos, (short) d.questid);
-                    }
-                    
-                    dropPos.x += 25;
+            sprayTask = TimerManager.getInstance().register(() -> {
+                if(dropItems.isEmpty()) {
+                    sprayTask.cancel(false);
+                    return;
                 }
+
+                ReactorDropEntry d = dropItems.remove(0);
+                if (d.itemId == 0) {
+                    int range = maxMeso - minMeso;
+                    int displayDrop = (int) (Math.random() * range) + minMeso;
+                    int mesoDrop = (displayDrop * worldMesoRate);
+                    r.getMap().spawnMesoDrop(mesoDrop, r.getMap().calcDropPos(dropPos, r.getPosition()), r, chr, false, (byte) 2);
+                } else {
+                    Item drop;
+
+                    if (ItemConstants.getInventoryType(d.itemId) != MapleInventoryType.EQUIP) {
+                        drop = new Item(d.itemId, (short) 0, (short) 1);
+                    } else {
+                        MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
+                        drop = ii.randomizeStats((Equip) ii.getEquipById(d.itemId));
+                    }
+
+                    r.getMap().dropFromReactor(getPlayer(), r, drop, dropPos, (short) d.questid);
+                }
+
+                dropPos.x += 25;
             }, 200);
         }
     }
@@ -319,27 +317,21 @@ public class ReactorActionManager extends AbstractPlayerInteraction {
     }
 
     public ScheduledFuture<?> schedule(final String methodName, final EventInstanceManager eim, long delay) {
-        return TimerManager.getInstance().schedule(new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    iv.invokeFunction(methodName, eim);
-                } catch (ScriptException | NoSuchMethodException ex) {
-                    Logger.getLogger(EventManager.class.getName()).log(Level.SEVERE, null, ex);
-                }
+        return TimerManager.getInstance().schedule(() -> {
+            try {
+                iv.invokeFunction(methodName, eim);
+            } catch (ScriptException | NoSuchMethodException ex) {
+                Logger.getLogger(EventManager.class.getName()).log(Level.SEVERE, null, ex);
             }
         }, delay);
     }
 
     public ScheduledFuture<?> scheduleAtTimestamp(final String methodName, long timestamp) {
-        return TimerManager.getInstance().scheduleAtTimestamp(new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    iv.invokeFunction(methodName, (Object) null);
-                } catch (ScriptException | NoSuchMethodException ex) {
-                    Logger.getLogger(EventManager.class.getName()).log(Level.SEVERE, null, ex);
-                }
+        return TimerManager.getInstance().scheduleAtTimestamp(() -> {
+            try {
+                iv.invokeFunction(methodName, (Object) null);
+            } catch (ScriptException | NoSuchMethodException ex) {
+                Logger.getLogger(EventManager.class.getName()).log(Level.SEVERE, null, ex);
             }
         }, timestamp);
     }

src/main/java/server/MapleStorage.java

@@ -233,16 +233,13 @@ public class MapleStorage {
         
         lock.lock();
         try {
-            Collections.sort(items, new Comparator<Item>() {
-                @Override
-                public int compare(Item o1, Item o2) {
-                    if (o1.getInventoryType().getType() < o2.getInventoryType().getType()) {
-                        return -1;
-                    } else if (o1.getInventoryType() == o2.getInventoryType()) {
-                        return 0;
-                    }
-                    return 1;
+            Collections.sort(items, (o1, o2) -> {
+                if (o1.getInventoryType().getType() < o2.getInventoryType().getType()) {
+                    return -1;
+                } else if (o1.getInventoryType() == o2.getInventoryType()) {
+                    return 0;
                 }
+                return 1;
             });
             
             List<Item> storageItems = getItems();

src/main/java/server/TimerManager.java

@@ -21,16 +21,17 @@
 */
 package server;
 
+import net.server.Server;
+import tools.FilePrinter;
+
+import javax.management.MBeanServer;
+import javax.management.ObjectName;
 import java.lang.management.ManagementFactory;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
-import net.server.Server;
-import javax.management.MBeanServer;
-import javax.management.ObjectName;
-import tools.FilePrinter;
 
 public class TimerManager implements TimerManagerMBean {
     private static TimerManager instance = new TimerManager();
@@ -79,12 +80,9 @@ public class TimerManager implements TimerManagerMBean {
     }
 	
     public Runnable purge() {//Yay?
-        return new Runnable() {
-            @Override
-            public void run() {
-                Server.getInstance().forceUpdateCurrentTime();
-                ses.purge();
-            }
+        return () -> {
+            Server.getInstance().forceUpdateCurrentTime();
+            ses.purge();
         };
     }
     

src/main/java/server/events/gm/MapleCoconut.java

@@ -23,13 +23,14 @@
 package server.events.gm;
 
 import client.MapleCharacter;
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.List;
 import server.TimerManager;
 import server.maps.MapleMap;
 import tools.MaplePacketCreator;
 
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
 /**
  *
  * @author kevintjuh93
@@ -58,35 +59,32 @@ public class MapleCoconut extends MapleEvent {
            setCoconutsHittable(true);
            map.broadcastMessage(MaplePacketCreator.getClock(300));
 
-        TimerManager.getInstance().schedule(new Runnable() {
-            @Override
-            public void run() {
-                if (map.getId() == 109080000) {
-                    if (getMapleScore() == getStoryScore()) {
-						bonusTime();
-                    } else if (getMapleScore() > getStoryScore()) {
-                        for (MapleCharacter chr : map.getCharacters()) {
-                            if (chr.getTeam() == 0) {
-                                chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/victory"));
-                                chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Victory"));
-                            } else {
-                                chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/lose"));
-                                chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Failed"));
-                            }
+        TimerManager.getInstance().schedule(() -> {
+            if (map.getId() == 109080000) {
+                if (getMapleScore() == getStoryScore()) {
+                    bonusTime();
+                } else if (getMapleScore() > getStoryScore()) {
+                    for (MapleCharacter chr : map.getCharacters()) {
+                        if (chr.getTeam() == 0) {
+                            chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/victory"));
+                            chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Victory"));
+                        } else {
+                            chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/lose"));
+                            chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Failed"));
                         }
-                        warpOut();
-                    } else {
-                        for (MapleCharacter chr : map.getCharacters()) {
-                            if (chr.getTeam() == 1) {
-                                chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/victory"));
-                                chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Victory"));
-                            } else {
-                                chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/lose"));
-                                chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Failed"));
-                            }
-                        }
-                        warpOut();
                     }
+                    warpOut();
+                } else {
+                    for (MapleCharacter chr : map.getCharacters()) {
+                        if (chr.getTeam() == 1) {
+                            chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/victory"));
+                            chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Victory"));
+                        } else {
+                            chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/lose"));
+                            chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Failed"));
+                        }
+                    }
+                    warpOut();
                 }
             }
         }, 300000);
@@ -94,59 +92,53 @@ public class MapleCoconut extends MapleEvent {
 
        public void bonusTime() {
            map.broadcastMessage(MaplePacketCreator.getClock(120));
-        TimerManager.getInstance().schedule(new Runnable() {
-            @Override
-            public void run() {
-                if (getMapleScore() == getStoryScore()) {
+        TimerManager.getInstance().schedule(() -> {
+            if (getMapleScore() == getStoryScore()) {
+                for (MapleCharacter chr : map.getCharacters()) {
+                    chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/lose"));
+                    chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Failed"));
+                }
+                warpOut();
+            } else if (getMapleScore() > getStoryScore()) {
                     for (MapleCharacter chr : map.getCharacters()) {
-                        chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/lose"));
-                        chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Failed"));
+                        if (chr.getTeam() == 0) {
+                            chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/victory"));
+                            chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Victory"));
+                        } else {
+                            chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/lose"));
+                            chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Failed"));
+                        }
                     }
                     warpOut();
-                } else if (getMapleScore() > getStoryScore()) {
-                        for (MapleCharacter chr : map.getCharacters()) {
-                            if (chr.getTeam() == 0) {
-                                chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/victory"));
-                                chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Victory"));
-                            } else {
-                                chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/lose"));
-                                chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Failed"));
-                            }
+                } else {
+                    for (MapleCharacter chr : map.getCharacters()) {
+                        if (chr.getTeam() == 1) {
+                            chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/victory"));
+                            chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Victory"));
+                        } else {
+                            chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/lose"));
+                            chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Failed"));
                         }
-                        warpOut();
-                    } else {
-                        for (MapleCharacter chr : map.getCharacters()) {
-                            if (chr.getTeam() == 1) {
-                                chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/victory"));
-                                chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Victory"));
-                            } else {
-                                chr.getClient().announce(MaplePacketCreator.showEffect("event/coconut/lose"));
-                                chr.getClient().announce(MaplePacketCreator.playSound("Coconut/Failed"));
-                            }
-                        }
-                        warpOut();
                     }
-            }
+                    warpOut();
+                }
         }, 120000);
 
        }
 
        public void warpOut() {
           setCoconutsHittable(false);
-        TimerManager.getInstance().schedule(new Runnable() {
-            @Override
-            public void run() {
-				List<MapleCharacter> chars = new ArrayList<>(map.getCharacters());
-				
-				for (MapleCharacter chr : chars) {
-					if ((getMapleScore() > getStoryScore() && chr.getTeam() == 0) || (getStoryScore() > getMapleScore() && chr.getTeam() == 1)) {
-						chr.changeMap(109050000);
-					} else {
-						chr.changeMap(109050001);
-					}
-				}
-				map.setCoconut(null);
+        TimerManager.getInstance().schedule(() -> {
+            List<MapleCharacter> chars = new ArrayList<>(map.getCharacters());
+
+            for (MapleCharacter chr : chars) {
+                if ((getMapleScore() > getStoryScore() && chr.getTeam() == 0) || (getStoryScore() > getMapleScore() && chr.getTeam() == 1)) {
+                    chr.changeMap(109050000);
+                } else {
+                    chr.changeMap(109050001);
+                }
             }
+            map.setCoconut(null);
         }, 12000);
        }
 

src/main/java/server/events/gm/MapleFitness.java

@@ -23,10 +23,11 @@
 package server.events.gm;
 
 import client.MapleCharacter;
-import java.util.concurrent.ScheduledFuture;
 import server.TimerManager;
 import tools.MaplePacketCreator;
 
+import java.util.concurrent.ScheduledFuture;
+
 /**
  *
  * @author kevintjuh93
@@ -40,12 +41,9 @@ public class MapleFitness {
        
        public MapleFitness(final MapleCharacter chr) {
            this.chr = chr;
-           this.schedule = TimerManager.getInstance().schedule(new Runnable() {
-            @Override
-            public void run() {
-            if (chr.getMapId() >= 109040000 && chr.getMapId() <= 109040004)
-                chr.changeMap(chr.getMap().getReturnMap());
-            }
+           this.schedule = TimerManager.getInstance().schedule(() -> {
+           if (chr.getMapId() >= 109040000 && chr.getMapId() <= 109040004)
+               chr.changeMap(chr.getMap().getReturnMap());
            }, 900000);
        }
        
@@ -80,42 +78,39 @@ public class MapleFitness {
        }
 
        public void checkAndMessage() {
-           this.schedulemsg = TimerManager.getInstance().register(new Runnable() {
-            @Override
-            public void run() {
-                if (chr.getFitness() == null) {
-                    resetTimes();
-                }
-            if (chr.getMap().getId() >= 109040000 && chr.getMap().getId() <= 109040004) {
-             if (getTimeLeft() > 9000 && getTimeLeft() < 11000) {
-                 chr.getClient().announce(MaplePacketCreator.serverNotice(0, "You have 10 sec left. Those of you unable to beat the game, we hope you beat it next time! Great job everyone!! See you later~"));
-             } else if (getTimeLeft() > 99000 && getTimeLeft() < 101000) {
-                 chr.getClient().announce(MaplePacketCreator.serverNotice(0, "Alright, you don't have much time remaining. Please hurry up a little!"));
-             } else if (getTimeLeft() > 239000 && getTimeLeft() < 241000) {
-                 chr.getClient().announce(MaplePacketCreator.serverNotice(0, "The 4th stage is the last one for [The Maple Physical Fitness Test]. Please don't give up at the last minute and try your best. The reward is waiting for you at the very top!"));
-             } else if (getTimeLeft() > 299000 && getTimeLeft() < 301000) {
-                 chr.getClient().announce(MaplePacketCreator.serverNotice(0, "The 3rd stage offers traps where you may see them, but you won't be able to step on them. Please be careful of them as you make your way up."));
-             } else if (getTimeLeft() > 359000 && getTimeLeft() < 361000) {
-                 chr.getClient().announce(MaplePacketCreator.serverNotice(0, "For those who have heavy lags, please make sure to move slowly to avoid falling all the way down because of lags."));
-             } else if (getTimeLeft() > 499000 && getTimeLeft() < 501000) {
-                 chr.getClient().announce(MaplePacketCreator.serverNotice(0, "Please remember that if you die during the event, you'll be eliminated from the game. If you're running out of HP, either take a potion or recover HP first before moving on."));
-             } else if (getTimeLeft() > 599000 && getTimeLeft() < 601000) {
-                 chr.getClient().announce(MaplePacketCreator.serverNotice(0, "The most important thing you'll need to know to avoid the bananas thrown by the monkeys is *Timing* Timing is everything in this!"));
-             } else if (getTimeLeft() > 659000 && getTimeLeft() < 661000) {
-                 chr.getClient().announce(MaplePacketCreator.serverNotice(0, "The 2nd stage offers monkeys throwing bananas. Please make sure to avoid them by moving along at just the right timing."));
-             } else if (getTimeLeft() > 699000 && getTimeLeft() < 701000) {
-                 chr.getClient().announce(MaplePacketCreator.serverNotice(0, "Please remember that if you die during the event, you'll be eliminated from the game. You still have plenty of time left, so either take a potion or recover HP first before moving on."));
-             } else if (getTimeLeft() > 779000 && getTimeLeft() < 781000) {
-                 chr.getClient().announce(MaplePacketCreator.serverNotice(0, "Everyone that clears [The Maple Physical Fitness Test] on time will be given an item, regardless of the order of finish, so just relax, take your time, and clear the 4 stages."));
-             } else if (getTimeLeft() > 839000 && getTimeLeft() < 841000) {
-                 chr.getClient().announce(MaplePacketCreator.serverNotice(0, "There may be a heavy lag due to many users at stage 1 all at once. It won't be difficult, so please make sure not to fall down because of heavy lag."));
-             } else if (getTimeLeft() > 869000 && getTimeLeft() < 871000) {
-                 chr.getClient().announce(MaplePacketCreator.serverNotice(0, "[MapleStory Physical Fitness Test] consists of 4 stages, and if you happen to die during the game, you'll be eliminated from the game, so please be careful of that."));
-             }
-            } else {
-             resetTimes();
-            }
+           this.schedulemsg = TimerManager.getInstance().register(() -> {
+               if (chr.getFitness() == null) {
+                   resetTimes();
+               }
+           if (chr.getMap().getId() >= 109040000 && chr.getMap().getId() <= 109040004) {
+            if (getTimeLeft() > 9000 && getTimeLeft() < 11000) {
+                chr.getClient().announce(MaplePacketCreator.serverNotice(0, "You have 10 sec left. Those of you unable to beat the game, we hope you beat it next time! Great job everyone!! See you later~"));
+            } else if (getTimeLeft() > 99000 && getTimeLeft() < 101000) {
+                chr.getClient().announce(MaplePacketCreator.serverNotice(0, "Alright, you don't have much time remaining. Please hurry up a little!"));
+            } else if (getTimeLeft() > 239000 && getTimeLeft() < 241000) {
+                chr.getClient().announce(MaplePacketCreator.serverNotice(0, "The 4th stage is the last one for [The Maple Physical Fitness Test]. Please don't give up at the last minute and try your best. The reward is waiting for you at the very top!"));
+            } else if (getTimeLeft() > 299000 && getTimeLeft() < 301000) {
+                chr.getClient().announce(MaplePacketCreator.serverNotice(0, "The 3rd stage offers traps where you may see them, but you won't be able to step on them. Please be careful of them as you make your way up."));
+            } else if (getTimeLeft() > 359000 && getTimeLeft() < 361000) {
+                chr.getClient().announce(MaplePacketCreator.serverNotice(0, "For those who have heavy lags, please make sure to move slowly to avoid falling all the way down because of lags."));
+            } else if (getTimeLeft() > 499000 && getTimeLeft() < 501000) {
+                chr.getClient().announce(MaplePacketCreator.serverNotice(0, "Please remember that if you die during the event, you'll be eliminated from the game. If you're running out of HP, either take a potion or recover HP first before moving on."));
+            } else if (getTimeLeft() > 599000 && getTimeLeft() < 601000) {
+                chr.getClient().announce(MaplePacketCreator.serverNotice(0, "The most important thing you'll need to know to avoid the bananas thrown by the monkeys is *Timing* Timing is everything in this!"));
+            } else if (getTimeLeft() > 659000 && getTimeLeft() < 661000) {
+                chr.getClient().announce(MaplePacketCreator.serverNotice(0, "The 2nd stage offers monkeys throwing bananas. Please make sure to avoid them by moving along at just the right timing."));
+            } else if (getTimeLeft() > 699000 && getTimeLeft() < 701000) {
+                chr.getClient().announce(MaplePacketCreator.serverNotice(0, "Please remember that if you die during the event, you'll be eliminated from the game. You still have plenty of time left, so either take a potion or recover HP first before moving on."));
+            } else if (getTimeLeft() > 779000 && getTimeLeft() < 781000) {
+                chr.getClient().announce(MaplePacketCreator.serverNotice(0, "Everyone that clears [The Maple Physical Fitness Test] on time will be given an item, regardless of the order of finish, so just relax, take your time, and clear the 4 stages."));
+            } else if (getTimeLeft() > 839000 && getTimeLeft() < 841000) {
+                chr.getClient().announce(MaplePacketCreator.serverNotice(0, "There may be a heavy lag due to many users at stage 1 all at once. It won't be difficult, so please make sure not to fall down because of heavy lag."));
+            } else if (getTimeLeft() > 869000 && getTimeLeft() < 871000) {
+                chr.getClient().announce(MaplePacketCreator.serverNotice(0, "[MapleStory Physical Fitness Test] consists of 4 stages, and if you happen to die during the game, you'll be eliminated from the game, so please be careful of that."));
             }
+           } else {
+            resetTimes();
+           }
            }, 5000, 29500);
        }
        // 14:30 [Notice][MapleStory Physical Fitness Test] consists of 4 stages, and if you happen to die during the game, you'll be eliminated from the game, so please be careful of that.

src/main/java/server/events/gm/MapleOla.java

@@ -22,10 +22,11 @@
 package server.events.gm;
 
 import client.MapleCharacter;
-import java.util.concurrent.ScheduledFuture;
 import server.TimerManager;
 import tools.MaplePacketCreator;
 
+import java.util.concurrent.ScheduledFuture;
+
 /**
  *
  * @author kevintjuh93
@@ -38,13 +39,10 @@ public class MapleOla {
 
        public MapleOla(final MapleCharacter chr) {
            this.chr = chr;
-           this.schedule = TimerManager.getInstance().schedule(new Runnable() {
-            @Override
-            public void run() {
-            if (chr.getMapId() >= 109030001 && chr.getMapId() <= 109030303)
-             chr.changeMap(chr.getMap().getReturnMap());
-             resetTimes();
-            }
+           this.schedule = TimerManager.getInstance().schedule(() -> {
+           if (chr.getMapId() >= 109030001 && chr.getMapId() <= 109030303)
+            chr.changeMap(chr.getMap().getReturnMap());
+            resetTimes();
            }, 360000);
        }
 

src/main/java/server/events/gm/MapleOxQuiz.java

@@ -22,16 +22,17 @@
 package server.events.gm;
 
 import client.MapleCharacter;
-import tools.Randomizer;
-import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
 import provider.MapleDataProvider;
 import provider.MapleDataProviderFactory;
 import provider.MapleDataTool;
 import server.TimerManager;
 import server.maps.MapleMap;
 import tools.MaplePacketCreator;
+import tools.Randomizer;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  *
@@ -69,39 +70,36 @@ public final class MapleOxQuiz {
         }
         final int number = gm;
         map.broadcastMessage(MaplePacketCreator.showOXQuiz(round, question, true));
-        TimerManager.getInstance().schedule(new Runnable() {
-            @Override
-            public void run() {
-                map.broadcastMessage(MaplePacketCreator.showOXQuiz(round, question, true));
-				List<MapleCharacter> chars = new ArrayList<>(map.getCharacters());
-				
-                for (MapleCharacter chr : chars) {
-                    if (chr != null) // make sure they aren't null... maybe something can happen in 12 seconds.
-                    {
-                        if (!isCorrectAnswer(chr, getOXAnswer(round, question)) && !chr.isGM()) {
-                            chr.changeMap(chr.getMap().getReturnMap());
-                        } else {
-                            chr.gainExp(expGain, true, true);
-                        }
+        TimerManager.getInstance().schedule(() -> {
+            map.broadcastMessage(MaplePacketCreator.showOXQuiz(round, question, true));
+            List<MapleCharacter> chars = new ArrayList<>(map.getCharacters());
+
+            for (MapleCharacter chr : chars) {
+                if (chr != null) // make sure they aren't null... maybe something can happen in 12 seconds.
+                {
+                    if (!isCorrectAnswer(chr, getOXAnswer(round, question)) && !chr.isGM()) {
+                        chr.changeMap(chr.getMap().getReturnMap());
+                    } else {
+                        chr.gainExp(expGain, true, true);
                     }
                 }
-                //do question
-                if ((round == 1 && question == 29) || ((round == 2 || round == 3) && question == 17) || ((round == 4 || round == 8) && question == 12) || (round == 5 && question == 26) || (round == 9 && question == 44) || ((round == 6 || round == 7) && question == 16)) {
-                    question = 100;
-                } else {
-                    question++;
-                }
-                //send question
-                if (map.getCharacters().size() - number <= 2) {
-                    map.broadcastMessage(MaplePacketCreator.serverNotice(6, "The event has ended"));
-                    map.getPortal("join00").setPortalStatus(true);
-                    map.setOx(null);
-                    map.setOxQuiz(false);
-                    //prizes here
-                    return;
-                }
-                sendQuestion();
             }
+            //do question
+            if ((round == 1 && question == 29) || ((round == 2 || round == 3) && question == 17) || ((round == 4 || round == 8) && question == 12) || (round == 5 && question == 26) || (round == 9 && question == 44) || ((round == 6 || round == 7) && question == 16)) {
+                question = 100;
+            } else {
+                question++;
+            }
+            //send question
+            if (map.getCharacters().size() - number <= 2) {
+                map.broadcastMessage(MaplePacketCreator.serverNotice(6, "The event has ended"));
+                map.getPortal("join00").setPortalStatus(true);
+                map.setOx(null);
+                map.setOxQuiz(false);
+                //prizes here
+                return;
+            }
+            sendQuestion();
         }, 30000); // Time to answer = 30 seconds ( Ox Quiz packet shows a 30 second timer.
     }
 

src/main/java/server/events/gm/MapleSnowball.java

@@ -22,12 +22,13 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 package server.events.gm;
 
 import client.MapleCharacter;
-import java.util.LinkedList;
-import java.util.List;
 import server.TimerManager;
 import server.maps.MapleMap;
 import tools.MaplePacketCreator;
 
+import java.util.LinkedList;
+import java.util.List;
+
 /**
  *
  * @author kevintjuh93
@@ -62,24 +63,21 @@ public class MapleSnowball {
             }
         }
         hittable = true;
-        TimerManager.getInstance().schedule(new Runnable() {
-            @Override
-            public void run() {
-                if (map.getSnowball(team).getPosition() > map.getSnowball(team == 0 ? 1 : 0).getPosition()) {
-                    for (MapleCharacter chr : characters) {
-                        if (chr != null)
-                            chr.announce(MaplePacketCreator.rollSnowBall(false, 3, map.getSnowball(0), map.getSnowball(0)));
-                    }
-                    winner = true;
-                } else if (map.getSnowball(team == 0 ? 1 : 0).getPosition() > map.getSnowball(team).getPosition()) {
-                    for (MapleCharacter chr : characters) {
-                        if (chr != null)
-                            chr.announce(MaplePacketCreator.rollSnowBall(false, 4, map.getSnowball(0), map.getSnowball(0)));
-                    }
-                    winner = true;
-                } //Else
-                warpOut();
-            }
+        TimerManager.getInstance().schedule(() -> {
+            if (map.getSnowball(team).getPosition() > map.getSnowball(team == 0 ? 1 : 0).getPosition()) {
+                for (MapleCharacter chr : characters) {
+                    if (chr != null)
+                        chr.announce(MaplePacketCreator.rollSnowBall(false, 3, map.getSnowball(0), map.getSnowball(0)));
+                }
+                winner = true;
+            } else if (map.getSnowball(team == 0 ? 1 : 0).getPosition() > map.getSnowball(team).getPosition()) {
+                for (MapleCharacter chr : characters) {
+                    if (chr != null)
+                        chr.announce(MaplePacketCreator.rollSnowBall(false, 4, map.getSnowball(0), map.getSnowball(0)));
+                }
+                winner = true;
+            } //Else
+            warpOut();
         }, 600000);
 
     }
@@ -112,13 +110,9 @@ public class MapleSnowball {
             if (this.snowmanhp - damage < 0) {
                 this.snowmanhp = 0;
 
-                TimerManager.getInstance().schedule(new Runnable() {
-
-                    @Override
-                    public void run() {
-                        setSnowmanHP(7500);
-                        message(5);
-                    }
+                TimerManager.getInstance().schedule(() -> {
+                    setSnowmanHP(7500);
+                    message(5);
                 }, 10000);
             } else
                 this.snowmanhp -= damage;
@@ -149,17 +143,13 @@ public class MapleSnowball {
     }
 
     public void warpOut() {
-        TimerManager.getInstance().schedule(new Runnable() {
+        TimerManager.getInstance().schedule(() -> {
+            if (winner == true)
+                map.warpOutByTeam(team, 109050000);
+            else
+                map.warpOutByTeam(team, 109050001);
 
-            @Override
-            public void run() {
-                if (winner == true)
-                    map.warpOutByTeam(team, 109050000);
-                else
-                    map.warpOutByTeam(team, 109050001);
-
-                map.setSnowball(team, null);
-            }
+            map.setSnowball(team, null);
         }, 10000);
     }
 }

src/main/java/server/expeditions/MapleExpedition.java

@@ -22,31 +22,25 @@
 
 package server.expeditions;
 
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.ScheduledFuture;
-
+import client.MapleCharacter;
 import net.server.PlayerStorage;
 import net.server.Server;
+import net.server.audit.locks.MonitoredLockType;
+import net.server.audit.locks.MonitoredReentrantLock;
+import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
+import net.server.channel.Channel;
 import server.TimerManager;
 import server.life.MapleMonster;
 import server.maps.MapleMap;
 import tools.LogHelper;
 import tools.MaplePacketCreator;
-import client.MapleCharacter;
-import java.util.Iterator;
-import java.util.Properties;
-import net.server.audit.locks.MonitoredLockType;
-import net.server.audit.locks.MonitoredReentrantLock;
-import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
-import net.server.channel.Channel;
+
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.util.Map.Entry;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ScheduledFuture;
 
 /**
  *
@@ -133,17 +127,14 @@ public class MapleExpedition {
 		final MapleExpedition exped = this;
                 startTime = System.currentTimeMillis() + type.getRegistrationTime() * 60 * 1000;
                 
-		schedule = TimerManager.getInstance().schedule(new Runnable() { 
-			@Override
-			public void run() {
-				if (registering){
-                                        exped.removeChannelExpedition(startMap.getChannelServer());
-					if (!silent) startMap.broadcastMessage(MaplePacketCreator.serverNotice(6, "[Expedition] The time limit has been reached. Expedition has been disbanded."));
-                                        
-                                        dispose(false);
-				}
-			}
-		}, type.getRegistrationTime() * 60 * 1000);
+		schedule = TimerManager.getInstance().schedule(() -> {
+            if (registering){
+exped.removeChannelExpedition(startMap.getChannelServer());
+                if (!silent) startMap.broadcastMessage(MaplePacketCreator.serverNotice(6, "[Expedition] The time limit has been reached. Expedition has been disbanded."));
+
+dispose(false);
+            }
+        }, type.getRegistrationTime() * 60 * 1000);
 	}
 
 	public void dispose(boolean log){

src/main/java/server/life/MapleMonster.java

@@ -21,66 +21,45 @@
  */
 package server.life;
 
-import client.MapleBuffStat;
-import client.MapleCharacter;
-import client.MapleClient;
-import client.MapleFamilyEntry;
-import client.MapleJob;
-import client.Skill;
-import client.SkillFactory;
+import client.*;
 import client.status.MonsterStatus;
 import client.status.MonsterStatusEffect;
 import config.YamlConfig;
-import constants.skills.Crusader;
-import constants.skills.FPMage;
-import constants.skills.Hermit;
-import constants.skills.ILMage;
-import constants.skills.NightLord;
-import constants.skills.NightWalker;
-import constants.skills.Priest;
-import constants.skills.Shadower;
-import constants.skills.WhiteKnight;
-import java.awt.Point;
-import java.lang.ref.WeakReference;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.EnumMap;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
-import net.server.audit.locks.MonitoredReentrantLock;
-import net.server.channel.Channel;
-import net.server.world.MapleParty;
-import net.server.world.MaplePartyCharacter;
-import scripting.event.EventInstanceManager;
-import server.TimerManager;
-import server.life.MapleLifeFactory.BanishInfo;
-import server.maps.MapleMap;
-import server.maps.MapleMapObjectType;
-import tools.IntervalBuilder;
-import tools.MaplePacketCreator;
-import tools.Pair;
-import tools.Randomizer;
+import constants.skills.*;
 import net.server.audit.LockCollector;
 import net.server.audit.locks.MonitoredLockType;
+import net.server.audit.locks.MonitoredReentrantLock;
 import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
-import net.server.services.type.ChannelServices;
+import net.server.channel.Channel;
+import net.server.coordinator.world.MapleMonsterAggroCoordinator;
 import net.server.services.task.channel.MobAnimationService;
 import net.server.services.task.channel.MobClearSkillService;
 import net.server.services.task.channel.MobStatusService;
 import net.server.services.task.channel.OverallService;
-import net.server.coordinator.world.MapleMonsterAggroCoordinator;
+import net.server.services.type.ChannelServices;
+import net.server.world.MapleParty;
+import net.server.world.MaplePartyCharacter;
+import scripting.event.EventInstanceManager;
 import server.MapleStatEffect;
+import server.TimerManager;
+import server.life.MapleLifeFactory.BanishInfo;
 import server.loot.MapleLootManager;
+import server.maps.MapleMap;
+import server.maps.MapleMapObjectType;
 import server.maps.MapleSummon;
+import tools.IntervalBuilder;
+import tools.MaplePacketCreator;
+import tools.Pair;
+import tools.Randomizer;
+
+import java.awt.*;
+import java.lang.ref.WeakReference;
+import java.util.List;
+import java.util.*;
+import java.util.Map.Entry;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 
 public class MapleMonster extends AbstractLoadedMapleLife {
     
@@ -792,51 +771,48 @@ public class MapleMonster extends AbstractLoadedMapleLife {
             if(toSpawn.size() > 0) {
                 final EventInstanceManager eim = this.getMap().getEventInstance();
                 
-                TimerManager.getInstance().schedule(new Runnable() {
-                    @Override
-                    public void run() {
-                        MapleCharacter controller = lastController.getLeft();
-                        boolean aggro = lastController.getRight();
-                        
-                        for (Integer mid : toSpawn) {
-                            final MapleMonster mob = MapleLifeFactory.getMonster(mid);
-                            mob.setPosition(getPosition());
-                            mob.setFh(getFh());
-                            mob.setParentMobOid(getObjectId());
-                            
-                            if (dropsDisabled()) {
-                                mob.disableDrops();
-                            }
-                            reviveMap.spawnMonster(mob);
+                TimerManager.getInstance().schedule(() -> {
+                    MapleCharacter controller = lastController.getLeft();
+                    boolean aggro = lastController.getRight();
 
-                            if (mob.getId() >= 8810010 && mob.getId() <= 8810017 && reviveMap.isHorntailDefeated()) {
-                                boolean htKilled = false;
-                                MapleMonster ht = reviveMap.getMonsterById(8810018);
-                                
-                                if(ht != null) {
-                                    ht.lockMonster();
-                                    try {
-                                        htKilled = ht.isAlive();
-                                        ht.setHpZero();
-                                    } finally {
-                                        ht.unlockMonster();
-                                    }
-                                    
-                                    if(htKilled) {
-                                        reviveMap.killMonster(ht, killer, true);
-                                    }
+                    for (Integer mid : toSpawn) {
+                        final MapleMonster mob = MapleLifeFactory.getMonster(mid);
+                        mob.setPosition(getPosition());
+                        mob.setFh(getFh());
+                        mob.setParentMobOid(getObjectId());
+
+                        if (dropsDisabled()) {
+                            mob.disableDrops();
+                        }
+                        reviveMap.spawnMonster(mob);
+
+                        if (mob.getId() >= 8810010 && mob.getId() <= 8810017 && reviveMap.isHorntailDefeated()) {
+                            boolean htKilled = false;
+                            MapleMonster ht = reviveMap.getMonsterById(8810018);
+
+                            if(ht != null) {
+                                ht.lockMonster();
+                                try {
+                                    htKilled = ht.isAlive();
+                                    ht.setHpZero();
+                                } finally {
+                                    ht.unlockMonster();
                                 }
-                                
-                                for(int i = 8810017; i >= 8810010; i--) {
-                                    reviveMap.killMonster(reviveMap.getMonsterById(i), killer, true);
+
+                                if(htKilled) {
+                                    reviveMap.killMonster(ht, killer, true);
                                 }
-                            } else if (controller != null) {
-                                mob.aggroSwitchController(controller, aggro);
                             }
-                            
-                            if(eim != null) {
-                                eim.reviveMonster(mob);
+
+                            for(int i = 8810017; i >= 8810010; i--) {
+                                reviveMap.killMonster(reviveMap.getMonsterById(i), killer, true);
                             }
+                        } else if (controller != null) {
+                            mob.aggroSwitchController(controller, aggro);
+                        }
+
+                        if(eim != null) {
+                            eim.reviveMonster(mob);
                         }
                     }
                 }, getAnimationTime("die1"));
@@ -851,29 +827,26 @@ public class MapleMonster extends AbstractLoadedMapleLife {
     
     public void dropFromFriendlyMonster(long delay) {
         final MapleMonster m = this;
-        monsterItemDrop = TimerManager.getInstance().register(new Runnable() {
-            @Override
-            public void run() {
-                if (!m.isAlive()) {
-                    if (monsterItemDrop != null) {
-                        monsterItemDrop.cancel(false);
-                    }
-                    
-                    return;
+        monsterItemDrop = TimerManager.getInstance().register(() -> {
+            if (!m.isAlive()) {
+                if (monsterItemDrop != null) {
+                    monsterItemDrop.cancel(false);
                 }
-                
-                MapleMap map = m.getMap();
-                List<MapleCharacter> chrList = map.getAllPlayers();
-                if (!chrList.isEmpty()) {
-                    MapleCharacter chr = (MapleCharacter) chrList.get(0);
-                    
-                    EventInstanceManager eim = map.getEventInstance();
-                    if (eim != null) {
-                        eim.friendlyItemDrop(m);
-                    }
-                    
-                    map.dropFromFriendlyMonster(chr, m);
+
+                return;
+            }
+
+            MapleMap map = m.getMap();
+            List<MapleCharacter> chrList = map.getAllPlayers();
+            if (!chrList.isEmpty()) {
+                MapleCharacter chr = (MapleCharacter) chrList.get(0);
+
+                EventInstanceManager eim = map.getEventInstance();
+                if (eim != null) {
+                    eim.friendlyItemDrop(m);
                 }
+
+                map.dropFromFriendlyMonster(chr, m);
             }
         }, delay, delay);
     }
@@ -1197,26 +1170,22 @@ public class MapleMonster extends AbstractLoadedMapleLife {
             }
         }
         
-        final Runnable cancelTask = new Runnable() {
-
-            @Override
-            public void run() {
-                if (isAlive()) {
-                    byte[] packet = MaplePacketCreator.cancelMonsterStatus(getObjectId(), status.getStati());
-                    broadcastMonsterStatusMessage(packet);
-                }
-                
-                statiLock.lock();
-                try {
-                    for (MonsterStatus stat : status.getStati().keySet()) {
-                        stati.remove(stat);
-                    }
-                } finally {
-                    statiLock.unlock();
-                }
-                
-                setVenomMulti(0);
+        final Runnable cancelTask = () -> {
+            if (isAlive()) {
+                byte[] packet = MaplePacketCreator.cancelMonsterStatus(getObjectId(), status.getStati());
+                broadcastMonsterStatusMessage(packet);
             }
+
+            statiLock.lock();
+            try {
+                for (MonsterStatus stat : status.getStati().keySet()) {
+                    stati.remove(stat);
+                }
+            } finally {
+                statiLock.unlock();
+            }
+
+            setVenomMulti(0);
         };
         
         Runnable overtimeAction = null;
@@ -1313,22 +1282,18 @@ public class MapleMonster extends AbstractLoadedMapleLife {
     }
     
     public void applyMonsterBuff(final Map<MonsterStatus, Integer> stats, final int x, int skillId, long duration, MobSkill skill, final List<Integer> reflection) {
-        final Runnable cancelTask = new Runnable() {
+        final Runnable cancelTask = () -> {
+            if (isAlive()) {
+                byte[] packet = MaplePacketCreator.cancelMonsterStatus(getObjectId(), stats);
+                broadcastMonsterStatusMessage(packet);
 
-            @Override
-            public void run() {
-                if (isAlive()) {
-                    byte[] packet = MaplePacketCreator.cancelMonsterStatus(getObjectId(), stats);
-                    broadcastMonsterStatusMessage(packet);
-                    
-                    statiLock.lock();
-                    try {
-                        for (final MonsterStatus stat : stats.keySet()) {
-                            stati.remove(stat);
-                        }
-                    } finally {
-                        statiLock.unlock();
+                statiLock.lock();
+                try {
+                    for (final MonsterStatus stat : stats.keySet()) {
+                        stati.remove(stat);
                     }
+                } finally {
+                    statiLock.unlock();
                 }
             }
         };
@@ -1538,12 +1503,7 @@ public class MapleMonster extends AbstractLoadedMapleLife {
         
         final MapleMonster mons = this;
         MapleMap mmap = mons.getMap();
-        Runnable r = new Runnable() {
-            @Override
-            public void run() {
-                mons.clearSkill(skillId, level);
-            }
-        };
+        Runnable r = () -> mons.clearSkill(skillId, level);
         
         MobClearSkillService service = (MobClearSkillService) map.getChannelServer().getServiceAccess(ChannelServices.MOB_CLEAR_SKILL);
         service.registerMobClearSkillAction(mmap.getId(), r, cooltime);
@@ -1607,12 +1567,7 @@ public class MapleMonster extends AbstractLoadedMapleLife {
 
             final MapleMonster mons = this;
             MapleMap mmap = mons.getMap();
-            Runnable r = new Runnable() {
-                @Override
-                public void run() {
-                    mons.clearAttack(attackPos);
-                }
-            };
+            Runnable r = () -> mons.clearAttack(attackPos);
             
             MobClearSkillService service = (MobClearSkillService) map.getChannelServer().getServiceAccess(ChannelServices.MOB_CLEAR_SKILL);
             service.registerMobClearSkillAction(mmap.getId(), r, cooltime);
@@ -1715,16 +1670,13 @@ public class MapleMonster extends AbstractLoadedMapleLife {
                 stats.setEffectiveness(e, ee);
                 
                 MapleMap mmap = this.getMap();
-                Runnable r = new Runnable() {
-                    @Override
-                    public void run() {
-                        monsterLock.lock();
-                        try {
-                            stats.removeEffectiveness(fE);
-                            stats.setEffectiveness(fE, fEE);
-                        } finally {
-                            monsterLock.unlock();
-                        }
+                Runnable r = () -> {
+                    monsterLock.lock();
+                    try {
+                        stats.removeEffectiveness(fE);
+                        stats.setEffectiveness(fE, fEE);
+                    } finally {
+                        monsterLock.unlock();
                     }
                 };
                 
@@ -2178,35 +2130,32 @@ public class MapleMonster extends AbstractLoadedMapleLife {
         }
         
         availablePuppetUpdate = false;
-        Runnable r = new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    MapleCharacter chrController = MapleMonster.this.getActiveController();
-                    if (chrController == null) {
+        Runnable r = () -> {
+            try {
+                MapleCharacter chrController = MapleMonster.this.getActiveController();
+                if (chrController == null) {
+                    return;
+                }
+
+                MapleStatEffect puppetEffect = chrController.getBuffEffect(MapleBuffStat.PUPPET);
+                if (puppetEffect != null) {
+                    MapleSummon puppet = chrController.getSummonByKey(puppetEffect.getSourceId());
+
+                    if (puppet != null && isPuppetInVicinity(puppet)) {
+                        controllerHasPuppet = true;
+                        aggroRefreshPuppetVisibility(chrController, puppet);
                         return;
                     }
-
-                    MapleStatEffect puppetEffect = chrController.getBuffEffect(MapleBuffStat.PUPPET);
-                    if (puppetEffect != null) {
-                        MapleSummon puppet = chrController.getSummonByKey(puppetEffect.getSourceId());
-
-                        if (puppet != null && isPuppetInVicinity(puppet)) {
-                            controllerHasPuppet = true;
-                            aggroRefreshPuppetVisibility(chrController, puppet);
-                            return;
-                        }
-                    }
-
-                    if (controllerHasPuppet) {
-                        controllerHasPuppet = false;
-
-                        chrController.announce(MaplePacketCreator.stopControllingMonster(MapleMonster.this.getObjectId()));
-                        aggroMonsterControl(chrController.getClient(), MapleMonster.this, MapleMonster.this.isControllerHasAggro());
-                    }
-                } finally {
-                    availablePuppetUpdate = true;
                 }
+
+                if (controllerHasPuppet) {
+                    controllerHasPuppet = false;
+
+                    chrController.announce(MaplePacketCreator.stopControllingMonster(MapleMonster.this.getObjectId()));
+                    aggroMonsterControl(chrController.getClient(), MapleMonster.this, MapleMonster.this.isControllerHasAggro());
+                }
+            } finally {
+                availablePuppetUpdate = true;
             }
         };
         
@@ -2252,12 +2201,7 @@ public class MapleMonster extends AbstractLoadedMapleLife {
     }
     
     private void disposeLocks() {
-        LockCollector.getInstance().registerDisposeAction(new Runnable() {
-            @Override
-            public void run() {
-                emptyLocks();
-            }
-        });
+        LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
     }
     
     private void emptyLocks() {

src/main/java/server/life/MobSkill.java

@@ -21,25 +21,22 @@
  */
 package server.life;
 
-import java.awt.Point;
-import java.awt.Rectangle;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
 import client.MapleCharacter;
 import client.MapleDisease;
 import client.status.MonsterStatus;
 import constants.game.GameConstants;
-import java.util.LinkedList;
-import java.util.Map;
-import net.server.services.type.ChannelServices;
 import net.server.services.task.channel.OverallService;
-import tools.Randomizer;
+import net.server.services.type.ChannelServices;
 import server.maps.MapleMap;
 import server.maps.MapleMapObject;
 import server.maps.MapleMapObjectType;
 import server.maps.MapleMist;
 import tools.ArrayMap;
+import tools.Randomizer;
+
+import java.awt.*;
+import java.util.List;
+import java.util.*;
 
 /**
  *
@@ -108,12 +105,9 @@ public class MobSkill {
     }
 
     public void applyDelayedEffect(final MapleCharacter player, final MapleMonster monster, final boolean skill, int animationTime) {
-        Runnable toRun = new Runnable() {
-            @Override
-            public void run() {
-                if (monster.isAlive()) {
-                    applyEffect(player, monster, skill, null);
-                }
+        Runnable toRun = () -> {
+            if (monster.isAlive()) {
+                applyEffect(player, monster, skill, null);
             }
         };
 

src/main/java/server/life/positioner/MaplePlayerNPCPodium.java

@@ -20,12 +20,6 @@
 package server.life.positioner;
 
 import config.YamlConfig;
-import java.awt.Point;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
 import net.server.Server;
 import net.server.channel.Channel;
 import server.life.MaplePlayerNPC;
@@ -34,6 +28,12 @@ import server.maps.MapleMapObject;
 import server.maps.MapleMapObjectType;
 import tools.MaplePacketCreator;
 
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
 /**
  *
  * @author RonanLana
@@ -92,11 +92,8 @@ public class MaplePlayerNPCPodium {
                 playerNpcs.add((MaplePlayerNPC) mmo);
             }
             
-            Collections.sort(playerNpcs, new Comparator<MaplePlayerNPC>() {
-                @Override
-                public int compare(MaplePlayerNPC p1, MaplePlayerNPC p2) {
-                    return p1.getScriptId() - p2.getScriptId(); // scriptid as playernpc history
-                }
+            Collections.sort(playerNpcs, (p1, p2) -> {
+                return p1.getScriptId() - p2.getScriptId(); // scriptid as playernpc history
             });
             
             for(Channel ch : Server.getInstance().getChannelsFromWorld(map.getWorld())) {

src/main/java/server/life/positioner/MaplePlayerNPCPositioner.java

@@ -20,14 +20,6 @@
 package server.life.positioner;
 
 import config.YamlConfig;
-import java.awt.Point;
-import java.awt.Rectangle;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.LinkedList;
-import java.util.List;
 import net.server.Server;
 import net.server.channel.Channel;
 import server.life.MaplePlayerNPC;
@@ -36,6 +28,10 @@ import server.maps.MapleMapObject;
 import server.maps.MapleMapObjectType;
 import tools.MaplePacketCreator;
 
+import java.awt.*;
+import java.util.List;
+import java.util.*;
+
 /**
  *
  * @author RonanLana
@@ -145,11 +141,8 @@ public class MaplePlayerNPCPositioner {
                 playerNpcs.add((MaplePlayerNPC) mmo);
             }
             
-            Collections.sort(playerNpcs, new Comparator<MaplePlayerNPC>() {
-                @Override
-                public int compare(MaplePlayerNPC p1, MaplePlayerNPC p2) {
-                    return p1.getScriptId() - p2.getScriptId(); // scriptid as playernpc history
-                }
+            Collections.sort(playerNpcs, (p1, p2) -> {
+                return p1.getScriptId() - p2.getScriptId(); // scriptid as playernpc history
             });
             
             for(Channel ch : Server.getInstance().getChannelsFromWorld(map.getWorld())) {

src/main/java/server/maps/MapMonitor.java

@@ -21,9 +21,10 @@
 */
 package server.maps;
 
-import java.util.concurrent.ScheduledFuture;
 import server.TimerManager;
 
+import java.util.concurrent.ScheduledFuture;
+
 public class MapMonitor {
     private ScheduledFuture<?> monitorSchedule;
     private MapleMap map;
@@ -32,12 +33,9 @@ public class MapMonitor {
     public MapMonitor(final MapleMap map, String portal) {
         this.map = map;
         this.portal = map.getPortal(portal);
-        this.monitorSchedule = TimerManager.getInstance().register(new Runnable() {
-            @Override
-            public void run() {
-                if (map.getCharacters().size() < 1) {
-                    cancelAction();
-                }
+        this.monitorSchedule = TimerManager.getInstance().register(() -> {
+            if (map.getCharacters().size() < 1) {
+                cancelAction();
             }
         }, 5000);
     }

src/main/java/server/maps/MapleDoor.java

@@ -21,15 +21,14 @@
 */
 package server.maps;
 
-import java.awt.Point;
-import java.util.Collection;
-
+import client.MapleCharacter;
 import config.YamlConfig;
+import net.server.services.task.channel.OverallService;
+import net.server.services.type.ChannelServices;
 import tools.Pair;
 
-import client.MapleCharacter;
-import net.server.services.type.ChannelServices;
-import net.server.services.task.channel.OverallService;
+import java.awt.*;
+import java.util.Collection;
 
 /**
  *
@@ -134,11 +133,8 @@ public class MapleDoor {
                 MapleMap town = destroyDoor.getTown();
                 
                 OverallService service = (OverallService) town.getChannelServer().getServiceAccess(ChannelServices.OVERALL);
-                service.registerOverallAction(town.getId(), new Runnable() {
-                    @Override
-                    public void run() {
-                        destroyDoor.broadcastRemoveDoor(owner);   // thanks BHB88 for noticing doors crashing players when instantly cancelling buff
-                    }
+                service.registerOverallAction(town.getId(), () -> {
+                    destroyDoor.broadcastRemoveDoor(owner);   // thanks BHB88 for noticing doors crashing players when instantly cancelling buff
                 }, effectTimeLeft);
             } else {
                 destroyDoor.broadcastRemoveDoor(owner);

src/main/java/server/maps/MapleMap.java

@@ -34,27 +34,7 @@ import client.status.MonsterStatusEffect;
 import config.YamlConfig;
 import constants.game.GameConstants;
 import constants.inventory.ItemConstants;
-import java.awt.Point;
-import java.awt.Rectangle;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Calendar;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Random;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.locks.Lock;
+import net.server.Server;
 import net.server.audit.locks.MonitoredLockType;
 import net.server.audit.locks.MonitoredReadLock;
 import net.server.audit.locks.MonitoredReentrantReadWriteLock;
@@ -62,36 +42,22 @@ import net.server.audit.locks.MonitoredWriteLock;
 import net.server.audit.locks.factory.MonitoredReadLockFactory;
 import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
 import net.server.audit.locks.factory.MonitoredWriteLockFactory;
-import java.lang.ref.WeakReference;
-import net.server.Server;
-import net.server.coordinator.world.MapleMonsterAggroCoordinator;
 import net.server.channel.Channel;
-import net.server.services.type.ChannelServices;
+import net.server.coordinator.world.MapleMonsterAggroCoordinator;
 import net.server.services.task.channel.FaceExpressionService;
 import net.server.services.task.channel.MobMistService;
 import net.server.services.task.channel.OverallService;
+import net.server.services.type.ChannelServices;
 import net.server.world.MapleParty;
 import net.server.world.World;
+import scripting.event.EventInstanceManager;
 import scripting.map.MapScriptManager;
 import server.MapleItemInformationProvider;
 import server.MapleStatEffect;
 import server.TimerManager;
-import server.events.gm.MapleCoconut;
-import server.events.gm.MapleFitness;
-import server.events.gm.MapleOla;
-import server.events.gm.MapleOxQuiz;
-import server.events.gm.MapleSnowball;
-import server.life.MapleLifeFactory;
+import server.events.gm.*;
+import server.life.*;
 import server.life.MapleLifeFactory.selfDestruction;
-import server.life.MapleMonster;
-import server.life.MapleMonsterInformationProvider;
-import server.life.MapleNPC;
-import server.life.MonsterDropEntry;
-import server.life.MonsterGlobalDropEntry;
-import server.life.SpawnPoint;
-import scripting.event.EventInstanceManager;
-import server.life.MaplePlayerNPC;
-import server.life.MonsterListener;
 import server.partyquest.GuardianSpawnPoint;
 import server.partyquest.MapleCarnivalFactory;
 import server.partyquest.MapleCarnivalFactory.MCSkill;
@@ -100,6 +66,15 @@ import tools.MaplePacketCreator;
 import tools.Pair;
 import tools.Randomizer;
 
+import java.awt.*;
+import java.lang.ref.WeakReference;
+import java.util.List;
+import java.util.*;
+import java.util.Map.Entry;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.Lock;
+
 public class MapleMap {
     
     private static final List<MapleMapObjectType> rangedMapobjectTypes = Arrays.asList(MapleMapObjectType.SHOP, MapleMapObjectType.ITEM, MapleMapObjectType.NPC, MapleMapObjectType.MONSTER, MapleMapObjectType.DOOR, MapleMapObjectType.SUMMON, MapleMapObjectType.REACTOR);
@@ -823,49 +798,41 @@ public class MapleMap {
                 return;
             }
             
-            itemMonitor = TimerManager.getInstance().register(new Runnable() {
-                @Override
-                public void run() {
-                    chrWLock.lock();
-                    try {
-                        if (characters.isEmpty()) {
-                            if(itemMonitorTimeout == 0) {
-                                if(itemMonitor != null) {
-                                    stopItemMonitor();
-                                    aggroMonitor.stopAggroCoordinator();
-                                }
-                                
-                                return;
-                            } else {
-                                itemMonitorTimeout--;
+            itemMonitor = TimerManager.getInstance().register(() -> {
+                chrWLock.lock();
+                try {
+                    if (characters.isEmpty()) {
+                        if(itemMonitorTimeout == 0) {
+                            if(itemMonitor != null) {
+                                stopItemMonitor();
+                                aggroMonitor.stopAggroCoordinator();
                             }
+
+                            return;
                         } else {
-                            itemMonitorTimeout = 1;
+                            itemMonitorTimeout--;
                         }
-                    } finally {
-                        chrWLock.unlock();
-                    }
-                    
-                    boolean tryClean;
-                    objectRLock.lock();
-                    try {
-                        tryClean = registeredDrops.size() > 70;
-                    } finally {
-                        objectRLock.unlock();
-                    }
-                    
-                    if (tryClean) {
-                        cleanItemMonitor();
+                    } else {
+                        itemMonitorTimeout = 1;
                     }
+                } finally {
+                    chrWLock.unlock();
+                }
+
+                boolean tryClean;
+                objectRLock.lock();
+                try {
+                    tryClean = registeredDrops.size() > 70;
+                } finally {
+                    objectRLock.unlock();
+                }
+
+                if (tryClean) {
+                    cleanItemMonitor();
                 }
             }, YamlConfig.config.server.ITEM_MONITOR_TIME, YamlConfig.config.server.ITEM_MONITOR_TIME);
             
-            expireItemsTask = TimerManager.getInstance().register(new Runnable() {
-                @Override
-                public void run() {
-                    makeDisappearExpiredItemDrops();
-                }
-            }, YamlConfig.config.server.ITEM_EXPIRE_CHECK, YamlConfig.config.server.ITEM_EXPIRE_CHECK);
+            expireItemsTask = TimerManager.getInstance().register(() -> makeDisappearExpiredItemDrops(), YamlConfig.config.server.ITEM_EXPIRE_CHECK, YamlConfig.config.server.ITEM_EXPIRE_CHECK);
             
             if(YamlConfig.config.server.USE_SPAWN_LOOT_ON_ANIMATION) {
                 lootLock.lock();
@@ -875,20 +842,10 @@ public class MapleMap {
                     lootLock.unlock();
                 }
 
-                mobSpawnLootTask = TimerManager.getInstance().register(new Runnable() {
-                    @Override
-                    public void run() {
-                        spawnMobItemDrops();
-                    }
-                }, 200, 200);
+                mobSpawnLootTask = TimerManager.getInstance().register(() -> spawnMobItemDrops(), 200, 200);
             }
             
-            characterStatUpdateTask = TimerManager.getInstance().register(new Runnable() {
-                @Override
-                public void run() {
-                    runCharacterStatUpdate();
-                }
-            }, 200, 200);
+            characterStatUpdateTask = TimerManager.getInstance().register(() -> runCharacterStatUpdate(), 200, 200);
                     
             itemMonitorTimeout = 1;
         } finally {
@@ -1145,18 +1102,15 @@ public class MapleMap {
     private void spawnDrop(final Item idrop, final Point dropPos, final MapleMapObject dropper, final MapleCharacter chr, final byte droptype, final short questid) {
         final MapleMapItem mdrop = new MapleMapItem(idrop, dropPos, dropper, chr, chr.getClient(), droptype, false, questid);
         mdrop.setDropTime(Server.getInstance().getCurrentTime());
-        spawnAndAddRangedMapObject(mdrop, new DelayedPacketCreation() {
-            @Override
-            public void sendPackets(MapleClient c) {
-                MapleCharacter chr = c.getPlayer();
-                
-                if (chr.needQuestItem(questid, idrop.getItemId())) {
-                    mdrop.lockItem();
-                    try {
-                        c.announce(MaplePacketCreator.dropItemFromMapObject(chr, mdrop, dropper.getPosition(), dropPos, (byte) 1));
-                    } finally {
-                        mdrop.unlockItem();
-                    }
+        spawnAndAddRangedMapObject(mdrop, c -> {
+            MapleCharacter chr1 = c.getPlayer();
+
+            if (chr1.needQuestItem(questid, idrop.getItemId())) {
+                mdrop.lockItem();
+                try {
+                    c.announce(MaplePacketCreator.dropItemFromMapObject(chr1, mdrop, dropper.getPosition(), dropPos, (byte) 1));
+                } finally {
+                    mdrop.unlockItem();
                 }
             }
         }, null);
@@ -1170,15 +1124,12 @@ public class MapleMap {
         final MapleMapItem mdrop = new MapleMapItem(meso, droppos, dropper, owner, owner.getClient(), droptype, playerDrop);
         mdrop.setDropTime(Server.getInstance().getCurrentTime());
 
-        spawnAndAddRangedMapObject(mdrop, new DelayedPacketCreation() {
-            @Override
-            public void sendPackets(MapleClient c) {
-                mdrop.lockItem();
-                try {
-                    c.announce(MaplePacketCreator.dropItemFromMapObject(c.getPlayer(), mdrop, dropper.getPosition(), droppos, (byte) 1));
-                } finally {
-                    mdrop.unlockItem();
-                }
+        spawnAndAddRangedMapObject(mdrop, c -> {
+            mdrop.lockItem();
+            try {
+                c.announce(MaplePacketCreator.dropItemFromMapObject(c.getPlayer(), mdrop, dropper.getPosition(), droppos, (byte) 1));
+            } finally {
+                mdrop.unlockItem();
             }
         }, null);
 
@@ -1916,12 +1867,7 @@ public class MapleMap {
             getEventInstance().registerMonster(monster);
         }
 
-        spawnAndAddRangedMapObject(monster, new DelayedPacketCreation() {
-            @Override
-            public void sendPackets(MapleClient c) {
-                c.announce(MaplePacketCreator.spawnMonster(monster, false));
-            }
-        });
+        spawnAndAddRangedMapObject(monster, c -> c.announce(MaplePacketCreator.spawnMonster(monster, false)));
         
         monster.aggroUpdateController();
         updateBossSpawn(monster);
@@ -1937,21 +1883,11 @@ public class MapleMap {
             Runnable removeAfterAction;
             
             if (selfDestruction == null) {
-                removeAfterAction = new Runnable() {
-                    @Override
-                    public void run() {
-                        killMonster(monster, null, false);
-                    }
-                };
+                removeAfterAction = () -> killMonster(monster, null, false);
                 
                 registerMapSchedule(removeAfterAction, monster.getStats().removeAfter() * 1000);
             } else {
-                removeAfterAction = new Runnable() {
-                    @Override
-                    public void run() {
-                        killMonster(monster, null, false, selfDestruction.getAction());
-                    }
-                };
+                removeAfterAction = () -> killMonster(monster, null, false, selfDestruction.getAction());
                 
                 registerMapSchedule(removeAfterAction, selfDestruction.removeAfter() * 1000);
             }
@@ -2018,12 +1954,7 @@ public class MapleMap {
             getEventInstance().registerMonster(monster);
         }
         
-        spawnAndAddRangedMapObject(monster, new DelayedPacketCreation() {
-            @Override
-            public void sendPackets(MapleClient c) {
-                c.announce(MaplePacketCreator.spawnMonster(monster, true));
-            }
-        }, null);
+        spawnAndAddRangedMapObject(monster, c -> c.announce(MaplePacketCreator.spawnMonster(monster, true)), null);
         
         monster.aggroUpdateController();
         updateBossSpawn(monster);
@@ -2084,12 +2015,7 @@ public class MapleMap {
         monster.setPosition(spos);
         monster.setSpawnEffect(effect);
         
-        spawnAndAddRangedMapObject(monster, new DelayedPacketCreation() {
-            @Override
-            public void sendPackets(MapleClient c) {
-                c.announce(MaplePacketCreator.spawnMonster(monster, true, effect));
-            }
-        });
+        spawnAndAddRangedMapObject(monster, c -> c.announce(MaplePacketCreator.spawnMonster(monster, true, effect)));
         
         monster.aggroUpdateController();
         updateBossSpawn(monster);
@@ -2102,12 +2028,7 @@ public class MapleMap {
     public void spawnFakeMonster(final MapleMonster monster) {
         monster.setMap(this);
         monster.setFake(true);
-        spawnAndAddRangedMapObject(monster, new DelayedPacketCreation() {
-            @Override
-            public void sendPackets(MapleClient c) {
-                c.announce(MaplePacketCreator.spawnFakeMonster(monster, 0));
-            }
-        });
+        spawnAndAddRangedMapObject(monster, c -> c.announce(MaplePacketCreator.spawnFakeMonster(monster, 0)));
         
         spawnedMonstersOnMap.incrementAndGet();
         addSelfDestructive(monster);
@@ -2122,30 +2043,17 @@ public class MapleMap {
 
     public void spawnReactor(final MapleReactor reactor) {
         reactor.setMap(this);
-        spawnAndAddRangedMapObject(reactor, new DelayedPacketCreation() {
-            @Override
-            public void sendPackets(MapleClient c) {
-                c.announce(reactor.makeSpawnData());
-            }
-        });
+        spawnAndAddRangedMapObject(reactor, c -> c.announce(reactor.makeSpawnData()));
     }
 
     public void spawnDoor(final MapleDoorObject door) {
-        spawnAndAddRangedMapObject(door, new DelayedPacketCreation() {
-            @Override
-            public void sendPackets(MapleClient c) {
-                MapleCharacter chr = c.getPlayer();
-                if (chr != null) {
-                    door.sendSpawnData(c, false);
-                    chr.addVisibleMapObject(door);
-                }
+        spawnAndAddRangedMapObject(door, c -> {
+            MapleCharacter chr = c.getPlayer();
+            if (chr != null) {
+                door.sendSpawnData(c, false);
+                chr.addVisibleMapObject(door);
             }
-        }, new SpawnCondition() {
-            @Override
-            public boolean canSpawn(MapleCharacter chr) {
-                return chr.getMapId() == door.getFrom().getId();
-            }
-        });
+        }, chr -> chr.getMapId() == door.getFrom().getId());
     }
     
     public MaplePortal getDoorPortal(int doorid) {
@@ -2159,12 +2067,9 @@ public class MapleMap {
     }
     
     public void spawnSummon(final MapleSummon summon) {
-        spawnAndAddRangedMapObject(summon, new DelayedPacketCreation() {
-            @Override
-            public void sendPackets(MapleClient c) {
-                if (summon != null) {
-                    c.announce(MaplePacketCreator.spawnSummon(summon, true));
-                }
+        spawnAndAddRangedMapObject(summon, c -> {
+            if (summon != null) {
+                c.announce(MaplePacketCreator.spawnSummon(summon, true));
             }
         }, null);
     }
@@ -2175,30 +2080,24 @@ public class MapleMap {
         TimerManager tMan = TimerManager.getInstance();
         final ScheduledFuture<?> poisonSchedule;
         if (poison) {
-            Runnable poisonTask = new Runnable() {
-                @Override
-                public void run() {
-                    List<MapleMapObject> affectedMonsters = getMapObjectsInBox(mist.getBox(), Collections.singletonList(MapleMapObjectType.MONSTER));
-                    for (MapleMapObject mo : affectedMonsters) {
-                        if (mist.makeChanceResult()) {
-                            MonsterStatusEffect poisonEffect = new MonsterStatusEffect(Collections.singletonMap(MonsterStatus.POISON, 1), mist.getSourceSkill(), null, false);
-                            ((MapleMonster) mo).applyStatus(mist.getOwner(), poisonEffect, true, duration);
-                        }
+            Runnable poisonTask = () -> {
+                List<MapleMapObject> affectedMonsters = getMapObjectsInBox(mist.getBox(), Collections.singletonList(MapleMapObjectType.MONSTER));
+                for (MapleMapObject mo : affectedMonsters) {
+                    if (mist.makeChanceResult()) {
+                        MonsterStatusEffect poisonEffect = new MonsterStatusEffect(Collections.singletonMap(MonsterStatus.POISON, 1), mist.getSourceSkill(), null, false);
+                        ((MapleMonster) mo).applyStatus(mist.getOwner(), poisonEffect, true, duration);
                     }
                 }
             };
             poisonSchedule = tMan.register(poisonTask, 2000, 2500);
         } else if (recovery) {
-            Runnable poisonTask = new Runnable() {
-                @Override
-                public void run() {
-                    List<MapleMapObject> players = getMapObjectsInBox(mist.getBox(), Collections.singletonList(MapleMapObjectType.PLAYER));
-                    for (MapleMapObject mo : players) {
-                        if (mist.makeChanceResult()) {
-                            MapleCharacter chr = (MapleCharacter) mo;
-                            if (mist.getOwner().getId() == chr.getId() || mist.getOwner().getParty() != null && mist.getOwner().getParty().containsMembers(chr.getMPC())) {	                        	
-                                chr.addMP((int) mist.getSourceSkill().getEffect(chr.getSkillLevel(mist.getSourceSkill().getId())).getX() * chr.getMp() / 100);
-                            }
+            Runnable poisonTask = () -> {
+                List<MapleMapObject> players = getMapObjectsInBox(mist.getBox(), Collections.singletonList(MapleMapObjectType.PLAYER));
+                for (MapleMapObject mo : players) {
+                    if (mist.makeChanceResult()) {
+                        MapleCharacter chr = (MapleCharacter) mo;
+                        if (mist.getOwner().getId() == chr.getId() || mist.getOwner().getParty() != null && mist.getOwner().getParty().containsMembers(chr.getMPC())) {
+                            chr.addMP((int) mist.getSourceSkill().getEffect(chr.getSkillLevel(mist.getSourceSkill().getId())).getX() * chr.getMp() / 100);
                         }
                     }
                 }
@@ -2208,15 +2107,12 @@ public class MapleMap {
             poisonSchedule = null;
         }
         
-        Runnable mistSchedule = new Runnable() {
-            @Override
-            public void run() {
-                removeMapObject(mist);
-                if (poisonSchedule != null) {
-                    poisonSchedule.cancel(false);
-                }
-                broadcastMessage(mist.makeDestroyData());
+        Runnable mistSchedule = () -> {
+            removeMapObject(mist);
+            if (poisonSchedule != null) {
+                poisonSchedule.cancel(false);
             }
+            broadcastMessage(mist.makeDestroyData());
         };
         
         MobMistService service = (MobMistService) this.getChannelServer().getServiceAccess(ChannelServices.MOB_MIST);
@@ -2227,12 +2123,9 @@ public class MapleMap {
         addMapObject(kite);
         broadcastMessage(kite.makeSpawnData());
         
-        Runnable expireKite = new Runnable() {
-            @Override
-            public void run() {
-                removeMapObject(kite);
-                broadcastMessage(kite.makeDestroyData());
-            }
+        Runnable expireKite = () -> {
+            removeMapObject(kite);
+            broadcastMessage(kite.makeDestroyData());
         };
         
         getWorldServer().registerTimedMapObject(expireKite, YamlConfig.config.server.KITE_EXPIRE_TIME);
@@ -2252,15 +2145,12 @@ public class MapleMap {
         final MapleMapItem mdrop = new MapleMapItem(item, droppos, dropper, owner, owner.getClient(), dropType, playerDrop);
         mdrop.setDropTime(Server.getInstance().getCurrentTime());
 
-        spawnAndAddRangedMapObject(mdrop, new DelayedPacketCreation() {
-            @Override
-            public void sendPackets(MapleClient c) {
-                mdrop.lockItem();
-                try {
-                    c.announce(MaplePacketCreator.dropItemFromMapObject(c.getPlayer(), mdrop, dropper.getPosition(), droppos, (byte) 1));
-                } finally {
-                    mdrop.unlockItem();
-                }
+        spawnAndAddRangedMapObject(mdrop, c -> {
+            mdrop.lockItem();
+            try {
+                c.announce(MaplePacketCreator.dropItemFromMapObject(c.getPlayer(), mdrop, dropper.getPosition(), droppos, (byte) 1));
+            } finally {
+                mdrop.unlockItem();
             }
         }, null);
         
@@ -2392,12 +2282,9 @@ public class MapleMap {
         mapEffect = new MapleMapEffect(msg, itemId);
         broadcastMessage(mapEffect.makeStartData());
         
-        Runnable r = new Runnable() {
-            @Override
-            public void run() {
-                broadcastMessage(mapEffect.makeDestroyData());
-                mapEffect = null;
-            }
+        Runnable r = () -> {
+            broadcastMessage(mapEffect.makeDestroyData());
+            mapEffect = null;
         };
         
         registerMapSchedule(r, time);
@@ -2516,73 +2403,49 @@ public class MapleMap {
         if (mapid == 200090060) { // To Rien
             int travelTime = getWorldServer().getTransportationTime(1 * 60 * 1000);
             chr.announce(MaplePacketCreator.getClock(travelTime / 1000));
-            TimerManager.getInstance().schedule(new Runnable() {
-
-                @Override
-                public void run() {
-                    if (chr.getMapId() == 200090060) {
-                        chr.changeMap(140020300, 0);
-                    }
+            TimerManager.getInstance().schedule(() -> {
+                if (chr.getMapId() == 200090060) {
+                    chr.changeMap(140020300, 0);
                 }
             }, travelTime);
         } else if (mapid == 200090070) { // To Lith Harbor
             int travelTime = getWorldServer().getTransportationTime(1 * 60 * 1000);
             chr.announce(MaplePacketCreator.getClock(travelTime / 1000));
-            TimerManager.getInstance().schedule(new Runnable() {
-
-                @Override
-                public void run() {
-                    if (chr.getMapId() == 200090070) {
-                        chr.changeMap(104000000, 3);
-                    }
+            TimerManager.getInstance().schedule(() -> {
+                if (chr.getMapId() == 200090070) {
+                    chr.changeMap(104000000, 3);
                 }
             }, travelTime);
         } else if (mapid == 200090030) { // To Ereve (SkyFerry)
             int travelTime = getWorldServer().getTransportationTime(2 * 60 * 1000);
             chr.announce(MaplePacketCreator.getClock(travelTime / 1000));
-            TimerManager.getInstance().schedule(new Runnable() {
-
-                @Override
-                public void run() {
-                    if (chr.getMapId() == 200090030) {
-                        chr.changeMap(130000210, 0);
-                    }
+            TimerManager.getInstance().schedule(() -> {
+                if (chr.getMapId() == 200090030) {
+                    chr.changeMap(130000210, 0);
                 }
             }, travelTime);
         } else if (mapid == 200090031) { // To Victoria Island (SkyFerry)
             int travelTime = getWorldServer().getTransportationTime(2 * 60 * 1000);
             chr.announce(MaplePacketCreator.getClock(travelTime / 1000));
-            TimerManager.getInstance().schedule(new Runnable() {
-
-                @Override
-                public void run() {
-                    if (chr.getMapId() == 200090031) {
-                        chr.changeMap(101000400, 0);
-                    }
+            TimerManager.getInstance().schedule(() -> {
+                if (chr.getMapId() == 200090031) {
+                    chr.changeMap(101000400, 0);
                 }
             }, travelTime);
         } else if (mapid == 200090021) { // To Orbis (SkyFerry)
             int travelTime = getWorldServer().getTransportationTime(8 * 60 * 1000);
             chr.announce(MaplePacketCreator.getClock(travelTime / 1000));
-            TimerManager.getInstance().schedule(new Runnable() {
-
-                @Override
-                public void run() {
-                    if (chr.getMapId() == 200090021) {
-                        chr.changeMap(200000161, 0);
-                    }
+            TimerManager.getInstance().schedule(() -> {
+                if (chr.getMapId() == 200090021) {
+                    chr.changeMap(200000161, 0);
                 }
             }, travelTime);
         } else if (mapid == 200090020) { // To Ereve From Orbis (SkyFerry)
             int travelTime = getWorldServer().getTransportationTime(8 * 60 * 1000);
             chr.announce(MaplePacketCreator.getClock(travelTime / 1000));
-            TimerManager.getInstance().schedule(new Runnable() {
-
-                @Override
-                public void run() {
-                    if (chr.getMapId() == 200090020) {
-                        chr.changeMap(130000210, 0);
-                    }
+            TimerManager.getInstance().schedule(() -> {
+                if (chr.getMapId() == 200090020) {
+                    chr.changeMap(130000210, 0);
                 }
             }, travelTime);
         } else if (MapleMiniDungeonInfo.isDungeonMap(mapid)) {
@@ -3590,17 +3453,14 @@ public class MapleMap {
                                 MapleMap reactorMap = reactor.getMap();
                                 
                                 OverallService service = (OverallService) reactorMap.getChannelServer().getServiceAccess(ChannelServices.OVERALL);
-                                service.registerOverallAction(reactorMap.getId(), new Runnable() {
-                                    @Override
-                                    public void run() {
-                                        reactor.lockReactor();
-                                        try {
-                                            reactor.resetReactorActions(0);
-                                            reactor.setAlive(true);
-                                            broadcastMessage(MaplePacketCreator.triggerReactor(reactor, 0));
-                                        } finally {
-                                            reactor.unlockReactor();
-                                        }
+                                service.registerOverallAction(reactorMap.getId(), () -> {
+                                    reactor.lockReactor();
+                                    try {
+                                        reactor.resetReactorActions(0);
+                                        reactor.setAlive(true);
+                                        broadcastMessage(MaplePacketCreator.triggerReactor(reactor, 0));
+                                    } finally {
+                                        reactor.unlockReactor();
                                     }
                                 }, reactor.getDelay());
                             }

src/main/java/server/maps/MapleMiniDungeon.java

@@ -19,16 +19,16 @@
 */
 package server.maps;
 
-import server.TimerManager;
 import client.MapleCharacter;
-
-import java.util.List;
-import java.util.ArrayList;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.locks.Lock;
-import tools.MaplePacketCreator;
 import net.server.audit.locks.MonitoredLockType;
 import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
+import server.TimerManager;
+import tools.MaplePacketCreator;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.locks.Lock;
 
 /**
  *
@@ -46,12 +46,7 @@ public class MapleMiniDungeon {
         baseMap = base;
         expireTime = timeLimit * 1000;
         
-        timeoutTask = TimerManager.getInstance().schedule(new Runnable() {
-            @Override
-            public void run() {
-                close();
-            }
-        }, expireTime);
+        timeoutTask = TimerManager.getInstance().schedule(() -> close(), expireTime);
         
         expireTime += System.currentTimeMillis();
     }

src/main/java/server/maps/MapleReactor.java

@@ -23,22 +23,20 @@ package server.maps;
 
 import client.MapleClient;
 import config.YamlConfig;
-
-import java.awt.Rectangle;
-import java.util.List;
-
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.locks.Lock;
+import net.server.audit.locks.MonitoredLockType;
 import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
-
+import net.server.services.task.channel.OverallService;
+import net.server.services.type.ChannelServices;
 import scripting.reactor.ReactorScriptManager;
 import server.TimerManager;
+import server.partyquest.GuardianSpawnPoint;
 import tools.MaplePacketCreator;
 import tools.Pair;
-import net.server.audit.locks.MonitoredLockType;
-import net.server.services.type.ChannelServices;
-import net.server.services.task.channel.OverallService;
-import server.partyquest.GuardianSpawnPoint;
+
+import java.awt.*;
+import java.util.List;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.locks.Lock;
 
 /**
  *
@@ -232,23 +230,15 @@ public class MapleReactor extends AbstractMapleMapObject {
         if (timeOut > -1) {
             final byte nextState = stats.getTimeoutState(state);
 
-            timeoutTask = TimerManager.getInstance().schedule(new Runnable() {
-                @Override
-                public void run() {
-                    timeoutTask = null;
-                    tryForceHitReactor(nextState);
-                }
+            timeoutTask = TimerManager.getInstance().schedule(() -> {
+                timeoutTask = null;
+                tryForceHitReactor(nextState);
             }, timeOut);
         }
     }
 
     public void delayedHitReactor(final MapleClient c, long delay) {
-        TimerManager.getInstance().schedule(new Runnable() {
-            @Override
-            public void run() {
-                hitReactor(c);
-            }
-        }, delay);
+        TimerManager.getInstance().schedule(() -> hitReactor(c), delay);
     }
 
     public void hitReactor(MapleClient c) {
@@ -371,12 +361,9 @@ public class MapleReactor extends AbstractMapleMapObject {
     }
     
     public void delayedRespawn() {
-        Runnable r = new Runnable() {
-            @Override
-            public void run() {
-                delayedRespawnRun = null;
-                respawn();
-            }
+        Runnable r = () -> {
+            delayedRespawnRun = null;
+            respawn();
         };
         
         delayedRespawnRun = r;

src/main/java/server/maps/MapleTVEffect.java

@@ -22,11 +22,12 @@
 package server.maps;
 
 import client.MapleCharacter;
-import java.util.List;
 import net.server.Server;
 import server.TimerManager;
 import tools.MaplePacketCreator;
 
+import java.util.List;
+
 /*
  * MapleTVEffect
  * @author MrXotic (XoticStory)
@@ -58,12 +59,7 @@ public class MapleTVEffect {
 			} else if (type == 5) {
 				delay = 60000;
 			}
-			TimerManager.getInstance().schedule(new Runnable() {
-				@Override
-				public void run() {
-					broadcastTV(false, userWorld, null, null, -1, null);
-				}
-			}, delay);
+			TimerManager.getInstance().schedule(() -> broadcastTV(false, userWorld, null, null, -1, null), delay);
 		} else {
 			server.broadcastMessage(userWorld, MaplePacketCreator.removeTV());
 		}

src/main/java/server/partyquest/AriantColiseum.java

@@ -19,12 +19,6 @@
 */
 package server.partyquest;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.concurrent.ScheduledFuture;
 import client.MapleCharacter;
 import constants.game.GameConstants;
 import server.TimerManager;
@@ -33,6 +27,13 @@ import server.expeditions.MapleExpeditionType;
 import server.maps.MapleMap;
 import tools.MaplePacketCreator;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.concurrent.ScheduledFuture;
+
 /**
  *
  * @author Ronan
@@ -78,26 +79,11 @@ public class AriantColiseum {
             mc.announce(MaplePacketCreator.updateAriantPQRanking(score));
         }
         
-        setAriantScoreBoard(TimerManager.getInstance().schedule(new Runnable() {
-            @Override
-            public void run() {
-                showArenaResults();
-            }
-        }, pqTimerBoard));
+        setAriantScoreBoard(TimerManager.getInstance().schedule(() -> showArenaResults(), pqTimerBoard));
         
-        setArenaFinish(TimerManager.getInstance().schedule(new Runnable() {
-            @Override
-            public void run() {
-                enterKingsRoom();
-            }
-        }, pqTimer));
+        setArenaFinish(TimerManager.getInstance().schedule(() -> enterKingsRoom(), pqTimer));
         
-        setArenaUpdate(TimerManager.getInstance().register(new Runnable() {
-            @Override
-            public void run() {
-                broadcastAriantScoreUpdate();
-            }
-        }, 500, 500));
+        setArenaUpdate(TimerManager.getInstance().register(() -> broadcastAriantScoreUpdate(), 500, 500));
     }
     
     private void setArenaUpdate(ScheduledFuture<?> ariantUpdate) {
@@ -289,13 +275,10 @@ public class AriantColiseum {
                 chr.changeMap(980010000, 0);
             }
             
-            map.getWorldServer().registerTimedMapObject(new Runnable() {
-                @Override
-                public void run() {
-                    score.clear();
-                    exped = null;
-                    map = null;
-                }
+            map.getWorldServer().registerTimedMapObject(() -> {
+                score.clear();
+                exped = null;
+                map = null;
             }, 5 * 60 * 1000);
         }
     }

src/main/java/server/partyquest/MonsterCarnival.java

@@ -1,6 +1,5 @@
 package server.partyquest;
 
-import java.util.concurrent.ScheduledFuture;
 import client.MapleCharacter;
 import config.YamlConfig;
 import constants.string.LanguageConstants;
@@ -13,6 +12,8 @@ import server.maps.MapleMap;
 import server.maps.MapleReactor;
 import tools.MaplePacketCreator;
 
+import java.util.concurrent.ScheduledFuture;
+
 /**
  * @author Drago (Dragohe4rt)
  */
@@ -95,24 +96,9 @@ public class MonsterCarnival {
             
             // thanks Atoot, Vcoc for noting double CPQ functional being sent to players in CPQ start
             
-            timer = TimerManager.getInstance().schedule(new Runnable() {
-                @Override
-                public void run() {
-                    timeUp();
-                }
-            }, map.getTimeDefault() * 1000); // thanks Atoot for noticing an irregular "event extended" issue here
-            effectTimer = TimerManager.getInstance().schedule(new Runnable() {
-                @Override
-                public void run() {
-                    complete();
-                }
-            }, map.getTimeDefault() * 1000 - 10 * 1000);
-            respawnTask = TimerManager.getInstance().register(new Runnable() {
-                @Override
-                public void run() {
-                    respawn();
-                }
-            }, YamlConfig.config.server.RESPAWN_INTERVAL);
+            timer = TimerManager.getInstance().schedule(() -> timeUp(), map.getTimeDefault() * 1000); // thanks Atoot for noticing an irregular "event extended" issue here
+            effectTimer = TimerManager.getInstance().schedule(() -> complete(), map.getTimeDefault() * 1000 - 10 * 1000);
+            respawnTask = TimerManager.getInstance().register(() -> respawn(), YamlConfig.config.server.RESPAWN_INTERVAL);
             
             cs.initMonsterCarnival(cpq1, room);
         } catch (Exception e) {
@@ -362,19 +348,8 @@ public class MonsterCarnival {
         
         map.broadcastMessage(MaplePacketCreator.getClock(3 * 60));
         
-        timer = TimerManager.getInstance().schedule(new Runnable() {
-            @Override
-            public void run() {
-                timeUp();
-            }
-        }, map.getTimeExpand() * 1000);
-        effectTimer = TimerManager.getInstance().schedule(new Runnable() {
-            @Override
-            public void run() {
-                complete();
-            }
-
-        }, map.getTimeExpand() * 1000 - 10 * 1000); // thanks Vcoc for noticing a time set issue here
+        timer = TimerManager.getInstance().schedule(() -> timeUp(), map.getTimeExpand() * 1000);
+        effectTimer = TimerManager.getInstance().schedule(() -> complete(), map.getTimeExpand() * 1000 - 10 * 1000); // thanks Vcoc for noticing a time set issue here
     }
 
     public void complete() {

src/main/java/server/partyquest/Pyramid.java

@@ -23,12 +23,13 @@
 package server.partyquest;
 
 import client.MapleCharacter;
-import java.util.concurrent.ScheduledFuture;
 import net.server.world.MapleParty;
 import server.MapleItemInformationProvider;
 import server.TimerManager;
 import tools.MaplePacketCreator;
 
+import java.util.concurrent.ScheduledFuture;
+
 /**
  *
  * @author kevintjuh93
@@ -79,13 +80,10 @@ public class Pyramid extends PartyQuest {
         if (gaugeSchedule == null) {
             gauge = 100;
             count = 0;
-            gaugeSchedule = TimerManager.getInstance().register(new Runnable() {
-                @Override
-                public void run() {
-                    gauge -= decrease;
-                    if (gauge <= 0) warp(926010001);
+            gaugeSchedule = TimerManager.getInstance().register(() -> {
+                gauge -= decrease;
+                if (gauge <= 0) warp(926010001);
 
-                }
             }, 1000);
         }
     }
@@ -125,13 +123,10 @@ public class Pyramid extends PartyQuest {
         else
             value = 120;
 
-        timer = TimerManager.getInstance().schedule(new Runnable() {
-                @Override
-                public void run() {
-                    stage++;
-                    warp(map + (stage * 100));//Should work :D
-                }
-            }, value * 1000);//, 4000
+        timer = TimerManager.getInstance().schedule(() -> {
+            stage++;
+            warp(map + (stage * 100));//Should work :D
+        }, value * 1000);//, 4000
         broadcastInfo("party", getParticipants().size() > 1 ? 1 : 0);
         broadcastInfo("hit", kill);
         broadcastInfo("miss", miss);

src/main/java/server/quest/actions/ItemAction.java

@@ -25,15 +25,10 @@ import client.MapleCharacter;
 import client.MapleClient;
 import client.inventory.Item;
 import client.inventory.MapleInventoryType;
+import client.inventory.manipulator.MapleInventoryManipulator;
 import constants.inventory.ItemConstants;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.LinkedList;
-import java.util.List;
 import provider.MapleData;
 import provider.MapleDataTool;
-import client.inventory.manipulator.MapleInventoryManipulator;
 import server.MapleItemInformationProvider;
 import server.quest.MapleQuest;
 import server.quest.MapleQuestActionType;
@@ -42,6 +37,11 @@ import tools.MaplePacketCreator;
 import tools.Pair;
 import tools.Randomizer;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
 /**
  *
  * @author Tyler (Twdtwd)
@@ -79,14 +79,7 @@ public class ItemAction extends MapleQuestAction {
 			items.add(new ItemData(Integer.parseInt(iEntry.getName()), id, count, prop, job, gender, period));
 		}
                 
-                Collections.sort(items, new Comparator<ItemData>()
-                {
-                    @Override
-                    public int compare( ItemData o1, ItemData o2 )
-                    {
-                        return o1.map - o2.map;
-                    }
-                });
+                Collections.sort(items, (o1, o2) -> o1.map - o2.map);
 	}
 	
 	@Override

src/main/java/tools/MaplePacketCreator.java

@@ -20,46 +20,12 @@
  */
 package tools;
 
-import java.awt.Point;
-import java.net.InetAddress;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import client.BuddylistEntry;
-import client.MapleBuffStat;
-import client.MapleCharacter;
+import client.*;
 import client.MapleCharacter.SkillEntry;
-import client.MapleClient;
-import client.MapleDisease;
-import client.MapleFamilyEntitlement;
-import client.MapleFamilyEntry;
+import client.inventory.*;
+import client.inventory.Equip.ScrollResult;
 import client.keybind.MapleKeyBinding;
 import client.keybind.MapleQuickslotBinding;
-import client.MapleMount;
-import client.MapleQuestStatus;
-import client.MapleRing;
-import client.MapleStat;
-import client.MonsterBook;
-import client.Skill;
-import client.SkillMacro;
-import client.inventory.Equip;
-import client.inventory.Equip.ScrollResult;
-import client.inventory.Item;
-import client.inventory.ItemFactory;
-import client.inventory.MapleInventory;
-import client.inventory.MapleInventoryType;
-import client.inventory.MaplePet;
-import client.inventory.ModifyInventory;
 import client.newyear.NewYearCardRecord;
 import client.status.MonsterStatus;
 import client.status.MonsterStatusEffect;
@@ -67,7 +33,6 @@ import config.YamlConfig;
 import constants.game.ExpTable;
 import constants.game.GameConstants;
 import constants.inventory.ItemConstants;
-import constants.net.ServerConstants;
 import constants.skills.Buccaneer;
 import constants.skills.Corsair;
 import constants.skills.ThunderBreaker;
@@ -88,35 +53,26 @@ import net.server.world.World;
 import server.CashShop.CashItem;
 import server.CashShop.CashItemFactory;
 import server.CashShop.SpecialCashItem;
-import server.DueyPackage;
-import server.MTSItemInfo;
-import server.MapleItemInformationProvider;
-import server.MapleShopItem;
-import server.MapleTrade;
+import server.*;
 import server.events.gm.MapleSnowball;
 import server.life.MapleMonster;
 import server.life.MapleNPC;
 import server.life.MaplePlayerNPC;
 import server.life.MobSkill;
-import server.maps.AbstractMapleMapObject;
-import server.maps.MapleDoor;
-import server.maps.MapleDoorObject;
-import server.maps.MapleDragon;
-import server.maps.MapleHiredMerchant;
-import server.maps.MapleMap;
-import server.maps.MapleMapItem;
-import server.maps.MapleMiniGame;
+import server.maps.*;
 import server.maps.MapleMiniGame.MiniGameResult;
-import server.maps.MapleMist;
-import server.maps.MaplePlayerShop;
-import server.maps.MaplePlayerShopItem;
-import server.maps.MapleReactor;
-import server.maps.MapleSummon;
 import server.movement.LifeMovementFragment;
 import tools.data.input.SeekableLittleEndianAccessor;
 import tools.data.output.LittleEndianWriter;
 import tools.data.output.MaplePacketLittleEndianWriter;
-import java.util.TimeZone;
+
+import java.awt.*;
+import java.net.InetAddress;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.*;
+import java.util.Map.Entry;
 
 /**
  *
@@ -1032,13 +988,10 @@ public class MaplePacketCreator {
                 }
                 List<Pair<MapleStat, Integer>> mystats = stats;
                 if (mystats.size() > 1) {
-                        Collections.sort(mystats, new Comparator<Pair<MapleStat, Integer>>() {
-                                @Override
-                                public int compare(Pair<MapleStat, Integer> o1, Pair<MapleStat, Integer> o2) {
-                                        int val1 = o1.getLeft().getValue();
-                                        int val2 = o2.getLeft().getValue();
-                                        return (val1 < val2 ? -1 : (val1 == val2 ? 0 : 1));
-                                }
+                        Collections.sort(mystats, (o1, o2) -> {
+                                int val1 = o1.getLeft().getValue();
+                                int val2 = o2.getLeft().getValue();
+                                return (val1 < val2 ? -1 : (val1 == val2 ? 0 : 1));
                         });
                 }
                 mplew.writeInt(updateMask);