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

Reformat and clean up "net" package

Browse Source
This commit is contained in:
P0nk
2021-09-09 23:26:02 +02:00
parent 69f4580637
commit 6be6ea9927
235 changed files with 3556 additions and 3398 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -33,166 +33,165 @@ import java.util.Map.Entry;
import java.util.concurrent.ScheduledFuture;
/**
*
* @author Ronan
*/
public abstract class BaseScheduler {
private int idleProcs = 0;
private List<SchedulerListener> listeners = new LinkedList<>();
private final List<SchedulerListener> listeners = new LinkedList<>();
private final List<MonitoredReentrantLock> externalLocks = new LinkedList<>();
private Map<Object, Pair<Runnable, Long>> registeredEntries = new HashMap<>();
private final Map<Object, Pair<Runnable, Long>> registeredEntries = new HashMap<>();
private ScheduledFuture<?> schedulerTask = null;
private MonitoredReentrantLock schedulerLock;
private Runnable monitorTask = () -> runBaseSchedule();
private final Runnable monitorTask = () -> runBaseSchedule();
protected BaseScheduler(MonitoredLockType lockType) {
schedulerLock = MonitoredReentrantLockFactory.createLock(lockType, true);
}
// NOTE: practice EXTREME caution when adding external locks to the scheduler system, if you don't know what you're doing DON'T USE THIS.
protected BaseScheduler(MonitoredLockType lockType, List<MonitoredReentrantLock> extLocks) {
schedulerLock = MonitoredReentrantLockFactory.createLock(lockType, true);
externalLocks.addAll(extLocks);
}
protected void addListener(SchedulerListener listener) {
listeners.add(listener);
}
private void lockScheduler() {
if(!externalLocks.isEmpty()) {
for(MonitoredReentrantLock l : externalLocks) {
if (!externalLocks.isEmpty()) {
for (MonitoredReentrantLock l : externalLocks) {
l.lock();
}
}
schedulerLock.lock();
}
private void unlockScheduler() {
if(!externalLocks.isEmpty()) {
for(MonitoredReentrantLock l : externalLocks) {
if (!externalLocks.isEmpty()) {
for (MonitoredReentrantLock l : externalLocks) {
l.unlock();
}
}
schedulerLock.unlock();
}
private void runBaseSchedule() {
List<Object> toRemove;
Map<Object, Pair<Runnable, Long>> registeredEntriesCopy;
lockScheduler();
try {
if(registeredEntries.isEmpty()) {
if (registeredEntries.isEmpty()) {
idleProcs++;
if(idleProcs >= YamlConfig.config.server.MOB_STATUS_MONITOR_LIFE) {
if(schedulerTask != null) {
if (idleProcs >= YamlConfig.config.server.MOB_STATUS_MONITOR_LIFE) {
if (schedulerTask != null) {
schedulerTask.cancel(false);
schedulerTask = null;
}
}
return;
}
idleProcs = 0;
registeredEntriesCopy = new HashMap<>(registeredEntries);
} finally {
unlockScheduler();
}
long timeNow = Server.getInstance().getCurrentTime();
toRemove = new LinkedList<>();
for(Entry<Object, Pair<Runnable, Long>> rmd : registeredEntriesCopy.entrySet()) {
for (Entry<Object, Pair<Runnable, Long>> rmd : registeredEntriesCopy.entrySet()) {
Pair<Runnable, Long> r = rmd.getValue();
if(r.getRight() < timeNow) {
if (r.getRight() < timeNow) {
r.getLeft().run(); // runs the scheduled action
toRemove.add(rmd.getKey());
}
}
if(!toRemove.isEmpty()) {
if (!toRemove.isEmpty()) {
lockScheduler();
try {
for(Object o : toRemove) {
for (Object o : toRemove) {
registeredEntries.remove(o);
}
} finally {
unlockScheduler();
}
}
dispatchRemovedEntries(toRemove, true);
}
protected void registerEntry(Object key, Runnable removalAction, long duration) {
lockScheduler();
try {
idleProcs = 0;
if(schedulerTask == null) {
if (schedulerTask == null) {
schedulerTask = TimerManager.getInstance().register(monitorTask, YamlConfig.config.server.MOB_STATUS_MONITOR_PROC, YamlConfig.config.server.MOB_STATUS_MONITOR_PROC);
}
registeredEntries.put(key, new Pair<>(removalAction, Server.getInstance().getCurrentTime() + duration));
} finally {
unlockScheduler();
}
}
protected void interruptEntry(Object key) {
Runnable toRun = null;
lockScheduler();
try {
Pair<Runnable, Long> rm = registeredEntries.remove(key);
if(rm != null) {
if (rm != null) {
toRun = rm.getLeft();
}
} finally {
unlockScheduler();
}
if(toRun != null) {
if (toRun != null) {
toRun.run();
}
dispatchRemovedEntries(Collections.singletonList(key), false);
}
private void dispatchRemovedEntries(List<Object> toRemove, boolean fromUpdate) {
for (SchedulerListener listener : listeners.toArray(new SchedulerListener[listeners.size()])) {
listener.removedScheduledEntries(toRemove, fromUpdate);
}
}
public void dispose() {
lockScheduler();
try {
if(schedulerTask != null) {
if (schedulerTask != null) {
schedulerTask.cancel(false);
schedulerTask = null;
}
listeners.clear();
registeredEntries.clear();
} finally {
unlockScheduler();
externalLocks.clear();
}
disposeLocks();
}
private void disposeLocks() {
LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
}
private void emptyLocks() {
schedulerLock = schedulerLock.dispose();
}

7
src/main/java/net/server/services/BaseService.java
View File

@@ -22,16 +22,15 @@ package net.server.services;
import config.YamlConfig;
/**
*
* @author Ronan
*/
public abstract class BaseService {
protected static int getChannelSchedulerIndex(int mapid) {
int section = 1000000000 / YamlConfig.config.server.CHANNEL_LOCKS;
return mapid / section;
}
public abstract void dispose();
}

1
src/main/java/net/server/services/SchedulerListener.java
View File

@@ -22,7 +22,6 @@ package net.server.services;
import java.util.List;
/**
*
* @author Ronan
*/
public interface SchedulerListener {

13
src/main/java/net/server/services/Service.java
View File

@@ -20,14 +20,13 @@
package net.server.services;
/**
*
* @author Ronan
*/
public class Service <T extends BaseService> {
public class Service<T extends BaseService> {
private Class<T> cls;
private BaseService service;
public Service(Class<T> s) {
try {
cls = s;
@@ -36,15 +35,15 @@ public class Service <T extends BaseService> {
e.printStackTrace();
}
}
public T getService() {
return cls.cast(service);
}
public void dispose() {
service.dispose();
service = null;
}
}

3
src/main/java/net/server/services/ServiceType.java
View File

@@ -20,10 +20,9 @@
package net.server.services;
/**
*
* @author Ronan
*/
public interface ServiceType <T extends Enum<?>> {
public interface ServiceType<T extends Enum<?>> {
Service createService();
int ordinal();
T[] enumValues();

13
src/main/java/net/server/services/ServicesManager.java
View File

@@ -20,31 +20,30 @@
package net.server.services;
/**
*
* @author Ronan
*/
public class ServicesManager {
private Service[] services;
public ServicesManager(ServiceType serviceBundle) {
Enum[] serviceTypes = serviceBundle.enumValues();
services = new Service[serviceTypes.length];
for (Enum type : serviceTypes) {
services[type.ordinal()] = ((ServiceType) type).createService();
}
}
public Service getAccess(ServiceType s) {
return services[s.ordinal()];
}
public void shutdown() {
for (Service service : services) {
service.dispose();
}
services = null;
}
}

25
src/main/java/net/server/services/task/channel/EventService.java
View File

@@ -25,35 +25,34 @@ import net.server.services.BaseScheduler;
import net.server.services.BaseService;
/**
*
* @author Ronan
*/
public class EventService extends BaseService {
private EventScheduler[] eventSchedulers = new EventScheduler[YamlConfig.config.server.CHANNEL_LOCKS];
private final EventScheduler[] eventSchedulers = new EventScheduler[YamlConfig.config.server.CHANNEL_LOCKS];
public EventService() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
eventSchedulers[i] = new EventScheduler();
}
}
@Override
public void dispose() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
if(eventSchedulers[i] != null) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
if (eventSchedulers[i] != null) {
eventSchedulers[i].dispose();
eventSchedulers[i] = null;
}
}
}
public void registerEventAction(int mapid, Runnable runAction, long delay) {
eventSchedulers[getChannelSchedulerIndex(mapid)].registerDelayedAction(runAction, delay);
}
private class EventScheduler extends BaseScheduler {
public EventScheduler() {
super(MonitoredLockType.CHANNEL_EVENTS);
}
@@ -61,7 +60,7 @@ public class EventService extends BaseService {
public void registerDelayedAction(Runnable runAction, long delay) {
registerEntry(runAction, runAction, delay);
}
}
}

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

@@ -33,69 +33,68 @@ import tools.PacketCreator;
import java.util.Collections;
/**
*
* @author Ronan
*/
public class FaceExpressionService extends BaseService {
private FaceExpressionScheduler[] faceExpressionSchedulers = new FaceExpressionScheduler[YamlConfig.config.server.CHANNEL_LOCKS];
private MonitoredReentrantLock[] faceLock = new MonitoredReentrantLock[YamlConfig.config.server.CHANNEL_LOCKS];
private final FaceExpressionScheduler[] faceExpressionSchedulers = new FaceExpressionScheduler[YamlConfig.config.server.CHANNEL_LOCKS];
private final MonitoredReentrantLock[] faceLock = new MonitoredReentrantLock[YamlConfig.config.server.CHANNEL_LOCKS];
public FaceExpressionService() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
faceLock[i] = MonitoredReentrantLockFactory.createLock(MonitoredLockType.CHANNEL_FACEEXPRS, true);
faceExpressionSchedulers[i] = new FaceExpressionScheduler(faceLock[i]);
}
}
private void emptyLocks() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
faceLock[i] = faceLock[i].dispose();
}
}
private void disposeLocks() {
LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
}
@Override
public void dispose() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
if(faceExpressionSchedulers[i] != null) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
if (faceExpressionSchedulers[i] != null) {
faceExpressionSchedulers[i].dispose();
faceExpressionSchedulers[i] = null;
}
}
disposeLocks();
}
public void registerFaceExpression(final MapleMap map, final Character chr, int emote) {
int lockid = getChannelSchedulerIndex(map.getId());
Runnable cancelAction = () -> {
if(chr.isLoggedinWorld()) {
if (chr.isLoggedinWorld()) {
map.broadcastMessage(chr, PacketCreator.facialExpression(chr, 0), false);
}
};
faceLock[lockid].lock();
try {
if(!chr.isLoggedinWorld()) {
if (!chr.isLoggedinWorld()) {
return;
}
faceExpressionSchedulers[lockid].registerFaceExpression(chr.getId(), cancelAction);
} finally {
faceLock[lockid].unlock();
}
map.broadcastMessage(chr, PacketCreator.facialExpression(chr, emote), false);
}
public void unregisterFaceExpression(int mapid, Character chr) {
int lockid = getChannelSchedulerIndex(mapid);
faceLock[lockid].lock();
try {
faceExpressionSchedulers[lockid].unregisterFaceExpression(chr.getId());
@@ -103,9 +102,9 @@ public class FaceExpressionService extends BaseService {
faceLock[lockid].unlock();
}
}
private class FaceExpressionScheduler extends BaseScheduler {
public FaceExpressionScheduler(final MonitoredReentrantLock channelFaceLock) {
super(MonitoredLockType.CHANNEL_FACESCHDL, Collections.singletonList(channelFaceLock));
}
@@ -117,7 +116,7 @@ public class FaceExpressionService extends BaseService {
public void unregisterFaceExpression(Integer characterId) {
interruptEntry(characterId);
}
}
}

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

@@ -31,47 +31,47 @@ import java.util.HashSet;
import java.util.Set;
/**
*
* @author Ronan
*/
public class MobAnimationService extends BaseService {
private MobAnimationScheduler[] mobAnimationSchedulers = new MobAnimationScheduler[YamlConfig.config.server.CHANNEL_LOCKS];
private final MobAnimationScheduler[] mobAnimationSchedulers = new MobAnimationScheduler[YamlConfig.config.server.CHANNEL_LOCKS];
public MobAnimationService() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
mobAnimationSchedulers[i] = new MobAnimationScheduler();
}
}
@Override
public void dispose() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
if(mobAnimationSchedulers[i] != null) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
if (mobAnimationSchedulers[i] != null) {
mobAnimationSchedulers[i].dispose();
mobAnimationSchedulers[i] = null;
}
}
}
public boolean registerMobOnAnimationEffect(int mapid, int mobHash, long delay) {
return mobAnimationSchedulers[getChannelSchedulerIndex(mapid)].registerAnimationMode(mobHash, delay);
}
// do nothing
private static Runnable r = () -> {};
private static final Runnable r = () -> {
};
private class MobAnimationScheduler extends BaseScheduler {
Set<Integer> onAnimationMobs = new HashSet<>(1000);
private MonitoredReentrantLock animationLock = MonitoredReentrantLockFactory.createLock(MonitoredLockType.CHANNEL_MOBANIMAT, true);
public MobAnimationScheduler() {
super(MonitoredLockType.CHANNEL_MOBACTION);
super.addListener((toRemove, update) -> {
animationLock.lock();
try {
for(Object hashObj : toRemove) {
for (Object hashObj : toRemove) {
Integer mobHash = (Integer) hashObj;
onAnimationMobs.remove(mobHash);
}
@@ -84,7 +84,7 @@ public class MobAnimationService extends BaseService {
public boolean registerAnimationMode(Integer mobHash, long animationTime) {
animationLock.lock();
try {
if(onAnimationMobs.contains(mobHash)) {
if (onAnimationMobs.contains(mobHash)) {
return false;
}
@@ -109,7 +109,7 @@ public class MobAnimationService extends BaseService {
private void emptyLocks() {
animationLock = animationLock.dispose();
}
}
}

27
src/main/java/net/server/services/task/channel/MobClearSkillService.java
View File

@@ -25,35 +25,34 @@ import net.server.services.BaseScheduler;
import net.server.services.BaseService;
/**
*
* @author Ronan
*/
public class MobClearSkillService extends BaseService {
private MobClearSkillScheduler[] mobClearSkillSchedulers = new MobClearSkillScheduler[YamlConfig.config.server.CHANNEL_LOCKS];
private final MobClearSkillScheduler[] mobClearSkillSchedulers = new MobClearSkillScheduler[YamlConfig.config.server.CHANNEL_LOCKS];
public MobClearSkillService() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
mobClearSkillSchedulers[i] = new MobClearSkillScheduler();
}
}
@Override
public void dispose() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
if(mobClearSkillSchedulers[i] != null) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
if (mobClearSkillSchedulers[i] != null) {
mobClearSkillSchedulers[i].dispose();
mobClearSkillSchedulers[i] = null;
}
}
}
}
public void registerMobClearSkillAction(int mapid, Runnable runAction, long delay) {
mobClearSkillSchedulers[getChannelSchedulerIndex(mapid)].registerClearSkillAction(runAction, delay);
}
private class MobClearSkillScheduler extends BaseScheduler {
public MobClearSkillScheduler() {
super(MonitoredLockType.CHANNEL_MOBSKILL);
}
@@ -61,7 +60,7 @@ public class MobClearSkillService extends BaseService {
public void registerClearSkillAction(Runnable runAction, long delay) {
registerEntry(runAction, runAction, delay);
}
}
}

25
src/main/java/net/server/services/task/channel/MobMistService.java
View File

@@ -25,33 +25,32 @@ import net.server.services.BaseScheduler;
import net.server.services.BaseService;
/**
*
* @author Ronan
*/
public class MobMistService extends BaseService {
private MobMistScheduler[] mobMistSchedulers = new MobMistScheduler[YamlConfig.config.server.CHANNEL_LOCKS];
private final MobMistScheduler[] mobMistSchedulers = new MobMistScheduler[YamlConfig.config.server.CHANNEL_LOCKS];
public MobMistService() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
mobMistSchedulers[i] = new MobMistScheduler();
}
}
@Override
public void dispose() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
if(mobMistSchedulers[i] != null) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
if (mobMistSchedulers[i] != null) {
mobMistSchedulers[i].dispose();
mobMistSchedulers[i] = null;
}
}
}
}
public void registerMobMistCancelAction(int mapid, Runnable runAction, long delay) {
mobMistSchedulers[getChannelSchedulerIndex(mapid)].registerMistCancelAction(runAction, delay);
}
private class MobMistScheduler extends BaseScheduler {
public MobMistScheduler() {
@@ -61,7 +60,7 @@ public class MobMistService extends BaseService {
public void registerMistCancelAction(Runnable runAction, long delay) {
registerEntry(runAction, runAction, delay);
}
}
}

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

@@ -34,60 +34,59 @@ import java.util.List;
import java.util.Map;
/**
*
* @author Ronan
*/
public class MobStatusService extends BaseService {
private MobStatusScheduler[] mobStatusSchedulers = new MobStatusScheduler[YamlConfig.config.server.CHANNEL_LOCKS];
private final MobStatusScheduler[] mobStatusSchedulers = new MobStatusScheduler[YamlConfig.config.server.CHANNEL_LOCKS];
public MobStatusService() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
mobStatusSchedulers[i] = new MobStatusScheduler();
}
}
@Override
public void dispose() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
if(mobStatusSchedulers[i] != null) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
if (mobStatusSchedulers[i] != null) {
mobStatusSchedulers[i].dispose();
mobStatusSchedulers[i] = null;
}
}
}
public void registerMobStatus(int mapid, MonsterStatusEffect mse, Runnable cancelAction, long duration) {
registerMobStatus(mapid, mse, cancelAction, duration, null, -1);
}
public void registerMobStatus(int mapid, MonsterStatusEffect mse, Runnable cancelAction, long duration, Runnable overtimeAction, int overtimeDelay) {
mobStatusSchedulers[getChannelSchedulerIndex(mapid)].registerMobStatus(mse, cancelAction, duration, overtimeAction, overtimeDelay);
}
public void interruptMobStatus(int mapid, MonsterStatusEffect mse) {
mobStatusSchedulers[getChannelSchedulerIndex(mapid)].interruptMobStatus(mse);
}
private class MobStatusScheduler extends BaseScheduler {
private Map<MonsterStatusEffect, MobStatusOvertimeEntry> registeredMobStatusOvertime = new HashMap<>();
private final Map<MonsterStatusEffect, MobStatusOvertimeEntry> registeredMobStatusOvertime = new HashMap<>();
private MonitoredReentrantLock overtimeStatusLock = MonitoredReentrantLockFactory.createLock(MonitoredLockType.CHANNEL_OVTSTATUS, true);
private class MobStatusOvertimeEntry {
private int procCount;
private int procLimit;
private Runnable r;
private final int procLimit;
private final Runnable r;
protected MobStatusOvertimeEntry(int delay, Runnable run) {
procCount = 0;
procLimit = (int)Math.ceil((float) delay / YamlConfig.config.server.MOB_STATUS_MONITOR_PROC);
procLimit = (int) Math.ceil((float) delay / YamlConfig.config.server.MOB_STATUS_MONITOR_PROC);
r = run;
}
protected void update(List<Runnable> toRun) {
procCount++;
if(procCount >= procLimit) {
if (procCount >= procLimit) {
procCount = 0;
toRun.add(r);
}
@@ -102,15 +101,15 @@ public class MobStatusService extends BaseService {
overtimeStatusLock.lock();
try {
for(Object mseo : toRemove) {
for (Object mseo : toRemove) {
MonsterStatusEffect mse = (MonsterStatusEffect) mseo;
registeredMobStatusOvertime.remove(mse);
}
if(update) {
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) {
for (MobStatusOvertimeEntry mdoe : mdoeList) {
mdoe.update(toRun);
}
}
@@ -118,14 +117,14 @@ public class MobStatusService extends BaseService {
overtimeStatusLock.unlock();
}
for(Runnable r : toRun) {
for (Runnable r : toRun) {
r.run();
}
});
}
public void registerMobStatus(MonsterStatusEffect mse, Runnable cancelStatus, long duration, Runnable overtimeStatus, int overtimeDelay) {
if(overtimeStatus != null) {
if (overtimeStatus != null) {
MobStatusOvertimeEntry mdoe = new MobStatusOvertimeEntry(overtimeDelay, overtimeStatus);
overtimeStatusLock.lock();
@@ -156,7 +155,7 @@ public class MobStatusService extends BaseService {
private void emptyLocks() {
overtimeStatusLock = overtimeStatusLock.dispose();
}
}
}

29
src/main/java/net/server/services/task/channel/OverallService.java
View File

@@ -25,40 +25,39 @@ import net.server.services.BaseScheduler;
import net.server.services.BaseService;
/**
*
* @author Ronan
*/
public class OverallService extends BaseService { // thanks Alex for suggesting a refactor over the several channel schedulers unnecessarily populating the Channel class
private OverallScheduler[] channelSchedulers = new OverallScheduler[YamlConfig.config.server.CHANNEL_LOCKS];
private final OverallScheduler[] channelSchedulers = new OverallScheduler[YamlConfig.config.server.CHANNEL_LOCKS];
public OverallService() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
channelSchedulers[i] = new OverallScheduler();
}
}
@Override
public void dispose() {
for(int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
if(channelSchedulers[i] != null) {
for (int i = 0; i < YamlConfig.config.server.CHANNEL_LOCKS; i++) {
if (channelSchedulers[i] != null) {
channelSchedulers[i].dispose();
channelSchedulers[i] = null;
}
}
}
public void registerOverallAction(int mapid, Runnable runAction, long delay) {
channelSchedulers[getChannelSchedulerIndex(mapid)].registerDelayedAction(runAction, delay);
}
public void forceRunOverallAction(int mapid, Runnable runAction) {
channelSchedulers[getChannelSchedulerIndex(mapid)].forceRunDelayedAction(runAction);
}
public class OverallScheduler extends BaseScheduler {
public OverallScheduler() {
super(MonitoredLockType.CHANNEL_OVERALL);
}
@@ -70,7 +69,7 @@ public class OverallService extends BaseService { // thanks Alex for suggestin
public void forceRunDelayedAction(Runnable runAction) {
interruptEntry(runAction);
}
}
}

17
src/main/java/net/server/services/task/world/CharacterSaveService.java
View File

@@ -24,27 +24,26 @@ import net.server.services.BaseScheduler;
import net.server.services.BaseService;
/**
*
* @author Ronan
*/
public class CharacterSaveService extends BaseService {
CharacterSaveScheduler chrSaveScheduler = new CharacterSaveScheduler();
@Override
public void dispose() {
if(chrSaveScheduler != null) {
if (chrSaveScheduler != null) {
chrSaveScheduler.dispose();
chrSaveScheduler = null;
}
}
public void registerSaveCharacter(int characterId, Runnable runAction) {
chrSaveScheduler.registerSaveCharacter(characterId, runAction);
}
private class CharacterSaveScheduler extends BaseScheduler {
public CharacterSaveScheduler() {
super(MonitoredLockType.WORLD_SAVECHARS);
}
@@ -56,7 +55,7 @@ public class CharacterSaveService extends BaseService {
public void unregisterSaveCharacter(Integer characterId) {
interruptEntry(characterId);
}
}
}

27
src/main/java/net/server/services/type/ChannelServices.java
View File

@@ -19,23 +19,16 @@
*/
package net.server.services.type;
import net.server.services.ServiceType;
import net.server.services.task.channel.EventService;
import net.server.services.task.channel.FaceExpressionService;
import net.server.services.task.channel.MobAnimationService;
import net.server.services.task.channel.MobClearSkillService;
import net.server.services.task.channel.MobMistService;
import net.server.services.task.channel.MobStatusService;
import net.server.services.task.channel.OverallService;
import net.server.services.BaseService;
import net.server.services.Service;
import net.server.services.ServiceType;
import net.server.services.task.channel.*;
/**
*
* @author Ronan
*/
public enum ChannelServices implements ServiceType {
MOB_STATUS(MobStatusService.class),
MOB_ANIMATION(MobAnimationService.class),
MOB_CLEAR_SKILL(MobClearSkillService.class),
@@ -43,21 +36,21 @@ public enum ChannelServices implements ServiceType {
FACE_EXPRESSION(FaceExpressionService.class),
EVENT(EventService.class),
OVERALL(OverallService.class);
private Class<? extends BaseService> s;
private ChannelServices(Class<? extends BaseService> service) {
private final Class<? extends BaseService> s;
ChannelServices(Class<? extends BaseService> service) {
s = service;
}
@Override
public Service createService() {
return new Service(s);
}
@Override
public ChannelServices[] enumValues() {
return ChannelServices.values();
}
}

19
src/main/java/net/server/services/type/WorldServices.java
View File

@@ -19,33 +19,32 @@
*/
package net.server.services.type;
import net.server.services.ServiceType;
import net.server.services.BaseService;
import net.server.services.Service;
import net.server.services.ServiceType;
import net.server.services.task.world.CharacterSaveService;
/**
*
* @author Ronan
*/
public enum WorldServices implements ServiceType {
SAVE_CHARACTER(CharacterSaveService.class);
private Class<? extends BaseService> s;
private WorldServices(Class<? extends BaseService> service) {
private final Class<? extends BaseService> s;
WorldServices(Class<? extends BaseService> service) {
s = service;
}
@Override
public Service createService() {
return new Service(s);
}
@Override
public WorldServices[] enumValues() {
return WorldServices.values();
}
}