Sweetgum/sweetgum-server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cleanup: replace anonymous inner class with lambda

Browse Source
This commit is contained in:
P0nk
2021-04-07 23:45:16 +02:00
parent 2d143d0afd
commit 6253169e35
65 changed files with 1204 additions and 2234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
src/main/java/net/server/Server.java
View File

@@ -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 {

24
src/main/java/net/server/audit/ThreadTracker.java
View File

@@ -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() {

28
src/main/java/net/server/audit/locks/active/TrackerReadLock.java
View File

@@ -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();

27
src/main/java/net/server/audit/locks/active/TrackerReentrantLock.java
View File

@@ -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();

28
src/main/java/net/server/audit/locks/active/TrackerWriteLock.java
View File

@@ -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();

49
src/main/java/net/server/channel/Channel.java
View File

@@ -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;

119
src/main/java/net/server/channel/handlers/AbstractDealDamageHandler.java
View File

@@ -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());

7
src/main/java/net/server/channel/handlers/PlayerLoggedinHandler.java
View File

@@ -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;
}

73
src/main/java/net/server/channel/handlers/UseCashItemHandler.java
View File

@@ -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());

13
src/main/java/net/server/channel/handlers/UseOwlOfMinervaHandler.java
View File

@@ -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) {

22
src/main/java/net/server/coordinator/partysearch/PartySearchStorage.java
View File

@@ -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();

28
src/main/java/net/server/coordinator/session/MapleSessionCoordinator.java
View File

@@ -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) {

46
src/main/java/net/server/coordinator/world/MapleMonsterAggroCoordinator.java
View File

@@ -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() {

26
src/main/java/net/server/services/BaseScheduler.java
View File

@@ -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() {

21
src/main/java/net/server/services/task/channel/FaceExpressionService.java
View File

@@ -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);
}
};

46
src/main/java/net/server/services/task/channel/MobAnimationService.java
View File

@@ -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() {

60
src/main/java/net/server/services/task/channel/MobStatusService.java
View File

@@ -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() {

27
src/main/java/net/server/world/MapleParty.java
View File

@@ -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() {

31
src/main/java/net/server/world/World.java
View File

@@ -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() {