diff --git a/src/main/java/client/Character.java b/src/main/java/client/Character.java
index 07491a5deb..8a14edd62a 100644
--- a/src/main/java/client/Character.java
+++ b/src/main/java/client/Character.java
@@ -1876,7 +1876,7 @@ public class Character extends AbstractCharacterObject {
                     List<Character> pchr = this.getPartyMembersOnSameMap();
 
                     if (!ItemConstants.isPartyAllcure(itemid)) {
-                        MapleStatEffect mse = ii.getItemEffect(itemid);
+                        StatEffect mse = ii.getItemEffect(itemid);
 
                         if (!pchr.isEmpty()) {
                             for (Character mc : pchr) {
@@ -3332,7 +3332,7 @@ public class Character extends AbstractCharacterObject {
         }
     }
 
-    public MapleStatEffect getBuffEffect(BuffStat stat) {
+    public StatEffect getBuffEffect(BuffStat stat) {
         effLock.lock();
         chrLock.lock();
         try {
@@ -3633,7 +3633,7 @@ public class Character extends AbstractCharacterObject {
                 effLock.unlock();
             }
         } else {
-            Map<MapleStatEffect, Long> mseBuffs = new LinkedHashMap<>();
+            Map<StatEffect, Long> mseBuffs = new LinkedHashMap<>();
 
             effLock.lock();
             chrLock.lock();
@@ -3648,7 +3648,7 @@ public class Character extends AbstractCharacterObject {
                 effLock.unlock();
             }
 
-            for (Entry<MapleStatEffect, Long> mse : mseBuffs.entrySet()) {
+            for (Entry<StatEffect, Long> mse : mseBuffs.entrySet()) {
                 cancelEffect(mse.getKey(), false, mse.getValue());
             }
         }
@@ -3758,7 +3758,7 @@ public class Character extends AbstractCharacterObject {
         cancelEffect(ii.getItemEffect(itemId), false, -1);
     }
 
-    public boolean cancelEffect(MapleStatEffect effect, boolean overwrite, long startTime) {
+    public boolean cancelEffect(StatEffect effect, boolean overwrite, long startTime) {
         boolean ret;
 
         prtLock.lock();
@@ -3786,7 +3786,7 @@ public class Character extends AbstractCharacterObject {
         return ret;
     }
 
-    private static MapleStatEffect getEffectFromBuffSource(Map<BuffStat, MapleBuffStatValueHolder> buffSource) {
+    private static StatEffect getEffectFromBuffSource(Map<BuffStat, MapleBuffStatValueHolder> buffSource) {
         try {
             return buffSource.entrySet().iterator().next().getValue().effect;
         } catch (Exception e) {
@@ -3794,7 +3794,7 @@ public class Character extends AbstractCharacterObject {
         }
     }
 
-    private boolean isUpdatingEffect(Set<MapleStatEffect> activeEffects, MapleStatEffect mse) {
+    private boolean isUpdatingEffect(Set<StatEffect> activeEffects, StatEffect mse) {
         if (mse == null) {
             return false;
         }
@@ -3812,14 +3812,14 @@ public class Character extends AbstractCharacterObject {
         effLock.lock();     // thanks davidlafriniere, maple006, RedHat for pointing a deadlock occurring here
         try {
             Set<BuffStat> updatedBuffs = new LinkedHashSet<>();
-            Set<MapleStatEffect> activeEffects = new LinkedHashSet<>();
+            Set<StatEffect> activeEffects = new LinkedHashSet<>();
 
             for (MapleBuffStatValueHolder mse : effects.values()) {
                 activeEffects.add(mse.effect);
             }
 
             for (Map<BuffStat, MapleBuffStatValueHolder> buff : buffEffects.values()) {
-                MapleStatEffect mse = getEffectFromBuffSource(buff);
+                StatEffect mse = getEffectFromBuffSource(buff);
                 if (isUpdatingEffect(activeEffects, mse)) {
                     for (Pair<BuffStat, Integer> p : mse.getStatups()) {
                         updatedBuffs.add(p.getLeft());
@@ -3854,14 +3854,14 @@ public class Character extends AbstractCharacterObject {
                 }
             }
 
-            propagateBuffEffectUpdates(new LinkedHashMap<Integer, Pair<MapleStatEffect, Long>>(), retrievedStats, removedStats);
+            propagateBuffEffectUpdates(new LinkedHashMap<Integer, Pair<StatEffect, Long>>(), retrievedStats, removedStats);
         } finally {
             chrLock.unlock();
             effLock.unlock();
         }
     }
 
-    private boolean cancelEffect(MapleStatEffect effect, boolean overwrite, long startTime, boolean firstCancel) {
+    private boolean cancelEffect(StatEffect effect, boolean overwrite, long startTime, boolean firstCancel) {
         Set<BuffStat> removedStats = new LinkedHashSet<>();
         dropBuffStats(cancelEffectInternal(effect, overwrite, startTime, removedStats));
         updateLocalStats();
@@ -3870,7 +3870,7 @@ public class Character extends AbstractCharacterObject {
         return !removedStats.isEmpty();
     }
 
-    private List<Pair<BuffStat, MapleBuffStatValueHolder>> cancelEffectInternal(MapleStatEffect effect, boolean overwrite, long startTime, Set<BuffStat> removedStats) {
+    private List<Pair<BuffStat, MapleBuffStatValueHolder>> cancelEffectInternal(StatEffect effect, boolean overwrite, long startTime, Set<BuffStat> removedStats) {
         Map<BuffStat, MapleBuffStatValueHolder> buffstats = null;
         BuffStat ombs;
         if (!overwrite) {   // is removing the source effect, meaning every effect from this srcid is being purged
@@ -3949,7 +3949,7 @@ public class Character extends AbstractCharacterObject {
         cancelPlayerBuffs(Arrays.asList(stat));
     }
 
-    private Map<BuffStat, MapleBuffStatValueHolder> extractCurrentBuffStats(MapleStatEffect effect) {
+    private Map<BuffStat, MapleBuffStatValueHolder> extractCurrentBuffStats(StatEffect effect) {
         chrLock.lock();
         try {
             Map<BuffStat, MapleBuffStatValueHolder> stats = new LinkedHashMap<>();
@@ -3968,7 +3968,7 @@ public class Character extends AbstractCharacterObject {
         }
     }
 
-    private Map<BuffStat, MapleBuffStatValueHolder> extractLeastRelevantStatEffectsIfFull(MapleStatEffect effect) {
+    private Map<BuffStat, MapleBuffStatValueHolder> extractLeastRelevantStatEffectsIfFull(StatEffect effect) {
         Map<BuffStat, MapleBuffStatValueHolder> extractedStatBuffs = new LinkedHashMap<>();
 
         chrLock.lock();
@@ -4035,16 +4035,16 @@ public class Character extends AbstractCharacterObject {
         }
     }
 
-    private static Map<MapleStatEffect, Integer> topologicalSortLeafStatCount(Map<BuffStat, Stack<MapleStatEffect>> buffStack) {
-        Map<MapleStatEffect, Integer> leafBuffCount = new LinkedHashMap<>();
+    private static Map<StatEffect, Integer> topologicalSortLeafStatCount(Map<BuffStat, Stack<StatEffect>> buffStack) {
+        Map<StatEffect, Integer> leafBuffCount = new LinkedHashMap<>();
 
-        for (Entry<BuffStat, Stack<MapleStatEffect>> e : buffStack.entrySet()) {
-            Stack<MapleStatEffect> mseStack = e.getValue();
+        for (Entry<BuffStat, Stack<StatEffect>> e : buffStack.entrySet()) {
+            Stack<StatEffect> mseStack = e.getValue();
             if (mseStack.isEmpty()) {
                 continue;
             }
 
-            MapleStatEffect mse = mseStack.peek();
+            StatEffect mse = mseStack.peek();
             Integer count = leafBuffCount.get(mse);
             if (count == null) {
                 leafBuffCount.put(mse, 1);
@@ -4056,12 +4056,12 @@ public class Character extends AbstractCharacterObject {
         return leafBuffCount;
     }
 
-    private static List<MapleStatEffect> topologicalSortRemoveLeafStats(Map<MapleStatEffect, Set<BuffStat>> stackedBuffStats, Map<BuffStat, Stack<MapleStatEffect>> buffStack, Map<MapleStatEffect, Integer> leafStatCount) {
-        List<MapleStatEffect> clearedStatEffects = new LinkedList<>();
+    private static List<StatEffect> topologicalSortRemoveLeafStats(Map<StatEffect, Set<BuffStat>> stackedBuffStats, Map<BuffStat, Stack<StatEffect>> buffStack, Map<StatEffect, Integer> leafStatCount) {
+        List<StatEffect> clearedStatEffects = new LinkedList<>();
         Set<BuffStat> clearedStats = new LinkedHashSet<>();
 
-        for (Entry<MapleStatEffect, Integer> e : leafStatCount.entrySet()) {
-            MapleStatEffect mse = e.getKey();
+        for (Entry<StatEffect, Integer> e : leafStatCount.entrySet()) {
+            StatEffect mse = e.getKey();
 
             if (stackedBuffStats.get(mse).size() <= e.getValue()) {
                 clearedStatEffects.add(mse);
@@ -4073,36 +4073,36 @@ public class Character extends AbstractCharacterObject {
         }
 
         for (BuffStat mbs : clearedStats) {
-            MapleStatEffect mse = buffStack.get(mbs).pop();
+            StatEffect mse = buffStack.get(mbs).pop();
             stackedBuffStats.get(mse).remove(mbs);
         }
 
         return clearedStatEffects;
     }
 
-    private static void topologicalSortRebaseLeafStats(Map<MapleStatEffect, Set<BuffStat>> stackedBuffStats, Map<BuffStat, Stack<MapleStatEffect>> buffStack) {
-        for (Entry<BuffStat, Stack<MapleStatEffect>> e : buffStack.entrySet()) {
-            Stack<MapleStatEffect> mseStack = e.getValue();
+    private static void topologicalSortRebaseLeafStats(Map<StatEffect, Set<BuffStat>> stackedBuffStats, Map<BuffStat, Stack<StatEffect>> buffStack) {
+        for (Entry<BuffStat, Stack<StatEffect>> e : buffStack.entrySet()) {
+            Stack<StatEffect> mseStack = e.getValue();
 
             if (!mseStack.isEmpty()) {
-                MapleStatEffect mse = mseStack.pop();
+                StatEffect mse = mseStack.pop();
                 stackedBuffStats.get(mse).remove(e.getKey());
             }
         }
     }
 
-    private static List<MapleStatEffect> topologicalSortEffects(Map<BuffStat, List<Pair<MapleStatEffect, Integer>>> buffEffects) {
-        Map<MapleStatEffect, Set<BuffStat>> stackedBuffStats = new LinkedHashMap<>();
-        Map<BuffStat, Stack<MapleStatEffect>> buffStack = new LinkedHashMap<>();
+    private static List<StatEffect> topologicalSortEffects(Map<BuffStat, List<Pair<StatEffect, Integer>>> buffEffects) {
+        Map<StatEffect, Set<BuffStat>> stackedBuffStats = new LinkedHashMap<>();
+        Map<BuffStat, Stack<StatEffect>> buffStack = new LinkedHashMap<>();
 
-        for (Entry<BuffStat, List<Pair<MapleStatEffect, Integer>>> e : buffEffects.entrySet()) {
+        for (Entry<BuffStat, List<Pair<StatEffect, Integer>>> e : buffEffects.entrySet()) {
             BuffStat mbs = e.getKey();
 
-            Stack<MapleStatEffect> mbsStack = new Stack<>();
+            Stack<StatEffect> mbsStack = new Stack<>();
             buffStack.put(mbs, mbsStack);
 
-            for (Pair<MapleStatEffect, Integer> emse : e.getValue()) {
-                MapleStatEffect mse = emse.getLeft();
+            for (Pair<StatEffect, Integer> emse : e.getValue()) {
+                StatEffect mse = emse.getLeft();
                 mbsStack.push(mse);
 
                 Set<BuffStat> mbsStats = stackedBuffStats.get(mse);
@@ -4115,14 +4115,14 @@ public class Character extends AbstractCharacterObject {
             }
         }
 
-        List<MapleStatEffect> buffList = new LinkedList<>();
+        List<StatEffect> buffList = new LinkedList<>();
         while (true) {
-            Map<MapleStatEffect, Integer> leafStatCount = topologicalSortLeafStatCount(buffStack);
+            Map<StatEffect, Integer> leafStatCount = topologicalSortLeafStatCount(buffStack);
             if (leafStatCount.isEmpty()) {
                 break;
             }
 
-            List<MapleStatEffect> clearedNodes = topologicalSortRemoveLeafStats(stackedBuffStats, buffStack, leafStatCount);
+            List<StatEffect> clearedNodes = topologicalSortRemoveLeafStats(stackedBuffStats, buffStack, leafStatCount);
             if (clearedNodes.isEmpty()) {
                 topologicalSortRebaseLeafStats(stackedBuffStats, buffStack);
             } else {
@@ -4133,16 +4133,16 @@ public class Character extends AbstractCharacterObject {
         return buffList;
     }
 
-    private static List<MapleStatEffect> sortEffectsList(Map<MapleStatEffect, Integer> updateEffectsList) {
-        Map<BuffStat, List<Pair<MapleStatEffect, Integer>>> buffEffects = new LinkedHashMap<>();
+    private static List<StatEffect> sortEffectsList(Map<StatEffect, Integer> updateEffectsList) {
+        Map<BuffStat, List<Pair<StatEffect, Integer>>> buffEffects = new LinkedHashMap<>();
 
-        for (Entry<MapleStatEffect, Integer> p : updateEffectsList.entrySet()) {
-            MapleStatEffect mse = p.getKey();
+        for (Entry<StatEffect, Integer> p : updateEffectsList.entrySet()) {
+            StatEffect mse = p.getKey();
 
             for (Pair<BuffStat, Integer> statup : mse.getStatups()) {
                 BuffStat stat = statup.getLeft();
 
-                List<Pair<MapleStatEffect, Integer>> statBuffs = buffEffects.get(stat);
+                List<Pair<StatEffect, Integer>> statBuffs = buffEffects.get(stat);
                 if (statBuffs == null) {
                     statBuffs = new ArrayList<>();
                     buffEffects.put(stat, statBuffs);
@@ -4152,23 +4152,23 @@ public class Character extends AbstractCharacterObject {
             }
         }
 
-        Comparator cmp = new Comparator<Pair<MapleStatEffect, Integer>>() {
+        Comparator cmp = new Comparator<Pair<StatEffect, Integer>>() {
             @Override
-            public int compare(Pair<MapleStatEffect, Integer> o1, Pair<MapleStatEffect, Integer> o2) {
+            public int compare(Pair<StatEffect, Integer> o1, Pair<StatEffect, Integer> o2) {
                 return o2.getRight().compareTo(o1.getRight());
             }
         };
 
-        for (Entry<BuffStat, List<Pair<MapleStatEffect, Integer>>> statBuffs : buffEffects.entrySet()) {
+        for (Entry<BuffStat, List<Pair<StatEffect, Integer>>> statBuffs : buffEffects.entrySet()) {
             Collections.sort(statBuffs.getValue(), cmp);
         }
 
         return topologicalSortEffects(buffEffects);
     }
 
-    private List<Pair<Integer, Pair<MapleStatEffect, Long>>> propagatePriorityBuffEffectUpdates(Set<BuffStat> retrievedStats) {
-        List<Pair<Integer, Pair<MapleStatEffect, Long>>> priorityUpdateEffects = new LinkedList<>();
-        Map<MapleBuffStatValueHolder, MapleStatEffect> yokeStats = new LinkedHashMap<>();
+    private List<Pair<Integer, Pair<StatEffect, Long>>> propagatePriorityBuffEffectUpdates(Set<BuffStat> retrievedStats) {
+        List<Pair<Integer, Pair<StatEffect, Long>>> priorityUpdateEffects = new LinkedList<>();
+        Map<MapleBuffStatValueHolder, StatEffect> yokeStats = new LinkedHashMap<>();
 
         // priority buffsources: override buffstats for the client to perceive those as "currently buffed"
         Set<MapleBuffStatValueHolder> mbsvhList = new LinkedHashSet<>();
@@ -4177,7 +4177,7 @@ public class Character extends AbstractCharacterObject {
         }
 
         for (MapleBuffStatValueHolder mbsvh : mbsvhList) {
-            MapleStatEffect mse = mbsvh.effect;
+            StatEffect mse = mbsvh.effect;
             int buffSourceId = mse.getBuffSourceId();
             if (isPriorityBuffSourceid(buffSourceId) && !hasActiveBuff(buffSourceId)) {
                 for (Pair<BuffStat, Integer> ps : mse.getStatups()) {
@@ -4194,9 +4194,9 @@ public class Character extends AbstractCharacterObject {
             }
         }
 
-        for (Entry<MapleBuffStatValueHolder, MapleStatEffect> e : yokeStats.entrySet()) {
+        for (Entry<MapleBuffStatValueHolder, StatEffect> e : yokeStats.entrySet()) {
             MapleBuffStatValueHolder mbsvhPriority = e.getKey();
-            MapleStatEffect mseActive = e.getValue();
+            StatEffect mseActive = e.getValue();
 
             priorityUpdateEffects.add(new Pair<>(mseActive.getBuffSourceId(), new Pair<>(mbsvhPriority.effect, mbsvhPriority.startTime)));
         }
@@ -4204,13 +4204,13 @@ public class Character extends AbstractCharacterObject {
         return priorityUpdateEffects;
     }
 
-    private void propagateBuffEffectUpdates(Map<Integer, Pair<MapleStatEffect, Long>> retrievedEffects, Set<BuffStat> retrievedStats, Set<BuffStat> removedStats) {
+    private void propagateBuffEffectUpdates(Map<Integer, Pair<StatEffect, Long>> retrievedEffects, Set<BuffStat> retrievedStats, Set<BuffStat> removedStats) {
         cancelInactiveBuffStats(retrievedStats, removedStats);
         if (retrievedStats.isEmpty()) {
             return;
         }
 
-        Map<BuffStat, Pair<Integer, MapleStatEffect>> maxBuffValue = new LinkedHashMap<>();
+        Map<BuffStat, Pair<Integer, StatEffect>> maxBuffValue = new LinkedHashMap<>();
         for (BuffStat mbs : retrievedStats) {
             MapleBuffStatValueHolder mbsvh = effects.get(mbs);
             if (mbsvh != null) {
@@ -4220,19 +4220,19 @@ public class Character extends AbstractCharacterObject {
             maxBuffValue.put(mbs, new Pair<>(Integer.MIN_VALUE, null));
         }
 
-        Map<MapleStatEffect, Integer> updateEffects = new LinkedHashMap<>();
+        Map<StatEffect, Integer> updateEffects = new LinkedHashMap<>();
 
-        List<MapleStatEffect> recalcMseList = new LinkedList<>();
-        for (Entry<Integer, Pair<MapleStatEffect, Long>> re : retrievedEffects.entrySet()) {
+        List<StatEffect> recalcMseList = new LinkedList<>();
+        for (Entry<Integer, Pair<StatEffect, Long>> re : retrievedEffects.entrySet()) {
             recalcMseList.add(re.getValue().getLeft());
         }
 
         boolean mageJob = this.getJobStyle() == Job.MAGICIAN;
         do {
-            List<MapleStatEffect> mseList = recalcMseList;
+            List<StatEffect> mseList = recalcMseList;
             recalcMseList = new LinkedList<>();
 
-            for (MapleStatEffect mse : mseList) {
+            for (StatEffect mse : mseList) {
                 int maxEffectiveStatup = Integer.MIN_VALUE;
                 for (Pair<BuffStat, Integer> st : mse.getStatups()) {
                     BuffStat mbs = st.getLeft();
@@ -4248,13 +4248,13 @@ public class Character extends AbstractCharacterObject {
                         }
                     }
 
-                    Pair<Integer, MapleStatEffect> mbv = maxBuffValue.get(mbs);
+                    Pair<Integer, StatEffect> mbv = maxBuffValue.get(mbs);
                     if (mbv == null) {
                         continue;
                     }
 
                     if (mbv.getLeft() < st.getRight()) {
-                        MapleStatEffect msbe = mbv.getRight();
+                        StatEffect msbe = mbv.getRight();
                         if (msbe != null) {
                             recalcMseList.add(msbe);
                         }
@@ -4273,16 +4273,16 @@ public class Character extends AbstractCharacterObject {
             }
         } while (!recalcMseList.isEmpty());
 
-        List<MapleStatEffect> updateEffectsList = sortEffectsList(updateEffects);
+        List<StatEffect> updateEffectsList = sortEffectsList(updateEffects);
 
-        List<Pair<Integer, Pair<MapleStatEffect, Long>>> toUpdateEffects = new LinkedList<>();
-        for (MapleStatEffect mse : updateEffectsList) {
+        List<Pair<Integer, Pair<StatEffect, Long>>> toUpdateEffects = new LinkedList<>();
+        for (StatEffect mse : updateEffectsList) {
             toUpdateEffects.add(new Pair<>(mse.getBuffSourceId(), retrievedEffects.get(mse.getBuffSourceId())));
         }
 
         List<Pair<BuffStat, Integer>> activeStatups = new LinkedList<>();
-        for (Pair<Integer, Pair<MapleStatEffect, Long>> lmse : toUpdateEffects) {
-            Pair<MapleStatEffect, Long> msel = lmse.getRight();
+        for (Pair<Integer, Pair<StatEffect, Long>> lmse : toUpdateEffects) {
+            Pair<StatEffect, Long> msel = lmse.getRight();
 
             for (Pair<BuffStat, Integer> statup : getActiveStatupsFromSourceid(lmse.getLeft())) {
                 activeStatups.add(statup);
@@ -4292,9 +4292,9 @@ public class Character extends AbstractCharacterObject {
             activeStatups.clear();
         }
 
-        List<Pair<Integer, Pair<MapleStatEffect, Long>>> priorityEffects = propagatePriorityBuffEffectUpdates(retrievedStats);
-        for (Pair<Integer, Pair<MapleStatEffect, Long>> lmse : priorityEffects) {
-            Pair<MapleStatEffect, Long> msel = lmse.getRight();
+        List<Pair<Integer, Pair<StatEffect, Long>>> priorityEffects = propagatePriorityBuffEffectUpdates(retrievedStats);
+        for (Pair<Integer, Pair<StatEffect, Long>> lmse : priorityEffects) {
+            Pair<StatEffect, Long> msel = lmse.getRight();
 
             for (Pair<BuffStat, Integer> statup : getActiveStatupsFromSourceid(lmse.getLeft())) {
                 activeStatups.add(statup);
@@ -4312,7 +4312,7 @@ public class Character extends AbstractCharacterObject {
         }
     }
 
-    private static BuffStat getSingletonStatupFromEffect(MapleStatEffect mse) {
+    private static BuffStat getSingletonStatupFromEffect(StatEffect mse) {
         for (Pair<BuffStat, Integer> mbs : mse.getStatups()) {
             if (isSingletonStatup(mbs.getLeft())) {
                 return mbs.getLeft();
@@ -4375,7 +4375,7 @@ public class Character extends AbstractCharacterObject {
         buffEffectsCount.put(stat, val);
     }
 
-    public void registerEffect(MapleStatEffect effect, long starttime, long expirationtime, boolean isSilent) {
+    public void registerEffect(StatEffect effect, long starttime, long expirationtime, boolean isSilent) {
         if (effect.isDragonBlood()) {
             prepareDragonBlood(effect);
         } else if (effect.isBerserk()) {
@@ -4391,7 +4391,7 @@ public class Character extends AbstractCharacterObject {
             Skill bHealing = SkillFactory.getSkill(DarkKnight.AURA_OF_BEHOLDER);
             int bHealingLvl = getSkillLevel(bHealing);
             if (bHealingLvl > 0) {
-                final MapleStatEffect healEffect = bHealing.getEffect(bHealingLvl);
+                final StatEffect healEffect = bHealing.getEffect(bHealingLvl);
                 int healInterval = healEffect.getX() * 1000;
                 beholderHealingSchedule = TimerManager.getInstance().register(new Runnable() {
                     @Override
@@ -4409,7 +4409,7 @@ public class Character extends AbstractCharacterObject {
             }
             Skill bBuff = SkillFactory.getSkill(DarkKnight.HEX_OF_BEHOLDER);
             if (getSkillLevel(bBuff) > 0) {
-                final MapleStatEffect buffEffect = bBuff.getEffect(getSkillLevel(bBuff));
+                final StatEffect buffEffect = bBuff.getEffect(getSkillLevel(bBuff));
                 int buffInterval = buffEffect.getX() * 1000;
                 beholderBuffSchedule = TimerManager.getInstance().register(new Runnable() {
                     @Override
@@ -4498,7 +4498,7 @@ public class Character extends AbstractCharacterObject {
             boolean active = effect.isActive(this);
             if (YamlConfig.config.server.USE_BUFF_MOST_SIGNIFICANT) {
                 toDeploy = new LinkedHashMap<>();
-                Map<Integer, Pair<MapleStatEffect, Long>> retrievedEffects = new LinkedHashMap<>();
+                Map<Integer, Pair<StatEffect, Long>> retrievedEffects = new LinkedHashMap<>();
                 Set<BuffStat> retrievedStats = new LinkedHashSet<>();
                 for (Entry<BuffStat, MapleBuffStatValueHolder> statup : appliedStatups.entrySet()) {
                     MapleBuffStatValueHolder mbsvh = effects.get(statup.getKey());
@@ -4583,7 +4583,7 @@ public class Character extends AbstractCharacterObject {
         int skillId = getJobMapChair(job);
         int skillLv = getSkillLevel(skillId);
         if (skillLv > 0) {
-            MapleStatEffect mapChairSkill = SkillFactory.getSkill(skillId).getEffect(skillLv);
+            StatEffect mapChairSkill = SkillFactory.getSkill(skillId).getEffect(skillLv);
             return cancelEffect(mapChairSkill, false, -1);
         }
 
@@ -4598,7 +4598,7 @@ public class Character extends AbstractCharacterObject {
         int skillId = getJobMapChair(job);
         int skillLv = getSkillLevel(skillId);
         if (skillLv > 0) {
-            MapleStatEffect mapChairSkill = SkillFactory.getSkill(skillId).getEffect(skillLv);
+            StatEffect mapChairSkill = SkillFactory.getSkill(skillId).getEffect(skillLv);
             mapChairSkill.applyTo(this);
             return true;
         }
@@ -4933,12 +4933,12 @@ public class Character extends AbstractCharacterObject {
         float rate = 100.0f;
 
         if (itemid == 0) {
-            MapleStatEffect mseMeso = getBuffEffect(BuffStat.MESO_UP_BY_ITEM);
+            StatEffect mseMeso = getBuffEffect(BuffStat.MESO_UP_BY_ITEM);
             if (mseMeso != null) {
                 rate += mseMeso.getCardRate(mapid, itemid);
             }
         } else {
-            MapleStatEffect mseItem = getBuffEffect(BuffStat.ITEM_UP_BY_ITEM);
+            StatEffect mseItem = getBuffEffect(BuffStat.ITEM_UP_BY_ITEM);
             if (mseItem != null) {
                 rate += mseItem.getCardRate(mapid, itemid);
             }
@@ -5848,7 +5848,7 @@ public class Character extends AbstractCharacterObject {
         return Collections.unmodifiableList(ret);
     }
 
-    public MapleStatEffect getStatForBuff(BuffStat effect) {
+    public StatEffect getStatForBuff(BuffStat effect) {
         effLock.lock();
         chrLock.lock();
         try {
@@ -5948,7 +5948,7 @@ public class Character extends AbstractCharacterObject {
 
     public void handleEnergyChargeGain() { // to get here energychargelevel has to be > 0
         Skill energycharge = isCygnus() ? SkillFactory.getSkill(ThunderBreaker.ENERGY_CHARGE) : SkillFactory.getSkill(Marauder.ENERGY_CHARGE);
-        MapleStatEffect ceffect;
+        StatEffect ceffect;
         ceffect = energycharge.getEffect(getSkillLevel(energycharge));
         TimerManager tMan = TimerManager.getInstance();
         if (energybar < 10000) {
@@ -6806,7 +6806,7 @@ public class Character extends AbstractCharacterObject {
             return;
         }
 
-        MapleStatEffect mse = ii.getItemEffect(couponid);
+        StatEffect mse = ii.getItemEffect(couponid);
         mse.applyTo(this);
     }
 
@@ -7472,12 +7472,12 @@ public class Character extends AbstractCharacterObject {
 
     private static class MapleBuffStatValueHolder {
 
-        public MapleStatEffect effect;
+        public StatEffect effect;
         public long startTime;
         public int value;
         public boolean bestApplied;
 
-        public MapleBuffStatValueHolder(MapleStatEffect effect, long startTime, int value) {
+        public MapleBuffStatValueHolder(StatEffect effect, long startTime, int value) {
             super();
             this.effect = effect;
             this.startTime = startTime;
@@ -7680,7 +7680,7 @@ public class Character extends AbstractCharacterObject {
         setStance(0);
     }
 
-    private void prepareDragonBlood(final MapleStatEffect bloodEffect) {
+    private void prepareDragonBlood(final StatEffect bloodEffect) {
         if (dragonBloodSchedule != null) {
             dragonBloodSchedule.cancel(false);
         }
@@ -7769,14 +7769,14 @@ public class Character extends AbstractCharacterObject {
             localmaxhp = Math.min(30000, localmaxhp);
             localmaxmp = Math.min(30000, localmaxmp);
 
-            MapleStatEffect combo = getBuffEffect(BuffStat.ARAN_COMBO);
+            StatEffect combo = getBuffEffect(BuffStat.ARAN_COMBO);
             if (combo != null) {
                 localwatk += combo.getX();
             }
 
             if (energybar == 15000) {
                 Skill energycharge = isCygnus() ? SkillFactory.getSkill(ThunderBreaker.ENERGY_CHARGE) : SkillFactory.getSkill(Marauder.ENERGY_CHARGE);
-                MapleStatEffect ceffect = energycharge.getEffect(getSkillLevel(energycharge));
+                StatEffect ceffect = energycharge.getEffect(getSkillLevel(energycharge));
                 localwatk += ceffect.getWatk();
             }
 
diff --git a/src/main/java/client/Skill.java b/src/main/java/client/Skill.java
index 36643f8d98..95d1ab5062 100644
--- a/src/main/java/client/Skill.java
+++ b/src/main/java/client/Skill.java
@@ -21,14 +21,15 @@
 */
 package client;
 
+import server.StatEffect;
+import server.life.Element;
+
 import java.util.ArrayList;
 import java.util.List;
-import server.MapleStatEffect;
-import server.life.Element;
 
 public class Skill {
     private int id;
-    private List<MapleStatEffect> effects = new ArrayList<>();
+    private List<StatEffect> effects = new ArrayList<>();
     private Element element;
     private int animationTime;
     private int job;
@@ -43,7 +44,7 @@ public class Skill {
         return id;
     }
 
-    public MapleStatEffect getEffect(int level) {
+    public StatEffect getEffect(int level) {
         return effects.get(level - 1);
     }
 
@@ -93,7 +94,7 @@ public class Skill {
         return action;
     }
     
-    public void addLevelEffect(MapleStatEffect effect) {
+    public void addLevelEffect(StatEffect effect) {
         effects.add(effect);
     }
 }
\ No newline at end of file
diff --git a/src/main/java/client/SkillFactory.java b/src/main/java/client/SkillFactory.java
index 93a7dc3ff0..16dd09841d 100644
--- a/src/main/java/client/SkillFactory.java
+++ b/src/main/java/client/SkillFactory.java
@@ -24,7 +24,7 @@ package client;
 import constants.skills.*;
 import provider.*;
 import provider.wz.WZFiles;
-import server.MapleStatEffect;
+import server.StatEffect;
 import server.life.Element;
 
 import java.util.HashMap;
@@ -318,7 +318,7 @@ public class SkillFactory {
         }
 
         for (Data level : data.getChildByPath("level")) {
-            ret.addLevelEffect(MapleStatEffect.loadSkillEffectFromData(level, id, isBuff));
+            ret.addLevelEffect(StatEffect.loadSkillEffectFromData(level, id, isBuff));
         }
         ret.setAnimationTime(0);
         if (effect != null) {
diff --git a/src/main/java/client/processor/action/PetAutopotProcessor.java b/src/main/java/client/processor/action/PetAutopotProcessor.java
index f0de3183b6..dd4f14f6b3 100644
--- a/src/main/java/client/processor/action/PetAutopotProcessor.java
+++ b/src/main/java/client/processor/action/PetAutopotProcessor.java
@@ -29,7 +29,7 @@ import client.inventory.Item;
 import client.inventory.manipulator.InventoryManipulator;
 import config.YamlConfig;
 import server.ItemInformationProvider;
-import server.MapleStatEffect;
+import server.StatEffect;
 import tools.PacketCreator;
 
 import java.util.List;
@@ -88,7 +88,7 @@ public class PetAutopotProcessor {
             }
             
             int useCount = 0, qtyCount = 0;
-            MapleStatEffect stat = null;
+            StatEffect stat = null;
             
             maxHp = chr.getCurrentMaxHp();
             maxMp = chr.getCurrentMaxMp();
diff --git a/src/main/java/net/server/PlayerBuffValueHolder.java b/src/main/java/net/server/PlayerBuffValueHolder.java
index af5874971c..423ff79342 100644
--- a/src/main/java/net/server/PlayerBuffValueHolder.java
+++ b/src/main/java/net/server/PlayerBuffValueHolder.java
@@ -21,7 +21,7 @@
 */
 package net.server;
 
-import server.MapleStatEffect;
+import server.StatEffect;
 
 /**
  *
@@ -29,9 +29,9 @@ import server.MapleStatEffect;
  */
 public class PlayerBuffValueHolder {
     public int usedTime;
-    public MapleStatEffect effect;
+    public StatEffect effect;
 
-    public PlayerBuffValueHolder(int usedTime, MapleStatEffect effect) {
+    public PlayerBuffValueHolder(int usedTime, StatEffect effect) {
         this.usedTime = usedTime;
         this.effect = effect;
     }
diff --git a/src/main/java/net/server/channel/handlers/AbstractDealDamageHandler.java b/src/main/java/net/server/channel/handlers/AbstractDealDamageHandler.java
index 5d16bf61a7..9d8d2d6845 100644
--- a/src/main/java/net/server/channel/handlers/AbstractDealDamageHandler.java
+++ b/src/main/java/net/server/channel/handlers/AbstractDealDamageHandler.java
@@ -33,7 +33,7 @@ import net.AbstractPacketHandler;
 import net.packet.InPacket;
 import net.server.PlayerBuffValueHolder;
 import scripting.AbstractPlayerInteraction;
-import server.MapleStatEffect;
+import server.StatEffect;
 import server.TimerManager;
 import server.life.*;
 import server.maps.MapItem;
@@ -58,7 +58,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
         public int speed = 4;
         public Point position = new Point();
         
-        public MapleStatEffect getAttackEffect(Character chr, Skill theSkill) {
+        public StatEffect getAttackEffect(Character chr, Skill theSkill) {
             Skill mySkill = theSkill;
             if (mySkill == null) {
                 mySkill = SkillFactory.getSkill(skill);
@@ -87,7 +87,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
         }
         
         Skill theSkill = null;
-        MapleStatEffect attackEffect = null;
+        StatEffect attackEffect = null;
         final int job = player.getJob().getId();
         try {
             if (player.isBanned()) {
@@ -299,13 +299,13 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
                     } else if (attack.skill == ILArchMage.ICE_DEMON) {
                         monster.setTempEffectiveness(Element.FIRE, ElementalEffectiveness.WEAK, SkillFactory.getSkill(ILArchMage.ICE_DEMON).getEffect(player.getSkillLevel(SkillFactory.getSkill(ILArchMage.ICE_DEMON))).getDuration() * 1000);
                     } else if (attack.skill == Outlaw.HOMING_BEACON || attack.skill == Corsair.BULLSEYE) {
-                        MapleStatEffect beacon = SkillFactory.getSkill(attack.skill).getEffect(player.getSkillLevel(attack.skill));
+                        StatEffect beacon = SkillFactory.getSkill(attack.skill).getEffect(player.getSkillLevel(attack.skill));
                         beacon.applyBeaconBuff(player, monster.getObjectId());
                     } else if (attack.skill == Outlaw.FLAME_THROWER) {
                         if (!monster.isBoss()) {
                             Skill type = SkillFactory.getSkill(Outlaw.FLAME_THROWER);
                             if (player.getSkillLevel(type) > 0) {
-                                MapleStatEffect DoT = type.getEffect(player.getSkillLevel(type));
+                                StatEffect DoT = type.getEffect(player.getSkillLevel(type));
                                 MonsterStatusEffect monsterStatusEffect = new MonsterStatusEffect(Collections.singletonMap(MonsterStatus.POISON, 1), type, null, false);
                                 monster.applyStatus(player, monsterStatusEffect, true, DoT.getDuration(), false);
                             }
@@ -378,7 +378,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
                     } else if (job == 412 || job == 422 || job == 1411) {
                         Skill type = SkillFactory.getSkill(player.getJob().getId() == 412 ? 4120005 : (player.getJob().getId() == 1411 ? 14110004 : 4220005));
                         if (player.getSkillLevel(type) > 0) {
-                            MapleStatEffect venomEffect = type.getEffect(player.getSkillLevel(type));
+                            StatEffect venomEffect = type.getEffect(player.getSkillLevel(type));
                             for (int i = 0; i < attackCount; i++) {
                                 if (venomEffect.makeChanceResult()) {
                                     if (monster.getVenomMulti() < 3) {
@@ -400,7 +400,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
                             
                             int skillLevel = player.getSkillLevel(mortalBlow);
                             if (skillLevel > 0) {
-                                MapleStatEffect mortal = mortalBlow.getEffect(skillLevel);
+                                StatEffect mortal = mortalBlow.getEffect(skillLevel);
                                 if (monster.getHp() <= (monster.getStats().getHp() * mortal.getX()) / 100) {
                                     if (Randomizer.rand(1, 100) <= mortal.getY()) {
                                         map.damageMonster(player, monster, Integer.MAX_VALUE);  // thanks Conrad for noticing reduced EXP gain from skill kill
@@ -621,7 +621,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
 
         if(ret.skill != 0) {
             Skill skill = SkillFactory.getSkill(ret.skill);
-            MapleStatEffect effect = skill.getEffect(ret.skilllevel);
+            StatEffect effect = skill.getEffect(ret.skilllevel);
 
             if (magic) {
                 // Since the skill is magic based, use the magic formula
@@ -668,7 +668,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
             
             if(comboBuff > 6) {
                 // Advanced Combo
-                MapleStatEffect ceffect = SkillFactory.getSkill(advcomboid).getEffect(chr.getSkillLevel(advcomboid));
+                StatEffect ceffect = SkillFactory.getSkill(advcomboid).getEffect(chr.getSkillLevel(advcomboid));
                 calcDmgMax = (long) Math.floor(calcDmgMax * (ceffect.getDamage() + 50) / 100 + 0.20 + (comboBuff - 5) * 0.04);
             } else {
                 // Normal Combo
@@ -676,7 +676,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
                 if(skillLv <= 0 || chr.isGM()) skillLv = SkillFactory.getSkill(oid).getMaxLevel();
                 
                 if(skillLv > 0) {
-                    MapleStatEffect ceffect = SkillFactory.getSkill(oid).getEffect(skillLv);
+                    StatEffect ceffect = SkillFactory.getSkill(oid).getEffect(skillLv);
                     calcDmgMax = (long) Math.floor(calcDmgMax * (ceffect.getDamage() + 50) / 100 + Math.floor((comboBuff - 1) * (skillLv / 6)) / 100);
                 }
             }
@@ -697,7 +697,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
         
         if(chr.getEnergyBar() == 15000) {
             int energycharge = chr.isCygnus() ? ThunderBreaker.ENERGY_CHARGE : Marauder.ENERGY_CHARGE;
-            MapleStatEffect ceffect = SkillFactory.getSkill(energycharge).getEffect(chr.getSkillLevel(energycharge));
+            StatEffect ceffect = SkillFactory.getSkill(energycharge).getEffect(chr.getSkillLevel(energycharge));
             calcDmgMax *= (100 + ceffect.getDamage()) / 100;
         }
         
diff --git a/src/main/java/net/server/channel/handlers/CloseRangeDamageHandler.java b/src/main/java/net/server/channel/handlers/CloseRangeDamageHandler.java
index 035eae7196..c295f804d2 100644
--- a/src/main/java/net/server/channel/handlers/CloseRangeDamageHandler.java
+++ b/src/main/java/net/server/channel/handlers/CloseRangeDamageHandler.java
@@ -27,7 +27,7 @@ import config.YamlConfig;
 import constants.game.GameConstants;
 import constants.skills.*;
 import net.packet.InPacket;
-import server.MapleStatEffect;
+import server.StatEffect;
 import tools.PacketCreator;
 import tools.Pair;
 
@@ -78,7 +78,7 @@ public final class CloseRangeDamageHandler extends AbstractDealDamageHandler {
                 int advcomboid = chr.isCygnus() ? DawnWarrior.ADVANCED_COMBO : Hero.ADVANCED_COMBO;
                 Skill combo = SkillFactory.getSkill(oid);
                 Skill advcombo = SkillFactory.getSkill(advcomboid);
-                MapleStatEffect ceffect;
+                StatEffect ceffect;
                 int advComboSkillLevel = chr.getSkillLevel(advcombo);
                 if (advComboSkillLevel > 0) {
                     ceffect = advcombo.getEffect(advComboSkillLevel);
@@ -151,7 +151,7 @@ public final class CloseRangeDamageHandler extends AbstractDealDamageHandler {
             c.sendPacket(PacketCreator.serverNotice(5, "As you used the secret skill, your energy bar has been reset."));
         } else if (attack.skill > 0) {
             Skill skill = SkillFactory.getSkill(attack.skill);
-            MapleStatEffect effect_ = skill.getEffect(chr.getSkillLevel(skill));
+            StatEffect effect_ = skill.getEffect(chr.getSkillLevel(skill));
             if (effect_.getCooldown() > 0) {
                 if (chr.skillIsCooling(attack.skill)) {
                     return;
diff --git a/src/main/java/net/server/channel/handlers/MagicDamageHandler.java b/src/main/java/net/server/channel/handlers/MagicDamageHandler.java
index aa8ec78a7b..1345d3d5e7 100644
--- a/src/main/java/net/server/channel/handlers/MagicDamageHandler.java
+++ b/src/main/java/net/server/channel/handlers/MagicDamageHandler.java
@@ -31,7 +31,7 @@ import constants.skills.FPArchMage;
 import constants.skills.ILArchMage;
 import net.packet.InPacket;
 import net.packet.Packet;
-import server.MapleStatEffect;
+import server.StatEffect;
 import tools.PacketCreator;
 
 public final class MagicDamageHandler extends AbstractDealDamageHandler {
@@ -64,9 +64,9 @@ public final class MagicDamageHandler extends AbstractDealDamageHandler {
                 Packet packet = PacketCreator.magicAttack(chr, attack.skill, attack.skilllevel, attack.stance, attack.numAttackedAndDamage, attack.allDamage, charge, attack.speed, attack.direction, attack.display);
 		
 		chr.getMap().broadcastMessage(chr, packet, false, true);
-		MapleStatEffect effect = attack.getAttackEffect(chr, null);
+		StatEffect effect = attack.getAttackEffect(chr, null);
 		Skill skill = SkillFactory.getSkill(attack.skill);
-		MapleStatEffect effect_ = skill.getEffect(chr.getSkillLevel(skill));
+		StatEffect effect_ = skill.getEffect(chr.getSkillLevel(skill));
 		if (effect_.getCooldown() > 0) {
 			if (chr.skillIsCooling(attack.skill)) {
 				return;
diff --git a/src/main/java/net/server/channel/handlers/PetAutoPotHandler.java b/src/main/java/net/server/channel/handlers/PetAutoPotHandler.java
index dd1f3e5e83..822fd8bcbe 100644
--- a/src/main/java/net/server/channel/handlers/PetAutoPotHandler.java
+++ b/src/main/java/net/server/channel/handlers/PetAutoPotHandler.java
@@ -27,7 +27,7 @@ import client.processor.action.PetAutopotProcessor;
 import net.AbstractPacketHandler;
 import net.packet.InPacket;
 import server.ItemInformationProvider;
-import server.MapleStatEffect;
+import server.StatEffect;
 
 public final class PetAutoPotHandler extends AbstractPacketHandler {
     
@@ -40,7 +40,7 @@ public final class PetAutoPotHandler extends AbstractPacketHandler {
         int itemId = p.readInt();
         
         Character chr = c.getPlayer();
-        MapleStatEffect stat = ItemInformationProvider.getInstance().getItemEffect(itemId);
+        StatEffect stat = ItemInformationProvider.getInstance().getItemEffect(itemId);
         if (stat.getHp() > 0 || stat.getHpRate() > 0.0) {
             float estimatedHp = ((float) chr.getHp()) / chr.getMaxHp();
             chr.setAutopotHpAlert(estimatedHp + 0.05f);
diff --git a/src/main/java/net/server/channel/handlers/RangedAttackHandler.java b/src/main/java/net/server/channel/handlers/RangedAttackHandler.java
index 5896e1faa7..a2f1c8ea51 100644
--- a/src/main/java/net/server/channel/handlers/RangedAttackHandler.java
+++ b/src/main/java/net/server/channel/handlers/RangedAttackHandler.java
@@ -35,7 +35,7 @@ import constants.skills.*;
 import net.packet.InPacket;
 import net.packet.Packet;
 import server.ItemInformationProvider;
-import server.MapleStatEffect;
+import server.StatEffect;
 import tools.PacketCreator;
 import tools.Randomizer;
 
@@ -98,7 +98,7 @@ public final class RangedAttackHandler extends AbstractDealDamageHandler {
             short slot = -1;
             int projectile = 0;
             short bulletCount = 1;
-            MapleStatEffect effect = null;
+            StatEffect effect = null;
             if (attack.skill != 0) {
                 effect = attack.getAttackEffect(chr, null);
                 bulletCount = effect.getBulletCount();
@@ -205,7 +205,7 @@ public final class RangedAttackHandler extends AbstractDealDamageHandler {
                 
                 if (attack.skill != 0) {
                     Skill skill = SkillFactory.getSkill(attack.skill);
-                    MapleStatEffect effect_ = skill.getEffect(chr.getSkillLevel(skill));
+                    StatEffect effect_ = skill.getEffect(chr.getSkillLevel(skill));
                     if (effect_.getCooldown() > 0) {
                         if (chr.skillIsCooling(attack.skill)) {
                             return;
diff --git a/src/main/java/net/server/channel/handlers/SpecialMoveHandler.java b/src/main/java/net/server/channel/handlers/SpecialMoveHandler.java
index 0d06e583f4..e2599c5a0a 100644
--- a/src/main/java/net/server/channel/handlers/SpecialMoveHandler.java
+++ b/src/main/java/net/server/channel/handlers/SpecialMoveHandler.java
@@ -30,7 +30,7 @@ import constants.skills.*;
 import net.AbstractPacketHandler;
 import net.packet.InPacket;
 import net.server.Server;
-import server.MapleStatEffect;
+import server.StatEffect;
 import server.life.Monster;
 import tools.PacketCreator;
 
@@ -69,13 +69,13 @@ public final class SpecialMoveHandler extends AbstractPacketHandler {
         }
         if (skillLevel == 0 || skillLevel != __skillLevel) return;
         
-        MapleStatEffect effect = skill.getEffect(skillLevel);
+        StatEffect effect = skill.getEffect(skillLevel);
         if (effect.getCooldown() > 0) {
             if (chr.skillIsCooling(skillid)) {
                 return;
             } else if (skillid != Corsair.BATTLE_SHIP) {
                 int cooldownTime = effect.getCooldown();
-                if(MapleStatEffect.isHerosWill(skillid) && YamlConfig.config.server.USE_FAST_REUSE_HERO_WILL) {
+                if(StatEffect.isHerosWill(skillid) && YamlConfig.config.server.USE_FAST_REUSE_HERO_WILL) {
                     cooldownTime /= 60;
                 }
                 
@@ -107,7 +107,7 @@ public final class SpecialMoveHandler extends AbstractPacketHandler {
             return;
         } else if (skillid == Brawler.MP_RECOVERY) {// MP Recovery
             Skill s = SkillFactory.getSkill(skillid);
-            MapleStatEffect ef = s.getEffect(chr.getSkillLevel(s));
+            StatEffect ef = s.getEffect(chr.getSkillLevel(s));
             
             int lose = chr.safeAddHP(-1 * (chr.getCurrentMaxHp() / ef.getX()));
             int gain = -lose * (ef.getY() / 100);
diff --git a/src/main/java/net/server/channel/handlers/SummonDamageHandler.java b/src/main/java/net/server/channel/handlers/SummonDamageHandler.java
index f4b58f0158..77c8c94c6f 100644
--- a/src/main/java/net/server/channel/handlers/SummonDamageHandler.java
+++ b/src/main/java/net/server/channel/handlers/SummonDamageHandler.java
@@ -33,7 +33,7 @@ import client.status.MonsterStatusEffect;
 import constants.skills.Outlaw;
 import net.packet.InPacket;
 import server.ItemInformationProvider;
-import server.MapleStatEffect;
+import server.StatEffect;
 import server.life.Monster;
 import server.life.MonsterInformationProvider;
 import server.maps.Summon;
@@ -82,7 +82,7 @@ public final class SummonDamageHandler extends AbstractDealDamageHandler {
             return;
         }
         Skill summonSkill = SkillFactory.getSkill(summon.getSkill());
-        MapleStatEffect summonEffect = summonSkill.getEffect(summon.getSkillLevel());
+        StatEffect summonEffect = summonSkill.getEffect(summon.getSkillLevel());
         p.skip(4);
         List<SummonAttackEntry> allDamage = new ArrayList<>();
         byte direction = p.readByte();
@@ -127,7 +127,7 @@ public final class SummonDamageHandler extends AbstractDealDamageHandler {
         }
     }
     
-    private static int calcMaxDamage(MapleStatEffect summonEffect, Character player, boolean magic) {
+    private static int calcMaxDamage(StatEffect summonEffect, Character player, boolean magic) {
         double maxDamage;
         
         if (magic) {
diff --git a/src/main/java/net/server/channel/handlers/TakeDamageHandler.java b/src/main/java/net/server/channel/handlers/TakeDamageHandler.java
index a62f0b5f19..0c8dec5338 100644
--- a/src/main/java/net/server/channel/handlers/TakeDamageHandler.java
+++ b/src/main/java/net/server/channel/handlers/TakeDamageHandler.java
@@ -35,7 +35,7 @@ import constants.inventory.ItemConstants;
 import constants.skills.Aran;
 import net.AbstractPacketHandler;
 import net.packet.InPacket;
-import server.MapleStatEffect;
+import server.StatEffect;
 import server.life.LifeFactory.loseItem;
 import server.life.*;
 import server.maps.MapObject;
@@ -205,7 +205,7 @@ public final class TakeDamageHandler extends AbstractPacketHandler {
                         map.broadcastMessage(chr, PacketCreator.damageMonster(oid, bouncedamage), false, true);
                         attacker.aggroMonsterDamage(chr, bouncedamage);
                     }
-                    MapleStatEffect bPressure = chr.getBuffEffect(BuffStat.BODY_PRESSURE); // thanks Atoot for noticing an issue on Body Pressure neutralise
+                    StatEffect bPressure = chr.getBuffEffect(BuffStat.BODY_PRESSURE); // thanks Atoot for noticing an issue on Body Pressure neutralise
                     if (bPressure != null) {
                         Skill skill = SkillFactory.getSkill(Aran.BODY_PRESSURE);
                         if (!attacker.alreadyBuffedStats().contains(MonsterStatus.NEUTRALISE)) {
@@ -216,7 +216,7 @@ public final class TakeDamageHandler extends AbstractPacketHandler {
                     }
                 }
                 
-                MapleStatEffect cBarrier = chr.getBuffEffect(BuffStat.COMBO_BARRIER);  // thanks BHB for noticing Combo Barrier buff not working
+                StatEffect cBarrier = chr.getBuffEffect(BuffStat.COMBO_BARRIER);  // thanks BHB for noticing Combo Barrier buff not working
                 if (cBarrier != null) {
                     damage *= (cBarrier.getX() / 1000.0);
                 }
diff --git a/src/main/java/net/server/channel/handlers/UseItemHandler.java b/src/main/java/net/server/channel/handlers/UseItemHandler.java
index 2f0f1d9b07..10e792a94a 100644
--- a/src/main/java/net/server/channel/handlers/UseItemHandler.java
+++ b/src/main/java/net/server/channel/handlers/UseItemHandler.java
@@ -32,7 +32,7 @@ import constants.inventory.ItemConstants;
 import net.AbstractPacketHandler;
 import net.packet.InPacket;
 import server.ItemInformationProvider;
-import server.MapleStatEffect;
+import server.StatEffect;
 import tools.PacketCreator;
 
 /**
@@ -98,7 +98,7 @@ public final class UseItemHandler extends AbstractPacketHandler {
             if(toUse.getItemId() != 2022153) {
                 ii.getItemEffect(toUse.getItemId()).applyTo(chr);
             } else {
-                MapleStatEffect mse = ii.getItemEffect(toUse.getItemId());
+                StatEffect mse = ii.getItemEffect(toUse.getItemId());
                 for(Character player : chr.getMap().getCharacters()) {
                     mse.applyTo(player);
                 }
diff --git a/src/main/java/scripting/event/EventInstanceManager.java b/src/main/java/scripting/event/EventInstanceManager.java
index ca8389555a..ea3c04dd20 100644
--- a/src/main/java/scripting/event/EventInstanceManager.java
+++ b/src/main/java/scripting/event/EventInstanceManager.java
@@ -37,7 +37,7 @@ import net.server.world.PartyCharacter;
 import scripting.AbstractPlayerInteraction;
 import scripting.event.scheduler.EventScriptScheduler;
 import server.ItemInformationProvider;
-import server.MapleStatEffect;
+import server.StatEffect;
 import server.ThreadManager;
 import server.TimerManager;
 import server.expeditions.Expedition;
@@ -144,7 +144,7 @@ public class EventInstanceManager {
         
         public void applyEventPlayersItemBuff(int itemId) {
                 List<Character> players = getPlayerList();
-                MapleStatEffect mse = ItemInformationProvider.getInstance().getItemEffect(itemId);
+                StatEffect mse = ItemInformationProvider.getInstance().getItemEffect(itemId);
                 
                 if(mse != null) {
                         for (Character player: players) {
@@ -162,7 +162,7 @@ public class EventInstanceManager {
                 Skill skill = SkillFactory.getSkill(skillId);
                 
                 if(skill != null) {
-                        MapleStatEffect mse = skill.getEffect(Math.min(skillLv, skill.getMaxLevel()));
+                        StatEffect mse = skill.getEffect(Math.min(skillLv, skill.getMaxLevel()));
                         if(mse != null) {
                                 for (Character player: players) {
                                         mse.applyTo(player);
diff --git a/src/main/java/scripting/npc/NPCConversationManager.java b/src/main/java/scripting/npc/NPCConversationManager.java
index 3b221a60cd..3f74b063ed 100644
--- a/src/main/java/scripting/npc/NPCConversationManager.java
+++ b/src/main/java/scripting/npc/NPCConversationManager.java
@@ -364,7 +364,7 @@ public class NPCConversationManager extends AbstractPlayerInteraction {
 		return GameConstants.getJobName(id);
 	}
 
-	public MapleStatEffect getItemEffect(int itemId) {
+	public StatEffect getItemEffect(int itemId) {
 		return ItemInformationProvider.getInstance().getItemEffect(itemId);
 	}
 
diff --git a/src/main/java/server/ItemInformationProvider.java b/src/main/java/server/ItemInformationProvider.java
index 485a502a32..574edbf47f 100644
--- a/src/main/java/server/ItemInformationProvider.java
+++ b/src/main/java/server/ItemInformationProvider.java
@@ -67,7 +67,7 @@ public class ItemInformationProvider {
     protected Data insStringData;
     protected Data petStringData;
     protected Map<Integer, Short> slotMaxCache = new HashMap<>();
-    protected Map<Integer, MapleStatEffect> itemEffects = new HashMap<>();
+    protected Map<Integer, StatEffect> itemEffects = new HashMap<>();
     protected Map<Integer, Map<String, Integer>> equipStatsCache = new HashMap<>();
     protected Map<Integer, Equip> equipCache = new HashMap<>();
     protected Map<Integer, Data> equipLevelInfoCache = new HashMap<>();
@@ -1258,8 +1258,8 @@ public class ItemInformationProvider {
         return equip;
     }
 
-    public MapleStatEffect getItemEffect(int itemId) {
-        MapleStatEffect ret = itemEffects.get(Integer.valueOf(itemId));
+    public StatEffect getItemEffect(int itemId) {
+        StatEffect ret = itemEffects.get(Integer.valueOf(itemId));
         if (ret == null) {
             Data item = getItemData(itemId);
             if (item == null) {
@@ -1269,7 +1269,7 @@ public class ItemInformationProvider {
             if (spec == null) {
                 spec = item.getChildByPath("spec");
             }
-            ret = MapleStatEffect.loadItemEffectFromData(spec, itemId);
+            ret = StatEffect.loadItemEffectFromData(spec, itemId);
             itemEffects.put(Integer.valueOf(itemId), ret);
         }
         return ret;
diff --git a/src/main/java/server/MapleStatEffect.java b/src/main/java/server/StatEffect.java
similarity index 97%
rename from src/main/java/server/MapleStatEffect.java
rename to src/main/java/server/StatEffect.java
index ac8063ec0b..f37a959ee1 100644
--- a/src/main/java/server/MapleStatEffect.java
+++ b/src/main/java/server/StatEffect.java
@@ -57,8 +57,7 @@ import java.util.*;
  * @author Frz
  * @author Ronan
  */
-public class MapleStatEffect {
-
+public class StatEffect {
     private short watk, matk, wdef, mdef, acc, avoid, speed, jump;
     private short hp, mp;
     private double hpR, mpR;
@@ -82,52 +81,50 @@ public class MapleStatEffect {
     private short bulletCount, bulletConsume;
     private byte mapProtection;
     private CardItemupStats cardStats;
-    
+
     private static class CardItemupStats {
         protected int itemCode, prob;
         protected boolean party;
-        private List<Pair<Integer, Integer>> areas;
-        
+        private final List<Pair<Integer, Integer>> areas;
+
         private CardItemupStats(int code, int prob, List<Pair<Integer, Integer>> areas, boolean inParty) {
             this.itemCode = code;
             this.prob = prob;
             this.areas = areas;
             this.party = inParty;
         }
-        
+
         private boolean isInArea(int mapid) {
             if (this.areas == null) {
                 return true;
             }
-            
+
             for (Pair<Integer, Integer> a : this.areas) {
                 if (mapid >= a.left && mapid <= a.right) {
                     return true;
                 }
             }
-            
+
             return false;
         }
     }
-    
+
     private boolean isEffectActive(int mapid, boolean partyHunting) {
-        if (cardStats == null) return true;
-        
+        if (cardStats == null) {
+            return true;
+        }
+
         if (!cardStats.isInArea(mapid)) {
             return false;
         }
-        
-        if (cardStats.party && !partyHunting) {
-            return false;
-        }
-        
-        return true;
+
+        return !cardStats.party || partyHunting;
     }
-    
+
     public boolean isActive(Character applyto) {
         return isEffectActive(applyto.getMapId(), applyto.getPartyMembersOnSameMap().size() > 1);
     }
-    
+
     public int getCardRate(int mapid, int itemid) {
         if (cardStats != null) {
             if (cardStats.itemCode == Integer.MAX_VALUE) {
@@ -142,15 +139,15 @@ public class MapleStatEffect {
                 }
             }
         }
-        
+
         return 0;
     }
-    
-    public static MapleStatEffect loadSkillEffectFromData(Data source, int skillid, boolean overtime) {
+
+    public static StatEffect loadSkillEffectFromData(Data source, int skillid, boolean overtime) {
         return loadFromData(source, skillid, true, overtime);
     }
 
-    public static MapleStatEffect loadItemEffectFromData(Data source, int itemid) {
+    public static StatEffect loadItemEffectFromData(Data source, int itemid) {
         return loadFromData(source, itemid, false, false);
     }
 
@@ -170,8 +167,8 @@ public class MapleStatEffect {
         }
     }
 
-    private static MapleStatEffect loadFromData(Data source, int sourceid, boolean skill, boolean overTime) {
-        MapleStatEffect ret = new MapleStatEffect();
+    private static StatEffect loadFromData(Data source, int sourceid, boolean skill, boolean overTime) {
+        StatEffect ret = new StatEffect();
         ret.duration = DataTool.getIntConvert("time", source, -1);
         ret.hp = (short) DataTool.getInt("hp", source, 0);
         ret.hpR = DataTool.getInt("hpR", source, 0) / 100.0;
@@ -220,10 +217,10 @@ public class MapleStatEffect {
             ret.mobSkillLevel = 0;
             ret.target = 0;
         }
-        
+
         Data mdds = source.getChildByPath("mob");
         if (mdds != null) {
-            if (mdds.getChildren()!= null && mdds.getChildren().size() > 0) {
+            if (mdds.getChildren() != null && mdds.getChildren().size() > 0) {
                 ret.mob = DataTool.getInt("mob", mdds, 0);
             }
         }
@@ -249,10 +246,10 @@ public class MapleStatEffect {
 
         ret.barrier = DataTool.getInt("barrier", source, 0);
         addBuffStatPairToListIfNotZero(statups, BuffStat.AURA, ret.barrier);
-        
+
         ret.mapProtection = mapProtection(sourceid);
         addBuffStatPairToListIfNotZero(statups, BuffStat.MAP_PROTECTION, (int) ret.mapProtection);
-        
+
         if (ret.overTime && ret.getSummonMovementType() == null) {
             if (!skill) {
                 if (isPyramidBuff(sourceid)) {
@@ -307,14 +304,14 @@ public class MapleStatEffect {
                     int prob = 0, itemupCode = Integer.MAX_VALUE;
                     List<Pair<Integer, Integer>> areas = null;
                     boolean inParty = false;
-                    
+
                     Data con = source.getChildByPath("con");
                     if (con != null) {
                         areas = new ArrayList<>(3);
 
                         for (Data conData : con.getChildren()) {
                             int type = DataTool.getInt("type", conData, -1);
-                            
+
                             if (type == 0) {
                                 int startMap = DataTool.getInt("sMap", conData, 0);
                                 int endMap = DataTool.getInt("eMap", conData, 0);
@@ -324,54 +321,54 @@ public class MapleStatEffect {
                                 inParty = true;
                             }
                         }
-                        
+
                         if (areas.isEmpty()) {
                             areas = null;
                         }
                     }
-                    
+
                     if (DataTool.getInt("mesoupbyitem", source, 0) != 0) {
                         addBuffStatPairToListIfNotZero(statups, BuffStat.MESO_UP_BY_ITEM, 4);
                         prob = DataTool.getInt("prob", source, 1);
                     }
-                    
+
                     int itemupType = DataTool.getInt("itemupbyitem", source, 0);
                     if (itemupType != 0) {
                         addBuffStatPairToListIfNotZero(statups, BuffStat.ITEM_UP_BY_ITEM, 4);
                         prob = DataTool.getInt("prob", source, 1);
-                        
+
                         switch (itemupType) {
                             case 2:
                                 itemupCode = DataTool.getInt("itemCode", source, 1);
                                 break;
-                                
+
                             case 3:
                                 itemupCode = DataTool.getInt("itemRange", source, 1);    // 3 digits
                                 break;
                         }
                     }
-                    
+
                     if (DataTool.getInt("respectPimmune", source, 0) != 0) {
                         addBuffStatPairToListIfNotZero(statups, BuffStat.RESPECT_PIMMUNE, 4);
                     }
-                    
+
                     if (DataTool.getInt("respectMimmune", source, 0) != 0) {
                         addBuffStatPairToListIfNotZero(statups, BuffStat.RESPECT_MIMMUNE, 4);
                     }
-                    
+
                     if (DataTool.getString("defenseAtt", source, null) != null) {
                         addBuffStatPairToListIfNotZero(statups, BuffStat.DEFENSE_ATT, 4);
                     }
-                    
+
                     if (DataTool.getString("defenseState", source, null) != null) {
                         addBuffStatPairToListIfNotZero(statups, BuffStat.DEFENSE_STATE, 4);
                     }
-                    
+
                     int thaw = DataTool.getInt("thaw", source, 0);
                     if (thaw != 0) {
                         addBuffStatPairToListIfNotZero(statups, BuffStat.MAP_PROTECTION, thaw > 0 ? 1 : 2);
                     }
-                    
+
                     ret.cardStats = new CardItemupStats(itemupCode, prob, areas, inParty);
                 } else if (isExpIncrease(sourceid)) {
                     addBuffStatPairToListIfNotZero(statups, BuffStat.EXP_INCREASE, DataTool.getInt("expinc", source, 0));
@@ -542,7 +539,7 @@ public class MapleStatEffect {
                     break;
                 case Evan.SLOW:
                     statups.add(new Pair<>(BuffStat.SLOW, x));
-                // BOWMAN
+                    // BOWMAN
                 case Priest.MYSTIC_DOOR:
                 case Hunter.SOUL_ARROW:
                 case Crossbowman.SOUL_ARROW:
@@ -773,7 +770,7 @@ public class MapleStatEffect {
                     break;
                 case Evan.PHANTOM_IMPRINT:
                     monsterStatus.put(MonsterStatus.PHANTOM_IMPRINT, x);
-                //ARAN
+                    //ARAN
                 case Aran.COMBO_ABILITY:
                     statups.add(new Pair<>(BuffStat.ARAN_COMBO, 100));
                     break;
@@ -811,7 +808,7 @@ public class MapleStatEffect {
     /**
      * @param applyto
      * @param obj
-     * @param attack damage done by the skill
+     * @param attack  damage done by the skill
      */
     public void applyPassive(Character applyto, MapObject obj, int attack) {
         if (makeChanceResult()) {
@@ -867,7 +864,7 @@ public class MapleStatEffect {
             applyto.toggleHide(false);
             return true;
         }
-        
+
         if (primary && isHeal()) {
             affectedPlayers = applyBuff(applyfrom, useMaxRange);
         }
@@ -940,7 +937,7 @@ public class MapleStatEffect {
         }
         if (isShadowClaw()) {
             short projectileConsume = this.getBulletConsume();  // noticed by shavit
-            
+
             Inventory use = applyto.getInventory(InventoryType.USE);
             use.lockInventory();
             try {
@@ -966,7 +963,7 @@ public class MapleStatEffect {
         SummonMovementType summonMovementType = getSummonMovementType();
         if (overTime || isCygnusFA() || summonMovementType != null) {
             if (summonMovementType != null && pos != null) {
-                if (summonMovementType.getValue() == summonMovementType.STATIONARY.getValue()) {
+                if (summonMovementType.getValue() == SummonMovementType.STATIONARY.getValue()) {
                     applyto.cancelBuffStats(BuffStat.PUPPET);
                 } else {
                     applyto.cancelBuffStats(BuffStat.SUMMON);
@@ -1071,7 +1068,7 @@ public class MapleStatEffect {
         } else if (mobSkill > 0 && mobSkillLevel > 0) {
             MobSkill ms = MobSkillFactory.getMobSkill(mobSkill, mobSkillLevel);
             Disease dis = Disease.getBySkill(mobSkill);
-            
+
             if (target > 0) {
                 for (Character chr : applyto.getMap().getAllPlayers()) {
                     if (chr.getId() != applyto.getId()) {
@@ -1087,7 +1084,7 @@ public class MapleStatEffect {
 
     private int applyBuff(Character applyfrom, boolean useMaxRange) {
         int affectedc = 1;
-        
+
         if (isPartyBuff() && (applyfrom.getParty() != null || isGmBuff())) {
             Rectangle bounds = (!useMaxRange) ? calculateBoundingBox(applyfrom.getPosition(), applyfrom.isFacingLeft()) : new Rectangle(Integer.MIN_VALUE / 2, Integer.MIN_VALUE / 2, Integer.MAX_VALUE, Integer.MAX_VALUE);
             List<MapObject> affecteds = applyfrom.getMap().getMapObjectsInRect(bounds, Arrays.asList(MapObjectType.PLAYER));
@@ -1106,7 +1103,7 @@ public class MapleStatEffect {
                     }
                 }
             }
-            
+
             affectedc += affectedp.size();   // used for heal
             for (Character affected : affectedp) {
                 applyTo(applyfrom, affected, false, null, useMaxRange, affectedc);
@@ -1213,12 +1210,12 @@ public class MapleStatEffect {
             }
         }
     }
-    
+
     private void applyBuffEffect(Character applyfrom, Character applyto, boolean primary) {
         if (!isMonsterRiding() && !isCouponBuff() && !isMysticDoor() && !isHyperBody() && !isCombo()) {     // last mystic door already dispelled if it has been used before.
             applyto.cancelEffect(this, true, -1);
         }
-        
+
         List<Pair<BuffStat, Integer>> localstatups = statups;
         int localDuration = getBuffLocalDuration();
         int localsourceid = sourceid;
@@ -1230,7 +1227,7 @@ public class MapleStatEffect {
             if (mount != null) {
                 ridingMountId = mount.getItemId();
             }
-            
+
             if (sourceid == Corsair.BATTLE_SHIP) {
                 ridingMountId = 1932000;
             } else if (sourceid == Beginner.SPACESHIP || sourceid == Noblesse.SPACESHIP) {
@@ -1244,11 +1241,11 @@ public class MapleStatEffect {
             } else if (sourceid == Beginner.BALROG_MOUNT || sourceid == Noblesse.BALROG_MOUNT || sourceid == Legend.BALROG_MOUNT) {
                 ridingMountId = 1932010;
             }
-            
+
             // thanks inhyuk for noticing some skill mounts not acting properly for other players when changing maps
             givemount = applyto.mount(ridingMountId, sourceid);
             applyto.getClient().getWorldServer().registerMountHunger(applyto);
-            
+
             localDuration = sourceid;
             localsourceid = ridingMountId;
             localstatups = Collections.singletonList(new Pair<>(BuffStat.MONSTER_RIDING, 0));
@@ -1286,8 +1283,10 @@ public class MapleStatEffect {
                 mbuff = PacketCreator.giveForeignBuff(applyto.getId(), dsstat);
             } else if (isCombo()) {
                 Integer comboCount = applyto.getBuffedValue(BuffStat.COMBO);
-                if (comboCount == null) comboCount = 0;
-                
+                if (comboCount == null) {
+                    comboCount = 0;
+                }
+
                 List<Pair<BuffStat, Integer>> cbstat = Collections.singletonList(new Pair<>(BuffStat.COMBO, comboCount));
                 buff = PacketCreator.giveBuff((skill ? sourceid : -sourceid), localDuration, cbstat);
                 mbuff = PacketCreator.giveForeignBuff(applyto.getId(), cbstat);
@@ -1321,10 +1320,10 @@ public class MapleStatEffect {
             if (buff != null) {
                 //Thanks flav for such a simple release! :)
                 //Thanks Conrad, Atoot for noticing summons not using buff icon
-                
+
                 applyto.sendPacket(buff);
             }
-            
+
             long starttime = Server.getInstance().getCurrentTime();
             //CancelEffectAction cancelAction = new CancelEffectAction(applyto, this, starttime);
             //ScheduledFuture<?> schedule = TimerManager.getInstance().schedule(cancelAction, localDuration);
@@ -1422,7 +1421,7 @@ public class MapleStatEffect {
 
     private int alchemistModifyVal(Character chr, int val, boolean withX) {
         if (!skill && (chr.getJob().isA(Job.HERMIT) || chr.getJob().isA(Job.NIGHTWALKER3))) {
-            MapleStatEffect alchemistEffect = getAlchemistEffect(chr);
+            StatEffect alchemistEffect = getAlchemistEffect(chr);
             if (alchemistEffect != null) {
                 return (int) (val * ((withX ? alchemistEffect.getX() : alchemistEffect.getY()) / 100.0));
             }
@@ -1430,7 +1429,7 @@ public class MapleStatEffect {
         return val;
     }
 
-    private MapleStatEffect getAlchemistEffect(Character chr) {
+    private StatEffect getAlchemistEffect(Character chr) {
         int id = Hermit.ALCHEMIST;
         if (chr.isCygnus()) {
             id = NightWalker.ALCHEMIST;
@@ -1488,10 +1487,8 @@ public class MapleStatEffect {
         if (lt == null || rb == null) {
             return false;
         }
-        if ((sourceid >= 1211003 && sourceid <= 1211008) || sourceid == Paladin.SWORD_HOLY_CHARGE || sourceid == Paladin.BW_HOLY_CHARGE || sourceid == DawnWarrior.SOUL_CHARGE) {// wk charges have lt and rb set but are neither player nor monster buffs
-            return false;
-        }
-        return true;
+        // wk charges have lt and rb set but are neither player nor monster buffs
+        return (sourceid < 1211003 || sourceid > 1211008) && sourceid != Paladin.SWORD_HOLY_CHARGE && sourceid != Paladin.BW_HOLY_CHARGE && sourceid != DawnWarrior.SOUL_CHARGE;
     }
 
     private boolean isHeal() {
@@ -1550,11 +1547,11 @@ public class MapleStatEffect {
     public static boolean isExpIncrease(int sourceid) {
         return sourceid >= 2022450 && sourceid <= 2022452;
     }
-    
+
     public static boolean isAriantShield(int sourceid) {
         return sourceid == 2022269;
     }
-    
+
     public static boolean isMonsterCard(int sourceid) {
         int itemType = sourceid / 10000;
         return itemType == 238;
@@ -1591,7 +1588,7 @@ public class MapleStatEffect {
     private boolean isCouponBuff() {
         return isRateCoupon(sourceid);
     }
-    
+
     private boolean isAriantShield() {
         int itemid = sourceid;
         return isAriantShield(itemid);
@@ -1639,7 +1636,7 @@ public class MapleStatEffect {
     private boolean isCrash() {
         return skill && (sourceid == DragonKnight.POWER_CRASH || sourceid == Crusader.ARMOR_CRASH || sourceid == WhiteKnight.MAGIC_CRASH);
     }
-    
+
     private boolean isSeal() {
         return skill && (sourceid == ILMage.SEAL || sourceid == FPMage.SEAL || sourceid == BlazeWizard.SEAL);
     }
@@ -1651,11 +1648,7 @@ public class MapleStatEffect {
     private boolean isCureAllAbnormalStatus() {
         if (skill) {
             return isHerosWill(sourceid);
-        } else if (sourceid == 2022544) {
-            return true;
-        }
-
-        return false;
+        } else return sourceid == 2022544;
     }
 
     public static boolean isHerosWill(int skillid) {
@@ -1678,18 +1671,18 @@ public class MapleStatEffect {
                 return false;
         }
     }
-    
+
     private boolean isWkCharge() {
         if (!skill) {
             return false;
         }
-        
+
         for (Pair<BuffStat, Integer> p : statups) {
             if (p.getLeft().equals(BuffStat.WK_CHARGE)) {
                 return true;
             }
         }
-        
+
         return false;
     }
 
@@ -1728,7 +1721,7 @@ public class MapleStatEffect {
     private int getMorph(Character chr) {
         if (morphId == 1000 || morphId == 1001 || morphId == 1003) { // morph skill
             return chr.getGender() == 0 ? morphId : morphId + 100;
-        } 
+        }
         return morphId;
     }
 
@@ -1784,11 +1777,11 @@ public class MapleStatEffect {
     /*
      private static class CancelEffectAction implements Runnable {
 
-     private MapleStatEffect effect;
+     private StatEffect effect;
      private WeakReference<Character> target;
      private long startTime;
 
-     public CancelEffectAction(Character target, MapleStatEffect effect, long startTime) {
+     public CancelEffectAction(Character target, StatEffect effect, long startTime) {
      this.effect = effect;
      this.target = new WeakReference<>(target);
      this.startTime = startTime;
@@ -1859,7 +1852,7 @@ public class MapleStatEffect {
         return statups;
     }
 
-    public boolean sameSource(MapleStatEffect effect) {
+    public boolean sameSource(StatEffect effect) {
         return this.sourceid == effect.sourceid && this.skill == effect.skill;
     }
 
diff --git a/src/main/java/server/life/Monster.java b/src/main/java/server/life/Monster.java
index ed8cd1f60a..fce1e1e3bd 100644
--- a/src/main/java/server/life/Monster.java
+++ b/src/main/java/server/life/Monster.java
@@ -42,7 +42,7 @@ import net.server.services.type.ChannelServices;
 import net.server.world.Party;
 import net.server.world.PartyCharacter;
 import scripting.event.EventInstanceManager;
-import server.MapleStatEffect;
+import server.StatEffect;
 import server.TimerManager;
 import server.life.LifeFactory.BanishInfo;
 import server.loot.LootManager;
@@ -1801,7 +1801,7 @@ public class Monster extends AbstractLoadedLife {
     }
 
     public boolean isCharacterPuppetInVicinity(Character chr) {
-        MapleStatEffect mse = chr.getBuffEffect(BuffStat.PUPPET);
+        StatEffect mse = chr.getBuffEffect(BuffStat.PUPPET);
         if (mse != null) {
             Summon summon = chr.getSummonByKey(mse.getSourceId());
 
@@ -2133,7 +2133,7 @@ public class Monster extends AbstractLoadedLife {
                     return;
                 }
 
-                MapleStatEffect puppetEffect = chrController.getBuffEffect(BuffStat.PUPPET);
+                StatEffect puppetEffect = chrController.getBuffEffect(BuffStat.PUPPET);
                 if (puppetEffect != null) {
                     Summon puppet = chrController.getSummonByKey(puppetEffect.getSourceId());
 
diff --git a/src/main/java/server/maps/MapleMap.java b/src/main/java/server/maps/MapleMap.java
index 1af50443fa..6ec5cbf58d 100644
--- a/src/main/java/server/maps/MapleMap.java
+++ b/src/main/java/server/maps/MapleMap.java
@@ -54,7 +54,7 @@ import net.server.world.World;
 import scripting.event.EventInstanceManager;
 import scripting.map.MapScriptManager;
 import server.ItemInformationProvider;
-import server.MapleStatEffect;
+import server.StatEffect;
 import server.TimerManager;
 import server.events.gm.*;
 import server.life.*;
@@ -1401,7 +1401,7 @@ public class MapleMap {
                         for (MapObject mmo : this.getPlayers()) {
                             Character character = (Character) mmo;
                             if (character.isAlive()) {
-                                MapleStatEffect statEffect = mii.getItemEffect(buff);
+                                StatEffect statEffect = mii.getItemEffect(buff);
                                 character.sendPacket(PacketCreator.showOwnBuffEffect(buff, 1));
                                 broadcastMessage(character, PacketCreator.showBuffEffect(character.getId(), buff, 1), false);
                                 statEffect.applyTo(character);
@@ -2535,7 +2535,7 @@ public class MapleMap {
             }
         }
 
-        MapleStatEffect summonStat = chr.getStatForBuff(BuffStat.SUMMON);
+        StatEffect summonStat = chr.getStatForBuff(BuffStat.SUMMON);
         if (summonStat != null) {
             Summon summon = chr.getSummonByKey(summonStat.getSourceId());
             summon.setPosition(chr.getPosition());
diff --git a/src/main/java/server/maps/Mist.java b/src/main/java/server/maps/Mist.java
index 8492216918..0b9960824e 100644
--- a/src/main/java/server/maps/Mist.java
+++ b/src/main/java/server/maps/Mist.java
@@ -27,7 +27,7 @@ import client.Skill;
 import client.SkillFactory;
 import constants.skills.*;
 import net.packet.Packet;
-import server.MapleStatEffect;
+import server.StatEffect;
 import server.life.MobSkill;
 import server.life.Monster;
 import tools.PacketCreator;
@@ -41,7 +41,7 @@ public class Mist extends AbstractMapObject {
     private final Rectangle mistPosition;
     private Character owner = null;
     private Monster mob = null;
-    private MapleStatEffect source;
+    private StatEffect source;
     private MobSkill skill;
     private final boolean isMobMist;
     private boolean isPoisonMist;
@@ -58,7 +58,7 @@ public class Mist extends AbstractMapObject {
         skillDelay = 0;
     }
 
-    public Mist(Rectangle mistPosition, Character owner, MapleStatEffect source) {
+    public Mist(Rectangle mistPosition, Character owner, StatEffect source) {
         this.mistPosition = mistPosition;
         this.owner = owner;
         this.source = source;